/**
** Unit upgrades unit!
**
** @param unit Pointer to unit.
*/
global void HandleActionUpgradeTo(Unit* unit)
{
Player* player;
UnitType* type;
const UnitStats* stats;
DebugLevel3Fn(" %d\n" _C_ UnitNumber(unit));
player=unit->Player;
if( !unit->SubAction ) { // first entry
unit->Data.UpgradeTo.Ticks=0;
unit->SubAction=1;
}
type=unit->Orders[0].Type;
stats=&type->Stats[player->Player];
UnitMarkSeen(unit);
// FIXME: Should count down here
unit->Data.UpgradeTo.Ticks+=SpeedUpgrade;
if( unit->Data.UpgradeTo.Ticks>=stats->Costs[TimeCost] ) {
unit->HP+=stats->HitPoints-unit->Type->Stats[player->Player].HitPoints;
// don't have such unit now
player->UnitTypesCount[unit->Type->Type]--;
unit->Type=type;
unit->Stats=(UnitStats*)stats;
// and we have new one...
player->UnitTypesCount[unit->Type->Type]++;
UpdateForNewUnit(unit,1);
NotifyPlayer(player,NotifyGreen,unit->X,unit->Y,
"Upgrade to %s complete",unit->Type->Name );
if( unit->Player->Ai ) {
AiUpgradeToComplete(unit,type);
}
unit->Reset=unit->Wait=1;
unit->Orders[0].Action=UnitActionStill;
unit->SubAction=0;
//
// Update possible changed buttons.
//
if( IsOnlySelected(unit) ) {
UpdateButtonPanel();
MustRedraw|=RedrawPanels;
} else if( player==ThisPlayer ) {
UpdateButtonPanel();
MustRedraw|=RedrawInfoPanel;
}
return;
}
if( IsOnlySelected(unit) ) {
MustRedraw|=RedrawInfoPanel;
}
unit->Reset=1;
unit->Wait=CYCLES_PER_SECOND/6;
}
/**
** Create a unit and place it on the map
**
** @param l Lua state.
**
** @return Returns the slot number of the made unit.
*/
static int CclCreateUnit(lua_State *l)
{
LuaCheckArgs(l, 3);
lua_pushvalue(l, 1);
CUnitType *unittype = CclGetUnitType(l);
if (unittype == NULL) {
LuaError(l, "Bad unittype");
}
lua_pop(l, 1);
Vec2i ipos;
CclGetPos(l, &ipos.x, &ipos.y, 3);
lua_pushvalue(l, 2);
const int playerno = TriggerGetPlayer(l);
lua_pop(l, 1);
if (playerno == -1) {
printf("CreateUnit: You cannot use \"any\" in create-unit, specify a player\n");
LuaError(l, "bad player");
return 0;
}
if (Players[playerno].Type == PlayerNobody) {
printf("CreateUnit: player %d does not exist\n", playerno);
LuaError(l, "bad player");
return 0;
}
CUnit *unit = MakeUnit(*unittype, &Players[playerno]);
if (unit == NULL) {
DebugPrint("Unable to allocate unit");
return 0;
} else {
if (UnitCanBeAt(*unit, ipos)
|| (unit->Type->Building && CanBuildUnitType(NULL, *unit->Type, ipos, 0))) {
unit->Place(ipos);
} else {
const int heading = SyncRand() % 256;
unit->tilePos = ipos;
DropOutOnSide(*unit, heading, NULL);
}
UpdateForNewUnit(*unit, 0);
lua_pushnumber(l, UnitNumber(*unit));
return 1;
}
}
/* virtual */ void COrder_Train::Execute(CUnit &unit)
{
AnimateActionTrain(unit);
if (unit.Wait) {
unit.Wait--;
return ;
}
CPlayer &player = *unit.Player;
const CUnitType &nType = *this->Type;
const int cost = nType.Stats[player.Index].Costs[TimeCost];
this->Ticks += std::max(1, player.SpeedTrain / SPEEDUP_FACTOR);
if (this->Ticks < cost) {
unit.Wait = CYCLES_PER_SECOND / 6;
return ;
}
this->Ticks = std::min(this->Ticks, cost);
// Check if enough supply available.
const int food = player.CheckLimits(nType);
if (food < 0) {
if (food == -3 && unit.Player->AiEnabled) {
AiNeedMoreSupply(*unit.Player);
}
unit.Wait = CYCLES_PER_SECOND / 6;
return ;
}
CUnit *newUnit = MakeUnit(nType, &player);
if (newUnit == NULL) { // No more memory :/
player.Notify(NotifyYellow, unit.tilePos, _("Unable to train %s"), nType.Name.c_str());
unit.Wait = CYCLES_PER_SECOND / 6;
return ;
}
// New unit might supply food
UpdateForNewUnit(*newUnit, 0);
// Set life span
if (unit.Type->DecayRate) {
newUnit->TTL = GameCycle + unit.Type->DecayRate * 6 * CYCLES_PER_SECOND;
}
/* Auto Group Add */
if (!unit.Player->AiEnabled && unit.GroupId) {
int num = 0;
while (!(unit.GroupId & (1 << num))) {
++num;
}
AddToGroup(&newUnit, 1, num);
}
DropOutOnSide(*newUnit, LookingW, &unit);
player.Notify(NotifyGreen, newUnit->tilePos, _("New %s ready"), nType.Name.c_str());
if (&player == ThisPlayer) {
PlayUnitSound(*newUnit, VoiceReady);
}
if (unit.Player->AiEnabled) {
AiTrainingComplete(unit, *newUnit);
}
if (unit.NewOrder && unit.NewOrder->HasGoal()
&& unit.NewOrder->GetGoal()->Destroyed) {
delete unit.NewOrder;
unit.NewOrder = NULL;
}
if (CanHandleOrder(*newUnit, unit.NewOrder) == true) {
delete newUnit->Orders[0];
newUnit->Orders[0] = unit.NewOrder->Clone();
} else {
#if 0
// Tell the unit to rigth-click ?
#endif
}
this->Finished = true;
if (IsOnlySelected(unit)) {
UI.ButtonPanel.Update();
}
}
//Wyrmgus start
//static int TransformUnitIntoType(CUnit &unit, const CUnitType &newtype)
int TransformUnitIntoType(CUnit &unit, const CUnitType &newtype)
//Wyrmgus end
{
const CUnitType &oldtype = *unit.Type;
if (&oldtype == &newtype) { // nothing to do
return 1;
}
const Vec2i pos = unit.tilePos + oldtype.GetHalfTileSize() - newtype.GetHalfTileSize();
CUnit *container = unit.Container;
//Wyrmgus start
/*
if (container) {
MapUnmarkUnitSight(unit);
} else {
SaveSelection();
unit.Remove(NULL);
if (!UnitTypeCanBeAt(newtype, pos)) {
unit.Place(unit.tilePos);
RestoreSelection();
// FIXME unit is not modified, try later ?
return 0;
}
}
*/
if (!SaveGameLoading) {
if (container) {
MapUnmarkUnitSight(unit);
} else {
SaveSelection();
unit.Remove(NULL);
if (!UnitTypeCanBeAt(newtype, pos)) {
unit.Place(unit.tilePos);
RestoreSelection();
// FIXME unit is not modified, try later ?
return 0;
}
}
}
//Wyrmgus end
CPlayer &player = *unit.Player;
player.UnitTypesCount[oldtype.Slot]--;
player.UnitTypesCount[newtype.Slot]++;
if (unit.Active) {
player.UnitTypesAiActiveCount[oldtype.Slot]--;
player.UnitTypesAiActiveCount[newtype.Slot]++;
}
//Wyrmgus start
if (unit.Character == NULL) {
player.UnitTypesNonHeroCount[oldtype.Slot]--;
player.UnitTypesNonHeroCount[newtype.Slot]++;
}
//Wyrmgus end
player.Demand += newtype.Stats[player.Index].Variables[DEMAND_INDEX].Value - oldtype.Stats[player.Index].Variables[DEMAND_INDEX].Value;
player.Supply += newtype.Stats[player.Index].Variables[SUPPLY_INDEX].Value - oldtype.Stats[player.Index].Variables[SUPPLY_INDEX].Value;
// Change resource limit
for (int i = 0; i < MaxCosts; ++i) {
if (player.MaxResources[i] != -1) {
player.MaxResources[i] += newtype.Stats[player.Index].Storing[i] - oldtype.Stats[player.Index].Storing[i];
player.SetResource(i, player.StoredResources[i], STORE_BUILDING);
}
}
// adjust Variables with percent.
const CUnitStats &newstats = newtype.Stats[player.Index];
//Wyrmgus start
const CUnitStats &oldstats = oldtype.Stats[player.Index];
//Wyrmgus end
for (unsigned int i = 0; i < UnitTypeVar.GetNumberVariable(); ++i) {
//Wyrmgus start
/*
if (unit.Variable[i].Max && unit.Variable[i].Value) {
unit.Variable[i].Value = newstats.Variables[i].Max *
unit.Variable[i].Value / unit.Variable[i].Max;
} else {
unit.Variable[i].Value = newstats.Variables[i].Value;
}
if (i == KILL_INDEX || i == XP_INDEX) {
unit.Variable[i].Value = unit.Variable[i].Max;
} else {
unit.Variable[i].Max = newstats.Variables[i].Max;
unit.Variable[i].Increase = newstats.Variables[i].Increase;
unit.Variable[i].Enable = newstats.Variables[i].Enable;
}
*/
if (i == LEVEL_INDEX) { //if the unit's level changed in accordance to the difference between the levels of the two unit types, then its level change would be duplicated when leveling up, so let's skip the level variable here
continue;
}
if (unit.Variable[i].Max && unit.Variable[i].Value) {
unit.Variable[i].Value += newstats.Variables[i].Max - oldstats.Variables[i].Max;
} else {
unit.Variable[i].Value += newstats.Variables[i].Value - oldstats.Variables[i].Value;
}
if (i == KILL_INDEX || i == XP_INDEX) {
unit.Variable[i].Value = unit.Variable[i].Max;
} else {
unit.Variable[i].Max += newstats.Variables[i].Max - oldstats.Variables[i].Max;
unit.Variable[i].Increase += newstats.Variables[i].Increase - oldstats.Variables[i].Increase;
unit.Variable[i].Enable = newstats.Variables[i].Enable;
}
//Wyrmgus end
}
//Wyrmgus start
for (size_t i = 0; i < UnitTypes.size(); ++i) {
if (newstats.UnitStock[i] != oldstats.UnitStock[i]) {
unit.UnitStock[i] += newstats.UnitStock[i] - oldstats.UnitStock[i];
unit.UnitStock[i] = std::max(unit.UnitStock[i], 0);
}
}
//Wyrmgus end
//Wyrmgus start
//change variation if upgrading (new unit type may have different variations)
unit.ChooseVariation(&newtype);
for (int i = 0; i < MaxImageLayers; ++i) {
unit.ChooseVariation(&newtype, false, i);
}
//Wyrmgus end
unit.Type = const_cast<CUnitType *>(&newtype);
unit.Stats = &unit.Type->Stats[player.Index];
//Wyrmgus start
//deequip the current equipment if they are incompatible with the new unit type
for (int i = 0; i < MaxItemSlots; ++i) {
for (size_t j = 0; j < unit.EquippedItems[i].size(); ++j) {
if (!unit.CanEquipItemClass(unit.EquippedItems[i][j]->Type->ItemClass)) {
unit.DeequipItem(*unit.EquippedItems[i][j]);
}
}
}
//Wyrmgus end
//Wyrmgus start
//change personal name if new unit type's civilization is different from old unit type's civilization
if (unit.Character == NULL && !oldtype.Civilization.empty() && !newtype.Civilization.empty() && oldtype.Civilization != newtype.Civilization) {
unit.UpdatePersonalName();
}
//Wyrmgus end
if (newtype.CanCastSpell && !unit.AutoCastSpell) {
unit.AutoCastSpell = new char[SpellTypeTable.size()];
unit.SpellCoolDownTimers = new int[SpellTypeTable.size()];
memset(unit.AutoCastSpell, 0, SpellTypeTable.size() * sizeof(char));
memset(unit.SpellCoolDownTimers, 0, SpellTypeTable.size() * sizeof(int));
}
UpdateForNewUnit(unit, 1);
//Wyrmgus start
/*
// Update Possible sight range change
UpdateUnitSightRange(unit);
if (!container) {
unit.Place(pos);
RestoreSelection();
} else {
MapMarkUnitSight(unit);
}
*/
if (!SaveGameLoading) {
// Update Possible sight range change
UpdateUnitSightRange(unit);
if (!container) {
unit.Place(pos);
RestoreSelection();
} else {
MapMarkUnitSight(unit);
//Wyrmgus start
//if unit has a container, update the container's attack range, as the unit's range may have been changed with the upgrade
container->UpdateContainerAttackRange();
//Wyrmgus end
}
}
//Wyrmgus end
//Wyrmgus start
//update the unit's XP required, as its level or points may have changed
unit.UpdateXPRequired();
//Wyrmgus end
//Wyrmgus start
/*
//
// Update possible changed buttons.
//
if (IsOnlySelected(unit) || &player == ThisPlayer) {
// could affect the buttons of any selected unit
SelectedUnitChanged();
}
*/
if (!SaveGameLoading) {
//
// Update possible changed buttons.
//
if (IsOnlySelected(unit) || &player == ThisPlayer) {
// could affect the buttons of any selected unit
SelectedUnitChanged();
}
}
//Wyrmgus end
return 1;
}
static void Finish(COrder_Built &order, CUnit &unit)
{
const CUnitType &type = *unit.Type;
CPlayer &player = *unit.Player;
DebugPrint("%d: Building %s(%s) ready.\n" _C_ player.Index _C_ type.Ident.c_str() _C_ type.Name.c_str());
// HACK: the building is ready now
player.UnitTypesCount[type.Slot]++;
if (unit.Active) {
player.UnitTypesAiActiveCount[type.Slot]++;
}
unit.Constructed = 0;
if (unit.Frame < 0) {
unit.Frame = -1;
} else {
unit.Frame = 0;
}
CUnit *worker = order.GetWorkerPtr();
if (worker != NULL) {
if (type.BoolFlag[BUILDERLOST_INDEX].value) {
// Bye bye worker.
LetUnitDie(*worker);
worker = NULL;
} else { // Drop out the worker.
worker->ClearAction();
DropOutOnSide(*worker, LookingW, &unit);
// If we can harvest from the new building, do it.
if (worker->Type->ResInfo[type.GivesResource]) {
CommandResource(*worker, unit, 0);
}
// If we can reurn goods to a new depot, do it.
if (worker->CurrentResource && worker->ResourcesHeld > 0 && type.CanStore[worker->CurrentResource]) {
CommandReturnGoods(*worker, &unit, 0);
}
}
}
if (type.GivesResource && type.StartingResources != 0) {
// Has StartingResources, Use those
unit.ResourcesHeld = type.StartingResources;
}
player.Notify(NotifyGreen, unit.tilePos, _("New %s done"), type.Name.c_str());
if (&player == ThisPlayer) {
if (type.MapSound.Ready.Sound) {
PlayUnitSound(unit, VoiceReady);
} else if (worker) {
PlayUnitSound(*worker, VoiceWorkCompleted);
} else {
PlayUnitSound(unit, VoiceBuilding);
}
}
if (player.AiEnabled) {
/* Worker can be NULL */
AiWorkComplete(worker, unit);
}
// FIXME: Vladi: this is just a hack to test wall fixing,
// FIXME: also not sure if the right place...
// FIXME: Johns: hardcoded unit-type wall / more races!
if (&type == UnitTypeOrcWall || &type == UnitTypeHumanWall) {
Map.SetWall(unit.tilePos, &type == UnitTypeHumanWall);
unit.Remove(NULL);
UnitLost(unit);
UnitClearOrders(unit);
unit.Release();
return ;
}
UpdateForNewUnit(unit, 0);
// Set the direction of the building if it supports them
if (type.NumDirections > 1 && type.BoolFlag[NORANDOMPLACING_INDEX].value == false) {
if (type.BoolFlag[WALL_INDEX].value) { // Special logic for walls
CorrectWallDirections(unit);
CorrectWallNeighBours(unit);
} else {
unit.Direction = (MyRand() >> 8) & 0xFF; // random heading
}
UnitUpdateHeading(unit);
}
if (IsOnlySelected(unit) || &player == ThisPlayer) {
SelectedUnitChanged();
}
MapUnmarkUnitSight(unit);
unit.CurrentSightRange = unit.Stats->Variables[SIGHTRANGE_INDEX].Max;
MapMarkUnitSight(unit);
order.Finished = true;
}
/**
** Transform a unit in another.
**
** @param unit unit to transform.
** @param newtype new type of the unit.
**
** @return 0 on error, 1 if nothing happens, 2 else.
*/
static int TransformUnitIntoType(CUnit &unit, const CUnitType &newtype)
{
const CUnitType &oldtype = *unit.Type;
if (&oldtype == &newtype) { // nothing to do
return 1;
}
const Vec2i pos = unit.tilePos + oldtype.GetHalfTileSize() - newtype.GetHalfTileSize();
CUnit *container = unit.Container;
if (container) {
MapUnmarkUnitSight(unit);
} else {
SaveSelection();
unit.Remove(NULL);
if (!UnitTypeCanBeAt(newtype, pos)) {
unit.Place(unit.tilePos);
RestoreSelection();
// FIXME unit is not modified, try later ?
return 0;
}
}
CPlayer &player = *unit.Player;
player.UnitTypesCount[oldtype.Slot]--;
player.UnitTypesCount[newtype.Slot]++;
player.Demand += newtype.Demand - oldtype.Demand;
player.Supply += newtype.Supply - oldtype.Supply;
// Change resource limit
for (int i = 0; i < MaxCosts; ++i) {
if (player.MaxResources[i] != -1) {
player.MaxResources[i] += newtype.Stats[player.Index].Storing[i] - oldtype.Stats[player.Index].Storing[i];
player.SetResource(i, player.StoredResources[i], STORE_BUILDING);
}
}
// adjust Variables with percent.
const CUnitStats &newstats = newtype.Stats[player.Index];
for (unsigned int i = 0; i < UnitTypeVar.GetNumberVariable(); ++i) {
if (unit.Variable[i].Max && unit.Variable[i].Value) {
unit.Variable[i].Value = newstats.Variables[i].Max *
unit.Variable[i].Value / unit.Variable[i].Max;
} else {
unit.Variable[i].Value = newstats.Variables[i].Value;
}
unit.Variable[i].Max = newstats.Variables[i].Max;
unit.Variable[i].Increase = newstats.Variables[i].Increase;
unit.Variable[i].Enable = newstats.Variables[i].Enable;
}
unit.Type = const_cast<CUnitType *>(&newtype);
unit.Stats = &unit.Type->Stats[player.Index];
if (newtype.CanCastSpell && !unit.AutoCastSpell) {
unit.AutoCastSpell = new char[SpellTypeTable.size()];
memset(unit.AutoCastSpell, 0, SpellTypeTable.size() * sizeof(char));
}
UpdateForNewUnit(unit, 1);
// Update Possible sight range change
UpdateUnitSightRange(unit);
if (!container) {
unit.Place(pos);
RestoreSelection();
} else {
MapMarkUnitSight(unit);
}
//
// Update possible changed buttons.
//
if (IsOnlySelected(unit) || &player == ThisPlayer) {
// could affect the buttons of any selected unit
SelectedUnitChanged();
}
return 1;
}
/**
** Parse unit
**
** @param l Lua state.
**
** @todo Verify that vision table is always correct (transporter)
** @todo (PlaceUnit() and host-info).
*/
static int CclUnit(lua_State *l)
{
const int slot = LuaToNumber(l, 1);
if (!lua_istable(l, 2)) {
LuaError(l, "incorrect argument");
}
CUnit *unit = NULL;
CUnitType *type = NULL;
CUnitType *seentype = NULL;
CPlayer *player = NULL;
// Parse the list:
const int args = lua_rawlen(l, 2);
for (int j = 0; j < args; ++j) {
const char *value = LuaToString(l, 2, j + 1);
++j;
if (!strcmp(value, "type")) {
type = UnitTypeByIdent(LuaToString(l, 2, j + 1));
} else if (!strcmp(value, "seen-type")) {
seentype = UnitTypeByIdent(LuaToString(l, 2, j + 1));
} else if (!strcmp(value, "player")) {
player = &Players[LuaToNumber(l, 2, j + 1)];
// During a unit's death animation (when action is "die" but the
// unit still has its original type, i.e. it's still not a corpse)
// the unit is already removed from map and from player's
// unit list (=the unit went through LetUnitDie() which
// calls RemoveUnit() and UnitLost()). Such a unit should not
// be put on player's unit list! However, this state is not
// easily detected from this place. It seems that it is
// characterized by
// unit->CurrentAction()==UnitActionDie so we have to wait
// until we parsed at least Unit::Orders[].
Assert(type);
unit = &UnitManager.GetSlotUnit(slot);
unit->Init(*type);
unit->Seen.Type = seentype;
unit->Active = 0;
unit->Removed = 0;
Assert(UnitNumber(*unit) == slot);
} else if (!strcmp(value, "current-sight-range")) {
unit->CurrentSightRange = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "refs")) {
unit->Refs = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "host-info")) {
lua_rawgeti(l, 2, j + 1);
if (!lua_istable(l, -1) || lua_rawlen(l, -1) != 4) {
LuaError(l, "incorrect argument");
}
Vec2i pos;
int w;
int h;
pos.x = LuaToNumber(l, -1, 1);
pos.y = LuaToNumber(l, -1, 2);
w = LuaToNumber(l, -1, 3);
h = LuaToNumber(l, -1, 4);
MapSight(*player, pos, w, h, unit->CurrentSightRange, MapMarkTileSight);
// Detectcloak works in container
if (unit->Type->DetectCloak) {
MapSight(*player, pos, w, h, unit->CurrentSightRange, MapMarkTileDetectCloak);
}
// Radar(Jammer) not.
lua_pop(l, 1);
} else if (!strcmp(value, "tile")) {
lua_rawgeti(l, 2, j + 1);
CclGetPos(l, &unit->tilePos.x , &unit->tilePos.y, -1);
lua_pop(l, 1);
unit->Offset = Map.getIndex(unit->tilePos);
} else if (!strcmp(value, "seen-tile")) {
lua_rawgeti(l, 2, j + 1);
CclGetPos(l, &unit->Seen.tilePos.x , &unit->Seen.tilePos.y, -1);
lua_pop(l, 1);
} else if (!strcmp(value, "stats")) {
unit->Stats = &type->Stats[LuaToNumber(l, 2, j + 1)];
} else if (!strcmp(value, "pixel")) {
lua_rawgeti(l, 2, j + 1);
CclGetPos(l, &unit->IX , &unit->IY, -1);
lua_pop(l, 1);
} else if (!strcmp(value, "seen-pixel")) {
lua_rawgeti(l, 2, j + 1);
CclGetPos(l, &unit->Seen.IX , &unit->Seen.IY, -1);
lua_pop(l, 1);
} else if (!strcmp(value, "frame")) {
unit->Frame = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "seen")) {
unit->Seen.Frame = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "not-seen")) {
unit->Seen.Frame = UnitNotSeen;
--j;
} else if (!strcmp(value, "direction")) {
unit->Direction = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "damage-type")) {
unit->DamagedType = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "attacked")) {
// FIXME : unsigned long should be better handled
unit->Attacked = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "auto-repair")) {
unit->AutoRepair = 1;
--j;
} else if (!strcmp(value, "burning")) {
unit->Burning = 1;
--j;
} else if (!strcmp(value, "destroyed")) {
unit->Destroyed = 1;
--j;
} else if (!strcmp(value, "removed")) {
unit->Removed = 1;
--j;
} else if (!strcmp(value, "selected")) {
unit->Selected = 1;
--j;
} else if (!strcmp(value, "summoned")) {
unit->Summoned = 1;
--j;
} else if (!strcmp(value, "waiting")) {
unit->Waiting = 1;
--j;
} else if (!strcmp(value, "mine-low")) {
unit->MineLow = 1;
--j;
} else if (!strcmp(value, "rescued-from")) {
unit->RescuedFrom = &Players[LuaToNumber(l, 2, j + 1)];
} else if (!strcmp(value, "seen-by-player")) {
const char *s = LuaToString(l, 2, j + 1);
unit->Seen.ByPlayer = 0;
for (int i = 0; i < PlayerMax && *s; ++i, ++s) {
if (*s == '-' || *s == '_' || *s == ' ') {
unit->Seen.ByPlayer &= ~(1 << i);
} else {
unit->Seen.ByPlayer |= (1 << i);
}
}
} else if (!strcmp(value, "seen-destroyed")) {
const char *s = LuaToString(l, 2, j + 1);
unit->Seen.Destroyed = 0;
for (int i = 0; i < PlayerMax && *s; ++i, ++s) {
if (*s == '-' || *s == '_' || *s == ' ') {
unit->Seen.Destroyed &= ~(1 << i);
} else {
unit->Seen.Destroyed |= (1 << i);
}
}
} else if (!strcmp(value, "constructed")) {
unit->Constructed = 1;
--j;
} else if (!strcmp(value, "seen-constructed")) {
unit->Seen.Constructed = 1;
--j;
} else if (!strcmp(value, "seen-state")) {
unit->Seen.State = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "active")) {
unit->Active = 1;
--j;
} else if (!strcmp(value, "ttl")) {
// FIXME : unsigned long should be better handled
unit->TTL = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "threshold")) {
// FIXME : unsigned long should be better handled
unit->Threshold = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "group-id")) {
unit->GroupId = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "last-group")) {
unit->LastGroup = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "resources-held")) {
unit->ResourcesHeld = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "current-resource")) {
lua_rawgeti(l, 2, j + 1);
lua_pushvalue(l, -1);
unit->CurrentResource = CclGetResourceByName(l);
lua_pop(l, 1);
} else if (!strcmp(value, "pathfinder-input")) {
lua_rawgeti(l, 2, j + 1);
lua_pushvalue(l, -1);
unit->pathFinderData->input.Load(l);
lua_pop(l, 1);
} else if (!strcmp(value, "pathfinder-output")) {
lua_rawgeti(l, 2, j + 1);
lua_pushvalue(l, -1);
unit->pathFinderData->output.Load(l);
lua_pop(l, 1);
} else if (!strcmp(value, "wait")) {
unit->Wait = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "anim-data")) {
lua_rawgeti(l, 2, j + 1);
CAnimations::LoadUnitAnim(l, *unit, -1);
lua_pop(l, 1);
} else if (!strcmp(value, "wait-anim-data")) {
lua_rawgeti(l, 2, j + 1);
CAnimations::LoadWaitUnitAnim(l, *unit, -1);
lua_pop(l, 1);
} else if (!strcmp(value, "blink")) {
unit->Blink = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "moving")) {
unit->Moving = 1;
--j;
} else if (!strcmp(value, "re-cast")) {
unit->ReCast = 1;
--j;
} else if (!strcmp(value, "boarded")) {
unit->Boarded = 1;
--j;
} else if (!strcmp(value, "next-worker")) {
lua_rawgeti(l, 2, j + 1);
lua_pushvalue(l, -1);
unit->NextWorker = CclGetUnitFromRef(l);
lua_pop(l, 1);
} else if (!strcmp(value, "resource-workers")) {
lua_rawgeti(l, 2, j + 1);
lua_pushvalue(l, -1);
unit->Resource.Workers = CclGetUnitFromRef(l);
lua_pop(l, 1);
} else if (!strcmp(value, "resource-assigned")) {
lua_rawgeti(l, 2, j + 1);
lua_pushvalue(l, -1);
unit->Resource.Assigned = LuaToNumber(l, -1);
lua_pop(l, 1);
} else if (!strcmp(value, "resource-active")) {
lua_rawgeti(l, 2, j + 1);
lua_pushvalue(l, -1);
unit->Resource.Active = LuaToNumber(l, -1);
lua_pop(l, 1);
} else if (!strcmp(value, "units-boarded-count")) {
unit->BoardCount = LuaToNumber(l, 2, j + 1);
} else if (!strcmp(value, "units-contained")) {
int subargs;
int k;
lua_rawgeti(l, 2, j + 1);
if (!lua_istable(l, -1)) {
LuaError(l, "incorrect argument");
}
subargs = lua_rawlen(l, -1);
for (k = 0; k < subargs; ++k) {
lua_rawgeti(l, -1, k + 1);
CUnit *u = CclGetUnitFromRef(l);
lua_pop(l, 1);
u->AddInContainer(*unit);
}
lua_pop(l, 1);
} else if (!strcmp(value, "orders")) {
lua_rawgeti(l, 2, j + 1);
lua_pushvalue(l, -1);
CclParseOrders(l, *unit);
lua_pop(l, 1);
// now we know unit's action so we can assign it to a player
Assert(player != NULL);
unit->AssignToPlayer(*player);
if (unit->CurrentAction() == UnitActionBuilt) {
DebugPrint("HACK: the building is not ready yet\n");
// HACK: the building is not ready yet
unit->Player->UnitTypesCount[type->Slot]--;
if (unit->Active) {
unit->Player->UnitTypesAiActiveCount[type->Slot]--;
}
}
} else if (!strcmp(value, "critical-order")) {
lua_rawgeti(l, 2, j + 1);
lua_pushvalue(l, -1);
CclParseOrder(l, *unit , &unit->CriticalOrder);
lua_pop(l, 1);
} else if (!strcmp(value, "saved-order")) {
lua_rawgeti(l, 2, j + 1);
lua_pushvalue(l, -1);
CclParseOrder(l, *unit, &unit->SavedOrder);
lua_pop(l, 1);
} else if (!strcmp(value, "new-order")) {
lua_rawgeti(l, 2, j + 1);
lua_pushvalue(l, -1);
CclParseOrder(l, *unit, &unit->NewOrder);
lua_pop(l, 1);
} else if (!strcmp(value, "goal")) {
unit->Goal = &UnitManager.GetSlotUnit(LuaToNumber(l, 2, j + 1));
} else if (!strcmp(value, "auto-cast")) {
const char *s = LuaToString(l, 2, j + 1);
Assert(SpellTypeByIdent(s));
if (!unit->AutoCastSpell) {
unit->AutoCastSpell = new char[SpellTypeTable.size()];
memset(unit->AutoCastSpell, 0, SpellTypeTable.size());
}
unit->AutoCastSpell[SpellTypeByIdent(s)->Slot] = 1;
} else if (!strcmp(value, "spell-cooldown")) {
lua_rawgeti(l, 2, j + 1);
if (!lua_istable(l, -1) || lua_rawlen(l, -1) != SpellTypeTable.size()) {
LuaError(l, "incorrect argument");
}
if (!unit->SpellCoolDownTimers) {
unit->SpellCoolDownTimers = new int[SpellTypeTable.size()];
memset(unit->SpellCoolDownTimers, 0, SpellTypeTable.size() * sizeof(int));
}
for (size_t k = 0; k < SpellTypeTable.size(); ++k) {
unit->SpellCoolDownTimers[k] = LuaToNumber(l, -1, k + 1);
}
lua_pop(l, 1);
} else {
const int index = UnitTypeVar.VariableNameLookup[value];// User variables
if (index != -1) { // Valid index
lua_rawgeti(l, 2, j + 1);
DefineVariableField(l, unit->Variable + index, -1);
lua_pop(l, 1);
continue;
}
LuaError(l, "Unit: Unsupported tag: %s" _C_ value);
}
}
// Unit may not have been assigned to a player before now. If not,
// do so now. It is only assigned earlier if we have orders.
// for loading of units from a MAP, and not a savegame, we won't
// have orders for those units. They should appear here as if
// they were just created.
if (!unit->Player) {
Assert(player);
unit->AssignToPlayer(*player);
UpdateForNewUnit(*unit, 0);
}
// Revealers are units that can see while removed
if (unit->Removed && unit->Type->Revealer) {
MapMarkUnitSight(*unit);
}
// Fix Colors for rescued units.
if (unit->RescuedFrom) {
unit->Colors = &unit->RescuedFrom->UnitColors;
}
return 0;
}
