← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/reward.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/reward.cpp
27
27
#include "ruinlist.h"
28
28
#include "rewardlist.h"
29
29
#include "Itemlist.h"
 
30
#include "Item.h"
30
31
#include "GameMap.h"
31
32
#include "ruin.h"
32
33
#include "ucompose.hpp"
 
34
#include "SightMap.h"
 
35
 
 
36
std::string Reward::d_tag = "reward";
 
37
 
33
38
using namespace std;
34
39
 
35
40
Reward::Reward(Type type, std::string name)
39
44
 
40
45
Reward::Reward(XML_Helper *helper)
41
46
{
42
 
  Uint32 t;
43
 
  helper->getData(t, "type");
44
 
  d_type = static_cast<Reward::Type>(t);
 
47
  std::string type_str;
 
48
  helper->getData(type_str, "type");
 
49
  d_type = rewardTypeFromString(type_str);
45
50
  helper->getData(d_name, "name");
46
51
}
47
 
        
 
52
 
48
53
Reward::Reward (const Reward& orig)
49
54
        :d_type(orig.d_type), d_name(orig.d_name)
50
55
{
51
56
}
52
57
 
53
 
bool Reward::save(XML_Helper* helper) const
54
 
{
55
 
  bool retval = true;
56
 
  retval &= helper->saveData("type", d_type);
57
 
  retval &= helper->saveData("name", d_name);
58
 
  return retval;
59
 
}
60
 
 
61
58
Reward::~Reward()
62
59
{
63
60
}
65
62
Reward* Reward::handle_load(XML_Helper* helper)
66
63
{
67
64
    Uint32 t;
68
 
    helper->getData(t, "type");
 
65
    std::string type_str;
 
66
    helper->getData(type_str, "type");
 
67
    t = rewardTypeFromString(type_str);
69
68
 
70
69
    switch (t)
71
70
    {
100
99
{
101
100
}
102
101
 
103
 
bool Reward_Gold::save(XML_Helper* helper) const
 
102
bool Reward_Gold::save(XML_Helper* helper)
104
103
{
105
104
  bool retval = true;
106
 
  retval &= helper->openTag("reward");
107
 
  retval &= Reward::save(helper);
 
105
  retval &= helper->openTag(Reward::d_tag);
 
106
  std::string type_str = rewardTypeToString(Reward::Type(d_type));
 
107
  retval &= helper->saveData("type", type_str);
 
108
  retval &= helper->saveData("name", d_name);
108
109
  retval &= helper->saveData("gold", d_gold);
109
110
  retval &= helper->closeTag();
110
111
  return retval;
128
129
  d_army  = al->getArmy (army_set, army_type);
129
130
}
130
131
 
131
 
Reward_Allies::Reward_Allies(const Army *army, Uint32 count)
 
132
Reward_Allies::Reward_Allies(const ArmyProto *army, Uint32 count)
132
133
    :Reward(Reward::ALLIES), d_count(count)
133
134
{
134
 
  d_army_type = army->getType();
 
135
  d_army_type = army->getTypeId();
135
136
  d_army_set = army->getArmyset();
136
137
  d_army = army;
137
138
}
152
153
{
153
154
}
154
155
 
155
 
bool Reward_Allies::save(XML_Helper* helper) const
 
156
bool Reward_Allies::save(XML_Helper* helper)
156
157
{
157
158
  bool retval = true;
158
 
  retval &= helper->openTag("reward");
159
 
  retval &= Reward::save(helper);
 
159
  retval &= helper->openTag(Reward::d_tag);
 
160
  std::string type_str = rewardTypeToString(Reward::Type(d_type));
 
161
  retval &= helper->saveData("type", type_str);
 
162
  retval &= helper->saveData("name", d_name);
160
163
  retval &= helper->saveData("num_allies", d_count);
161
164
  retval &= helper->saveData("ally_type", d_army_type);
162
165
  retval &= helper->saveData("ally_armyset", d_army_set);
169
172
  return (rand() % MAX_STACK_SIZE) + 1;
170
173
}
171
174
 
172
 
const Army* Reward_Allies::randomArmyAlly()
 
175
const ArmyProto* Reward_Allies::randomArmyAlly()
173
176
{
174
177
  Uint32 allytype;
175
178
  // list all the army types that can be allies.
176
 
  std::vector<const Army*> allytypes;
 
179
  std::vector<const ArmyProto*> allytypes;
177
180
  Armysetlist *al = Armysetlist::getInstance();
178
181
  Player *p = Playerlist::getInstance()->getActiveplayer();
179
182
  if (!p)
180
183
    p = Playerlist::getInstance()->getNeutral();
181
184
  for (unsigned int j = 0; j < al->getSize(p->getArmyset()); j++)
182
185
    {
183
 
      const Army *a = al->getArmy (p->getArmyset(), j);
 
186
      const ArmyProto *a = al->getArmy (p->getArmyset(), j);
184
187
      if (a->getAwardable())
185
188
        allytypes.push_back(a);
186
189
    }
191
194
  return allytypes[allytype];
192
195
}
193
196
 
194
 
bool Reward_Allies::addAllies(Player *p, Vector<int> pos, const Army *army, Uint32 alliesCount)
 
197
bool Reward_Allies::addAllies(Player *p, Vector<int> pos, const ArmyProto *army, Uint32 alliesCount)
195
198
{
196
199
  for (unsigned int i = 0; i < alliesCount; i++)
197
200
    {
227
230
 
228
231
bool Reward_Item::loadItem(std::string tag, XML_Helper* helper)
229
232
{
230
 
  if (tag == "item")
 
233
  if (tag == Item::d_tag)
231
234
    {
232
235
      d_item = new Item(helper);
233
236
      return true;
239
242
Reward_Item::Reward_Item(XML_Helper* helper)
240
243
    :Reward(helper)
241
244
{
242
 
  helper->registerTag("item", sigc::mem_fun(this, &Reward_Item::loadItem));
 
245
  helper->registerTag(Item::d_tag, sigc::mem_fun(this, &Reward_Item::loadItem));
243
246
}
244
247
 
245
248
Reward_Item::Reward_Item (const Reward_Item& orig)
247
250
{
248
251
}
249
252
 
250
 
bool Reward_Item::save(XML_Helper* helper) const
 
253
bool Reward_Item::save(XML_Helper* helper)
251
254
{
252
255
  bool retval = true;
253
 
  retval &= helper->openTag("reward");
254
 
  retval &= Reward::save(helper);
 
256
  retval &= helper->openTag(Reward::d_tag);
 
257
  std::string type_str = rewardTypeToString(Reward::Type(d_type));
 
258
  retval &= helper->saveData("type", type_str);
 
259
  retval &= helper->saveData("name", d_name);
255
260
  retval &= d_item->save(helper);
256
261
  retval &= helper->closeTag();
257
262
  return retval;
262
267
  Itemlist *il = Itemlist::getInstance();
263
268
  Itemlist::iterator it = il->begin();
264
269
  std::advance(it, rand() % il->size());
265
 
  Item *i = it->second;
 
270
  ItemProto *i = it->second;
266
271
  return new Item(*i);
267
272
}
268
273
 
291
296
        :Reward(orig), d_ruin_pos(orig.d_ruin_pos)
292
297
{
293
298
}
294
 
bool Reward_Ruin::save(XML_Helper* helper) const
 
299
bool Reward_Ruin::save(XML_Helper* helper)
295
300
{
296
301
  bool retval = true;
297
 
  retval &= helper->openTag("reward");
298
 
  retval &= Reward::save(helper);
 
302
  retval &= helper->openTag(Reward::d_tag);
 
303
  std::string type_str = rewardTypeToString(Reward::Type(d_type));
 
304
  retval &= helper->saveData("type", type_str);
 
305
  retval &= helper->saveData("name", d_name);
299
306
  retval &= helper->saveData("x", getRuin()->getPos().x);
300
307
  retval &= helper->saveData("y", getRuin()->getPos().y);
301
308
  retval &= helper->closeTag();
309
316
  Rewardlist *rw = Rewardlist::getInstance();
310
317
  for (Ruinlist::iterator it = rl->begin(); it != rl->end(); it++)
311
318
    {
312
 
      if ((*it).isHidden())
313
 
        if ((*it).getOwner() == NULL || 
314
 
            (*it).getOwner() == Playerlist::getInstance()->getNeutral())
 
319
      if ((*it)->isHidden())
 
320
        if ((*it)->getOwner() == NULL || 
 
321
            (*it)->getOwner() == Playerlist::getInstance()->getNeutral())
315
322
          {
316
323
            //is it already being pointed to by a reward in the rewardlist?
317
324
            bool found = false;
322
329
                    Ruin *r = static_cast<Reward_Ruin*>(*i)->getRuin();
323
330
                    if (r)
324
331
                      {
325
 
                        if (r->getPos() == (*it).getPos())
 
332
                        if (r->getPos() == (*it)->getPos())
326
333
                          {
327
334
                            found = true;
328
335
                            break;
331
338
                  }
332
339
              }
333
340
            if (found == false)
334
 
              hidden_ruins.push_back(&*it);
 
341
              hidden_ruins.push_back(*it);
335
342
          }
336
343
    }
337
344
 if (hidden_ruins.empty())
345
352
 
346
353
Reward_Map::Reward_Map(Vector<int> pos, std::string name, 
347
354
                       Uint32 height, Uint32 width)
348
 
    :Reward(Reward::MAP, name), Location(pos), d_height(height), d_width(width)
349
 
{
350
 
}
 
355
    :Reward(Reward::MAP, name)
 
356
{
 
357
  d_sightmap = new SightMap(name, pos, height, width);
 
358
}
 
359
 
 
360
bool Reward_Map::loadMap(std::string tag, XML_Helper* helper)
 
361
{
 
362
  if (tag == SightMap::d_tag)
 
363
    {
 
364
      d_sightmap = new SightMap(helper);
 
365
      return true;
 
366
    }
 
367
    
 
368
  return false;
 
369
}
 
370
 
351
371
 
352
372
Reward_Map::Reward_Map(XML_Helper* helper)
353
 
    :Reward(helper), Location(helper)
 
373
    :Reward(helper)
354
374
{
355
 
  helper->getData(d_height, "height");
356
 
  helper->getData(d_width, "width");
 
375
  helper->registerTag(SightMap::d_tag, sigc::mem_fun(this, &Reward_Map::loadMap));
357
376
}
358
377
 
359
378
Reward_Map::Reward_Map (const Reward_Map& orig)
360
 
        :Reward(orig), Location(orig),
361
 
        d_height(orig.d_height), d_width(orig.d_width)
 
379
        :Reward(orig)
362
380
{
 
381
  d_sightmap = new SightMap(*orig.d_sightmap);
363
382
}
364
383
 
365
 
bool Reward_Map::save(XML_Helper* helper) const
 
384
bool Reward_Map::save(XML_Helper* helper)
366
385
{
367
386
  bool retval = true;
368
 
  retval &= helper->openTag("reward");
369
 
  retval &= Reward::save(helper);
370
 
  retval &= helper->saveData("id", getId());
371
 
  retval &= helper->saveData("x", getPos().x);
372
 
  retval &= helper->saveData("y", getPos().y);
373
 
  retval &= helper->saveData("name", getName());
374
 
  retval &= helper->saveData("height", d_height);
375
 
  retval &= helper->saveData("width", d_width);
 
387
  retval &= helper->openTag(Reward::d_tag);
 
388
  std::string type_str = rewardTypeToString(Reward::Type(d_type));
 
389
  retval &= helper->saveData("type", type_str);
 
390
  retval &= helper->saveData("name", d_sightmap->getName());
 
391
  retval &= d_sightmap->save(helper);
376
392
  retval &= helper->closeTag();
377
393
  return retval;
378
394
}
389
405
 
390
406
Reward_Map::~Reward_Map()
391
407
{
 
408
  if (d_sightmap)
 
409
    delete d_sightmap;
392
410
}
393
411
 
394
412
std::string Reward::getDescription()
429
447
        {
430
448
          Reward_Map *m = dynamic_cast<Reward_Map *>(this);
431
449
          s += String::ucompose(_("Map: %1,%2 %3x%4"), 
432
 
                                  m->getPos().x,
433
 
                                  m->getPos().y,
 
450
                                  m->getLocation().x,
 
451
                                  m->getLocation().y,
434
452
                                  m->getHeight(),
435
453
                                  m->getWidth());
436
454
          return s;
438
456
    }
439
457
  return s;
440
458
}
 
459
 
 
460
std::string Reward::rewardTypeToString(const Reward::Type type)
 
461
{
 
462
  switch (type)
 
463
    {
 
464
      case Reward::GOLD:
 
465
        return "Reward::GOLD";
 
466
        break;
 
467
      case Reward::ALLIES:
 
468
        return "Reward::ALLIES";
 
469
        break;
 
470
      case Reward::ITEM:
 
471
        return "Reward::ITEM";
 
472
        break;
 
473
      case Reward::RUIN:
 
474
        return "Reward::RUIN";
 
475
        break;
 
476
      case Reward::MAP:
 
477
        return "Reward::MAP";
 
478
        break;
 
479
    }
 
480
  return "Reward::GOLD";
 
481
}
 
482
 
 
483
Reward::Type Reward::rewardTypeFromString(const std::string str)
 
484
{
 
485
  if (str.size() > 0 && isdigit(str.c_str()[0]))
 
486
    return Reward::Type(atoi(str.c_str()));
 
487
  if (str == "Reward::GOLD")
 
488
    return Reward::GOLD;
 
489
  else if (str == "Reward::ALLIES")
 
490
    return Reward::ALLIES;
 
491
  else if (str == "Reward::ITEM")
 
492
    return Reward::ITEM;
 
493
  else if (str == "Reward::RUIN")
 
494
    return Reward::RUIN;
 
495
  else if (str == "Reward::MAP")
 
496
    return Reward::MAP;
 
497
  return Reward::GOLD;
 
498
}
 
499
 
 
500
Reward* Reward::copy(const Reward* r)
 
501
{
 
502
  switch(r->getType())
 
503
    {
 
504
    case  Reward::GOLD:
 
505
      return (new Reward_Gold(*dynamic_cast<const Reward_Gold*>(r)));
 
506
    case  Reward::ALLIES:
 
507
      return (new Reward_Allies(*dynamic_cast<const Reward_Allies*>(r)));
 
508
    case Reward::ITEM:
 
509
      return (new Reward_Item(*dynamic_cast<const Reward_Item*>(r)));
 
510
    case Reward::RUIN:
 
511
      return (new Reward_Ruin(*dynamic_cast<const Reward_Ruin*>(r)));
 
512
    case Reward::MAP:
 
513
      return (new Reward_Map(*dynamic_cast<const Reward_Map*>(r)));
 
514
    }
 
515
 
 
516
  return 0;
 
517
}