/** ** Check if we can build the building. ** ** @param type Unit that can build the building. ** @param building Building to be build. ** ** @return True if made, false if can't be made. ** ** @note We must check if the dependencies are fulfilled. */ static int AiBuildBuilding(const CUnitType &type, CUnitType &building, int near_x, int near_y) { CUnit *table[UnitMax]; int num = 0; // // Remove all workers on the way building something // const int nunits = FindPlayerUnitsByType(AiPlayer->Player, type, table); for (int i = 0; i < nunits; ++i) { CUnit& unit = *table[i]; int j; for (j = 0; j < unit.OrderCount; ++j) { int action = unit.Orders[j]->Action; if (action == UnitActionBuild || action == UnitActionRepair || action == UnitActionReturnGoods || (action == UnitActionResource && unit.SubAction > 55) /* SUB_START_GATHERING */) { break; } } if (j == unit.OrderCount) { table[num++] = &unit; } } if (num == 0) { // No workers available to build return 0; } CUnit& unit = (num == 1) ? *table[0] : *table[SyncRand() % num]; Vec2i pos; // Find a place to build. if (AiFindBuildingPlace(unit, building, near_x, near_y, &pos)) { CommandBuildBuilding(unit, pos, building, FlushCommands); return 1; } else { //when first worker can't build then rest also won't be able (save CPU) if (near_x != -1 && near_y != -1) { //Crush CPU !!!!! for (int i = 0; i < num && table[i] != &unit; ++i) { // Find a place to build. if (AiFindBuildingPlace(*table[i], building, near_x, near_y, &pos)) { CommandBuildBuilding(*table[i], pos, building, FlushCommands); return 1; } } } } return 0; }
/** ** Send command: Unit builds building at position. ** ** @param unit pointer to unit. ** @param pos map tile position of construction. ** @param what pointer to unit-type of the building. ** @param flush Flag flush all pending commands. */ void SendCommandBuildBuilding(CUnit &unit, const Vec2i &pos, CUnitType &what, int flush) { if (!IsNetworkGame()) { CommandLog("build", &unit, flush, pos.x, pos.y, NoUnitP, what.Ident.c_str(), -1); CommandBuildBuilding(unit, pos, what, flush); } else { NetworkSendCommand(MessageCommandBuild, unit, pos.x, pos.y, NoUnitP, &what, flush); } }
/** ** Check if we can build the building. ** ** @param type Unit that can build the building. ** @param building Building to be build. ** ** @return True if made, false if can't be made. ** ** @note We must check if the dependencies are fulfilled. */ static int AiBuildBuilding(const CUnitType &type, CUnitType &building, const Vec2i &nearPos) { std::vector<CUnit *> table; FindPlayerUnitsByType(*AiPlayer->Player, type, table); int num = 0; // Remove all workers on the way building something for (size_t i = 0; i != table.size(); ++i) { CUnit &unit = *table[i]; if (IsAlreadyWorking(unit) == false) { table[num++] = &unit; } } if (num == 0) { // No workers available to build return 0; } CUnit &unit = (num == 1) ? *table[0] : *table[SyncRand() % num]; Vec2i pos; // Find a place to build. if (AiFindBuildingPlace(unit, building, nearPos, &pos)) { CommandBuildBuilding(unit, pos, building, FlushCommands); return 1; } else { //when first worker can't build then rest also won't be able (save CPU) if (Map.Info.IsPointOnMap(nearPos)) { //Crush CPU !!!!! for (int i = 0; i < num && table[i] != &unit; ++i) { // Find a place to build. if (AiFindBuildingPlace(*table[i], building, nearPos, &pos)) { CommandBuildBuilding(*table[i], pos, building, FlushCommands); return 1; } } } } return 0; }
/** ** 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; } } }
//Wyrmgus start //static int AiAssignHarvesterFromUnit(CUnit &unit, int resource) static int AiAssignHarvesterFromUnit(CUnit &unit, int resource, int resource_range) //Wyrmgus end { // Try to find the nearest depot first. CUnit *depot = FindDeposit(unit, 1000, resource); // Find a resource to harvest from. //Wyrmgus start // CUnit *mine = UnitFindResource(unit, depot ? *depot : unit, 1000, resource, true); CUnit *mine = UnitFindResource(unit, depot ? *depot : unit, resource_range, resource, true, NULL, false); //Wyrmgus end if (mine) { //Wyrmgus start // CommandResource(unit, *mine, FlushCommands); // return 1; if (mine->Type->BoolFlag[CANHARVEST_INDEX].value) { CommandResource(unit, *mine, FlushCommands); return 1; } else { // if the resource isn't readily harvestable (but is a deposit), build a mine there const int n = AiHelpers.Refinery[resource - 1].size(); for (int i = 0; i < n; ++i) { CUnitType &type = *AiHelpers.Refinery[resource - 1][i]; if (CanBuildUnitType(&unit, type, mine->tilePos, 1, true, mine->MapLayer)) { CommandBuildBuilding(unit, mine->tilePos, type, FlushCommands, mine->MapLayer); return 1; } } } //Wyrmgus end } //Wyrmgus start /* int exploremask = 0; for (size_t i = 0; i != UnitTypes.size(); ++i) { const CUnitType *type = UnitTypes[i]; if (type && type->GivesResource == resource) { switch (type->UnitType) { case UnitTypeLand: exploremask |= MapFieldLandUnit; break; case UnitTypeFly: exploremask |= MapFieldAirUnit; break; //Wyrmgus start case UnitTypeFlyLow: exploremask |= MapFieldLandUnit; break; //Wyrmgus end case UnitTypeNaval: exploremask |= MapFieldSeaUnit; break; default: Assert(0); } } } // Ask the AI to explore AiExplore(unit.tilePos, exploremask); */ //Wyrmgus end // Failed. return 0; }