From 295ed303af137464c995efe165d8767d22f89859 Mon Sep 17 00:00:00 2001 From: MascaraSnake Date: Sun, 26 Apr 2020 11:55:10 +0200 Subject: [PATCH] Make T_StartCrumble use its own thinker data structure --- src/p_floor.c | 175 +++++++++++++++++++++++++------------------------- src/p_map.c | 4 +- src/p_saveg.c | 59 ++++++++++++++++- src/p_spec.h | 20 +++++- 4 files changed, 164 insertions(+), 94 deletions(-) diff --git a/src/p_floor.c b/src/p_floor.c index 179cf73c7..d0fef319c 100644 --- a/src/p_floor.c +++ b/src/p_floor.c @@ -757,7 +757,7 @@ void T_BounceCheese(bouncecheese_t *bouncer) // T_StartCrumble //////////////////////////////// ////////////////////////////////////////////////// // Crumbling platform Tails 03-11-2002 -void T_StartCrumble(elevator_t *elevator) +void T_StartCrumble(crumble_t *crumble) { ffloor_t *rover; sector_t *sector; @@ -765,42 +765,42 @@ void T_StartCrumble(elevator_t *elevator) // Once done, the no-return thinker just sits there, // constantly 'returning'... kind of an oxymoron, isn't it? - if (((elevator->floordestheight == 1 && elevator->direction == -1) - || (elevator->floordestheight == 0 && elevator->direction == 1)) - && elevator->type == elevateContinuous) // No return crumbler + if (((crumble->floordestheight == 1 && crumble->direction == -1) + || (crumble->floordestheight == 0 && crumble->direction == 1)) + && crumble->type == elevateContinuous) // No return crumbler { - elevator->sector->ceilspeed = 0; - elevator->sector->floorspeed = 0; + crumble->sector->ceilspeed = 0; + crumble->sector->floorspeed = 0; return; } - if (elevator->distance != 0) + if (crumble->distance != 0) { - if (elevator->distance > 0) // Count down the timer + if (crumble->distance > 0) // Count down the timer { - elevator->distance--; - if (elevator->distance <= 0) - elevator->distance = -15*TICRATE; // Timer until platform returns to original position. + crumble->distance--; + if (crumble->distance <= 0) + crumble->distance = -15*TICRATE; // Timer until platform returns to original position. else { // Timer isn't up yet, so just keep waiting. - elevator->sector->ceilspeed = 0; - elevator->sector->floorspeed = 0; + crumble->sector->ceilspeed = 0; + crumble->sector->floorspeed = 0; return; } } - else if (++elevator->distance == 0) // Reposition back to original spot + else if (++crumble->distance == 0) // Reposition back to original spot { - for (i = -1; (i = P_FindSectorFromTag(elevator->sourceline->tag, i)) >= 0 ;) + for (i = -1; (i = P_FindSectorFromTag(crumble->sourceline->tag, i)) >= 0 ;) { sector = §ors[i]; for (rover = sector->ffloors; rover; rover = rover->next) { if (rover->flags & FF_CRUMBLE && rover->flags & FF_FLOATBOB - && rover->master == elevator->sourceline) + && rover->master == crumble->sourceline) { - rover->alpha = elevator->origspeed; + rover->alpha = crumble->origspeed; if (rover->alpha == 0xff) rover->flags &= ~FF_TRANSLUCENT; @@ -809,39 +809,39 @@ void T_StartCrumble(elevator_t *elevator) } // Up! - if (elevator->floordestheight == 1) - elevator->direction = -1; + if (crumble->floordestheight == 1) + crumble->direction = -1; else - elevator->direction = 1; + crumble->direction = 1; - elevator->sector->ceilspeed = 0; - elevator->sector->floorspeed = 0; + crumble->sector->ceilspeed = 0; + crumble->sector->floorspeed = 0; return; } // Flash to indicate that the platform is about to return. - if (elevator->distance > -224 && (leveltime % ((abs(elevator->distance)/8) + 1) == 0)) + if (crumble->distance > -224 && (leveltime % ((abs(crumble->distance)/8) + 1) == 0)) { - for (i = -1; (i = P_FindSectorFromTag(elevator->sourceline->tag, i)) >= 0 ;) + for (i = -1; (i = P_FindSectorFromTag(crumble->sourceline->tag, i)) >= 0 ;) { sector = §ors[i]; for (rover = sector->ffloors; rover; rover = rover->next) { if (!(rover->flags & FF_NORETURN) && rover->flags & FF_CRUMBLE && rover->flags & FF_FLOATBOB - && rover->master == elevator->sourceline) + && rover->master == crumble->sourceline) { - if (rover->alpha == elevator->origspeed) + if (rover->alpha == crumble->origspeed) { rover->flags |= FF_TRANSLUCENT; rover->alpha = 0x00; } else { - if (elevator->origspeed == 0xff) + if (crumble->origspeed == 0xff) rover->flags &= ~FF_TRANSLUCENT; - rover->alpha = elevator->origspeed; + rover->alpha = crumble->origspeed; } } } @@ -851,74 +851,74 @@ void T_StartCrumble(elevator_t *elevator) // We're about to go back to the original position, // so set this to let other thinkers know what is // about to happen. - if (elevator->distance < 0 && elevator->distance > -3) - elevator->sector->crumblestate = CRUMBLE_RESTORE; // makes T_BounceCheese remove itself + if (crumble->distance < 0 && crumble->distance > -3) + crumble->sector->crumblestate = CRUMBLE_RESTORE; // makes T_BounceCheese remove itself } - if ((elevator->floordestheight == 0 && elevator->direction == -1) - || (elevator->floordestheight == 1 && elevator->direction == 1)) // Down + if ((crumble->floordestheight == 0 && crumble->direction == -1) + || (crumble->floordestheight == 1 && crumble->direction == 1)) // Down { - elevator->sector->crumblestate = CRUMBLE_FALL; // Allow floating now. + crumble->sector->crumblestate = CRUMBLE_FALL; // Allow floating now. // Only fall like this if it isn't meant to float on water - if (elevator->high != 42) + if (crumble->high != 42) { - elevator->speed += gravity; // Gain more and more speed + crumble->speed += gravity; // Gain more and more speed - if ((elevator->floordestheight == 0 && !(elevator->sector->ceilingheight < -16384*FRACUNIT)) - || (elevator->floordestheight == 1 && !(elevator->sector->ceilingheight > 16384*FRACUNIT))) + if ((crumble->floordestheight == 0 && !(crumble->sector->ceilingheight < -16384*FRACUNIT)) + || (crumble->floordestheight == 1 && !(crumble->sector->ceilingheight > 16384*FRACUNIT))) { fixed_t dest; - if (elevator->floordestheight == 1) - dest = elevator->sector->ceilingheight + (elevator->speed*2); + if (crumble->floordestheight == 1) + dest = crumble->sector->ceilingheight + (crumble->speed*2); else - dest = elevator->sector->ceilingheight - (elevator->speed*2); + dest = crumble->sector->ceilingheight - (crumble->speed*2); T_MovePlane //jff 4/7/98 reverse order of ceiling/floor ( - elevator->sector, - elevator->speed, + crumble->sector, + crumble->speed, dest, false, true, // move ceiling - elevator->direction + crumble->direction ); - if (elevator->floordestheight == 1) - dest = elevator->sector->floorheight + (elevator->speed*2); + if (crumble->floordestheight == 1) + dest = crumble->sector->floorheight + (crumble->speed*2); else - dest = elevator->sector->floorheight - (elevator->speed*2); + dest = crumble->sector->floorheight - (crumble->speed*2); T_MovePlane ( - elevator->sector, - elevator->speed, + crumble->sector, + crumble->speed, dest, false, false, // move floor - elevator->direction + crumble->direction ); - elevator->sector->ceilspeed = 42; - elevator->sector->floorspeed = elevator->speed*elevator->direction; + crumble->sector->ceilspeed = 42; + crumble->sector->floorspeed = crumble->speed*crumble->direction; } } } else // Up (restore to original position) { - elevator->sector->crumblestate = CRUMBLE_WAIT; - elevator->sector->ceilingheight = elevator->ceilingwasheight; - elevator->sector->floorheight = elevator->floorwasheight; - elevator->sector->floordata = NULL; - elevator->sector->ceilingdata = NULL; - elevator->sector->ceilspeed = 0; - elevator->sector->floorspeed = 0; - elevator->sector->moved = true; - P_RemoveThinker(&elevator->thinker); + crumble->sector->crumblestate = CRUMBLE_WAIT; + crumble->sector->ceilingheight = crumble->ceilingwasheight; + crumble->sector->floorheight = crumble->floorwasheight; + crumble->sector->floordata = NULL; + crumble->sector->ceilingdata = NULL; + crumble->sector->ceilspeed = 0; + crumble->sector->floorspeed = 0; + crumble->sector->moved = true; + P_RemoveThinker(&crumble->thinker); } - for (i = -1; (i = P_FindSectorFromTag(elevator->sourceline->tag, i)) >= 0 ;) + for (i = -1; (i = P_FindSectorFromTag(crumble->sourceline->tag, i)) >= 0 ;) { sector = §ors[i]; sector->moved = true; @@ -2309,7 +2309,7 @@ void EV_DoContinuousFall(sector_t *sec, sector_t *backsector, fixed_t spd, boole INT32 EV_StartCrumble(sector_t *sec, ffloor_t *rover, boolean floating, player_t *player, fixed_t origalpha, boolean crumblereturn) { - elevator_t *elevator; + crumble_t *crumble; sector_t *foundsec; INT32 i; @@ -2320,55 +2320,54 @@ INT32 EV_StartCrumble(sector_t *sec, ffloor_t *rover, boolean floating, if (sec->crumblestate >= CRUMBLE_ACTIVATED) return 0; - // create and initialize new elevator thinker - elevator = Z_Calloc(sizeof (*elevator), PU_LEVSPEC, NULL); - P_AddThinker(THINK_MAIN, &elevator->thinker); - elevator->thinker.function.acp1 = (actionf_p1)T_StartCrumble; + // create and initialize new crumble thinker + crumble = Z_Calloc(sizeof (*crumble), PU_LEVSPEC, NULL); + P_AddThinker(THINK_MAIN, &crumble->thinker); + crumble->thinker.function.acp1 = (actionf_p1)T_StartCrumble; // Does this crumbler return? if (crumblereturn) - elevator->type = elevateBounce; + crumble->type = elevateBounce; else - elevator->type = elevateContinuous; + crumble->type = elevateContinuous; - // set up the fields according to the type of elevator action - elevator->sector = sec; - elevator->speed = 0; + // set up the fields + crumble->sector = sec; + crumble->speed = 0; if (player && player->mo && (player->mo->eflags & MFE_VERTICALFLIP)) { - elevator->direction = 1; // Up - elevator->floordestheight = 1; + crumble->direction = 1; // Up + crumble->floordestheight = 1; } else { - elevator->direction = -1; // Down - elevator->floordestheight = 0; + crumble->direction = -1; // Down + crumble->floordestheight = 0; } - elevator->floorwasheight = elevator->sector->floorheight; - elevator->ceilingwasheight = elevator->sector->ceilingheight; - elevator->distance = TICRATE; // Used for delay time - elevator->low = 0; - elevator->player = player; - elevator->origspeed = origalpha; + crumble->floorwasheight = crumble->sector->floorheight; + crumble->ceilingwasheight = crumble->sector->ceilingheight; + crumble->distance = TICRATE; // Used for delay time + crumble->player = player; + crumble->origspeed = origalpha; - elevator->sourceline = rover->master; + crumble->sourceline = rover->master; - sec->floordata = elevator; + sec->floordata = crumble; if (floating) - elevator->high = 42; + crumble->high = 42; else - elevator->high = 0; + crumble->high = 0; - elevator->sector->crumblestate = CRUMBLE_ACTIVATED; + crumble->sector->crumblestate = CRUMBLE_ACTIVATED; - for (i = -1; (i = P_FindSectorFromTag(elevator->sourceline->tag, i)) >= 0 ;) + for (i = -1; (i = P_FindSectorFromTag(crumble->sourceline->tag, i)) >= 0 ;) { foundsec = §ors[i]; - P_SpawnMobj(foundsec->soundorg.x, foundsec->soundorg.y, elevator->direction == 1 ? elevator->sector->floorheight : elevator->sector->ceilingheight, MT_CRUMBLEOBJ); + P_SpawnMobj(foundsec->soundorg.x, foundsec->soundorg.y, crumble->direction == 1 ? crumble->sector->floorheight : crumble->sector->ceilingheight, MT_CRUMBLEOBJ); } return 1; diff --git a/src/p_map.c b/src/p_map.c index accc52836..2b6623f71 100644 --- a/src/p_map.c +++ b/src/p_map.c @@ -4223,14 +4223,14 @@ static boolean PIT_ChangeSector(mobj_t *thing, boolean realcrush) { //If the thing was crushed by a crumbling FOF, reward the player who made it crumble! thinker_t *think; - elevator_t *crumbler; + crumble_t *crumbler; for (think = thlist[THINK_MAIN].next; think != &thlist[THINK_MAIN]; think = think->next) { if (think->function.acp1 != (actionf_p1)T_StartCrumble) continue; - crumbler = (elevator_t *)think; + crumbler = (crumble_t *)think; if (crumbler->player && crumbler->player->mo && crumbler->player->mo != thing diff --git a/src/p_saveg.c b/src/p_saveg.c index f6e31fc3a..5032cfc75 100644 --- a/src/p_saveg.c +++ b/src/p_saveg.c @@ -1930,6 +1930,30 @@ static void SaveElevatorThinker(const thinker_t *th, const UINT8 type) WRITEUINT32(save_p, SaveLine(ht->sourceline)); } +// +// SaveCrumbleThinker +// +// Saves a crumble_t thinker +// +static void SaveCrumbleThinker(const thinker_t *th, const UINT8 type) +{ + const crumble_t *ht = (const void *)th; + WRITEUINT8(save_p, type); + WRITEUINT8(save_p, ht->type); + WRITEUINT32(save_p, SaveSector(ht->sector)); + WRITEUINT32(save_p, SaveSector(ht->actionsector)); + WRITEINT32(save_p, ht->direction); + WRITEFIXED(save_p, ht->floordestheight); + WRITEFIXED(save_p, ht->speed); + WRITEFIXED(save_p, ht->origspeed); + WRITEFIXED(save_p, ht->high); + WRITEFIXED(save_p, ht->distance); + WRITEFIXED(save_p, ht->floorwasheight); + WRITEFIXED(save_p, ht->ceilingwasheight); + WRITEUINT32(save_p, SavePlayer(ht->player)); // was dummy + WRITEUINT32(save_p, SaveLine(ht->sourceline)); +} + // // SaveScrollThinker // @@ -2377,7 +2401,7 @@ static void P_NetArchiveThinkers(void) } else if (th->function.acp1 == (actionf_p1)T_CameraScanner) { - SaveElevatorThinker(th, tc_camerascanner); + SaveCrumbleThinker(th, tc_camerascanner); continue; } else if (th->function.acp1 == (actionf_p1)T_Scroll) @@ -3142,7 +3166,7 @@ static thinker_t* LoadFireflickerThinker(actionf_p1 thinker) return &ht->thinker; } // -// LoadElevatorThinker +// +vatorThinker // // Loads a elevator_t from a save game // @@ -3179,6 +3203,35 @@ static thinker_t* LoadElevatorThinker(actionf_p1 thinker, UINT8 floorOrCeiling) return &ht->thinker; } +// +// LoadCrumbleThinker +// +// Loads a crumble_t from a save game +// +static thinker_t* LoadCrumbleThinker(actionf_p1 thinker) +{ + crumble_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL); + ht->thinker.function.acp1 = thinker; + ht->type = READUINT8(save_p); + ht->sector = LoadSector(READUINT32(save_p)); + ht->actionsector = LoadSector(READUINT32(save_p)); + ht->direction = READINT32(save_p); + ht->floordestheight = READFIXED(save_p); + ht->speed = READFIXED(save_p); + ht->origspeed = READFIXED(save_p); + ht->high = READFIXED(save_p); + ht->distance = READFIXED(save_p); + ht->floorwasheight = READFIXED(save_p); + ht->ceilingwasheight = READFIXED(save_p); + ht->player = LoadPlayer(READUINT32(save_p)); // was dummy + ht->sourceline = LoadLine(READUINT32(save_p)); + + if (ht->sector) + ht->sector->floordata = ht; + + return &ht->thinker; +} + // // LoadScrollThinker // @@ -3707,7 +3760,7 @@ static void P_NetUnArchiveThinkers(void) break; case tc_startcrumble: - th = LoadElevatorThinker((actionf_p1)T_StartCrumble, 1); + th = LoadCrumbleThinker((actionf_p1)T_StartCrumble); break; case tc_marioblock: diff --git a/src/p_spec.h b/src/p_spec.h index e243e3a61..7e2a97ce9 100644 --- a/src/p_spec.h +++ b/src/p_spec.h @@ -311,6 +311,24 @@ typedef struct line_t *sourceline; } elevator_t; +typedef struct +{ + thinker_t thinker; + elevator_e type; + sector_t *sector; + sector_t *actionsector; // The sector the rover action is taking place in. + INT32 direction; + fixed_t floordestheight; + fixed_t speed; + fixed_t origspeed; + fixed_t high; + fixed_t distance; + fixed_t floorwasheight; // Height the floor WAS at + fixed_t ceilingwasheight; // Height the ceiling WAS at + player_t *player; // Player who initiated the thinker (used for airbob) + line_t *sourceline; +} crumble_t; + typedef struct { thinker_t thinker; @@ -440,7 +458,7 @@ void T_MoveFloor(floormove_t *movefloor); void T_MoveElevator(elevator_t *elevator); void T_ContinuousFalling(continuousfall_t *faller); void T_BounceCheese(bouncecheese_t *bouncer); -void T_StartCrumble(elevator_t *elevator); +void T_StartCrumble(crumble_t *crumble); void T_MarioBlock(mariothink_t *block); void T_FloatSector(floatthink_t *floater); void T_MarioBlockChecker(mariocheck_t *block);