void DrawNewHouseTile(TileInfo *ti, HouseID house_id) { const HouseSpec *hs = HouseSpec::Get(house_id); if (ti->tileh != SLOPE_FLAT) { bool draw_old_one = true; if (HasBit(hs->callback_mask, CBM_HOUSE_DRAW_FOUNDATIONS)) { /* Called to determine the type (if any) of foundation to draw for the house tile */ uint32 callback_res = GetHouseCallback(CBID_HOUSE_DRAW_FOUNDATIONS, 0, 0, house_id, Town::GetByTile(ti->tile), ti->tile); if (callback_res != CALLBACK_FAILED) draw_old_one = ConvertBooleanCallback(hs->grf_prop.grffile, CBID_HOUSE_DRAW_FOUNDATIONS, callback_res); } if (draw_old_one) DrawFoundation(ti, FOUNDATION_LEVELED); } HouseResolverObject object(house_id, ti->tile, Town::GetByTile(ti->tile)); const SpriteGroup *group = SpriteGroup::Resolve(hs->grf_prop.spritegroup[0], &object); if (group != NULL && group->type == SGT_TILELAYOUT) { /* Limit the building stage to the number of stages supplied. */ const TileLayoutSpriteGroup *tlgroup = (const TileLayoutSpriteGroup *)group; byte stage = GetHouseBuildingStage(ti->tile); DrawTileLayout(ti, tlgroup, stage, house_id); } }
static void DrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *group, byte stage, HouseID house_id) { const DrawTileSprites *dts = group->ProcessRegisters(&stage); const HouseSpec *hs = HouseSpec::Get(house_id); PaletteID palette = hs->random_colour[TileHash2Bit(ti->x, ti->y)] + PALETTE_RECOLOUR_START; if (HasBit(hs->callback_mask, CBM_HOUSE_COLOUR)) { uint16 callback = GetHouseCallback(CBID_HOUSE_COLOUR, 0, 0, house_id, Town::GetByTile(ti->tile), ti->tile); if (callback != CALLBACK_FAILED) { /* If bit 14 is set, we should use a 2cc colour map, else use the callback value. */ palette = HasBit(callback, 14) ? GB(callback, 0, 8) + SPR_2CCMAP_BASE : callback; } } SpriteID image = dts->ground.sprite; PaletteID pal = dts->ground.pal; if (HasBit(image, SPRITE_MODIFIER_CUSTOM_SPRITE)) image += stage; if (HasBit(pal, SPRITE_MODIFIER_CUSTOM_SPRITE)) pal += stage; if (GB(image, 0, SPRITE_WIDTH) != 0) { DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, palette)); } DrawNewGRFTileSeq(ti, dts, TO_HOUSES, stage, palette); }
void DrawNewHouseTile(TileInfo *ti, HouseID house_id) { const HouseSpec *hs = HouseSpec::Get(house_id); const SpriteGroup *group; ResolverObject object; if (ti->tileh != SLOPE_FLAT) { bool draw_old_one = true; if (HasBit(hs->callback_mask, CBM_HOUSE_DRAW_FOUNDATIONS)) { /* Called to determine the type (if any) of foundation to draw for the house tile */ uint32 callback_res = GetHouseCallback(CBID_HOUSE_DRAW_FOUNDATIONS, 0, 0, house_id, Town::GetByTile(ti->tile), ti->tile); draw_old_one = (callback_res != 0); } if (draw_old_one) DrawFoundation(ti, FOUNDATION_LEVELED); } NewHouseResolver(&object, house_id, ti->tile, Town::GetByTile(ti->tile)); group = SpriteGroup::Resolve(hs->spritegroup, &object); if (group == NULL || group->type != SGT_TILELAYOUT) { return; } else { /* Limit the building stage to the number of stages supplied. */ const TileLayoutSpriteGroup *tlgroup = (const TileLayoutSpriteGroup *)group; byte stage = GetHouseBuildingStage(ti->tile); stage = Clamp(stage - 4 + tlgroup->num_building_stages, 0, tlgroup->num_building_stages - 1); DrawTileLayout(ti, tlgroup, stage, house_id); } }
static void AnimationControl(TileIndex tile, uint16 random_bits) { const HouseSpec *hs = HouseSpec::Get(GetHouseType(tile)); if (HasBit(hs->callback_mask, CBM_HOUSE_ANIMATION_START_STOP)) { uint32 param = (hs->extra_flags & SYNCHRONISED_CALLBACK_1B) ? (GB(Random(), 0, 16) | random_bits << 16) : Random(); uint16 callback_res = GetHouseCallback(CBID_HOUSE_ANIMATION_START_STOP, param, 0, GetHouseType(tile), Town::GetByTile(tile), tile); if (callback_res != CALLBACK_FAILED) ChangeHouseAnimationFrame(hs->grffile, tile, callback_res); } }
bool CanDeleteHouse(TileIndex tile) { const HouseSpec *hs = HouseSpec::Get(GetHouseType(tile)); /* Humans are always allowed to remove buildings, as is water and * anyone using the scenario editor. */ if (Company::IsValidHumanID(_current_company) || _current_company == OWNER_WATER || _current_company == OWNER_NONE) { return true; } if (HasBit(hs->callback_mask, CBM_HOUSE_DENY_DESTRUCTION)) { uint16 callback_res = GetHouseCallback(CBID_HOUSE_DENY_DESTRUCTION, 0, 0, GetHouseType(tile), Town::GetByTile(tile), tile); return (callback_res == CALLBACK_FAILED || !ConvertBooleanCallback(hs->grf_prop.grffile, CBID_HOUSE_DENY_DESTRUCTION, callback_res)); } else { return !(hs->extra_flags & BUILDING_IS_PROTECTED); } }
bool NewHouseTileLoop(TileIndex tile) { const HouseSpec *hs = HouseSpec::Get(GetHouseType(tile)); if (GetHouseProcessingTime(tile) > 0) { DecHouseProcessingTime(tile); return true; } TriggerHouse(tile, HOUSE_TRIGGER_TILE_LOOP); if (hs->building_flags & BUILDING_HAS_1_TILE) TriggerHouse(tile, HOUSE_TRIGGER_TILE_LOOP_TOP); if (HasBit(hs->callback_mask, CBM_HOUSE_ANIMATION_START_STOP)) { /* If this house is marked as having a synchronised callback, all the * tiles will have the callback called at once, rather than when the * tile loop reaches them. This should only be enabled for the northern * tile, or strange things will happen (here, and in TTDPatch). */ if (hs->extra_flags & SYNCHRONISED_CALLBACK_1B) { uint16 random = GB(Random(), 0, 16); if (hs->building_flags & BUILDING_HAS_1_TILE) AnimationControl(tile, random); if (hs->building_flags & BUILDING_2_TILES_Y) AnimationControl(TILE_ADDXY(tile, 0, 1), random); if (hs->building_flags & BUILDING_2_TILES_X) AnimationControl(TILE_ADDXY(tile, 1, 0), random); if (hs->building_flags & BUILDING_HAS_4_TILES) AnimationControl(TILE_ADDXY(tile, 1, 1), random); } else { AnimationControl(tile, 0); } } /* Check callback 21, which determines if a house should be destroyed. */ if (HasBit(hs->callback_mask, CBM_HOUSE_DESTRUCTION)) { uint16 callback_res = GetHouseCallback(CBID_HOUSE_DESTRUCTION, 0, 0, GetHouseType(tile), Town::GetByTile(tile), tile); if (callback_res != CALLBACK_FAILED && Convert8bitBooleanCallback(hs->grf_prop.grffile, CBID_HOUSE_DESTRUCTION, callback_res)) { ClearTownHouse(Town::GetByTile(tile), tile); return false; } } SetHouseProcessingTime(tile, hs->processing_time); MarkTileDirtyByTile(tile); return true; }
/* Simple wrapper for GetHouseCallback to keep the animation unified. */ uint16 GetSimpleHouseCallback(CallbackID callback, uint32 param1, uint32 param2, const HouseSpec *spec, Town *town, TileIndex tile, uint32 extra_data) { return GetHouseCallback(callback, param1, param2, spec - HouseSpec::Get(0), town, tile, false, 0, extra_data); }
void AnimateNewHouseTile(TileIndex tile) { const HouseSpec *hs = HouseSpec::Get(GetHouseType(tile)); byte animation_speed = hs->animation_speed; bool frame_set_by_callback = false; if (HasBit(hs->callback_mask, CBM_HOUSE_ANIMATION_SPEED)) { uint16 callback_res = GetHouseCallback(CBID_HOUSE_ANIMATION_SPEED, 0, 0, GetHouseType(tile), Town::GetByTile(tile), tile); if (callback_res != CALLBACK_FAILED) animation_speed = Clamp(callback_res & 0xFF, 2, 16); } /* An animation speed of 2 means the animation frame changes 4 ticks, and * increasing this value by one doubles the wait. 2 is the minimum value * allowed for animation_speed, which corresponds to 120ms, and 16 is the * maximum, corresponding to around 33 minutes. */ if (_tick_counter % (1 << animation_speed) != 0) return; byte frame = GetHouseAnimationFrame(tile); byte num_frames = GB(hs->animation_frames, 0, 7); if (HasBit(hs->callback_mask, CBM_HOUSE_ANIMATION_NEXT_FRAME)) { uint32 param = (hs->extra_flags & CALLBACK_1A_RANDOM_BITS) ? Random() : 0; uint16 callback_res = GetHouseCallback(CBID_HOUSE_ANIMATION_NEXT_FRAME, param, 0, GetHouseType(tile), Town::GetByTile(tile), tile); if (callback_res != CALLBACK_FAILED) { frame_set_by_callback = true; switch (callback_res & 0xFF) { case 0xFF: DeleteAnimatedTile(tile); break; case 0xFE: /* Carry on as normal. */ frame_set_by_callback = false; break; default: frame = callback_res & 0xFF; break; } /* If the lower 7 bits of the upper byte of the callback * result are not empty, it is a sound effect. */ if (GB(callback_res, 8, 7) != 0) PlayTileSound(hs->grffile, GB(callback_res, 8, 7), tile); } } if (!frame_set_by_callback) { if (frame < num_frames) { frame++; } else if (frame == num_frames && HasBit(hs->animation_frames, 7)) { /* This animation loops, so start again from the beginning */ frame = 0; } else { /* This animation doesn't loop, so stay here */ DeleteAnimatedTile(tile); } } SetHouseAnimationFrame(tile, frame); MarkTileDirtyByTile(tile); }