← Back to branch summary

~ubuntu-branches/ubuntu/saucy/lordsawar/saucy

« back to all changes in this revision

Viewing changes to src/ruin.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Barry deFreese, Barry deFreese
  • Date: 2008-12-20 13:52:12 UTC
  • mfrom: (1.1.6 upstream) (5.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20081220135212-noeb2w3y98ebo7o9
Tags: 0.1.4-1
[ Barry deFreese ]
* New upstream release.
* Move 0.0.8-2.1 changelog entry to correct point in changelog.
* Make lordsawar-data suggest lordsawar.
* Update my e-mail address.
* Add build-depends on intltool, uuid-dev, and libboost-dev.
* Don't install locales since there are no translations currently.
* Add simple man page for new lordsawar-pbm binary.
* Drop gcc4.3 patches as they have been fixed upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ruin.cpp
23
23
#include "rewardlist.h"
24
24
#include <stdlib.h>
25
25
 
 
26
std::string Ruin::d_tag = "ruin";
 
27
 
26
28
Ruin::Ruin(Vector<int> pos, std::string name, int type, Stack* occupant, bool searched, bool hidden, Player *owner, bool sage)
27
 
    :NamedLocation(pos, name), d_searched(searched), d_type(type),
28
 
    d_occupant(occupant), d_hidden(hidden), d_owner(owner), d_sage(sage)
 
29
:NamedLocation(pos, RUIN_TILE_WIDTH, name,
 
30
                name + _(" is inhabited by monsters and full of treasure!")), 
 
31
    d_searched(searched), 
 
32
    d_type(type), d_occupant(occupant), d_hidden(hidden), d_owner(owner), 
 
33
    d_sage(sage)
29
34
{
30
35
    d_owner = NULL;
31
36
    d_reward = NULL;
32
37
    //mark the location as being occupied by a ruin on the map
33
 
    GameMap::getInstance()->getTile(getPos())->setBuilding(Maptile::RUIN);
 
38
    for (unsigned int i = 0; i < getSize(); i++)
 
39
      for (unsigned int j = 0; j < getSize(); j++)
 
40
        {
 
41
          Vector<int> pos = getPos() + Vector<int>(i, j);
 
42
          GameMap::getInstance()->getTile(pos)->setBuilding(Maptile::RUIN);
 
43
        }
34
44
}
35
45
 
36
46
Ruin::Ruin(const Ruin& ruin)
41
51
}
42
52
 
43
53
Ruin::Ruin(XML_Helper* helper)
44
 
    :NamedLocation(helper), d_type(0), d_occupant(0), d_hidden(0), 
45
 
    d_owner(0), d_sage(0), d_reward(0)
 
54
    :NamedLocation(helper, RUIN_TILE_WIDTH), d_type(0), d_occupant(0), 
 
55
    d_hidden(0), d_owner(0), d_sage(0), d_reward(0)
46
56
{
47
57
    Uint32 ui;
48
 
    helper->getData(d_type, "type");
 
58
    std::string type_str;
 
59
    helper->getData(type_str, "type");
 
60
    d_type = ruinTypeFromString(type_str);
49
61
    helper->getData(d_searched, "searched");
50
62
    helper->getData(d_sage, "sage");
51
63
    helper->getData(d_hidden, "hidden");
61
73
      d_owner = NULL;
62
74
 
63
75
    //mark the location as being occupied by a ruin on the map
64
 
    GameMap::getInstance()->getTile(getPos())->setBuilding(Maptile::RUIN);
 
76
    for (unsigned int i = 0; i < getSize(); i++)
 
77
      for (unsigned int j = 0; j < getSize(); j++)
 
78
        {
 
79
          Vector<int> pos = getPos() + Vector<int>(i, j);
 
80
          GameMap::getInstance()->getTile(pos)->setBuilding(Maptile::RUIN);
 
81
        }
65
82
}
66
83
 
67
84
Ruin::~Ruin()
76
93
{
77
94
  bool retval = true;
78
95
 
79
 
  retval &= helper->openTag("ruin");
 
96
  retval &= helper->openTag(Ruin::d_tag);
80
97
  retval &= helper->saveData("id", d_id);
81
98
  retval &= helper->saveData("x", getPos().x);
82
99
  retval &= helper->saveData("y", getPos().y);
83
100
  retval &= helper->saveData("name", getName());
84
 
  retval &= helper->saveData("type", d_type);
 
101
  retval &= helper->saveData("description", getDescription());
 
102
  std::string type_str = ruinTypeToString(Ruin::Type(d_type));
 
103
  retval &= helper->saveData("type", type_str);
85
104
  retval &= helper->saveData("searched", d_searched);
86
105
  retval &= helper->saveData("sage", d_sage);
87
106
  retval &= helper->saveData("hidden", d_hidden);
92
111
  if (d_occupant)
93
112
    retval &= d_occupant->save(helper);
94
113
  if (d_sage == false && d_reward)
95
 
    {
96
 
      if (d_reward->getType() == Reward::GOLD)
97
 
        static_cast<Reward_Gold*>(d_reward)->save(helper);
98
 
      else if (d_reward->getType() == Reward::ALLIES)
99
 
        static_cast<Reward_Allies*>(d_reward)->save(helper);
100
 
      else if (d_reward->getType() == Reward::ITEM)
101
 
        static_cast<Reward_Item*>(d_reward)->save(helper);
102
 
      else if (d_reward->getType() == Reward::RUIN)
103
 
        static_cast<Reward_Ruin*>(d_reward)->save(helper);
104
 
      else if (d_reward->getType() == Reward::MAP)
105
 
        static_cast<Reward_Map*>(d_reward)->save(helper);
106
 
    }
 
114
    retval &= d_reward->save(helper);
107
115
  retval &= helper->closeTag();
108
116
 
109
117
  return retval;
111
119
 
112
120
bool Ruin::load(std::string tag, XML_Helper* helper)
113
121
{
114
 
  if (tag == "reward")
 
122
  if (tag == Reward::d_tag)
115
123
    {
116
 
      Reward *reward = new Reward(helper);
117
 
      if (reward->getType() == Reward::GOLD)
118
 
        d_reward = new Reward_Gold(helper);
119
 
      else if (reward->getType() == Reward::ALLIES)
120
 
        d_reward = new Reward_Allies(helper);
121
 
      else if (reward->getType() == Reward::ITEM)
122
 
        d_reward = new Reward_Item(helper);
123
 
      else if (reward->getType() == Reward::RUIN)
124
 
        d_reward = new Reward_Ruin(helper);
125
 
      else if (reward->getType() == Reward::MAP)
126
 
        d_reward = new Reward_Map(helper);
127
 
 
128
 
      delete reward;
129
 
 
130
 
      return true;
 
124
        Uint32 t;
 
125
        std::string type_str;
 
126
        helper->getData(type_str, "type");
 
127
        t = Reward::rewardTypeFromString(type_str);
 
128
        switch (t)
 
129
          {
 
130
          case  Reward::GOLD:
 
131
            d_reward = new Reward_Gold(helper); break;
 
132
          case  Reward::ALLIES:
 
133
            d_reward = new Reward_Allies(helper); break;
 
134
          case Reward::ITEM:
 
135
            d_reward = new Reward_Item(helper); break;
 
136
          case Reward::RUIN:
 
137
            d_reward = new Reward_Ruin(helper); break;
 
138
          case Reward::MAP:
 
139
            d_reward = new Reward_Map(helper); break;
 
140
          }
 
141
        return true;
131
142
    }
132
143
 
133
 
  if (tag == "stack")
 
144
  if (tag == Stack::d_tag)
134
145
    {
135
146
      Stack* s = new Stack(helper);
136
147
      d_occupant = s;
151
162
    setReward(new Reward_Gold(Reward_Gold::getRandomGoldPieces()));
152
163
  else if (num == 1)
153
164
    {
154
 
      const Army *a = Reward_Allies::randomArmyAlly();
 
165
      const ArmyProto *a = Reward_Allies::randomArmyAlly();
155
166
      setReward(new Reward_Allies(a, Reward_Allies::getRandomAmountOfAllies()));
156
167
    }
157
168
  else if (num == 2)
163
174
        setReward(new Reward_Gold(Reward_Gold::getRandomGoldPieces()));
164
175
    }
165
176
}
 
177
 
 
178
std::string Ruin::ruinTypeToString(const Ruin::Type type)
 
179
{
 
180
  switch (type)
 
181
    {
 
182
      case Ruin::RUIN:
 
183
        return "Ruin::RUIN";
 
184
        break;
 
185
      case Ruin::STRONGHOLD:
 
186
        return "Ruin::STRONGHOLD";
 
187
        break;
 
188
    }
 
189
  return "Ruin::RUIN";
 
190
}
 
191
 
 
192
Ruin::Type Ruin::ruinTypeFromString(const std::string str)
 
193
{
 
194
  if (str.size() > 0 && isdigit(str.c_str()[0]))
 
195
    return Ruin::Type(atoi(str.c_str()));
 
196
  if (str == "Ruin::RUIN")
 
197
    return Ruin::RUIN;
 
198
  else if (str == "Ruin::STRONGHOLD")
 
199
    return Ruin::STRONGHOLD;
 
200
  return Ruin::RUIN;
 
201
}
166
202
// End of file