/**
** Enter the transporter.
**
** @param unit Pointer to unit.
*/
static void EnterTransporter(CUnit &unit, COrder_Board &order)
{
CUnit *transporter = order.GetGoal();
Assert(transporter != NULL);
if (!transporter->IsVisibleAsGoal(*unit.Player)) {
DebugPrint("Transporter gone\n");
return;
}
if (transporter->BoardCount < transporter->Type->MaxOnBoard) {
// Place the unit inside the transporter.
unit.Remove(transporter);
transporter->BoardCount++;
unit.Boarded = 1;
if (!unit.Player->AiEnabled) {
// Don't make anything funny after going out of the transporter.
CommandStopUnit(unit);
}
if (IsOnlySelected(*transporter)) {
SelectedUnitChanged();
}
return;
}
DebugPrint("No free slot in transporter\n");
}
/**
** Send unit harvest a location
**
** @param unit pointer to unit.
** @param pos map position for harvest.
** @param flush if true, flush command queue.
*/
void CommandResourceLoc(CUnit &unit, const Vec2i &pos, int flush)
{
if (IsUnitValidForNetwork(unit) == false) {
return ;
}
if (!unit.Type->Building && !unit.Type->BoolFlag[HARVESTER_INDEX].value) {
ClearSavedAction(unit);
return ;
}
//Wyrmgus start
CMapField &mf = *Map.Field(unit.tilePos);
if ((mf.Flags & MapFieldBridge) && !unit.Type->BoolFlag[BRIDGE_INDEX].value && unit.Type->UnitType == UnitTypeLand) {
std::vector<CUnit *> table;
Select(unit.tilePos, unit.tilePos, table);
for (size_t i = 0; i != table.size(); ++i) {
if (!table[i]->Removed && table[i]->Type->BoolFlag[BRIDGE_INDEX].value && table[i]->CanMove()) {
CommandStopUnit(*table[i]); //always stop the raft if a new command is issued
}
}
}
//Wyrmgus end
COrderPtr *order;
if (unit.Type->Building) {
ClearNewAction(unit);
order = &unit.NewOrder;
} else {
order = GetNextOrder(unit, flush);
if (order == NULL) {
return;
}
}
*order = COrder::NewActionResource(unit, pos);
ClearSavedAction(unit);
}
/**
** Cast a spell at position or unit.
**
** @param unit Pointer to unit.
** @param pos map position to spell cast on.
** @param dest Spell cast on unit (if exist).
** @param spell Spell type pointer.
** @param flush If true, flush command queue.
*/
void CommandSpellCast(CUnit &unit, const Vec2i &pos, CUnit *dest, const SpellType &spell, int flush, bool isAutocast)
{
DebugPrint(": %d casts %s at %d %d on %d\n" _C_
UnitNumber(unit) _C_ spell.Ident.c_str() _C_ pos.x _C_ pos.y _C_ dest ? UnitNumber(*dest) : 0);
Assert(unit.Type->CanCastSpell[spell.Slot]);
Assert(Map.Info.IsPointOnMap(pos));
if (IsUnitValidForNetwork(unit) == false) {
return ;
}
//Wyrmgus start
CMapField &mf = *Map.Field(unit.tilePos);
if ((mf.Flags & MapFieldBridge) && !unit.Type->BoolFlag[BRIDGE_INDEX].value && unit.Type->UnitType == UnitTypeLand) {
std::vector<CUnit *> table;
Select(unit.tilePos, unit.tilePos, table);
for (size_t i = 0; i != table.size(); ++i) {
if (!table[i]->Removed && table[i]->Type->BoolFlag[BRIDGE_INDEX].value && table[i]->CanMove()) {
CommandStopUnit(*table[i]); //always stop the raft if a new command is issued
}
}
}
//Wyrmgus end
COrderPtr *order = GetNextOrder(unit, flush);
if (order == NULL) {
return;
}
*order = COrder::NewActionSpellCast(spell, pos, dest, true);
ClearSavedAction(unit);
}
/**
** Send command: Unit stop.
**
** @param unit pointer to unit.
*/
void SendCommandStopUnit(CUnit &unit)
{
if (!IsNetworkGame()) {
CommandLog("stop", &unit, FlushCommands, -1, -1, NoUnitP, NULL, -1);
CommandStopUnit(unit);
} else {
NetworkSendCommand(MessageCommandStop, unit, 0, 0, NoUnitP, 0, FlushCommands);
}
}
/**
** Move unit to new position
**
** @param unit pointer to unit.
** @param pos map position to move to.
** @param flush if true, flush command queue.
*/
void CommandMove(CUnit &unit, const Vec2i &pos, int flush)
{
Assert(Map.Info.IsPointOnMap(pos));
if (IsUnitValidForNetwork(unit) == false) {
return ;
}
//Wyrmgus start
CMapField &mf = *Map.Field(unit.tilePos);
CMapField &new_mf = *Map.Field(pos);
//if the unit is a land unit over a raft, move the raft instead of the unit
if ((mf.Flags & MapFieldBridge) && !unit.Type->BoolFlag[BRIDGE_INDEX].value && unit.Type->UnitType == UnitTypeLand) {
std::vector<CUnit *> table;
Select(unit.tilePos, unit.tilePos, table);
for (size_t i = 0; i != table.size(); ++i) {
if (!table[i]->Removed && table[i]->Type->BoolFlag[BRIDGE_INDEX].value && table[i]->CanMove()) {
CommandStopUnit(*table[i]); //always stop the raft if a new command is issued
if ((new_mf.Flags & MapFieldWaterAllowed) || (new_mf.Flags & MapFieldCoastAllowed) || (mf.Flags & MapFieldWaterAllowed)) { // if is standing on water, tell the raft to go to the nearest coast, even if the ultimate goal is on land
CommandStopUnit(unit);
CommandMove(*table[i], pos, flush);
return;
}
}
}
}
//Wyrmgus end
COrderPtr *order;
if (!unit.CanMove()) {
ClearNewAction(unit);
order = &unit.NewOrder;
} else {
order = GetNextOrder(unit, flush);
if (order == NULL) {
return;
}
}
*order = COrder::NewActionMove(pos);
ClearSavedAction(unit);
}
/**
** Move unit to unit resource.
**
** @return 1 if reached, -1 if unreacheable, 0 if on the way.
*/
int COrder_Resource::MoveToResource_Unit(CUnit &unit)
{
const CUnit *goal = this->GetGoal();
Assert(goal);
switch (DoActionMove(unit)) { // reached end-point?
case PF_UNREACHABLE:
//Wyrmgus start
//if is unreachable and is on a raft, see if the raft can move closer
if ((Map.Field(unit.tilePos)->Flags & MapFieldBridge) && !unit.Type->BoolFlag[BRIDGE_INDEX].value && unit.Type->UnitType == UnitTypeLand) {
std::vector<CUnit *> table;
Select(unit.tilePos, unit.tilePos, table);
for (size_t i = 0; i != table.size(); ++i) {
if (!table[i]->Removed && table[i]->Type->BoolFlag[BRIDGE_INDEX].value && table[i]->CanMove()) {
if (table[i]->CurrentAction() == UnitActionStill) {
CommandStopUnit(*table[i]);
CommandMove(*table[i], this->HasGoal() ? this->GetGoal()->tilePos : this->goalPos, FlushCommands);
}
return 0;
}
}
}
//Wyrmgus end
return -1;
case PF_REACHED:
break;
case PF_WAIT:
if (unit.Player->AiEnabled) {
this->Range++;
if (this->Range >= 5) {
this->Range = 0;
AiCanNotMove(unit);
}
}
default:
// Goal gone or something.
if (unit.Anim.Unbreakable || goal->IsVisibleAsGoal(*unit.Player)) {
return 0;
}
break;
}
return 1;
}
/**
** Attack with unit at new position
**
** @param unit pointer to unit.
** @param pos map position to attack.
** @param target or unit to be attacked.
** @param flush if true, flush command queue.
*/
void CommandAttack(CUnit &unit, const Vec2i &pos, CUnit *target, int flush)
{
Assert(Map.Info.IsPointOnMap(pos));
if (IsUnitValidForNetwork(unit) == false) {
return ;
}
//Wyrmgus start
CMapField &mf = *Map.Field(unit.tilePos);
CMapField &new_mf = *Map.Field(pos);
if ((mf.Flags & MapFieldBridge) && !unit.Type->BoolFlag[BRIDGE_INDEX].value && unit.Type->UnitType == UnitTypeLand) {
std::vector<CUnit *> table;
Select(unit.tilePos, unit.tilePos, table);
for (size_t i = 0; i != table.size(); ++i) {
if (!table[i]->Removed && table[i]->Type->BoolFlag[BRIDGE_INDEX].value && table[i]->CanMove()) {
CommandStopUnit(*table[i]); //always stop the raft if a new command is issued
}
}
}
//Wyrmgus end
COrderPtr *order;
//Wyrmgus start
// if (!unit.Type->CanAttack) {
if (!unit.CanAttack()) {
//Wyrmgus end
ClearNewAction(unit);
order = &unit.NewOrder;
} else {
order = GetNextOrder(unit, flush);
if (order == NULL) {
return;
}
}
if (target && target->IsAlive()) {
*order = COrder::NewActionAttack(unit, *target);
} else {
*order = COrder::NewActionAttack(unit, pos);
}
ClearSavedAction(unit);
}
/**
** Unit dies!
**
** @param unit The unit which dies.
*/
global void HandleActionDie(Unit* unit)
{
//
// Show death animation
//
if( unit->Type->Animations && unit->Type->Animations->Die ) {
UnitShowAnimation(unit,unit->Type->Animations->Die);
} else {
// some units has no death animation
unit->Reset=unit->Wait=1;
}
//
// Die sequence terminated, generate corpse.
//
if( unit->Reset ) {
DebugLevel3("Die complete %d\n" _C_ UnitNumber(unit));
if( !unit->Type->CorpseType ) {
UnitMarkSeen(unit);
ReleaseUnit(unit);
return;
}
#ifdef NEW_FOW
//Fixes sight from death
MapUnmarkSight(unit->Player,unit->X,unit->Y,unit->CurrentSightRange);
//unit->CurrentSightRange=unit->Type->Stats->SightRange;
#endif
unit->State=unit->Type->CorpseScript;
unit->Type=unit->Type->CorpseType;
CommandStopUnit(unit); // This clears all order queues
IfDebug(
if( unit->Orders[0].Action!=UnitActionDie ) {
DebugLevel0Fn("Reset to die is really needed\n");
}
);
/**
** Execute a command (from network).
**
** @param msgnr Network message type
** @param unum Unit number (slot) that receive the command.
** @param x optional X map position.
** @param y optional y map position.
** @param dstnr optional destination unit.
*/
void ExecCommand(unsigned char msgnr, UnitRef unum,
unsigned short x, unsigned short y, UnitRef dstnr)
{
CUnit &unit = UnitManager.GetSlotUnit(unum);
const Vec2i pos(x, y);
const int arg1 = x;
const int arg2 = y;
//
// Check if unit is already killed?
//
if (unit.Destroyed) {
DebugPrint(" destroyed unit skipping %d\n" _C_ UnitNumber(unit));
return;
}
Assert(unit.Type);
const int status = (msgnr & 0x80) >> 7;
// Note: destroyed destination unit is handled by the action routines.
switch (msgnr & 0x7F) {
case MessageSync:
return;
case MessageQuit:
return;
case MessageChat:
return;
case MessageCommandStop:
CommandLog("stop", &unit, FlushCommands, -1, -1, NoUnitP, NULL, -1);
CommandStopUnit(unit);
break;
case MessageCommandStand:
CommandLog("stand-ground", &unit, status, -1, -1, NoUnitP, NULL, -1);
CommandStandGround(unit, status);
break;
case MessageCommandDefend: {
if (dstnr != (unsigned short)0xFFFF) {
CUnit &dest = UnitManager.GetSlotUnit(dstnr);
Assert(dest.Type);
CommandLog("defend", &unit, status, -1, -1, &dest, NULL, -1);
CommandDefend(unit, dest, status);
}
break;
}
case MessageCommandFollow: {
if (dstnr != (unsigned short)0xFFFF) {
CUnit &dest = UnitManager.GetSlotUnit(dstnr);
Assert(dest.Type);
CommandLog("follow", &unit, status, -1, -1, &dest, NULL, -1);
CommandFollow(unit, dest, status);
}
break;
}
case MessageCommandMove:
//Wyrmgus start
// CommandLog("move", &unit, status, pos.x, pos.y, NoUnitP, NULL, -1);
// CommandMove(unit, pos, status);
if (!unit.CanMove()) { //FIXME: find better way to identify whether the unit should move or set a rally point
CommandLog("rally-point", &unit, status, pos.x, pos.y, NoUnitP, NULL, -1);
CommandRallyPoint(unit, pos);
} else {
CommandLog("move", &unit, status, pos.x, pos.y, NoUnitP, NULL, -1);
CommandMove(unit, pos, status);
}
//Wyrmgus end
break;
//Wyrmgus start
case MessageCommandPickUp: {
if (dstnr != (unsigned short)0xFFFF) {
CUnit &dest = UnitManager.GetSlotUnit(dstnr);
Assert(dest.Type);
CommandLog("pick-up", &unit, status, -1, -1, &dest, NULL, -1);
CommandPickUp(unit, dest, status);
}
break;
}
//Wyrmgus end
case MessageCommandRepair: {
CUnit *dest = NoUnitP;
if (dstnr != (unsigned short)0xFFFF) {
dest = &UnitManager.GetSlotUnit(dstnr);
Assert(dest && dest->Type);
}
CommandLog("repair", &unit, status, pos.x, pos.y, dest, NULL, -1);
CommandRepair(unit, pos, dest, status);
break;
}
case MessageCommandAutoRepair:
CommandLog("auto-repair", &unit, status, arg1, arg2, NoUnitP, NULL, 0);
CommandAutoRepair(unit, arg1);
break;
case MessageCommandAttack: {
CUnit *dest = NoUnitP;
if (dstnr != (unsigned short)0xFFFF) {
dest = &UnitManager.GetSlotUnit(dstnr);
Assert(dest && dest->Type);
}
CommandLog("attack", &unit, status, pos.x, pos.y, dest, NULL, -1);
CommandAttack(unit, pos, dest, status);
break;
}
case MessageCommandGround:
CommandLog("attack-ground", &unit, status, pos.x, pos.y, NoUnitP, NULL, -1);
CommandAttackGround(unit, pos, status);
break;
//Wyrmgus start
case MessageCommandUse: {
if (dstnr != (unsigned short)0xFFFF) {
CUnit &dest = UnitManager.GetSlotUnit(dstnr);
Assert(dest.Type);
CommandLog("use", &unit, status, -1, -1, &dest, NULL, -1);
CommandUse(unit, dest, status);
}
break;
}
//Wyrmgus end
case MessageCommandPatrol:
CommandLog("patrol", &unit, status, pos.x, pos.y, NoUnitP, NULL, -1);
CommandPatrolUnit(unit, pos, status);
break;
case MessageCommandBoard: {
if (dstnr != (unsigned short)0xFFFF) {
CUnit &dest = UnitManager.GetSlotUnit(dstnr);
Assert(dest.Type);
CommandLog("board", &unit, status, arg1, arg2, &dest, NULL, -1);
CommandBoard(unit, dest, status);
}
break;
}
case MessageCommandUnload: {
CUnit *dest = NULL;
if (dstnr != (unsigned short)0xFFFF) {
dest = &UnitManager.GetSlotUnit(dstnr);
Assert(dest && dest->Type);
}
CommandLog("unload", &unit, status, pos.x, pos.y, dest, NULL, -1);
CommandUnload(unit, pos, dest, status);
break;
}
case MessageCommandBuild:
CommandLog("build", &unit, status, pos.x, pos.y, NoUnitP, UnitTypes[dstnr]->Ident.c_str(), -1);
CommandBuildBuilding(unit, pos, *UnitTypes[dstnr], status);
break;
case MessageCommandDismiss:
CommandLog("dismiss", &unit, FlushCommands, -1, -1, NULL, NULL, -1);
CommandDismiss(unit);
break;
case MessageCommandResourceLoc:
CommandLog("resource-loc", &unit, status, pos.x, pos.y, NoUnitP, NULL, -1);
CommandResourceLoc(unit, pos, status);
break;
case MessageCommandResource: {
if (dstnr != (unsigned short)0xFFFF) {
CUnit &dest = UnitManager.GetSlotUnit(dstnr);
Assert(dest.Type);
CommandLog("resource", &unit, status, -1, -1, &dest, NULL, -1);
CommandResource(unit, dest, status);
}
break;
}
case MessageCommandReturn: {
CUnit *dest = (dstnr != (unsigned short)0xFFFF) ? &UnitManager.GetSlotUnit(dstnr) : NULL;
CommandLog("return", &unit, status, -1, -1, dest, NULL, -1);
CommandReturnGoods(unit, dest, status);
break;
}
case MessageCommandTrain:
//Wyrmgus start
// CommandLog("train", &unit, status, -1, -1, NoUnitP, UnitTypes[dstnr]->Ident.c_str(), -1);
// CommandTrainUnit(unit, *UnitTypes[dstnr], status);
CommandLog("train", &unit, status, -1, -1, NoUnitP, UnitTypes[dstnr]->Ident.c_str(), arg1); // use X as a way to mark the player
CommandTrainUnit(unit, *UnitTypes[dstnr], arg1, status);
//Wyrmgus end
break;
case MessageCommandCancelTrain:
// We need (short)x for the last slot -1
if (dstnr != (unsigned short)0xFFFF) {
CommandLog("cancel-train", &unit, FlushCommands, -1, -1, NoUnitP,
UnitTypes[dstnr]->Ident.c_str(), (short)x);
CommandCancelTraining(unit, (short)x, UnitTypes[dstnr]);
} else {
CommandLog("cancel-train", &unit, FlushCommands, -1, -1, NoUnitP, NULL, (short)x);
CommandCancelTraining(unit, (short)x, NULL);
}
break;
case MessageCommandUpgrade:
//Wyrmgus start
/*
CommandLog("upgrade-to", &unit, status, -1, -1, NoUnitP,
UnitTypes[dstnr]->Ident.c_str(), -1);
CommandUpgradeTo(unit, *UnitTypes[dstnr], status);
break;
*/
if (arg1 == 2) { //use X as a way to mark whether this is an upgrade or a transformation
CommandLog("transform-into", &unit, status, -1, -1, NoUnitP,
UnitTypes[dstnr]->Ident.c_str(), -1);
CommandTransformIntoType(unit, *UnitTypes[dstnr]);
} else {
CommandLog("upgrade-to", &unit, status, -1, -1, NoUnitP,
UnitTypes[dstnr]->Ident.c_str(), -1);
CommandUpgradeTo(unit, *UnitTypes[dstnr], status);
}
break;
//Wyrmgus end
case MessageCommandCancelUpgrade:
CommandLog("cancel-upgrade-to", &unit, FlushCommands, -1, -1, NoUnitP, NULL, -1);
CommandCancelUpgradeTo(unit);
break;
case MessageCommandResearch:
CommandLog("research", &unit, status, -1, -1, NoUnitP,
AllUpgrades[arg1]->Ident.c_str(), -1);
CommandResearch(unit, *AllUpgrades[arg1], status);
break;
case MessageCommandCancelResearch:
CommandLog("cancel-research", &unit, FlushCommands, -1, -1, NoUnitP, NULL, -1);
CommandCancelResearch(unit);
break;
//Wyrmgus start
case MessageCommandQuest: {
CommandLog("quest", &unit, 0, 0, 0, NoUnitP, Quests[arg1]->Ident.c_str(), -1);
CommandQuest(unit, Quests[arg1]);
break;
}
case MessageCommandBuy: {
if (dstnr != (unsigned short)0xFFFF) {
CUnit &dest = UnitManager.GetSlotUnit(dstnr);
Assert(dest.Type);
CommandLog("buy", &unit, 0, -1, -1, &dest, NULL, arg1);
CommandBuy(unit, &dest, arg1);
}
break;
}
//Wyrmgus end
default: {
int id = (msgnr & 0x7f) - MessageCommandSpellCast;
if (arg2 != (unsigned short)0xFFFF) {
CUnit *dest = NULL;
if (dstnr != (unsigned short)0xFFFF) {
dest = &UnitManager.GetSlotUnit(dstnr);
Assert(dest && dest->Type);
}
CommandLog("spell-cast", &unit, status, pos.x, pos.y, dest, NULL, id);
CommandSpellCast(unit, pos, dest, *SpellTypeTable[id], status);
} else {
CommandLog("auto-spell-cast", &unit, status, arg1, -1, NoUnitP, NULL, id);
CommandAutoSpellCast(unit, id, arg1);
}
break;
}
}
}
/* virtual */ void COrder_Follow::Execute(CUnit &unit)
{
if (unit.Wait) {
if (!unit.Waiting) {
unit.Waiting = 1;
unit.WaitBackup = unit.Anim;
}
//Wyrmgus start
// UnitShowAnimation(unit, unit.Type->Animations->Still);
UnitShowAnimation(unit, unit.GetAnimations()->Still);
//Wyrmgus end
unit.Wait--;
return;
}
if (unit.Waiting) {
unit.Anim = unit.WaitBackup;
unit.Waiting = 0;
}
CUnit *goal = this->GetGoal();
// Reached target
if (this->State == State_TargetReached) {
if (!goal || !goal->IsVisibleAsGoal(*unit.Player)) {
DebugPrint("Goal gone\n");
this->Finished = true;
return ;
}
// Don't follow after immobile units
if (goal && goal->CanMove() == false) {
this->Finished = true;
return;
}
//Wyrmgus start
// if (goal->tilePos == this->goalPos) {
if (goal->tilePos == this->goalPos && goal->MapLayer == this->MapLayer) {
//Wyrmgus end
// Move to the next order
if (unit.Orders.size() > 1) {
this->Finished = true;
return ;
}
unit.Wait = 10;
if (this->Range > 1) {
this->Range = 1;
this->State = State_Init;
}
return ;
}
this->State = State_Init;
}
if (this->State == State_Init) { // first entry
this->State = State_Initialized;
}
switch (DoActionMove(unit)) { // reached end-point?
case PF_UNREACHABLE:
//Wyrmgus start
if ((Map.Field(unit.tilePos, unit.MapLayer)->Flags & MapFieldBridge) && !unit.Type->BoolFlag[BRIDGE_INDEX].value && unit.Type->UnitType == UnitTypeLand) {
std::vector<CUnit *> table;
Select(unit.tilePos, unit.tilePos, table, unit.MapLayer);
for (size_t i = 0; i != table.size(); ++i) {
if (!table[i]->Removed && table[i]->Type->BoolFlag[BRIDGE_INDEX].value && table[i]->CanMove()) {
if (table[i]->CurrentAction() == UnitActionStill) {
CommandStopUnit(*table[i]);
CommandMove(*table[i], this->HasGoal() ? this->GetGoal()->tilePos : this->goalPos, FlushCommands, this->HasGoal() ? this->GetGoal()->MapLayer : this->MapLayer);
}
return;
}
}
}
//Wyrmgus end
// Some tries to reach the goal
this->Range++;
break;
case PF_REACHED: {
if (!goal) { // goal has died
this->Finished = true;
return ;
}
// Handle Teleporter Units
// FIXME: BAD HACK
// goal shouldn't be busy and portal should be alive
if (goal->Type->BoolFlag[TELEPORTER_INDEX].value && goal->Goal && goal->Goal->IsAlive() && unit.MapDistanceTo(*goal) <= 1) {
if (!goal->IsIdle()) { // wait
unit.Wait = 10;
return;
}
// Check if we have enough mana
if (goal->Goal->Type->TeleportCost > goal->Variable[MANA_INDEX].Value) {
this->Finished = true;
return;
} else {
goal->Variable[MANA_INDEX].Value -= goal->Goal->Type->TeleportCost;
}
// Everything is OK, now teleport the unit
unit.Remove(NULL);
if (goal->Type->TeleportEffectIn) {
goal->Type->TeleportEffectIn->pushPreamble();
goal->Type->TeleportEffectIn->pushInteger(UnitNumber(unit));
goal->Type->TeleportEffectIn->pushInteger(UnitNumber(*goal));
goal->Type->TeleportEffectIn->pushInteger(unit.GetMapPixelPosCenter().x);
goal->Type->TeleportEffectIn->pushInteger(unit.GetMapPixelPosCenter().y);
goal->Type->TeleportEffectIn->run();
}
unit.tilePos = goal->Goal->tilePos;
//Wyrmgus start
unit.MapLayer = goal->Goal->MapLayer;
//Wyrmgus end
DropOutOnSide(unit, unit.Direction, NULL);
// FIXME: we must check if the units supports the new order.
CUnit &dest = *goal->Goal;
if (dest.Type->TeleportEffectOut) {
dest.Type->TeleportEffectOut->pushPreamble();
dest.Type->TeleportEffectOut->pushInteger(UnitNumber(unit));
dest.Type->TeleportEffectOut->pushInteger(UnitNumber(dest));
dest.Type->TeleportEffectOut->pushInteger(unit.GetMapPixelPosCenter().x);
dest.Type->TeleportEffectOut->pushInteger(unit.GetMapPixelPosCenter().y);
dest.Type->TeleportEffectOut->run();
}
if (dest.NewOrder == NULL
|| (dest.NewOrder->Action == UnitActionResource && !unit.Type->BoolFlag[HARVESTER_INDEX].value)
//Wyrmgus start
// || (dest.NewOrder->Action == UnitActionAttack && !unit.Type->CanAttack)
|| (dest.NewOrder->Action == UnitActionAttack && !unit.CanAttack(true))
//Wyrmgus end
|| (dest.NewOrder->Action == UnitActionBoard && unit.Type->UnitType != UnitTypeLand)) {
this->Finished = true;
return ;
} else {
if (dest.NewOrder->HasGoal()) {
if (dest.NewOrder->GetGoal()->Destroyed) {
delete dest.NewOrder;
dest.NewOrder = NULL;
this->Finished = true;
return ;
}
unit.Orders.insert(unit.Orders.begin() + 1, dest.NewOrder->Clone());
this->Finished = true;
return ;
}
}
}
this->goalPos = goal->tilePos;
//Wyrmgus start
this->MapLayer = goal->MapLayer;
//Wyrmgus end
this->State = State_TargetReached;
}
// FALL THROUGH
default:
break;
}
// Target destroyed?
if (goal && !goal->IsVisibleAsGoal(*unit.Player)) {
DebugPrint("Goal gone\n");
this->goalPos = goal->tilePos + goal->Type->GetHalfTileSize();
//Wyrmgus start
this->MapLayer = goal->MapLayer;
//Wyrmgus end
this->ClearGoal();
goal = NULL;
}
if (unit.Anim.Unbreakable) {
return ;
}
// If our leader is dead or stops or attacks:
// Attack any enemy in reaction range.
// If don't set the goal, the unit can than choose a
// better goal if moving nearer to enemy.
//Wyrmgus start
// if (unit.Type->CanAttack
if (unit.CanAttack()
//Wyrmgus end
&& (!goal || goal->CurrentAction() == UnitActionAttack || goal->CurrentAction() == UnitActionStill)) {
CUnit *target = AttackUnitsInReactRange(unit);
if (target) {
// Save current command to come back.
COrder *savedOrder = NULL;
if (unit.CanStoreOrder(unit.CurrentOrder())) {
savedOrder = this->Clone();
}
this->Finished = true;
//Wyrmgus start
// unit.Orders.insert(unit.Orders.begin() + 1, COrder::NewActionAttack(unit, target->tilePos));
unit.Orders.insert(unit.Orders.begin() + 1, COrder::NewActionAttack(unit, target->tilePos, target->MapLayer));
//Wyrmgus end
if (savedOrder != NULL) {
unit.SavedOrder = savedOrder;
}
}
}
}
/* virtual */ void COrder_Defend::Execute(CUnit &unit)
{
if (unit.Wait) {
if (!unit.Waiting) {
unit.Waiting = 1;
unit.WaitBackup = unit.Anim;
}
//Wyrmgus start
// UnitShowAnimation(unit, unit.Type->Animations->Still);
UnitShowAnimation(unit, unit.GetAnimations()->Still);
//Wyrmgus end
unit.Wait--;
return;
}
if (unit.Waiting) {
unit.Anim = unit.WaitBackup;
unit.Waiting = 0;
}
CUnit *goal = this->GetGoal();
if (this->State == State_Init) {
if (!goal || !goal->IsVisibleAsGoal(*unit.Player)) {
this->Finished = true;
return;
}
this->State = State_MovingToTarget;
} else if (this->State == State_Defending) {
if (!goal || !goal->IsVisibleAsGoal(*unit.Player)) {
this->Finished = true;
return;
}
}
if (!unit.Anim.Unbreakable) {
if (AutoCast(unit) || AutoAttack(unit) || AutoRepair(unit)) {
return;
}
}
switch (DoActionMove(unit)) {
case PF_UNREACHABLE:
//Wyrmgus start
//if is unreachable and is on a raft, see if the raft can move closer to the enemy
if ((Map.Field(unit.tilePos)->Flags & MapFieldBridge) && !unit.Type->BoolFlag[BRIDGE_INDEX].value && unit.Type->UnitType == UnitTypeLand) {
std::vector<CUnit *> table;
Select(unit.tilePos, unit.tilePos, table);
for (size_t i = 0; i != table.size(); ++i) {
if (!table[i]->Removed && table[i]->Type->BoolFlag[BRIDGE_INDEX].value && table[i]->CanMove()) {
if (table[i]->CurrentAction() == UnitActionStill) {
CommandStopUnit(*table[i]);
CommandMove(*table[i], this->HasGoal() ? this->GetGoal()->tilePos : this->goalPos, FlushCommands);
}
return;
}
}
}
//Wyrmgus end
// Some tries to reach the goal
this->Range++;
break;
case PF_REACHED: {
if (!goal || !goal->IsVisibleAsGoal(*unit.Player)) { // goal has died
this->Finished = true;
return;
}
// Now defend the goal
this->goalPos = goal->tilePos;
this->State = State_Defending;
}
default:
break;
}
// Target destroyed?
if (goal && !goal->IsVisibleAsGoal(*unit.Player)) {
DebugPrint("Goal gone\n");
this->goalPos = goal->tilePos + goal->Type->GetHalfTileSize();
this->ClearGoal();
goal = NULL;
if (this->State == State_Defending) {
this->Finished = true;
return;
}
}
}
/**
** Move unit to terrain.
**
** @return 1 if reached, -1 if unreacheable, 0 if on the way.
*/
int COrder_Resource::MoveToResource_Terrain(CUnit &unit)
{
Vec2i pos = this->goalPos;
// Wood gone, look somewhere else.
if ((Map.Info.IsPointOnMap(pos) == false || Map.Field(pos)->IsTerrainResourceOnMap(CurrentResource) == false)
&& (!unit.IX) && (!unit.IY)) {
//Wyrmgus start
// if (!FindTerrainType(unit.Type->MovementMask, MapFieldForest, 16, *unit.Player, this->goalPos, &pos)) {
if ((this->CurrentResource == WoodCost && !FindTerrainType(unit.Type->MovementMask, MapFieldForest, 16, *unit.Player, this->goalPos, &pos)) || (this->CurrentResource == StoneCost && !FindTerrainType(unit.Type->MovementMask, MapFieldRocks, 16, *unit.Player, this->goalPos, &pos))) {
//Wyrmgus end
// no wood in range
return -1;
} else {
this->goalPos = pos;
}
}
switch (DoActionMove(unit)) {
case PF_UNREACHABLE:
//Wyrmgus start
//if is unreachable and is on a raft, see if the raft can move closer
if ((Map.Field(unit.tilePos)->Flags & MapFieldBridge) && !unit.Type->BoolFlag[BRIDGE_INDEX].value && unit.Type->UnitType == UnitTypeLand) {
std::vector<CUnit *> table;
Select(unit.tilePos, unit.tilePos, table);
for (size_t i = 0; i != table.size(); ++i) {
if (!table[i]->Removed && table[i]->Type->BoolFlag[BRIDGE_INDEX].value && table[i]->CanMove()) {
if (table[i]->CurrentAction() == UnitActionStill) {
CommandStopUnit(*table[i]);
CommandMove(*table[i], this->HasGoal() ? this->GetGoal()->tilePos : this->goalPos, FlushCommands);
}
return 0;
}
}
}
//Wyrmgus end
unit.Wait = 10;
if (unit.Player->AiEnabled) {
this->Range++;
if (this->Range >= 5) {
this->Range = 0;
AiCanNotMove(unit);
}
}
//Wyrmgus start
// if (FindTerrainType(unit.Type->MovementMask, MapFieldForest, 9999, *unit.Player, unit.tilePos, &pos)) {
if ((this->CurrentResource == WoodCost && FindTerrainType(unit.Type->MovementMask, MapFieldForest, 9999, *unit.Player, unit.tilePos, &pos)) || (this->CurrentResource == StoneCost && FindTerrainType(unit.Type->MovementMask, MapFieldRocks, 9999, *unit.Player, unit.tilePos, &pos))) {
//Wyrmgus end
this->goalPos = pos;
DebugPrint("Found a better place to harvest %d,%d\n" _C_ pos.x _C_ pos.y);
// FIXME: can't this overflow? It really shouldn't, since
// x and y are really supossed to be reachable, checked thorugh a flood fill.
// I don't know, sometimes stuff happens.
return 0;
}
return -1;
case PF_REACHED:
return 1;
case PF_WAIT:
if (unit.Player->AiEnabled) {
this->Range++;
if (this->Range >= 5) {
this->Range = 0;
AiCanNotMove(unit);
}
}
default:
return 0;
}
}
/**
** Move to resource depot
**
** @param unit Pointer to unit.
**
** @return TRUE if reached, otherwise FALSE.
*/
int COrder_Resource::MoveToDepot(CUnit &unit)
{
const ResourceInfo &resinfo = *unit.Type->ResInfo[this->CurrentResource];
CUnit &goal = *this->GetGoal();
CPlayer &player = *unit.Player;
Assert(&goal);
switch (DoActionMove(unit)) { // reached end-point?
case PF_UNREACHABLE:
//Wyrmgus start
//if is unreachable and is on a raft, see if the raft can move closer
if ((Map.Field(unit.tilePos)->Flags & MapFieldBridge) && !unit.Type->BoolFlag[BRIDGE_INDEX].value && unit.Type->UnitType == UnitTypeLand) {
std::vector<CUnit *> table;
Select(unit.tilePos, unit.tilePos, table);
for (size_t i = 0; i != table.size(); ++i) {
if (!table[i]->Removed && table[i]->Type->BoolFlag[BRIDGE_INDEX].value && table[i]->CanMove()) {
if (table[i]->CurrentAction() == UnitActionStill) {
CommandStopUnit(*table[i]);
CommandMove(*table[i], this->HasGoal() ? this->GetGoal()->tilePos : this->goalPos, FlushCommands);
}
return 0;
}
}
}
//Wyrmgus end
return -1;
case PF_REACHED:
break;
case PF_WAIT:
if (unit.Player->AiEnabled) {
this->Range++;
if (this->Range >= 5) {
this->Range = 0;
AiCanNotMove(unit);
}
}
default:
if (unit.Anim.Unbreakable || goal.IsVisibleAsGoal(player)) {
return 0;
}
break;
}
//
// Target is dead, stop getting resources.
//
if (!goal.IsVisibleAsGoal(player)) {
DebugPrint("%d: Worker %d report: Destroyed depot\n" _C_ player.Index _C_ UnitNumber(unit));
unit.CurrentOrder()->ClearGoal();
CUnit *depot = FindDeposit(unit, 1000, unit.CurrentResource);
if (depot) {
UnitGotoGoal(unit, depot, SUB_MOVE_TO_DEPOT);
DebugPrint("%d: Worker %d report: Going to new deposit.\n" _C_ player.Index _C_ UnitNumber(unit));
} else {
DebugPrint("%d: Worker %d report: Can't find a new resource deposit.\n"
_C_ player.Index _C_ UnitNumber(unit));
// FIXME: perhaps we should choose an alternative
this->Finished = true;
}
return 0;
}
// If resource depot is still under construction, wait!
if (goal.CurrentAction() == UnitActionBuilt) {
unit.Wait = 10;
return 0;
}
this->ClearGoal();
unit.Wait = resinfo.WaitAtDepot;
// Place unit inside the depot
if (unit.Wait) {
int selected = unit.Selected;
unit.Remove(&goal);
if (selected && !Preference.DeselectInMine) {
unit.Removed = 0;
SelectUnit(unit);
SelectionChanged();
unit.Removed = 1;
}
unit.Anim.CurrAnim = NULL;
}
// Update resource.
const int rindex = resinfo.FinalResource;
//Wyrmgus start
// player.ChangeResource(rindex, (unit.ResourcesHeld * player.Incomes[rindex]) / 100, true);
// player.TotalResources[rindex] += (unit.ResourcesHeld * player.Incomes[rindex]) / 100;
player.ChangeResource(rindex, (unit.ResourcesHeld * resinfo.FinalResourceConversionRate / 100 * player.Incomes[rindex]) / 100, true);
player.TotalResources[rindex] += (unit.ResourcesHeld * resinfo.FinalResourceConversionRate / 100 * player.Incomes[rindex]) / 100;
//Wyrmgus end
unit.ResourcesHeld = 0;
unit.CurrentResource = 0;
if (unit.Wait) {
//Wyrmgus start
// unit.Wait /= std::max(1, unit.Player->SpeedResourcesReturn[resinfo.ResourceId] / SPEEDUP_FACTOR);
unit.Wait /= std::max(1, (unit.Player->SpeedResourcesReturn[resinfo.ResourceId] + goal.Variable[TIMEEFFICIENCYBONUS_INDEX].Value) / SPEEDUP_FACTOR);
//Wyrmgus end
if (unit.Wait) {
unit.Wait--;
}
}
return 1;
}
/* virtual */ void CAnimation_SetVar::Action(CUnit &unit, int &/*move*/, int /*scale*/) const
{
Assert(unit.Anim.Anim == this);
char arg1[128];
CUnit *goal = &unit;
strcpy(arg1, this->varStr.c_str());
if (this->unitSlotStr.empty() == false) {
switch (this->unitSlotStr[0]) {
case 'l': // last created unit
goal = UnitManager.lastCreatedUnit();
break;
case 't': // target unit
goal = unit.CurrentOrder()->GetGoal();
break;
case 's': // unit self (no use)
goal = &unit;
break;
}
}
if (!goal) {
return;
}
char *next = strchr(arg1, '.');
if (next == NULL) {
// Special case for non-CVariable variables
if (!strcmp(arg1, "DamageType")) {
int death = ExtraDeathIndex(this->valueStr.c_str());
if (death == ANIMATIONS_DEATHTYPES) {
fprintf(stderr, "Incorrect death type : %s \n" _C_ this->valueStr.c_str());
Exit(1);
return;
}
goal->Type->DamageType = this->valueStr;
return;
}
fprintf(stderr, "Need also specify the variable '%s' tag \n" _C_ arg1);
Exit(1);
return;
} else {
*next = '\0';
}
const int index = UnitTypeVar.VariableNameLookup[arg1];// User variables
if (index == -1) {
fprintf(stderr, "Bad variable name '%s'\n" _C_ arg1);
Exit(1);
return;
}
const int rop = ParseAnimInt(unit, this->valueStr.c_str());
int value = 0;
if (!strcmp(next + 1, "Value")) {
value = goal->Variable[index].Value;
} else if (!strcmp(next + 1, "Max")) {
value = goal->Variable[index].Max;
} else if (!strcmp(next + 1, "Increase")) {
value = goal->Variable[index].Increase;
} else if (!strcmp(next + 1, "Enable")) {
value = goal->Variable[index].Enable;
} else if (!strcmp(next + 1, "Percent")) {
value = goal->Variable[index].Value * 100 / goal->Variable[index].Max;
}
switch (this->mod) {
case modAdd:
value += rop;
break;
case modSub:
value -= rop;
break;
case modMul:
value *= rop;
break;
case modDiv:
if (!rop) {
fprintf(stderr, "Division by zero in AnimationSetVar\n");
Exit(1);
return;
}
value /= rop;
break;
case modMod:
if (!rop) {
fprintf(stderr, "Division by zero in AnimationSetVar\n");
Exit(1);
return;
}
value %= rop;
break;
case modAnd:
value &= rop;
break;
case modOr:
value |= rop;
break;
case modXor:
value ^= rop;
break;
case modNot:
value = !value;
break;
default:
value = rop;
}
if (!strcmp(next + 1, "Value")) {
goal->Variable[index].Value = value;
} else if (!strcmp(next + 1, "Max")) {
goal->Variable[index].Max = value;
} else if (!strcmp(next + 1, "Increase")) {
goal->Variable[index].Increase = value;
} else if (!strcmp(next + 1, "Enable")) {
goal->Variable[index].Enable = value;
} else if (!strcmp(next + 1, "Percent")) {
goal->Variable[index].Value = goal->Variable[index].Max * value / 100;
}
clamp(&goal->Variable[index].Value, 0, goal->Variable[index].Max);
//Wyrmgus start
if (index == ATTACKRANGE_INDEX && goal->Container) {
goal->Container->UpdateContainerAttackRange();
} else if (index == LEVEL_INDEX || index == POINTS_INDEX) {
goal->UpdateXPRequired();
} else if (index == XP_INDEX) {
goal->XPChanged();
} else if (index == STUN_INDEX && goal->Variable[index].Value > 0) { //if unit has become stunned, stop it
CommandStopUnit(*goal);
}
//Wyrmgus end
}