Cube  Check-in [3d4489fdbb]

// weapon.cpp: all shooting and effects code

#include "cube.h"

struct guninfo {
	short sound, attackdelay, damage, projspeed, part, kickamount;
	char *name;
	OFString *name;
};

const int MONSTERDAMAGEFACTOR = 4;
const int SGRAYS = 20;
const float SGSPREAD = 2;
OFVector3D sg[SGRAYS];

guninfo guns[NUMGUNS] = {
    {S_PUNCH1, 250, 50, 0, 0, 1, "fist"},
    {S_SG, 1400, 10, 0, 0, 20, "shotgun"}, // *SGRAYS
    {S_CG, 100, 30, 0, 0, 7, "chaingun"},
    {S_RLFIRE, 800, 120, 80, 0, 10, "rocketlauncher"},
    {S_RIFLE, 1500, 100, 0, 0, 30, "rifle"},
    {S_FLAUNCH, 200, 20, 50, 4, 1, "fireball"},
    {S_ICEBALL, 200, 40, 30, 6, 1, "iceball"},
    {S_SLIMEBALL, 200, 30, 160, 7, 1, "slimeball"},
    {S_PIGR1, 250, 50, 0, 0, 1, "bite"},
    {S_PUNCH1, 250, 50, 0, 0, 1, @"fist"},
    {S_SG, 1400, 10, 0, 0, 20, @"shotgun"}, // *SGRAYS
    {S_CG, 100, 30, 0, 0, 7, @"chaingun"},
    {S_RLFIRE, 800, 120, 80, 0, 10, @"rocketlauncher"},
    {S_RIFLE, 1500, 100, 0, 0, 30, @"rifle"},
    {S_FLAUNCH, 200, 20, 50, 4, 1, @"fireball"},
    {S_ICEBALL, 200, 40, 30, 6, 1, @"iceball"},
    {S_SLIMEBALL, 200, 30, 160, 7, 1, @"slimeball"},
    {S_PIGR1, 250, 50, 0, 0, 1, @"bite"},
};

void
selectgun(int a, int b, int c)
{
	if (a < -1 || b < -1 || c < -1 || a >= NUMGUNS || b >= NUMGUNS ||
	    c >= NUMGUNS)

	else if (s != GUN_RIFLE && player1->ammo[GUN_RIFLE])
		s = GUN_RIFLE;
	else
		s = GUN_FIST;
	if (s != player1->gunselect)
		playsoundc(S_WEAPLOAD);
	player1->gunselect = s;
	// conoutf(@"%s selected", (int)guns[s].name);
	// conoutf(@"%s selected", (int)guns[s].name.UTF8String);
};
}

int
reloadtime(int gun)
{
	return guns[gun].attackdelay;
};
}

void
weapon(OFString *a1, OFString *a2, OFString *a3)
{
	@autoreleasepool {
		selectgun(a1.UTF8String[0] ? atoi(a1.UTF8String) : -1,
	selectgun((a1.length > 0 ? (int)a1.longLongValue : -1),
		    a2.UTF8String[0] ? atoi(a2.UTF8String) : -1,
		    a3.UTF8String[0] ? atoi(a3.UTF8String) : -1);
	    (a2.length > 0 ? (int)a2.longLongValue : -1),
	}
	    (a3.length > 0 ? (int)a3.longLongValue : -1));
}
COMMAND(weapon, ARG_3STR)

void
createrays(OFVector3D &from,
    OFVector3D &to) // create random spread of rays for the shotgun
{
	vdist(dist, dvec, from, to);
	float f = dist * SGSPREAD / 1000;
	loopi(SGRAYS)
	{
#define RNDD (rnd(101) - 50) * f
		OFVector3D r = OFMakeVector3D(RNDD, RNDD, RNDD);
		sg[i] = to;
		vadd(sg[i], r);
	};
};
	}
}

bool
intersect(dynent *d, OFVector3D &from,
    OFVector3D &to) // if lineseg hits entity bounding box
{
	OFVector3D v = to, w = d->o, *p;
	vsub(v, from);

		if (c2 <= c1)
			p = &to;
		else {
			float f = c1 / c2;
			vmul(v, f);
			vadd(v, from);
			p = &v;
		};
	};

	return p->x <= d->o.x + d->radius && p->x >= d->o.x - d->radius &&
	       p->y <= d->o.y + d->radius && p->y >= d->o.y - d->radius &&
	       p->z <= d->o.z + d->aboveeye && p->z >= d->o.z - d->eyeheight;
		}
	}

	return (p->x <= d->o.x + d->radius && p->x >= d->o.x - d->radius &&
	        p->y <= d->o.y + d->radius && p->y >= d->o.y - d->radius &&
	        p->z <= d->o.z + d->aboveeye && p->z >= d->o.z - d->eyeheight);
};
}

char *
playerincrosshair()
{
	if (demoplayback)
		return NULL;
	loopv(players)
	{
		dynent *o = players[i];
		if (!o)
			continue;
		if (intersect(o, player1->o, worldpos))
			return o->name;
	};
	}
	return NULL;
};
}

const int MAXPROJ = 100;
struct projectile {
	OFVector3D o, to;
	float speed;
	dynent *owner;
	int gun;
	bool inuse, local;
};
projectile projs[MAXPROJ];
} projs[MAXPROJ];

void
projreset()
{
	loopi(MAXPROJ) projs[i].inuse = false;
};
}

void
newprojectile(OFVector3D &from, OFVector3D &to, float speed, bool local,
    dynent *owner, int gun)
{
	loopi(MAXPROJ)
	{
		projectile *p = &projs[i];
		if (p->inuse)
			continue;
		p->inuse = true;
		p->o = from;
		p->to = to;
		p->speed = speed;
		p->local = local;
		p->owner = owner;
		p->gun = gun;
		return;
	};
};
	}
}

void
hit(int target, int damage, dynent *d, dynent *at)
{
	if (d == player1)
		selfdamage(damage, at == player1 ? -1 : -2, at);
	else if (d->monsterstate)
		monsterpain(d, damage, at);
	else {
		addmsg(1, 4, SV_DAMAGE, target, damage, d->lifesequence);
		playsound(S_PAIN1 + rnd(5), &d->o);
	};
	particle_splash(3, damage, 1000, d->o);
	demodamage(damage, d->o);
};
}

const float RL_RADIUS = 5;
const float RL_DAMRAD = 7; // hack

void
radialeffect(dynent *o, OFVector3D &v, int cn, int qdam, dynent *at)
{
	if (o->state != CS_ALIVE)
		return;
	vdist(dist, temp, v, o->o);
	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);
		vmul(temp, (RL_DAMRAD - dist) * damage / 800);
		vadd(o->vel, temp);
	};
};
	}
}

void
splash(projectile *p, OFVector3D &v, OFVector3D &vold, int notthisplayer,
    int notthismonster, int qdam)
{
	particle_splash(0, 50, 300, v);
	p->inuse = false;

		{
			if (i == notthisplayer)
				continue;
			dynent *o = players[i];
			if (!o)
				continue;
			radialeffect(o, v, i, qdam, p->owner);
		};
		}
		dvector &mv = getmonsters();
		loopv(mv) if (i != notthismonster)
		    radialeffect(mv[i], v, i, qdam, p->owner);
	};
};
	}
}

inline void
projdamage(dynent *o, projectile *p, OFVector3D &v, int i, int im, int qdam)
{
	if (o->state != CS_ALIVE)
		return;
	if (intersect(o, p->o, v)) {
		splash(p, v, p->o, i, im, qdam);
		hit(i, qdam, o, p->owner);
	};
};
	}
}

void
moveprojectiles(float time)
{
	loopi(MAXPROJ)
	{
		projectile *p = &projs[i];

					particle_splash(1, 1, 200, v);
					particle_splash(
					    guns[p->gun].part, 1, 1, v);
				}
			}
		}
		p->o = v;
	};
};
	}
}

void
shootv(int gun, OFVector3D &from, OFVector3D &to, dynent *d,
    bool local) // create visual effect from a shot
{
	playsound(guns[gun].sound, d == player1 ? NULL : &d->o);
	int pspeed = 25;
	switch (gun) {
	case GUN_FIST:
		break;

	case GUN_SG: {
		loopi(SGRAYS) particle_splash(0, 5, 200, sg[i]);
		break;
	};
	}

	case GUN_CG:
		particle_splash(0, 100, 250, to);
		// particle_trail(1, 10, from, to);
		break;

	case GUN_RL:
	case GUN_FIREBALL:
	case GUN_ICEBALL:
	case GUN_SLIMEBALL:
		pspeed = guns[gun].projspeed;
		if (d->monsterstate)
			pspeed /= 2;
		newprojectile(from, to, (float)pspeed, local, d, gun);
		break;

	case GUN_RIFLE:
		particle_splash(0, 50, 200, to);
		particle_trail(1, 500, from, to);
		break;
	};
};
	}
}

void
hitpush(int target, int damage, dynent *d, dynent *at, OFVector3D &from,
    OFVector3D &to)
{
	hit(target, damage, d, at);
	vdist(dist, v, from, to);

	if (d->gunselect == GUN_SG) {
		int damage = 0;
		loop(r, SGRAYS) if (intersect(o, from, sg[r])) damage += qdam;
		if (damage)
			hitpush(i, damage, o, d, from, to);
	} else if (intersect(o, from, to))
		hitpush(i, qdam, o, d, from, to);
};
}

void
shoot(dynent *d, OFVector3D &targ)
{
	int attacktime = lastmillis - d->lastaction;
	if (attacktime < d->gunwait)
		return;
	d->gunwait = 0;
	if (!d->attacking)
		return;
	d->lastaction = lastmillis;
	d->lastattackgun = d->gunselect;
	if (!d->ammo[d->gunselect]) {
		playsoundc(S_NOAMMO);
		d->gunwait = 250;
		d->lastattackgun = -1;
		return;
	};
	}
	if (d->gunselect)
		d->ammo[d->gunselect]--;
	OFVector3D from = d->o;
	OFVector3D to = targ;
	from.z -= 0.2f; // below eye

	vdist(dist, unitv, from, to);
	vdiv(unitv, dist);
	OFVector3D kickback = unitv;
	vmul(kickback, guns[d->gunselect].kickamount * -0.01f);
	vadd(d->vel, kickback);
	if (d->pitch < 80.0f)
		d->pitch += guns[d->gunselect].kickamount * 0.05f;

	if (d->gunselect == GUN_FIST || d->gunselect == GUN_BITE) {
		vmul(unitv, 3); // punch range
		to = from;
		vadd(to, unitv);
	};
	}
	if (d->gunselect == GUN_SG)
		createrays(from, to);

	if (d->quadmillis && attacktime > 200)
		playsoundc(S_ITEMPUP);
	shootv(d->gunselect, from, to, d, true);
	if (!d->monsterstate)

	loopv(players)
	{
		dynent *o = players[i];
		if (!o)
			continue;
		raydamage(o, from, to, d, i);
	};
	}

	dvector &v = getmonsters();
	loopv(v) if (v[i] != d) raydamage(v[i], from, to, d, -2);

	if (d->monsterstate)
		raydamage(player1, from, to, d, -1);
};
}