Newly added object files: Fix trailing whitespace + EOF newline

src/objects/bungee.c

@@ -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;
 	}
-}
+}

src/objects/dlzothers.c

@@ -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);
-}
+}

src/objects/dlzrocket.c

@@ -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);
-	
+}
-}

src/objects/dlzseasaw.c

@@ -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);
-}
+}

src/objects/eggball.c

@@ -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);
-}
+}

src/objects/rideroid.c

@@ -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");
-					
+
 		}
 	}
 }

src/objects/wpzothers.c

@@ -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);
 	}
-}
+}

src/objects/wpzturbine.c

@@ -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);
-}
+}