← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/citylist.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/citylist.cpp
 
1
// Copyright (C) 2000, 2001, 2002, 2003 Michael Bartl
 
2
// Copyright (C) 2001, 2002, 2003, 2004, 2005 Ulf Lorenz
 
3
// Copyright (C) 2004 John Farrell
 
4
// Copyright (C) 2005 Andrea Paternesi
 
5
// Copyright (C) 2006, 2007, 2008 Ben Asselstine
 
6
// Copyright (C) 2007 Ole Laursen
 
7
//
1
8
//  This program is free software; you can redistribute it and/or modify
2
9
//  it under the terms of the GNU General Public License as published by
3
10
//  the Free Software Foundation; either version 2 of the License, or
10
17
//
11
18
//  You should have received a copy of the GNU General Public License
12
19
//  along with this program; if not, write to the Free Software
13
 
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
20
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 
 
21
//  02110-1301, USA.
14
22
 
15
23
#include <sigc++/functors/mem_fun.h>
16
24
 
74
82
    {
75
83
        if ((*it).isBurnt())
76
84
          continue;
77
 
        if ((*it).getPlayer() == player) cities++;
 
85
        if ((*it).getOwner() == player) cities++;
78
86
    }
79
87
    
80
88
    return cities;
87
95
    // This iteration adds the city production to the player    
88
96
    for (iterator it = begin(); it != end(); it++)
89
97
    {
90
 
        if ((*it).getPlayer() == p)
 
98
        if ((*it).getOwner() == p)
91
99
            (*it).nextTurn();
92
100
    }
93
101
 
96
104
    // add the gold in the first run, because then the player may come above 0
97
105
    // gold, which means some cities produce units, others not.
98
106
    for (const_iterator it = begin(); it != end(); it++)
99
 
        if ((*it).getPlayer() == p)
 
107
        if ((*it).getOwner() == p)
100
108
            p->addGold((*it).getGold());
101
109
}
 
110
static bool isFogged(void *object)
 
111
{
 
112
  return ((City*)object)->isFogged();
 
113
}
 
114
 
 
115
static bool isBurnt(void *object)
 
116
{
 
117
  return ((City*)object)->isBurnt();
 
118
}
 
119
 
 
120
static bool isNotOwnedByNeutral(void *object)
 
121
{
 
122
  return ((City*)object)->getOwner() != Playerlist::getInstance()->getNeutral();
 
123
}
 
124
 
 
125
static bool isNotOwnedByActivePlayer(void *object)
 
126
{
 
127
  return ((City*)object)->getOwner() != Playerlist::getActiveplayer();
 
128
}
 
129
 
 
130
static bool isOwnedByActivePlayer(void *object)
 
131
{
 
132
  return ((City*)object)->getOwner() == Playerlist::getActiveplayer();
 
133
}
 
134
 
 
135
static bool isNotOwnedByEnemy(void *object)
 
136
{
 
137
  Player *p = Playerlist::getActiveplayer();
 
138
  if (!p)
 
139
    return false;
 
140
  City *city = ((City*)object);
 
141
  if (city->getOwner() != p &&
 
142
            p->getDiplomaticState(city->getOwner()) == Player::AT_WAR)
 
143
    return false;
 
144
  return true;
 
145
}
102
146
 
103
147
City* Citylist::getNearestEnemyCity(const Vector<int>& pos)
104
148
{
105
 
    int diff = -1;
106
 
    iterator diffit;
107
 
    Player* p = Playerlist::getInstance()->getActiveplayer();
108
 
    
109
 
    for (iterator it = begin(); it != end(); ++it)
110
 
    {
111
 
        if ((*it).isBurnt())
112
 
            continue;
113
 
 
114
 
        if ((*it).getPlayer() != p &&
115
 
            p->getDiplomaticState((*it).getPlayer()) == Player::AT_WAR)
116
 
        {        
117
 
            Vector<int> p = (*it).getPos();
118
 
            int delta = abs(p.x - pos.x);
119
 
            if (delta < abs(p.y - pos.y))
120
 
                delta = abs(p.y - pos.y);
121
 
            if ((diff > delta) || (diff == -1))
122
 
            {
123
 
                diff = delta;
124
 
                diffit = it;
125
 
            }
126
 
        }
127
 
    }
128
 
 
129
 
    if (diff == -1) return 0;
130
 
    return &(*diffit);
 
149
  std::list<bool (*)(void *)> filters;
 
150
  filters.push_back(isBurnt);
 
151
  filters.push_back(isNotOwnedByEnemy);
 
152
  return getNearestObject(pos, &filters);
131
153
}
132
154
 
 
155
 
133
156
City* Citylist::getNearestForeignCity(const Vector<int>& pos)
134
157
{
135
 
    int diff = -1;
136
 
    iterator diffit;
137
 
    Player* p = Playerlist::getInstance()->getActiveplayer();
138
 
    
139
 
    for (iterator it = begin(); it != end(); ++it)
140
 
    {
141
 
        if ((*it).isBurnt())
142
 
            continue;
143
 
 
144
 
        if ((*it).getPlayer() != p)
145
 
        {        
146
 
            Vector<int> p = (*it).getPos();
147
 
            int delta = abs(p.x - pos.x);
148
 
            if (delta < abs(p.y - pos.y))
149
 
                delta = abs(p.y - pos.y);
150
 
            if ((diff > delta) || (diff == -1))
151
 
            {
152
 
                diff = delta;
153
 
                diffit = it;
154
 
            }
155
 
        }
156
 
    }
157
 
 
158
 
    if (diff == -1) return 0;
159
 
    return &(*diffit);
 
158
  std::list<bool (*)(void *)> filters;
 
159
  filters.push_back(isBurnt);
 
160
  filters.push_back(isOwnedByActivePlayer);
 
161
  return getNearestObject(pos, &filters);
160
162
}
161
163
 
162
164
City* Citylist::getNearestCity(const Vector<int>& pos, int dist)
197
199
        if ((*it).isBurnt())
198
200
            continue;
199
201
 
200
 
        if ((*it).getPlayer() == p)
 
202
        if ((*it).getOwner() == p)
201
203
        {
202
204
            Vector<int> p = (*it).getPos();
203
205
            int delta = abs(p.x - pos.x);
218
220
 
219
221
City* Citylist::getNearestCity(const Vector<int>& pos)
220
222
{
221
 
    int diff = -1;
222
 
    iterator diffit;
223
 
 
224
 
    for (iterator it = begin(); it != end(); ++it)
225
 
    {
226
 
          if ((*it).isBurnt())
227
 
              continue;
228
 
          
229
 
          Vector<int> p = (*it).getPos();
230
 
          int delta = abs(p.x - pos.x);
231
 
          if (delta < abs(p.y - pos.y))
232
 
              delta = abs(p.y - pos.y);
233
 
          
234
 
          if ((diff > delta) || (diff == -1))
235
 
          {
236
 
              diff = delta;
237
 
              diffit = it;
238
 
          }
239
 
    }
240
 
    
241
 
    if (diff == -1) return 0;
242
 
    return &(*diffit);
 
223
  std::list<bool (*)(void *)> filters;
 
224
  filters.push_back(isBurnt);
 
225
  return getNearestObject(pos, &filters);
243
226
}
244
227
 
245
228
City* Citylist::getNearestVisibleCity(const Vector<int>& pos)
246
229
{
247
 
    int diff = -1;
248
 
    iterator diffit;
249
 
 
250
 
    for (iterator it = begin(); it != end(); ++it)
251
 
    {
252
 
          if ((*it).isBurnt())
253
 
              continue;
254
 
 
255
 
          if ((*it).isFogged() == true)
256
 
              continue;
257
 
          
258
 
          Vector<int> p = (*it).getPos();
259
 
          int delta = abs(p.x - pos.x);
260
 
          if (delta < abs(p.y - pos.y))
261
 
              delta = abs(p.y - pos.y);
262
 
          
263
 
          if ((diff > delta) || (diff == -1))
264
 
          {
265
 
              diff = delta;
266
 
              diffit = it;
267
 
          }
268
 
    }
269
 
    
270
 
    if (diff == -1) return 0;
271
 
    return &(*diffit);
 
230
  std::list<bool (*)(void *)> filters;
 
231
  filters.push_back(isBurnt);
 
232
  filters.push_back(isFogged);
 
233
  return getNearestObject(pos, &filters);
272
234
}
273
235
 
274
236
City* Citylist::getNearestVisibleCity(const Vector<int>& pos, int dist)
293
255
  return NULL;
294
256
}
295
257
 
 
258
 
296
259
City* Citylist::getNearestVisibleFriendlyCity(const Vector<int>& pos)
297
260
{
298
 
    int diff = -1;
299
 
    iterator diffit;
300
 
    Player* p = Playerlist::getInstance()->getActiveplayer();
301
 
    
302
 
    for (iterator it = begin(); it != end(); ++it)
303
 
    {
304
 
        if ((*it).isBurnt())
305
 
            continue;
306
 
 
307
 
        if ((*it).isFogged())
308
 
            continue;
309
 
 
310
 
        if ((*it).getPlayer() == p)
311
 
        {
312
 
            Vector<int> p = (*it).getPos();
313
 
            int delta = abs(p.x - pos.x);
314
 
            if (delta < abs(p.y - pos.y))
315
 
                delta = abs(p.y - pos.y);
316
 
            
317
 
            if ((diff > delta) || (diff == -1))
318
 
            {
319
 
                diff = delta;
320
 
                diffit = it;
321
 
            }
322
 
        }
323
 
    }
324
 
    
325
 
    if (diff == -1) return 0;
326
 
    return &(*diffit);
 
261
  std::list<bool (*)(void *)> filters;
 
262
  filters.push_back(isBurnt);
 
263
  filters.push_back(isFogged);
 
264
  filters.push_back(isNotOwnedByActivePlayer);
 
265
  return getNearestObject(pos, &filters);
327
266
}
328
267
 
329
268
City* Citylist::getNearestNeutralCity(const Vector<int>& pos)
330
269
{
331
 
    int diff = -1;
332
 
    iterator diffit;
333
 
    
334
 
    for (iterator it = begin(); it != end(); ++it)
335
 
    {
336
 
        if ((*it).isBurnt())
337
 
            continue;
338
 
 
339
 
        if ((*it).getPlayer() == Playerlist::getInstance()->getNeutral())
340
 
        {
341
 
            Vector<int> p = (*it).getPos();
342
 
            int delta = abs(p.x - pos.x);
343
 
            if (delta < abs(p.y - pos.y))
344
 
                delta = abs(p.y - pos.y);
345
 
            
346
 
            if ((diff > delta) || (diff == -1))
347
 
            {
348
 
                diff = delta;
349
 
                diffit = it;
350
 
            }
351
 
        }
352
 
    }
353
 
    
354
 
    if (diff == -1) return 0;
355
 
    return &(*diffit);
 
270
  std::list<bool (*)(void *)> filters;
 
271
  filters.push_back(isBurnt);
 
272
  filters.push_back(isNotOwnedByNeutral);
 
273
  return getNearestObject(pos, &filters);
356
274
}
357
275
 
358
276
 
359
277
City* Citylist::getFirstCity(Player* p)
360
278
{
361
279
    for (iterator it = begin(); it != end(); it++)
362
 
        if ((*it).getPlayer() == p)
 
280
        if ((*it).getOwner() == p)
363
281
            return &(*it);
364
282
 
365
283
    return 0;
388
306
        it--;
389
307
        City *city = &*it;
390
308
        Army *a = new Army (helper, Army::PRODUCTION_BASE);
391
 
        city->addBasicProd(-1, a);
 
309
        city->addProductionBase(-1, a);
392
310
        return true;
393
311
      }
394
312
    if (tag == "city")
403
321
void Citylist::changeOwnership(Player *old_owner, Player *new_owner)
404
322
{
405
323
  for (iterator it = begin(); it != end(); it++)
406
 
    if ((*it).getPlayer() == old_owner)
 
324
    if ((*it).getOwner() == old_owner)
407
325
      {
408
 
        (*it).setPlayer(new_owner);
 
326
        (*it).setOwner(new_owner);
409
327
        if ((*it).isCapital())
410
328
          if ((*it).getCapitalOwner() == old_owner)
411
329
            (*it).setCapitalOwner(new_owner);
418
336
    {
419
337
      if ((*it).isBurnt() == true)
420
338
        continue;
421
 
      if ((*it).getPlayer() != c->getPlayer())
 
339
      if ((*it).getOwner() != c->getOwner())
422
340
        continue;
423
341
      if ((*it).getVectoring() == Vector<int>(-1,-1))
424
342
        continue;
439
357
  int count = 0;
440
358
  for (iterator it = begin(); it != end(); it++)
441
359
    {
442
 
      if (p && (*it).getPlayer() == p)
 
360
      if (p && (*it).getOwner() == p)
443
361
        continue;
444
362
      Vector<int> pos = (*it).getPos();
445
363
      count++;
461
379
{
462
380
  for (iterator it = begin(); it != end(); it++)
463
381
    {
464
 
      if ((*it).getPlayer() != target->getPlayer())
 
382
      if ((*it).getOwner() != target->getOwner())
465
383
        continue;
466
384
      if (target->contains((*it).getVectoring()))
467
385
        return true;
474
392
  std::list<City*> cities;
475
393
  for (iterator it = begin(); it != end(); it++)
476
394
    {
477
 
      if ((*it).getPlayer() != target->getPlayer())
 
395
      if ((*it).getOwner() != target->getOwner())
478
396
        continue;
479
397
      if (target->contains((*it).getVectoring()))
480
398
        cities.push_back(&(*it));
481
399
    }
482
400
  return cities;
483
401
}
484
 
City* Citylist::getNearestCity(City *city)
485
 
{
486
 
    int diff = -1;
487
 
    iterator diffit;
488
 
 
489
 
    for (iterator it = begin(); it != end(); ++it)
490
 
    {
491
 
          if ((*it).isBurnt())
492
 
              continue;
493
 
          
494
 
          Vector<int> pos = city->getPos();
495
 
          Vector<int> p = (*it).getPos();
496
 
          int delta = abs(p.x - pos.x);
497
 
          if (delta < abs(p.y - pos.y))
498
 
              delta = abs(p.y - pos.y);
499
 
          
500
 
          if ((diff > delta && delta != 0) || (diff == -1))
501
 
          {
502
 
              diff = delta;
503
 
              diffit = it;
504
 
          }
505
 
    }
506
 
    
507
 
    if (diff == -1) return 0;
508
 
    return &(*diffit);
509
 
}
510
402
 
511
403
City* Citylist::getNearestCityPast(const Vector<int>& pos, int dist)
512
404
{
513
 
    int diff = -1;
514
 
    iterator diffit;
515
 
 
516
 
    for (iterator it = begin(); it != end(); ++it)
517
 
    {
518
 
          if ((*it).isBurnt())
519
 
              continue;
520
 
          
521
 
          Vector<int> p = (*it).getPos();
522
 
          int delta = abs(p.x - pos.x);
523
 
          if (delta < abs(p.y - pos.y))
524
 
              delta = abs(p.y - pos.y);
525
 
          
526
 
          if ((diff > delta && delta >= dist) || (diff == -1))
527
 
          {
528
 
              diff = delta;
529
 
              diffit = it;
530
 
          }
531
 
    }
532
 
    
533
 
    if (diff == -1) return 0;
534
 
    return &(*diffit);
 
405
  std::list<bool (*)(void *)> filters;
 
406
  filters.push_back(isBurnt);
 
407
  return getNearestObjectAfter(pos, dist, &filters);
535
408
}
536
409
 
537
410
// End of file