← Back to branch summary

~ubuntu-branches/ubuntu/precise/lordsawar/precise

« back to all changes in this revision

Viewing changes to src/player.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Barry deFreese
  • Date: 2007-10-29 15:38:06 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20071029153806-z2j47adhmdjc7wae
Tags: 0.0.4-1
* New upstream release
* Add desktop file and simple manpage for new binary lordsawar-army-editor
* Syntax fixes on manpages
* Move manpages to correct section (6)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/player.cpp
76
76
Player::Player(string name, Uint32 armyset, SDL_Color color, Type type,
77
77
               int player_no)
78
78
    :d_color(color), d_name(name), d_armyset(armyset), d_gold(1000),
79
 
    d_dead(false), d_immortal(false), d_type(type)
 
79
    d_dead(false), d_immortal(false), d_type(type), d_upkeep(0)
80
80
{
81
81
    if (player_no != -1)
82
82
        d_id = player_no;
94
94
    {
95
95
      d_fight_order.push_back(i);
96
96
    }
 
97
    memset(d_triumph, 0, sizeof(d_triumph));
97
98
}
98
99
 
99
100
Player::Player(const Player& player)
100
101
    :d_color(player.d_color), d_name(player.d_name), d_armyset(player.d_armyset),
101
102
    d_gold(player.d_gold), d_dead(player.d_dead), d_immortal(player.d_immortal),
102
103
    d_type(player.d_type), d_id(player.d_id), d_fogmap(player.d_fogmap),
103
 
    d_fight_order(player.d_fight_order)
 
104
    d_fight_order(player.d_fight_order), d_upkeep(player.d_upkeep)
104
105
{
105
106
    // as the other player is propably dumped somehow, we need to deep copy
106
107
    // everything. This costs a lot, but the only useful situation for this
107
108
    // I can think of is a change of the player type, as occurs in the editor.
108
 
    Stacklist::iterator it;
109
109
    d_stacklist = new Stacklist();
110
 
    for (it = player.d_stacklist->begin(); it != player.d_stacklist->end(); it++)
 
110
    for (Stacklist::iterator it = player.d_stacklist->begin(); 
 
111
         it != player.d_stacklist->end(); it++)
111
112
    {
112
113
        Stack* mine = new Stack(**it);
113
114
        // change the stack's loyalty
122
123
 
123
124
    // copy events
124
125
    std::list<History*>::const_iterator pit;
125
 
    for (pit = player.d_history.begin(); pit != player.d_history.end(); ait++)
 
126
    for (pit = player.d_history.begin(); pit != player.d_history.end(); pit++)
126
127
        d_history.push_back(History::copy(*pit));
127
128
 
128
129
    // copy fogmap; TBD
138
139
    helper->getData(d_dead, "dead");
139
140
    helper->getData(d_immortal, "immortal");
140
141
    helper->getData(d_type, "type");
 
142
    helper->getData(d_upkeep, "upkeep");
141
143
 
142
144
    string s;
143
145
    helper->getData(s, "color");
167
169
    helper->registerTag("history", sigc::mem_fun(this, &Player::load));
168
170
    helper->registerTag("stacklist", sigc::mem_fun(this, &Player::load));
169
171
    helper->registerTag("fogmap", sigc::mem_fun(this, &Player::load));
 
172
    helper->registerTag("triumphs", sigc::mem_fun(this, &Player::load));
170
173
 
171
174
}
172
175
 
398
401
    retval &= helper->saveData("immortal", d_immortal);
399
402
    retval &= helper->saveData("type", d_type);
400
403
    debug("type of " << d_name << " is " << d_type)
 
404
    retval &= helper->saveData("upkeep", d_upkeep);
401
405
 
402
406
    std::stringstream fight_order;
403
407
    for (std::list<Uint32>::const_iterator it = d_fight_order.begin();
420
424
    retval &= d_stacklist->save(helper);
421
425
    retval &= d_fogmap->save(helper);
422
426
 
 
427
    //save the triumphs
 
428
            
 
429
    helper->openTag("triumphs");
 
430
    for (unsigned int i = 0; i < 5; i++)
 
431
      {
 
432
        std::stringstream tally;
 
433
        for (unsigned int j = 0; j < MAX_PLAYERS; j++)
 
434
            tally << d_triumph[j][i] << " ";
 
435
        switch (TriumphType(i))
 
436
          {
 
437
          case TALLY_HERO:
 
438
            retval &= helper->saveData("hero", tally.str());
 
439
            break;
 
440
          case TALLY_NORMAL:
 
441
            retval &= helper->saveData("normal", tally.str());
 
442
            break;
 
443
          case TALLY_SPECIAL:
 
444
            retval &= helper->saveData("special", tally.str());
 
445
            break;
 
446
          case TALLY_SHIP:
 
447
            retval &= helper->saveData("ship", tally.str());
 
448
            break;
 
449
          case TALLY_FLAG:
 
450
            retval &= helper->saveData("flag", tally.str());
 
451
            break;
 
452
          }
 
453
      }
 
454
    helper->closeTag();
 
455
 
423
456
    return retval;
424
457
}
425
458
 
468
501
    if (tag == "fogmap")
469
502
        d_fogmap = new FogMap(helper);
470
503
 
 
504
    if (tag == "triumphs")
 
505
      {
 
506
        for (unsigned int i = 0; i < 5; i++)
 
507
          {
 
508
            std::string tally;
 
509
            std::stringstream stally;
 
510
            Uint32 val;
 
511
            switch (TriumphType(i))
 
512
              {
 
513
              case TALLY_HERO:
 
514
                helper->getData(tally, "hero");
 
515
                break;
 
516
              case TALLY_NORMAL:
 
517
                helper->getData(tally, "normal");
 
518
                break;
 
519
              case TALLY_SPECIAL:
 
520
                helper->getData(tally, "special");
 
521
                break;
 
522
              case TALLY_SHIP:
 
523
                helper->getData(tally, "ship");
 
524
                break;
 
525
              case TALLY_FLAG:
 
526
                helper->getData(tally, "flag");
 
527
                break;
 
528
              }
 
529
            stally.str(tally);
 
530
            for (unsigned int j = 0; j < MAX_PLAYERS; j++)
 
531
              {
 
532
                stally >> val;
 
533
                d_triumph[j][i] = val;
 
534
              }
 
535
          }
 
536
      }
 
537
 
471
538
    return true;
472
539
}
473
540
 
 
541
void Player::calculateUpkeep()
 
542
{
 
543
    d_upkeep = 0;
 
544
    Stacklist *sl = getStacklist();
 
545
    for (Stacklist::iterator i = sl->begin(), iend = sl->end(); i != iend; ++i)
 
546
      d_upkeep += (*i)->getUpkeep();
 
547
}
474
548
// End of file