Cube  Check-in [6259424802]

			self.yaw = self.targetYaw;
	} else {
		self.yaw -= curtime * 0.5f;
		if (self.targetYaw > self.yaw)
			self.yaw = self.targetYaw;
	}

	float disttoenemy =
	vdist(disttoenemy, vectoenemy, self.origin, self.enemy.origin);
	    OFDistanceOfVectors3D(self.origin, self.enemy.origin);
	self.pitch =
	    atan2(self.enemy.origin.z - self.origin.z, disttoenemy) * 180 / PI;

	// special case: if we run into scenery
	if (self.blocked) {
		self.blocked = false;
		// try to jump over obstackle (rare)

			if (monster.state == CS_DEAD) {
				if (lastmillis - monster.lastAction < 2000) {
					monster.move = 0;
					moveplayer(monster, 1, false);
				}
			} else {
				v.z += monster.eyeHeight;
				float dist =
				vdist(dist, t, monster.origin, v);
				    OFDistanceOfVectors3D(monster.origin, v);
				v.z -= monster.eyeHeight;

				if (dist < 4)
					teleport(i, monster);
			}
		}
	}];

#define VIRTH 1800
#define FONTH 64
#define PIXELTAB (VIRTW / 12)

#define PI (3.1415927f)
#define PI2 (2 * PI)

// simplistic vector ops
#define vdist(d, v, e, s)                         \
	OFVector3D v = OFSubtractVectors3D(s, e); \
	float d = sqrtf(OFDotProductOfVectors3D(v, v));
#define vreject(v, u, max)                                 \
	((v).x > (u).x + (max) || (v).x < (u).x - (max) || \
	    (v).y > (u).y + (max) || (v).y < (u).y - (max))
#define vlinterp(v, f, u, g)                   \
	{                                      \
		(v).x = (v).x * f + (u).x * g; \
		(v).y = (v).y * f + (u).y * g; \

			return;

		if (OUTBORD(e.x, e.y))
			return;

		OFVector3D v = OFMakeVector3D(
		    e.x, e.y, (float)S(e.x, e.y)->floor + player1.eyeHeight);
		vdist(dist, t, player1.origin, v);
		float dist = OFDistanceOfVectors3D(player1.origin, v);

		if (dist < (e.type == TELEPORT ? 4 : 2.5))
			pickup(i, player1);
	}];
}

void

		newparticle(p, &d, rnd(fade * 3), type);
	}
}

void
particle_trail(int type, int fade, const OFVector3D *s, const OFVector3D *e)
{
	vdist(d, v, *s, *e);
	float d = OFDistanceOfVectors3D(*s, *e);
	OFVector3D v = OFSubtractVectors3D(*s, *e);
	v = OFMultiplyVector3D(v, 1.0f / (d * 2 + 0.1f));
	OFVector3D p = *s;
	for (int i = 0; i < ((int)d * 2); i++) {
		p = OFAddVectors3D(p, v);
		OFVector3D d =
		    OFMakeVector3D(rnd(11) - 5, rnd(11) - 5, rnd(11) - 5);
		newparticle(&p, &d, rnd(fade) + fade, type);

				// if(a==z || b==c)
				//	printf("* %d\n", lastmillis);
				float bf = (itime - a.lastUpdate) /
				    (float)(b.lastUpdate - a.lastUpdate);
				fixwrap(a, player1);
				fixwrap(c, player1);
				fixwrap(z, player1);
				float dist =
				vdist(dist, v, z.origin, c.origin);
				    OFDistanceOfVectors3D(z.origin, c.origin);
				// if teleport or spawn, don't interpolate
				if (dist < 16) {
					catmulrom(z.origin, a.origin, b.origin,
					    c.origin, bf, player1.origin);
					OFVector3D vz = OFMakeVector3D(
					    z.yaw, z.pitch, z.roll);
					OFVector3D va = OFMakeVector3D(

VAR(stereo, 0, 1, 1);

static void
updatechanvol(int chan, const OFVector3D *loc)
{
	int vol = soundvol, pan = 255 / 2;

	if (loc) {
		vdist(dist, v, *loc, player1.origin);
		vol -= (int)(dist * 3 * soundvol /
		    255); // simple mono distance attenuation
		OFVector3D origin = player1.origin;
		float dist = OFDistanceOfVectors3D(*loc, origin);
		OFVector3D v = OFSubtractVectors3D(*loc, origin);

		// simple mono distance attenuation
		vol -= (int)(dist * 3 * soundvol / 255);

		if (stereo && (v.x != 0 || v.y != 0)) {
			// relative angle of sound along X-Y axis
			float yaw =
			    -atan2(v.x, v.y) - player1.yaw * (PI / 180.0f);
			// range is from 0 (left) to 255 (right)
			pan = (int)(255.9f * (0.5 * sin(yaw) + 0.5f));
		}
	}

	vol = (vol * MAXVOL) / 255;
	Mix_Volume(chan, vol);
	Mix_SetPanning(chan, 255 - pan, pan);
}

static void
newsoundloc(int chan, const OFVector3D *loc)

	    (a3.length > 0 ? a3.cube_intValue : -1));
})

// create random spread of rays for the shotgun
void
createrays(const OFVector3D *from, const OFVector3D *to)
{
	vdist(dist, dvec, *from, *to);
	float dist = OFDistanceOfVectors3D(*from, *to);
	float f = dist * SGSPREAD / 1000;
	for (int i = 0; i < SGRAYS; i++)
#define RNDD (rnd(101) - 50) * f
		sg[i] = OFAddVectors3D(*to, OFMakeVector3D(RNDD, RNDD, RNDD));
}

// if lineseg hits entity bounding box

static void
radialeffect(
    DynamicEntity *o, const OFVector3D *v, int cn, int qdam, DynamicEntity *at)
{
	if (o.state != CS_ALIVE)
		return;
	vdist(dist, temp, *v, o.origin);

	OFVector3D origin = o.origin;
	float dist = OFDistanceOfVectors3D(*v, origin);
	OFVector3D temp = OFSubtractVectors3D(*v, origin);
	dist -= 2; // account for eye distance imprecision

	if (dist < RL_DAMRAD) {
		if (dist < 0)
			dist = 0;

		int damage = (int)(qdam * (1 - (dist / RL_DAMRAD)));
		hit(cn, damage, o, at);

		temp =
		    OFMultiplyVector3D(temp, (RL_DAMRAD - dist) * damage / 800);
		o.velocity = OFAddVectors3D(o.velocity, temp);
	}
}

static void

		if (!p.inuse)
			continue;

		int qdam = guns[p.gun].damage * (p.owner.quadMillis ? 4 : 1);
		if ([p.owner isKindOfClass:Monster.class])
			qdam /= MONSTERDAMAGEFACTOR;
		vdist(dist, v, p.o, p.to);
		OFVector3D po = p.o, pto = pto;
		float dist = OFDistanceOfVectors3D(po, pto);
		OFVector3D v = OFSubtractVectors3D(po, pto);
		float dtime = dist * 1000 / p.speed;
		if (time > dtime)
			dtime = time;
		v = OFMultiplyVector3D(v, time / dtime);
		v = OFAddVectors3D(v, p.o);
		if (p.local) {
			for (id player in players)

}

void
hitpush(int target, int damage, DynamicEntity *d, DynamicEntity *at,
    const OFVector3D *from, const OFVector3D *to)
{
	hit(target, damage, d, at);
	vdist(dist, v, *from, *to);
	float dist = OFDistanceOfVectors3D(*from, *to);
	OFVector3D v = OFSubtractVectors3D(*from, *to);
	v = OFMultiplyVector3D(v, damage / dist / 50);
	d.velocity = OFAddVectors3D(d.velocity, v);
}

void
raydamage(DynamicEntity *o, const OFVector3D *from, const OFVector3D *to,
    DynamicEntity *d, int i)

	}
	if (d.gunSelect)
		d.ammo[d.gunSelect]--;
	OFVector3D from = d.origin;
	OFVector3D to = *targ;
	from.z -= 0.2f; // below eye

	float dist = OFDistanceOfVectors3D(from, to);
	vdist(dist, unitv, from, to);
	OFVector3D unitv = OFSubtractVectors3D(from, to);
	unitv = OFMultiplyVector3D(unitv, 1.0f / dist);
	OFVector3D kickback =
	    OFMultiplyVector3D(unitv, guns[d.gunSelect].kickamount * -0.01f);
	d.velocity = OFAddVectors3D(d.velocity, kickback);
	if (d.pitch < 80.0f)
		d.pitch += guns[d.gunSelect].kickamount * 0.05f;

	__block int best;
	__block float bdist = 99999;
	[ents enumerateObjectsUsingBlock:^(Entity *e, size_t i, bool *stop) {
		if (e.type == NOTUSED)
			return;

		OFVector3D v = OFMakeVector3D(e.x, e.y, e.z);
		vdist(dist, t, player1.origin, v);
		float dist = OFDistanceOfVectors3D(player1.origin, v);
		if (dist < bdist) {
			best = i;
			bdist = dist;
		}
	}];

	return (bdist == 99999 ? -1 : best);