/**
*
*
* @author OLiver
*/
void nofCarrier::LookForWares()
{
// Gibts an dieser Flagge etwas, das ich tragen muss?
if(workplace->AreWareJobs(!rs_dir, ct, true))
{
// Dann soll das CARRS_FETCHWARE übernehmen
FetchWare(false);
}
else if(workplace->AreWareJobs(rs_dir, ct, false))
{
// Oder evtl auf der anderen Seite?
state = CARRS_FETCHWARE;
rs_dir = !rs_dir;
rs_pos = 0;
StartWalking(cur_rs->GetDir(rs_dir, rs_pos));
}
else
{
// Wieder zurück in die Mitte gehen
state = CARRS_GOTOMIDDLEOFROAD;
rs_dir = !rs_dir;
rs_pos = 0;
StartWalking(cur_rs->GetDir(rs_dir, rs_pos));
}
}
void nofTradeLeader::Walked()
{
// Exception handling: goal destroyed or sth. like this
if(fails > 1)
{
WanderFailedTrade();
return;
}
bool invalid_goal = false;
noBase* nob = gwg->GetNO(goal_);
if(nob->GetType() != NOP_BUILDING)
invalid_goal = true;
if(!static_cast<noBuilding*>(nob)->IsWarehouse())
invalid_goal = true;
unsigned char next_dir;
if(invalid_goal)
{
TryToGoHome();
next_dir = tr.GetNextDir();
StartWalking(next_dir);
}
else
{
next_dir = tr.GetNextDir();
// Are we now at the goal?
if(next_dir == REACHED_GOAL)
{
gwg->GetPlayer(static_cast<nobBaseWarehouse*>(nob)->GetPlayer()).IncreaseInventoryJob(this->GetJobType(), 1);
gwg->RemoveFigure(this, pos);
static_cast<nobBaseWarehouse*>(nob)->AddFigure(this);
}
else if(next_dir != NO_PATH)
StartWalking(next_dir);
else
{
TryToGoHome();
next_dir = tr.GetNextDir();
if(next_dir == NO_PATH)
{
CancelTradeCaravane();
next_dir = GetCurMoveDir();
//StartWanderingFailedTrade();
}
StartWalking(next_dir);
//next_dir=tr.GetNextDir();
//next_dir = dir;
}
}
//if(successor&&next_dir!=NO_PATH)
if(successor)
{
successor->AddNextDir(next_dir);
}
}
void nofActiveSoldier::WalkingHome()
{
// Is our home military building destroyed?
if(!building)
{
// Start wandering around
state = STATE_FIGUREWORK;
StartWandering();
Wander();
return;
}
// Walking home to our military building
// Are we already at the flag?
if(GetPos() == building->GetFlag()->GetPos())
{
// Enter via the door
StartWalking(1);
return;
}
// or are have we come into the building?
if(GetPos() == building->GetPos())
{
// We're there!
building->AddActiveSoldier(this);
// Remove myself from the map
gwg->RemoveFigure(this, pos);
return;
}
unsigned char dir = gwg->FindHumanPath(pos, building->GetFlag()->GetPos(), 100);
// Or we don't find a route?
if(dir == 0xFF)
{
// Start wandering around then
StartWandering();
state = STATE_FIGUREWORK;
Wander();
// Inform our home building that we're not coming anymore
building->SoldierLost(this);
}
// All ok?
else
{
// Find all sorts of enemies (attackers, aggressive defenders..) nearby
if(FindEnemiesNearby())
// Enemy found -> abort, because nofActiveSoldier handles all things now (inclusive one walking step)
return;
// Start walking
StartWalking(dir);
}
}
void nofGeologist::GoToNextNode()
{
// Wenn es keine Flagge mehr gibt, dann gleich rumirren
if(!flag)
{
StartWandering();
Wander();
state = STATE_FIGUREWORK;
return;
}
// ersten Punkt suchen
unsigned char dir = GetNextNode();
if(dir != INVALID_DIR)
{
// Wenn es einen Punkt gibt, dann hingehen
state = STATE_GEOLOGIST_GOTONEXTNODE;
StartWalking(Direction::fromInt(dir));
--signs;
} else if(node_goal == pos)
{
// Already there
state = STATE_GEOLOGIST_GOTONEXTNODE;
--signs;
Walked();
} else
{
// ansonsten zur Flagge zurückgehen
state = STATE_GOTOFLAG;
Walked();
}
}
void Motion::TurnByAngle(double angle)
{
if(angle == 0)
return;
else if(angle > 0)
StartWalking(0,0,30);
else if(angle < 0)
{
angle = -angle;
StartWalking(0,0,-30);
}
usleep(2000*1000);
//usleep(factor*angle*27);
StopWalking();
SetHeadTilt(HeadTilt(GetHeadTilt().Tilt,0));
}
void Motion::StartWalking(double distance)
{
double timeToWalk = distance / BrainData::GetInstance()->WALK_SPEED;
StartWalking();
usleep(timeToWalk*1000000); //convert sec to microsec
StopWalking();
}
void nofShipWright::WalkToWorkpoint()
{
// Sind wir am Ziel angekommen?
if(pos == dest)
{
// Anfangen zu arbeiten
state = STATE_WORK;
current_ev = GetEvMgr().AddEvent(this, WORKING_TIME_SHIPS, 1);
return;
}
unsigned char dir = gwg->FindHumanPath(pos, dest, 20);
// Weg suchen und gucken ob der Punkt noch in Ordnung ist
if(dir == 0xFF || (!IsPointGood(dest) && gwg->GetGOT(dest) != GOT_SHIPBUILDINGSITE))
{
// Punkt freigeben
gwg->SetReserved(dest, false);
// Kein Weg führt mehr zum Ziel oder Punkt ist nich mehr in Ordnung --> wieder nach Hause gehen
StartWalkingHome();
}
else
{
// Alles ok, wir können hinlaufen
StartWalking(dir);
}
}
bool nofAttacker::AttackFlag(nofDefender* /*defender*/)
{
// Zur Flagge laufen, findet er einen Weg?
unsigned char tmp_dir = gwg->FindHumanPath(pos, attacked_goal->GetFlag()->GetPos(), 3, true);
if(tmp_dir != 0xFF)
{
// Hat er drumrum gewartet?
bool waiting_around_building = (state == STATE_ATTACKING_WAITINGAROUNDBUILDING);
// Ja er hat einen Weg gefunden, also hinlaufen
// Wenn er steht, muss er loslaufen
if(waiting_around_building)
StartWalking(Direction(tmp_dir));
state = STATE_ATTACKING_ATTACKINGFLAG;
// Hatte er ums Gebäude gewartet?
if(waiting_around_building)
{
// evtl. Nachrücker senden
attacked_goal->SendSuccessor(pos, radius);
}
return true;
}
return false;
}
void nofBuildingWorker::WorkingReady()
{
// wir arbeiten nicht mehr
workplace->is_working = false;
// Trage ich eine Ware?
if(ware != GD_NOTHING)
{
noFlag* flag = workplace->GetFlag();
// Ist noch Platz an der Fahne?
if(flag->GetNumWares() < 8)
{
// Ware erzeugen
auto* real_ware = new Ware(ware, nullptr, flag);
// Inventur entsprechend erhöhen, dabei Schilder unterscheiden!
GoodType ware_type = ConvertShields(real_ware->type);
gwg->GetPlayer(player).IncreaseInventoryWare(ware_type, 1);
// Abnehmer für Ware finden
real_ware->SetGoal(gwg->GetPlayer(player).FindClientForWare(real_ware));
// Ware soll ihren weiteren Weg berechnen
real_ware->RecalcRoute();
// Ware ablegen
flag->AddWare(real_ware);
real_ware->WaitAtFlag(flag);
// Warenstatistik erhöhen
gwg->GetPlayer(this->player).IncreaseMerchandiseStatistic(ware);
// Tragen nun keine Ware mehr
ware = GD_NOTHING;
}
}
// Wieder reingehen
StartWalking(Direction::NORTHWEST);
state = STATE_ENTERBUILDING;
}
void noFigure::NodeFreed(const MapPoint pt)
{
// Stehen wir gerade aus diesem Grund?
if(waiting_for_free_node)
{
// Ist das der Punkt, zu dem wir hin wollen?
if(pt == gwg->GetNeighbour(this->pos, GetCurMoveDir()))
{
// Gehen wir in ein Gebäude? Dann wieder ausgleichen, weil wir die Türen sonst doppelt aufmachen!
if(GetCurMoveDir() == 1 && gwg->GetNO(gwg->GetNeighbour(this->pos, 1))->GetType() == NOP_BUILDING)
gwg->GetSpecObj<noBuilding>(gwg->GetNeighbour(this->pos, 1))->CloseDoor();
// oder aus einem raus?
if(GetCurMoveDir() == 4 && gwg->GetNO(this->pos)->GetType() == NOP_BUILDING)
gwg->GetSpecObj<noBuilding>(this->pos)->CloseDoor();
// Wir stehen nun nicht mehr
waiting_for_free_node = false;
// Dann loslaufen
StartWalking(GetCurMoveDir());
// anderen Leuten noch ggf Bescheid sagen
gwg->RoadNodeAvailable(this->pos);
}
}
}
void nofHunter::HandleStateWalkingToCadaver()
{
// Sind wir schon da?
if(animal->GetX() == x && animal->GetY() == y)
{
// dann ausnehmen
state = STATE_HUNTER_EVISCERATING;
current_ev = em->AddEvent(this,80,1);
}
else
{
// Weg dorthin suchen
if((dir=gwg->FindHumanPath(x,y,animal->GetX(),animal->GetY(),6)) != 0xFF)
{
// Weg gefunden, dann hinlaufen
StartWalking(dir);
}
else
{
// kein Weg gefunden --> nach Hause laufen
StartWalkingHome();
WalkHome();
}
}
}
void nofGeologist::GoToNextNode()
{
// Wenn es keine Flagge mehr gibt, dann gleich rumirren
if(!flag)
{
StartWandering();
Wander();
state = STATE_FIGUREWORK;
return;
}
// ersten Punkt suchen
unsigned char dir = GetNextNode();
if(dir != 0xFF)
{
// Wenn es einen Punkt gibt, dann hingehen
state = STATE_GEOLOGIST_GOTONEXTNODE;
StartWalking(dir);
--signs;
}
else
{
// ansonsten zur Flagge zurückgehen
state = STATE_GOTOFLAG;
Walked();
}
}
/// Erkundet (quasi ein Umherirren)
void nofScout_Free::Scout()
{
// Erkundet er noch, ist aber schon seine maximale Wegstrecke abgelaufen?
if(--rest_way == 0)
{
// Wieder zur Flagge zurückgehen
state = STATE_GOTOFLAG;
GoToFlag();
return;
}
// Bin ich schon an dem Punkt angekommen?
if(pos == nextPos)
{
// Nächsten Punkt suchen
GoToNewNode();
}
else
{
// Weg suchen
dir = gwg->FindHumanPath(pos, nextPos, 30);
// Wenns keinen gibt, neuen suchen, ansonsten hinlaufen
if(dir == 0xFF)
// Neuen Punkt suchen
GoToNewNode();
else
StartWalking(dir);
}
}
void nofFarmhand::WalkToWorkpoint()
{
// Sind wir am Ziel angekommen?
if(pos == dest)
{
// Anfangen zu arbeiten
state = STATE_WORK;
current_ev = em->AddEvent(this, JOB_CONSTS[job_].work_length, 1);
WorkStarted();
return;
}
// Weg suchen und gucken ob der Punkt noch in Ordnung ist
unsigned char dir = gwg->FindHumanPath(pos, dest, 20);
if(dir == 0xFF || GetPointQuality(dest) == PQ_NOTPOSSIBLE)
{
// Punkt freigeben
gwg->GetNode(dest).reserved = false;
// Kein Weg führt mehr zum Ziel oder Punkt ist nich mehr in Ordnung --> wieder nach Hause gehen
StartWalkingHome();
}
else
{
// Alles ok, wir können hinlaufen
StartWalking(dir);
}
}
void nofFarmhand::WalkHome()
{
// Sind wir zu Hause angekommen? (genauer an der Flagge !!)
if(pos == dest)
{
// Weiteres übernimmt nofBuildingWorker
WorkingReady();
return;
}
unsigned char dir = gwg->FindHumanPath(pos, dest, 40);
// Weg suchen und ob wir überhaupt noch nach Hause kommen
if(dir == 0xFF)
{
// Kein Weg führt mehr nach Hause--> Rumirren
StartWandering();
Wander();
// Haus Bescheid sagen
workplace->WorkerLost();
workplace = 0;
}
else
{
// Alles ok, wir können hinlaufen
StartWalking(dir);
}
}
/// Wenn ein Kampf gewonnen wurde
void nofDefender::WonFighting()
{
//addon BattlefieldPromotion active? -> increase rank!
if(GAMECLIENT.GetGGS().isEnabled(ADDON_BATTLEFIELD_PROMOTION))
IncreaseRank();
// Angreifer tot
attacker = 0;
// Ist evtl. unser Heimatgebäude zerstört?
if(!building)
{
// Rumirren
state = STATE_FIGUREWORK;
StartWandering();
Wander();
return;
}
// Neuen Angreifer rufen
if( (attacker = building->FindAttackerNearBuilding()) )
{
// Ein Angreifer gefunden, dann warten wir auf ihn, bis er kommt
state = STATE_DEFENDING_WAITING;
}
else
{
// Kein Angreifer gefunden, dann gehen wir wieder in unser Gebäude
state = STATE_DEFENDING_WALKINGFROM;
StartWalking(1);
// Angreifer auf 0 setzen, er ist ja tot
attacker = 0;
}
}
void nofPlaner::Walked()
{
/// Zur Baustelle zurückgelaufen? (=fertig)
if(pos == building_site->GetPos())
{
// Baustelle Bescheid sagen
building_site->PlaningFinished();
state = STATE_FIGUREWORK;
// Nach Hause laufen bzw. auch rumirren
rs_pos = 0;
rs_dir = true;
cur_rs = gwg->GetSpecObj<noRoadNode>(pos)->routes[4];
building_site = 0;
GoHome();
StartWalking(4);
}
else
{
/// Anfangen zu arbeiten
current_ev = em->AddEvent(this, JOB_CONSTS[JOB_PLANER].work_length, 1);
state = STATE_PLANING;
}
}
void nofHunter::HandleStateFindingShootingPoint()
{
// Sind wir schon da und steht das Tier schon?
if(shooting_x == x && shooting_y == y && animal->IsReadyForShooting())
{
// dann schießen
state = STATE_HUNTER_SHOOTING;
current_ev = em->AddEvent(this,16,1);
}
else
{
// Weg dorthin suchen
if((dir=gwg->FindHumanPath(x,y,shooting_x,shooting_y,6)) != 0xFF)
{
// Weg gefunden, dann hinlaufen
StartWalking(dir);
}
else
{
// kein Weg gefunden --> nach Hause laufen
StartWalkingHome();
WalkHome();
}
}
}
void nofHunter::WalkHome()
{
// Sind wir zu Hause angekommen? (genauer an der Flagge !!)
unsigned short flag_x = workplace->GetX()+(workplace->GetY()&1), flag_y = workplace->GetY()+1;
if(x == flag_x && y == flag_y)
{
// Weiteres übernimmt nofBuildingWorker
WorkingReady();
}
// Weg suchen und ob wir überhaupt noch nach Hause kommen (Toleranz bei dem Weg mit einberechnen,
// damit er nicht einfach rumirrt und wegstirbt, wenn er einmal ein paar Felder zu weit gelaufen ist)
else if((dir = gwg->FindHumanPath(x,y,flag_x,flag_y,MAX_HUNTING_DISTANCE+MAX_HUNTING_DISTANCE/4)) == 0xFF)
{
// Kein Weg führt mehr nach Hause--> Rumirren
StartWandering();
Wander();
// Haus Bescheid sagen
workplace->WorkerLost();
}
else
{
// Alles ok, wir können hinlaufen
StartWalking(dir);
}
}
/// Doesn't find a defender at the flag -> Send defenders or capture it
void nofAttacker::ContinueAtFlag()
{
RTTR_Assert(attacked_goal);
// Greifen wir grad ein Gebäude an?
if(state == STATE_ATTACKING_FIGHTINGVSDEFENDER || (state == STATE_FIGHTING && attacked_goal->GetFlag()->GetPos() == pos))
{
// Dann neuen Verteidiger rufen
if(attacked_goal->CallDefender(this)) //-V522
{
// Verteidiger gefunden --> hinstellen und auf ihn warten
SwitchStateAttackingWaitingForDefender();
} else
{
// check for soldiers of other non-friendly non-owner players to fight
if(FindEnemiesNearby(attacked_goal->GetPlayer()))
return;
// kein Verteidiger gefunden --> ins Gebäude laufen und es erobern
state = STATE_ATTACKING_CAPTURINGFIRST;
StartWalking(Direction::NORTHWEST);
// Normalen Militärgebäuden schonmal Bescheid sagen
if(attacked_goal->GetGOT() == GOT_NOB_MILITARY)
static_cast<nobMilitary*>(attacked_goal)->PrepareCapturing();
}
} else
{
// weiterlaufen
state = STATE_ATTACKING_WALKINGTOGOAL;
MissAttackingWalk();
}
}
/// Behandelt das Laufen zurück zum Schiff
void nofAttacker::HandleState_SeaAttack_ReturnToShip()
{
// Ist evtl. unser Heimatgebäude zerstört?
if(!building)
{
// Rumirren
state = STATE_FIGUREWORK;
StartWandering();
Wander();
// Schiff Bescheid sagen
CancelAtShip();
return;
}
// Sind wir schon im Schiff?
if(pos == shipPos)
{
// Alle Figuren durchgehen
for(noBase* figure : gwg->GetFigures(pos))
{
if(figure->GetObjId() == ship_obj_id)
{
StartReturnViaShip(static_cast<noShip&>(*figure));
return;
}
}
RTTR_Assert(false);
ship_obj_id = 0;
// Kein Schiff gefunden? Das kann eigentlich nich sein!
// Dann rumirren
StartWandering();
state = STATE_FIGUREWORK;
Wander();
return;
}
unsigned char dir = gwg->FindHumanPath(pos, shipPos, MAX_ATTACKING_RUN_DISTANCE);
// oder finden wir gar keinen Weg mehr?
if(dir == 0xFF)
{
// Kein Weg gefunden --> Rumirren
StartWandering();
state = STATE_FIGUREWORK;
Wander();
// Dem Heimatgebäude Bescheid sagen
building->SoldierLost(this);
// Und dem Schiff
CancelAtShip();
}
// oder ist alles ok? :)
else
{
// weiterlaufen
StartWalking(Direction(dir));
}
}
/**
*
*
* @author OLiver
*/
bool nofCarrier::AddWareJob(const noRoadNode* rn)
{
// Wenn wir rumstehen, sollten wir mal loslaufen! ^^und ggf umdrehen, genauso wie beim Laufen in die Mitte
if(state == CARRS_WAITFORWARE || state == CARRS_GOTOMIDDLEOFROAD)
{
// Stimmt die Richtung nicht? Dann umdrehen (geht aber nur, wenn wir stehen!)
if(rs_dir == workplace->GetNodeID(rn) && state == CARRS_WAITFORWARE)
{
rs_dir = !rs_dir;
// wenn wir zur Mitte laufen, müssen noch 2 von der pos abgezogen werden wegen dem Laufen
rs_pos = cur_rs->GetLength() - rs_pos - ((state == CARRS_GOTOMIDDLEOFROAD) ? 2 : 0);
}
// beim Gehen in die Mitte nicht sofort umdrehen!
else if(rs_dir == workplace->GetNodeID(rn))
return false;
// Und loslaufen, wenn wir stehen
if(state == CARRS_WAITFORWARE)
{
StartWalking(cur_rs->GetDir(rs_dir, rs_pos));
// Endlich wird wieder ordentlich gearbeitet!
StartWorking();
}
state = CARRS_FETCHWARE;
// Wir übernehmen den Job
return true;
}
else if(state == CARRS_WAITFORWARESPACE && rs_dir == !workplace->GetNodeID(rn))
{
// Wenn wir auf einen freien Platz warten, können wir nun losgehen, da wir ja die Waren dann "tauschen" können
StartWalking(cur_rs->GetDir(rs_dir, rs_pos));
state = CARRS_CARRYWARE;
// Wir übernehmen den Job
return true;
}
// Wir übernehmen den Job nicht
return false;
}
void nofPlaner::GoalReached()
{
state = STATE_WALKING;
// Zufällig Uhrzeigersinn oder dagegen
pd = ( RANDOM.Rand(__FILE__, __LINE__, GetObjId(), 2) == 0 ) ? (PD_CLOCKWISE) : (PD_COUNTERCLOCKWISE);
// Je nachdem erst nach rechts oder links gehen
StartWalking((pd == PD_CLOCKWISE) ? 5 : 3);
}
void nofDefender::HomeDestroyedAtBegin()
{
building = 0;
state = STATE_FIGUREWORK;
// Rumirren
StartWandering();
StartWalking(RANDOM.Rand(__FILE__, __LINE__, GetObjId(), 6));
}
void nofTradeDonkey::Walked()
{
if(next_dirs.size()<1)
{
//WanderFailedTrade();
gwg->RemoveFigure(this,x,y);
return;
}
unsigned char next_dir = GetNextDir();
// Are we now at the goal?
if(next_dir == REACHED_GOAL)
{
noBase * nob = gwg->GetNO(x,y);
bool invalid_goal = false;
if(nob->GetType() != NOP_BUILDING)
invalid_goal = true;
else if(!static_cast<noBuilding*>(nob)->IsWarehouse())
invalid_goal = true;
if(invalid_goal)
{
CancelTradeCaravane();
WanderFailedTrade();
return;
}
gwg->GetPlayer(static_cast<nobBaseWarehouse*>(nob)->GetPlayer())
->IncreaseInventoryJob(this->GetJobType(),1);
gwg->RemoveFigure(this,x,y);
static_cast<nobBaseWarehouse*>(nob)->AddFigure(this);
// Add also our ware if we carry one
if(gt != GD_NOTHING)
{
Goods goods;
goods.goods[gt] = 1;
static_cast<nobBaseWarehouse*>(nob)->AddGoods(goods);
gwg->GetPlayer(static_cast<nobBaseWarehouse*>(nob)->GetPlayer())
->IncreaseInventoryWare(gt,1);
}
}
else
{
if(next_dir!=NO_PATH)
StartWalking(next_dir);
else
{
CancelTradeCaravane();
WanderFailedTrade();
}
}
if(successor)
successor->AddNextDir(next_dir);
}
bool nofBuildingWorker::FreePlaceAtFlag()
{
// Hinaus gehen, um Ware abzulegen, falls wir auf einen freien Platz warten
if(state == STATE_WAITFORWARESPACE)
{
StartWalking(Direction::SOUTHEAST);
state = STATE_CARRYOUTWARE;
return true;
} else
return false;
}
void nofDefender::AttackerArrested()
{
// Neuen Angreifer suchen
attacker = building->FindAttackerNearBuilding();
if(!attacker)
{
// Kein Angreifer gefunden, dann gehen wir wieder in unser Gebäude
state = STATE_DEFENDING_WALKINGFROM;
StartWalking(1);
}
}
void noFigure::WanderToFlag()
{
// Existiert die Flagge überhaupt noch?
noBase* no = gwg->GetNO(flagPos_);
if(no->GetObjId() != flag_obj_id)
{
// Wenn nicht, wieder normal weiter rumirren
StartWandering();
Wander();
return;
}
// Sind wir schon da?
if(pos == flagPos_)
{
// Gibts noch nen Weg zu einem Lagerhaus?
if(nobBaseWarehouse* wh = gwg->GetPlayer(player).FindWarehouse(
gwg->GetSpecObj<noRoadNode>(pos), FW::Condition_StoreFigure, 0, true, &job_, false))
{
// ja, dann können wir ja hingehen
goal_ = wh;
cur_rs = 0;
rs_pos = 0;
fs = FS_GOHOME;
wh->AddDependentFigure(this);
WalkToGoal();
return;
}
else
{
// Wenn nicht, wieder normal weiter rumirren
StartWandering();
Wander();
return;
}
}
// Weiter zur Flagge gehen
// Gibts noch nen Weg dahin bzw. existiert die Flagge noch?
unsigned char dir = gwg->FindHumanPath(pos, flagPos_, 60, false);
if(dir != 0xFF)
{
// weiter hinlaufen
StartWalking(dir);
}
else
{
// Wenn nicht, wieder normal weiter rumirren
StartWandering();
Wander();
}
}
void nofDefender::AttackerArrested()
{
// Neuen Angreifer suchen
if(!(attacker = building->FindAttackerNearBuilding()))
{
// Kein Angreifer gefunden, dann gehen wir wieder in unser Gebäude
state = STATE_DEFENDING_WALKINGFROM;
StartWalking(1);
// Angreifer auf 0 setzen, er ist ja tot
attacker = 0;
}
}
/// Geht wieder zurück zur Flagge und dann nach Hause
void nofFlagWorker::GoToFlag()
{
// Zur Flagge zurücklaufen
// Bin ich an der Fahne?
if(pos == flag->GetPos())
{
// nach Hause gehen
nobBaseWarehouse* wh = gwg->GetPlayer(player).FindWarehouse(*flag, FW::AcceptsFigure(job_), true, false);
if(wh)
{
GoHome(wh);
// Vorgaukeln, dass wir ein Stück Straße bereits geschafft haben
// damit wir mit WalkToGoal weiter bis zum Ziel laufen können
cur_rs = &emulated_wanderroad;
rs_pos = 0;
WalkToGoal();
}
else
{
// Weg führt nicht mehr zum Lagerhaus, dann rumirren
StartWandering();
Wander();
}
// Da wir quasi "freiwillig" nach Hause gegangen sind ohne das Abreißen der Flagge, auch manuell wieder
// "abmelden"
gwg->GetPlayer(player).RemoveFlagWorker(this);
state = STATE_FIGUREWORK;
flag = NULL;
}
else
{
// Weg suchen
unsigned char dir = gwg->FindHumanPath(pos, flag->GetPos(), 40);
// Wenns keinen gibt, rumirren, ansonsten hinlaufen
if(dir == 0xFF)
{
Abrogate();
StartWandering();
Wander();
state = STATE_FIGUREWORK;
flag = NULL;
}
else
{
StartWalking(dir);
}
}
}
