gronod/OpenTTD
1
0
Fork 0
mirror of https://github.com/OpenTTD/OpenTTD.git synced 2025-06-21 20:49:31 +01:00
Code Issues Packages Projects Releases Wiki Activity

(svn r4342) Change the first two parameters of commands - virtual pixel coordinates of the tile to operate on - to a TileIndex

Browse Source 
Remove DoCommandByTile(), because now it does the same as DoCommand()
This commit is contained in:
tron 2006-04-10 07:15:58 +00:00
parent 6926bd55fd
commit 81e6d68f95
38 changed files with 434 additions and 460 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ai/ai.c
View File

@ -96,7 +96,7 @@ int32 AI_DoCommand(uint tile, uint32 p1, uint32 p2, uint32 flags, uint procc)
tmp_cmdtext = strdup(_cmd_text);
/* First, do a test-run to see if we can do this */
res = DoCommandByTile(tile, p1, p2, flags & ~DC_EXEC, procc);
res = DoCommand(tile, p1, p2, flags & ~DC_EXEC, procc);
/* The command failed, or you didn't want to execute, or you are quering, return */
if ((CmdFailed(res)) || !(flags & DC_EXEC) || (flags & DC_QUERY_COST)) {
if (tmp_cmdtext != NULL)

162
ai/default/default.c
View File

@ -146,7 +146,7 @@ static EngineID AiChooseTrainToBuild(RailType railtype, int32 money, byte flag,
continue;
}
ret = DoCommandByTile(tile, i, 0, 0, CMD_BUILD_RAIL_VEHICLE);
ret = DoCommand(tile, i, 0, 0, CMD_BUILD_RAIL_VEHICLE);
if (!CmdFailed(ret) && ret <= money &&
rvi->ai_rank >= best_veh_score) {
best_veh_score = rvi->ai_rank;
@ -172,7 +172,7 @@ static EngineID AiChooseRoadVehToBuild(CargoID cargo, int32 money, TileIndex til
if (!HASBIT(e->player_avail, _current_player) || e->reliability < 0x8A3D)
continue;
ret = DoCommandByTile(tile, i, 0, 0, CMD_BUILD_ROAD_VEH);
ret = DoCommand(tile, i, 0, 0, CMD_BUILD_ROAD_VEH);
if (!CmdFailed(ret) && ret <= money && ret >= best_veh_cost) {
best_veh_cost = ret;
best_veh_index = i;
@ -203,7 +203,7 @@ static EngineID AiChooseAircraftToBuild(int32 money, byte flag)
if (i>=253) continue;
}
ret = DoCommandByTile(0, i, 0, DC_QUERY_COST, CMD_BUILD_AIRCRAFT);
ret = DoCommand(0, i, 0, DC_QUERY_COST, CMD_BUILD_AIRCRAFT);
if (!CmdFailed(ret) && ret <= money && ret >= best_veh_cost) {
best_veh_cost = ret;
best_veh_index = i;
@ -271,7 +271,7 @@ static EngineID AiChooseShipToReplaceWith(Player* p, Vehicle* v)
static void AiHandleGotoDepot(Player *p, int cmd)
{
if (p->ai.cur_veh->current_order.type != OT_GOTO_DEPOT)
DoCommandByTile(0, p->ai.cur_veh->index, 0, DC_EXEC, cmd);
DoCommand(0, p->ai.cur_veh->index, 0, DC_EXEC, cmd);
if (++p->ai.state_counter <= 1387) {
p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;
@ -314,13 +314,13 @@ static void AiHandleReplaceTrain(Player *p)
BackupVehicleOrders(v, orderbak);
tile = v->tile;
if (!CmdFailed(DoCommandByTile(0, v->index, 2, DC_EXEC, CMD_SELL_RAIL_WAGON)) &&
!CmdFailed(DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE)) ) {
if (!CmdFailed(DoCommand(0, v->index, 2, DC_EXEC, CMD_SELL_RAIL_WAGON)) &&
!CmdFailed(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE)) ) {
VehicleID veh = _new_train_id;
AiRestoreVehicleOrders(GetVehicle(veh), orderbak);
DoCommandByTile(0, veh, 0, DC_EXEC, CMD_START_STOP_TRAIN);
DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_TRAIN);
DoCommandByTile(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
}
}
}
@ -343,13 +343,13 @@ static void AiHandleReplaceRoadVeh(Player *p)
BackupVehicleOrders(v, orderbak);
tile = v->tile;
if (!CmdFailed(DoCommandByTile(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH)) &&
!CmdFailed(DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH)) ) {
if (!CmdFailed(DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH)) &&
!CmdFailed(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH)) ) {
VehicleID veh = _new_roadveh_id;
AiRestoreVehicleOrders(GetVehicle(veh), orderbak);
DoCommandByTile(0, veh, 0, DC_EXEC, CMD_START_STOP_ROADVEH);
DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_ROADVEH);
DoCommandByTile(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
}
}
}
@ -372,13 +372,13 @@ static void AiHandleReplaceAircraft(Player *p)
BackupVehicleOrders(v, orderbak);
tile = v->tile;
if (!CmdFailed(DoCommandByTile(0, v->index, 0, DC_EXEC, CMD_SELL_AIRCRAFT)) &&
!CmdFailed(DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT)) ) {
if (!CmdFailed(DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_AIRCRAFT)) &&
!CmdFailed(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT)) ) {
VehicleID veh = _new_aircraft_id;
AiRestoreVehicleOrders(GetVehicle(veh), orderbak);
DoCommandByTile(0, veh, 0, DC_EXEC, CMD_START_STOP_AIRCRAFT);
DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_AIRCRAFT);
DoCommandByTile(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
}
}
}
@ -1552,10 +1552,10 @@ static int32 AiDoBuildDefaultRailTrack(TileIndex tile, const AiDefaultBlockData
if (p->mode < 2) {
if (p->mode == 0) {
// Depot
ret = DoCommandByTile(c, _cur_ai_player->ai.railtype_to_use, p->attr, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_TRAIN_DEPOT);
ret = DoCommand(c, _cur_ai_player->ai.railtype_to_use, p->attr, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_TRAIN_DEPOT);
} else {
// Station
ret = DoCommandByTile(c, (p->attr&1) | (p->attr>>4)<<8 | (p->attr>>1&7)<<16, _cur_ai_player->ai.railtype_to_use, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_RAILROAD_STATION);
ret = DoCommand(c, (p->attr&1) | (p->attr>>4)<<8 | (p->attr>>1&7)<<16, _cur_ai_player->ai.railtype_to_use, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_RAILROAD_STATION);
}
if (CmdFailed(ret)) return CMD_ERROR;
@ -1579,7 +1579,7 @@ clear_town_stuff:;
for (i = 0; i != 6; i++, j >>= 1) {
if (j&1) {
k = i;
ret = DoCommandByTile(c, _cur_ai_player->ai.railtype_to_use, i, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_SINGLE_RAIL);
ret = DoCommand(c, _cur_ai_player->ai.railtype_to_use, i, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_SINGLE_RAIL);
if (CmdFailed(ret)) return CMD_ERROR;
total_cost += ret;
}
@ -1593,7 +1593,7 @@ clear_town_stuff:;
if (flag & DC_EXEC) {
j = 4 - j;
do {
ret = DoCommandByTile(c, k, 0, flag, CMD_BUILD_SIGNALS);
ret = DoCommand(c, k, 0, flag, CMD_BUILD_SIGNALS);
} while (--j);
} else {
ret = _price.build_signals;
@ -1605,12 +1605,12 @@ clear_town_stuff:;
//Clear stuff and then build single rail.
if (GetTileSlope(c,NULL) != 0)
return CMD_ERROR;
ret = DoCommandByTile(c, 0, 0, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(c, 0, 0, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return CMD_ERROR;
total_cost += ret + _price.build_rail;
if (flag & DC_EXEC) {
DoCommandByTile(c, _cur_ai_player->ai.railtype_to_use, p->attr&1, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_SINGLE_RAIL);
DoCommand(c, _cur_ai_player->ai.railtype_to_use, p->attr&1, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_SINGLE_RAIL);
}
goto clear_town_stuff;
@ -1701,11 +1701,11 @@ static void AiDoTerraformLand(TileIndex tile, int dir, int unk, int mode)
if (slope != 0) {
if (mode > 0 || (mode == 0 && !(r & 0xC))) {
// Terraform up
DoCommandByTile(tile, _terraform_up_flags[slope - 1], 1,
DoCommand(tile, _terraform_up_flags[slope - 1], 1,
DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
} else if (h != 0) {
// Terraform down
DoCommandByTile(tile, _terraform_down_flags[slope - 1], 0,
DoCommand(tile, _terraform_down_flags[slope - 1], 0,
DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
}
}
@ -1947,7 +1947,7 @@ static inline void AiCheckBuildRailBridgeHere(AiRailFinder *arf, TileIndex tile,
}
// Is building a (rail)bridge possible at this place (type doesn't matter)?
if (CmdFailed(DoCommandByTile(tile_new, tile, 0 | arf->player->ai.railtype_to_use << 8,
if (CmdFailed(DoCommand(tile_new, tile, 0 | arf->player->ai.railtype_to_use << 8,
DC_AUTO, CMD_BUILD_BRIDGE)) )
return;
AiBuildRailRecursive(arf, tile_new, dir2);
@ -1965,7 +1965,7 @@ static inline void AiCheckBuildRailTunnelHere(AiRailFinder *arf, TileIndex tile,
uint z;
if (GetTileSlope(tile, &z) == _dir_table_2[p[0] & 3] && z != 0) {
int32 cost = DoCommandByTile(tile, arf->player->ai.railtype_to_use, 0, DC_AUTO, CMD_BUILD_TUNNEL);
int32 cost = DoCommand(tile, arf->player->ai.railtype_to_use, 0, DC_AUTO, CMD_BUILD_TUNNEL);
if (!CmdFailed(cost) && cost <= (arf->player->player_money>>4)) {
AiBuildRailRecursive(arf, _build_tunnel_endtile, p[0]&3);
@ -2024,7 +2024,7 @@ static void AiBuildRailRecursive(AiRailFinder *arf, TileIndex tile, int dir)
do {
// Make sure the tile is not in the list of banned tiles and that a rail can be built here.
if (!AiIsTileBanned(arf->player, tile, p[0]) &&
!CmdFailed(DoCommandByTile(tile, arf->player->ai.railtype_to_use, p[0], DC_AUTO | DC_NO_WATER | DC_NO_RAIL_OVERLAP, CMD_BUILD_SINGLE_RAIL))) {
!CmdFailed(DoCommand(tile, arf->player->ai.railtype_to_use, p[0], DC_AUTO | DC_NO_WATER | DC_NO_RAIL_OVERLAP, CMD_BUILD_SINGLE_RAIL))) {
AiBuildRailRecursive(arf, tile, p[1]);
}
@ -2111,26 +2111,26 @@ static void AiBuildRailConstruct(Player *p)
*/
for (i = MAX_BRIDGES - 1; i != 0; i--) {
if (CheckBridge_Stuff(i, bridge_len)) {
int32 cost = DoCommandByTile(arf.bridge_end_tile, p->ai.cur_tile_a, i | (p->ai.railtype_to_use << 8), DC_AUTO, CMD_BUILD_BRIDGE);
int32 cost = DoCommand(arf.bridge_end_tile, p->ai.cur_tile_a, i | (p->ai.railtype_to_use << 8), DC_AUTO, CMD_BUILD_BRIDGE);
if (!CmdFailed(cost) && cost < (p->player_money >> 5))
break;
}
}
// Build it
DoCommandByTile(arf.bridge_end_tile, p->ai.cur_tile_a, i | (p->ai.railtype_to_use << 8), DC_AUTO | DC_EXEC, CMD_BUILD_BRIDGE);
DoCommand(arf.bridge_end_tile, p->ai.cur_tile_a, i | (p->ai.railtype_to_use << 8), DC_AUTO | DC_EXEC, CMD_BUILD_BRIDGE);
p->ai.cur_tile_a = arf.bridge_end_tile;
p->ai.state_counter = 0;
} else if (arf.best_ptr[0]&0x40) {
// tunnel
DoCommandByTile(p->ai.cur_tile_a, p->ai.railtype_to_use, 0, DC_AUTO | DC_EXEC, CMD_BUILD_TUNNEL);
DoCommand(p->ai.cur_tile_a, p->ai.railtype_to_use, 0, DC_AUTO | DC_EXEC, CMD_BUILD_TUNNEL);
p->ai.cur_tile_a = _build_tunnel_endtile;
p->ai.state_counter = 0;
} else {
// rail
p->ai.cur_dir_a = arf.best_ptr[1];
DoCommandByTile(p->ai.cur_tile_a, p->ai.railtype_to_use, arf.best_ptr[0],
DoCommand(p->ai.cur_tile_a, p->ai.railtype_to_use, arf.best_ptr[0],
DC_EXEC | DC_AUTO | DC_NO_WATER | DC_NO_RAIL_OVERLAP, CMD_BUILD_SINGLE_RAIL);
p->ai.state_counter = 0;
}
@ -2153,7 +2153,7 @@ static bool AiRemoveTileAndGoForward(Player *p)
if (IsTileType(tile, MP_TUNNELBRIDGE)) {
if (IsTunnel(tile)) {
// Clear the tunnel and continue at the other side of it.
if (CmdFailed(DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR)))
if (CmdFailed(DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR)))
return false;
p->ai.cur_tile_a = TILE_MASK(_build_tunnel_endtile - TileOffsByDir(p->ai.cur_dir_a));
return true;
@ -2168,7 +2168,7 @@ static bool AiRemoveTileAndGoForward(Player *p)
tilenew = TILE_MASK(tile - TileOffsByDir(p->ai.cur_dir_a));
// And clear the bridge.
if (CmdFailed(DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR)))
if (CmdFailed(DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR)))
return false;
p->ai.cur_tile_a = tilenew;
return true;
@ -2185,11 +2185,11 @@ static bool AiRemoveTileAndGoForward(Player *p)
// Then remove and signals if there are any.
if (IsTileType(tile, MP_RAILWAY) &&
GetRailTileType(tile) == RAIL_TYPE_SIGNALS) {
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_REMOVE_SIGNALS);
DoCommand(tile, 0, 0, DC_EXEC, CMD_REMOVE_SIGNALS);
}
// And also remove the rail.
if (CmdFailed(DoCommandByTile(tile, 0, bit, DC_EXEC, CMD_REMOVE_SINGLE_RAIL)))
if (CmdFailed(DoCommand(tile, 0, bit, DC_EXEC, CMD_REMOVE_SINGLE_RAIL)))
return false;
// Find the direction at the other edge of the rail.
@ -2294,7 +2294,7 @@ static void AiStateBuildRail(Player *p)
p->ai.cur_tile_a = tile;
p->ai.start_dir_a = dir;
p->ai.cur_dir_a = dir;
DoCommandByTile(TILE_MASK(tile + TileOffsByDir(dir)), 0, (dir&1)?1:0, DC_EXEC, CMD_REMOVE_SINGLE_RAIL);
DoCommand(TILE_MASK(tile + TileOffsByDir(dir)), 0, (dir&1)?1:0, DC_EXEC, CMD_REMOVE_SINGLE_RAIL);
assert(TILE_MASK(tile) != 0xFF00);
@ -2305,7 +2305,7 @@ static void AiStateBuildRail(Player *p)
p->ai.cur_tile_b = tile;
p->ai.start_dir_b = dir;
p->ai.cur_dir_b = dir;
DoCommandByTile(TILE_MASK(tile + TileOffsByDir(dir)), 0, (dir&1)?1:0, DC_EXEC, CMD_REMOVE_SINGLE_RAIL);
DoCommand(TILE_MASK(tile + TileOffsByDir(dir)), 0, (dir&1)?1:0, DC_EXEC, CMD_REMOVE_SINGLE_RAIL);
assert(TILE_MASK(tile) != 0xFF00);
@ -2381,7 +2381,7 @@ static void AiStateBuildRailVeh(Player *p)
/* veh will return INVALID_ENGINE if no suitable wagon is available.
* We shall treat this in the same way as having no money */
if (veh == INVALID_ENGINE) goto handle_nocash;
cost = DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE);
cost = DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE);
if (CmdFailed(cost)) goto handle_nocash;
p->ai.wagon_list[i] = _new_wagon_id;
p->ai.wagon_list[i + 1] = INVALID_VEHICLE;
@ -2400,7 +2400,7 @@ handle_nocash:
// after a while, if AI still doesn't have cash, get out of this block by selling the wagons.
if (++p->ai.state_counter == 1000) {
for (i = 0; p->ai.wagon_list[i] != INVALID_VEHICLE; i++) {
cost = DoCommandByTile(tile, p->ai.wagon_list[i], 0, DC_EXEC, CMD_SELL_RAIL_WAGON);
cost = DoCommand(tile, p->ai.wagon_list[i], 0, DC_EXEC, CMD_SELL_RAIL_WAGON);
assert(!CmdFailed(cost));
}
p->ai.state = AIS_0;
@ -2409,7 +2409,7 @@ handle_nocash:
}
// Try to build the locomotive
cost = DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE);
cost = DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE);
assert(!CmdFailed(cost));
loco_id = _new_train_id;
@ -2418,12 +2418,12 @@ handle_nocash:
if (v->next != NULL) {
i = p->ai.wagon_list[p->ai.num_wagons * 2 - 2];
p->ai.wagon_list[p->ai.num_wagons * 2 - 2] = INVALID_VEHICLE;
DoCommandByTile(tile, i, 0, DC_EXEC, CMD_SELL_RAIL_WAGON);
DoCommand(tile, i, 0, DC_EXEC, CMD_SELL_RAIL_WAGON);
}
// Move the wagons onto the train
for (i = 0; p->ai.wagon_list[i] != INVALID_VEHICLE; i++) {
DoCommandByTile(tile, p->ai.wagon_list[i] | (loco_id << 16), 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
DoCommand(tile, p->ai.wagon_list[i] | (loco_id << 16), 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
}
for (i = 0; p->ai.order_list_blocks[i] != 0xFF; i++) {
@ -2443,12 +2443,12 @@ handle_nocash:
if (p->ai.num_want_fullload != 0 && (is_pass || i == 0))
order.flags |= OF_FULL_LOAD;
DoCommandByTile(0, loco_id + (i << 16), PackOrder(&order), DC_EXEC, CMD_INSERT_ORDER);
DoCommand(0, loco_id + (i << 16), PackOrder(&order), DC_EXEC, CMD_INSERT_ORDER);
}
DoCommandByTile(0, loco_id, 0, DC_EXEC, CMD_START_STOP_TRAIN);
DoCommand(0, loco_id, 0, DC_EXEC, CMD_START_STOP_TRAIN);
DoCommandByTile(0, loco_id, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
DoCommand(0, loco_id, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
if (p->ai.num_want_fullload != 0) p->ai.num_want_fullload--;
@ -2472,7 +2472,7 @@ static void AiStateDeleteRailBlocks(Player *p)
if (aib->cur_building_rule != 255) {
b = _default_rail_track_data[aib->cur_building_rule]->data;
while (b->mode != 4) {
DoCommandByTile(TILE_ADD(aib->use_tile, ToTileIndexDiff(b->tileoffs)), 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(TILE_ADD(aib->use_tile, ToTileIndexDiff(b->tileoffs)), 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
b++;
}
}
@ -2554,7 +2554,7 @@ static int32 AiDoBuildDefaultRoadBlock(TileIndex tile, const AiDefaultBlockData
if ((GetRoadBits(c) & p->attr) == p->attr) continue;
}
ret = DoCommandByTile(c, p->attr, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD);
ret = DoCommand(c, p->attr, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD);
if (CmdFailed(ret)) return CMD_ERROR;
total_cost += ret;
@ -2563,15 +2563,15 @@ static int32 AiDoBuildDefaultRoadBlock(TileIndex tile, const AiDefaultBlockData
if (p->mode == 0) {
// Depot
ret = DoCommandByTile(c, p->attr, 0, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_ROAD_DEPOT);
ret = DoCommand(c, p->attr, 0, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_ROAD_DEPOT);
goto clear_town_stuff;
} else if (p->mode == 1) {
if (_want_road_truck_station) {
// Truck station
ret = DoCommandByTile(c, p->attr, RS_TRUCK, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_ROAD_STOP);
ret = DoCommand(c, p->attr, RS_TRUCK, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_ROAD_STOP);
} else {
// Bus station
ret = DoCommandByTile(c, p->attr, RS_BUS, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_ROAD_STOP);
ret = DoCommand(c, p->attr, RS_BUS, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_BUILD_ROAD_STOP);
}
clear_town_stuff:;
@ -2589,7 +2589,7 @@ clear_town_stuff:;
if (GetTileSlope(c, NULL) != 0) return CMD_ERROR;
if (!IsTileType(c, MP_STREET) || GetRoadType(c) != ROAD_NORMAL) {
ret = DoCommandByTile(c, 0, 0, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(c, 0, 0, flag | DC_AUTO | DC_NO_WATER | DC_AI_BUILDING, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return CMD_ERROR;
}
@ -2822,7 +2822,7 @@ static bool AiBuildRoadHelper(TileIndex tile, int flags, int type)
1+2,
8+4,
};
return !CmdFailed(DoCommandByTile(tile, _road_bits[type], 0, flags, CMD_BUILD_ROAD));
return !CmdFailed(DoCommand(tile, _road_bits[type], 0, flags, CMD_BUILD_ROAD));
}
static inline void AiCheckBuildRoadBridgeHere(AiRoadFinder *arf, TileIndex tile, const byte *p)
@ -2857,7 +2857,7 @@ static inline void AiCheckBuildRoadBridgeHere(AiRoadFinder *arf, TileIndex tile,
}
// Is building a (rail)bridge possible at this place (type doesn't matter)?
if (CmdFailed(DoCommandByTile(tile_new, tile, 0x8000, DC_AUTO, CMD_BUILD_BRIDGE)))
if (CmdFailed(DoCommand(tile_new, tile, 0x8000, DC_AUTO, CMD_BUILD_BRIDGE)))
return;
AiBuildRoadRecursive(arf, tile_new, dir2);
@ -2873,7 +2873,7 @@ static inline void AiCheckBuildRoadTunnelHere(AiRoadFinder *arf, TileIndex tile,
uint z;
if (GetTileSlope(tile, &z) == _dir_table_2[p[0] & 3] && z != 0) {
int32 cost = DoCommandByTile(tile, 0x200, 0, DC_AUTO, CMD_BUILD_TUNNEL);
int32 cost = DoCommand(tile, 0x200, 0, DC_AUTO, CMD_BUILD_TUNNEL);
if (!CmdFailed(cost) && cost <= (arf->player->player_money>>4)) {
AiBuildRoadRecursive(arf, _build_tunnel_endtile, p[0]&3);
@ -3009,18 +3009,18 @@ do_some_terraform:
*/
for (i = 10; i != 0; i--) {
if (CheckBridge_Stuff(i, bridge_len)) {
int32 cost = DoCommandByTile(tile, p->ai.cur_tile_a, i + (0x80 << 8), DC_AUTO, CMD_BUILD_BRIDGE);
int32 cost = DoCommand(tile, p->ai.cur_tile_a, i + (0x80 << 8), DC_AUTO, CMD_BUILD_BRIDGE);
if (!CmdFailed(cost) && cost < (p->player_money >> 5)) break;
}
}
// Build it
DoCommandByTile(tile, p->ai.cur_tile_a, i + (0x80 << 8), DC_AUTO | DC_EXEC, CMD_BUILD_BRIDGE);
DoCommand(tile, p->ai.cur_tile_a, i + (0x80 << 8), DC_AUTO | DC_EXEC, CMD_BUILD_BRIDGE);
p->ai.state_counter = 0;
} else if (arf.best_ptr[0]&0x40) {
// tunnel
DoCommandByTile(tile, 0x200, 0, DC_AUTO | DC_EXEC, CMD_BUILD_TUNNEL);
DoCommand(tile, 0x200, 0, DC_AUTO | DC_EXEC, CMD_BUILD_TUNNEL);
p->ai.cur_tile_a = _build_tunnel_endtile;
p->ai.state_counter = 0;
} else {
@ -3162,7 +3162,7 @@ static void AiStateBuildRoadVehicles(Player *p)
return;
}
if (CmdFailed(DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH))) return;
if (CmdFailed(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH))) return;
loco_id = _new_roadveh_id;
@ -3183,11 +3183,11 @@ static void AiStateBuildRoadVehicles(Player *p)
if (p->ai.num_want_fullload != 0 && (is_pass || i == 0))
order.flags |= OF_FULL_LOAD;
DoCommandByTile(0, loco_id + (i << 16), PackOrder(&order), DC_EXEC, CMD_INSERT_ORDER);
DoCommand(0, loco_id + (i << 16), PackOrder(&order), DC_EXEC, CMD_INSERT_ORDER);
}
DoCommandByTile(0, loco_id, 0, DC_EXEC, CMD_START_STOP_ROADVEH);
DoCommandByTile(0, loco_id, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
DoCommand(0, loco_id, 0, DC_EXEC, CMD_START_STOP_ROADVEH);
DoCommand(0, loco_id, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
if (p->ai.num_want_fullload != 0) p->ai.num_want_fullload--;
if (--p->ai.num_loco_to_build == 0) p->ai.state = AIS_0;
@ -3206,7 +3206,7 @@ static void AiStateDeleteRoadBlocks(Player *p)
b = _road_default_block_data[aib->cur_building_rule]->data;
while (b->mode != 4) {
if (b->mode <= 1) {
DoCommandByTile(TILE_ADD(aib->use_tile, ToTileIndexDiff(b->tileoffs)), 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(TILE_ADD(aib->use_tile, ToTileIndexDiff(b->tileoffs)), 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
}
b++;
}
@ -3306,7 +3306,7 @@ static int32 AiDoBuildDefaultAirportBlock(TileIndex tile, const AiDefaultBlockDa
for (; p->mode == 0; p++) {
if (!HASBIT(_avail_aircraft, p->attr)) return CMD_ERROR;
ret = DoCommandByTile(TILE_MASK(tile + ToTileIndexDiff(p->tileoffs)), p->attr,0,flag | DC_AUTO | DC_NO_WATER,CMD_BUILD_AIRPORT);
ret = DoCommand(TILE_MASK(tile + ToTileIndexDiff(p->tileoffs)), p->attr,0,flag | DC_AUTO | DC_NO_WATER,CMD_BUILD_AIRPORT);
if (CmdFailed(ret)) return CMD_ERROR;
total_cost += ret;
}
@ -3464,7 +3464,7 @@ static void AiStateBuildAircraftVehicles(Player *p)
/* XXX - Have the AI pick the hangar terminal in an airport. Eg get airport-type
* and offset to the FIRST depot because the AI picks the st->xy tile */
tile += ToTileIndexDiff(GetAirport(GetStationByTile(tile)->airport_type)->airport_depots[0]);
if (CmdFailed(DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT))) return;
if (CmdFailed(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT))) return;
loco_id = _new_aircraft_id;
for (i=0; p->ai.order_list_blocks[i] != 0xFF; i++) {
@ -3480,12 +3480,12 @@ static void AiStateBuildAircraftVehicles(Player *p)
if (p->ai.num_want_fullload != 0 && (is_pass || i == 0))
order.flags |= OF_FULL_LOAD;
DoCommandByTile(0, loco_id + (i << 16), PackOrder(&order), DC_EXEC, CMD_INSERT_ORDER);
DoCommand(0, loco_id + (i << 16), PackOrder(&order), DC_EXEC, CMD_INSERT_ORDER);
}
DoCommandByTile(0, loco_id, 0, DC_EXEC, CMD_START_STOP_AIRCRAFT);
DoCommand(0, loco_id, 0, DC_EXEC, CMD_START_STOP_AIRCRAFT);
DoCommandByTile(0, loco_id, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
DoCommand(0, loco_id, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
if (p->ai.num_want_fullload != 0) p->ai.num_want_fullload--;
@ -3519,29 +3519,29 @@ static void AiStateSellVeh(Player *p)
if (!IsTileDepotType(v->tile, TRANSPORT_RAIL) || v->u.rail.track != 0x80 || !(v->vehstatus&VS_STOPPED)) {
if (v->current_order.type != OT_GOTO_DEPOT)
DoCommandByTile(0, v->index, 0, DC_EXEC, CMD_TRAIN_GOTO_DEPOT);
DoCommand(0, v->index, 0, DC_EXEC, CMD_TRAIN_GOTO_DEPOT);
goto going_to_depot;
}
// Sell whole train
DoCommandByTile(v->tile, v->index, 1, DC_EXEC, CMD_SELL_RAIL_WAGON);
DoCommand(v->tile, v->index, 1, DC_EXEC, CMD_SELL_RAIL_WAGON);
} else if (v->type == VEH_Road) {
if (!IsTileDepotType(v->tile, TRANSPORT_ROAD) || v->u.road.state != 254 || !(v->vehstatus&VS_STOPPED)) {
if (v->current_order.type != OT_GOTO_DEPOT)
DoCommandByTile(0, v->index, 0, DC_EXEC, CMD_SEND_ROADVEH_TO_DEPOT);
DoCommand(0, v->index, 0, DC_EXEC, CMD_SEND_ROADVEH_TO_DEPOT);
goto going_to_depot;
}
DoCommandByTile(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH);
DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH);
} else if (v->type == VEH_Aircraft) {
if (!IsHangarTile(v->tile) || !(v->vehstatus & VS_STOPPED)) {
if (v->current_order.type != OT_GOTO_DEPOT)
DoCommandByTile(0, v->index, 0, DC_EXEC, CMD_SEND_AIRCRAFT_TO_HANGAR);
DoCommand(0, v->index, 0, DC_EXEC, CMD_SEND_AIRCRAFT_TO_HANGAR);
goto going_to_depot;
}
DoCommandByTile(0, v->index, 0, DC_EXEC, CMD_SELL_AIRCRAFT);
DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_AIRCRAFT);
} else if (v->type == VEH_Ship) {
// XXX: not implemented
error("!v->type == VEH_Ship");
@ -3589,7 +3589,7 @@ static void AiStateRemoveStation(Player *p)
(tile = st->train_tile) != 0 ||
(tile = st->dock_tile) != 0 ||
(tile = st->airport_tile) != 0)) {
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
}
used++;
}
@ -3657,7 +3657,7 @@ pos_3:
if (GetRailTrackStatus(tile + TileOffsByDir(dir)) & _depot_bits[dir])
return;
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
}
} else if (IsTileType(tile, MP_STREET)) {
if (!IsTileOwner(tile, _current_player)) return;
@ -3690,8 +3690,8 @@ pos_3:
dir = GetRoadDepotDirection(tile);
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommandByTile(
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(
TILE_MASK(tile + TileOffsByDir(dir)),
DiagDirToRoadBits(ReverseDiagDir(dir)),
0,
@ -3833,7 +3833,7 @@ static void AiHandleTakeover(Player *p)
// Computer wants to buy it.
old_p = _current_player;
_current_player = p->index;
DoCommandByTile(0, old_p, 0, DC_EXEC, CMD_BUY_COMPANY);
DoCommand(0, old_p, 0, DC_EXEC, CMD_BUY_COMPANY);
_current_player = old_p;
}
}
@ -3846,14 +3846,14 @@ static void AiAdjustLoan(Player *p)
if (p->player_money > base * 1400) {
// Decrease loan
if (p->current_loan != 0) {
DoCommandByTile(0, 0, 0, DC_EXEC, CMD_DECREASE_LOAN);
DoCommand(0, 0, 0, DC_EXEC, CMD_DECREASE_LOAN);
}
} else if (p->player_money < base * 500) {
// Increase loan
if (p->current_loan < _economy.max_loan &&
p->num_valid_stat_ent >= 2 &&
-(p->old_economy[0].expenses+p->old_economy[1].expenses) < base * 60) {
DoCommandByTile(0, 0, 0, DC_EXEC, CMD_INCREASE_LOAN);
DoCommand(0, 0, 0, DC_EXEC, CMD_INCREASE_LOAN);
}
}
}
@ -3865,7 +3865,7 @@ static void AiBuildCompanyHQ(Player *p)
if (p->location_of_house == 0 &&
p->last_build_coordinate != 0) {
tile = AdjustTileCoordRandomly(p->last_build_coordinate, 8);
DoCommandByTile(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ);
DoCommand(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ);
}
}

24
aircraft_cmd.c
View File

@ -130,16 +130,15 @@ static int32 EstimateAircraftCost(EngineID engine_type)
/** Build an aircraft.
* @param x,y tile coordinates of depot where aircraft is built
* @param tile tile of depot where aircraft is built
* @param p1 aircraft type being built (engine)
* @param p2 unused
*/
int32 CmdBuildAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int32 value;
Vehicle *vl[3], *v, *u, *w;
UnitID unit_num;
TileIndex tile = TileVirtXY(x, y);
const AircraftVehicleInfo *avi;
Engine *e;
@ -166,6 +165,9 @@ int32 CmdBuildAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2)
return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
if (flags & DC_EXEC) {
uint x;
uint y;
v = vl[0];
u = vl[1];
@ -322,11 +324,11 @@ static void DoDeleteAircraft(Vehicle *v)
}
/** Sell an aircraft.
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID to be sold
* @param p2 unused
*/
int32 CmdSellAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSellAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
@ -351,11 +353,11 @@ int32 CmdSellAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Start/Stop an aircraft.
* @param x,y unused
* @param tile unused
* @param p1 aircraft ID to start/stop
* @param p2 unused
*/
int32 CmdStartStopAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdStartStopAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
@ -384,14 +386,14 @@ int32 CmdStartStopAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Send an aircraft to the hangar.
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID to send to the hangar
* @param p2 various bitmasked elements
* - p2 = 0 - aircraft goes to the depot and stays there (user command)
* - p2 non-zero - aircraft will try to goto a depot, but not stop there (eg forced servicing)
* - p2 (bit 17) - aircraft will try to goto a depot at the next airport
*/
int32 CmdSendAircraftToHangar(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSendAircraftToHangar(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
@ -447,12 +449,12 @@ int32 CmdSendAircraftToHangar(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/** Refits an aircraft to the specified cargo type.
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID of the aircraft to refit
* @param p2 various bitstuffed elements
* - p2 = (bit 0-7) - the new cargo type to refit to
*/
int32 CmdRefitAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRefitAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
int pass, mail;

2
aircraft_gui.c
View File

@ -244,7 +244,7 @@ static void AircraftRefitWndProc(Window *w, WindowEvent *e)
WP(w,refit_d).cargo = DrawVehicleRefitWindow(v, WP(w, refit_d).sel);
if (WP(w,refit_d).cargo != CT_INVALID) {
int32 cost = DoCommandByTile(v->tile, v->index, WP(w,refit_d).cargo, DC_QUERY_COST, CMD_REFIT_AIRCRAFT);
int32 cost = DoCommand(v->tile, v->index, WP(w,refit_d).cargo, DC_QUERY_COST, CMD_REFIT_AIRCRAFT);
if (!CmdFailed(cost)) {
SetDParam(2, cost);
SetDParam(0, _cargoc.names_long[WP(w,refit_d).cargo]);

2
bridge_gui.c
View File

@ -128,7 +128,7 @@ void ShowBuildBridgeWindow(TileIndex start, TileIndex end, byte bridge_type)
// only query bridge building possibility once, result is the same for all bridges!
// returns CMD_ERROR on failure, and price on success
ret = DoCommandByTile(end, start, (bridge_type << 8), DC_AUTO | DC_QUERY_COST, CMD_BUILD_BRIDGE);
ret = DoCommand(end, start, (bridge_type << 8), DC_AUTO | DC_QUERY_COST, CMD_BUILD_BRIDGE);
if (CmdFailed(ret)) {
errmsg = _error_message;

43
clear_cmd.c
View File

@ -96,7 +96,7 @@ static int TerraformProc(TerraformerState *ts, TileIndex tile, int mode)
return r;
if (!IsTileType(tile, MP_RAILWAY)) {
int32 ret = DoCommandByTile(tile, 0,0, ts->flags & ~DC_EXEC, CMD_LANDSCAPE_CLEAR);
int32 ret = DoCommand(tile, 0,0, ts->flags & ~DC_EXEC, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) {
_terraform_err_tile = tile;
@ -183,14 +183,13 @@ static bool TerraformTileHeight(TerraformerState *ts, TileIndex tile, int height
}
/** Terraform land
* @param x,y coordinates to terraform
* @param tile tile to terraform
* @param p1 corners to terraform.
* @param p2 direction; eg up or down
*/
int32 CmdTerraformLand(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdTerraformLand(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TerraformerState ts;
TileIndex tile;
int direction;
TerraformerHeightMod modheight_data[576];
@ -208,8 +207,6 @@ int32 CmdTerraformLand(int x, int y, uint32 flags, uint32 p1, uint32 p2)
ts.modheight = modheight_data;
ts.tile_table = tile_table_data;
tile = TileVirtXY(x, y);
/* Make an extra check for map-bounds cause we add tiles to the originating tile */
if (tile + TileDiffXY(1, 1) >= MapSize()) return CMD_ERROR;
@ -275,7 +272,7 @@ int32 CmdTerraformLand(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int count;
TileIndex *ti = ts.tile_table;
for (count = ts.tile_table_count; count != 0; count--, ti++) {
DoCommandByTile(*ti, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
DoCommand(*ti, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
}
}
@ -307,16 +304,17 @@ int32 CmdTerraformLand(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/** Levels a selected (rectangle) area of land
* @param x,y end tile of area-drag
* @param tile end tile of area-drag
* @param p1 start tile of area drag
* @param p2 unused
*/
int32 CmdLevelLand(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
int32 CmdLevelLand(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int size_x, size_y;
int ex;
int ey;
int sx, sy;
uint h, curh;
TileIndex tile;
int32 ret, cost, money;
if (p1 >= MapSize()) return CMD_ERROR;
@ -326,9 +324,9 @@ int32 CmdLevelLand(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
// remember level height
h = TileHeight(p1);
ex >>= 4; ey >>= 4;
// make sure sx,sy are smaller than ex,ey
ex = TileX(tile);
ey = TileY(tile);
sx = TileX(p1);
sy = TileY(p1);
if (ex < sx) intswap(ex, sx);
@ -344,7 +342,7 @@ int32 CmdLevelLand(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
BEGIN_TILE_LOOP(tile2, size_x, size_y, tile) {
curh = TileHeight(tile2);
while (curh != h) {
ret = DoCommandByTile(tile2, 8, (curh > h) ? 0 : 1, flags & ~DC_EXEC, CMD_TERRAFORM_LAND);
ret = DoCommand(tile2, 8, (curh > h) ? 0 : 1, flags & ~DC_EXEC, CMD_TERRAFORM_LAND);
if (CmdFailed(ret)) break;
cost += ret;
@ -353,7 +351,7 @@ int32 CmdLevelLand(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
_additional_cash_required = ret;
return cost - ret;
}
DoCommandByTile(tile2, 8, (curh > h) ? 0 : 1, flags, CMD_TERRAFORM_LAND);
DoCommand(tile2, 8, (curh > h) ? 0 : 1, flags, CMD_TERRAFORM_LAND);
}
curh += (curh > h) ? -1 : 1;
@ -365,26 +363,23 @@ int32 CmdLevelLand(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
/** Purchase a land area. Actually you only purchase one tile, so
* the name is a bit confusing ;p
* @param x,y the tile the player is purchasing
* @param tile the tile the player is purchasing
* @param p1 unused
* @param p2 unused
*/
int32 CmdPurchaseLandArea(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdPurchaseLandArea(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile;
int32 cost;
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
tile = TileVirtXY(x, y);
if (!EnsureNoVehicle(tile)) return CMD_ERROR;
if (IsOwnedLandTile(tile) && IsTileOwner(tile, _current_player)) {
return_cmd_error(STR_5807_YOU_ALREADY_OWN_IT);
}
cost = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
cost = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(cost)) return CMD_ERROR;
if (flags & DC_EXEC) {
@ -422,18 +417,14 @@ static int32 ClearTile_Clear(TileIndex tile, byte flags)
/** Sell a land area. Actually you only sell one tile, so
* the name is a bit confusing ;p
* @param x,y the tile the player is selling
* @param tile the tile the player is selling
* @param p1 unused
* @param p2 unused
*/
int32 CmdSellLandArea(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSellLandArea(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile;
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
tile = TileVirtXY(x, y);
if (!IsOwnedLandTile(tile)) return CMD_ERROR;
if (!CheckTileOwnership(tile) && _current_player != OWNER_WATER) return CMD_ERROR;

25
command.c
View File

@ -13,7 +13,7 @@
const char* _cmd_text = NULL;
#define DEF_COMMAND(yyyy) int32 yyyy(int x, int y, uint32 flags, uint32 p1, uint32 p2)
#define DEF_COMMAND(yyyy) int32 yyyy(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
DEF_COMMAND(CmdBuildRailroadTrack);
DEF_COMMAND(CmdRemoveRailroadTrack);
@ -315,21 +315,16 @@ bool IsValidCommand(uint cmd)
byte GetCommandFlags(uint cmd) {return _command_proc_table[cmd & 0xFF].flags;}
int32 DoCommandByTile(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint procc)
{
return DoCommand(TileX(tile) * TILE_SIZE, TileY(tile) * TILE_SIZE, p1, p2, flags, procc);
}
static int _docommand_recursive;
int32 DoCommand(int x, int y, uint32 p1, uint32 p2, uint32 flags, uint procc)
int32 DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint procc)
{
int32 res;
CommandProc *proc;
/* Do not even think about executing out-of-bounds tile-commands */
if (TileVirtXY(x, y) >= MapSize()) {
if (tile >= MapSize()) {
_cmd_text = NULL;
return CMD_ERROR;
}
@ -342,7 +337,7 @@ int32 DoCommand(int x, int y, uint32 p1, uint32 p2, uint32 flags, uint procc)
// only execute the test call if it's toplevel, or we're not execing.
if (_docommand_recursive == 1 || !(flags & DC_EXEC) || (flags & DC_FORCETEST) ) {
res = proc(x, y, flags&~DC_EXEC, p1, p2);
res = proc(tile, flags & ~DC_EXEC, p1, p2);
if (CmdFailed(res)) {
if (res & 0xFFFF) _error_message = res & 0xFFFF;
goto error;
@ -362,7 +357,7 @@ int32 DoCommand(int x, int y, uint32 p1, uint32 p2, uint32 flags, uint procc)
/* Execute the command here. All cost-relevant functions set the expenses type
* themselves with "SET_EXPENSES_TYPE(...);" at the beginning of the function */
res = proc(x, y, flags, p1, p2);
res = proc(tile, flags, p1, p2);
if (CmdFailed(res)) {
if (res & 0xFFFF) _error_message = res & 0xFFFF;
error:
@ -375,8 +370,8 @@ error:
if (--_docommand_recursive == 0) {
SubtractMoneyFromPlayer(res);
// XXX - Old AI hack which doesn't use DoCommandDP; update last build coord of player
if ( (x|y) != 0 && _current_player < MAX_PLAYERS) {
GetPlayer(_current_player)->last_build_coordinate = TileVirtXY(x, y);
if (tile != 0 && _current_player < MAX_PLAYERS) {
GetPlayer(_current_player)->last_build_coordinate = tile;
}
}
@ -457,7 +452,7 @@ bool DoCommandP(TileIndex tile, uint32 p1, uint32 p2, CommandCallback *callback,
// cost estimation only?
if (_shift_pressed && IsLocalPlayer() && !(cmd & (CMD_NETWORK_COMMAND | CMD_SHOW_NO_ERROR))) {
// estimate the cost.
res = proc(x, y, flags, p1, p2);
res = proc(tile, flags, p1, p2);
if (CmdFailed(res)) {
if (res & 0xFFFF) _error_message = res & 0xFFFF;
ShowErrorMessage(_error_message, error_part1, x, y);
@ -473,7 +468,7 @@ bool DoCommandP(TileIndex tile, uint32 p1, uint32 p2, CommandCallback *callback,
if (!((cmd & CMD_NO_TEST_IF_IN_NETWORK) && _networking)) {
// first test if the command can be executed.
res = proc(x,y, flags, p1, p2);
res = proc(tile, flags, p1, p2);
if (CmdFailed(res)) {
if (res & 0xFFFF) _error_message = res & 0xFFFF;
goto show_error;
@ -505,7 +500,7 @@ bool DoCommandP(TileIndex tile, uint32 p1, uint32 p2, CommandCallback *callback,
/* Actually try and execute the command. If no cost-type is given
* use the construction one */
_yearly_expenses_type = EXPENSES_CONSTRUCTION;
res2 = proc(x,y, flags|DC_EXEC, p1, p2);
res2 = proc(tile, flags|DC_EXEC, p1, p2);
// If notest is on, it means the result of the test can be different than
// the real command.. so ignore the test

5
command.h
View File

@ -169,6 +169,8 @@ enum {
CMD_OFFLINE = 0x2, /// the command cannot be executed in a multiplayer game; single-player only
};
typedef int32 CommandProc(TileIndex tile, uint32 flags, uint32 p1, uint32 p2);
typedef struct Command {
CommandProc *proc;
byte flags;
@ -189,8 +191,7 @@ static inline bool CmdFailed(int32 res)
}
/* command.c */
int32 DoCommand(int x, int y, uint32 p1, uint32 p2, uint32 flags, uint procc);
int32 DoCommandByTile(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint procc);
int32 DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint procc);
extern const char* _cmd_text; // Text, which gets sent with a command

2
disaster_cmd.c
View File

@ -33,7 +33,7 @@ static void DisasterClearSquare(TileIndex tile)
case MP_HOUSE: {
PlayerID p = _current_player;
_current_player = OWNER_NONE;
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
_current_player = p;
break;
}

12
economy.c
View File

@ -1531,11 +1531,11 @@ static void DoAcquireCompany(Player *p)
extern int GetAmountOwnedBy(Player *p, byte owner);
/** Acquire shares in an opposing company.
* @param x,y unused
* @param tile unused
* @param p1 player to buy the shares from
* @param p2 unused
*/
int32 CmdBuyShareInCompany(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuyShareInCompany(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Player *p;
int64 cost;
@ -1576,11 +1576,11 @@ int32 CmdBuyShareInCompany(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Sell shares in an opposing company.
* @param x,y unused
* @param tile unused
* @param p1 player to sell the shares from
* @param p2 unused
*/
int32 CmdSellShareInCompany(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSellShareInCompany(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Player *p;
int64 cost;
@ -1611,11 +1611,11 @@ int32 CmdSellShareInCompany(int x, int y, uint32 flags, uint32 p1, uint32 p2)
* When a competing company is gone bankrupt you get the chance to purchase
* that company.
* @todo currently this only works for AI players
* @param x,y unused
* @param tile unused
* @param p1 player/company to buy up
* @param p2 unused
*/
int32 CmdBuyCompany(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuyCompany(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Player *p;

8
engine.c
View File

@ -334,11 +334,11 @@ void EnginesDailyLoop(void)
/** Accept an engine prototype. XXX - it is possible that the top-player
* changes while you are waiting to accept the offer? Then it becomes invalid
* @param x,y unused
* @param tile unused
* @param p1 engine-prototype offered
* @param p2 unused
*/
int32 CmdWantEnginePreview(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdWantEnginePreview(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Engine *e;
@ -445,11 +445,11 @@ void EnginesMonthlyLoop(void)
}
/** Rename an engine.
* @param x,y unused
* @param tile unused
* @param p1 engine ID to rename
* @param p2 unused
*/
int32 CmdRenameEngine(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRenameEngine(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
StringID str;

11
industry_cmd.c
View File

@ -1030,7 +1030,7 @@ static void ChopLumberMillTrees(Industry *i)
_industry_sound_tile = tile;
SndPlayTileFx(SND_38_CHAINSAW, tile);
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
SetTropicZone(tile, TROPICZONE_INVALID);
i->cargo_waiting[0] = min(0xffff, i->cargo_waiting[0] + 45);
@ -1348,7 +1348,7 @@ static bool CheckIfIndustryTilesAreFree(TileIndex tile, const IndustryTileTable*
}
} else {
do_clear:
if (CmdFailed(DoCommandByTile(cur_tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR)))
if (CmdFailed(DoCommand(cur_tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR)))
return false;
}
}
@ -1474,7 +1474,7 @@ static void DoCreateNewIndustry(Industry* i, TileIndex tile, int type, const Ind
size = it->ti.y;
if (size > i->height)i->height = size;
DoCommandByTile(cur_tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(cur_tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
MakeIndustry(cur_tile, i->index, it->gfx);
if (_generating_world) _m[cur_tile].m1 = 0x1E; /* maturity */
@ -1499,15 +1499,14 @@ static void DoCreateNewIndustry(Industry* i, TileIndex tile, int type, const Ind
}
/** Build/Fund an industry
* @param x,y coordinates where industry is built
* @param tile tile where industry is built
* @param p1 industry type @see build_industry.h and @see industry.h
* @param p2 unused
*/
int32 CmdBuildIndustry(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildIndustry(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
const Town* t;
Industry *i;
TileIndex tile = TileVirtXY(x, y);
int num;
const IndustryTileTable * const *itt;
const IndustryTileTable *it;

18
landscape.c
View File

@ -272,27 +272,27 @@ void GetTileDesc(TileIndex tile, TileDesc *td)
}
/** Clear a piece of landscape
* @param x,y coordinates of clearance
* @param tile tile to clear
* @param p1 unused
* @param p2 unused
*/
int32 CmdLandscapeClear(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdLandscapeClear(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile = TileVirtXY(x, y);
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
return _tile_type_procs[GetTileType(tile)]->clear_tile_proc(tile, flags);
}
/** Clear a big piece of landscape
* @param x,y end coordinates of area dragging
* @param tile end tile of area dragging
* @param p1 start tile of area dragging
* @param p2 unused
*/
int32 CmdClearArea(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
int32 CmdClearArea(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int32 cost, ret, money;
int ex;
int ey;
int sx,sy;
int x,y;
bool success = false;
@ -302,6 +302,8 @@ int32 CmdClearArea(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
// make sure sx,sy are smaller than ex,ey
ex = TileX(tile) * TILE_SIZE;
ey = TileY(tile) * TILE_SIZE;
sx = TileX(p1) * TILE_SIZE;
sy = TileY(p1) * TILE_SIZE;
if (ex < sx) intswap(ex, sx);
@ -312,7 +314,7 @@ int32 CmdClearArea(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
for (x = sx; x <= ex; x += TILE_SIZE) {
for (y = sy; y <= ey; y += TILE_SIZE) {
ret = DoCommandByTile(TileVirtXY(x, y), 0, 0, flags & ~DC_EXEC, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(TileVirtXY(x, y), 0, 0, flags & ~DC_EXEC, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) continue;
cost += ret;
success = true;
@ -322,7 +324,7 @@ int32 CmdClearArea(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
_additional_cash_required = ret;
return cost - ret;
}
DoCommandByTile(TileVirtXY(x, y), 0, 0, flags, CMD_LANDSCAPE_CLEAR);
DoCommand(TileVirtXY(x, y), 0, 0, flags, CMD_LANDSCAPE_CLEAR);
// draw explosion animation...
if ((x == sx || x == ex) && (y == sy || y == ey)) {

42
misc_cmd.c
View File

@ -15,11 +15,11 @@
#include "variables.h"
/** Change the player's face.
* @param x,y unused
* @param tile unused
* @param p1 unused
* @param p2 face bitmasked
*/
int32 CmdSetPlayerFace(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSetPlayerFace(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
if (flags & DC_EXEC) {
GetPlayer(_current_player)->face = p2;
@ -29,11 +29,11 @@ int32 CmdSetPlayerFace(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Change the player's company-colour
* @param x,y unused
* @param tile unused
* @param p1 unused
* @param p2 new colour for vehicles, property, etc.
*/
int32 CmdSetPlayerColor(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSetPlayerColor(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Player *p, *pp;
byte colour;
@ -58,11 +58,11 @@ int32 CmdSetPlayerColor(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Increase the loan of your company.
* @param x,y unused
* @param tile unused
* @param p1 unused
* @param p2 when set, loans the maximum amount in one go (press CTRL)
*/
int32 CmdIncreaseLoan(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdIncreaseLoan(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Player *p;
@ -87,11 +87,11 @@ int32 CmdIncreaseLoan(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Decrease the loan of your company.
* @param x,y unused
* @param tile unused
* @param p1 unused
* @param p2 when set, pays back the maximum loan permitting money (press CTRL)
*/
int32 CmdDecreaseLoan(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdDecreaseLoan(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Player *p;
int32 loan;
@ -127,11 +127,11 @@ int32 CmdDecreaseLoan(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Change the name of the company.
* @param x,y unused
* @param tile unused
* @param p1 unused
* @param p2 unused
*/
int32 CmdChangeCompanyName(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdChangeCompanyName(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
StringID str;
Player *p;
@ -153,11 +153,11 @@ int32 CmdChangeCompanyName(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Change the name of the president.
* @param x,y unused
* @param tile unused
* @param p1 unused
* @param p2 unused
*/
int32 CmdChangePresidentName(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdChangePresidentName(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
StringID str;
Player *p;
@ -177,7 +177,7 @@ int32 CmdChangePresidentName(int x, int y, uint32 flags, uint32 p1, uint32 p2)
snprintf(buf, lengthof(buf), "%s Transport", _cmd_text);
_cmd_text = buf;
DoCommandByTile(0, 0, 0, DC_EXEC, CMD_CHANGE_COMPANY_NAME);
DoCommand(0, 0, 0, DC_EXEC, CMD_CHANGE_COMPANY_NAME);
}
MarkWholeScreenDirty();
} else
@ -190,11 +190,11 @@ int32 CmdChangePresidentName(int x, int y, uint32 flags, uint32 p1, uint32 p2)
* Increase or decrease the pause counter. If the counter is zero,
* the game is unpaused. A counter is used instead of a boolean value
* to have more control over the game when saving/loading, etc.
* @param x,y unused
* @param tile unused
* @param p1 0 = decrease pause counter; 1 = increase pause counter
* @param p2 unused
*/
int32 CmdPause(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdPause(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
if (flags & DC_EXEC) {
_pause += (p1 == 1) ? 1 : -1;
@ -208,11 +208,11 @@ int32 CmdPause(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/** Change the financial flow of your company.
* This is normally only enabled in offline mode, but if there is a debug
* build, you can cheat (to test).
* @param x,y unused
* @param tile unused
* @param p1 the amount of money to receive (if negative), or spend (if positive)
* @param p2 unused
*/
int32 CmdMoneyCheat(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdMoneyCheat(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
#ifndef _DEBUG
if (_networking) return CMD_ERROR;
@ -225,11 +225,11 @@ int32 CmdMoneyCheat(int x, int y, uint32 flags, uint32 p1, uint32 p2)
* To prevent abuse in multiplayer games you can only send money to other
* players if you have paid off your loan (either explicitely, or implicitely
* given the fact that you have more money than loan).
* @param x,y unused
* @param tile unused
* @param p1 the amount of money to transfer; max 20.000.000
* @param p2 the player to transfer the money to
*/
int32 CmdGiveMoney(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdGiveMoney(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
const Player *p = GetPlayer(_current_player);
int32 amount = min((int32)p1, 20000000);
@ -256,12 +256,12 @@ int32 CmdGiveMoney(int x, int y, uint32 flags, uint32 p1, uint32 p2)
* We cannot really check for valid values of p2 (too much work mostly); stored
* in file 'settings_gui.c' _game_setting_info[]; we'll just trust the server it knows
* what to do and does this correctly
* @param x,y unused
* @param tile unused
* @param p1 the difficulty setting being changed. If it is -1, the difficulty level
* itself is changed. The new value is inside p2
* @param p2 new value for a difficulty setting or difficulty level
*/
int32 CmdChangeDifficultyLevel(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdChangeDifficultyLevel(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
if (p1 != (uint32)-1L && ((int32)p1 >= GAME_DIFFICULTY_NUM || (int32)p1 < 0)) return CMD_ERROR;

2
misc_gui.c
View File

@ -147,7 +147,7 @@ static void Place_LandInfo(TileIndex tile)
old_money = p->money64;
p->money64 = p->player_money = 0x7fffffff;
lid.costclear = DoCommandByTile(tile, 0, 0, 0, CMD_LANDSCAPE_CLEAR);
lid.costclear = DoCommand(tile, 0, 0, 0, CMD_LANDSCAPE_CLEAR);
p->money64 = old_money;
UpdatePlayerMoney32(p);

1
openttd.h
View File

@ -295,7 +295,6 @@ typedef struct {
byte width_1, width_2;
} ViewportSign;
typedef int32 CommandProc(int x, int y, uint32 flags, uint32 p1, uint32 p2);
typedef void DrawTileProc(TileInfo *ti);
typedef uint GetSlopeZProc(const TileInfo* ti);

22
order_cmd.c
View File

@ -160,7 +160,7 @@ static void DeleteOrderWarnings(const Vehicle* v)
/** Add an order to the orderlist of a vehicle.
* @param x,y unused
* @param tile unused
* @param p1 various bitstuffed elements
* - p1 = (bit 0 - 15) - ID of the vehicle
* - p1 = (bit 16 - 31) - the selected order (if any). If the last order is given,
@ -168,7 +168,7 @@ static void DeleteOrderWarnings(const Vehicle* v)
* only the first 8 bits used currently (bit 16 - 23) (max 255)
* @param p2 packed order to insert
*/
int32 CmdInsertOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdInsertOrder(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
VehicleID veh = GB(p1, 0, 16);
@ -427,11 +427,11 @@ static int32 DecloneOrder(Vehicle *dst, uint32 flags)
}
/** Delete an order from the orderlist of a vehicle.
* @param x,y unused
* @param tile unused
* @param p1 the ID of the vehicle
* @param p2 the order to delete (max 255)
*/
int32 CmdDeleteOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdDeleteOrder(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v, *u;
VehicleID veh_id = p1;
@ -501,11 +501,11 @@ int32 CmdDeleteOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Goto next order of order-list.
* @param x,y unused
* @param tile unused
* @param p1 The ID of the vehicle which order is skipped
* @param p2 unused
*/
int32 CmdSkipOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSkipOrder(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
VehicleID veh_id = p1;
@ -542,7 +542,7 @@ int32 CmdSkipOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/** Modify an order in the orderlist of a vehicle.
* @param x,y unused
* @param tile unused
* @param p1 various bitstuffed elements
* - p1 = (bit 0 - 15) - ID of the vehicle
* - p1 = (bit 16 - 31) - the selected order (if any). If the last order is given,
@ -550,7 +550,7 @@ int32 CmdSkipOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)
* only the first 8 bits used currently (bit 16 - 23) (max 255)
* @param p2 mode to change the order to (always set)
*/
int32 CmdModifyOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdModifyOrder(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
Order *order;
@ -617,7 +617,7 @@ int32 CmdModifyOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)
* - p1 = (bit 16-31) - source vehicle to clone orders from, if any (none for CO_UNSHARE)
* @param p2 mode of cloning: CO_SHARE, CO_COPY, or CO_UNSHARE
*/
int32 CmdCloneOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdCloneOrder(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *dst;
VehicleID veh_src = GB(p1, 16, 16);
@ -821,7 +821,7 @@ void RestoreVehicleOrders(const Vehicle* v, const BackuppedOrders* bak)
}
/** Restore the current order-index of a vehicle and sets service-interval.
* @param x,y unused
* @param tile unused
* @param p1 the ID of the vehicle
* @param p2 various bistuffed elements
* - p2 = (bit 0-15) - current order-index (p2 & 0xFFFF)
@ -833,7 +833,7 @@ void RestoreVehicleOrders(const Vehicle* v, const BackuppedOrders* bak)
* If we do want to backup/restore it, just add UnitID uid to BackuppedOrders, and
* restore it as parameter 'y' (ugly hack I know) for example. "v->unitnumber = y;"
*/
int32 CmdRestoreOrderIndex(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRestoreOrderIndex(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
OrderID cur_ord = GB(p2, 0, 16);

8
players.c
View File

@ -651,7 +651,7 @@ static void DeletePlayerStuff(PlayerID pi)
}
/** Change engine renewal parameters
* @param x,y unused
* @param tile unused
* @param p1 bits 0-3 command
* - p1 = 0 - change auto renew bool
* - p1 = 1 - change auto renew months
@ -676,7 +676,7 @@ static void DeletePlayerStuff(PlayerID pi)
* if p1 = 5, then
* - p2 = enable renew_keep_length
*/
int32 CmdReplaceVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdReplaceVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Player *p;
if (!(_current_player < MAX_PLAYERS))
@ -784,7 +784,7 @@ int32 CmdReplaceVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Control the players: add, delete, etc.
* @param x,y unused
* @param tile unused
* @param p1 various functionality
* - p1 = 0 - create a new player, Which player (network) it will be is in p2
* - p1 = 1 - create a new AI player
@ -802,7 +802,7 @@ int32 CmdReplaceVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
* @arg - network_server.c:838 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_COMMAND)@n
* @arg - network_client.c:536 DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_MAP) from where the map has been received
*/
int32 CmdPlayerCtrl(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdPlayerCtrl(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
if (flags & DC_EXEC) _current_player = OWNER_NONE;

93
rail_cmd.c
View File

@ -230,13 +230,12 @@ static uint32 CheckRailSlope(uint tileh, TrackBits rail_bits, TrackBits existing
static inline bool ValParamTrackOrientation(Track track) {return IsValidTrack(track);}
/** Build a single piece of rail
* @param x,y coordinates on where to build
* @param tile tile to build on
* @param p1 railtype of being built piece (normal, mono, maglev)
* @param p2 rail track to build
*/
int32 CmdBuildSingleRail(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildSingleRail(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile;
uint tileh;
Track track = (Track)p2;
TrackBits trackbit;
@ -245,7 +244,6 @@ int32 CmdBuildSingleRail(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (!ValParamRailtype(p1) || !ValParamTrackOrientation(track)) return CMD_ERROR;
tile = TileVirtXY(x, y);
tileh = GetTileSlope(tile, NULL);
trackbit = TrackToTrackBits(track);
@ -257,7 +255,7 @@ int32 CmdBuildSingleRail(int x, int y, uint32 flags, uint32 p1, uint32 p2)
!IsBridgeMiddle(tile) ||
(GetBridgeAxis(tile) == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X) != trackbit) {
// Get detailed error message
return DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
}
if (IsClearUnderBridge(tile)) {
@ -271,7 +269,7 @@ int32 CmdBuildSingleRail(int x, int y, uint32 flags, uint32 p1, uint32 p2)
return_cmd_error(STR_1007_ALREADY_BUILT);
} else {
// Get detailed error message
return DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
}
break;
@ -284,7 +282,7 @@ int32 CmdBuildSingleRail(int x, int y, uint32 flags, uint32 p1, uint32 p2)
!IsTileOwner(tile, _current_player) ||
GetRailType(tile) != p1) {
// Get detailed error message
return DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
}
ret = CheckRailSlope(tileh, trackbit, GetTrackBits(tile), tile);
@ -327,7 +325,7 @@ int32 CmdBuildSingleRail(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (CmdFailed(ret)) return ret;
cost += ret;
ret = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return ret;
cost += ret;
@ -344,15 +342,14 @@ int32 CmdBuildSingleRail(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Remove a single piece of track
* @param x,y coordinates for removal of track
* @param tile tile to remove track from
* @param p1 unused
* @param p2 rail orientation
*/
int32 CmdRemoveSingleRail(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRemoveSingleRail(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Track track = (Track)p2;
TrackBits trackbit;
TileIndex tile;
int32 cost = _price.remove_rail;
bool crossing = false;
@ -361,8 +358,6 @@ int32 CmdRemoveSingleRail(int x, int y, uint32 flags, uint32 p1, uint32 p2)
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
tile = TileVirtXY(x, y);
switch (GetTileType(tile)) {
case MP_TUNNELBRIDGE:
if (!IsBridge(tile) ||
@ -407,7 +402,7 @@ int32 CmdRemoveSingleRail(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/* Charge extra to remove signals on the track, if they are there */
if (HasSignalOnTrack(tile, track))
cost += DoCommand(x, y, track, 0, flags, CMD_REMOVE_SIGNALS);
cost += DoCommand(tile, track, 0, flags, CMD_REMOVE_SIGNALS);
if (flags & DC_EXEC) {
present ^= trackbit;
@ -499,15 +494,17 @@ static int32 ValidateAutoDrag(Trackdir *trackdir, int x, int y, int ex, int ey)
}
/** Build a stretch of railroad tracks.
* @param x,y start tile of drag
* @param tile start tile of drag
* @param p1 end tile of drag
* @param p2 various bitstuffed elements
* - p2 = (bit 0-3) - railroad type normal/maglev (0 = normal, 1 = mono, 2 = maglev)
* - p2 = (bit 4-6) - track-orientation, valid values: 0-5 (Track enum)
* - p2 = (bit 7) - 0 = build, 1 = remove tracks
*/
static int32 CmdRailTrackHelper(int x, int y, uint32 flags, uint32 p1, uint32 p2)
static int32 CmdRailTrackHelper(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int x;
int y;
int ex, ey;
int32 ret, total_cost = 0;
Track track = (Track)GB(p2, 4, 3);
@ -520,6 +517,8 @@ static int32 CmdRailTrackHelper(int x, int y, uint32 flags, uint32 p1, uint32 p2
trackdir = TrackToTrackdir(track);
/* unpack end point */
x = TileX(tile) * TILE_SIZE;
y = TileY(tile) * TILE_SIZE;
ex = TileX(p1) * TILE_SIZE;
ey = TileY(p1) * TILE_SIZE;
@ -530,7 +529,7 @@ static int32 CmdRailTrackHelper(int x, int y, uint32 flags, uint32 p1, uint32 p2
if (flags & DC_EXEC) SndPlayTileFx(SND_20_SPLAT_2, TileVirtXY(x, y));
for (;;) {
ret = DoCommand(x, y, railtype, TrackdirToTrack(trackdir), flags, (mode == 0) ? CMD_BUILD_SINGLE_RAIL : CMD_REMOVE_SINGLE_RAIL);
ret = DoCommand(TileVirtXY(x, y), railtype, TrackdirToTrack(trackdir), flags, (mode == 0) ? CMD_BUILD_SINGLE_RAIL : CMD_REMOVE_SINGLE_RAIL);
if (CmdFailed(ret)) {
if ((_error_message != STR_1007_ALREADY_BUILT) && (mode == 0))
@ -555,32 +554,31 @@ static int32 CmdRailTrackHelper(int x, int y, uint32 flags, uint32 p1, uint32 p2
* Stub for the unified rail builder/remover
* @see CmdRailTrackHelper
*/
int32 CmdBuildRailroadTrack(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildRailroadTrack(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
return CmdRailTrackHelper(x, y, flags, p1, CLRBIT(p2, 7));
return CmdRailTrackHelper(tile, flags, p1, CLRBIT(p2, 7));
}
/** Build rail on a stretch of track.
* Stub for the unified rail builder/remover
* @see CmdRailTrackHelper
*/
int32 CmdRemoveRailroadTrack(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRemoveRailroadTrack(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
return CmdRailTrackHelper(x, y, flags, p1, SETBIT(p2, 7));
return CmdRailTrackHelper(tile, flags, p1, SETBIT(p2, 7));
}
/** Build a train depot
* @param x,y position of the train depot
* @param tile position of the train depot
* @param p1 rail type
* @param p2 entrance direction (DiagDirection)
*
* @todo When checking for the tile slope,
* distingush between "Flat land required" and "land sloped in wrong direction"
*/
int32 CmdBuildTrainDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildTrainDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Depot *d;
TileIndex tile = TileVirtXY(x, y);
int32 cost, ret;
uint tileh;
@ -610,7 +608,7 @@ int32 CmdBuildTrainDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
}
ret = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return CMD_ERROR;
cost = ret;
@ -634,16 +632,15 @@ int32 CmdBuildTrainDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/** Build signals, alternate between double/single, signal/semaphore,
* pre/exit/combo-signals, and what-else not
* @param x,y coordinates where signals is being built
* @param tile tile where to build the signals
* @param p1 various bitstuffed elements
* - p1 = (bit 0-2) - track-orientation, valid values: 0-5 (Track enum)
* - p1 = (bit 3) - choose semaphores/signals or cycle normal/pre/exit/combo depending on context
* @param p2 used for CmdBuildManySignals() to copy direction of first signal
* TODO: p2 should be replaced by two bits for "along" and "against" the track.
*/
int32 CmdBuildSingleSignal(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildSingleSignal(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile = TileVirtXY(x, y);
SignalVariant sigvar;
bool pre_signal;
Track track = (Track)(p1 & 0x7);
@ -750,7 +747,7 @@ int32 CmdBuildSingleSignal(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Build many signals by dragging; AutoSignals
* @param x,y start tile of drag
* @param tile start tile of drag
* @param p1 end tile of drag
* @param p2 various bitstuffed elements
* - p2 = (bit 0) - 0 = build, 1 = remove signals
@ -758,12 +755,13 @@ int32 CmdBuildSingleSignal(int x, int y, uint32 flags, uint32 p1, uint32 p2)
* - p2 = (bit 4- 6) - track-orientation, valid values: 0-5 (Track enum)
* - p2 = (bit 24-31) - user defined signals_density
*/
static int32 CmdSignalTrackHelper(int x, int y, uint32 flags, uint32 p1, uint32 p2)
static int32 CmdSignalTrackHelper(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int x;
int y;
int ex, ey;
int32 ret, total_cost, signal_ctr;
byte signals;
TileIndex tile = TileVirtXY(x, y);
bool error = true;
int mode = p2 & 0x1;
@ -785,6 +783,8 @@ static int32 CmdSignalTrackHelper(int x, int y, uint32 flags, uint32 p1, uint32
signal_density *= 2;
// unpack end tile
x = TileX(tile) * TILE_SIZE;
y = TileY(tile) * TILE_SIZE;
ex = TileX(p1) * TILE_SIZE;
ey = TileY(p1) * TILE_SIZE;
@ -814,7 +814,7 @@ static int32 CmdSignalTrackHelper(int x, int y, uint32 flags, uint32 p1, uint32
for (;;) {
// only build/remove signals with the specified density
if ((signal_ctr % signal_density) == 0 ) {
ret = DoCommand(x, y, TrackdirToTrack(trackdir) | semaphores, signals, flags, (mode == 1) ? CMD_REMOVE_SIGNALS : CMD_BUILD_SIGNALS);
ret = DoCommand(TileVirtXY(x, y), TrackdirToTrack(trackdir) | semaphores, signals, flags, (mode == 1) ? CMD_REMOVE_SIGNALS : CMD_BUILD_SIGNALS);
/* Abort placement for any other error than NOT_SUITABLE_TRACK
* This includes vehicles on track, competitor's tracks, etc. */
@ -843,18 +843,17 @@ static int32 CmdSignalTrackHelper(int x, int y, uint32 flags, uint32 p1, uint32
* Stub for the unified signal builder/remover
* @see CmdSignalTrackHelper
*/
int32 CmdBuildSignalTrack(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildSignalTrack(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
return CmdSignalTrackHelper(x, y, flags, p1, p2);
return CmdSignalTrackHelper(tile, flags, p1, p2);
}
/** Remove signals
* @param x,y coordinates where signal is being deleted from
* @param tile coordinates where signal is being deleted from
* @param p1 track to remove signal from (Track enum)
*/
int32 CmdRemoveSingleSignal(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRemoveSingleSignal(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile = TileVirtXY(x, y);
Track track = (Track)(p1 & 0x7);
if (!ValParamTrackOrientation(track) || !IsTileType(tile, MP_RAILWAY) || !EnsureNoVehicle(tile))
@ -891,9 +890,9 @@ int32 CmdRemoveSingleSignal(int x, int y, uint32 flags, uint32 p1, uint32 p2)
* Stub for the unified signal builder/remover
* @see CmdSignalTrackHelper
*/
int32 CmdRemoveSignalTrack(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRemoveSignalTrack(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
return CmdSignalTrackHelper(x, y, flags, p1, SETBIT(p2, 0));
return CmdSignalTrackHelper(tile, flags, p1, SETBIT(p2, 0));
}
typedef int32 DoConvertRailProc(TileIndex tile, RailType totype, bool exec);
@ -922,13 +921,15 @@ extern int32 DoConvertTunnelBridgeRail(TileIndex tile, RailType totype, bool exe
/** Convert one rail type to the other. You can convert normal rail to
* monorail/maglev easily or vice-versa.
* @param ex,ey end tile of rail conversion drag
* @param tile end tile of rail conversion drag
* @param p1 start tile of drag
* @param p2 new railtype to convert to
*/
int32 CmdConvertRail(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
int32 CmdConvertRail(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int32 ret, cost, money;
int ex;
int ey;
int sx, sy, x, y;
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
@ -937,6 +938,8 @@ int32 CmdConvertRail(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
if (p1 >= MapSize()) return CMD_ERROR;
// make sure sx,sy are smaller than ex,ey
ex = TileX(tile) * TILE_SIZE;
ey = TileY(tile) * TILE_SIZE;
sx = TileX(p1) * TILE_SIZE;
sy = TileY(p1) * TILE_SIZE;
if (ex < sx) intswap(ex, sx);
@ -1019,12 +1022,12 @@ static int32 ClearTile_Track(TileIndex tile, byte flags)
/* XXX: Why the fuck do we remove these thow signals first? */
case RAIL_TYPE_SIGNALS:
if (HasSignalOnTrack(tile, TRACK_X)) {
ret = DoCommandByTile(tile, TRACK_X, 0, flags, CMD_REMOVE_SIGNALS);
ret = DoCommand(tile, TRACK_X, 0, flags, CMD_REMOVE_SIGNALS);
if (CmdFailed(ret)) return CMD_ERROR;
cost += ret;
}
if (HasSignalOnTrack(tile, TRACK_LOWER)) {
ret = DoCommandByTile(tile, TRACK_LOWER, 0, flags, CMD_REMOVE_SIGNALS);
ret = DoCommand(tile, TRACK_LOWER, 0, flags, CMD_REMOVE_SIGNALS);
if (CmdFailed(ret)) return CMD_ERROR;
cost += ret;
}
@ -1041,7 +1044,7 @@ static int32 ClearTile_Track(TileIndex tile, byte flags)
for (i = 0; m5 != 0; i++, m5 >>= 1) {
if (m5 & 1) {
ret = DoCommandByTile(tile, 0, i, flags, CMD_REMOVE_SINGLE_RAIL);
ret = DoCommand(tile, 0, i, flags, CMD_REMOVE_SINGLE_RAIL);
if (CmdFailed(ret)) return CMD_ERROR;
cost += ret;
}
@ -2001,7 +2004,7 @@ static void ChangeTileOwner_Track(TileIndex tile, PlayerID old_player, PlayerID
if (new_player != OWNER_SPECTATOR) {
SetTileOwner(tile, new_player);
} else {
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
}
}

2
rail_gui.c
View File

@ -480,7 +480,7 @@ static void BuildRailToolbWndProc(Window *w, WindowEvent *e)
case WE_PLACE_PRESIZE: {
TileIndex tile = e->place.tile;
DoCommandByTile(tile, 0, 0, DC_AUTO, CMD_BUILD_TUNNEL);
DoCommand(tile, 0, 0, DC_AUTO, CMD_BUILD_TUNNEL);
VpSetPresizeRange(tile, _build_tunnel_endtile == 0 ? tile : _build_tunnel_endtile);
} break;

50
road_cmd.c
View File

@ -88,16 +88,15 @@ static bool CheckAllowRemoveRoad(TileIndex tile, RoadBits remove, bool* edge_roa
/** Delete a piece of road.
* @param x,y tile coordinates for road construction
* @param tile tile where to remove road from
* @param p1 road piece flags
* @param p2 unused
*/
int32 CmdRemoveRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRemoveRoad(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
// cost for removing inner/edge -roads
static const uint16 road_remove_cost[2] = {50, 18};
TileIndex tile;
PlayerID owner;
Town *t;
/* true if the roadpiece was always removeable,
@ -111,8 +110,6 @@ int32 CmdRemoveRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (p1 >> 4) return CMD_ERROR;
pieces = p1;
tile = TileVirtXY(x, y);
if (!IsTileType(tile, MP_STREET) && !IsTileType(tile, MP_TUNNELBRIDGE)) return CMD_ERROR;
owner = IsLevelCrossing(tile) ? GetCrossingRoadOwner(tile) : GetTileOwner(tile);
@ -271,17 +268,16 @@ static uint32 CheckRoadSlope(int tileh, RoadBits* pieces, RoadBits existing)
}
/** Build a piece of road.
* @param x,y tile coordinates for road construction
* @param tile tile where to build road
* @param p1 road piece flags
* @param p2 the town that is building the road (0 if not applicable)
*/
int32 CmdBuildRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildRoad(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int32 cost = 0;
int32 ret;
RoadBits existing = 0;
RoadBits pieces;
TileIndex tile;
byte tileh;
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
@ -291,7 +287,6 @@ int32 CmdBuildRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if ((p1 >> 4) || (_current_player < MAX_PLAYERS && p2 != 0) || !IsTownIndex(p2)) return CMD_ERROR;
pieces = p1;
tile = TileVirtXY(x, y);
tileh = GetTileSlope(tile, NULL);
switch (GetTileType(tile)) {
@ -388,7 +383,7 @@ int32 CmdBuildRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
default:
do_clear:;
ret = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return ret;
cost += ret;
}
@ -439,16 +434,16 @@ int32 DoConvertStreetRail(TileIndex tile, RailType totype, bool exec)
/** Build a long piece of road.
* @param x,y end tile of drag
* @param end_tile end tile of drag
* @param p1 start tile of drag
* @param p2 various bitstuffed elements
* - p2 = (bit 0) - start tile starts in the 2nd half of tile (p2 & 1)
* - p2 = (bit 1) - end tile starts in the 2nd half of tile (p2 & 2)
* - p2 = (bit 2) - direction: 0 = along x-axis, 1 = along y-axis (p2 & 4)
*/
int32 CmdBuildLongRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildLongRoad(TileIndex end_tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex start_tile, end_tile, tile;
TileIndex start_tile, tile;
int32 cost, ret;
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
@ -456,7 +451,6 @@ int32 CmdBuildLongRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (p1 >= MapSize()) return CMD_ERROR;
start_tile = p1;
end_tile = TileVirtXY(x, y);
/* Only drag in X or Y direction dictated by the direction variable */
if (!HASBIT(p2, 2) && TileY(start_tile) != TileY(end_tile)) return CMD_ERROR; // x-axis
@ -479,7 +473,7 @@ int32 CmdBuildLongRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (tile == end_tile && !HASBIT(p2, 1)) bits &= ROAD_NW | ROAD_NE;
if (tile == start_tile && HASBIT(p2, 0)) bits &= ROAD_SE | ROAD_SW;
ret = DoCommandByTile(tile, bits, 0, flags, CMD_BUILD_ROAD);
ret = DoCommand(tile, bits, 0, flags, CMD_BUILD_ROAD);
if (CmdFailed(ret)) {
if (_error_message != STR_1007_ALREADY_BUILT) return CMD_ERROR;
} else {
@ -495,16 +489,16 @@ int32 CmdBuildLongRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Remove a long piece of road.
* @param x,y end tile of drag
* @param end_tile end tile of drag
* @param p1 start tile of drag
* @param p2 various bitstuffed elements
* - p2 = (bit 0) - start tile starts in the 2nd half of tile (p2 & 1)
* - p2 = (bit 1) - end tile starts in the 2nd half of tile (p2 & 2)
* - p2 = (bit 2) - direction: 0 = along x-axis, 1 = along y-axis (p2 & 4)
*/
int32 CmdRemoveLongRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRemoveLongRoad(TileIndex end_tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex start_tile, end_tile, tile;
TileIndex start_tile, tile;
int32 cost, ret;
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
@ -512,7 +506,6 @@ int32 CmdRemoveLongRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (p1 >= MapSize()) return CMD_ERROR;
start_tile = p1;
end_tile = TileVirtXY(x, y);
/* Only drag in X or Y direction dictated by the direction variable */
if (!HASBIT(p2, 2) && TileY(start_tile) != TileY(end_tile)) return CMD_ERROR; // x-axis
@ -537,7 +530,7 @@ int32 CmdRemoveLongRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
// try to remove the halves.
if (bits != 0) {
ret = DoCommandByTile(tile, bits, 0, flags, CMD_REMOVE_ROAD);
ret = DoCommand(tile, bits, 0, flags, CMD_REMOVE_ROAD);
if (!CmdFailed(ret)) cost += ret;
}
@ -550,26 +543,23 @@ int32 CmdRemoveLongRoad(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Build a road depot.
* @param x,y tile coordinates where the depot will be built
* @param tile tile where to build the depot
* @param p1 entrance direction (DiagDirection)
* @param p2 unused
*
* @todo When checking for the tile slope,
* distingush between "Flat land required" and "land sloped in wrong direction"
*/
int32 CmdBuildRoadDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildRoadDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int32 cost;
Depot *dep;
TileIndex tile;
uint tileh;
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
if (p1 > 3) return CMD_ERROR; // check direction
tile = TileVirtXY(x, y);
if (!EnsureNoVehicle(tile)) return CMD_ERROR;
tileh = GetTileSlope(tile, NULL);
@ -581,7 +571,7 @@ int32 CmdBuildRoadDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
}
cost = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
cost = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(cost)) return CMD_ERROR;
dep = AllocateDepot();
@ -624,7 +614,7 @@ static int32 ClearTile_Road(TileIndex tile, byte flags)
flags & DC_AUTO) {
return_cmd_error(STR_1801_MUST_REMOVE_ROAD_FIRST);
}
return DoCommandByTile(tile, b, 0, flags, CMD_REMOVE_ROAD);
return DoCommand(tile, b, 0, flags, CMD_REMOVE_ROAD);
}
case ROAD_CROSSING: {
@ -632,11 +622,11 @@ static int32 ClearTile_Road(TileIndex tile, byte flags)
if (flags & DC_AUTO) return_cmd_error(STR_1801_MUST_REMOVE_ROAD_FIRST);
ret = DoCommandByTile(tile, GetCrossingRoadBits(tile), 0, flags, CMD_REMOVE_ROAD);
ret = DoCommand(tile, GetCrossingRoadBits(tile), 0, flags, CMD_REMOVE_ROAD);
if (CmdFailed(ret)) return CMD_ERROR;
if (flags & DC_EXEC) {
DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
}
return ret;
}
@ -1092,7 +1082,7 @@ static void ChangeTileOwner_Road(TileIndex tile, PlayerID old_player, PlayerID n
default:
case ROAD_DEPOT:
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
break;
}
}

2
road_gui.c
View File

@ -270,7 +270,7 @@ static void BuildRoadToolbWndProc(Window* w, WindowEvent* e)
case WE_PLACE_PRESIZE: {
TileIndex tile = e->place.tile;
DoCommandByTile(tile, 0x200, 0, DC_AUTO, CMD_BUILD_TUNNEL);
DoCommand(tile, 0x200, 0, DC_AUTO, CMD_BUILD_TUNNEL);
VpSetPresizeRange(tile, _build_tunnel_endtile==0?tile:_build_tunnel_endtile);
break;
}

24
roadveh_cmd.c
View File

@ -101,16 +101,15 @@ static int32 EstimateRoadVehCost(EngineID engine_type)
}
/** Build a road vehicle.
* @param x,y tile coordinates of depot where road vehicle is built
* @param tile tile of depot where road vehicle is built
* @param p1 bus/truck type being built (engine)
* @param p2 unused
*/
int32 CmdBuildRoadVeh(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int32 cost;
Vehicle *v;
UnitID unit_num;
TileIndex tile = TileVirtXY(x, y);
Engine *e;
if (!IsEngineBuildable(p1, VEH_Road)) return_cmd_error(STR_ENGINE_NOT_BUILDABLE);
@ -135,6 +134,9 @@ int32 CmdBuildRoadVeh(int x, int y, uint32 flags, uint32 p1, uint32 p2)
return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
if (flags & DC_EXEC) {
int x;
int y;
const RoadVehicleInfo *rvi = RoadVehInfo(p1);
v->unitnumber = unit_num;
@ -200,11 +202,11 @@ int32 CmdBuildRoadVeh(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Start/Stop a road vehicle.
* @param x,y unused
* @param tile unused
* @param p1 road vehicle ID to start/stop
* @param p2 unused
*/
int32 CmdStartStopRoadVeh(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdStartStopRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
@ -242,11 +244,11 @@ void ClearSlot(Vehicle *v)
}
/** Sell a road vehicle.
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID to be sold
* @param p2 unused
*/
int32 CmdSellRoadVeh(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSellRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
@ -342,11 +344,11 @@ static const Depot* FindClosestRoadDepot(const Vehicle* v)
}
/** Send a road vehicle to the depot.
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID to send to the depot
* @param p2 unused
*/
int32 CmdSendRoadVehToDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSendRoadVehToDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
const Depot *dep;
@ -390,11 +392,11 @@ int32 CmdSendRoadVehToDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Turn a roadvehicle around.
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID to turn
* @param p2 unused
*/
int32 CmdTurnRoadVeh(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdTurnRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;

2
settings.c
View File

@ -1403,7 +1403,7 @@ static const SettingDesc *GetSettingDescription(uint index)
* The new value is properly clamped to its minimum/maximum when setting
* @see _patch_settings
*/
int32 CmdChangePatchSetting(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdChangePatchSetting(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
const SettingDesc *sd = GetSettingDescription(p1);

4
settings_gui.c
View File

@ -218,11 +218,11 @@ static void GameOptionsWndProc(Window *w, WindowEvent *e)
}
/** Change the side of the road vehicles drive on (server only).
* @param x,y unused
* @param tile unused
* @param p1 the side of the road; 0 = left side and 1 = right side
* @param p2 unused
*/
int32 CmdSetRoadDriveSide(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSetRoadDriveSide(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
/* Check boundaries and you can only change this if NO vehicles have been built yet,
* except in the intro-menu where of course it's always possible to do so. */

24
ship_cmd.c
View File

@ -809,16 +809,15 @@ void ShipsYearlyLoop(void)
}
/** Build a ship.
* @param x,y tile coordinates of depot where ship is built
* @param tile tile of depot where ship is built
* @param p1 ship type being built (engine)
* @param p2 unused
*/
int32 CmdBuildShip(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildShip(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int32 value;
Vehicle *v;
UnitID unit_num;
TileIndex tile = TileVirtXY(x, y);
Engine *e;
if (!IsEngineBuildable(p1, VEH_Ship)) return_cmd_error(STR_ENGINE_NOT_BUILDABLE);
@ -839,6 +838,9 @@ int32 CmdBuildShip(int x, int y, uint32 flags, uint32 p1, uint32 p2)
return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
if (flags & DC_EXEC) {
int x;
int y;
const ShipVehicleInfo *svi = ShipVehInfo(p1);
v->unitnumber = unit_num;
@ -897,11 +899,11 @@ int32 CmdBuildShip(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Sell a ship.
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID to be sold
* @param p2 unused
*/
int32 CmdSellShip(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSellShip(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
@ -930,11 +932,11 @@ int32 CmdSellShip(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Start/Stop a ship.
* @param x,y unused
* @param tile unused
* @param p1 ship ID to start/stop
* @param p2 unused
*/
int32 CmdStartStopShip(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdStartStopShip(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
@ -959,11 +961,11 @@ int32 CmdStartStopShip(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Send a ship to the depot.
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID to send to the depot
* @param p2 unused
*/
int32 CmdSendShipToDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSendShipToDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
const Depot *dep;
@ -1008,12 +1010,12 @@ int32 CmdSendShipToDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/** Refits a ship to the specified cargo type.
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID of the ship to refit
* @param p2 various bitstuffed elements
* - p2 = (bit 0-7) - the new cargo type to refit to (p2 & 0xFF)
*/
int32 CmdRefitShip(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRefitShip(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
int32 cost;

2
ship_gui.c
View File

@ -88,7 +88,7 @@ static void ShipRefitWndProc(Window *w, WindowEvent *e)
WP(w,refit_d).cargo = DrawVehicleRefitWindow(v, WP(w, refit_d).sel);;
if (WP(w,refit_d).cargo != CT_INVALID) {
int32 cost = DoCommandByTile(v->tile, v->index, WP(w,refit_d).cargo, DC_QUERY_COST, CMD_REFIT_SHIP);
int32 cost = DoCommand(v->tile, v->index, WP(w,refit_d).cargo, DC_QUERY_COST, CMD_REFIT_SHIP);
if (!CmdFailed(cost)) {
SetDParam(2, cost);
SetDParam(0, _cargoc.names_long[WP(w,refit_d).cargo]);

11
signs.c
View File

@ -104,11 +104,11 @@ static SignStruct *AllocateSign(void)
/** Place a sign at the given coordinates. Ownership of sign has
* no effect whatsoever except for the colour the sign gets for easy recognition,
* but everybody is able to rename/remove it.
* @param x,y coordinates to place sign at
* @param tile tile to place sign at
* @param p1 unused
* @param p2 unused
*/
int32 CmdPlaceSign(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdPlaceSign(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
SignStruct *ss;
@ -118,6 +118,9 @@ int32 CmdPlaceSign(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/* When we execute, really make the sign */
if (flags & DC_EXEC) {
int x = TileX(tile) * TILE_SIZE;
int y = TileY(tile) * TILE_SIZE;
ss->str = STR_280A_SIGN;
ss->x = x;
ss->y = y;
@ -136,11 +139,11 @@ int32 CmdPlaceSign(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/** Rename a sign. If the new name of the sign is empty, we assume
* the user wanted to delete it. So delete it. Ownership of signs
* has no meaning/effect whatsoever except for eyecandy
* @param x,y unused
* @param tile unused
* @param p1 index of the sign to be renamed/removed
* @param p2 unused
*/
int32 CmdRenameSign(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRenameSign(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
if (!IsSignIndex(p1)) return CMD_ERROR;

50
station_cmd.c
View File

@ -804,7 +804,7 @@ int32 CheckFlatLandBelow(TileIndex tile, uint w, uint h, uint flags, uint invali
}
}
} else {
ret = DoCommandByTile(tile_cur, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile_cur, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return ret;
cost += ret;
}
@ -912,7 +912,7 @@ static void GetStationLayout(byte *layout, int numtracks, int plat_len, const St
}
/** Build railroad station
* @param x,y starting position of station dragging/placement
* @param tile_org starting position of station dragging/placement
* @param p1 various bitstuffed elements
* - p1 = (bit 0) - orientation (p1 & 1)
* - p1 = (bit 8-15) - number of tracks
@ -922,10 +922,9 @@ static void GetStationLayout(byte *layout, int numtracks, int plat_len, const St
* - p2 = (bit 4) - set for custom station (p2 & 0x10)
* - p2 = (bit 8-..) - custom station id (p2 >> 8)
*/
int32 CmdBuildRailroadStation(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildRailroadStation(TileIndex tile_org, uint32 flags, uint32 p1, uint32 p2)
{
Station *st;
TileIndex tile_org;
int w_org, h_org;
int32 cost, ret;
StationID est;
@ -935,8 +934,6 @@ int32 CmdBuildRailroadStation(int x, int y, uint32 flags, uint32 p1, uint32 p2)
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
tile_org = TileVirtXY(x, y);
/* Does the authority allow this? */
if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile_org)) return CMD_ERROR;
if (!ValParamRailtype(p2 & 0xF)) return CMD_ERROR;
@ -1124,13 +1121,12 @@ restart:
/** Remove a single tile from a railroad station.
* This allows for custom-built station with holes and weird layouts
* @param x,y tile coordinates to remove
* @param tile tile of station piece to remove
* @param p1 unused
* @param p2 unused
*/
int32 CmdRemoveFromRailroadStation(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRemoveFromRailroadStation(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile = TileVirtXY(x, y);
Station *st;
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
@ -1196,7 +1192,7 @@ static int32 RemoveRailroadStation(Station *st, TileIndex tile, uint32 flags)
/* if there is flooding and non-uniform stations are enabled, remove platforms tile by tile */
if (_current_player == OWNER_WATER && _patches.nonuniform_stations)
return DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_REMOVE_FROM_RAILROAD_STATION);
return DoCommand(tile, 0, 0, DC_EXEC, CMD_REMOVE_FROM_RAILROAD_STATION);
/* Current player owns the station? */
if (_current_player != OWNER_WATER && !CheckOwnership(st->owner))
@ -1284,17 +1280,16 @@ static void FindRoadStationSpot(bool truck_station, Station* st, RoadStop*** cur
}
/** Build a bus station
* @param x,y coordinates to build bus station at
* @param tile tile to build bus station at
* @param p1 entrance direction (DiagDirection)
* @param p2 0 for Bus stops, 1 for truck stops
*/
int32 CmdBuildRoadStop(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildRoadStop(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Station *st;
RoadStop *road_stop;
RoadStop **currstop;
RoadStop *prev = NULL;
TileIndex tile;
int32 cost;
int32 ret;
bool type = !!p2;
@ -1304,8 +1299,6 @@ int32 CmdBuildRoadStop(int x, int y, uint32 flags, uint32 p1, uint32 p2)
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
tile = TileVirtXY(x, y);
if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile))
return CMD_ERROR;
@ -1500,13 +1493,12 @@ static const byte * const _airport_sections[] = {
};
/** Place an Airport.
* @param x,y tile coordinates where airport will be built
* @param tile tile where airport will be built
* @param p1 airport type, @see airport.h
* @param p2 unused
*/
int32 CmdBuildAirport(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildAirport(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile;
Town *t;
Station *st;
int32 cost;
@ -1519,8 +1511,6 @@ int32 CmdBuildAirport(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/* Check if a valid, buildable airport was chosen for construction */
if (p1 > lengthof(_airport_sections) || !HASBIT(GetValidAirports(), p1)) return CMD_ERROR;
tile = TileVirtXY(x, y);
if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile))
return CMD_ERROR;
@ -1673,13 +1663,12 @@ static int32 RemoveAirport(Station *st, uint32 flags)
}
/** Build a buoy.
* @param x,y tile coordinates of bouy construction
* @param tile tile where to place the bouy
* @param p1 unused
* @param p2 unused
*/
int32 CmdBuildBuoy(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildBuoy(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile = TileVirtXY(x, y);
Station *st;
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
@ -1774,13 +1763,12 @@ static const byte _dock_w_chk[4] = { 2,1,2,1 };
static const byte _dock_h_chk[4] = { 1,2,1,2 };
/** Build a dock/haven.
* @param x,y tile coordinates where dock will be built
* @param tile tile where dock will be built
* @param p1 unused
* @param p2 unused
*/
int32 CmdBuildDock(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildDock(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile = TileVirtXY(x, y);
TileIndex tile_cur;
DiagDirection direction;
int32 cost;
@ -1798,7 +1786,7 @@ int32 CmdBuildDock(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (!EnsureNoVehicle(tile)) return CMD_ERROR;
cost = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
cost = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(cost)) return CMD_ERROR;
tile_cur = tile + TileOffsByDir(direction);
@ -1809,7 +1797,7 @@ int32 CmdBuildDock(int x, int y, uint32 flags, uint32 p1, uint32 p2)
return_cmd_error(STR_304B_SITE_UNSUITABLE);
}
cost = DoCommandByTile(tile_cur, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
cost = DoCommand(tile_cur, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(cost)) return CMD_ERROR;
tile_cur = tile_cur + TileOffsByDir(direction);
@ -2427,11 +2415,11 @@ static void UpdateStationWaiting(Station *st, int type, uint amount)
}
/** Rename a station
* @param x,y unused
* @param tile unused
* @param p1 station ID that is to be renamed
* @param p2 unused
*/
int32 CmdRenameStation(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRenameStation(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
StringID str;
Station *st;
@ -2672,7 +2660,7 @@ static void ChangeTileOwner_Station(TileIndex tile, PlayerID old_player, PlayerI
_global_station_sort_dirty = true; // transfer ownership of station to another player
InvalidateWindowClasses(WC_STATION_LIST);
} else {
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
}
}

45
town_cmd.c
View File

@ -471,8 +471,8 @@ static bool IsRoadAllowedHere(TileIndex tile, int dir)
// No, try to build one in the direction.
// if that fails clear the land, and if that fails exit.
// This is to make sure that we can build a road here later.
if (CmdFailed(DoCommandByTile(tile, (dir & 1 ? ROAD_X : ROAD_Y), 0, DC_AUTO, CMD_BUILD_ROAD)) &&
CmdFailed(DoCommandByTile(tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR)))
if (CmdFailed(DoCommand(tile, (dir & 1 ? ROAD_X : ROAD_Y), 0, DC_AUTO, CMD_BUILD_ROAD)) &&
CmdFailed(DoCommand(tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR)))
return false;
}
@ -500,10 +500,10 @@ no_slope:
int32 res;
if (CHANCE16I(1, 16, r)) {
res = DoCommandByTile(tile, slope, 0, DC_EXEC | DC_AUTO | DC_NO_WATER,
res = DoCommand(tile, slope, 0, DC_EXEC | DC_AUTO | DC_NO_WATER,
CMD_TERRAFORM_LAND);
} else {
res = DoCommandByTile(tile, slope^0xF, 1, DC_EXEC | DC_AUTO | DC_NO_WATER,
res = DoCommand(tile, slope ^ 0xF, 1, DC_EXEC | DC_AUTO | DC_NO_WATER,
CMD_TERRAFORM_LAND);
}
if (CmdFailed(res) && CHANCE16I(1, 3, r)) {
@ -523,9 +523,9 @@ static bool TerraformTownTile(TileIndex tile, int edges, int dir)
TILE_ASSERT(tile);
r = DoCommandByTile(tile, edges, dir, DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
r = DoCommand(tile, edges, dir, DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
if (CmdFailed(r) || r >= 126 * 16) return false;
DoCommandByTile(tile, edges, dir, DC_AUTO | DC_NO_WATER | DC_EXEC, CMD_TERRAFORM_LAND);
DoCommand(tile, edges, dir, DC_AUTO | DC_NO_WATER | DC_EXEC, CMD_TERRAFORM_LAND);
return true;
}
@ -654,7 +654,7 @@ static void GrowTownInTile(TileIndex* tile_ptr, RoadBits mask, int block, Town*
default:
build_road_and_exit:
if (!CmdFailed(DoCommandByTile(tile, rcmd, t1->index, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD))) {
if (!CmdFailed(DoCommand(tile, rcmd, t1->index, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD))) {
_grow_town_result = -1;
}
return;
@ -681,7 +681,7 @@ build_road_and_exit:
do {
byte bridge_type = RandomRange(MAX_BRIDGES - 1);
if (CheckBridge_Stuff(bridge_type, bridge_len)) {
if (!CmdFailed(DoCommandByTile(tile, tmptile, 0x8000 + bridge_type, DC_EXEC | DC_AUTO, CMD_BUILD_BRIDGE)))
if (!CmdFailed(DoCommand(tile, tmptile, 0x8000 + bridge_type, DC_EXEC | DC_AUTO, CMD_BUILD_BRIDGE)))
_grow_town_result = -1;
// obviously, if building any bridge would fail, there is no need to try other bridge-types
@ -795,8 +795,8 @@ static bool GrowTown(Town *t)
// Only work with plain land that not already has a house with GetHouseConstructionTick=0
if ((!IsTileType(tile, MP_HOUSE) || GetHouseConstructionTick(tile) != 0) &&
GetTileSlope(tile, NULL) == 0) {
if (!CmdFailed(DoCommandByTile(tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR))) {
DoCommandByTile(tile, GenRandomRoadBits(), t->index, DC_EXEC | DC_AUTO, CMD_BUILD_ROAD);
if (!CmdFailed(DoCommand(tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR))) {
DoCommand(tile, GenRandomRoadBits(), t->index, DC_EXEC | DC_AUTO, CMD_BUILD_ROAD);
_current_player = old_player;
return true;
}
@ -994,13 +994,12 @@ static Town *AllocateTown(void)
/** Create a new town.
* This obviously only works in the scenario editor. Function not removed
* as it might be possible in the future to fund your own town :)
* @param x,y coordinates where town is built
* @param tile coordinates where town is built
* @param p1 unused
* @param p2 unused
*/
int32 CmdBuildTown(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildTown(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile = TileVirtXY(x, y);
Town *t;
uint32 townnameparts;
@ -1114,7 +1113,7 @@ static bool CheckBuildHouseMode(TileIndex tile, uint tileh, int mode)
if (b)
return false;
return !CmdFailed(DoCommandByTile(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_LANDSCAPE_CLEAR));
return !CmdFailed(DoCommand(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_LANDSCAPE_CLEAR));
}
int GetTownRadiusGroup(const Town *t, TileIndex tile)
@ -1151,7 +1150,7 @@ static bool CheckFree2x2Area(TileIndex tile)
if (GetTileSlope(tile, NULL)) return false;
if (CmdFailed(DoCommandByTile(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER | DC_FORCETEST, CMD_LANDSCAPE_CLEAR)))
if (CmdFailed(DoCommand(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER | DC_FORCETEST, CMD_LANDSCAPE_CLEAR)))
return false;
}
@ -1286,7 +1285,7 @@ static bool BuildTownHouse(Town *t, TileIndex tile)
if (!EnsureNoVehicle(tile)) return false;
if (GetTileSlope(tile, NULL) & 0x10) return false;
r = DoCommandByTile(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_LANDSCAPE_CLEAR);
r = DoCommand(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(r)) return false;
DoBuildTownHouse(t, tile);
@ -1358,11 +1357,11 @@ static void ClearTownHouse(Town *t, TileIndex tile)
}
/** Rename a town (server-only).
* @param x,y unused
* @param tile unused
* @param p1 town ID to rename
* @param p2 unused
*/
int32 CmdRenameTown(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRenameTown(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
StringID str;
Town *t;
@ -1410,14 +1409,14 @@ void DeleteTown(Town *t)
switch (GetTileType(tile)) {
case MP_HOUSE:
if (GetTownByTile(tile) == t)
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
break;
case MP_STREET:
case MP_TUNNELBRIDGE:
if (IsTileOwner(tile, OWNER_TOWN) &&
ClosestTownFromTile(tile, (uint)-1) == t)
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
break;
default:
@ -1499,7 +1498,7 @@ static bool DoBuildStatueOfCompany(TileIndex tile)
old = _current_player;
_current_player = OWNER_NONE;
r = DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
r = DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
_current_player = old;
if (CmdFailed(r)) return false;
@ -1611,11 +1610,11 @@ extern uint GetMaskOfTownActions(int *nump, PlayerID pid, const Town *t);
/** Do a town action.
* This performs an action such as advertising, building a statue, funding buildings,
* but also bribing the town-council
* @param x,y unused
* @param tile unused
* @param p1 town to do the action at
* @param p2 action to perform, @see _town_action_proc for the list of available actions
*/
int32 CmdDoTownAction(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdDoTownAction(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int32 cost;
Town *t;

52
train_cmd.c
View File

@ -655,7 +655,7 @@ static void NormalizeTrainVehInDepot(const Vehicle* u)
if (v->type == VEH_Train && IsFreeWagon(v) &&
v->tile == u->tile &&
v->u.rail.track == 0x80) {
if (CmdFailed(DoCommandByTile(0, v->index | (u->index << 16), 1, DC_EXEC,
if (CmdFailed(DoCommand(0, v->index | (u->index << 16), 1, DC_EXEC,
CMD_MOVE_RAIL_VEHICLE)))
break;
}
@ -696,18 +696,17 @@ static void AddRearEngineToMultiheadedTrain(Vehicle* v, Vehicle* u, bool buildin
}
/** Build a railroad vehicle.
* @param x,y tile coordinates (depot) where rail-vehicle is built
* @param tile tile of the depot where rail-vehicle is built
* @param p1 engine type id
* @param p2 bit 0 prevents any free cars from being added to the train
*/
int32 CmdBuildRailVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
const RailVehicleInfo *rvi;
int value;
Vehicle *v;
UnitID unit_num;
Engine *e;
TileIndex tile = TileVirtXY(x, y);
uint num_vehicles;
/* Check if the engine-type is valid (for the player) */
@ -748,17 +747,16 @@ int32 CmdBuildRailVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
if (flags & DC_EXEC) {
DiagDirection dir;
DiagDirection dir = GetRailDepotDirection(tile);
int x = TileX(tile) * TILE_SIZE + _vehicle_initial_x_fract[dir];
int y = TileY(tile) * TILE_SIZE + _vehicle_initial_y_fract[dir];
v->unitnumber = unit_num;
dir = GetRailDepotDirection(tile);
v->direction = DiagDirToDir(dir);
v->tile = tile;
v->owner = _current_player;
v->x_pos = (x |= _vehicle_initial_x_fract[dir]);
v->y_pos = (y |= _vehicle_initial_y_fract[dir]);
v->x_pos = x;
v->y_pos = y;
v->z_pos = GetSlopeZ(x,y);
v->z_height = 6;
v->u.rail.track = 0x80;
@ -938,13 +936,13 @@ static void NormaliseTrainConsist(Vehicle *v)
}
/** Move a rail vehicle around inside the depot.
* @param x,y unused
* @param tile unused
* @param p1 various bitstuffed elements
* - p1 (bit 0 - 15) source vehicle index
* - p1 (bit 16 - 31) what wagon to put the source wagon AFTER, XXX - INVALID_VEHICLE to make a new line
* @param p2 (bit 0) move all vehicles following the source vehicle
*/
int32 CmdMoveRailVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdMoveRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
VehicleID s = GB(p1, 0, 16);
VehicleID d = GB(p1, 16, 16);
@ -1171,7 +1169,7 @@ int32 CmdMoveRailVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
* To do this, CmdMoveRailVehicle must be called once more
* we can't loop forever here because next time we reach this line we will have a front engine */
if (src_head != NULL && !IsFrontEngine(src_head) && IsTrainEngine(src_head)) {
CmdMoveRailVehicle(x, y, flags, src_head->index | (INVALID_VEHICLE << 16), 1);
CmdMoveRailVehicle(0, flags, src_head->index | (INVALID_VEHICLE << 16), 1);
src_head = NULL; // don't do anything more to this train since the new call will do it
}
@ -1210,11 +1208,11 @@ int32 CmdMoveRailVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Start/Stop a train.
* @param x,y unused
* @param tile unused
* @param p1 train to start/stop
* @param p2 unused
*/
int32 CmdStartStopTrain(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdStartStopTrain(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
@ -1238,7 +1236,7 @@ int32 CmdStartStopTrain(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Sell a (single) train wagon/engine.
* @param x,y unused
* @param tile unused
* @param p1 the wagon/engine index
* @param p2 the selling mode
* - p2 = 0: only sell the single dragged wagon/engine (and any belonging rear-engines)
@ -1247,7 +1245,7 @@ int32 CmdStartStopTrain(int x, int y, uint32 flags, uint32 p1, uint32 p2)
* - p2 = 2: when selling attached locos, rearrange all vehicles after it to separate lines;
* all wagons of the same type will go on the same line. Used by the AI currently
*/
int32 CmdSellRailWagon(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSellRailWagon(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v, *tmp, *first;
Vehicle *new_f = NULL;
@ -1355,7 +1353,7 @@ int32 CmdSellRailWagon(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (p2 == 2 && HASBIT(ori_subtype, Train_Front)) {
for (v = first; v != NULL; v = tmp) {
tmp = GetNextVehicle(v);
DoCommandByTile(v->tile, v->index | INVALID_VEHICLE << 16, 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
DoCommand(v->tile, v->index | INVALID_VEHICLE << 16, 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
}
}
}
@ -1632,11 +1630,11 @@ static void ReverseTrainDirection(Vehicle *v)
}
/** Reverse train.
* @param x,y unused
* @param tile unused
* @param p1 train to reverse
* @param p2 if true, reverse a unit in a train (needs to be in a depot)
*/
int32 CmdReverseTrainDirection(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdReverseTrainDirection(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
@ -1681,11 +1679,11 @@ static void ReverseTrainDirection(Vehicle *v)
}
/** Force a train through a red signal
* @param x,y unused
* @param tile unused
* @param p1 train to ignore the red signal
* @param p2 unused
*/
int32 CmdForceTrainProceed(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdForceTrainProceed(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
@ -1701,11 +1699,11 @@ int32 CmdForceTrainProceed(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Refits a train to the specified cargo type.
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID of the train to refit
* @param p2 the new cargo type to refit to (p2 & 0xFF)
*/
int32 CmdRefitRailVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRefitRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
CargoID new_cid = GB(p2, 0, 8);
Vehicle *v;
@ -1873,11 +1871,11 @@ static TrainFindDepotData FindClosestTrainDepot(Vehicle *v)
}
/** Send a train to a depot
* @param x,y unused
* @param tile unused
* @param p1 train to send to the depot
* @param p2 unused
*/
int32 CmdSendTrainToDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdSendTrainToDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
TrainFindDepotData tfdd;
@ -1916,7 +1914,7 @@ int32 CmdSendTrainToDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
/* If there is no depot in front, reverse automatically */
if (tfdd.reverse)
DoCommandByTile(v->tile, v->index, 0, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION);
DoCommand(v->tile, v->index, 0, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION);
}
return 0;

2
train_gui.c
View File

@ -810,7 +810,7 @@ static void RailVehicleRefitWndProc(Window *w, WindowEvent *e)
WP(w,refit_d).cargo = DrawVehicleRefitWindow(v, WP(w, refit_d).sel);
if (WP(w,refit_d).cargo != CT_INVALID) {
int32 cost = DoCommandByTile(v->tile, v->index, WP(w,refit_d).cargo, DC_QUERY_COST, CMD_REFIT_RAIL_VEHICLE);
int32 cost = DoCommand(v->tile, v->index, WP(w,refit_d).cargo, DC_QUERY_COST, CMD_REFIT_RAIL_VEHICLE);
if (!CmdFailed(cost)) {
SetDParam(2, cost);
SetDParam(0, _cargoc.names_long[WP(w,refit_d).cargo]);

10
tree_cmd.c
View File

@ -124,14 +124,16 @@ void GenerateTrees(void)
}
/** Plant a tree.
* @param x,y start tile of area-drag of tree plantation
* @param tile start tile of area-drag of tree plantation
* @param p1 tree type, -1 means random.
* @param p2 end tile of area-drag
*/
int32 CmdPlantTree(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
int32 CmdPlantTree(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
StringID msg = INVALID_STRING_ID;
int32 cost;
int ex;
int ey;
int sx, sy, x, y;
if (p2 >= MapSize()) return CMD_ERROR;
@ -141,10 +143,10 @@ int32 CmdPlantTree(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)
SET_EXPENSES_TYPE(EXPENSES_OTHER);
// make sure sx,sy are smaller than ex,ey
ex = TileX(tile);
ey = TileY(tile);
sx = TileX(p2);
sy = TileY(p2);
ex /= TILE_SIZE;
ey /= TILE_SIZE;
if (ex < sx) intswap(ex, sx);
if (ey < sy) intswap(ey, sy);

28
tunnelbridge_cmd.c
View File

@ -170,17 +170,19 @@ bool CheckBridge_Stuff(byte bridge_type, uint bridge_len)
}
/** Build a Bridge
* @param x,y end tile coord
* @param end_tile end tile
* @param p1 packed start tile coords (~ dx)
* @param p2 various bitstuffed elements
* - p2 = (bit 0- 7) - bridge type (hi bh)
* - p2 = (bit 8-..) - rail type. bit15 ((x>>8)&0x80) means road bridge.
*/
int32 CmdBuildBridge(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildBridge(TileIndex end_tile, uint32 flags, uint32 p1, uint32 p2)
{
int bridge_type;
TransportType transport;
RailType railtype;
int x;
int y;
int sx,sy;
TileIndex tile_start;
TileIndex tile_end;
@ -214,6 +216,8 @@ int32 CmdBuildBridge(int x, int y, uint32 flags, uint32 p1, uint32 p2)
transport = TRANSPORT_RAIL;
}
x = TileX(end_tile) * TILE_SIZE;
y = TileY(end_tile) * TILE_SIZE;
sx = TileX(p1) * TILE_SIZE;
sy = TileY(p1) * TILE_SIZE;
@ -268,7 +272,7 @@ int32 CmdBuildBridge(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/* Try and clear the start landscape */
ret = DoCommandByTile(tile_start, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile_start, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return ret;
cost = ret;
@ -280,7 +284,7 @@ int32 CmdBuildBridge(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/* Try and clear the end landscape */
ret = DoCommandByTile(tile_end, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile_end, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return ret;
cost += ret;
@ -352,7 +356,7 @@ int32 CmdBuildBridge(int x, int y, uint32 flags, uint32 p1, uint32 p2)
default:
not_valid_below:;
/* try and clear the middle landscape */
ret = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return ret;
cost += ret;
transport_under = INVALID_TRANSPORT;
@ -425,14 +429,13 @@ not_valid_below:;
/** Build Tunnel.
* @param x,y start tile coord of tunnel
* @param tile start tile of tunnel
* @param p1 railtype, 0x200 for road tunnel
* @param p2 unused
*/
int32 CmdBuildTunnel(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildTunnel(TileIndex start_tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndexDiff delta;
TileIndex start_tile;
TileIndex end_tile;
DiagDirection direction;
uint start_tileh;
@ -446,7 +449,6 @@ int32 CmdBuildTunnel(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (p1 != 0x200 && !ValParamRailtype(p1)) return CMD_ERROR;
start_tile = TileVirtXY(x, y);
start_tileh = GetTileSlope(start_tile, &start_z);
switch (start_tileh) {
@ -457,7 +459,7 @@ int32 CmdBuildTunnel(int x, int y, uint32 flags, uint32 p1, uint32 p2)
default: return_cmd_error(STR_500B_SITE_UNSUITABLE_FOR_TUNNEL);
}
ret = DoCommandByTile(start_tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(start_tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return ret;
cost = _price.build_tunnel + ret;
@ -483,10 +485,10 @@ int32 CmdBuildTunnel(int x, int y, uint32 flags, uint32 p1, uint32 p2)
// slope of end tile must be complementary to the slope of the start tile
if (end_tileh != (15 ^ start_tileh)) {
ret = DoCommandByTile(end_tile, end_tileh & start_tileh, 0, flags, CMD_TERRAFORM_LAND);
ret = DoCommand(end_tile, end_tileh & start_tileh, 0, flags, CMD_TERRAFORM_LAND);
if (CmdFailed(ret)) return_cmd_error(STR_5005_UNABLE_TO_EXCAVATE_LAND);
} else {
ret = DoCommandByTile(end_tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(end_tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return ret;
}
cost += _price.build_tunnel + ret;
@ -1297,7 +1299,7 @@ static void ChangeTileOwner_TunnelBridge(TileIndex tile, PlayerID old_player, Pl
SetTileOwner(tile, OWNER_NONE);
}
} else {
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
}
}
}

7
unmovable_cmd.c
View File

@ -82,14 +82,13 @@ void UpdateCompanyHQ(Player *p, uint score)
}
/** Build or relocate the HQ. This depends if the HQ is already built or not
* @param x,y the coordinates where the HQ will be built or relocated to
* @param tile tile where the HQ will be built or relocated to
* @param p1 unused
* @param p2 unused
*/
extern int32 CheckFlatLandBelow(TileIndex tile, uint w, uint h, uint flags, uint invalid_dirs, int *);
int32 CmdBuildCompanyHQ(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildCompanyHQ(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile = TileVirtXY(x, y);
Player *p = GetPlayer(_current_player);
int cost;
int32 ret;
@ -219,7 +218,7 @@ static int32 ClearTile_Unmovable(TileIndex tile, byte flags)
}
if (IsOwnedLand(tile)) {
return DoCommandByTile(tile, 0, 0, flags, CMD_SELL_LAND_AREA);
return DoCommand(tile, 0, 0, flags, CMD_SELL_LAND_AREA);
}
// checks if you're allowed to remove unmovable things

40
vehicle.c
View File

@ -1493,11 +1493,11 @@ void AgeVehicle(Vehicle *v)
}
/** Clone a vehicle. If it is a train, it will clone all the cars too
* @param x,y depot where the cloned vehicle is build
* @param tile tile of the depot where the cloned vehicle is build
* @param p1 the original vehicle's index
* @param p2 1 = shared orders, else copied orders
*/
int32 CmdCloneVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdCloneVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v_front, *v;
Vehicle *w_front, *w, *w_rear;
@ -1544,7 +1544,7 @@ int32 CmdCloneVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
continue;
}
cost = DoCommand(x, y, v->engine_type, 1, flags, CMD_BUILD_VEH(v->type));
cost = DoCommand(tile, v->engine_type, 1, flags, CMD_BUILD_VEH(v->type));
if (CmdFailed(cost)) return cost;
@ -1557,18 +1557,18 @@ int32 CmdCloneVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (v->cargo_type != w->cargo_type) {
// we can't pay for refitting because we can't estimate refitting costs for a vehicle before it's build
// if we pay for it anyway, the cost and the estimated cost will not be the same and we will have an assert
DoCommand(x, y, w->index, v->cargo_type, flags, CMD_REFIT_VEH(v->type));
DoCommand(0, w->index, v->cargo_type, flags, CMD_REFIT_VEH(v->type));
}
}
if (v->type == VEH_Train && !IsFrontEngine(v)) {
// this s a train car
// add this unit to the end of the train
DoCommand(x, y, (w_rear->index << 16) | w->index, 1, flags, CMD_MOVE_RAIL_VEHICLE);
DoCommand(0, (w_rear->index << 16) | w->index, 1, flags, CMD_MOVE_RAIL_VEHICLE);
} else {
// this is a front engine or not a train. It need orders
w_front = w;
DoCommand(x, y, (v->index << 16) | w->index, p2 & 1 ? CO_SHARE : CO_COPY, flags, CMD_CLONE_ORDER);
DoCommand(0, (v->index << 16) | w->index, p2 & 1 ? CO_SHARE : CO_COPY, flags, CMD_CLONE_ORDER);
}
w_rear = w; // trains needs to know the last car in the train, so they can add more in next loop
}
@ -1633,7 +1633,7 @@ static int32 ReplaceVehicle(Vehicle **w, byte flags)
new_engine_type = EngineReplacementForPlayer(p, old_v->engine_type);
if (new_engine_type == INVALID_ENGINE) new_engine_type = old_v->engine_type;
cost = DoCommand(old_v->x_pos, old_v->y_pos, new_engine_type, 1, flags, CMD_BUILD_VEH(old_v->type));
cost = DoCommand(old_v->tile, new_engine_type, 1, flags, CMD_BUILD_VEH(old_v->type));
if (CmdFailed(cost)) return cost;
if (flags & DC_EXEC) {
@ -1646,7 +1646,7 @@ static int32 ReplaceVehicle(Vehicle **w, byte flags)
// we add the refit cost to cost, so it's added to the cost animation
// it's not in the calculation of having enough money to actually do the replace since it's rather hard to do by design, but since
// we pay for it, it's nice to make the cost animation include it
int32 temp_cost = DoCommand(0, 0, new_v->index, old_v->cargo_type, DC_EXEC, CMD_REFIT_VEH(new_v->type));
int32 temp_cost = DoCommand(0, new_v->index, old_v->cargo_type, DC_EXEC, CMD_REFIT_VEH(new_v->type));
if (!CmdFailed(temp_cost)) cost += temp_cost;
}
}
@ -1657,12 +1657,12 @@ static int32 ReplaceVehicle(Vehicle **w, byte flags)
* We add the new engine after the old one instead of replacing it. It will give the same result anyway when we
* sell the old engine in a moment
*/
DoCommand(0, 0, (GetPrevVehicleInChain(old_v)->index << 16) | new_v->index, 1, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
DoCommand(0, (GetPrevVehicleInChain(old_v)->index << 16) | new_v->index, 1, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
/* Now we move the old one out of the train */
DoCommand(0, 0, (INVALID_VEHICLE << 16) | old_v->index, 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
DoCommand(0, (INVALID_VEHICLE << 16) | old_v->index, 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
} else {
// copy/clone the orders
DoCommand(0, 0, (old_v->index << 16) | new_v->index, IsOrderListShared(old_v) ? CO_SHARE : CO_COPY, DC_EXEC, CMD_CLONE_ORDER);
DoCommand(0, (old_v->index << 16) | new_v->index, IsOrderListShared(old_v) ? CO_SHARE : CO_COPY, DC_EXEC, CMD_CLONE_ORDER);
new_v->cur_order_index = old_v->cur_order_index;
ChangeVehicleViewWindow(old_v, new_v);
new_v->profit_this_year = old_v->profit_this_year;
@ -1680,7 +1680,7 @@ static int32 ReplaceVehicle(Vehicle **w, byte flags)
}
if (temp_v != NULL) {
DoCommand(0, 0, (new_v->index << 16) | temp_v->index, 1, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
DoCommand(0, (new_v->index << 16) | temp_v->index, 1, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
}
}
}
@ -1696,7 +1696,7 @@ static int32 ReplaceVehicle(Vehicle **w, byte flags)
}
// sell the engine/ find out how much you get for the old engine
cost += DoCommand(0, 0, old_v->index, 0, flags, CMD_SELL_VEH(old_v->type));
cost += DoCommand(0, old_v->index, 0, flags, CMD_SELL_VEH(old_v->type));
if (new_front) {
// now we assign the old unitnumber to the new vehicle
@ -1706,7 +1706,7 @@ static int32 ReplaceVehicle(Vehicle **w, byte flags)
// Transfer the name of the old vehicle.
if ((flags & DC_EXEC) && vehicle_name[0] != '\0') {
_cmd_text = vehicle_name;
DoCommand(0, 0, new_v->index, 0, DC_EXEC, CMD_NAME_VEHICLE);
DoCommand(0, new_v->index, 0, DC_EXEC, CMD_NAME_VEHICLE);
}
return cost;
@ -1836,9 +1836,9 @@ static void MaybeReplaceVehicle(Vehicle *v)
}
temp = w;
w = GetNextVehicle(w);
DoCommand(0, 0, (INVALID_VEHICLE << 16) | temp->index, 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
DoCommand(0, (INVALID_VEHICLE << 16) | temp->index, 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
MoveVehicleCargo(v, temp);
cost += DoCommand(0, 0, temp->index, 0, flags, CMD_SELL_VEH(temp->type));
cost += DoCommand(0, temp->index, 0, flags, CMD_SELL_VEH(temp->type));
}
}
@ -1850,11 +1850,11 @@ static void MaybeReplaceVehicle(Vehicle *v)
/** Give a custom name to your vehicle
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID to name
* @param p2 unused
*/
int32 CmdNameVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdNameVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle *v;
StringID str;
@ -1883,11 +1883,11 @@ int32 CmdNameVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
/** Change the service interval of a vehicle
* @param x,y unused
* @param tile unused
* @param p1 vehicle ID that is being service-interval-changed
* @param p2 new service interval
*/
int32 CmdChangeServiceInt(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdChangeServiceInt(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Vehicle* v;
uint16 serv_int = GetServiceIntervalClamped(p2); /* Double check the service interval from the user-input */

41
water_cmd.c
View File

@ -42,13 +42,13 @@ const SpriteID _water_shore_sprites[15] = {
static void FloodVehicle(Vehicle *v);
/** Build a ship depot.
* @param x,y tile coordinates where ship depot is built
* @param tile tile where ship depot is built
* @param p1 depot direction (0 == X or 1 == Y)
* @param p2 unused
*/
int32 CmdBuildShipDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildShipDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile, tile2;
TileIndex tile2;
int32 cost, ret;
Depot *depot;
@ -57,7 +57,6 @@ int32 CmdBuildShipDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (p1 > 1) return CMD_ERROR;
tile = TileVirtXY(x, y);
if (!EnsureNoVehicle(tile)) return CMD_ERROR;
tile2 = tile + (p1 ? TileDiffXY(0, 1) : TileDiffXY(1, 0));
@ -66,9 +65,9 @@ int32 CmdBuildShipDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (!IsClearWaterTile(tile) || !IsClearWaterTile(tile2))
return_cmd_error(STR_3801_MUST_BE_BUILT_ON_WATER);
ret = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return CMD_ERROR;
ret = DoCommandByTile(tile2, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile2, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return CMD_ERROR;
// pretend that we're not making land from the water even though we actually are.
@ -123,17 +122,17 @@ static int32 DoBuildShiplift(TileIndex tile, DiagDirection dir, uint32 flags)
int delta;
// middle tile
ret = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return CMD_ERROR;
delta = TileOffsByDir(dir);
// lower tile
ret = DoCommandByTile(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return CMD_ERROR;
if (GetTileSlope(tile - delta, NULL)) return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
// upper tile
ret = DoCommandByTile(tile + delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
ret = DoCommand(tile + delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return CMD_ERROR;
if (GetTileSlope(tile + delta, NULL)) return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
@ -173,13 +172,12 @@ static void MarkTilesAroundDirty(TileIndex tile)
}
/** Builds a lock (ship-lift)
* @param x,y tile coordinates where to place the lock
* @param tile tile where to place the lock
* @param p1 unused
* @param p2 unused
*/
int32 CmdBuildLock(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildLock(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile = TileVirtXY(x, y);
DiagDirection dir;
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
@ -195,23 +193,24 @@ int32 CmdBuildLock(int x, int y, uint32 flags, uint32 p1, uint32 p2)
}
/** Build a piece of canal.
* @param x,y end tile of stretch-dragging
* @param tile end tile of stretch-dragging
* @param p1 start tile of stretch-dragging
* @param p2 unused
*/
int32 CmdBuildCanal(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildCanal(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
int32 cost;
int size_x, size_y;
int x;
int y;
int sx, sy;
if (p1 >= MapSize()) return CMD_ERROR;
x = TileX(tile);
y = TileY(tile);
sx = TileX(p1);
sy = TileY(p1);
/* x,y are in pixel-coordinates, transform to tile-coordinates
* to be able to use the BEGIN_TILE_LOOP() macro */
x >>= 4; y >>= 4;
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
@ -241,7 +240,7 @@ int32 CmdBuildCanal(int x, int y, uint32 flags, uint32 p1, uint32 p2)
if (flags & DC_EXEC) SetWaterUnderBridge(tile);
} else {
/* no bridge, try to clear it. */
int32 ret = DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
int32 ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return ret;
cost += ret;
@ -524,7 +523,7 @@ static void TileLoopWaterHelper(TileIndex tile, const TileIndexDiffC *offs)
case MP_CLEAR:
case MP_TREES:
_current_player = OWNER_WATER;
if (!CmdFailed(DoCommandByTile(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
if (!CmdFailed(DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
MakeShore(target);
MarkTileDirtyByTile(target);
}
@ -557,7 +556,7 @@ static void TileLoopWaterHelper(TileIndex tile, const TileIndexDiffC *offs)
if (v != NULL) FloodVehicle(v);
}
if (!CmdFailed(DoCommandByTile(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
if (!CmdFailed(DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
MakeWater(target);
MarkTileDirtyByTile(target);
}
@ -684,7 +683,7 @@ static void ChangeTileOwner_Water(TileIndex tile, PlayerID old_player, PlayerID
if (new_player != OWNER_SPECTATOR) {
SetTileOwner(tile, new_player);
} else {
DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
}
}

14
waypoint.c
View File

@ -163,16 +163,15 @@ void UpdateAllWaypointCustomGraphics(void)
/** Convert existing rail to waypoint. Eg build a waypoint station over
* piece of rail
* @param x,y coordinates where waypoint will be built
* @param tile tile where waypoint will be built
* @param p1 graphics for waypoint type, 0 indicates standard graphics
* @param p2 unused
*
* @todo When checking for the tile slope,
* distingush between "Flat land required" and "land sloped in wrong direction"
*/
int32 CmdBuildTrainWaypoint(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdBuildTrainWaypoint(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile = TileVirtXY(x, y);
Waypoint *wp;
uint tileh;
Axis axis;
@ -311,23 +310,22 @@ int32 RemoveTrainWaypoint(TileIndex tile, uint32 flags, bool justremove)
}
/** Delete a waypoint
* @param x,y coordinates where waypoint is to be deleted
* @param tile tile where waypoint is to be deleted
* @param p1 unused
* @param p2 unused
*/
int32 CmdRemoveTrainWaypoint(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRemoveTrainWaypoint(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
TileIndex tile = TileVirtXY(x, y);
SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
return RemoveTrainWaypoint(tile, flags, true);
}
/** Rename a waypoint.
* @param x,y unused
* @param tile unused
* @param p1 id of waypoint
* @param p2 unused
*/
int32 CmdRenameWaypoint(int x, int y, uint32 flags, uint32 p1, uint32 p2)
int32 CmdRenameWaypoint(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
Waypoint *wp;
StringID str;