src/DB/Savables/Chunk.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008 by Sverre Rabbelier                                *
   3  *   sverre@rabbelier.nl                                                   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 3 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "Chunk.h"
  22 #include "Global.h"
  23 #include "FieldImpls.h"
  24 #include "TableImpls.h"
  25 #include "Managers.h"
  26 #include "Character.h"
  27 #include "CharacterManager.h"
  28 #include "FieldValues.h"
  29
  30 using mud::Chunk;
  31
  32 std::map<value_type, value_types> Chunk::ms_charactersInRoom;
  33
  34 Chunk::Chunk(SavableManagerPtr chunk) :
  35 m_chunk(chunk)
  36 {
  37         Assert(chunk);
  38 }
  39
  40 Chunk::~Chunk(void)
  41 {
  42         Unlock();
  43 }
  44
  45 value_type Chunk::getID() const
  46 {
  47         return m_chunk->getValue(db::TableImpls::Get()->CHUNKS->CHUNKID)->getIntegerValue();
  48 }
  49
  50 const std::string& Chunk::getName() const
  51 {
  52         return m_chunk->getValue(db::TableImpls::Get()->CHUNKS->NAME)->getStringValue();
  53 }
  54
  55 const std::string& Chunk::getDescription() const
  56 {
  57         return m_chunk->getValue(db::TableImpls::Get()->CHUNKS->DESCRIPTION)->getStringValue();
  58 }
  59
  60 const std::string& Chunk::getTags() const
  61 {
  62         return m_chunk->getValue(db::TableImpls::Get()->CHUNKS->TAGS)->getStringValue();
  63 }
  64
  65 value_type Chunk::getRoom() const
  66 {
  67         return m_chunk->getValue(db::TableImpls::Get()->CHUNKS->FKROOMS)->getIntegerValue();
  68 }
  69
  70 void Chunk::setName(const std::string& name)
  71 {
  72         Lock();
  73         ValuePtr value(new FieldValue(db::TableImpls::Get()->CHUNKS->NAME, name));
  74         m_chunk->setValue(value);
  75 }
  76
  77 void Chunk::setDescription(const std::string& description)
  78 {
  79         Lock();
  80         ValuePtr value(new FieldValue(db::TableImpls::Get()->CHUNKS->DESCRIPTION, description));
  81         m_chunk->setValue(value);
  82 }
  83
  84 void Chunk::setTags(const std::string& tags)
  85 {
  86         Lock();
  87         ValuePtr value(new FieldValue(db::TableImpls::Get()->CHUNKS->TAGS, tags));
  88         m_chunk->setValue(value);
  89 }
  90
  91 void Chunk::setRoom(value_type room)
  92 {
  93         Lock();
  94         ValuePtr value(new FieldValue(db::TableImpls::Get()->CHUNKS->FKROOMS, room));
  95         m_chunk->setValue(value);
  96 }
  97
  98 void mud::Chunk::addCharacter(value_type characterid)
  99 {
 100         SmartPtr<mud::Character> character = mud::Managers::Get()->Character->GetByKey(characterid);
 101         Assert(character->getChunk() == this->getID());
 102
 103         ms_charactersInRoom[getID()].insert(characterid);
 104 }
 105
 106 void mud::Chunk::removeCharacter(value_type characterid)
 107 {
 108         SmartPtr<mud::Character> character = mud::Managers::Get()->Character->GetByKey(characterid);
 109         Assert(character->getChunk() == this->getID());
 110
 111         value_types::const_iterator it = ms_charactersInRoom[getID()].find(characterid);
 112         Assert(it != end());
 113         ms_charactersInRoom[getID()].erase(it);
 114 }
 115
 116 void mud::Chunk::Send(const std::string& msg)
 117 {
 118         for(value_types::const_iterator it = begin(); it != end(); it++)
 119         {
 120                 CharacterPtr character = mud::Managers::Get()->Character->GetByKey(*it);
 121                 character->OnSend(msg);
 122         }
 123 }
 124
 125 void Chunk::Delete()
 126 {
 127         Lock();
 128         m_chunk->erase();
 129 }
 130
 131 void Chunk::Save()
 132 {
 133         Lock();
 134         m_chunk->save();
 135 }
 136
 137 void Chunk::Discard()
 138 {
 139         Lock();
 140         m_chunk->discard();
 141 }
 142
 143 bool Chunk::Exists()
 144 {
 145         return m_chunk->exists();
 146 }
 147
 148 SavableManagerPtr Chunk::getManager() const
 149 {
 150         return m_chunk;
 151 }
 152
 153 TableImplPtr Chunk::getTable() const
 154 {
 155         return m_chunk->getTable();
 156 }
 157
 158 value_type mud::Chunk::getExitAt(Coordinate direction) const
 159 {
 160         Assert(direction.isDirection());
 161
 162         int x = direction.getXCoordinate();
 163         int y = direction.getYCoordinate();
 164         int z = direction.getZCoordinate();
 165
 166         FieldValuesPtr values(new FieldValues(db::TableImpls::Get()->EXITS));
 167         values->addValue(db::TableImpls::Get()->EXITS->FKCHUNKSFROM, getID());
 168         values->addValue(db::TableImpls::Get()->EXITS->X, x);
 169         values->addValue(db::TableImpls::Get()->EXITS->Y, y);
 170         values->addValue(db::TableImpls::Get()->EXITS->Z, z);
 171
 172         SavableManagersPtr result = SavableManager::getmulti(values);
 173         if(result->size() > 0)
 174         {
 175                 SavableManagerPtr manager = result->first();
 176                 Assert(manager);
 177
 178                 FieldValuePtr value = manager->getValue(db::TableImpls::Get()->EXITS->EXITID);
 179                 Assert(value);
 180
 181                 return value->getIntegerValue();
 182         }
 183
 184         return 0;
 185 }
 186
 187 value_types::const_iterator mud::Chunk::begin()
 188 {
 189         return ms_charactersInRoom[getID()].begin();
 190 }
 191
 192 value_types::const_iterator mud::Chunk::end()
 193 {
 194         return ms_charactersInRoom[getID()].end();
 195 }
 196
 197 value_type mud::Chunk::size()
 198 {
 199         return ms_charactersInRoom[getID()].size();
 200 }