diff --git a/src/k_battle.c b/src/k_battle.c
index b594e0649..79a37898a 100644
--- a/src/k_battle.c
+++ b/src/k_battle.c
@@ -318,11 +318,14 @@ mobj_t *K_SpawnChaosEmerald(fixed_t x, fixed_t y, fixed_t z, angle_t angle, SINT
 mobj_t *K_SpawnSphereBox(fixed_t x, fixed_t y, fixed_t z, angle_t angle, SINT8 flip, UINT8 amount)
 {
 	mobj_t *drop = P_SpawnMobj(x, y, z, MT_SPHEREBOX);
+	fixed_t rand_move;
+	angle_t rand_angle;
 
 	drop->angle = angle;
-	P_Thrust(drop,
-		FixedAngle(P_RandomFixed(PR_ITEM_SPAWNER) * 180) + angle,
-		P_RandomRange(PR_ITEM_SPAWNER, 4, 12) * mapobjectscale);
+	// note: determinate random argument eval order
+	rand_move = P_RandomRange(PR_ITEM_SPAWNER, 4, 12) * mapobjectscale;
+	rand_angle = FixedAngle(P_RandomFixed(PR_ITEM_SPAWNER) * 180) + angle;
+	P_Thrust(drop, rand_angle, rand_move);
 
 	drop->momz = flip * 12 * mapobjectscale;
 	if (drop->eflags & MFE_UNDERWATER)
diff --git a/src/k_collide.cpp b/src/k_collide.cpp
index d9e74932e..057258028 100644
--- a/src/k_collide.cpp
+++ b/src/k_collide.cpp
@@ -1424,11 +1424,19 @@ boolean K_PuntCollide(mobj_t *t1, mobj_t *t2)
 		// dust effects
 		for (i = 0; i < 10; i++)
 		{
+			fixed_t rand_x;
+			fixed_t rand_y;
+			fixed_t rand_z;
+
+			// note: determinate random argument eval order
+			rand_z = P_RandomRange(PR_ITEM_DEBRIS, 0, 4*spacing) * FRACUNIT;
+			rand_y = P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing) * FRACUNIT;
+			rand_x = P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing) * FRACUNIT;
 			mobj_t *puff = P_SpawnMobjFromMobj(
 				t1,
-				P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing) * FRACUNIT,
-				P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing) * FRACUNIT,
-				P_RandomRange(PR_ITEM_DEBRIS, 0, 4*spacing) * FRACUNIT,
+				rand_x,
+				rand_y,
+				rand_z,
 				MT_SPINDASHDUST
 			);
 
diff --git a/src/k_kart.c b/src/k_kart.c
index 0f76d0a42..7816aaa21 100644
--- a/src/k_kart.c
+++ b/src/k_kart.c
@@ -1449,10 +1449,16 @@ static void K_DrawDraftCombiring(player_t *player, mobj_t *victim, fixed_t curdi
 	{
 		if (offset == 0)
 		{
-			mobj_t *band = P_SpawnMobj(curx + (P_RandomRange(PR_DECORATION, -12, 12)*mapobjectscale),
-				cury + (P_RandomRange(PR_DECORATION, -12, 12)*mapobjectscale),
-				curz + (P_RandomRange(PR_DECORATION, 24, 48)*mapobjectscale),
-				MT_SIGNSPARKLE);
+			mobj_t *band;
+			fixed_t rand_x;
+			fixed_t rand_y;
+			fixed_t rand_z;
+
+			// note: determinate random argument eval order
+			rand_z = P_RandomRange(PR_DECORATION, 24, 48)*mapobjectscale;
+			rand_y = P_RandomRange(PR_DECORATION, -12, 12)*mapobjectscale;
+			rand_x = P_RandomRange(PR_DECORATION, -12, 12)*mapobjectscale;
+			band = P_SpawnMobj(curx + rand_x, cury + rand_y, curz + rand_z, MT_SIGNSPARKLE);
 
 			if (maxdist == 0)
 			{
@@ -2067,9 +2073,17 @@ void K_SpawnDriftBoostClipSpark(mobj_t *clip)
 
 static void K_SpawnGenericSpeedLines(player_t *player, boolean top)
 {
-	mobj_t *fast = P_SpawnMobj(player->mo->x + (P_RandomRange(PR_DECORATION,-36,36) * player->mo->scale),
-		player->mo->y + (P_RandomRange(PR_DECORATION,-36,36) * player->mo->scale),
-		player->mo->z + (player->mo->height/2) + (P_RandomRange(PR_DECORATION,-20,20) * player->mo->scale),
+	fixed_t rand_x;
+	fixed_t rand_y;
+	fixed_t rand_z;
+
+	// note: determinate random argument eval order
+	rand_z = P_RandomRange(PR_DECORATION,-20,20);
+	rand_y = P_RandomRange(PR_DECORATION,-36,36);
+	rand_x = P_RandomRange(PR_DECORATION,-36,36);
+	mobj_t *fast = P_SpawnMobj(player->mo->x + (rand_x * player->mo->scale),
+		player->mo->y + (rand_y * player->mo->scale),
+		player->mo->z + (player->mo->height/2) + (rand_z * player->mo->scale),
 		MT_FASTLINE);
 
 	P_SetTarget(&fast->target, player->mo);
@@ -2170,10 +2184,18 @@ void K_SpawnGardenTopSpeedLines(player_t *player)
 
 void K_SpawnInvincibilitySpeedLines(mobj_t *mo)
 {
+	fixed_t rand_x;
+	fixed_t rand_y;
+	fixed_t rand_z;
+
+	// note: determinate random argument eval order
+	rand_z = P_RandomRange(PR_DECORATION, 0, 64);
+	rand_y = P_RandomRange(PR_DECORATION, -48, 48);
+	rand_x = P_RandomRange(PR_DECORATION, -48, 48);
 	mobj_t *fast = P_SpawnMobjFromMobj(mo,
-		P_RandomRange(PR_DECORATION, -48, 48) * FRACUNIT,
-		P_RandomRange(PR_DECORATION, -48, 48) * FRACUNIT,
-		P_RandomRange(PR_DECORATION, 0, 64) * FRACUNIT,
+		rand_x * FRACUNIT,
+		rand_y * FRACUNIT,
+		rand_z * FRACUNIT,
 		MT_FASTLINE);
 	P_SetMobjState(fast, S_KARTINVLINES1);
 
@@ -2205,6 +2227,9 @@ static void K_SpawnGrowShrinkParticles(mobj_t *mo, INT32 timer)
 	mobj_t *particle = NULL;
 	fixed_t particleScale = FRACUNIT;
 	fixed_t particleSpeed = 0;
+	fixed_t rand_x;
+	fixed_t rand_y;
+	fixed_t rand_z;
 
 	spawnFreq = abs(timer);
 
@@ -2231,11 +2256,15 @@ static void K_SpawnGrowShrinkParticles(mobj_t *mo, INT32 timer)
 		return;
 	}
 
+	// note: determinate random argument eval order
+	rand_z = P_RandomRange(PR_DECORATION, 0, 24);
+	rand_y = P_RandomRange(PR_DECORATION, -32, 32);
+	rand_x = P_RandomRange(PR_DECORATION, -32, 32);
 	particle = P_SpawnMobjFromMobj(
 		mo,
-		P_RandomRange(PR_DECORATION, -32, 32) * FRACUNIT,
-		P_RandomRange(PR_DECORATION, -32, 32) * FRACUNIT,
-		(P_RandomRange(PR_DECORATION, 0, 24) + (shrink ? 48 : 0)) * FRACUNIT,
+		rand_x * FRACUNIT,
+		rand_y * FRACUNIT,
+		(rand_z + (shrink ? 48 : 0)) * FRACUNIT,
 		MT_GROW_PARTICLE
 	);
 
@@ -5989,6 +6018,10 @@ void K_SpawnMineExplosion(mobj_t *source, skincolornum_t color, tic_t delay)
 
 	for (i = 0; i < 32; i++)
 	{
+		fixed_t rand_x;
+		fixed_t rand_y;
+		fixed_t rand_z;
+
 		dust = P_SpawnMobj(source->x, source->y, source->z, MT_SMOKE);
 		P_SetMobjState(dust, S_OPAQUESMOKE1);
 		dust->angle = (ANGLE_180/16) * i;
@@ -5999,9 +6032,13 @@ void K_SpawnMineExplosion(mobj_t *source, skincolornum_t color, tic_t delay)
 		dust->hitlag += delay;
 		dust->renderflags |= RF_DONTDRAW;
 
-		truc = P_SpawnMobj(source->x + P_RandomRange(PR_EXPLOSION, -radius, radius)*FRACUNIT,
-			source->y + P_RandomRange(PR_EXPLOSION, -radius, radius)*FRACUNIT,
-			source->z + P_RandomRange(PR_EXPLOSION, 0, height)*FRACUNIT, MT_BOOMEXPLODE);
+		// note: determinate random argument eval order
+		rand_z = P_RandomRange(PR_EXPLOSION, 0, height);
+		rand_y = P_RandomRange(PR_EXPLOSION, -radius, radius);
+		rand_x = P_RandomRange(PR_EXPLOSION, -radius, radius);
+		truc = P_SpawnMobj(source->x + rand_x*FRACUNIT,
+			source->y + rand_y*FRACUNIT,
+			source->z + rand_z*FRACUNIT, MT_BOOMEXPLODE);
 		K_MatchGenericExtraFlags(truc, source);
 		P_SetScale(truc, source->scale);
 		truc->destscale = source->scale*6;
@@ -6020,9 +6057,17 @@ void K_SpawnMineExplosion(mobj_t *source, skincolornum_t color, tic_t delay)
 
 	for (i = 0; i < 16; i++)
 	{
-		dust = P_SpawnMobj(source->x + P_RandomRange(PR_EXPLOSION, -radius, radius)*FRACUNIT,
-			source->y + P_RandomRange(PR_EXPLOSION, -radius, radius)*FRACUNIT,
-			source->z + P_RandomRange(PR_EXPLOSION, 0, height)*FRACUNIT, MT_SMOKE);
+		fixed_t rand_x;
+		fixed_t rand_y;
+		fixed_t rand_z;
+
+		// note: determinate random argument eval order
+		rand_z = P_RandomRange(PR_EXPLOSION, 0, height);
+		rand_y = P_RandomRange(PR_EXPLOSION, -radius, radius);
+		rand_x = P_RandomRange(PR_EXPLOSION, -radius, radius);
+		dust = P_SpawnMobj(source->x + rand_x*FRACUNIT,
+			source->y + rand_y*FRACUNIT,
+			source->z + rand_z*FRACUNIT, MT_SMOKE);
 		P_SetMobjState(dust, S_OPAQUESMOKE1);
 		P_SetScale(dust, source->scale);
 		dust->destscale = source->scale*10;
@@ -6032,9 +6077,13 @@ void K_SpawnMineExplosion(mobj_t *source, skincolornum_t color, tic_t delay)
 		dust->hitlag += delay;
 		dust->renderflags |= RF_DONTDRAW;
 
-		truc = P_SpawnMobj(source->x + P_RandomRange(PR_EXPLOSION, -radius, radius)*FRACUNIT,
-			source->y + P_RandomRange(PR_EXPLOSION, -radius, radius)*FRACUNIT,
-			source->z + P_RandomRange(PR_EXPLOSION, 0, height)*FRACUNIT, MT_BOOMPARTICLE);
+		// note: determinate random argument eval order
+		rand_z = P_RandomRange(PR_EXPLOSION, 0, height);
+		rand_y = P_RandomRange(PR_EXPLOSION, -radius, radius);
+		rand_x = P_RandomRange(PR_EXPLOSION, -radius, radius);
+		truc = P_SpawnMobj(source->x + rand_x*FRACUNIT,
+			source->y + rand_y*FRACUNIT,
+			source->z + rand_z*FRACUNIT, MT_BOOMPARTICLE);
 		K_MatchGenericExtraFlags(truc, source);
 		P_SetScale(truc, source->scale);
 		truc->destscale = source->scale*5;
@@ -6854,6 +6903,8 @@ void K_SpawnWipeoutTrail(mobj_t *mo)
 {
 	mobj_t *dust;
 	angle_t aoff;
+	fixed_t rand_x;
+	fixed_t rand_y;
 
 	I_Assert(mo != NULL);
 	I_Assert(!P_MobjWasRemoved(mo));
@@ -6868,8 +6919,11 @@ void K_SpawnWipeoutTrail(mobj_t *mo)
 	else
 		aoff += ANGLE_45;
 
-	dust = P_SpawnMobj(mo->x + FixedMul(24*mo->scale, FINECOSINE(aoff>>ANGLETOFINESHIFT)) + (P_RandomRange(PR_DECORATION,-8,8) << FRACBITS),
-		mo->y + FixedMul(24*mo->scale, FINESINE(aoff>>ANGLETOFINESHIFT)) + (P_RandomRange(PR_DECORATION,-8,8) << FRACBITS),
+	// note: determinate random argument eval order
+	rand_y = P_RandomRange(PR_DECORATION,-8,8);
+	rand_x = P_RandomRange(PR_DECORATION,-8,8);
+	dust = P_SpawnMobj(mo->x + FixedMul(24*mo->scale, FINECOSINE(aoff>>ANGLETOFINESHIFT)) + (rand_x << FRACBITS),
+		mo->y + FixedMul(24*mo->scale, FINESINE(aoff>>ANGLETOFINESHIFT)) + (rand_y << FRACBITS),
 		mo->z, MT_WIPEOUTTRAIL);
 
 	P_SetTarget(&dust->target, mo);
@@ -7589,6 +7643,8 @@ static void K_FlameDashLeftoverSmoke(mobj_t *src)
 
 	for (i = 0; i < 2; i++)
 	{
+		angle_t rand_angle;
+		fixed_t rand_move;
 		mobj_t *smoke = P_SpawnMobj(src->x, src->y, src->z+(8<<FRACBITS), MT_BOOSTSMOKE);
 
 		P_SetScale(smoke, src->scale);
@@ -7599,7 +7655,10 @@ static void K_FlameDashLeftoverSmoke(mobj_t *src)
 		smoke->momy = 3*src->momy/4;
 		smoke->momz = 3*P_GetMobjZMovement(src)/4;
 
-		P_Thrust(smoke, src->angle + FixedAngle(P_RandomRange(PR_DECORATION, 135, 225)<<FRACBITS), P_RandomRange(PR_DECORATION, 0, 8) * src->scale);
+		// note: determinate random argument eval order
+		rand_move = P_RandomRange(PR_DECORATION, 0, 8);
+		rand_angle = P_RandomRange(PR_DECORATION, 135, 225);
+		P_Thrust(smoke, src->angle + FixedAngle(rand_angle<<FRACBITS), rand_move * src->scale);
 		smoke->momz += P_RandomRange(PR_DECORATION, 0, 4) * src->scale;
 	}
 }
@@ -9810,7 +9869,7 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
 
 				debtflag->color = player->skincolor;
 				debtflag->fuse = 2;
-				
+
 				// Do the ring debt shake, come on now - outta the sprite frames and into the codebase
 				if (cv_reducevfx.value == 0)
 				{
@@ -10521,9 +10580,17 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
 		UINT32 baildropmodulo = baildropinversefreq *5/3 /10;
 		if ((leveltime % (1+baildropmodulo)) == 0)
 		{
-			mobj_t *sparkle = P_SpawnMobj(pmo->x + (P_RandomRange(PR_DECORATION, -40,40) * pmo->scale),
-				pmo->y + (P_RandomRange(PR_DECORATION, -40,40) * pmo->scale),
-				pmo->z + (pmo->height/2) + (P_RandomRange(PR_DECORATION, -40,40) * pmo->scale),
+			fixed_t rand_x;
+			fixed_t rand_y;
+			fixed_t rand_z;
+
+			// note: determinate random argument eval order
+			rand_z = P_RandomRange(PR_DECORATION, -40,40);
+			rand_y = P_RandomRange(PR_DECORATION, -40,40);
+			rand_x = P_RandomRange(PR_DECORATION, -40,40);
+			mobj_t *sparkle = P_SpawnMobj(pmo->x + (rand_x * pmo->scale),
+				pmo->y + (rand_y * pmo->scale),
+				pmo->z + (pmo->height/2) + (rand_z * pmo->scale),
 				MT_BAILSPARKLE);
 
 			sparkle->scale = pmo->scale;
@@ -13677,10 +13744,18 @@ static void K_KartSpindashDust(mobj_t *parent)
 
 static void K_KartSpindashWind(mobj_t *parent)
 {
+	fixed_t rand_x;
+	fixed_t rand_y;
+	fixed_t rand_z;
+
+	// note: determinate random argument eval order
+	rand_z = P_RandomRange(PR_DECORATION,-20,20);
+	rand_y = P_RandomRange(PR_DECORATION,-36,36);
+	rand_x = P_RandomRange(PR_DECORATION,-36,36);
 	mobj_t *wind = P_SpawnMobjFromMobj(parent,
-		P_RandomRange(PR_DECORATION,-36,36) * FRACUNIT,
-		P_RandomRange(PR_DECORATION,-36,36) * FRACUNIT,
-		FixedDiv(parent->height / 2, parent->scale) + (P_RandomRange(PR_DECORATION,-20,20) * FRACUNIT),
+		rand_x * FRACUNIT,
+		rand_y * FRACUNIT,
+		FixedDiv(parent->height / 2, parent->scale) + (rand_z * FRACUNIT),
 		MT_SPINDASHWIND
 	);
 
diff --git a/src/objects/adventure-air-booster.c b/src/objects/adventure-air-booster.c
index d971b0d82..9d455b0c8 100644
--- a/src/objects/adventure-air-booster.c
+++ b/src/objects/adventure-air-booster.c
@@ -179,11 +179,19 @@ void Obj_AdventureAirBoosterHitboxTouch(mobj_t *hitbox, player_t *player)
 	// before we change the colour, spawn a buncha sparkles
 	for (i = 0; i < 12; i++)
 	{
+		fixed_t rand_x;
+		fixed_t rand_y;
+		fixed_t rand_z;
+
+		// note: determinate random argument eval order
+		rand_z = P_RandomFixed(PR_DECORATION);
+		rand_y = P_RandomFixed(PR_DECORATION);
+		rand_x = P_RandomFixed(PR_DECORATION);
 		part = P_SpawnMobjFromMobj(
 			hitbox,
-			FixedMul(AAB_RADIUS << 1, P_RandomFixed(PR_DECORATION)) - AAB_RADIUS,
-			FixedMul(AAB_RADIUS << 1, P_RandomFixed(PR_DECORATION)) - AAB_RADIUS,
-			FixedMul(AAB_RADIUS << 1, P_RandomFixed(PR_DECORATION)) - AAB_RADIUS,
+			FixedMul(AAB_RADIUS << 1, rand_x) - AAB_RADIUS,
+			FixedMul(AAB_RADIUS << 1, rand_y) - AAB_RADIUS,
+			FixedMul(AAB_RADIUS << 1, rand_z) - AAB_RADIUS,
 			MT_DVDPARTICLE
 		);
 		part->color = booster->color;
diff --git a/src/objects/charge.c b/src/objects/charge.c
index 597395ca0..bf95f017e 100644
--- a/src/objects/charge.c
+++ b/src/objects/charge.c
@@ -78,10 +78,18 @@ void Obj_ChargeAuraThink (mobj_t *aura)
         {
             if (player->driftcharge)
             {
-                mobj_t *spark = P_SpawnMobjFromMobj(aura, 
-                    FRACUNIT*P_RandomRange(PR_DECORATION, -1*CHARGEAURA_SPARKRADIUS, CHARGEAURA_SPARKRADIUS),
-                    FRACUNIT*P_RandomRange(PR_DECORATION, -1*CHARGEAURA_SPARKRADIUS, CHARGEAURA_SPARKRADIUS),
-                    FRACUNIT*P_RandomRange(PR_DECORATION, -1*CHARGEAURA_SPARKRADIUS, CHARGEAURA_SPARKRADIUS),
+				fixed_t rand_x;
+				fixed_t rand_y;
+				fixed_t rand_z;
+
+				// note: determinate random argument eval order
+				rand_z = P_RandomRange(PR_DECORATION, -1*CHARGEAURA_SPARKRADIUS, CHARGEAURA_SPARKRADIUS);
+				rand_y = P_RandomRange(PR_DECORATION, -1*CHARGEAURA_SPARKRADIUS, CHARGEAURA_SPARKRADIUS);
+				rand_x = P_RandomRange(PR_DECORATION, -1*CHARGEAURA_SPARKRADIUS, CHARGEAURA_SPARKRADIUS);
+                mobj_t *spark = P_SpawnMobjFromMobj(aura,
+                    FRACUNIT*rand_x,
+                    FRACUNIT*rand_y,
+                    FRACUNIT*rand_z,
                     MT_CHARGESPARK);
                 spark->frame = P_RandomRange(PR_DECORATION, 1, 5);
                 spark->renderflags |= RF_FULLBRIGHT|RF_ADD;
@@ -160,4 +168,4 @@ void Obj_ChargeExtraThink (mobj_t *extra)
     if (extra->tics < 18)
         extra->renderflags |= (9 - extra->tics/2)<<RF_TRANSSHIFT;
     extra->rollangle += ANG30;
-}
\ No newline at end of file
+}
diff --git a/src/objects/checkpoint.cpp b/src/objects/checkpoint.cpp
index 195e1436a..c0a9dfe83 100644
--- a/src/objects/checkpoint.cpp
+++ b/src/objects/checkpoint.cpp
@@ -349,12 +349,16 @@ private:
 	{
 		auto rng = [=](int units) { return P_RandomRange(PR_DECORATION, -(units) * scale, +(units) * scale); };
 
+		// note: determinate random argument eval order
+		fixed_t rand_z = rng(24);
+		fixed_t rand_y = rng(12);
+		fixed_t rand_x = rng(12);
 		// From K_DrawDraftCombiring
 		mobj_t* p = P_SpawnMobjFromMobjUnscaled(
 			this,
-			(pos.x - x) + rng(12),
-			(pos.y - y) + rng(12),
-			(pos.z - z) + rng(24),
+			(pos.x - x) + rand_x,
+			(pos.y - y) + rand_y,
+			(pos.z - z) + rand_z,
 			MT_SIGNSPARKLE
 		);
 
diff --git a/src/objects/cloud.c b/src/objects/cloud.c
index b0e0c71f0..41f4539d0 100644
--- a/src/objects/cloud.c
+++ b/src/objects/cloud.c
@@ -138,7 +138,15 @@ void Obj_PlayerCloudThink(player_t *player)
 		player->cloudlaunch--;
 
 		if (leveltime % 6 == 0)
-			P_SpawnMobj(mo->x + P_RandomRange(PR_DECORATION, -8, 8)*mapobjectscale, mo->y + P_RandomRange(PR_DECORATION, -8, 8)*mapobjectscale, mo->z, MT_DRIFTDUST);
+		{
+			fixed_t rand_x;
+			fixed_t rand_y;
+
+			// note: determinate random argument eval order
+			rand_y = P_RandomRange(PR_DECORATION, -8, 8);
+			rand_x = P_RandomRange(PR_DECORATION, -8, 8);
+			P_SpawnMobj(mo->x + rand_x*mapobjectscale, mo->y + rand_y*mapobjectscale, mo->z, MT_DRIFTDUST);
+		}
 	}
 
 	if (player->cloud)
@@ -171,7 +179,15 @@ void Obj_PlayerBulbThink(player_t *player)
 		player->tuliplaunch--;
 
 		if (leveltime % 2 == 0)
-			P_SpawnMobj(mo->x + P_RandomRange(PR_DECORATION, -8, 8)*mapobjectscale, mo->y + P_RandomRange(PR_DECORATION, -8, 8)*mapobjectscale, mo->z, MT_DRIFTDUST);
+		{
+			fixed_t rand_x;
+			fixed_t rand_y;
+
+			// note: determinate random argument eval order
+			rand_y = P_RandomRange(PR_DECORATION, -8, 8);
+			rand_x = P_RandomRange(PR_DECORATION, -8, 8);
+			P_SpawnMobj(mo->x + rand_x*mapobjectscale, mo->y + rand_y*mapobjectscale, mo->z, MT_DRIFTDUST);
+		}
 	}
 
 	if (player->tulipbuf)
@@ -202,7 +218,7 @@ void Obj_PlayerBulbThink(player_t *player)
 		mo->player->nocontrol = 0;
 		P_InstaThrust(mo, mo->tracer->extravalue2, mo->tracer->extravalue1);
 		mo->momz = FixedMul(mapobjectscale, BULB_ZTHRUST)*P_MobjFlip(mo->tracer);
-		
+
 		mo->flags |= MF_SHOOTABLE;
 		player->tuliplaunch = TICRATE;
 		player->tulipbuf = 8;
@@ -224,7 +240,14 @@ void Obj_CloudTouched(mobj_t *special, mobj_t *toucher)
 
 	for (UINT8 i = 1; i < 6; i++)
 	{
-		mobj_t *spawn = P_SpawnMobj(toucher->x + P_RandomRange(PR_DECORATION, -32, 32)*mapobjectscale, toucher->y + P_RandomRange(PR_DECORATION, -32, 32)*mapobjectscale, toucher->z, MT_DRIFTDUST);
+		fixed_t rand_x;
+		fixed_t rand_y;
+		fixed_t rand_z;
+
+		// note: determinate argument eval order
+		rand_y = P_RandomRange(PR_DECORATION, -32, 32);
+		rand_x = P_RandomRange(PR_DECORATION, -32, 32);
+		mobj_t *spawn = P_SpawnMobj(toucher->x + rand_x*mapobjectscale, toucher->y + rand_y*mapobjectscale, toucher->z, MT_DRIFTDUST);
 		spawn->angle = R_PointToAngle2(toucher->x, toucher->y, spawn->x, spawn->y);
 		P_InstaThrust(spawn, spawn->angle, P_RandomRange(PR_DECORATION, 1, 8)*mapobjectscale);
 		P_SetObjectMomZ(spawn, P_RandomRange(PR_DECORATION, 4, 10)<<FRACBITS, false);
@@ -249,7 +272,7 @@ void Obj_BulbTouched(mobj_t *special, mobj_t *toucher)
 	if (toucher->player->tulip || toucher->player->tulipbuf)
 		return;
 
-	if (special && special->target) 
+	if (special && special->target)
 		return; // player already using it
 
 	if (toucher->player->respawn.timer)
diff --git a/src/objects/crate.cpp b/src/objects/crate.cpp
index 224880d14..a868f168c 100644
--- a/src/objects/crate.cpp
+++ b/src/objects/crate.cpp
@@ -250,7 +250,14 @@ private:
 		}
 
 		auto rng = [&](int x, int y) { return P_RandomRange(PR_DECORATION, x, y) * scale(); };
-		auto rng_xyz = [&](int x) { return std::tuple(rng(-x, x), rng(-x, x), rng(0, x)); };
+		auto rng_xyz = [&](int x)
+		{
+			// note: determinate random argument eval order
+			auto rand_z = rng(0, x);
+			auto rand_y = rng(-x, x);
+			auto rand_x = rng(-x, x);
+			return std::tuple(rand_x, rand_y, rand_z);
+		};
 
 		auto spawn = [&](bool playsound)
 		{
diff --git a/src/objects/destroyed-kart.cpp b/src/objects/destroyed-kart.cpp
index 069fe61c2..14643c5c9 100644
--- a/src/objects/destroyed-kart.cpp
+++ b/src/objects/destroyed-kart.cpp
@@ -215,9 +215,12 @@ struct Particle : Mobj
 
 		if (!is_shrapnel() && fuse > 7 && (bounces() & 1)) // 7 = 0.2/(1/35)
 		{
+			// note: determinate random argument eval order
+			int32_t rand_volume = P_RandomRange(PR_ITEM_DEBRIS, 20, 40);
+			int32_t rand_sound = P_RandomRange(PR_ITEM_DEBRIS, sfx_die01, sfx_die03);
 			voice(
-				static_cast<sfxenum_t>(P_RandomRange(PR_ITEM_DEBRIS, sfx_die01, sfx_die03)),
-				P_RandomRange(PR_ITEM_DEBRIS, 20, 40) * 255 / 100
+				static_cast<sfxenum_t>(rand_sound),
+				rand_volume * 255 / 100
 			);
 		}
 
@@ -480,11 +483,19 @@ private:
 		fixed_t spd = 8 * mapobjectscale;
 		for (UINT8 i = 0; i < count; ++i)
 		{
+			fixed_t rand_x;
+			fixed_t rand_y;
+			fixed_t rand_z;
+
+			// note: determinate random argument eval order
+			rand_z = P_RandomRange(PR_EXPLOSION, -48, 48);
+			rand_y = P_RandomRange(PR_EXPLOSION, -48, 48);
+			rand_x = P_RandomRange(PR_EXPLOSION, -48, 48);
 			mobj_t *x = P_SpawnMobjFromMobjUnscaled(
 				target,
-				P_RandomRange(PR_EXPLOSION, -48, 48) * target->scale,
-				P_RandomRange(PR_EXPLOSION, -48, 48) * target->scale,
-				P_RandomRange(PR_EXPLOSION, -48, 48) * target->scale,
+				rand_x * target->scale,
+				rand_y * target->scale,
+				rand_z * target->scale,
 				MT_THOK
 			);
 			x->hitlag = 0;
diff --git a/src/objects/emerald.c b/src/objects/emerald.c
index 2006a1406..9ccc07fba 100644
--- a/src/objects/emerald.c
+++ b/src/objects/emerald.c
@@ -40,11 +40,20 @@ void Obj_SpawnEmeraldSparks(mobj_t *mobj)
 		return;
 	}
 
+	fixed_t rand_x;
+	fixed_t rand_y;
+	fixed_t rand_z;
+
+	// note: determinate random argument eval order
+	rand_z = P_RandomRange(PR_SPARKLE, 0, 64);
+	rand_y = P_RandomRange(PR_SPARKLE, -48, 48);
+	rand_x = P_RandomRange(PR_SPARKLE, -48, 48);
+
 	mobj_t *sparkle = P_SpawnMobjFromMobj(
 		mobj,
-		P_RandomRange(PR_SPARKLE, -48, 48) * FRACUNIT,
-		P_RandomRange(PR_SPARKLE, -48, 48) * FRACUNIT,
-		P_RandomRange(PR_SPARKLE, 0, 64) * FRACUNIT,
+		rand_x * FRACUNIT,
+		rand_y * FRACUNIT,
+		rand_z * FRACUNIT,
 		MT_EMERALDSPARK
 	);
 
diff --git a/src/objects/item-debris.c b/src/objects/item-debris.c
index 201c9eee7..eec2e8499 100644
--- a/src/objects/item-debris.c
+++ b/src/objects/item-debris.c
@@ -110,11 +110,19 @@ spawn_cloud
 	// dust effects
 	for (i = 0; i < 10; i++)
 	{
+		fixed_t rand_x;
+		fixed_t rand_y;
+		fixed_t rand_z;
+
+		// note: determinate random argument eval order
+		rand_z = P_RandomRange(PR_UNDEFINED, 0, 4 * spacing);
+		rand_y = P_RandomRange(PR_UNDEFINED, -spacing, spacing);
+		rand_x = P_RandomRange(PR_UNDEFINED, -spacing, spacing);
 		mobj_t *puff = P_SpawnMobjFromMobj(
 				collectible,
-				P_RandomRange(PR_UNDEFINED, -spacing, spacing) * FRACUNIT,
-				P_RandomRange(PR_UNDEFINED, -spacing, spacing) * FRACUNIT,
-				P_RandomRange(PR_UNDEFINED, 0, 4 * spacing) * FRACUNIT,
+				rand_x * FRACUNIT,
+				rand_y * FRACUNIT,
+				rand_z * FRACUNIT,
 				MT_SPINDASHDUST
 		);
 
diff --git a/src/objects/monitor.c b/src/objects/monitor.c
index 38cf03ae5..94c4d9343 100644
--- a/src/objects/monitor.c
+++ b/src/objects/monitor.c
@@ -216,10 +216,15 @@ spawn_shard
 	const UINT16 rad = (monitor->radius / monitor->scale) / 4;
 	const UINT16 tall = (half / FRACUNIT) / 4;
 
+
+	// note: determinate random argument eval order
+	fixed_t rand_z = P_RandomKey(PR_ITEM_DEBRIS, tall + 1);
+	fixed_t rand_y = P_RandomRange(PR_ITEM_DEBRIS, -(rad), rad);
+	fixed_t rand_x = P_RandomRange(PR_ITEM_DEBRIS, -(rad), rad);
 	mobj_t *p = P_SpawnMobjFromMobj(monitor,
-			P_RandomRange(PR_ITEM_DEBRIS, -(rad), rad) * 8 * FRACUNIT,
-			P_RandomRange(PR_ITEM_DEBRIS, -(rad), rad) * 8 * FRACUNIT,
-			(half / 4) + P_RandomKey(PR_ITEM_DEBRIS, tall + 1) * 4 * FRACUNIT,
+			rand_x * 8 * FRACUNIT,
+			rand_y * 8 * FRACUNIT,
+			(half / 4) + rand_z * 4 * FRACUNIT,
 			MT_MONITOR_SHARD);
 
 	angle_t th = (part->angle + ANGLE_90);
@@ -283,9 +288,9 @@ spawn_monitor_explosion (mobj_t *monitor)
 		mobj_t *x = P_SpawnMobjFromMobj(monitor, 0, 0, 0, MT_BOOMEXPLODE);
 		x->hitlag = 0;
 		x->color = SKINCOLOR_WHITE;
-		x->momx = P_RandomRange(PR_EXPLOSION, -5, 5) * monitor->scale,
-			x->momy = P_RandomRange(PR_EXPLOSION, -5, 5) * monitor->scale,
-			x->momz = P_RandomRange(PR_EXPLOSION, 0, 6) * monitor->scale * P_MobjFlip(monitor);
+		x->momx = P_RandomRange(PR_EXPLOSION, -5, 5) * monitor->scale;
+		x->momy = P_RandomRange(PR_EXPLOSION, -5, 5) * monitor->scale;
+		x->momz = P_RandomRange(PR_EXPLOSION, 0, 6) * monitor->scale * P_MobjFlip(monitor);
 		P_SetScale(x, (x->destscale *= 3));
 	}
 }
diff --git a/src/objects/spb.c b/src/objects/spb.c
index 68a2090aa..90d9f2170 100644
--- a/src/objects/spb.c
+++ b/src/objects/spb.c
@@ -236,10 +236,14 @@ static void SpawnSPBSliptide(mobj_t *spb, SINT8 dir)
 // Used for seeking and when SPB is trailing its target from way too close!
 static void SpawnSPBSpeedLines(mobj_t *spb)
 {
+	// note: determinate random argument eval order
+	fixed_t rand_z = P_RandomRange(PR_DECORATION, -24, 24);
+	fixed_t rand_y = P_RandomRange(PR_DECORATION, -24, 24);
+	fixed_t rand_x = P_RandomRange(PR_DECORATION, -24, 24);
 	mobj_t *fast = P_SpawnMobjFromMobj(spb,
-		P_RandomRange(PR_DECORATION, -24, 24) * FRACUNIT,
-		P_RandomRange(PR_DECORATION, -24, 24) * FRACUNIT,
-		(spb->info->height / 2) + (P_RandomRange(PR_DECORATION, -24, 24) * FRACUNIT),
+		rand_x * FRACUNIT,
+		rand_y * FRACUNIT,
+		(spb->info->height / 2) + (rand_z * FRACUNIT),
 		MT_FASTLINE
 	);
 
@@ -596,7 +600,7 @@ static void SPBSeek(mobj_t *spb, mobj_t *bestMobj)
 			if (playeringame[i] == false || players[i].spectator == true)
 			{
 				// Not in-game
-				continue; 
+				continue;
 			}
 
 			if (players[i].mo == NULL || P_MobjWasRemoved(players[i].mo) == true)
@@ -629,11 +633,11 @@ static void SPBSeek(mobj_t *spb, mobj_t *bestMobj)
 
 	//CONS_Printf("%d: leveltime %d: SPB intangibility %d: SPBModeTimer\n", leveltime, spb_intangible(spb), spb_modetimer(spb));
 
-	// Tired of this thing whacking people when switching targets. 
+	// Tired of this thing whacking people when switching targets.
 	// I'm pretty sure checking mode timer doesn't work but, idk insurance!!
 
-	if (spb_intangible(spb) <= 0 || (spb_modetimer(spb) > 0)) 
-	 { 
+	if (spb_intangible(spb) <= 0 || (spb_modetimer(spb) > 0))
+	 {
 		if (sliptide != 0)
 		{
 			// 1 if turning left, -1 if turning right.
diff --git a/src/objects/super-flicky.cpp b/src/objects/super-flicky.cpp
index 28f956308..dea2d3ded 100644
--- a/src/objects/super-flicky.cpp
+++ b/src/objects/super-flicky.cpp
@@ -94,7 +94,7 @@ sine_bob
 	// slightly modified from objects/hyudoro.c
 	hyu->sprzoff = FixedMul(kBobHeight,
 			sineofs + FINESINE(a >> ANGLETOFINESHIFT)) * P_MobjFlip(hyu);
-			
+
 	if (P_IsObjectFlipped(hyu))
 		hyu->sprzoff -= hyu->height;
 }
@@ -383,11 +383,14 @@ struct Flicky : mobj_t
 			return;
 		}
 
+		fixed_t rand_z = P_RandomRange(PR_DECORATION, -24, 24);
+		fixed_t rand_y = P_RandomRange(PR_DECORATION, -24, 24);
+		fixed_t rand_x = P_RandomRange(PR_DECORATION, -24, 24);
 		mobj_t *fast = P_SpawnMobjFromMobjUnscaled(
 			this,
-			P_RandomRange(PR_DECORATION, -24, 24) * mapobjectscale,
-			P_RandomRange(PR_DECORATION, -24, 24) * mapobjectscale,
-			(height / 2) + (P_RandomRange(PR_DECORATION, -24, 24) * mapobjectscale),
+			rand_x * mapobjectscale,
+			rand_y * mapobjectscale,
+			(height / 2) + (rand_z * mapobjectscale),
 			MT_FASTLINE
 		);
 
diff --git a/src/objects/ufo.c b/src/objects/ufo.c
index 0ae317eab..1c3428831 100644
--- a/src/objects/ufo.c
+++ b/src/objects/ufo.c
@@ -82,10 +82,14 @@ static int maxhum = sizeof(hums) / sizeof(hums[0]) - 1;
 
 static void SpawnUFOSpeedLines(mobj_t *ufo)
 {
+	// note: determinate random argument eval order
+	fixed_t rand_z = P_RandomRange(PR_DECORATION, -24, 24);
+	fixed_t rand_y = P_RandomRange(PR_DECORATION, -120, 120);
+	fixed_t rand_x = P_RandomRange(PR_DECORATION, -120, 120);
 	mobj_t *fast = P_SpawnMobjFromMobj(ufo,
-		P_RandomRange(PR_DECORATION, -120, 120) * FRACUNIT,
-		P_RandomRange(PR_DECORATION, -120, 120) * FRACUNIT,
-		(ufo->info->height / 2) + (P_RandomRange(PR_DECORATION, -24, 24) * FRACUNIT),
+		rand_x * FRACUNIT,
+		rand_y * FRACUNIT,
+		(ufo->info->height / 2) + (rand_z * FRACUNIT),
 		MT_FASTLINE
 	);
 
@@ -102,10 +106,14 @@ static void SpawnUFOSpeedLines(mobj_t *ufo)
 
 static void SpawnEmeraldSpeedLines(mobj_t *mo)
 {
+	// note: determinate random argument eval order
+	fixed_t rand_z = P_RandomRange(PR_DECORATION, 0, 64);
+	fixed_t rand_y = P_RandomRange(PR_DECORATION, -48, 48);
+	fixed_t rand_x = P_RandomRange(PR_DECORATION, -48, 48);
 	mobj_t *fast = P_SpawnMobjFromMobj(mo,
-		P_RandomRange(PR_DECORATION, -48, 48) * FRACUNIT,
-		P_RandomRange(PR_DECORATION, -48, 48) * FRACUNIT,
-		P_RandomRange(PR_DECORATION, 0, 64) * FRACUNIT,
+		rand_x * FRACUNIT,
+		rand_y * FRACUNIT,
+		rand_z * FRACUNIT,
 		MT_FASTLINE);
 	P_SetMobjState(fast, S_KARTINVLINES1);
 
@@ -648,10 +656,14 @@ spawn_shard
 	const UINT16 rad = (ufo->radius / ufo->scale) / 4;
 	const UINT16 tall = (h / FRACUNIT);
 
+	// note: determinate random argument eval order
+	fixed_t rand_z = P_RandomKey(PR_ITEM_DEBRIS, tall + 1);
+	fixed_t rand_y = P_RandomRange(PR_ITEM_DEBRIS, -(rad), rad);
+	fixed_t rand_x = P_RandomRange(PR_ITEM_DEBRIS, -(rad), rad);
 	mobj_t *p = P_SpawnMobjFromMobj(ufo,
-			P_RandomRange(PR_ITEM_DEBRIS, -(rad), rad) * 8 * FRACUNIT,
-			P_RandomRange(PR_ITEM_DEBRIS, -(rad), rad) * 8 * FRACUNIT,
-			P_RandomKey(PR_ITEM_DEBRIS, tall + 1) * 4 * FRACUNIT,
+			rand_x * 8 * FRACUNIT,
+			rand_y * 8 * FRACUNIT,
+			rand_z * 4 * FRACUNIT,
 			MT_MONITOR_SHARD);
 
 	P_SetScale(p, (p->destscale = p->destscale * 3));
@@ -771,7 +783,7 @@ static void UFOKillPiece(mobj_t *piece)
 			set_flickerframe(NULL, piece);
 			piece->tics = 1;
 			return;
-		}		
+		}
 		case UFO_PIECE_TYPE_GLASS_UNDER:
 		case UFO_PIECE_TYPE_STEM:
 		{
diff --git a/src/p_enemy.c b/src/p_enemy.c
index 1b10dfe34..d7a03296b 100644
--- a/src/p_enemy.c
+++ b/src/p_enemy.c
@@ -2148,6 +2148,9 @@ void A_VultureFly(mobj_t *actor)
 	fixed_t dx, dy, dz, dxy, dm;
 	mobj_t *dust;
 	fixed_t momm;
+	fixed_t rand_x;
+	fixed_t rand_y;
+	fixed_t rand_z;
 
 	if (LUA_CallAction(A_VULTUREFLY, actor))
 		return;
@@ -2191,7 +2194,11 @@ void A_VultureFly(mobj_t *actor)
 
 	P_VultureHoverParticle(actor);
 
-	dust = P_SpawnMobj(actor->x + P_RandomFixed(PR_UNDEFINED) - FRACUNIT/2, actor->y + P_RandomFixed(PR_UNDEFINED) - FRACUNIT/2, actor->z + actor->height/2 + P_RandomFixed(PR_UNDEFINED) - FRACUNIT/2, MT_PARTICLE);
+	// note: determinate random argument eval order
+	rand_z = P_RandomFixed(PR_UNDEFINED);
+	rand_y = P_RandomFixed(PR_UNDEFINED);
+	rand_x = P_RandomFixed(PR_UNDEFINED);
+	dust = P_SpawnMobj(actor->x + rand_x - FRACUNIT/2, actor->y + rand_y - FRACUNIT/2, actor->z + actor->height/2 + rand_z - FRACUNIT/2, MT_PARTICLE);
 	P_SetScale(dust, 2*FRACUNIT);
 	dust->destscale = FRACUNIT/3;
 	dust->scalespeed = FRACUNIT/40;
@@ -3793,7 +3800,13 @@ void A_FishJump(mobj_t *actor)
 		if (i < MAXPLAYERS)
 		{
 			fixed_t rad = actor->radius>>FRACBITS;
-			P_SpawnMobjFromMobj(actor, P_RandomRange(PR_UNDEFINED, rad, -rad)<<FRACBITS, P_RandomRange(PR_UNDEFINED, rad, -rad)<<FRACBITS, 0, (mobjtype_t)locvar2);
+			fixed_t rand_x;
+			fixed_t rand_y;
+
+			// note: determinate random argument eval order
+			rand_y = P_RandomRange(PR_UNDEFINED, rad, -rad);
+			rand_x = P_RandomRange(PR_UNDEFINED, rad, -rad);
+			P_SpawnMobjFromMobj(actor, rand_x<<FRACBITS, rand_y<<FRACBITS, 0, (mobjtype_t)locvar2);
 		}
 	}
 
@@ -10339,6 +10352,9 @@ void A_FlameParticle(mobj_t *actor)
 	mobjtype_t type = (mobjtype_t)(mobjinfo[actor->type].painchance);
 	fixed_t rad, hei;
 	mobj_t *particle;
+	fixed_t rand_x;
+	fixed_t rand_y;
+	fixed_t rand_z;
 
 	if (LUA_CallAction(A_FLAMEPARTICLE, actor))
 		return;
@@ -10348,10 +10364,14 @@ void A_FlameParticle(mobj_t *actor)
 
 	rad = actor->radius>>FRACBITS;
 	hei = actor->height>>FRACBITS;
+	// note: determinate random argument eval order
+	rand_z = P_RandomRange(PR_DECORATION, hei/2, hei);
+	rand_y = P_RandomRange(PR_DECORATION, rad, -rad);
+	rand_x = P_RandomRange(PR_DECORATION, rad, -rad);
 	particle = P_SpawnMobjFromMobj(actor,
-		P_RandomRange(PR_DECORATION, rad, -rad)<<FRACBITS,
-		P_RandomRange(PR_DECORATION, rad, -rad)<<FRACBITS,
-		P_RandomRange(PR_DECORATION, hei/2, hei)<<FRACBITS,
+		rand_x<<FRACBITS,
+		rand_y<<FRACBITS,
+		rand_z<<FRACBITS,
 		type);
 	P_SetObjectMomZ(particle, 2<<FRACBITS, false);
 }
@@ -10535,9 +10555,17 @@ void A_MineExplode(mobj_t *actor)
 		P_SpawnMobj(actor->x, actor->y, actor->z, type);
 		for (i = 0; i < 16; i++)
 		{
-			mobj_t *b = P_SpawnMobj(actor->x+P_RandomRange(PR_EXPLOSION, -dist, dist)*FRACUNIT,
-				actor->y+P_RandomRange(PR_EXPLOSION, -dist, dist)*FRACUNIT,
-				actor->z+P_RandomRange(PR_EXPLOSION, ((actor->eflags & MFE_UNDERWATER) ? -dist : 0), dist)*FRACUNIT,
+			fixed_t rand_x;
+			fixed_t rand_y;
+			fixed_t rand_z;
+
+			// note: determinate random argument eval order
+			rand_z = P_RandomRange(PR_EXPLOSION, ((actor->eflags & MFE_UNDERWATER) ? -dist : 0), dist);
+			rand_y = P_RandomRange(PR_EXPLOSION, -dist, dist);
+			rand_x = P_RandomRange(PR_EXPLOSION, -dist, dist);
+			mobj_t *b = P_SpawnMobj(actor->x+rand_x*FRACUNIT,
+				actor->y+rand_y*FRACUNIT,
+				actor->z+rand_z*FRACUNIT,
 				type);
 			fixed_t dx = b->x - actor->x, dy = b->y - actor->y, dz = b->z - actor->z;
 			fixed_t dm = P_AproxDistance(dz, P_AproxDistance(dy, dx));
@@ -12102,9 +12130,16 @@ void A_JawzExplode(mobj_t *actor)
 	while (shrapnel)
 	{
 		INT32 speed, speed2;
+		fixed_t rand_x;
+		fixed_t rand_y;
+		fixed_t rand_z;
 
-		truc = P_SpawnMobj(actor->x + P_RandomRange(PR_EXPLOSION, -8, 8)*FRACUNIT, actor->y + P_RandomRange(PR_EXPLOSION, -8, 8)*FRACUNIT,
-			actor->z + P_RandomRange(PR_EXPLOSION, 0, 8)*FRACUNIT, MT_BOOMPARTICLE);
+		// note: determinate random argument eval order
+		rand_z = P_RandomRange(PR_EXPLOSION, 0, 8);
+		rand_y = P_RandomRange(PR_EXPLOSION, -8, 8);
+		rand_x = P_RandomRange(PR_EXPLOSION, -8, 8);
+		truc = P_SpawnMobj(actor->x + rand_x*FRACUNIT, actor->y + rand_y*FRACUNIT,
+			actor->z + rand_z*FRACUNIT, MT_BOOMPARTICLE);
 		truc->scale = actor->scale*2;
 
 		speed = FixedMul(7*FRACUNIT, actor->scale)>>FRACBITS;
@@ -12292,8 +12327,16 @@ void A_FZBoomSmoke(mobj_t *actor)
 
 	for (i = 0; i < 8+(4*var1); i++)
 	{
-		mobj_t *smoke = P_SpawnMobj(actor->x + (P_RandomRange(PR_SMOLDERING, -rad, rad)*actor->scale), actor->y + (P_RandomRange(PR_SMOLDERING, -rad, rad)*actor->scale),
-			actor->z + (P_RandomRange(PR_SMOLDERING, 0, 72)*actor->scale), MT_THOK);
+		fixed_t rand_x;
+		fixed_t rand_y;
+		fixed_t rand_z;
+
+		// note: determinate random argument eval order
+		rand_z = P_RandomRange(PR_SMOLDERING, 0, 72);
+		rand_y = P_RandomRange(PR_SMOLDERING, -rad, rad);
+		rand_x = P_RandomRange(PR_SMOLDERING, -rad, rad);
+		mobj_t *smoke = P_SpawnMobj(actor->x + (rand_x*actor->scale), actor->y + (rand_y*actor->scale),
+			actor->z + (rand_z*actor->scale), MT_THOK);
 
 		P_SetMobjState(smoke, S_FZEROSMOKE1);
 		smoke->tics += P_RandomRange(PR_SMOLDERING, -3, 4);
@@ -12516,12 +12559,19 @@ A_SpawnItemDebrisCloud (mobj_t *actor)
 	{
 		const INT16 spacing =
 			(target->radius / 2) / target->scale;
+		fixed_t rand_x;
+		fixed_t rand_y;
+		fixed_t rand_z;
 
+		// note: determinate random argument evaluation order
+		rand_z = P_RandomRange(PR_ITEM_DEBRIS, 0, 4 * spacing);
+		rand_y = P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing);
+		rand_x = P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing);
 		mobj_t *puff = P_SpawnMobjFromMobj(
 				target,
-				P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing) * FRACUNIT,
-				P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing) * FRACUNIT,
-				P_RandomRange(PR_ITEM_DEBRIS, 0, 4 * spacing) * FRACUNIT,
+				rand_x * FRACUNIT,
+				rand_y * FRACUNIT,
+				rand_z * FRACUNIT,
 				MT_SPINDASHDUST
 		);
 
diff --git a/src/p_inter.c b/src/p_inter.c
index f8d3f162a..8151a2c2d 100644
--- a/src/p_inter.c
+++ b/src/p_inter.c
@@ -2111,11 +2111,19 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
 			// dust effects
 			for (i = 0; i < 10; i++)
 			{
+				fixed_t rand_x;
+				fixed_t rand_y;
+				fixed_t rand_z;
+
+				// note: determinate random argument eval order
+				rand_z = P_RandomRange(PR_ITEM_DEBRIS, 0, 4*spacing);
+				rand_y = P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing);
+				rand_x = P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing);
 				mobj_t *puff = P_SpawnMobjFromMobj(
 					target,
-					P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing) * FRACUNIT,
-					P_RandomRange(PR_ITEM_DEBRIS, -spacing, spacing) * FRACUNIT,
-					P_RandomRange(PR_ITEM_DEBRIS, 0, 4*spacing) * FRACUNIT,
+					rand_x * FRACUNIT,
+					rand_y * FRACUNIT,
+					rand_z * FRACUNIT,
 					MT_SPINDASHDUST
 				);
 
diff --git a/src/p_mobj.c b/src/p_mobj.c
index 6e9014c7d..7cf2c39d9 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -6257,11 +6257,19 @@ static void P_MobjSceneryThink(mobj_t *mobj)
 
 					for (i = 0; i < 10; i++)
 					{
+						fixed_t rand_x;
+						fixed_t rand_y;
+						fixed_t rand_z;
+
+						// note: determinate random argument eval order
+						rand_z = P_RandomRange(PR_ITEM_RINGS, -spacing, spacing);
+						rand_y = P_RandomRange(PR_ITEM_RINGS, -spacing, spacing);
+						rand_x = P_RandomRange(PR_ITEM_RINGS, -spacing, spacing);
 						mobj_t *debris = P_SpawnMobjFromMobj(
 							mobj,
-							P_RandomRange(PR_ITEM_RINGS, -spacing, spacing) * FRACUNIT,
-							P_RandomRange(PR_ITEM_RINGS, -spacing, spacing) * FRACUNIT,
-							P_RandomRange(PR_ITEM_RINGS, -spacing, spacing) * FRACUNIT,
+							rand_x * FRACUNIT,
+							rand_y * FRACUNIT,
+							rand_z * FRACUNIT,
 							MT_BATTLEBUMPER_DEBRIS
 						);
 
@@ -6288,11 +6296,19 @@ static void P_MobjSceneryThink(mobj_t *mobj)
 
 					for (i = 0; i < 10; i++)
 					{
+						fixed_t rand_x;
+						fixed_t rand_y;
+						fixed_t rand_z;
+
+						// note: determinate random argument eval order
+						rand_z = P_RandomRange(PR_ITEM_RINGS, -spacing, spacing);
+						rand_y = P_RandomRange(PR_ITEM_RINGS, -spacing, spacing);
+						rand_x = P_RandomRange(PR_ITEM_RINGS, -spacing, spacing);
 						mobj_t *puff = P_SpawnMobjFromMobj(
 							mobj,
-							P_RandomRange(PR_ITEM_RINGS, -spacing, spacing) * FRACUNIT,
-							P_RandomRange(PR_ITEM_RINGS, -spacing, spacing) * FRACUNIT,
-							P_RandomRange(PR_ITEM_RINGS, -spacing, spacing) * FRACUNIT,
+							rand_x * FRACUNIT,
+							rand_y * FRACUNIT,
+							rand_z * FRACUNIT,
 							MT_SPINDASHDUST
 						);
 
@@ -8196,6 +8212,8 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 
 		if (mobj->state == &states[S_BOOSTSMOKESPAWNER])
 		{
+			fixed_t rand_angle;
+			fixed_t rand_move;
 			mobj_t *smoke = P_SpawnMobj(mobj->x, mobj->y, mobj->z+(8<<FRACBITS), MT_BOOSTSMOKE);
 
 			P_SetScale(smoke, mobj->target->scale/2);
@@ -8206,7 +8224,10 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 			smoke->momy = mobj->target->momy/2;
 			smoke->momz = mobj->target->momz/2;
 
-			P_Thrust(smoke, mobj->angle+FixedAngle(P_RandomRange(PR_ITEM_BOOST, 135, 225)<<FRACBITS), P_RandomRange(PR_ITEM_BOOST, 0, 8) * mobj->target->scale);
+			// note: determinate random argument eval order
+			rand_move = P_RandomRange(PR_ITEM_BOOST, 0, 8);
+			rand_angle = P_RandomRange(PR_ITEM_BOOST, 135, 225);
+			P_Thrust(smoke, mobj->angle+FixedAngle(rand_angle<<FRACBITS), rand_move * mobj->target->scale);
 		}
 		break;
 	case MT_INVULNFLASH:
@@ -8989,9 +9010,17 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 
 				for (i = 0; i < nl; i++)
 				{
-					mobj_t *fast = P_SpawnMobj(mobj->x + (P_RandomRange(PR_ITEM_BOOST, -36,36) * mobj->scale),
-						mobj->y + (P_RandomRange(PR_ITEM_BOOST, -36,36) * mobj->scale),
-						mobj->z + (mobj->height/2) + (P_RandomRange(PR_ITEM_BOOST, -20,20) * mobj->scale),
+					fixed_t rand_x;
+					fixed_t rand_y;
+					fixed_t rand_z;
+
+					// note: determinate random argument eval order
+					rand_z = P_RandomRange(PR_ITEM_BOOST, -20,20);
+					rand_y = P_RandomRange(PR_ITEM_BOOST, -36,36);
+					rand_x = P_RandomRange(PR_ITEM_BOOST, -36,36);
+					mobj_t *fast = P_SpawnMobj(mobj->x + (rand_x * mobj->scale),
+						mobj->y + (rand_y * mobj->scale),
+						mobj->z + (mobj->height/2) + (rand_z * mobj->scale),
 						MT_FASTLINE);
 
 					fast->angle = mobj->angle;
@@ -9527,7 +9556,13 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 		else // fire + smoke pillar
 		{
 			UINT8 i;
-			mobj_t *fire = P_SpawnMobj(mobj->x + (P_RandomRange(PR_SMOLDERING, -32, 32)*mobj->scale), mobj->y + (P_RandomRange(PR_SMOLDERING, -32, 32)*mobj->scale), mobj->z, MT_THOK);
+			fixed_t rand_x;
+			fixed_t rand_y;
+
+			// note: determinate random argument eval order
+			rand_y = P_RandomRange(PR_SMOLDERING, -32, 32);
+			rand_x = P_RandomRange(PR_SMOLDERING, -32, 32);
+			mobj_t *fire = P_SpawnMobj(mobj->x + (rand_x*mobj->scale), mobj->y + (rand_y*mobj->scale), mobj->z, MT_THOK);
 
 			fire->sprite = SPR_FPRT;
 			fire->frame = FF_FULLBRIGHT|FF_TRANS30;
@@ -9539,7 +9574,10 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 
 			for (i = 0; i < 2; i++)
 			{
-				mobj_t *smoke = P_SpawnMobj(mobj->x + (P_RandomRange(PR_SMOLDERING, -16, 16)*mobj->scale), mobj->y + (P_RandomRange(PR_SMOLDERING, -16, 16)*mobj->scale), mobj->z, MT_SMOKE);
+				// note: determinate random argument eval order
+				rand_y = P_RandomRange(PR_SMOLDERING, -16, 16);
+				rand_x = P_RandomRange(PR_SMOLDERING, -16, 16);
+				mobj_t *smoke = P_SpawnMobj(mobj->x + (rand_x*mobj->scale), mobj->y + (rand_y*mobj->scale), mobj->z, MT_SMOKE);
 
 				P_SetMobjState(smoke, S_FZSLOWSMOKE1);
 				smoke->scale = mobj->scale;
@@ -9763,9 +9801,17 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 
 			if ((mobj->tracer && !P_MobjWasRemoved(mobj->tracer)) && !(leveltime % 10))
 			{
-				mobj_t *dust = P_SpawnMobj(mobj->x + (P_RandomRange(PR_UNDEFINED, -4, 4)<<FRACBITS),
-					mobj->y + (P_RandomRange(PR_UNDEFINED, -4, 4)<<FRACBITS),
-					mobj->z + (P_RandomRange(PR_UNDEFINED, 0, 2)<<FRACBITS), MT_BBZDUST);
+				fixed_t rand_x;
+				fixed_t rand_y;
+				fixed_t rand_z;
+
+				// note: determinate random argument eval order
+				rand_z = P_RandomRange(PR_UNDEFINED, 0, 2);
+				rand_y = P_RandomRange(PR_UNDEFINED, -4, 4);
+				rand_x = P_RandomRange(PR_UNDEFINED, -4, 4);
+				mobj_t *dust = P_SpawnMobj(mobj->x + (rand_x<<FRACBITS),
+					mobj->y + (rand_y<<FRACBITS),
+					mobj->z + (rand_z<<FRACBITS), MT_BBZDUST);
 				P_SetScale(dust, mobj->scale/2);
 				P_InstaThrust(dust, FixedAngle(P_RandomRange(PR_UNDEFINED, 0,359)<<FRACBITS), abs(mobj->tracer->momz)/2);