thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2025-10-30 08:01:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Newly added object files: Fix trailing whitespace + EOF newline

Browse source
This commit is contained in:
toaster 2023-09-26 22:04:14 +01:00
parent bee1cb9a04
commit 490959b6f7
8 changed files with 328 additions and 331 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
src/objects/bungee.c
View file

@ -32,17 +32,17 @@
// Touching the bungee, used in p_inter.c
void Obj_BungeeSpecial(mobj_t *mo, player_t *p)
{
mobj_t *latch;
if (P_IsObjectOnGround(p->mo) || p->springstars || K_isPlayerInSpecialState(p))
return;
P_InstaThrust(p->mo, 0, 0);
p->bungee = BUNGEE_LATCH;
p->mo->flags |= MF_NOCLIPTHING; // prevent players from bumping if they latch onto the same bungee.
p->pflags |= PF_NOFASTFALL; // didn't know this flag existed but it's very convenient!!
latch = P_SpawnMobj(p->mo->x, p->mo->y, p->mo->z, MT_THOK);
P_SetMobjState(latch, S_INVISIBLE);
latch->angle = mo->angle;
@ -54,22 +54,22 @@ void Obj_BungeeSpecial(mobj_t *mo, player_t *p)
// this is the thinker to call on the player when they get bungee'd.
void Obj_playerBungeeThink(player_t *p)
{
mobj_t *bungee = p->mo->tracer;
UINT8 i;
// someone removed it
// someone removed it
if (!bungee || P_MobjWasRemoved(bungee))
return;
bungee->tics = 4; // we set this to a low value so that it despawns if the player vanishes for some reason.
if (p->bungee == BUNGEE_LATCH)
{
// rr has super high gravity which gets in the way.
p->mo->flags |= MF_NOGRAVITY;
p->mo->momz = (p->mo->momz*9)/10;
if (abs(p->mo->momz) < 6*mapobjectscale)
{
p->bungee = BUNGEE_LAUNCH;
@ -80,40 +80,40 @@ void Obj_playerBungeeThink(player_t *p)
else if (p->bungee == BUNGEE_LAUNCH)
{
p->mo->momz = (p->mo->momz*12)/10;
// if we go above/below (depending on our flip flags) the bungee, release us!
if ((p->mo->eflags & MFE_VERTICALFLIP && p->mo->z < bungee->z)
|| (!(p->mo->eflags & MFE_VERTICALFLIP) && p->mo->z > bungee->z ))
{
p->mo->flags &= ~MF_NOGRAVITY;
p->mo->flags &= ~MF_NOCLIPTHING;
p->pflags &= ~PF_NOFASTFALL;
p->bungee = BUNGEE_NONE;
P_InstaThrust(p->mo, bungee->angle, p->mo->momz/8);
p->mo->momz = (p->mo->momz*3)/4;
p->springstars = TICRATE; // these are used as a buffer not to latch to vines again.
p->springcolor = SKINCOLOR_EMERALD;
P_RemoveMobj(bungee);
P_SetTarget(&p->mo->tracer, NULL);
P_SetTarget(&p->mo->tracer, NULL);
return;
}
}
// basic visuals (but hey they work fine enough!)
for (i=0; i<8; i++)
{
fixed_t xpos = -(bungee->x - p->mo->x) /8 *i;
fixed_t ypos = -(bungee->y - p->mo->y) /8 *i;
fixed_t zpos = -(bungee->z - p->mo->z) /8 *i;
mobj_t *seg = P_SpawnMobj(bungee->x + xpos, bungee->y + ypos, bungee->z + zpos, MT_THOK);
P_SetScale(seg, mapobjectscale/3);
seg->color = SKINCOLOR_EMERALD;
seg->frame = 0;
seg->fuse = 2;
}
}
}

38
src/objects/dlzothers.c
View file

@ -36,10 +36,10 @@ void Obj_DLZHoverSpawn(mobj_t *mo)
void Obj_DLZHoverCollide(mobj_t *mo, mobj_t *mo2)
{
player_t *p = mo->player;
if (!p || p->lasthover == leveltime)
return;
if (abs(mo->z - mo2->z) < 512*mapobjectscale)
{
// momz adjust
@ -57,14 +57,14 @@ void Obj_DLZHoverCollide(mobj_t *mo, mobj_t *mo2)
mo->momz += 8*mapobjectscale;
}
}
// speed adjust
if (p->speed > K_GetKartSpeed(p, false, false))
P_Thrust(mo, R_PointToAngle2(0, 0, -mo->momx, -mo->momy), mapobjectscale/16);
if (!S_SoundPlaying(mo, sfx_s3kc6s))
S_StartSound(mo, sfx_s3kc6s);
p->lasthover = leveltime;
}
}
@ -83,23 +83,23 @@ void Obj_DLZRingVaccumCollide(mobj_t *mo, mobj_t *mo2)
if (mo->z + mo->height < mo2->z)
return;
if (mo->z > mo2->z + mo2->height)
return;
if (!P_IsObjectOnGround(mo) || mo->momz)
return;
fake = P_SpawnMobj(mo->x, mo->y, mo->z, MT_FLINGRING);
P_SetScale(fake, mo->scale);
fake->scalespeed = mapobjectscale/64;
fake->destscale = 1;
P_SetTarget(&fake->target, mo2);
fake->angle = R_PointToAngle2(mo2->x, mo2->y, fake->x, fake->y);
fake->movefactor = R_PointToDist2(mo2->x, mo2->y, fake->x, fake->y);
P_RemoveMobj(mo);
}
@ -107,27 +107,27 @@ void Obj_DLZSuckedRingThink(mobj_t *mo)
{
mobj_t *t = mo->target;
fixed_t x, y;
// commit die if the target disappears for some fucking reason
if (!t || P_MobjWasRemoved(t))
{
P_RemoveMobj(mo);
return;
}
x = t->x + mo->movefactor*FINECOSINE(mo->angle>>ANGLETOFINESHIFT);
y = t->y + mo->movefactor*FINESINE(mo->angle>>ANGLETOFINESHIFT);
P_MoveOrigin(mo, x, y, mo->z);
if (mo->cusval < 24)
mo->cusval++;
mo->angle += mo->cusval*ANG1;
if (mo->cusval > 8 && mo->movefactor)
mo->movefactor -= 1;
if (mo->scale < mapobjectscale/12)
P_RemoveMobj(mo);
}
}

71
src/objects/dlzrocket.c
View file

@ -36,25 +36,25 @@ void Obj_DLZRocketThink(mobj_t *mo)
{
UINT8 i;
angle_t an = mo->angle + ANGLE_90;
if (mo->extravalue1)
return;
for (i = 0; i < 2; i++)
{
fixed_t x = mo->x + FixedMul(mapobjectscale, DLZROCKETDIST*FINECOSINE(an>>ANGLETOFINESHIFT));
fixed_t y = mo->y + FixedMul(mapobjectscale, DLZROCKETDIST*FINESINE(an>>ANGLETOFINESHIFT));
mobj_t *r = P_SpawnMobj(x, y, mo->z, MT_THOK);
P_SetMobjState(r, i ? S_DLZROCKET_L : S_DLZROCKET_R);
P_SetScale(r, (mapobjectscale*3)/2);
r->destscale = (mapobjectscale*3)/2;
r->angle = mo->spawnpoint->angle*ANG1;
r->tics = -1;
an += ANGLE_180;
}
mo->extravalue1 = 1;
}
@ -63,7 +63,7 @@ void Obj_DLZRocketDismount(player_t *p)
// we aren't mounted on one.
if (!p->dlzrocket)
return;
p->dlzrocket = 0;
K_SpawnMineExplosion(p->mo, p->mo->color, 3);
S_StartSound(p->mo, sfx_s3k4e);
@ -74,29 +74,29 @@ void Obj_DLZRocketSpecial(mobj_t *mo, player_t *p)
{
if (K_isPlayerInSpecialState(p)) // already on one, don't bother resetting, duh.
return;
p->mo->z = mo->z + 16*P_MobjFlip(p->mo)*mapobjectscale;
P_SetPlayerAngle(p->mo->player, mo->angle);
p->dlzrocket = true;
p->dlzrocketangle = mo->angle;
p->dlzrocketanglev = 0;
p->dlzrocketspd = DLZROCKETSPEED;
p->spinouttimer = 0;
p->wipeoutslow = 0;
S_StartSound(mo, sfx_s262);
}
void Obj_playerDLZRocket(player_t *p)
{
fixed_t maxspd = DLZROCKETSPEED;
angle_t visangle;
UINT8 i, j;
p->dlzrocket++;
// helper arrows at the start of the ride to tell players they can move freely
if (p->dlzrocket < TICRATE*2
&& leveltime%10 < 5)
@ -107,22 +107,20 @@ void Obj_playerDLZRocket(player_t *p)
P_SetScale(arr, 2*mapobjectscale);
arr->tics = 2;
}
// calc max speed
if (p->ringboost)
maxspd += 10;
if (p->startboost)
maxspd += 30;
// set player speed
if (p->dlzrocketspd < maxspd)
p->dlzrocketspd++;
else if (p->dlzrocketspd > maxspd)
p->dlzrocket--;
// so long as PF_STASIS is applied, let the angle be overwritten freely.
// this is used by seasaws but can be used for misc modding purposes too.
if (p->pflags & PF_STASIS)
@ -131,42 +129,42 @@ void Obj_playerDLZRocket(player_t *p)
{
SINT8 turndir = 0;
P_SetPlayerAngle(p->mo->player, p->dlzrocketangle);
if (p->cmd.turning > 0)
turndir = 1;
else if (p->cmd.turning < 0)
turndir = -1;
p->dlzrocketangle += turndir*DLZROCKETTURNSPEED;
if (p->cmd.throwdir > 0)
p->dlzrocketanglev = min(DLZROCKETMAXVERT, p->dlzrocketanglev + DLZROCKETVERTSPEED);
else if (p->cmd.throwdir < 0)
p->dlzrocketanglev = max(-DLZROCKETMAXVERT, p->dlzrocketanglev - DLZROCKETVERTSPEED);
}
// angle correction on ceilings (THIS CODE LOOKS AWFUL AND IT CAN PROBABLY BE DONE BETTER......)
if ( (!(p->mo->eflags & MFE_VERTICALFLIP) && (p->mo->z+p->mo->height >= p->mo->ceilingz))
|| (p->mo->eflags & MFE_VERTICALFLIP && p->mo->z <= p->mo->floorz))
if ( (!(p->mo->eflags & MFE_VERTICALFLIP) && p->dlzrocketanglev > 0)
|| (p->mo->eflags & MFE_VERTICALFLIP && p->dlzrocketanglev < 0))
p->dlzrocketanglev = 0;
if (!(p->pflags & PF_STASIS))
{
angle_t van = p->dlzrocketanglev /4;
P_InstaThrust(p->mo, p->dlzrocketangle, FixedMul(mapobjectscale, p->dlzrocketspd*FINECOSINE(van>>ANGLETOFINESHIFT)));
p->mo->momz = FixedMul(mapobjectscale, p->dlzrocketspd*FINESINE((angle_t)p->dlzrocketanglev>>ANGLETOFINESHIFT));
p->mo->momz = FixedMul(mapobjectscale, p->dlzrocketspd*FINESINE((angle_t)p->dlzrocketanglev>>ANGLETOFINESHIFT));
}
if (leveltime%4 == 0)
S_StartSound(p->mo, sfx_s1c8);
// finally, visuals.
visangle = p->mo->angle + ANGLE_90;
for (i = 0; i < 2; i++)
{
fixed_t x = p->mo->x + FixedMul(mapobjectscale, 56*FINECOSINE(visangle>>ANGLETOFINESHIFT));
@ -176,29 +174,28 @@ void Obj_playerDLZRocket(player_t *p)
P_SetMobjState(r, i ? S_DLZROCKET_L : S_DLZROCKET_R);
P_SetScale(r, (mapobjectscale*3)/2);
r->angle = p->mo->angle;
for (j = 0; j < 2; j++)
{
fixed_t xoffs = P_RandomRange(PR_FUZZ, -6, 6)*mapobjectscale;
fixed_t yoffs = P_RandomRange(PR_FUZZ, -6, 6)*mapobjectscale;
fixed_t soffs = P_RandomRange(PR_FUZZ, 0, 3);
mobj_t *expl = P_SpawnMobj(r->x + xoffs, r->y + yoffs, r->z + xoffs, MT_THOK);
P_SetMobjState(expl, S_QUICKBOOM1+soffs);
expl->color = p->mo->color;
P_SetScale(expl, mapobjectscale);
expl->destscale = 2*mapobjectscale;
if (p->startboost)
expl->color = K_RainbowColor(leveltime);
}
visangle += ANGLE_180;
}
if ((p->dlzrocket > 10 && (P_IsObjectOnGround(p->mo) || p->mo->eflags & MFE_JUSTBOUNCEDWALL))
|| p->spinouttimer || p->wipeoutslow || p->tumbleHeight)
Obj_DLZRocketDismount(p);
}
}

124
src/objects/dlzseasaw.c
View file

@ -28,34 +28,34 @@
// updates the seasaw's visuals and hitboxes using the hnext/hprev list.
static void Obj_DLZSeasawUpdate(mobj_t *mo, boolean ghostme)
{
mobj_t *ptr = mo;
mobj_t *ptrp = mo;
UINT8 i, j;
angle_t visan = (angle_t)mo->extravalue1 + ANGLE_90;
P_SetScale(mo, 2*mapobjectscale);
if (mo->tracer && !P_MobjWasRemoved(mo->tracer))
{
mo->tracer->tics = 3;
P_MoveOrigin(mo->tracer, mo->x, mo->y, mo->z);
P_SetScale(mo->tracer, mo->scale);
if (mo->eflags & MFE_VERTICALFLIP)
{
mo->tracer->eflags |= MFE_VERTICALFLIP;
mo->tracer->eflags |= MF2_OBJECTFLIP;
}
}
for (i = 0; i < 2; i++)
{
INT32 dist = 32; // visuals dist
INT32 hdist = 16; // hitbox dist
// visuals
for (j = 0; j < 2; j++)
{
@ -65,7 +65,7 @@ static void Obj_DLZSeasawUpdate(mobj_t *mo, boolean ghostme)
fixed_t x = mo->x + FixedMul(mo->scale, dist*FINECOSINE(visan>>ANGLETOFINESHIFT));
fixed_t y = mo->y + FixedMul(mo->scale, dist*FINESINE(visan>>ANGLETOFINESHIFT));
ptr = ptr->hnext;
P_MoveOrigin(ptr, x, y, mo->z + 8*mapobjectscale*P_MobjFlip(mo));
ptr->angle = visan;
ptr->tics = 3;
@ -76,7 +76,7 @@ static void Obj_DLZSeasawUpdate(mobj_t *mo, boolean ghostme)
ptr->eflags |= MFE_VERTICALFLIP;
ptr->flags2 |= MF2_OBJECTFLIP;
}
if (ghostme && leveltime&1)
{
mobj_t *g = P_SpawnGhostMobj(ptr);
@ -84,23 +84,23 @@ static void Obj_DLZSeasawUpdate(mobj_t *mo, boolean ghostme)
g->color = mo->color;
g->fuse = 3;
}
dist += 55;
}
}
// hitboxes:
for (j = 0; j < 8; j++)
{
// get our mobj.
if (ptrp && !P_MobjWasRemoved(ptrp) && ptrp->hprev && !P_MobjWasRemoved(ptrp->hprev))
{
fixed_t x = mo->x + FixedMul(mo->scale, hdist*FINECOSINE(visan>>ANGLETOFINESHIFT));
fixed_t y = mo->y + FixedMul(mo->scale, hdist*FINESINE(visan>>ANGLETOFINESHIFT));
fixed_t y = mo->y + FixedMul(mo->scale, hdist*FINESINE(visan>>ANGLETOFINESHIFT));
ptrp = ptrp->hprev;
P_SetOrigin(ptrp, x, y, mo->z + 8*mapobjectscale*P_MobjFlip(mo)); // it's invisible so nobody cares about interpolating it.
ptrp->angle = visan;
ptrp->tics = 3;
@ -111,12 +111,12 @@ static void Obj_DLZSeasawUpdate(mobj_t *mo, boolean ghostme)
ptrp->eflags |= MFE_VERTICALFLIP;
ptrp->flags2 |= MF2_OBJECTFLIP;
}
hdist += 16;
}
}
visan += ANGLE_180;
}
}
@ -128,10 +128,10 @@ void Obj_DLZSeasawSpawn(mobj_t *mo)
mobj_t *ptr = mo;
mobj_t *ptrp = mo;
UINT8 i, j;
// setup vars
mo->extravalue1 = (INT32)mo->angle;
// center pole:
pole = P_SpawnMobj(mo->x, mo->y, mo->z, MT_THOK);
pole->tics = -1;
@ -139,37 +139,37 @@ void Obj_DLZSeasawSpawn(mobj_t *mo)
pole->frame = 0;
P_SetTarget(&pole->target, mo);
P_SetTarget(&mo->tracer, pole);
if (mo->eflags & MFE_VERTICALFLIP)
pole->eflags |= MFE_VERTICALFLIP;
// spawn visuals / hitboxes.
for (i = 0; i < 2; i++) // for each side...
{
for (j = 0; j < 2; j++) // spawn the 2 visual papersprites on each side.
{
// right now we don't care if the objects are positionned properly.
mobj_t *vis = P_SpawnMobj(mo->x, mo->y, mo->z + 8*mapobjectscale*P_MobjFlip(mo), MT_DLZ_SEASAW_VISUAL);
vis->sprite = SPR_DLZS;
vis->frame = (j+1)|FF_PAPERSPRITE;
vis->tics = -1;
if (mo->eflags & MFE_VERTICALFLIP)
{
vis->eflags |= MFE_VERTICALFLIP;
vis->flags2 |= MF2_OBJECTFLIP;
}
P_SetTarget(&vis->target, mo);
P_SetTarget(&ptr->hnext, vis); // save in an hnext list for updating later.
ptr = vis;
}
for (j = 0; j < 8; j++) // spawn the 8 hitboxes on each side.
{
// right now we don't care if the objects are positionned properly.
mobj_t *h = P_SpawnMobj(mo->x, mo->y, mo->z + 8*mapobjectscale*P_MobjFlip(mo), MT_DLZ_SEASAW_HITBOX);
h->extravalue1 = i; // keep track of which side we're on.
h->tics = -1;
@ -179,22 +179,22 @@ void Obj_DLZSeasawSpawn(mobj_t *mo)
h->eflags |= MFE_VERTICALFLIP;
h->flags2 |= MF2_OBJECTFLIP;
}
P_SetTarget(&h->target, mo);
P_SetTarget(&ptrp->hprev, h); // save in an hprev list for updating later.
ptrp = h;
}
}
// update after spawning the objects so that they appear in the right spot when the map loads.
Obj_DLZSeasawUpdate(mo, false);
Obj_DLZSeasawUpdate(mo, false);
}
static void Obj_DLZSeasawReset(mobj_t *mo)
{
mo->extravalue1 = (INT32)mo->angle;
P_SetTarget(&mo->target, NULL);
Obj_DLZSeasawUpdate(mo, false);
Obj_DLZSeasawUpdate(mo, false);
}
// main seasaw thinker.
@ -203,26 +203,26 @@ void Obj_DLZSeasawThink(mobj_t *mo)
boolean ghost = false;
SINT8 rot = 1;
fixed_t px, py;
if (mo->target && !P_MobjWasRemoved(mo->target))
{
mobj_t *t = mo->target;
player_t *p = t->player; // our target should always be a player, do NOT porceed if it isn't.
if (!p) // untarget this instantly.
{
Obj_DLZSeasawReset(mo);
return;
}
if (!mo->extravalue2)
rot = -1;
// first half of the animation...
if (!p->seasawdir)
{
INT32 angleadd = ANG1*max(4, (mo->movefactor/3)/mapobjectscale) * rot;
if (p->seasawangleadd > 175)
angleadd /= max(1, (p->seasawangleadd - 160)/8);
@ -242,39 +242,39 @@ void Obj_DLZSeasawThink(mobj_t *mo)
p->seasawangleadd = 0; // reset, we're gonna do a full 360!
p->seasawmoreangle = p->seasawangleadd - 170;
S_StartSound(t, sfx_s3k88);
S_StartSound(t, sfx_s3ka2);
S_StartSound(t, sfx_s3ka2);
}
}
else
{
INT32 angleadd = (mo->cvmem*2 +1)*(-rot);
mo->cvmem++;
p->seasawangleadd += abs(angleadd)/2; // for some reason i need to do this and i'm actually not sure why.
mo->extravalue1 += angleadd*ANG1;
p->seasawangle += angleadd*ANG1;
P_SetPlayerAngle(p, (angle_t)(p->seasawangle - ANGLE_90*rot));
P_SetPlayerAngle(p, (angle_t)(p->seasawangle - ANGLE_90*rot));
ghost = true;
if (p->seasawangleadd >= 340 + p->seasawmoreangle)
{
// reset everything and send the player zooming
Obj_DLZSeasawReset(mo);
P_SetPlayerAngle(p, mo->angle);
P_MoveOrigin(t, t->x, t->y, t->z); // miscall that to set the position properly.
P_InstaThrust(t, mo->angle, mo->movefactor*3); // send the player flying at triple the speed they came at us with.
S_StartSound(t, sfx_cdfm62);
p->seasawangleadd = 0;
p->seasawangle = 0;
p->seasawmoreangle = 0;
p->seasaw = false;
Obj_DLZSeasawUpdate(mo, true);
Obj_DLZSeasawUpdate(mo, true);
return;
}
}
// update the player
@ -285,9 +285,9 @@ void Obj_DLZSeasawThink(mobj_t *mo)
}
else
Obj_DLZSeasawReset(mo);
// finally, update the visuals.
Obj_DLZSeasawUpdate(mo, ghost);
Obj_DLZSeasawUpdate(mo, ghost);
}
// ported just for convenience of not needing to rewrite the code to account for UINT32 angles...
@ -308,7 +308,7 @@ void Obj_DLZSeasawCollide(mobj_t *mo, mobj_t *mo2)
// cooldown / respawning
if (p->seasawcooldown || p->respawn.timer)
return;
// other wacko state that'd do very weird shit if we overwrote it.
if (K_isPlayerInSpecialState(p))
return;
@ -316,23 +316,23 @@ void Obj_DLZSeasawCollide(mobj_t *mo, mobj_t *mo2)
// another player is already using the seasar
if (mo2->target && !P_MobjWasRemoved(mo2->target) && mo2->target->target && !P_MobjWasRemoved(mo2->target->target))
return;
// height checks
if (mo->z + mo->height < mo2->z)
return;
if (mo->z > mo2->z + mo2->height)
return;
// too slow.
if (p->speed < K_GetKartSpeed(p, false, false)/3)
return;
momangle = angtoint(R_PointToAngle2(0, 0, mo->momx, mo->momy));
//CONS_Printf("%d / %d -> %d\n", momangle, angtoint(mo2->target->angle), (abs(((momangle - angtoint(mo2->target->angle) +180) % 360) - 180)));
// this depends on the side we hit the thing from.
if (abs(((momangle - angtoint(mo2->target->angle) +180) % 360) - 180) > 60)
{
@ -340,17 +340,17 @@ void Obj_DLZSeasawCollide(mobj_t *mo, mobj_t *mo2)
mo2->target->extravalue1 += ANGLE_180;
invert = true;
}
mo2->target->movefactor = p->speed; // keep the speed the player was going at.
mo2->target->extravalue2 = mo2->extravalue1; // which side of the pole are we on?
// if inverted, then invert the value too.
if (invert)
mo2->target->extravalue2 = (!mo2->target->extravalue2) ? 1 : 0;
P_SetTarget(&mo2->target->target, mo);
mo2->target->cvmem = 0;
// set player vars now:
p->seasawdist = R_PointToDist2(mo->x, mo->y, mo2->target->x, mo2->target->y) /FRACUNIT; // distance from us to the center
p->seasawangle = (INT32)R_PointToAngle2(mo2->target->x, mo2->target->y, mo->x, mo->y); // angle from the center to us
@ -359,6 +359,6 @@ void Obj_DLZSeasawCollide(mobj_t *mo, mobj_t *mo2)
p->seasaw = true;
p->pflags |= PF_STASIS;
p->seasawcooldown = TICRATE/2;
S_StartSound(mo, sfx_s3k88);
}
}

34
src/objects/eggball.c
View file

@ -37,7 +37,7 @@ void Obj_EggBallSpawnerThink(mobj_t *mo)
mobj_t *ball = P_SpawnMobj(mo->x, mo->y, mo->z, MT_LSZ_EGGBALL);
ball->angle = mo->angle;
P_SetScale(ball, 6*mapobjectscale);
mo->extravalue1 = P_RandomRange(PR_FUZZ, TICRATE*BALLMINSPAWNTIME, TICRATE*BALLMAXSPAWNTIME);
}
mo->extravalue1--;
@ -50,18 +50,18 @@ void Obj_EggBallSpawnerThink(mobj_t *mo)
void Obj_EggBallThink(mobj_t *mo)
{
P_SetScale(mo, 6*mapobjectscale);
if (mo->eflags & MFE_JUSTHITFLOOR
&& mo->threshold)
{
if (mo->threshold < -10*mapobjectscale)
{
UINT8 i;
mo->momz = (fixed_t)(-mo->threshold)/8;
for (i=0; i<16; i++)
{
angle_t an = ANG1;
@ -70,14 +70,14 @@ void Obj_EggBallThink(mobj_t *mo)
P_InstaThrust(dust, (360/16)*an*i, mapobjectscale*24); // the angle thing is to avoid a warning due to overflows.
dust->momz = P_RandomRange(PR_FUZZ, 0, 7)*mapobjectscale;
}
S_StartSound(mo, sfx_s3k59);
P_StartQuakeFromMobj(FRACUNIT*20, 6, 512 * mapobjectscale, mo);
}
}
if (!mo->extravalue1)
{
if (P_IsObjectOnGround(mo))
@ -95,17 +95,17 @@ void Obj_EggBallThink(mobj_t *mo)
fixed_t dx = mo->x + P_RandomRange(PR_FUZZ, -96, 96)*mapobjectscale - mo->momx*2;
fixed_t dy = mo->y + P_RandomRange(PR_FUZZ, -96, 96)*mapobjectscale - mo->momy*2;
fixed_t dz = mo->z;
mobj_t *dust = P_SpawnMobj(dx, dy, dz, MT_DRIFTDUST);
P_SetScale(dust, mapobjectscale*3);
dust->momz = P_RandomRange(PR_FUZZ, 0, 7)*mapobjectscale;
dust->momz = P_RandomRange(PR_FUZZ, 0, 7)*mapobjectscale;
dust->destscale = mapobjectscale*8;
}
P_InstaThrust(mo, mo->angle, mo->cusval);
mo->extravalue2 += 1;
mo->frame = mo->extravalue2 % (24 * 2) / 2; // 24 is for frame Y.
// build up speed
if (P_IsObjectOnGround(mo))
{
@ -124,11 +124,11 @@ void Obj_EggBallThink(mobj_t *mo)
}
}
}
mo->movedir = mo->z;
mo->movedir = mo->z;
}
mo->threshold = mo->momz;
if (P_CheckDeathPitCollide(mo))
P_RemoveMobj(mo);
}
}

212
src/objects/rideroid.c
View file

@ -48,17 +48,17 @@ static void plr_resetRideroidVars(player_t *p)
p->rideroidangle = 0;
p->rideroidspeed = 0;
p->rideroidrollangle = 0;
p->rdaddmomx = 0;
p->rdaddmomy = 0;
p->rdaddmomz = 0;
p->rdaddmomz = 0;
}
// kills the rideroid and removes it from the map.
static void Obj_killRideroid(mobj_t *mo)
{
UINT8 i;
for (i = 0; i < 32; i++)
{
mobj_t *t = P_SpawnMobj(mo->x, mo->y, mo->z, MT_THOK);
@ -76,11 +76,11 @@ static void Obj_killRideroid(mobj_t *mo)
void Obj_getPlayerOffRideroid(mobj_t *mo)
{
mobj_t *pmo = mo->target;
if (pmo && !P_MobjWasRemoved(pmo))
{
player_t *p = pmo->player;
pmo->flags &= ~MF_NOGRAVITY;
plr_resetRideroidVars(p);
@ -89,9 +89,9 @@ void Obj_getPlayerOffRideroid(mobj_t *mo)
mo->momy = mo->momy*2;
mo->momz = 0;
mo->target = NULL;
S_StartSound(mo, sfx_ridr4);
}
}
@ -103,11 +103,11 @@ static void Obj_explodeRideroid(mobj_t *mo)
Obj_getPlayerOffRideroid(mo);
K_SpawnMineExplosion(pmo, pmo->color, 3);
S_StartSound(pmo, sfx_s3k4e);
S_StartSound(pmo, sfx_s3k4e);
Obj_killRideroid(mo);
// @TODO: quake.
}
// used to create a smooth trail.
@ -120,23 +120,23 @@ static void Obj_rideroidTrail(mobj_t *mo)
{
mobj_t *pmo = mo->target;
player_t *p = NULL;
UINT8 i, j;
angle_t h_an = mo->angle + ANG1*90;
if (pmo && !P_MobjWasRemoved(pmo))
{
p = pmo->player; // used to make some graphics local to save on framerate
mo->color = pmo->color;
mo->colorized = pmo->colorized;
}
}
// from here, we will use the following:
// extravalue1: prev x
// extravalue2: prev y
// cusval: prev z
// cvmem: prev roll angle
for (j = 0; j < 9; j++)
{
for (i = 0; i < 2; i++)
@ -146,14 +146,14 @@ static void Obj_rideroidTrail(mobj_t *mo)
fixed_t x = (fixed_t)Obj_rideroidLerp((fixed_t)mo->extravalue1, mo->x, percent);
fixed_t y = (fixed_t)Obj_rideroidLerp((fixed_t)mo->extravalue2, mo->y, percent);
fixed_t z = (fixed_t)Obj_rideroidLerp((fixed_t)mo->cusval, mo->z, percent);
angle_t v_an = i ? (roll+ANG1*90) : (roll-ANG1*90);
fixed_t pos = FixedMul(mo->scale, FINESINE(v_an>>ANGLETOFINESHIFT)*60);
fixed_t tx = x+FixedMul(FINECOSINE(h_an>>ANGLETOFINESHIFT), pos);
fixed_t ty = y+FixedMul(FINESINE(h_an>>ANGLETOFINESHIFT), pos);
fixed_t tz = z+FixedMul(FINECOSINE(v_an>>ANGLETOFINESHIFT)*60, mo->scale);
mobj_t *t = P_SpawnMobj(tx, ty, tz, MT_THOK);
t->color = SKINCOLOR_TEAL;
t->frame = FF_FULLBRIGHT|FF_TRANS50;
@ -168,10 +168,10 @@ static void Obj_rideroidTrail(mobj_t *mo)
else if (p->startboost)
t->color = K_RainbowColor(leveltime);
}
}
}
mo->extravalue1 = (INT32)mo->x;
mo->extravalue2 = (INT32)mo->y;
mo->cusval = (INT32)mo->z;
@ -182,15 +182,15 @@ static void Obj_rideroidTrail(mobj_t *mo)
static void Obj_updateRideroidPos(mobj_t *mo)
{
mobj_t *pmo = mo->target;
fixed_t x = pmo->x + 2*FINECOSINE(pmo->angle>>ANGLETOFINESHIFT);
fixed_t y = pmo->y + 2*FINESINE(pmo->angle>>ANGLETOFINESHIFT);
P_MoveOrigin(mo, x, y, pmo->z - 10*mapobjectscale);
mo->momx = pmo->momx;
mo->momy = pmo->momy;
mo->momz = pmo->momz;
Obj_rideroidTrail(mo);
}
@ -199,16 +199,16 @@ void Obj_RideroidThink(mobj_t *mo)
{
player_t *p;
mobj_t *pmo = mo->target;
fixed_t basemomx;
fixed_t basemomy;
fixed_t xthreshold;
fixed_t ythreshold;
// speed values...
fixed_t maxspd = RIDEROIDSPEED*mapobjectscale;
if (!pmo || P_MobjWasRemoved(pmo))
{
if (!mo->fuse)
@ -226,69 +226,69 @@ void Obj_RideroidThink(mobj_t *mo)
}
return;
}
// if we're here, our player should still exist which is kinda crazy!
p = pmo->player;
// pulling towards the node, AKA towards where the rideroid is, which just so happens to be us right now.
if (p->rdnodepull)
{
pmo->momx = (mo->x - pmo->x)/6;
pmo->momy = (mo->y - pmo->y)/6;
pmo->momz = (mo->z - pmo->z)/6;
//CONS_Printf("%d\n", R_PointToDist2(mo->x, mo->y, pmo->x, pmo->y)/FRACUNIT);
if (R_PointToDist2(mo->x, mo->y, pmo->x, pmo->y) < NODEPULLOK*mapobjectscale)
{
p->rideroid = true;
p->rdnodepull = false;
S_StartSound(pmo, sfx_ridr2);
}
return;
}
// if we're here, we made it to the rideroid and we can use it, or something like that!
// calculate the maximum speed we can move at.
// the values are a little arbitrary but they work for how little use these have.
if (p->ringboost)
maxspd = (maxspd*12)/10; // Ring Boost: 120% max speed.
if (p->draftpower)
{
UINT8 draftperc = (p->draftpower*100 / FRACUNIT); // 0-100%
maxspd += (draftperc/5) / 100;
}
if (p->startboost)
maxspd = (maxspd*15)/10; // 150% speed
// increase speed as we go unless we're turning harshly.
if (p->rideroidspeed*mapobjectscale < maxspd)
{
if (abs(p->cmd.turning < 400))
p->rideroidspeed += (p->ringboost ? 2 : 1); // acceleration is also higher with a ring boost.
p->rideroidspeed += (p->ringboost ? 2 : 1); // acceleration is also higher with a ring boost.
}
else
p->rideroidspeed -= 1;
// sounds
mo->movecount++; // we use this as a timer for sounds and whatnot.
if (mo->movecount == 1 || !(mo->movecount%TICRATE))
S_StartSound(mo, sfx_ridr3);
// aaaaand the actual gameplay and shit... wooooo
pmo->angle = mo->angle;
pmo->flags |= MF_NOGRAVITY;
// do not let the player touch the ground
// @TODO: check all 4 corners of the player and use P_GetZAt to account for slopes if pmo->standslope isn't NULL.
// right now it's not important as LV doesn't mix rdr and slopes but if somehow i manage to pull through w this shit it'll need to be done
@ -304,22 +304,22 @@ void Obj_RideroidThink(mobj_t *mo)
if (pmo->z < minz)
pmo->z = minz;
}
// if we hit a wall or get hit, get off of the rideroid.
if (pmo->eflags & MFE_JUSTBOUNCEDWALL || P_PlayerInPain(p))
{
Obj_explodeRideroid(mo);
return;
}
// now actual movement:
// first, do the movement for this frame
P_InstaThrust(pmo, (angle_t)p->rideroidangle, p->rideroidspeed*mapobjectscale);
basemomx = p->mo->momx;
basemomy = p->mo->momy;
pmo->momx += p->rdaddmomx;
pmo->momy += p->rdaddmomy;
pmo->momz += p->rdaddmomz;
@ -329,7 +329,7 @@ void Obj_RideroidThink(mobj_t *mo)
pmo->rollangle = p->rideroidrollangle;
mo->rollangle = p->rideroidrollangle;
pmo->pitch = 0;
// update the rideroid object (me) to be below the target player
Obj_updateRideroidPos(mo);
@ -340,71 +340,71 @@ void Obj_RideroidThink(mobj_t *mo)
fixed_t savemomy = pmo->momy;
SINT8 dir = 0;
INT32 a;
if (p->cmd.turning < -400)
{
a = (INT32)(mo->angle) - ANG1*90;
P_Thrust(pmo, mo->angle - ANGLE_90, 2*mapobjectscale);
p->rideroidrollangle -= ANG1*3;
if (p->rideroidrollangle < -ANG1*25)
p->rideroidrollangle = -ANG1*25;
dir = 1;
}
else if (p->cmd.turning > 400)
{
a = (INT32)(mo->angle) + ANG1*90;
P_Thrust(pmo, mo->angle + ANGLE_90, 2*mapobjectscale);
p->rideroidrollangle += ANG1*3;
if (p->rideroidrollangle > ANG1*25)
p->rideroidrollangle = ANG1*25;
dir = -1;
dir = -1;
}
if (dir != 0 && leveltime & 1 && p->rideroidspeed > RIDEROIDSPEED/2)
{
p->rideroidspeed -= 1;
}
if (dir != 0)
{
// save the added momentum
p->rdaddmomx = pmo->momx - basemomx;
p->rdaddmomy = pmo->momy - basemomy;
//CONS_Printf("AX1: %d, AY1: %d\n", p->rdaddmomx/mapobjectscale, p->rdaddmomy/mapobjectscale);
pmo->momx = basemomx;
pmo->momy = basemomy;
/*CONS_Printf("CURR: %d, %d\n", pmo->momx/mapobjectscale, pmo->momy/mapobjectscale);
CONS_Printf("BASE: %d, %d\n", basemomx/mapobjectscale, basemomy/mapobjectscale);
CONS_Printf("ADD: %d, %d\n", p->rdaddmomx/mapobjectscale, p->rdaddmomy/mapobjectscale);*/
// find out how much addmomx and addmomy we can actually get.
// we do this by misusing P_Thrust to calc our values then immediately cancelling it.
basemomx = pmo->momx;
basemomy = pmo->momy;
a = (INT32)(mo->angle) - dir*ANG1*90;
P_Thrust(pmo, (angle_t)a, RIDEROIDMAXADD*3*mapobjectscale);
xthreshold = pmo->momx - basemomx;
ythreshold = pmo->momy - basemomy;
//CONS_Printf("XT: %d (%d), YT: %d (%d)\n", xthreshold/mapobjectscale, abs(xthreshold/mapobjectscale), ythreshold/mapobjectscale, abs(ythreshold/mapobjectscale));
// clamp the momentums using the calculated thresholds.
// the fixedmul check checks if both numbers are of the same sign.
if (abs(p->rdaddmomx) > abs(xthreshold))
p->rdaddmomx = xthreshold;
if (abs(p->rdaddmomy) > abs(ythreshold))
p->rdaddmomy = ythreshold;
@ -423,39 +423,39 @@ void Obj_RideroidThink(mobj_t *mo)
p->rdaddmomy = (p->rdaddmomy*9)/10;
p->rideroidrollangle /= 2;
}
// and now, going up/down
if (p->cmd.throwdir > 0)
{
// if we were going the opposite direction, this helps us change our height very easily.
if (p->rdaddmomz < 0)
p->rdaddmomz /= 2;
p->rdaddmomz = min(RIDEROIDMAXADD*mapobjectscale/7, p->rdaddmomz + mapobjectscale/16);
if (p->rideroidspeed > RIDEROIDSPEED/2
&& abs(p->cmd.turning) > 400
&& leveltime & 1)
p->rideroidspeed -= 1;
}
else if (p->cmd.throwdir < 0)
{
// if we were going the opposite direction, this helps us change our height very easily.
if (p->rdaddmomz > 0)
p->rdaddmomz /= 2;
p->rdaddmomz = max(-RIDEROIDMAXADD*mapobjectscale/7, p->rdaddmomz - mapobjectscale/16);
if (p->rideroidspeed > RIDEROIDSPEED/2
&& abs(p->cmd.turning) > 400
&& leveltime & 1)
p->rideroidspeed -= 1;
p->rideroidspeed -= 1;
}
else
p->rdaddmomz = (p->rdaddmomz*6)/10;
}
// transposed lua code.
@ -470,25 +470,25 @@ void Obj_RideroidNodeSpawn(mobj_t *mo)
mobj_t *ptr = mo;
UINT8 i;
UINT8 j;
// make it bigger.
P_SetScale(mo, mo->scale*3);
// spawn the letter things.
for (i = 0; i < 2; i++)
{
angle_t ang = mo->angle + (i)*180;
fixed_t zpos = mo->z + 64*mapobjectscale + mapobjectscale*96*i;
ang *= ANG1; // this has to be done here or the warning prevents the compile, we don't care about overflowing here.
for (j = 0; j < 7; j++)
{
fixed_t xpos = mo->x + FixedMul(radius, FINECOSINE(ang>>ANGLETOFINESHIFT));
fixed_t ypos = mo->y + FixedMul(radius, FINESINE(ang>>ANGLETOFINESHIFT));
mobj_t *let = P_SpawnMobj(xpos, ypos, zpos, MT_THOK);
let->sprite = SPR_RDRL;
let->frame = j|FF_FULLBRIGHT|FF_PAPERSPRITE;
@ -496,15 +496,15 @@ void Obj_RideroidNodeSpawn(mobj_t *mo)
let->tics = -1;
let->angle = ang + ANG1*90;
let->scale = 2*mapobjectscale;
// set letter in previous thing's hnext, this will let us loop em easily in the looping thinker.
P_SetTarget(&ptr->hnext, let);
// set the ptr to the last letter spawned.
ptr = let;
ang += ANG1*8;
}
}
}
}
@ -514,57 +514,57 @@ void Obj_RideroidNodeThink(mobj_t *mo)
mobj_t *ptr = mo->hnext;
mobj_t *pmo;
UINT8 i;
mo->angle -= NODEROTSPEED; // continuously rotate.
while (ptr && !P_MobjWasRemoved(ptr))
{
// get the new position, move us here, and move on to the next object in line.
angle_t newang = ptr->angle - NODEROTSPEED;
fixed_t newxpos = mo->x + FixedMul(radius, FINECOSINE((newang - ANG1*90)>>ANGLETOFINESHIFT));
fixed_t newypos = mo->y + FixedMul(radius, FINESINE((newang - ANG1*90)>>ANGLETOFINESHIFT));
P_MoveOrigin(ptr, newxpos, newypos, ptr->z);
ptr->angle = newang;
ptr = ptr->hnext;
}
// check for players coming near us.
for (i = 0; i < MAXPLAYERS; i++)
{
if (!playeringame[i] || players[i].spectator || players[i].rideroid ||
players[i].rdnodepull || K_isPlayerInSpecialState(&players[i]) || P_PlayerInPain(&players[i]))
continue;
pmo = players[i].mo;
//CONS_Printf("rd: %d\n", players[i].rideroid);
if (R_PointToDist2(mo->x, mo->y, pmo->x, pmo->y) < NODERADIUS*mapobjectscale
&& pmo->z + pmo->height >= mo->z
&& pmo->z <= mo->z + 512*mapobjectscale)
{
mobj_t *rd;
plr_undoRespawn(&players[i]);
plr_resetRideroidVars(&players[i]);
players[i].rdnodepull = true;
players[i].rideroidangle = mo->spawnpoint->angle*ANG1; // reminder that mo->angle changes, so we use the spawnpoint angle.
players[i].rideroidspeed = RIDEROIDSPEED;
P_SetTarget(&pmo->tracer, mo);
// spawn the rideroid.
rd = P_SpawnMobj(mo->x, mo->y, mo->z, MT_RIDEROID);
rd->angle = players[i].rideroidangle;
P_SetTarget(&rd->target, pmo);
S_StartSound(rd, sfx_ridr1);
//CONS_Printf("rd pull\n");
}
}
}

18
src/objects/wpzothers.c
View file

@ -42,7 +42,7 @@ void Obj_WPZKuragenThink(mobj_t *mo)
{
//(void)mo;
boolean active = false;
// .....and i need to do this... because?
if (!mo->cusval)
{
@ -50,7 +50,7 @@ void Obj_WPZKuragenThink(mobj_t *mo)
mo->destscale = mapobjectscale*2;
mo->cusval = 1;
}
if (!(mo->spawnpoint->options & 1 || mo->spawnpoint->thing_args[0])) // extra flag skips player checks, making it a decoration.
{
UINT8 i;
@ -58,13 +58,13 @@ void Obj_WPZKuragenThink(mobj_t *mo)
{
player_t *p;
mobj_t *pmo;
if (!playeringame[i] || players[i].spectator)
continue;
p = &players[i];
pmo = p->mo;
if (R_PointToDist2(pmo->x, pmo->y, mo->x, mo->y) < mapobjectscale*6144)
{
active = true;
@ -72,11 +72,11 @@ void Obj_WPZKuragenThink(mobj_t *mo)
}
}
}
if (active && mo->extravalue1)
{
mo->extravalue1--;
if (!mo->extravalue1)
{
mobj_t *b = P_SpawnMobj(mo->x, mo->y, mo->z, MT_KURAGENBOMB);
@ -98,7 +98,7 @@ void Obj_WPZKuragenBombThink(mobj_t *mo)
P_SetScale(mo, mapobjectscale/2);
P_RadiusAttack(mo, mo, FRACUNIT*192, DMG_EXPLODE, false);
A_MineExplode(mo);
P_RemoveMobj(mo);
}
}
}

124
src/objects/wpzturbine.c
View file

@ -40,16 +40,16 @@ void Obj_WPZTurbineSpawn(mobj_t *mo)
{
mobj_t *ptr = mo;
UINT8 i;
// spawn the visuals regardless of flags, make em invisible.
// we'll care about updating em if it's worth doing later.
for (i = 0; i < 8; i++)
{
mobj_t *vis = P_SpawnMobj(mo->x, mo->y, mo->z, MT_THOK);
P_SetMobjState(vis, S_INVISIBLE);
vis->tics = 4; // if we don't use it just despawn it later.
P_SetTarget(&ptr->hnext, vis);
ptr = vis;
}
@ -60,22 +60,22 @@ static void Obj_WPZTurbineUpdate(mobj_t *mo)
{
angle_t ang = (angle_t)mo->extravalue1;
mapthing_t *mt = mo->spawnpoint;
if (!mt)
return;
// fans
if (!mt->thing_args[1])
{
UINT8 i;
mobj_t *ptr = mo;
for (i = 0; i < 8; i++)
{
fixed_t x = mo->x + FixedMul(mapobjectscale, TURBINE_RADIUS*FINECOSINE(ang>>ANGLETOFINESHIFT));
fixed_t y = mo->y + FixedMul(mapobjectscale, TURBINE_RADIUS*FINESINE(ang>>ANGLETOFINESHIFT));
fixed_t y = mo->y + FixedMul(mapobjectscale, TURBINE_RADIUS*FINESINE(ang>>ANGLETOFINESHIFT));
// get the mobj
if (ptr && !P_MobjWasRemoved(ptr) && ptr->hnext && !P_MobjWasRemoved(ptr->hnext))
{
@ -88,15 +88,15 @@ static void Obj_WPZTurbineUpdate(mobj_t *mo)
ptr->destscale = mapobjectscale*4;
ptr->angle = ang;
}
ang += (360/8)*ANG1;
}
}
// bubbles if we're underwater
// bubbles if we're underwater
if (mo->z < mo->watertop && leveltime%10 == 0)
{
INT32 dradius = TURBINE_SPIN;
INT32 bubbleradius;
angle_t bubbleang;
@ -105,14 +105,14 @@ static void Obj_WPZTurbineUpdate(mobj_t *mo)
if (mt->thing_args[7])
dradius = mt->thing_args[7];
bubbleradius = P_RandomRange(PR_FUZZ, dradius/4, (dradius*3)/2);
bubbleang = P_RandomRange(PR_FUZZ, 0, 359)*ANG1;
bx = mo->x + FixedMul(mapobjectscale, bubbleradius*FINECOSINE(bubbleang>>ANGLETOFINESHIFT));
by = mo->y + FixedMul(mapobjectscale, bubbleradius*FINECOSINE(bubbleang>>ANGLETOFINESHIFT));
bz = R_PointInSubsector(bx, by)->sector->floorheight;
bubble = P_SpawnMobj(bx, by, bz, MT_WATERPALACEBUBBLE);
bubble->fuse = TICRATE*10;
bubble->angle = bubbleang;
@ -135,44 +135,44 @@ void Obj_WPZTurbineThinker(mobj_t *mo)
SINT8 mult = (opt1) ? (-1) : (1);
mo->extravalue1 += rotspeed*mult;
// find players in range and take their phones.
for (i = 0; i < MAXPLAYERS; i++)
{
player_t *p;
mobj_t *pmo;
if (!playeringame[i] || players[i].spectator || K_isPlayerInSpecialState(&players[i]))
continue;
p = &players[i];
pmo = p->mo;
if (R_PointToDist2(pmo->x, pmo->y, mo->x, mo->y) < range
&& !p->turbine
&& !p->respawn.timer)
{
P_SetTarget(&pmo->tracer, mo);
p->turbine = turbinetime;
// to be fully honest i dont rememebr what i was on while writing this
// but it originally went by mo instead of pmo for angle??? how did it ever *work* ?
p->turbineangle = ANGLE_180 + R_PointToAngle2(0, 0, mo->momx, mo->momy);
if (!p->speed)
p->turbineangle = ANGLE_180 + mo->angle;
p->turbineangle += ANG1*45*mult;
p->turbineheight = baseheight;
p->turbinespd = false;
if (FixedDiv(p->speed, K_GetKartSpeed(p, false, false)) > FRACUNIT + FRACUNIT/3 // 133% speed
&& baseheight != sneakerheight)
{
p->turbineheight = sneakerheight;
p->turbinespd = true;
}
pmo->flags |= MF_NOCLIP;
}
}
@ -198,46 +198,46 @@ void Obj_playerWPZTurbine(player_t *p)
INT32 speed = ANG1*3;
boolean mode = false;
boolean distreached;
fixed_t tx, ty, tz;
fixed_t momz;
if (!t || P_MobjWasRemoved(t))
{
p->turbine = false;
P_SetTarget(&pmo->tracer, NULL);
return; // wtf happened
}
mt = t->spawnpoint;
opt1 = (mt->thing_args[0] != 0);
if (mt->thing_args[6])
dist = mt->thing_args[6]*FRACUNIT;
if (mt->thing_args[5])
speed = mt->thing_args[5]*ANG1/10;
if (mt->thing_args[9])
mode = true;
distreached = R_PointToDist2(t->x, t->y, pmo->x, pmo->y) <= dist+32*mapobjectscale;
if (mode && !distreached)
p->turbineangle = (INT32)R_PointToAngle2(t->x, t->y, pmo->x, pmo->y);
p->spinouttimer = TICRATE;
pmo->pitch = 0;
// determine target x/y/z
tx = t->x + (dist/FRACUNIT)*FINECOSINE((angle_t)(p->turbineangle)>>ANGLETOFINESHIFT);
ty = t->y + (dist/FRACUNIT)*FINESINE((angle_t)(p->turbineangle)>>ANGLETOFINESHIFT);
tz = p->turbineheight;
//CONS_Printf("%d %d\n", tx/FRACUNIT, ty/FRACUNIT);
if (mode)
{
if (distreached)
@ -255,13 +255,13 @@ void Obj_playerWPZTurbine(player_t *p)
pmo->momx = (tx - pmo->x)/24 * (p->turbinespd ? 2 : 1);
pmo->momy = (ty - pmo->y)/24 * (p->turbinespd ? 2 : 1);
}
momz = (tz - pmo->z)/128 * (p->turbinespd+1);
if (mt->thing_args[8])
{
momz = (mt->thing_args[8]*FRACUNIT) * ((tz < pmo->z) ? -1 : 1);
if (momz < 0)
{
if (pmo->z + momz < tz)
@ -276,9 +276,9 @@ void Obj_playerWPZTurbine(player_t *p)
momz = tz - pmo->z;
}
}
}
pmo->momz = momz;
p->turbineangle += (speed * (p->turbinespd ? 2 : 1)) * (opt1 ? -1 : 1);
P_SetPlayerAngle(p, (angle_t)p->turbineangle + ANGLE_90*(opt1 ? -1 : 1));
@ -288,7 +288,7 @@ void Obj_playerWPZTurbine(player_t *p)
fixed_t rx = pmo->x + P_RandomRange(PR_FUZZ, -64, 64)*mapobjectscale;
fixed_t ry = pmo->y + P_RandomRange(PR_FUZZ, -64, 64)*mapobjectscale;
fixed_t rz = pmo->z + P_RandomRange(PR_FUZZ, -64, 64)*mapobjectscale;
mobj_t *bubl = P_SpawnMobj(rx, ry, rz, MT_THOK);
P_SetScale(bubl, pmo->scale*2);
bubl->scalespeed = pmo->scale/12;
@ -297,22 +297,22 @@ void Obj_playerWPZTurbine(player_t *p)
bubl->frame = 0;
bubl->tics = TICRATE;
}
if (pmo->momz < mapobjectscale*6)
{
INT32 myang = angtoint(pmo->angle);
angle_t exitangle = t->angle;
INT32 targetangle = angtoint(exitangle);
INT32 launchangle = myang-targetangle;
// WHAT WAS I SMOKING
if ( (opt1 && launchangle > -60 && launchangle < -45)
|| (!opt1 && launchangle > 45 && launchangle < 60))
{
P_SetPlayerAngle(p, targetangle*ANG1);
if (mode)
P_InstaThrust(pmo, targetangle*ANG1, 128*mapobjectscale);
else
@ -320,25 +320,25 @@ void Obj_playerWPZTurbine(player_t *p)
fixed_t spd = FixedHypot(pmo->momx, pmo->momy);
P_InstaThrust(pmo, targetangle*ANG1, spd);
}
P_SetTarget(&pmo->tracer, NULL);
p->turbineheight = 0;
p->turbineangle = 0;
if (p->turbinespd)
pmo->momz = mapobjectscale*5 * (pmo->eflags & MFE_UNDERWATER ? 2 : 1);
if (pmo->eflags & MFE_UNDERWATER)
{
pmo->momz = mapobjectscale*5;
pmo->momx = (pmo->momx*17)/10;
pmo->momy = (pmo->momy*17)/10;
}
p->spinouttimer = 0;
pmo->flags &= ~MF_NOCLIP;
}
}
}
}
}
// bubbles that circle the turbine
@ -348,7 +348,7 @@ void Obj_WPZBubbleThink(mobj_t *mo)
mobj_t *t = mo->tracer;
fixed_t tx, ty;
mapthing_t *mt;
// where
// where did it go
if (!t || P_MobjWasRemoved(t))
@ -356,18 +356,18 @@ void Obj_WPZBubbleThink(mobj_t *mo)
P_RemoveMobj(mo);
return;
}
mt = t->spawnpoint;
if (!mt)
return;
mo->momz = mapobjectscale*16;
tx = t->x + FixedMul(mapobjectscale, mo->movecount*FINECOSINE(ang>>ANGLETOFINESHIFT));
ty = t->y + FixedMul(mapobjectscale, mo->movecount*FINESINE(ang>>ANGLETOFINESHIFT));
mo->momx = (tx - mo->x)/24;
mo->momy = (ty - mo->y)/24;
if (leveltime & 1)
{
fixed_t rx = mo->x + P_RandomRange(PR_FUZZ, -64, 64)*mapobjectscale;
@ -380,9 +380,9 @@ void Obj_WPZBubbleThink(mobj_t *mo)
bubl->frame = 0;
bubl->tics = TICRATE;
}
mo->angle += 3*ANG1 * (mt->thing_args[0] ? -1 : 1);
if (mo->z > mo->watertop || mo->z > mo->ceilingz)
P_RemoveMobj(mo);
}
}