/// 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));
}
}
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);
}
}
/// 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);
}
}
}
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 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();
}
}
/// 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;
}
}
/// Wenn ein Heimat-Militärgebäude bei Missionseinsätzen zerstört wurde
void nofDefender::HomeDestroyed()
{
building = 0;
switch(state)
{
case STATE_DEFENDING_WAITING:
{
// Hier muss sofort reagiert werden, da man steht
attacker = NULL;
// Rumirren
state = STATE_FIGUREWORK;
StartWandering();
Wander();
} break;
case STATE_DEFENDING_WALKINGTO:
case STATE_DEFENDING_WALKINGFROM:
{
attacker = NULL;
// Rumirren
StartWandering();
state = STATE_FIGUREWORK;
} break;
case STATE_FIGHTING:
{
// Die normale Tätigkeit wird erstmal fortgesetzt (Laufen, Kämpfen, wenn er schon an der Fahne ist
// wird er auch nicht mehr zurückgehen)
} break;
default:
break;
}
}
void Agent::Search() //Orange
{
searching = true;
int mouseX, mouseY;
Input::GetSingleton()->GetMouseXY(&mouseX, &mouseY);
float fDist = GetDistanceFromTarget((float)mouseX, (float)mouseY);
// Actuation
Wander(180, 60, 60);
// Transition
if (searchTimer > 3)
{
searching = false;
searchTimer = 0;
SetColour(Colour::Green);
}
if (fDist < m_nSightRange)
{
searching = false;
searchTimer = 0;
SetColour(Colour::Red);
}
if (GetHealth() <= 50)
{
searching = false;
searchTimer = 0;
SetColour(Colour::Blue);
}
}
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);
}
}
/** This program is a simple bumpers test.
*
*/
int main(int argc, char **argv)
{
geometry_msgs::Twist new_cmd;
ros::init(argc, argv, "bumper_wander");
ros::NodeHandle nh;
ros::Publisher cmd_vel_publisher = nh.advertise<geometry_msgs::Twist>("cmd_vel", 1);
ros::Subscriber bumpers_subscriber = nh.subscribe( "bumpers", 1, BumpersCallback );
ros::Subscriber movement_status_subscriber = nh.subscribe( "movement_status", 1, MovementStatusCallback );
ros::Rate loop_rate(LOOP_RATE);
while ( ros::ok() )
{
new_cmd = Wander();
EscapeCollision( &new_cmd, m_bump_direction );
EscapeStasis( &new_cmd, m_stasis_direction );
//ROS_INFO( "Publishing cmd_vel: Speed: %.2f Turn: %.2f", new_cmd.linear.x, new_cmd.angular.z );
cmd_vel_publisher.publish( new_cmd );
ros::spinOnce();
loop_rate.sleep();
}
return 0;
}
/// Wenn ein Kampf gewonnen wurde
void nofAggressiveDefender::WonFighting()
{
//addon BattlefieldPromotion active? -> increase rank!
if(GAMECLIENT.GetGGS().isEnabled(ADDON_BATTLEFIELD_PROMOTION))
IncreaseRank();
// Angreifer tot
attacker = NULL;
// Ist evtl. unser Heimatgebäude zerstört?
if(!building)
{
// Rumirren
state = STATE_FIGUREWORK;
StartWandering();
Wander();
// Ziel Bescheid sagen
if(attacked_goal)
attacked_goal->UnlinkAggressiveDefender(this);
return;
}
// Angreifer ist tot, nach anderen suchen, die in meiner Nähe sind und mich evtl noch mit denen kloppen
MissionAggressiveDefendingLookForNewAggressor();
}
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);
}
}
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();
}
}
/// Wenn ein Kampf gewonnen wurde
void nofAttacker::WonFighting()
{
// addon BattlefieldPromotion active? -> increase rank!
if(gwg->GetGGS().isEnabled(AddonId::BATTLEFIELD_PROMOTION))
IncreaseRank();
// Ist evtl. unser Heimatgebäude zerstört?
if(!building && state != STATE_ATTACKING_FIGHTINGVSDEFENDER)
{
// Dann dem Ziel Bescheid sagen, falls es existiert (evtl. wurdes zufällig zur selben Zeit zerstört)
InformTargetsAboutCancelling();
// Ggf. Schiff Bescheid sagen (Schiffs-Angreifer)
if(ship_obj_id)
CancelAtShip();
// Rumirren
state = STATE_FIGUREWORK;
StartWandering();
Wander();
return;
}
// Ist evtl. unser Ziel-Gebäude zerstört?
if(!attacked_goal)
{
// Nach Hause gehen
ReturnHomeMissionAttacking();
return;
}
ContinueAtFlag();
}
void noFigure::HandleEvent(const unsigned int id)
{
// Bei ID = 0 ists ein Laufevent, bei allen anderen an abgeleitete Klassen weiterleiten
if(id)
{
HandleDerivedEvent(id);
}
else
{
current_ev = NULL;
WalkFigure();
// Alte Richtung und Position für die Berechnung der Sichtbarkeiten merken
unsigned char old_dir = GetCurMoveDir();
MapPoint old_pos(pos);
switch(fs)
{
case FS_GOHOME:
case FS_GOTOGOAL:
{
WalkToGoal();
} break;
case FS_JOB:
{
Walked();
break;
}
case FS_WANDER:
{
Wander();
break;
}
}
// Ggf. Sichtbereich testen
if(GetVisualRange())
{
// Use old position (don't use this->x/y because it might be different now
// Figure could be in a ship etc.)
gwg->RecalcMovingVisibilities(old_pos, player, GetVisualRange(), old_dir, NULL);
std::vector<noBase*> figures = gwg->GetDynamicObjectsFrom(old_pos);
// Wenn Figur verschwunden ist, muss ihr ehemaliger gesamter Sichtbereich noch einmal
// neue berechnet werden
if(!helpers::contains(figures, this))
CalcVisibilities(old_pos);
}
}
}
Vector3 SteeringBehaviors::Calculate() {
this->_steeringForce.zero();
Vector3 force;
if(On(obstacle_avoidance)) {
double weightObstacleAvoidance = 10;
force = ObstacleAvoidance(((Agent*)this->_vehicle)->world->obstacles) *
weightObstacleAvoidance;
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(flee)) {
force = Flee(_vehicle->target);
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(seek)) {
force = Seek(_vehicle->target);
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(arrive)) {
force = Arrive(_vehicle->target, _deceleration);
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(pursue)) {
force = Pursue(this->evador1);
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(evade)) {
force = Evade(this->pursuer1);
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(wander)) {
force = Wander();
if(!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
return _steeringForce;
};
/// wenn man gelaufen ist
void nofDefender::Walked()
{
// Was bestimmtes machen, je nachdem welchen Status wir gerade haben
switch(state)
{
case STATE_DEFENDING_WALKINGTO:
{
// Mit Angreifer den Kampf beginnen
gwg->AddFigure(new noFighting(attacker, this), pos);
state = STATE_FIGHTING;
attacker->state = STATE_ATTACKING_FIGHTINGVSDEFENDER;
} break;
case STATE_DEFENDING_WALKINGFROM:
{
// Ist evtl. unser Heimatgebäude zerstört?
if(!building)
{
// Rumirren
attacker = 0;
state = STATE_FIGUREWORK;
StartWandering();
Wander();
return;
}
// Zu Hause angekommen
// Ist evtl. wieder ein Angreifer in der Zwischenzeit an der Fahne angekommen?
if(attacker)
{
// dann umdrehen und wieder rausgehen
state = STATE_DEFENDING_WALKINGTO;
StartWalking(4);
}
else
{
// mich von der Landkarte tilgen
gwg->RemoveFigure(this, pos);
// mich zum Gebäude wieder hinzufügen
building->AddActiveSoldier(this);
// Gebäude Bescheid sagen, dass es nun keinen Verteidiger mehr gibt
building->NoDefender();
}
} break;
default:
break;
}
}
void Moose::Hunting()
{
Wander();
Search(); // Call this to search for your prey (only works if SetPreyList has been called successfully).
// Check if the entity found a suitable target.
if (mCurTarget)
{
SetState(ES_ATTACK); // Switch its state to attack
mMoveSpeed = 2.5; // Increase it's movement speed
SetAnimationSpeed(100); // Decreases the animation's time between frames (makes the animation play faster)
PlayAnimation(ANIMATION_RUNNING, true); // Plays the running animation (must be set in constructor for this to work)
}
}
void Prey::FollowLeader()
{
if (LeaderInRange())
{
Wander();
}
else
{
// cout<<"Leader is out of range"<<endl;
SaveTarget();
ChaseMode();
SetFollowerState(FS_CHASELEADER);
}
}
/// wenn man gelaufen ist
void nofDefender::Walked()
{
// Was bestimmtes machen, je nachdem welchen Status wir gerade haben
switch(state)
{
case STATE_DEFENDING_WALKINGTO:
{
// Mit Angreifer den Kampf beginnen
gwg->AddFigure(new noFighting(attacker, this), pos);
state = STATE_FIGHTING;
attacker->FightVsDefenderStarted();
} break;
case STATE_DEFENDING_WALKINGFROM:
{
// Ist evtl. unser Heimatgebäude zerstört?
if(!building)
{
// Rumirren
attacker = 0;
state = STATE_FIGUREWORK;
StartWandering();
Wander();
return;
}
// Zu Hause angekommen
// Ist evtl. wieder ein Angreifer in der Zwischenzeit an der Fahne angekommen?
if(attacker)
{
// dann umdrehen und wieder rausgehen
state = STATE_DEFENDING_WALKINGTO;
StartWalking(4);
}
else
{
// mich von der Landkarte tilgen
gwg->RemoveFigure(this, pos);
nobBaseMilitary* bld = building;
// mich zum Gebäude wieder hinzufügen
RTTR_Assert(bld->GetDefender() == this); // I should be the defender
bld->AddActiveSoldier(this);
RTTR_Assert(!bld->GetDefender()); // No defender anymore
}
} break;
default:
break;
}
}
void Moose::Idle()
{
Wander(); // Moves around based on the values set in the constructor.
if (mHunger < 50)
{
mTargetType = ET_GRASS;
SetPrey((Entity **)((BaseApp*)mApp)->mGameState->mGrass);
mWanderStep = 300;
SetState(ES_HUNTING);
}
if (mAge > 20 && mHunger > 50 && !mSterile)
{
//Trigger stalking..
SetPrey((Entity **)((BaseApp *)mApp)->mGameState->mMoose);
mTargetType = ET_MOOSE;
mWanderStep = 300;
SetState(ES_STALKING);
}
//collect message from the message board..
MessageBoardMessages::iterator Pos;
Message CurMessage = MessageBoard::GetBoard()->CollectMessage(Pos);
if (CurMessage.TargetType == ET_MOOSE)
{
//dismiss the message if its a false alarm.
if (CurMessage.Target->GetAlive() == false || CurMessage.Target->GetType() == ET_CHUCK)
{
MessageBoard::GetBoard()->DismissMessage(Pos);
return;
}
//check the distance between this moose and the sender
float dist = sqrt((GetX() - CurMessage.Poster->GetX()) * (GetX() - CurMessage.Poster->GetX()) + (GetY() - CurMessage.Poster->GetY()) * (GetY() - CurMessage.Poster->GetY()));
if (dist < 300)
{
MessageBoard::GetBoard()->DismissMessage(Pos);
mTargetType = ET_PREDATOR;
mCurTarget = CurMessage.Target;
mMoveSpeed = 2.5; // Increase it's movement speed
SetAnimationSpeed(100); // Decreases the animation's time between frames (makes the animation play faster)
PlayAnimation(ANIMATION_CHARGING, true);
SetState(ES_CHARGING);
}
}
}
void nofBuilder::LostWork()
{
building_site = NULL;
if(state == STATE_FIGUREWORK)
GoHome();
else
{
// Event abmelden
em->RemoveEvent(current_ev);
StartWandering();
Wander();
state = STATE_FIGUREWORK;
}
}
/// Boat carrier paddles to the coast after his road was destroyed
void nofCarrier::WanderOnWater()
{
// Are we already there?
if(rs_pos == shore_path->size())
{
// Start normal wandering at the land
state = CARRS_FIGUREWORK;
StartWandering();
Wander();
delete shore_path;
shore_path = NULL;
}
else
{
// Continue paddling to the coast
StartWalking(shore_path->at(rs_pos));
++rs_pos;
}
}
void KAIBase::OnWander(void)
{
int nRetCode = false;
BOOL bRetCode = FALSE;
bRetCode = CheckAttacked();
KG_PROCESS_SUCCESS(bRetCode);
bRetCode = CheckTargetInAlertRange();
KG_PROCESS_SUCCESS(bRetCode);
bRetCode = CheckTargetInAttackRange();
KG_PROCESS_SUCCESS(bRetCode);
//闲逛一段距离
Wander();
Exit1:
return ;
}
Vector2D B020612E_Steering::CalculatePrioritised()
{
Vector2D force;
if (On(STEERING_OBSTACLEAVOIDANCE))
{
force = ObstacleAvoidance(ObstacleManager::Instance()->GetObstacles()) * 10.0f;
if (!AccumulateForce(_pSteeringForce, force))
return _pSteeringForce;
}
if (On(STEERING_FLEE))
{
force = Flee(_pTank->GetClick()) * 1.0f;
if (!AccumulateForce(_pSteeringForce, force))
return _pSteeringForce;
}
if (On(STEERING_SEEK))
{
force = Seek(_pTank->GetClick()) * 1.0f;
if (!AccumulateForce(_pSteeringForce, force))
return _pSteeringForce;
}
if (On(STEERING_WANDER))
{
force = Wander() * 1.0f;
if (!AccumulateForce(_pSteeringForce, force))
return _pSteeringForce;
}
if (On(STEERING_ARRIVE))
{
force = Arrive(_pTank->GetClick(), _pDeceleration) * 1.0f;
if (!AccumulateForce(_pSteeringForce, force))
return _pSteeringForce;
}
return _pSteeringForce;
}
Vector2D B020612E_Steering::CalculateWeightedSum()
{
//if (On(STEERING_OBSTACLEAVOIDANCE))
//_pSteeringForce += ObstacleAvoidance();
if (On(STEERING_WANDER))
_pSteeringForce += Wander() * 1.0f;
if (On(STEERING_SEEK))
_pSteeringForce += Seek(_pTank->GetClick()) * 1.0f;
if (On(STEERING_FLEE))
_pSteeringForce += Flee(_pTank->GetClick()) * 1.0f;
if (On(STEERING_ARRIVE))
_pSteeringForce += Arrive(_pTank->GetClick(), _pDeceleration) * 1.0f;
if (On(STEERING_PURSUIT))
_pSteeringForce += Pursuit(_pTank->GetMotion(), _pTank->GetMouseVelocity()) * 1.0f;
//if (On(STEERING_PATHFOLLOWING))
// _pSteeringForce += FollowPath() * 0.5f;
_pSteeringForce.Truncate(_pTank->GetMaxForce());
return _pSteeringForce;
}
void Moose::Stalking()
{
Wander();
Search();
if (mHunger < 50)
{
mTargetType = ET_GRASS;
SetPrey((Entity **)((BaseApp*)mApp)->mGameState->mGrass);
mWanderStep = 300;
SetState(ES_HUNTING);
}
if (mCurTarget)
{
SetState(ES_MATING); // Switch its state to attack
mMoveSpeed = 1.5; // Increase it's movement speed
SetAnimationSpeed(100); // Decreases the animation's time between frames (makes the animation play faster)
PlayAnimation(ANIMATION_WALKING);
}
}
void noFigure::StartWandering(const unsigned burned_wh_id)
{
fs = FS_WANDER;
cur_rs = 0;
goal_ = 0;
rs_pos = 0;
this->burned_wh_id = burned_wh_id;
// eine bestimmte Strecke rumirren und dann eine Flagge suchen
// 3x rumirren und eine Flagge suchen, wenn dann keine gefunden wurde, stirbt die Figur
wander_way = WANDER_WAY_MIN + RANDOM.Rand(__FILE__, __LINE__, GetObjId(), WANDER_WAY_MAX - WANDER_WAY_MIN);
// Soldaten sind härter im Nehmen
bool is_soldier = (job_ >= JOB_PRIVATE && job_ <= JOB_GENERAL);
wander_tryings = is_soldier ? WANDER_TRYINGS_SOLDIERS : WANDER_TRYINGS;
// Wenn wir stehen, zusätzlich noch loslaufen!
if(waiting_for_free_node)
{
waiting_for_free_node = false;
Wander();
}
}
void Boid::PreUpdate()
{
// find nearest boids
BoidFriend boids[5];
int count = 0;
FindClosest(boids, count, 5);
// avoid walls
AvoidWalls();
// update anger
if (count != 0)
{
float anger = 0.f;
for (int i = 0; i != count; ++i)
anger += boids[i].boid->m_Anger;
anger /= count;
// slowly adjust towards group anger
if (anger > m_Anger)
m_Anger += g_FrameTime * count;
else
m_Anger -= g_FrameTime * 0.5f;
}
m_Anger += Rand(0.f, 0.05f) * g_FrameTime;
m_Anger = Clamp(m_Anger, 0.f, 1.f);
// calculate flocking steering
AddForce(Flock(boids, count));
// attack if angry, otherwise flock and wander
if (m_Anger > 0.5f)
{
float t = (m_Anger - 0.5f) * 2.f;
AddForce(Attack() * t);
}
else
AddForce(Wander());
}
/// Wenn ein Heimat-Militärgebäude bei Missionseinsätzen zerstört wurde
void nofAttacker::HomeDestroyed()
{
switch(state)
{
case STATE_ATTACKING_WAITINGAROUNDBUILDING:
{
// Hier muss sofort reagiert werden, da man steht
// Angreifer muss zusätzlich seinem Ziel Bescheid sagen
nobBaseMilitary* curGoal = attacked_goal; // attacked_goal gets reset
InformTargetsAboutCancelling();
// Ggf. Schiff Bescheid sagen (Schiffs-Angreifer)
if(ship_obj_id)
CancelAtShip();
// Rumirren
building = nullptr;
state = STATE_FIGUREWORK;
StartWandering();
Wander();
// und evtl einen Nachrücker für diesen Platz suchen
curGoal->SendSuccessor(pos, radius);
}
break;
default:
{
// Wenn wir gerade auf dem Weg dorthin sind (z.B. an Bord eines Schiffs), Ziel löschen
if(goal_ == building)
goal_ = nullptr;
// Die normale Tätigkeit wird erstmal fortgesetzt (Laufen, Kämpfen, wenn er schon an der Fahne ist
// wird er auch nicht mehr zurückgehen)
building = nullptr;
}
break;
}
}
