2
* Copyright (C) 2002-4 by the Widelands Development Team
4
* This program is free software; you can redistribute it and/or
5
* modify it under the terms of the GNU General Public License
6
* as published by the Free Software Foundation; either version 2
7
* of the License, or (at your option) any later version.
9
* This program is distributed in the hope that it will be useful,
10
* but WITHOUT ANY WARRANTY; without even the implied warranty of
11
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
* GNU General Public License for more details.
14
* You should have received a copy of the GNU General Public License
15
* along with this program; if not, write to the Free Software
16
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22
#include "editor_game_base.h"
26
#include "militarysite.h"
29
#include "rendertarget.h"
32
#include "transport.h"
35
#include "warehouse.h"
36
#include "wexception.h"
40
==============================================================================
42
IdleSoldierSupply IMPLEMENTATION
44
==============================================================================
47
class IdleSoldierSupply : public Supply {
49
IdleSoldierSupply(Soldier* w);
52
void set_economy(Economy* e);
55
virtual PlayerImmovable* get_position(Game* g);
56
virtual int get_amount(Game* g, int ware);
57
virtual bool is_active(Game* g);
59
virtual WareInstance* launch_item(Game* g, int ware);
60
virtual Worker* launch_worker(Game* g, int ware);
62
virtual Soldier* launch_soldier(Game* g, int ware, Requeriments* req);
63
virtual int get_passing_requeriments(Game* g, int ware, Requeriments* r);
64
virtual void mark_as_used (Game* g, int ware, Requeriments* r);
73
IdleSoldierSupply::IdleSoldierSupply
75
Automatically register with the soldier's economy.
78
IdleSoldierSupply::IdleSoldierSupply(Soldier* s)
83
set_economy(s->get_economy());
89
IdleSoldierSupply::~IdleSoldierSupply
91
Automatically unregister from economy.
94
IdleSoldierSupply::~IdleSoldierSupply()
102
IdleSoldierSupply::set_economy
104
Add/remove this supply from the Economy as appropriate.
107
void IdleSoldierSupply::set_economy(Economy* e)
113
m_economy->remove_soldier_supply(m_soldier->get_owner()->get_tribe()->get_worker_index(m_soldier->get_name().c_str()), this);
118
m_economy->add_soldier_supply(m_soldier->get_owner()->get_tribe()->get_worker_index(m_soldier->get_name().c_str()), this);
124
IdleSoldierSupply::get_position
126
Return the soldier's position.
129
PlayerImmovable* IdleSoldierSupply::get_position(Game* g)
131
return m_soldier->get_location(g);
137
IdleSoldierSupply::get_amount
139
It's just the one soldier.
142
int IdleSoldierSupply::get_amount(Game* g, int ware)
144
if (ware == m_soldier->get_owner()->get_tribe()->get_worker_index(m_soldier->get_name().c_str()))
153
IdleSoldierSupply::is_active
155
Idle soldiers are always active supplies, because they need to get into a
159
bool IdleSoldierSupply::is_active(Game* g)
167
IdleSoldierSupply::launch_item
170
WareInstance* IdleSoldierSupply::launch_item(Game* g, int ware)
172
throw wexception("IdleSoldierSupply::launch_item() makes no sense.");
178
IdleSodlierSupply::launch_worker
181
Worker* IdleSoldierSupply::launch_worker(Game* g, int ware)
183
log ("IdleSoldierSupply::launch_worker() Warning something can go wrong around here.\n");
185
return launch_soldier(g, ware, NULL);
191
IdleSodlierSupply::launch_soldier
193
No need to explicitly launch the soldier.
196
Soldier* IdleSoldierSupply::launch_soldier(Game* g, int ware, Requeriments* req)
198
assert(ware == m_soldier->get_owner()->get_tribe()->get_worker_index(m_soldier->get_name().c_str()));
203
m_soldier->get_level(atrHP),
204
m_soldier->get_level(atrAttack),
205
m_soldier->get_level(atrDefense),
206
m_soldier->get_level(atrEvade)
209
// Ensures that this soldier is used now
210
m_soldier->mark (false);
214
throw wexception ("IdleSoldierSupply::launch_soldier Fails. Requeriments aren't accomplished.");
222
IdleSodlierSupply::mark_as_used
225
void IdleSoldierSupply::mark_as_used(Game* g, int ware, Requeriments* req)
227
assert(ware == m_soldier->get_owner()->get_tribe()->get_worker_index(m_soldier->get_name().c_str()));
232
m_soldier->get_level(atrHP),
233
m_soldier->get_level(atrAttack),
234
m_soldier->get_level(atrDefense),
235
m_soldier->get_level(atrEvade)
238
// Ensures that this soldier has a request now
239
m_soldier->mark (true);
242
throw wexception ("IdleSoldierSupply::launch_soldier Fails. Requeriments aren't accomplished.");
245
m_soldier->mark (true);
251
IdleSodlierSupply::get_passing_requeriments
253
No need to explicitly launch the soldier.
256
int IdleSoldierSupply::get_passing_requeriments(Game* g, int ware, Requeriments* req)
258
assert(ware == m_soldier->get_owner()->get_tribe()->get_worker_index(m_soldier->get_name().c_str()));
260
// Oops we find a marked soldied (in use)
261
if (m_soldier->is_marked())
268
m_soldier->get_level(atrHP),
269
m_soldier->get_level(atrAttack),
270
m_soldier->get_level(atrDefense),
271
m_soldier->get_level(atrEvade)
282
==============================================================
284
SOLDIER DESCRIPTION IMPLEMENTATION
286
==============================================================
291
Soldier_Descr::Soldier_Descr
292
Soldier_Descr::~Soldier_Descr
295
Soldier_Descr::Soldier_Descr(Tribe_Descr *tribe, const char *name)
296
: Worker_Descr(tribe, name)
298
add_attribute(Map_Object::SOLDIER);
301
Soldier_Descr::~Soldier_Descr(void)
303
m_hp_pics_fn.resize(0);
304
m_attack_pics_fn.resize(0);
305
m_defense_pics_fn.resize(0);
306
m_evade_pics_fn.resize(0);
313
Parse carrier-specific configuration data
316
void Soldier_Descr::parse(const char *directory, Profile *prof, const EncodeData *encdata)
318
Worker_Descr::parse(directory, prof, encdata);
319
Section* sglobal=prof->get_section("global");
322
std::string hp=sglobal->get_safe_string("hp");
323
std::vector<std::string> list;
324
split_string(hp, &list, "-");
326
throw wexception("Parse error in hp string: \"%s\" (must be \"min-max\")", hp.c_str());
328
for(i=0; i<list.size(); i++)
329
remove_spaces(&list[i]);
331
m_min_hp= strtol(list[0].c_str(),&endp, 0);
333
throw wexception("Parse error in hp string: %s is a bad value", list[0].c_str());
334
m_max_hp = strtol(list[1].c_str(),&endp, 0);
336
throw wexception("Parse error in hp string: %s is a bad value", list[1].c_str());
339
std::string attack=sglobal->get_safe_string("attack");
341
split_string(attack, &list, "-");
343
throw wexception("Parse error in attack string: \"%s\" (must be \"min-max\")", attack.c_str());
344
for(i=0; i<list.size(); i++)
345
remove_spaces(&list[i]);
346
m_min_attack= strtol(list[0].c_str(),&endp, 0);
348
throw wexception("Parse error in attack string: %s is a bad value", list[0].c_str());
349
m_max_attack = strtol(list[1].c_str(),&endp, 0);
351
throw wexception("Parse error in attack string: %s is a bad value", list[1].c_str());
354
m_defense=sglobal->get_safe_int("defense");
357
m_evade=sglobal->get_safe_int("evade");
359
// Parse increases per level
360
m_hp_incr=sglobal->get_safe_int("hp_incr_per_level");
361
m_attack_incr=sglobal->get_safe_int("attack_incr_per_level");
362
m_defense_incr=sglobal->get_safe_int("defense_incr_per_level");
363
m_evade_incr=sglobal->get_safe_int("evade_incr_per_level");
366
m_max_hp_level=sglobal->get_safe_int("max_hp_level");
367
m_max_attack_level=sglobal->get_safe_int("max_attack_level");
368
m_max_defense_level=sglobal->get_safe_int("max_defense_level");
369
m_max_evade_level=sglobal->get_safe_int("max_evade_level");
371
// Load the filenames
372
m_hp_pics_fn.resize(m_max_hp_level+1);
373
m_attack_pics_fn.resize(m_max_attack_level+1);
374
m_defense_pics_fn.resize(m_max_defense_level+1);
375
m_evade_pics_fn.resize(m_max_evade_level+1);
377
std::string dir=directory;
379
for(i=0; i<=m_max_hp_level; i++) {
380
sprintf(buffer, "hp_level_%i_pic", i);
382
m_hp_pics_fn[i]+=sglobal->get_safe_string(buffer);
384
for(i=0; i<=m_max_attack_level; i++) {
385
sprintf(buffer, "attack_level_%i_pic", i);
386
m_attack_pics_fn[i]=dir;
387
m_attack_pics_fn[i]+=sglobal->get_safe_string(buffer);
389
for(i=0; i<=m_max_defense_level; i++) {
390
sprintf(buffer, "defense_level_%i_pic", i);
391
m_defense_pics_fn[i]=dir;
392
m_defense_pics_fn[i]+=sglobal->get_safe_string(buffer);
394
for(i=0; i<=m_max_evade_level; i++) {
395
sprintf(buffer, "evade_level_%i_pic", i);
396
m_evade_pics_fn[i]=dir;
397
m_evade_pics_fn[i]+=sglobal->get_safe_string(buffer);
404
void Soldier_Descr::load_graphics(void) {
405
m_hp_pics.resize(m_max_hp_level+1);
406
m_attack_pics.resize(m_max_attack_level+1);
407
m_defense_pics.resize(m_max_defense_level+1);
408
m_evade_pics.resize(m_max_evade_level+1);
410
for(i=0; i<=m_max_hp_level; i++) {
411
m_hp_pics[i]=g_gr->get_picture(PicMod_Game, m_hp_pics_fn[i].c_str(), true);
413
for(i=0; i<=m_max_attack_level; i++) {
414
m_attack_pics[i]=g_gr->get_picture(PicMod_Game, m_attack_pics_fn[i].c_str(), true);
416
for(i=0; i<=m_max_defense_level; i++) {
417
m_defense_pics[i]=g_gr->get_picture(PicMod_Game, m_defense_pics_fn[i].c_str(), true);
419
for(i=0; i<=m_max_evade_level; i++) {
420
m_evade_pics[i]=g_gr->get_picture(PicMod_Game, m_evade_pics_fn[i].c_str(), true);
422
Worker_Descr::load_graphics();
427
* Get random animation of specified type
429
uint Soldier_Descr::get_rand_anim(std::string name)
431
// Todo: This is thought to get a random animation like attack_1 attack_2 attack_3 ...
432
// Randimly trhought this method. By now only gets attack, but isn't very difficult
433
// to remake allowing the attack_1 and so.
434
return get_animation(name.c_str());
438
* Create a new soldier
440
Bob* Soldier_Descr::create_object() {
441
return new Soldier(this);
445
==============================
449
==============================
458
Soldier::Soldier(Soldier_Descr *descr)
461
// all done through init
469
* Initialize this soldier
471
void Soldier::init(Editor_Game_Base* gg) {
478
m_min_attack=get_descr()->get_min_attack();
479
m_max_attack=get_descr()->get_max_attack();
480
m_defense=get_descr()->get_defense();
481
m_evade=get_descr()->get_evade();
483
Game* g= static_cast<Game*>(gg);
484
int range=get_descr()->get_max_hp()-get_descr()->get_min_hp();
485
int value=g->logic_rand() % range;
488
m_hp_current=m_hp_max;
496
* Set this soldiers level. Automatically sets the new values
498
void Soldier::set_level(uint hp, uint attack, uint defense, uint evade) {
500
set_attack_level(attack);
501
set_defense_level(defense);
502
set_evade_level(evade);
504
void Soldier::set_hp_level(uint hp) {
505
assert(hp>=m_hp_level && hp<=get_descr()->get_max_hp_level());
507
while(m_hp_level<hp) {
509
m_hp_max+=get_descr()->get_hp_incr_per_level();
510
m_hp_current+=get_descr()->get_hp_incr_per_level();
513
void Soldier::set_attack_level(uint attack) {
514
assert(attack>=m_attack_level && attack<=get_descr()->get_max_attack_level());
516
while(m_attack_level<attack) {
518
m_min_attack+=get_descr()->get_attack_incr_per_level();
519
m_max_attack+=get_descr()->get_attack_incr_per_level();
522
void Soldier::set_defense_level(uint defense) {
523
assert(defense>=m_defense_level && defense<=get_descr()->get_max_defense_level());
525
while(m_defense_level<defense) {
527
m_defense+=get_descr()->get_defense_incr_per_level();
530
void Soldier::set_evade_level(uint evade) {
531
assert(evade>=m_evade_level && evade<=get_descr()->get_max_evade_level());
533
while(m_evade_level<evade) {
535
m_evade+=get_descr()->get_evade_incr_per_level();
539
uint Soldier::get_level(tAttribute at)
543
case atrHP: return m_hp_level;
544
case atrAttack: return m_attack_level;
545
case atrDefense: return m_defense_level;
546
case atrEvade: return m_evade_level;
547
case atrTotal: return m_hp_level + m_attack_level + m_defense_level + m_evade_level;
549
throw wexception ("Soldier::get_level attribute not identified.)");
552
void Soldier::heal (uint hp)
554
// Ensures that we can only heal, don't hurt throught this method
557
molog ("healing (%d+)%d/%d\n", hp, m_hp_current, m_hp_max);
560
if (m_hp_current > m_hp_max)
561
m_hp_current = m_hp_max;
565
* This only subs the specified number of hitpoints, don't do anything more.
567
void Soldier::damage (uint value)
569
assert (m_hp_current > 0);
571
molog ("damage %d(-%d)/%d\n", m_hp_current, value, m_hp_max);
572
if (m_hp_current < value)
575
m_hp_current -= value;
579
* Draw this soldier. This basically draws him as a worker, but add hitpoints
581
void Soldier::draw(Editor_Game_Base* g, RenderTarget* dst, Point pos) {
582
uint anim = get_current_anim();
588
calc_drawpos(g, pos, &drawpos);
591
g_gr->get_animation_size(anim, g->get_gametime() - get_animstart(), &w, &h);
594
// first: draw white sourrounding
595
const int frame_width=w<<1; // width * 2
596
const int frame_height=5;
597
const int frame_beginning_x=drawpos.x-(frame_width>>1); // TODO: these should be calculated from the hot spot, not assumed
598
const int frame_beginning_y=drawpos.y-h-7;
599
dst->draw_rect(frame_beginning_x, frame_beginning_y, frame_width, frame_height, HP_FRAMECOLOR);
601
float percent = (float)m_hp_current/m_hp_max;
602
int energy_width=static_cast<int>(percent * (frame_width-2));
605
color = RGBColor(255, 0, 0);
606
else if (percent <= 0.5)
607
color = RGBColor(255, 255, 0);
609
color = RGBColor(17,192,17);
610
dst->fill_rect(frame_beginning_x+1, frame_beginning_y+1, energy_width, frame_height-2, color);
612
// Draw information fields about levels
613
// first, gather informations
614
uint hppic=get_hp_level_pic();
615
uint attackpic=get_attack_level_pic();
616
uint defensepic=get_defense_level_pic();
617
uint evadepic=get_evade_level_pic();
618
int hpw,hph,atw,ath,dew,deh,evw,evh;
619
g_gr->get_picture_size(hppic, &hpw, &hph);
620
g_gr->get_picture_size(attackpic, &atw, &ath);
621
g_gr->get_picture_size(defensepic, &dew, &deh);
622
g_gr->get_picture_size(evadepic, &evw, &evh);
624
dst->blit(frame_beginning_x, frame_beginning_y-hph-ath, attackpic);
625
dst->blit(frame_beginning_x+(frame_width>>1), frame_beginning_y-evh-deh, defensepic);
626
dst->blit(frame_beginning_x, frame_beginning_y-hph, hppic);
627
dst->blit(frame_beginning_x+(frame_width>>1), frame_beginning_y-evh, evadepic);
629
Worker::draw(g,dst,pos);
636
void Soldier::start_animation (Editor_Game_Base* gg, std::string name, uint time)
640
start_task_idle ((Game*)gg, get_descr()->get_rand_anim(name), time);
646
Soldier::start_task_gowarehouse
648
Get the soldier to move to the nearest warehouse.
649
The soldier is added to the list of usable wares, so he may be reassigned to
650
a new task immediately.
653
void Soldier::start_task_gowarehouse(Game* g)
657
push_task(g, &taskGowarehouse);
659
m_supply = (IdleWorkerSupply*) new IdleSoldierSupply(this);
668
Bob::Task Soldier::taskLaunchAttack = {
671
(Bob::Ptr)&Soldier::launchattack_update,
672
(Bob::Ptr)&Soldier::launchattack_signal,
677
* soldier::start_task_launchattack
679
void Soldier::start_task_launchattack(Game* g, Flag* f)
683
if (f->get_owner() == get_owner())
687
log ("Soldier::start_task_launchattack\n");
688
push_task(g, &taskLaunchAttack);
690
State* s = get_state();
692
// First step (we must exit from building), and set what is the target
694
s->ivar2 = 0; // Not requested to attack (used by signal 'combat')
695
s->objvar1 = get_location(g); // objvar1 is the owner flag (where is attached the FRIEND military site)
696
s->coords = f->get_position(); // Destination
701
* soldier::launchattack_update
703
void Soldier::launchattack_update (Game* g, State* state)
705
std::string signal = get_signal();
707
molog("[launchattack]: Task Updated %d\n", __LINE__);
709
/* if (signal == "combat" || state->ivar2 == 1)
711
molog("[launchattack] Combat requested for '%s'\n", signal.c_str());
714
molog("[launchattack] Combat not found, continue with launchattack\n");
717
if (signal == "fail")
719
molog("[launchattack]: Caught signal '%s'\n", signal.c_str());
722
else if (signal.size())
724
molog("[launchattack]: Interrupted by signal '%s'\n", signal.c_str());
729
// See if it's at building and drop of it
730
if (state->ivar1 == 1)
732
BaseImmovable* position = g->get_map()->get_immovable(get_position());
734
if (position && position->get_type() == BUILDING)
736
// We are in our building, try to exit
737
if (start_task_waitforcapacity(g, (Flag*)get_location(g)->get_base_flag()))
740
start_task_leavebuilding (g, 1);
745
// Ensures that the owner of this is the base flag of the militarysite that launchs the attack
746
Map* map = g->get_map();
747
PlayerImmovable* location = get_location(g);
751
assert(location->get_type() == FLAG);
753
owner = (Flag*)location;
755
if (state->ivar1 > 0)
760
location = (PlayerImmovable*) map->get_immovable(state->coords);
763
assert (location->get_type() == FLAG);
765
f_target = (Flag*) location;
766
c_target = f_target->get_position();
768
// Time to return home (in future, time to enter enemu house)
769
if (get_position() == c_target)
771
Building* bs = f_target->get_building();
772
// If there are enemy soldiers, time to kill they !!!
773
if (start_task_waitforassault(g, bs))
776
// Now, this soldier will enter to the house!
777
if (bs->get_owner() == get_owner())
780
schedule_act (g, 10);
784
bs->conquered_by (get_owner());
786
state->ivar1 = 0; // This makes return to home flag
787
schedule_act(g, 50); // Waits a little before trying to enter to the house
791
// Move towards enemy flag
792
if (!start_task_movepath(g, c_target, 0, get_descr()->get_right_walk_anims(does_carry_ware())))
794
molog("[launchattack]: Couldn't find path to enemy flag!\n");
796
mark(false); // Now can be healed
804
// Return to friend owner flag
805
if (get_position() == owner->get_position())
807
molog("[launchattack]: We are on home!\n");
808
mark(false); // Now can be healed
813
molog ("[launchattack]: Return home\n");
814
if (!start_task_movepath(g, owner->get_position(), 0, get_descr()->get_right_walk_anims(does_carry_ware())))
816
molog("[launchattack]: Couldn't find path home\n");
818
mark(false); // Now can be healed
824
void Soldier::launchattack_signal (Game* g, State* state)
826
std::string signal = get_signal ();
828
molog ("[LaunchAttack] Interrupted by signal '%s'\n", signal.c_str());
830
mark(false); // Now can be healed
832
launchattack_update(g, state);
837
* WaitForAssault task
842
Bob::Task Soldier::taskWaitForAssault = {
845
(Bob::Ptr)&Soldier::waitforassault_update,
846
(Bob::Ptr)&Soldier::waitforassault_signal,
851
* soldier::start_task_waitforassault (building)
853
* Returns true if is needed to wait.
855
bool Soldier::start_task_waitforassault (Game* g, Building* b)
862
if (!b->has_soldiers())
865
push_task(g, &taskWaitForAssault);
867
State* s = get_state();
873
void Soldier::waitforassault_update (Game* g, State* state)
875
Map_Object* imm = state->objvar1.get(g);
878
assert (imm->get_type() == BUILDING);
880
Building* b = (Building*) imm;
882
if (!b->has_soldiers())
884
MilitarySite* ms = (MilitarySite*) b;
885
molog("[waitforassault]: House %i (%p) empty of soldiers.\n", ms->get_serial(), ms);
886
if (ms->get_owner() == get_owner())
891
ms->conquered_by (get_owner());
892
molog("[waitforassault]: House %i (%p) empty of soldiers.\n", ms->get_serial(), ms);
898
switch (b->get_building_type())
900
case Building::MILITARYSITE:
902
MilitarySite* ms = (MilitarySite*) b;
903
// This should launch a soldier to defend the house !
908
case Building::WAREHOUSE:
910
Warehouse* wh = (Warehouse*) b;
911
// This should launch a soldier to defend the house !
917
molog("[waitforassault] Nothing to do with this building!!\n");
919
send_signal(g, "fail");
929
void Soldier::waitforassault_signal (Game* g, State* state)
931
std::string signal = get_signal();
933
if (signal == "end_combat")
935
molog("[WaitForAssault] Caught signal '%s' (Waking up!)\n", signal.c_str());
937
waitforassault_update(g, state);
940
else if (signal == "die")
942
molog ("[WaitForAssault] Caught signal '%s' (Death!)\n", signal.c_str());
947
else if (signal.size() > 0)
949
molog ("[WaitForAssault] : Interrupted by signal '%s'\n", signal.c_str());
955
* DefendBuilding task
960
Bob::Task Soldier::taskDefendBuilding = {
963
(Bob::Ptr)&Soldier::defendbuilding_update,
964
(Bob::Ptr)&Soldier::defendbuilding_signal,
968
void Soldier::start_task_defendbuilding (Game* g, Building* b, Bob* enemy)
970
molog ("Soldier: start_task_defendbuilding\n");
973
assert (((Building*) get_location(g)) == b);
975
push_task(g, &taskDefendBuilding);
976
mark(true); // This is for prevent to heal soldiers out of the building
977
State* s = get_state();
979
s->ivar2 = b->get_serial();
984
void Soldier::defendbuilding_update (Game* g, State* state)
986
if (get_current_hitpoints() < 1)
988
molog ("[DefendBuilding] : Ohh! I'm deading!!\n");
990
schedule_destroy (g);
992
schedule_act(g, 100);
996
if (state->ivar1 == 4)
998
pop_task(g); // We finally finish this task
999
start_task_idle(g, 0, -1); // Bind the soldier to the MS, and hide him of the map
1000
mark(false); // Now the soldier can be healed
1003
// 1-. Exit of this MS
1004
if (state->ivar1 == 1)
1006
BaseImmovable* position = g->get_map()->get_immovable(get_position());
1008
if (position && position->get_type() == BUILDING)
1010
// We are in our building, try to exit
1011
if (start_task_waitforcapacity(g, (Flag*)get_location(g)->get_base_flag()))
1014
start_task_leavebuilding (g, 0);
1019
// 2-. Create a BattleField with this soldier and attach emeny soldier
1020
if (state->ivar1 == 2)
1022
PlayerImmovable* imm = (PlayerImmovable*)state->objvar1.get(g);
1028
// Starts real combat!!
1029
Battle* battle = g->create_battle();
1030
battle->soldiers (this, s);
1035
// Here at least the soldier has ended of fighting (with this, the soldier will be healed)
1038
if (state->ivar1 == 3)
1040
// Now return home building !
1043
Building* build = (Building*)g->get_objects()->get_object(state->ivar2);
1046
molog ("[DefendBuilding] Returning home (%d)\n", state->ivar2);
1047
state->ivar1 = 4; // Next time Idle !
1048
set_location(build);
1049
start_task_return(g, false);
1054
molog ("[DefendBuilding] Home (%d) doesn't exists!\n", state->ivar2);
1061
molog("[DefendBuilding] End of function reached\n");
1065
void Soldier::defendbuilding_signal (Game* g, State* state)
1067
std::string signal = get_signal();
1068
if (signal == "end_combat")
1070
molog("[DefendBuilding] : Caught signal '%s'\n", signal.c_str());
1073
defendbuilding_update(g, state);
1075
else if (signal == "die")
1077
molog("[DefendBuilding] : Caught signal '%s'\n", signal.c_str());
1079
// Better to add here a start_task_die (usefull too for use at fugitive task)
1081
schedule_destroy(g);
1082
schedule_act(g, 5000);
1087
molog("[DefendBuilding] Interrupted by signal '%s'\n");
1094
void Soldier::log_general_info(Editor_Game_Base* egbase)
1096
Worker::log_general_info(egbase);
1097
molog("[Soldier]\n");
1098
molog("Levels: %d/%d/%d/%d\n", m_hp_level, m_attack_level, m_defense_level, m_evade_level);
1099
molog ("HitPoints: %d/%d\n", m_hp_current, m_hp_max);
1100
molog ("Attack : %d-%d\n", m_min_attack, m_max_attack);
1101
molog ("Defense : %d%%\n", m_defense);
1102
molog ("Evade: %d%%\n", m_evade);
added
removed
src/soldier.cc
