/**
* Rotate the unit to aim at the enemy.
*
* Stack: *none*.
*
* @param script The script engine to operate on.
* @return 0 if the enemy is no longer there or if we are looking at him, 1 otherwise.
*/
uint16 Script_Unit_Rotate(ScriptEngine *script)
{
const UnitInfo *ui;
Unit *u;
uint16 index;
int8 current;
tile32 tile;
int8 orientation;
VARIABLE_NOT_USED(script);
u = g_scriptCurrentUnit;
ui = &g_table_unitInfo[u->o.type];
if (ui->movementType != MOVEMENT_WINGER && u->currentDestination.tile != 0) return 1;
index = ui->o.flags.hasTurret ? 1 : 0;
/* Check if we are already rotating */
if (u->orientation[index].speed != 0) return 1;
current = u->orientation[index].current;
if (!Tools_Index_IsValid(u->targetAttack)) return 0;
/* Check where we should rotate to */
tile = Tools_Index_GetTile(u->targetAttack);
orientation = Tile_GetDirection(u->o.position, tile);
/* If we aren't already looking at it, rotate */
if (orientation == current) return 0;
Unit_SetOrientation(u, orientation, false, index);
return 1;
}
/**
* Set a new target, and rotate towards him if needed.
*
* Stack: 1 - An encoded tile of the unit/tile to target.
*
* @param script The script engine to operate on.
* @return The new target.
*/
uint16 Script_Unit_SetTarget(ScriptEngine *script)
{
Unit *u;
uint16 target;
tile32 tile;
int8 orientation;
u = g_scriptCurrentUnit;
target = STACK_PEEK(1);
if (target == 0 || !Tools_Index_IsValid(target)) {
u->targetAttack = 0;
return 0;
}
tile = Tools_Index_GetTile(target);
orientation = Tile_GetDirection(u->o.position, tile);
u->targetAttack = target;
if (!g_table_unitInfo[u->o.type].o.flags.hasTurret) {
u->targetMove = target;
Unit_SetOrientation(u, orientation, false, 0);
}
Unit_SetOrientation(u, orientation, false, 1);
return u->targetAttack;
}
/**
* Check if the given tile is a valid destination. In case of for example
* a carry-all it checks if the unit carrying can be placed on destination.
* In case of structures, it checks if you can walk into it.
*
* Stack: 1 - An encoded tile, indicating the destination.
*
* @param script The script engine to operate on.
* @return ??.
*/
uint16 Script_Unit_IsValidDestination(ScriptEngine *script)
{
Unit *u;
Unit *u2;
uint16 encoded;
uint16 index;
u = g_scriptCurrentUnit;
encoded = STACK_PEEK(1);
index = Tools_Index_Decode(encoded);
switch (Tools_Index_GetType(encoded)) {
case IT_TILE:
if (!Map_IsValidPosition(index)) return 1;
if (u->o.linkedID == 0xFF) return 1;
u2 = Unit_Get_ByIndex(u->o.linkedID);
u2->o.position = Tools_Index_GetTile(encoded);
if (!Unit_IsTileOccupied(u2)) return 0;
u2->o.position.tile = 0xFFFFFFFF;
return 1;
case IT_STRUCTURE: {
Structure *s;
s = Structure_Get_ByIndex(index);
if (s->o.houseID == Unit_GetHouseID(u)) return 0;
if (u->o.linkedID == 0xFF) return 1;
u2 = Unit_Get_ByIndex(u->o.linkedID);
return Unit_IsValidMovementIntoStructure(u2, s) != 0 ? 1 : 0;
}
default: return 1;
}
}
/**
* Gets the distance from the given object to the given encoded index.
* @param o The object.
* @param encoded The encoded index.
* @return The distance.
*/
uint16 Object_GetDistanceToEncoded(Object* o, uint16 encoded)
{
Structure* s;
tile32 position;
s = Tools_Index_GetStructure(encoded);
if (s != NULL)
{
uint16 packed;
position = s->o.position;
packed = Tile_PackTile(position);
packed += g_table_structure_layoutEdgeTiles[g_table_structureInfo[o->type].layout][(Orientation_256To8(Tile_GetDirection(o->position, position)) + 4) & 7];
position = Tile_UnpackTile(packed);
}
else
{
position = Tools_Index_GetTile(encoded);
}
return Tile_GetDistance(o->position, position);
}
/**
* Unknown function 0788.
*
* Stack: *none*.
*
* @param script The script engine to operate on.
* @return The value 0. Always.
*/
uint16 Script_Team_Unknown0788(ScriptEngine *script)
{
Team *t;
tile32 tile;
PoolFindStruct find;
VARIABLE_NOT_USED(script);
t = g_scriptCurrentTeam;
if (t->target == 0) return 0;
tile = Tools_Index_GetTile(t->target);
find.houseID = t->houseID;
find.index = 0xFFFF;
find.type = 0xFFFF;
while (true) {
Unit *u;
uint16 distance;
uint16 packed;
int16 orientation;
u = Unit_Find(&find);
if (u == NULL) break;
if (u->team - 1 != t->index) continue;
if (t->target == 0) {
Unit_SetAction(u, ACTION_GUARD);
continue;
}
distance = g_table_unitInfo[u->o.type].fireDistance << 8;
if (u->actionID == ACTION_ATTACK && u->targetAttack == t->target) {
if (u->targetMove != 0) continue;
if (Tile_GetDistance(u->o.position, tile) >= distance) continue;
}
if (u->actionID != ACTION_ATTACK) Unit_SetAction(u, ACTION_ATTACK);
orientation = (Tile_GetDirection(tile, u->o.position) & 0xC0) + Tools_RandomLCG_Range(0, 127);
if (orientation < 0) orientation += 256;
packed = Tile_PackTile(Tile_MoveByDirection(tile, orientation, distance));
if (Object_GetByPackedTile(packed) == NULL) {
Unit_SetDestination(u, Tools_Index_Encode(packed, IT_TILE));
} else {
Unit_SetDestination(u, Tools_Index_Encode(Tile_PackTile(tile), IT_TILE));
}
Unit_SetTarget(u, t->target);
}
return 0;
}
/**
* Rotate the turret to look at a tile.
*
* Stack: 1 - Tile to look at.
*
* @param script The script engine to operate on.
* @return 0 if looking at target, otherwise 1.
*/
uint16 Script_Structure_RotateTurret(ScriptEngine *script)
{
Structure *s;
tile32 lookAt;
Tile *tile;
uint16 baseSpriteID;
uint16 encoded;
int16 rotation;
int16 rotationNeeded;
int16 rotateDiff;
encoded = STACK_PEEK(1);
if (encoded == 0) return 0;
s = g_scriptCurrentStructure;
lookAt = Tools_Index_GetTile(encoded);
tile = &g_map[Tile_PackTile(s->o.position)];
/* Find the base sprite of the structure */
if (s->o.type == STRUCTURE_ROCKET_TURRET) {
baseSpriteID = g_iconMap[g_iconMap[ICM_ICONGROUP_BASE_ROCKET_TURRET] + 2];
} else {
baseSpriteID = g_iconMap[g_iconMap[ICM_ICONGROUP_BASE_DEFENSE_TURRET] + 2];
}
rotation = tile->groundSpriteID - baseSpriteID;
if (rotation < 0 || rotation > 7) return 1;
/* Find what rotation we should have to look at the target */
rotationNeeded = Orientation_Orientation256ToOrientation8(Tile_GetDirection(s->o.position, lookAt));
/* Do we need to rotate */
if (rotationNeeded == rotation) return 0;
/* Find the fastest way to rotate to the correct rotation */
rotateDiff = rotationNeeded - rotation;
if (rotateDiff < 0) rotateDiff += 8;
if (rotateDiff < 4) {
rotation++;
} else {
rotation--;
}
rotation &= 0x7;
/* Set the new sprites */
tile->groundSpriteID = baseSpriteID + rotation;
s->rotationSpriteDiff = rotation;
Map_Update(Tile_PackTile(s->o.position), 0, false);
return 1;
}
/**
* Move the Unit to the target, and keep repeating this function till we
* arrived there. When closing in on the target it will slow down the Unit.
* It is wise to only use this function on Carry-Alls.
*
* Stack: *none*.
*
* @param script The script engine to operate on.
* @return 1 if arrived, 0 if still busy.
*/
uint16 Script_Unit_MoveToTarget(ScriptEngine *script)
{
Unit *u;
uint16 delay;
tile32 tile;
uint16 distance;
int8 orientation;
int16 diff;
u = g_scriptCurrentUnit;
if (u->targetMove == 0) return 0;
tile = Tools_Index_GetTile(u->targetMove);
distance = Tile_GetDistance(u->o.position, tile);
if ((int16)distance < 128) {
Unit_SetSpeed(u, 0);
u->o.position.s.x += clamp((int16)(tile.s.x - u->o.position.s.x), -16, 16);
u->o.position.s.y += clamp((int16)(tile.s.y - u->o.position.s.y), -16, 16);
Unit_UpdateMap(2, u);
if ((int16)distance < 32) return 1;
script->delay = 2;
script->script--;
return 0;
}
orientation = Tile_GetDirection(u->o.position, tile);
Unit_SetOrientation(u, orientation, false, 0);
diff = abs(orientation - u->orientation[0].current);
if (diff > 128) diff = 256 - diff;
Unit_SetSpeed(u, (Tools_AdjustToGameSpeed(min(distance / 8, 255), 25, 255, true) * (255 - diff) + 128) / 256);
delay = max((int16)distance / 1024, 1);
Unit_UpdateMap(2, u);
if (delay != 0) {
script->delay = delay;
script->script--;
}
return 0;
}
/**
* Unknown function 0543.
*
* Stack: 1 - A distance.
*
* @param script The script engine to operate on.
* @return The number of moving units.
*/
uint16 Script_Team_Unknown0543(ScriptEngine *script)
{
Team *t;
uint16 count = 0;
uint16 distance;
PoolFindStruct find;
t = g_scriptCurrentTeam;
distance = STACK_PEEK(1);
find.houseID = t->houseID;
find.index = 0xFFFF;
find.type = 0xFFFF;
while (true) {
Unit *u;
tile32 tile;
uint16 distanceUnitDest;
uint16 distanceUnitTeam;
uint16 distanceTeamDest;
u = Unit_Find(&find);
if (u == NULL) break;
if (t->index != u->team - 1) continue;
tile = Tools_Index_GetTile(u->targetMove);
distanceUnitTeam = Tile_GetDistanceRoundedUp(u->o.position, t->position);
if (u->targetMove != 0) {
distanceUnitDest = Tile_GetDistanceRoundedUp(u->o.position, tile);
distanceTeamDest = Tile_GetDistanceRoundedUp(t->position, tile);
} else {
distanceUnitDest = 64;
distanceTeamDest = 64;
}
if ((distanceUnitDest < distanceTeamDest && (distance + 2) < distanceUnitTeam) || (distanceUnitDest >= distanceTeamDest && distanceUnitTeam > distance)) {
Unit_SetAction(u, ACTION_MOVE);
tile = Tile_MoveByRandom(t->position, distance << 4, true);
Unit_SetDestination(u, Tools_Index_Encode(Tile_PackTile(tile), IT_TILE));
count++;
continue;
}
Unit_SetAction(u, ACTION_GUARD);
}
return count;
}
/**
* Find the direction a tile is, seen from the structure. If the tile is
* invalid it gives the direction the structure is currently looking at.
*
* Stack: 1 - Tile to get the direction to, or the current direction of the
* structure in case the tile is invalid.
*
* @param script The script engine to operate on.
* @return The direction (value between 0 and 7, shifted to the left with 5).
*/
uint16 Script_Structure_GetDirection(ScriptEngine *script)
{
Structure *s;
tile32 tile;
uint16 encoded;
s = g_scriptCurrentStructure;
encoded = STACK_PEEK(1);
if (!Tools_Index_IsValid(encoded)) return s->rotationSpriteDiff << 5;
tile = Tools_Index_GetTile(encoded);
return Orientation_Orientation256ToOrientation8(Tile_GetDirection(s->o.position, tile)) << 5;
}
/**
* Get the direction to a tile or our current direction.
*
* Stack: 1 - An encoded tile to get the direction to.
*
* @param script The script engine to operate on.
* @return The direction to the encoded tile if valid, otherwise our current orientation.
*/
uint16 Script_Unit_GetOrientation(ScriptEngine *script)
{
Unit *u;
uint16 encoded;
u = g_scriptCurrentUnit;
encoded = STACK_PEEK(1);
if (Tools_Index_IsValid(encoded)) {
tile32 tile;
tile = Tools_Index_GetTile(encoded);
return Tile_GetDirection(u->o.position, tile);
}
return u->orientation[0].current;
}
/**
* Set the current destination of a Unit, bypassing any pathfinding.
* It is wise to only use this function on Carry-Alls.
*
* Stack: 1 - An encoded tile, the destination.
*
* @param script The script engine to operate on.
* @return The value 0. Always.
*/
uint16 Script_Unit_SetDestinationDirect(ScriptEngine *script)
{
Unit *u;
uint16 encoded;
encoded = STACK_PEEK(1);
if (!Tools_Index_IsValid(encoded)) return 0;
u = g_scriptCurrentUnit;
if (u->currentDestination.tile == 0 || g_table_unitInfo[u->o.type].flags.isNormalUnit) {
u->currentDestination = Tools_Index_GetTile(encoded);
}
Unit_SetOrientation(u, Tile_GetDirection(u->o.position, u->currentDestination), false, 0);
return 0;
}
/**
* Fire a bullet or missile from a (rocket) turret.
*
* Stack: *none*
* Variables: 2 - Target to shoot at.
*
* @param script The script engine to operate on.
* @return The time between this and the next time firing.
*/
uint16 Script_Structure_Fire(ScriptEngine *script)
{
Structure *s;
Unit *u;
tile32 position;
uint16 target;
uint16 damage;
uint16 fireDelay;
uint16 type;
s = g_scriptCurrentStructure;
target = script->variables[2];
if (target == 0) return 0;
if (s->o.type == STRUCTURE_ROCKET_TURRET && Tile_GetDistance(Tools_Index_GetTile(target), s->o.position) >= 0x300) {
type = UNIT_MISSILE_TURRET;
damage = 30;
fireDelay = Tools_AdjustToGameSpeed(g_table_unitInfo[UNIT_LAUNCHER].fireDelay, 1, 255, true);
} else {
type = UNIT_BULLET;
damage = 20;
fireDelay = Tools_AdjustToGameSpeed(g_table_unitInfo[UNIT_TANK].fireDelay, 1, 255, true);
}
position.tile = s->o.position.tile;
position.s.x += 0x80;
position.s.y += 0x80;
u = Unit_CreateBullet(position, type, s->o.houseID, damage, target);
if (u == NULL) return 0;
u->originEncoded = Tools_Index_Encode(s->o.index, IT_STRUCTURE);
return fireDelay;
}
/**
* Makes the current unit fire a bullet (or eat its target).
*
* Stack: *none*.
*
* @param script The script engine to operate on.
* @return The value 1 if the current unit fired/eat, 0 otherwise.
*/
uint16 Script_Unit_Fire(ScriptEngine *script)
{
const UnitInfo *ui;
Unit *u;
uint16 target;
UnitType typeID;
uint16 distance;
bool fireTwice;
uint16 damage;
u = g_scriptCurrentUnit;
target = u->targetAttack;
if (target == 0 || !Tools_Index_IsValid(target)) return 0;
if (u->o.type != UNIT_SANDWORM && target == Tools_Index_Encode(Tile_PackTile(u->o.position), IT_TILE)) u->targetAttack = 0;
if (u->targetAttack != target) {
Unit_SetTarget(u, target);
return 0;
}
ui = &g_table_unitInfo[u->o.type];
if (u->o.type != UNIT_SANDWORM && u->orientation[ui->o.flags.hasTurret ? 1 : 0].speed != 0) return 0;
if (Tools_Index_GetType(target) == IT_TILE && Object_GetByPackedTile(Tools_Index_GetPackedTile(target)) != NULL) Unit_SetTarget(u, target);
if (u->fireDelay != 0) return 0;
distance = Object_GetDistanceToEncoded(&u->o, target);
if ((int16)(ui->fireDistance << 8) < (int16)distance) return 0;
if (u->o.type != UNIT_SANDWORM && (Tools_Index_GetType(target) != IT_UNIT || g_table_unitInfo[Tools_Index_GetUnit(target)->o.type].movementType != MOVEMENT_WINGER)) {
int16 diff = 0;
int8 orientation;
orientation = Tile_GetDirection(u->o.position, Tools_Index_GetTile(target));
diff = abs(u->orientation[ui->o.flags.hasTurret ? 1 : 0].current - orientation);
if (ui->movementType == MOVEMENT_WINGER) diff /= 8;
if (diff >= 8) return 0;
}
damage = ui->damage;
typeID = ui->bulletType;
fireTwice = ui->flags.firesTwice && u->o.hitpoints > ui->o.hitpoints / 2;
if ((u->o.type == UNIT_TROOPERS || u->o.type == UNIT_TROOPER) && (int16)distance > 512) typeID = UNIT_MISSILE_TROOPER;
switch (typeID) {
case UNIT_SANDWORM: {
Unit *u2;
Unit_UpdateMap(0, u);
u2 = Tools_Index_GetUnit(target);
if (u2 != NULL) {
u2->o.script.variables[1] = 0xFFFF;
Unit_RemovePlayer(u2);
Unit_HouseUnitCount_Remove(u2);
Unit_Remove(u2);
}
Map_MakeExplosion(ui->explosionType, u->o.position, 0, 0);
Voice_PlayAtTile(63, u->o.position);
Unit_UpdateMap(1, u);
u->amount--;
script->delay = 12;
if ((int8)u->amount < 1) Unit_SetAction(u, ACTION_DIE);
} break;
case UNIT_MISSILE_TROOPER:
damage -= damage / 4;
/* FALL-THROUGH */
case UNIT_MISSILE_ROCKET:
case UNIT_MISSILE_TURRET:
case UNIT_MISSILE_DEVIATOR:
case UNIT_BULLET:
case UNIT_SONIC_BLAST: {
Unit *bullet;
bullet = Unit_CreateBullet(u->o.position, typeID, Unit_GetHouseID(u), damage, target);
if (bullet == NULL) return 0;
bullet->originEncoded = Tools_Index_Encode(u->o.index, IT_UNIT);
Voice_PlayAtTile(ui->bulletSound, u->o.position);
Unit_Deviation_Decrease(u, 20);
} break;
default: break;
}
u->fireDelay = Tools_AdjustToGameSpeed(ui->fireDelay * 2, 1, 0xFFFF, true);
if (fireTwice) {
u->o.flags.s.fireTwiceFlip = !u->o.flags.s.fireTwiceFlip;
if (u->o.flags.s.fireTwiceFlip) u->fireDelay = Tools_AdjustToGameSpeed(5, 1, 10, true) & 0xFF;
} else {
u->o.flags.s.fireTwiceFlip = false;
}
u->fireDelay += Tools_Random_256() & 1;
Unit_UpdateMap(2, u);
return 1;
}
