← Back to branch summary

~ubuntu-branches/ubuntu/raring/lordsawar/raring

« back to all changes in this revision

Viewing changes to src/reward.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Barry deFreese, Barry deFreese, Gonéri Le Bouder
  • Date: 2008-06-17 11:15:26 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20080617111526-yjyvu9df50zmpdo0
Tags: 0.0.9-1
[ Barry deFreese ]
* New upstream release.
  + Fixes gcc-4.3 builds so drop ftbfs_gcc-4.3_fix.diff.
  + Add new build-dependency for libgnet-dev.
* Add simple man page for new lordsawar-tile-editor.
* Add desktop file for lordsawar-tile-editor.
* Remove French translation on install.

[ Gonéri Le Bouder ]
* bump Debian Policy to 3.8.0. No change needed.
* fix wording in the 0.0.8-3 entry of the Debian changelog

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/reward.cpp
 
1
//  Copyright (C) 2007, 2008 Ben Asselstine
 
2
//
1
3
//  This program is free software; you can redistribute it and/or modify
2
4
//  it under the terms of the GNU General Public License as published by
3
5
//  the Free Software Foundation; either version 2 of the License, or
10
12
//
11
13
//  You should have received a copy of the GNU General Public License
12
14
//  along with this program; if not, write to the Free Software
13
 
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
15
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 
 
16
//  02110-1301, USA.
14
17
 
15
18
#include <stdlib.h>
16
19
#include <sstream>
22
25
#include "armysetlist.h"
23
26
#include "playerlist.h"
24
27
#include "ruinlist.h"
 
28
#include "rewardlist.h"
 
29
#include "Itemlist.h"
25
30
#include "GameMap.h"
26
31
#include "ruin.h"
 
32
#include "ucompose.hpp"
27
33
using namespace std;
28
34
 
29
35
Reward::Reward(Type type, std::string name)
38
44
  d_type = static_cast<Reward::Type>(t);
39
45
  helper->getData(d_name, "name");
40
46
}
 
47
        
 
48
Reward::Reward (const Reward& orig)
 
49
        :d_type(orig.d_type), d_name(orig.d_name)
 
50
{
 
51
}
41
52
 
42
53
bool Reward::save(XML_Helper* helper) const
43
54
{
84
95
  helper->getData(d_gold, "gold");
85
96
}
86
97
 
 
98
Reward_Gold::Reward_Gold (const Reward_Gold & orig)
 
99
        :Reward(orig), d_gold(orig.d_gold)
 
100
{
 
101
}
 
102
 
87
103
bool Reward_Gold::save(XML_Helper* helper) const
88
104
{
89
105
  bool retval = true;
98
114
{
99
115
}
100
116
 
 
117
Uint32 Reward_Gold::getRandomGoldPieces()
 
118
{
 
119
  return 310 + (rand() % 1000);
 
120
}
101
121
 
102
122
Reward_Allies::Reward_Allies(Uint32 army_type, Uint32 army_set, Uint32 count)
103
123
    :Reward(Reward::ALLIES), d_count(count)
126
146
  d_army = al->getArmy (d_army_set, d_army_type);
127
147
}
128
148
 
 
149
Reward_Allies::Reward_Allies (const Reward_Allies& orig)
 
150
        :Reward(orig), d_army(orig.d_army), d_army_type(orig.d_army_type), 
 
151
        d_army_set(orig.d_army_set), d_count(orig.d_count)
 
152
{
 
153
}
 
154
 
129
155
bool Reward_Allies::save(XML_Helper* helper) const
130
156
{
131
157
  bool retval = true;
137
163
  retval &= helper->closeTag();
138
164
  return retval;
139
165
}
 
166
        
 
167
const Uint32 Reward_Allies::getRandomAmountOfAllies()
 
168
{
 
169
  return (rand() % MAX_STACK_SIZE) + 1;
 
170
}
 
171
 
140
172
const Army* Reward_Allies::randomArmyAlly()
141
173
{
142
174
  Uint32 allytype;
152
184
      if (a->getAwardable())
153
185
        allytypes.push_back(a);
154
186
    }
155
 
  if (!allytypes.empty())
156
 
    allytype = rand() % allytypes.size();
157
 
  else 
 
187
  if (allytypes.empty())
158
188
    return NULL;
159
189
 
 
190
  allytype = rand() % allytypes.size();
160
191
  return allytypes[allytype];
161
192
}
162
193
 
165
196
  for (unsigned int i = 0; i < alliesCount; i++)
166
197
    {
167
198
      Army* ally = new Army(*army, p);
 
199
      ally->setUpkeep(0);
168
200
      if (GameMap::getInstance()->addArmy(pos, ally) == NULL)
169
201
        return false;
170
202
    }
176
208
  for (unsigned int i = 0; i < alliesCount; i++)
177
209
    {
178
210
      Army* ally = new Army(*army, p);
 
211
      ally->setUpkeep(0);
179
212
      if (GameMap::getInstance()->addArmy(l, ally) == NULL)
180
213
        return false;
181
214
    }
209
242
  helper->registerTag("item", sigc::mem_fun(this, &Reward_Item::loadItem));
210
243
}
211
244
 
 
245
Reward_Item::Reward_Item (const Reward_Item& orig)
 
246
        :Reward(orig), d_item(orig.d_item)
 
247
{
 
248
}
 
249
 
212
250
bool Reward_Item::save(XML_Helper* helper) const
213
251
{
214
252
  bool retval = true;
219
257
  return retval;
220
258
}
221
259
 
 
260
Item *Reward_Item::getRandomItem()
 
261
{
 
262
  Itemlist *il = Itemlist::getInstance();
 
263
  Itemlist::iterator it = il->begin();
 
264
  std::advance(it, rand() % il->size());
 
265
  Item *i = it->second;
 
266
  return new Item(*i);
 
267
}
222
268
 
223
269
Reward_Item::~Reward_Item()
224
270
{
227
273
}
228
274
 
229
275
Reward_Ruin::Reward_Ruin(Ruin *ruin)
230
 
    :Reward(Reward::RUIN), d_ruin(ruin)
 
276
    :Reward(Reward::RUIN), d_ruin_pos(ruin->getPos())
231
277
{
232
278
}
233
279
 
238
284
  Uint32 y;
239
285
  helper->getData(x, "x");
240
286
  helper->getData(y, "y");
241
 
  d_ruin = Ruinlist::getInstance()->getObjectAt(x, y);
 
287
  d_ruin_pos = Vector<int>(x,y);
242
288
}
243
289
 
 
290
Reward_Ruin::Reward_Ruin (const Reward_Ruin& orig)
 
291
        :Reward(orig), d_ruin_pos(orig.d_ruin_pos)
 
292
{
 
293
}
244
294
bool Reward_Ruin::save(XML_Helper* helper) const
245
295
{
246
296
  bool retval = true;
247
297
  retval &= helper->openTag("reward");
248
298
  retval &= Reward::save(helper);
249
 
  retval &= helper->saveData("x", d_ruin->getPos().x);
250
 
  retval &= helper->saveData("y", d_ruin->getPos().y);
 
299
  retval &= helper->saveData("x", getRuin()->getPos().x);
 
300
  retval &= helper->saveData("y", getRuin()->getPos().y);
251
301
  retval &= helper->closeTag();
252
302
  return retval;
253
303
}
254
304
 
 
305
Ruin *Reward_Ruin::getRandomHiddenRuin()
 
306
{
 
307
  std::vector<Ruin *>hidden_ruins;
 
308
  Ruinlist *rl = Ruinlist::getInstance();
 
309
  Rewardlist *rw = Rewardlist::getInstance();
 
310
  for (Ruinlist::iterator it = rl->begin(); it != rl->end(); it++)
 
311
    {
 
312
      if ((*it).isHidden())
 
313
        if ((*it).getOwner() == NULL || 
 
314
            (*it).getOwner() == Playerlist::getInstance()->getNeutral())
 
315
          {
 
316
            //is it already being pointed to by a reward in the rewardlist?
 
317
            bool found = false;
 
318
            for (Rewardlist::iterator i = rw->begin(); i != rw->end(); i++)
 
319
              {
 
320
                if ((*i)->getType() == Reward::RUIN)
 
321
                  {
 
322
                    Ruin *r = static_cast<Reward_Ruin*>(*i)->getRuin();
 
323
                    if (r)
 
324
                      {
 
325
                        if (r->getPos() == (*it).getPos())
 
326
                          {
 
327
                            found = true;
 
328
                            break;
 
329
                          }
 
330
                      }
 
331
                  }
 
332
              }
 
333
            if (found == false)
 
334
              hidden_ruins.push_back(&*it);
 
335
          }
 
336
    }
 
337
 if (hidden_ruins.empty())
 
338
   return NULL;
 
339
 return hidden_ruins[rand() % hidden_ruins.size()];
 
340
}
 
341
 
255
342
Reward_Ruin::~Reward_Ruin()
256
343
{
257
344
}
258
345
 
259
 
Reward_Map::Reward_Map(Location *loc, Uint32 height, Uint32 width)
260
 
    :Reward(Reward::MAP), d_loc(loc), d_height(height), d_width(width)
261
 
{
262
 
}
263
 
 
264
 
bool Reward_Map::loadLocation(std::string tag, XML_Helper* helper)
265
 
{
266
 
  if (tag == "location")
267
 
    {
268
 
      d_loc = new Location(helper);
269
 
      return true;
270
 
    }
271
 
    
272
 
  return false;
 
346
Reward_Map::Reward_Map(Vector<int> pos, std::string name, 
 
347
                       Uint32 height, Uint32 width)
 
348
    :Reward(Reward::MAP, name), Location(pos), d_height(height), d_width(width)
 
349
{
273
350
}
274
351
 
275
352
Reward_Map::Reward_Map(XML_Helper* helper)
276
 
    :Reward(helper)
 
353
    :Reward(helper), Location(helper)
277
354
{
278
 
  helper->registerTag("location", sigc::mem_fun(this, 
279
 
                                                &Reward_Map::loadLocation));
280
355
  helper->getData(d_height, "height");
281
356
  helper->getData(d_width, "width");
282
357
}
283
358
 
 
359
Reward_Map::Reward_Map (const Reward_Map& orig)
 
360
        :Reward(orig), Location(orig),
 
361
        d_height(orig.d_height), d_width(orig.d_width)
 
362
{
 
363
}
 
364
 
284
365
bool Reward_Map::save(XML_Helper* helper) const
285
366
{
286
367
  bool retval = true;
287
368
  retval &= helper->openTag("reward");
288
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());
289
374
  retval &= helper->saveData("height", d_height);
290
375
  retval &= helper->saveData("width", d_width);
291
 
  retval &= helper->openTag("location");
292
 
  retval &= helper->saveData("id", d_loc->getId());
293
 
  retval &= helper->saveData("name", d_loc->getName());
294
 
  Vector<int> pos = d_loc->getPos();
295
 
  retval &= helper->saveData("x", pos.x);
296
 
  retval &= helper->saveData("y", pos.y);
297
 
  retval &= helper->closeTag();
298
376
  retval &= helper->closeTag();
299
377
  return retval;
300
378
}
301
379
 
 
380
void Reward_Map::getRandomMap(int *x, int *y, int *width, int *height)
 
381
{
 
382
  int map_width = GameMap::getInstance()->getWidth();
 
383
  *x = rand() % (map_width - (map_width / 10));
 
384
  int map_height = GameMap::getInstance()->getHeight();
 
385
  *y = rand() % (map_height - (map_height / 10));
 
386
  *width = ((rand() % (map_width - *x)) + (map_width / 10));
 
387
  *height = ((rand() % (map_height - *y)) + (map_height / 10));
 
388
}
302
389
 
303
390
Reward_Map::~Reward_Map()
304
391
{
305
392
}
306
393
 
 
394
std::string Reward::getDescription()
 
395
{
 
396
  Glib::ustring s = "";
 
397
  switch (getType())
 
398
    {
 
399
    case Reward::GOLD:
 
400
        {
 
401
          Reward_Gold *g = dynamic_cast<Reward_Gold*>(this);
 
402
          s += String::ucompose(ngettext("%1 Gold Piece", "%1 Gold Pieces", 
 
403
                                         g->getGold()), g->getGold());
 
404
          return s;
 
405
        }
 
406
    case Reward::ALLIES:
 
407
        {
 
408
          Reward_Allies *a = dynamic_cast<Reward_Allies *>(this);
 
409
          if (a->getArmy())
 
410
            s += String::ucompose(_("Allies: %1 x %2"), a->getArmy()->getName(),
 
411
                                  a->getNoOfAllies());
 
412
          return s;
 
413
        }
 
414
    case Reward::ITEM:
 
415
        {
 
416
          Reward_Item *i = dynamic_cast<Reward_Item *>(this);
 
417
          if (i->getItem())
 
418
            s += String::ucompose(_("Item: %1"), i->getItem()->getName());
 
419
          return s;
 
420
        }
 
421
    case Reward::RUIN:
 
422
        {
 
423
          Reward_Ruin *r = dynamic_cast<Reward_Ruin *>(this);
 
424
          if (r->getRuin())
 
425
            s += String::ucompose(_("Site: %1"), r->getRuin()->getName());
 
426
          return s;
 
427
        }
 
428
    case Reward::MAP:
 
429
        {
 
430
          Reward_Map *m = dynamic_cast<Reward_Map *>(this);
 
431
          s += String::ucompose(_("Map: %1,%2 %3x%4"), 
 
432
                                  m->getPos().x,
 
433
                                  m->getPos().y,
 
434
                                  m->getHeight(),
 
435
                                  m->getWidth());
 
436
          return s;
 
437
        }
 
438
    }
 
439
  return s;
 
440
}