#include <ultra64.h>
#include "lib/sched.h"
#include "constants.h"
#include "game/bondmove.h"
#include "game/cheats.h"
#include "game/chraction.h"
#include "game/debug.h"
#include "game/chr.h"
#include "game/env.h"
#include "game/prop.h"
#include "game/propsnd.h"
#include "game/objectives.h"
#include "game/projectile.h"
#include "game/bondgun.h"
#include "game/gunfx.h"
#include "game/gset.h"
#include "game/modelmgr.h"
#include "game/tex.h"
#include "game/camera.h"
#include "game/player.h"
#include "game/mtxf2lbulk.h"
#include "game/playermgr.h"
#include "game/rng2.h"
#include "game/vtxstore.h"
#include "game/gfxmemory.h"
#include "game/explosions.h"
#include "game/smoke.h"
#include "game/sparks.h"
#include "game/bg.h"
#include "game/file.h"
#include "game/mplayer/setup.h"
#include "game/bot.h"
#include "game/botact.h"
#include "game/mplayer/mplayer.h"
#include "game/pad.h"
#include "game/propobj.h"
#include "game/splat.h"
#include "game/wallhit.h"
#include "bss.h"
#include "lib/vi.h"
#include "lib/main.h"
#include "lib/model.h"
#include "lib/rng.h"
#include "lib/mtx.h"
#include "lib/anim.h"
#include "lib/collision.h"
#include "data.h"
#include "gbiex.h"
#include "types.h"

void rng2_set_seed(u32 seed);

void *var8009ccc0[20];
s32 g_NumChrs;
s16 *g_Chrnums;
s16 *g_ChrIndexes;
struct chrdata *g_CurModelChr;

struct onscreendoor *g_ChrsOnscreenDoors = NULL;
s32 g_ChrsNumOnscreenDoors = 0;
f32 g_ChrsAnimSpeed = 0;
bool g_ChrsAnimDebugSetAll = false;
s32 g_ChrsAnimDebugAnimNum = 0;
u32 g_ChrsAnimDebugPaused = 0x00000000;
u32 g_ChrsAnimDebugSlow = 0x00000000;
bool g_ChrsDebugPatrols = false;
bool g_ChrsDebugSomething = false;
s32 g_NextChrnum = 5000;

struct chrdata *g_ChrSlots = NULL;

s32 g_NumChrSlots = 0;

Gfx *chr_render_cloak(Gfx *gdl, struct prop *chrprop, struct prop *thisprop);
Gfx *chr_render_shield(Gfx *gdl, struct chrdata *chr, u32 alpha);
void chr_set_drcaroll_images(struct chrdata *drcaroll, s32 imageleft, s32 imageright);

s32 chrs_get_num_slots(void)
{
	return g_NumChrSlots;
}

void chr_set_chrnum(struct chrdata *chr, s16 chrnum)
{
	s32 i;
	bool modified;
	s16 tmp;

	// Set the new chrnum
	for (i = 0; i < g_NumChrs; i++) {
		if (g_Chrnums[i] == chr->chrnum) {
			g_Chrnums[i] = chrnum;
			break;
		}

	}

	chr->chrnum = chrnum;

	// Sort the g_Chrnums and g_ChrIndexes arrays
	do {
		modified = false;

		for (i = 0; i < g_NumChrs - 1; i++) {
			if (g_Chrnums[i] > g_Chrnums[i + 1]) {
				tmp = g_Chrnums[i];
				g_Chrnums[i] = g_Chrnums[i + 1];
				g_Chrnums[i + 1] = tmp;

				tmp = g_ChrIndexes[i];
				g_ChrIndexes[i] = g_ChrIndexes[i + 1];
				g_ChrIndexes[i + 1] = tmp;

				modified = true;
			}
		}
	} while (modified);
}

void chr_register(s32 chrnum, s32 chrindex)
{
	s32 i;
	s16 tmp;

	for (i = 0; i < g_NumChrs; i++) {
		if (g_Chrnums[i] > chrnum) {
			tmp = g_Chrnums[i];
			g_Chrnums[i] = chrnum;
			chrnum = tmp;

			tmp = g_ChrIndexes[i];
			g_ChrIndexes[i] = chrindex;
			chrindex = tmp;
		}
	}

	g_Chrnums[g_NumChrs] = chrnum;
	g_ChrIndexes[g_NumChrs] = chrindex;
	g_NumChrs++;
}

void chr_deregister(s32 chrnum)
{
	s32 i;

	for (i = 0; i < g_NumChrs; i++) {
		if (g_Chrnums[i] == chrnum) {
			s32 j = i + 1;

			while (j < g_NumChrs) {
				g_Chrnums[i] = g_Chrnums[j];
				g_ChrIndexes[i] = g_ChrIndexes[j];
				i++;
				j++;
			}

			g_NumChrs--;
			return;
		}
	}
}

Vtx *chr_allocate_vertices(s32 numvertices)
{
	return (Vtx *) gfx_allocate(numvertices * sizeof(Vtx));
}

void chrs_set_debug_patrols(bool enabled)
{
	g_ChrsDebugPatrols = enabled;
}

bool chrs_get_debug_patrols(void)
{
	return g_ChrsDebugPatrols;
}

void chrs_set_debug_something(bool enabled)
{
	g_ChrsDebugSomething = enabled;
}

bool chrs_get_debug_something(void)
{
	return g_ChrsDebugSomething;
}

void chr_set_perim_enabled(struct chrdata *chr, bool enable)
{
	if (chr) {
		if (enable) {
			chr->hidden &= ~CHRHFLAG_PERIMDISABLED;
		} else {
			chr->hidden |= CHRHFLAG_PERIMDISABLED;
		}
	}
}

/**
 * When a chr is being pushed by a player, this function is called with the new
 * pos and rooms for the chr. It does collision checks and updates dstpos and
 * dstrooms to valid ones if needed.
 */
void chr_calculate_push_pos(struct chrdata *chr, struct coord *dstpos, RoomNum *dstrooms, bool arg3)
{
	f32 ymax;
	f32 ymin;
	f32 radius;
	bool moveok = false;
	f32 movex;
	f32 movez;
	struct prop *prop = chr->prop;
	u32 stack;
	f32 halfradius;
	struct defaultobj *chair = NULL;
	s32 cdresult;
	RoomNum sp84[20];
#if VERSION < VERSION_NTSC_1_0
	s32 i;
#endif
	struct coord sp78;
	struct coord sp6c;
	struct coord sp60;
	struct coord sp54;
	f32 value;
	struct coord sp44;
#if VERSION < VERSION_NTSC_1_0
	s32 j;
	s32 k;
	s32 l;
#endif

	// The eyespy can't be pushed
	if (CHRRACE(chr) == RACE_EYESPY) {
		rooms_copy(prop->rooms, dstrooms);
		chr_set_perim_enabled(chr, true);
		return;
	}

	chr_get_bbox(prop, &radius, &ymax, &ymin);
	halfradius = radius * 0.5f;
	chr_set_perim_enabled(chr, false);

	// myspecial is the chr's chair
	if (chr->myspecial != -1) {
		chair = obj_find_by_tag_id(chr->myspecial);

		if (chair && chair->prop) {
			obj_set_perim_enabled(chair->prop, false);
		}
	}

	los_find_intersecting_rooms_exhaustive(&prop->pos, prop->rooms, dstpos, dstrooms, sp84, 20);

#if VERSION < VERSION_NTSC_1_0
	for (i = 0; dstrooms[i] != -1; i++) {
		if (dstrooms[i] == chr->floorroom) {
			dstrooms[0] = chr->floorroom;
			dstrooms[1] = -1;
			break;
		}
	}
#endif

	chr_find_entered_rooms_at_pos(chr, dstpos, dstrooms);

	movex = dstpos->x - prop->pos.x;
	movez = dstpos->z - prop->pos.z;

	if (movex > halfradius || movez > halfradius || movex < -halfradius || movez < -halfradius) {
		cdresult = cd_test_cylmove_oobfail_findclosest(&prop->pos, prop->rooms, dstpos, dstrooms, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);

		if (cdresult == CDRESULT_NOCOLLISION) {
			cdresult = cd_test_volume_closestedge(&prop->pos, dstpos, radius, dstrooms, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);
		}
	} else {
		cdresult = cd_test_volume_closestedge(&prop->pos, dstpos, radius, sp84, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);
	}

	if (cdresult == CDRESULT_ERROR) {
		// empty
	} else if (cdresult == CDRESULT_NOCOLLISION) {
		// The move was completely valid
		if (arg3) {
			chr->invalidmove = 0;
			chr->lastmoveok60 = g_Vars.lvframe60;
		}

		moveok = true;
	} else {
		// Collision
#if VERSION >= VERSION_PAL_FINAL
		cd_get_edge(&sp78, &sp6c, 453, "chr/chr.c");
#elif VERSION >= VERSION_PAL_BETA
		cd_get_edge(&sp78, &sp6c, 453, "chr.c");
#elif VERSION >= VERSION_NTSC_1_0
		cd_get_edge(&sp78, &sp6c, 453, "chr/chr.c");
#else
		cd_get_edge(&sp78, &sp6c, 451, "chr.c");
#endif

		// Attempt to find a valid position - method #1
		sp60.x = dstpos->x - prop->pos.x;
		sp60.z = dstpos->z - prop->pos.z;

		if (sp78.f[0] != sp6c.f[0] || sp78.f[2] != sp6c.f[2]) {
			sp54.x = sp6c.x - sp78.x;
			sp54.z = sp6c.z - sp78.z;

			value = 1.0f / sqrtf(sp54.f[0] * sp54.f[0] + sp54.f[2] * sp54.f[2]);

			sp54.x *= value;
			sp54.z *= value;

			value = sp60.f[0] * sp54.f[0] + sp60.f[2] * sp54.f[2];

			sp44.x = sp54.x * value + prop->pos.x;
			sp44.y = dstpos->y;
			sp44.z = sp54.z * value + prop->pos.z;

			los_find_intersecting_rooms_exhaustive(&prop->pos, prop->rooms, &sp44, dstrooms, sp84, 20);

#if VERSION < VERSION_NTSC_1_0
			for (j = 0; dstrooms[j] != -1; j++) {
				if (dstrooms[j] == chr->floorroom) {
					dstrooms[0] = chr->floorroom;
					dstrooms[1] = -1;
					break;
				}
			}
#endif

			chr_find_entered_rooms_at_pos(chr, &sp44, dstrooms);

			movex = sp44.x - prop->pos.x;
			movez = sp44.z - prop->pos.z;

			if (movex > halfradius || movez > halfradius || movex < -halfradius || movez < -halfradius) {
				cdresult = cd_test_cylmove_oobfail(&prop->pos, prop->rooms, &sp44, dstrooms, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);

				if (cdresult == CDRESULT_NOCOLLISION) {
					cdresult = cd_test_volume_simple(&sp44, radius, dstrooms, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);
				}
			} else {
				cdresult = cd_test_volume_simple(&sp44, radius, sp84, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);
			}

			if (cdresult == CDRESULT_NOCOLLISION) {
				dstpos->x = sp44.x;
				dstpos->z = sp44.z;
				chr->invalidmove = 2;
				moveok = true;
			}
		}

		if (!moveok) {
			// Attempt to find a valid position - method #2
			sp54.x = sp78.x - dstpos->x;
			sp54.z = sp78.z - dstpos->z;

			if (sp54.f[0] * sp54.f[0] + sp54.f[2] * sp54.f[2] <= radius * radius) {
				if (sp78.f[0] != prop->pos.f[0] || sp78.f[2] != prop->pos.f[2]) {
					sp54.x = -(sp78.z - prop->pos.z);
					sp54.z = sp78.x - prop->pos.x;

					value = 1.0f / sqrtf(sp54.f[0] * sp54.f[0] + sp54.f[2] * sp54.f[2]);

					sp54.x *= value;
					sp54.z *= value;

					value = sp60.f[0] * sp54.f[0] + sp60.f[2] * sp54.f[2];

					sp44.x = sp54.x * value + prop->pos.x;
					sp44.y = dstpos->y;
					sp44.z = sp54.z * value + prop->pos.z;

					los_find_intersecting_rooms_exhaustive(&prop->pos, prop->rooms, &sp44, dstrooms, sp84, 20);

#if VERSION < VERSION_NTSC_1_0
					for (k = 0; dstrooms[k] != -1; k++) {
						if (dstrooms[k] == chr->floorroom) {
							dstrooms[0] = chr->floorroom;
							dstrooms[1] = -1;
							break;
						}
					}
#endif

					chr_find_entered_rooms_at_pos(chr, &sp44, dstrooms);

					movex = sp44.x - prop->pos.x;
					movez = sp44.z - prop->pos.z;

					if (movex > halfradius || movez > halfradius || movex < -halfradius || movez < -halfradius) {
						cdresult = cd_test_cylmove_oobfail(&prop->pos, prop->rooms, &sp44, dstrooms, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);

						if (cdresult == CDRESULT_NOCOLLISION) {
							cdresult = cd_test_volume_simple(&sp44, radius, dstrooms, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);
						}
					} else {
						cdresult = cd_test_volume_simple(&sp44, radius, sp84, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);
					}

					if (cdresult == CDRESULT_NOCOLLISION) {
						dstpos->x = sp44.x;
						dstpos->z = sp44.z;
						chr->invalidmove = 2;
						moveok = true;
					}
				}
			} else {
				sp54.x = sp6c.x - dstpos->x;
				sp54.z = sp6c.z - dstpos->z;

				if (sp54.f[0] * sp54.f[0] + sp54.f[2] * sp54.f[2] <= radius * radius) {
					if (sp6c.f[0] != prop->pos.f[0] || sp6c.f[2] != prop->pos.f[2]) {
						sp54.x = -(sp6c.z - prop->pos.z);
						sp54.z = sp6c.x - prop->pos.x;

						value = 1.0f / sqrtf(sp54.f[0] * sp54.f[0] + sp54.f[2] * sp54.f[2]);

						sp54.x *= value;
						sp54.z *= value;

						value = sp60.f[0] * sp54.f[0] + sp60.f[2] * sp54.f[2];

						sp44.x = sp54.x * value + prop->pos.x;
						sp44.y = dstpos->y;
						sp44.z = sp54.z * value + prop->pos.z;

						los_find_intersecting_rooms_exhaustive(&prop->pos, prop->rooms, &sp44, dstrooms, sp84, 20);

#if VERSION < VERSION_NTSC_1_0
						for (l = 0; dstrooms[l] != -1; l++) {
							if (dstrooms[l] == chr->floorroom) {
								dstrooms[0] = chr->floorroom;
								dstrooms[1] = -1;
								break;
							}
						}
#endif

						chr_find_entered_rooms_at_pos(chr, &sp44, dstrooms);

						movex = sp44.x - prop->pos.x;
						movez = sp44.z - prop->pos.z;

						if (movex > halfradius || movez > halfradius || movex < -halfradius || movez < -halfradius) {
							cdresult = cd_test_cylmove_oobfail(&prop->pos, prop->rooms, &sp44, dstrooms, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);

							if (cdresult == CDRESULT_NOCOLLISION) {
								cdresult = cd_test_volume_simple(&sp44, radius, dstrooms, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);
							}
						} else {
							cdresult = cd_test_volume_simple(&sp44, radius, sp84, CDTYPE_ALL, CHECKVERTICAL_YES, ymax - prop->pos.y, ymin - prop->pos.y);
						}

						if (cdresult == CDRESULT_NOCOLLISION) {
							dstpos->x = sp44.x;
							dstpos->z = sp44.z;
							chr->invalidmove = 2;
							moveok = true;
						}
					}
				}
			}
		}
	}

	if (!moveok) {
		// Keep chr where they are
		dstpos->x = prop->pos.x;
		dstpos->z = prop->pos.z;
		rooms_copy(prop->rooms, dstrooms);
		chr->invalidmove = 1;
	}

	chr_set_perim_enabled(chr, true);

	if (chair && chair->prop) {
		obj_set_perim_enabled(chair->prop, true);
	}
}

#if VERSION >= VERSION_NTSC_1_0
bool chr_ascend(struct chrdata *chr, struct coord *pos, RoomNum *rooms, f32 amount, bool writerooms)
#else
bool chr_ascend(struct chrdata *chr, struct coord *pos, RoomNum *rooms, f32 amount)
#endif
{
	bool result;
	struct coord newpos;
	RoomNum newrooms[8];
	f32 ymax;
	f32 ymin;
	f32 radius;

	newpos.x = pos->x;
	newpos.y = pos->y + amount;
	newpos.z = pos->z;

	chr_get_bbox(chr->prop, &radius, &ymax, &ymin);
	los_find_final_room_exhaustive(pos, rooms, &newpos, newrooms);
	chr_find_entered_rooms_at_pos(chr, &newpos, newrooms);
	chr_set_perim_enabled(chr, false);
	result = cd_test_volume_simple(&newpos, radius, newrooms, CDTYPE_ALL, CHECKVERTICAL_YES,
			ymax - chr->prop->pos.y,
			ymin - chr->prop->pos.y);
	chr_set_perim_enabled(chr, true);

#if VERSION >= VERSION_NTSC_1_0
	if (result == true && writerooms) {
		pos->y = newpos.y;
		rooms_copy(newrooms, rooms);
	}
#endif

	return result == CDRESULT_NOCOLLISION;
}

bool chr_update_position(struct model *model, struct coord *arg1, struct coord *arg2, f32 *mangroundptr)
{
	struct chrdata *chr = model->chr;
	struct prop *prop = chr->prop;
	struct prop *lift;
	s32 i;
	f32 ground;
	RoomNum spfc[8];
	f32 manground = chr->manground;
	s32 race = CHRRACE(chr);
	f32 yincrement = 0.0f;
	bool inlift;
	u16 floorflags = 0;
#if VERSION >= VERSION_NTSC_1_0
	s32 lvupdate240;
	f32 lvupdate60f;
	f32 lvupdate60freal;
	struct coord spd0;
	RoomNum spc0[8];
#endif

	// NTSC beta reads g_Vars lvupdate properties throughout this function,
	// while NTSC 1.0 and newer copy them into stack variables at the start.
	// A macro is used here for readability
#if VERSION >= VERSION_NTSC_1_0
	lvupdate240 = g_Vars.lvupdate240;
	lvupdate60f = g_Vars.lvupdate60f;
	lvupdate60freal = g_Vars.lvupdate60freal;

#define VAR(property) property
#else
#define VAR(property) g_Vars.property
#endif

	if (g_Anims[model->anim->animnum].flags & ANIMFLAG_ABSOLUTETRANSLATION) {
		if (chr->hidden & CHRHFLAG_FINDROOMSFAST) {
			los_find_final_room_fast(&prop->pos, prop->rooms, arg2, spfc);
		} else {
			los_find_final_room_exhaustive(&prop->pos, prop->rooms, arg2, spfc);
		}

		ground = cd_find_ground_at_cyl_ctfril(arg2, chr->radius, spfc, &chr->floorcol, &chr->floortype, &floorflags, &chr->floorroom, &inlift, &lift);

		if (ground < -1000000) {
			ground = 0.0f;
		}

		chr->ground = ground;
		chr->act_die.timeextra = 0.0f; // @bug? Assuming the actiontype
		chr->fallspeed.x = 0.0f;
		chr->fallspeed.y = 0.0f;
		chr->fallspeed.z = 0.0f;
		chr->manground = ground;
		chr->sumground = ground * (PAL ? 8.4175090789795f : 9.999998f);
		arg2->y -= ground;
	} else {
		arg2->y += manground;

		if (chr->aibot) {
			f32 move[2] = {0, 0};

			if (VAR(lvupdate240) > 0) {
#if VERSION >= VERSION_NTSC_1_0
				if (chr->aibot->forceslowupdates != 0) {
					// forceslowupdates is set when the bot is being saved from
					// falling out of bounds due to high lag. It forces them to
					// update in smaller increments, which gives a higher chance
					// of their collision detection working correctly.
					if (chr->prop->flags & PROPFLAG_ONANYSCREENPREVTICK) {
						chr->aibot->forceslowupdates = 0;
					} else {
						chr->aibot->forceslowupdates--;

						if (lvupdate240 >= 25) {
							lvupdate60f = 4.0f;
							lvupdate60freal = PALUPF(4.0f);
							lvupdate240 = 16;
						}
					}
				} else if (chr->onladder
						&& ((chr->prop->flags & (PROPFLAG_ONANYSCREENTHISTICK | PROPFLAG_ONANYSCREENPREVTICK)) == 0)
						&& lvupdate240 >= 25) {
					lvupdate60f = 4.0f;
					lvupdate60freal = PALUPF(4.0f);
					lvupdate240 = 16;
				}

				bot_update_lateral(chr, move, lvupdate240, lvupdate60freal);
#else
				bot_update_lateral(chr, move);
#endif
			}

			arg2->x = arg1->x + move[0];
			arg2->z = arg1->z + move[1];
		}

		if (chr->actiontype == ACT_PATROL || chr->actiontype == ACT_GOPOS) {
			chr->onladder = cd_find_ladder(&chr->prop->pos, chr->radius * 2.5f,
					chr->manground + chr->height - chr->prop->pos.y,
					chr->manground + 1.0f - chr->prop->pos.y,
					chr->prop->rooms, GEOFLAG_LADDER, &chr->laddernormal);
		} else {
			chr->onladder = false;
		}

		if (chr->aibot != NULL) {
			chr->height = 185.0f;

			if (chr->actiontype == ACT_GOPOS && (chr->act_gopos.flags & GOPOSFLAG_DUCK)) {
				chr->height = 135.0f;
			} else if (chr->actiontype == ACT_GOPOS && (chr->act_gopos.flags & GOPOSFLAG_CROUCH)) {
				chr->height = 90.0f;
			} else if (is_cyl_touching_tile_with_flags(&chr->prop->pos, chr->radius * 1.1f,
						chr->manground + 185.0f - chr->prop->pos.y,
						chr->manground - 10.0f - chr->prop->pos.y,
						chr->prop->rooms, GEOFLAG_AIBOTDUCK)) {
				chr->height = 135.0f;
			} else if (is_cyl_touching_tile_with_flags(&chr->prop->pos, chr->radius * 1.1f,
						chr->manground + 135.0f - chr->prop->pos.y,
						chr->manground - 10.0f - chr->prop->pos.y,
						chr->prop->rooms, GEOFLAG_AIBOTCROUCH)) {
				chr->height = 90.0f;
			}

			bmove_dampen_shotspeed(&chr->aibot->shotspeed);

			arg2->x += chr->aibot->shotspeed.x * g_HeadAnims[HEADANIM_MOVING].translateperframe * VAR(lvupdate60freal) * 0.5f;
			arg2->z += chr->aibot->shotspeed.z * g_HeadAnims[HEADANIM_MOVING].translateperframe * VAR(lvupdate60freal) * 0.5f;
		}

		if (chr->actiontype == ACT_DIE && chr->act_die.timeextra > 0.0f) {
			f32 speed = model->anim->playspeed * VAR(lvupdate60f) * (chr->act_die.timeextra - chr->act_die.elapseextra) / chr->act_die.timeextra;

			arg2->x += chr->act_die.extraspeed.x * speed;
			arg2->z += chr->act_die.extraspeed.z * speed;

			yincrement += chr->act_die.extraspeed.y * speed;

			chr->act_die.elapseextra += VAR(lvupdate60f) * model->anim->playspeed;

			if (chr->act_die.elapseextra > chr->act_die.timeextra) {
				chr->act_die.timeextra = 0.0f;
			}
		} else if (chr->timeextra > 0.0f) {
			f32 speed = model->anim->playspeed * VAR(lvupdate60f) * (chr->timeextra - chr->elapseextra) / chr->timeextra;

			arg2->x += chr->extraspeed.x * speed;
			arg2->z += chr->extraspeed.z * speed;

			yincrement += chr->extraspeed.y * speed;

			chr->elapseextra += VAR(lvupdate60f) * model->anim->playspeed;

			if (chr->elapseextra > chr->timeextra) {
				chr->timeextra = 0.0f;
			}
		}

		if (chr->pushspeed[0] != 0.0f || chr->pushspeed[1] != 0.0f) {
			arg2->x += chr->pushspeed[0] * VAR(lvupdate60freal);
			arg2->z += chr->pushspeed[1] * VAR(lvupdate60freal);

			chr->pushspeed[0] *= 0.9f;
			chr->pushspeed[1] *= 0.9f;

			if (chr->pushspeed[0] != 0.0f || chr->pushspeed[1] != 0.0f) {
				f32 pushdist = sqrtf(chr->pushspeed[0] * chr->pushspeed[0] + chr->pushspeed[1] * chr->pushspeed[1]);

				if (pushdist > 0.0f) {
					pushdist = 0.1f * VAR(lvupdate60freal) / pushdist;

					if (pushdist >= 1.0f) {
						chr->pushspeed[0] = 0.0f;
						chr->pushspeed[1] = 0.0f;
					} else {
						chr->pushspeed[0] -= chr->pushspeed[0] * pushdist;
						chr->pushspeed[1] -= chr->pushspeed[1] * pushdist;
					}
				} else {
					chr->pushspeed[0] = 0.0f;
					chr->pushspeed[1] = 0.0f;
				}
			}
		}

		arg2->x += chr->fallspeed.x * VAR(lvupdate60freal);
		arg2->z += chr->fallspeed.z * VAR(lvupdate60freal);

		if (race == RACE_EYESPY) {
			struct eyespy *eyespy = chr_to_eyespy(chr);

			if (eyespy && eyespy->deployed) {
				arg2->x = chr->prop->pos.x;
				arg2->y = chr->prop->pos.y;
				arg2->z = chr->prop->pos.z;
			}
		} else if (chr->actiontype == ACT_SKJUMP
				&& chr->act_skjump.state == SKJUMPSTATE_AIRBORNE
				&& !chr->act_skjump.needsnewanim
				&& g_Vars.lvupdate60 != 0) {
			arg2->x = chr->act_skjump.pos.x;
			yincrement = chr->act_skjump.pos.y;
			arg2->z = chr->act_skjump.pos.z;
		} else if (chr->onladder) {
			f32 dist;
			f32 xdiff = arg2->x - arg1->x;
			f32 zdiff = arg2->z - arg1->z;

			arg2->x = arg1->x;
			arg2->z = arg1->z;

			dist = sqrtf(xdiff * xdiff + zdiff * zdiff);

#if VERSION >= VERSION_NTSC_1_0
			if (dist > 100.0f) {
				dist = 100.0f;
			}
#endif

			yincrement += dist;

			chr->floortype = FLOORTYPE_METAL;
		}

		if (prop->type == PROPTYPE_PLAYER && chr->actiontype == ACT_BONDMULTI) {
			arg2->x = prop->pos.x;
			arg2->z = prop->pos.z;

			rooms_copy(prop->rooms, spfc);

			chr->invalidmove = 0;
			chr->lastmoveok60 = g_Vars.lvframe60;
		} else {
			if (chr->chrflags & CHRCFLAG_HAS_SPECIAL_DEATH_ANIMATION) {
				arg2->x = arg1->x;
				arg2->z = arg1->z;
			}

			chr_calculate_push_pos(chr, arg2, spfc, true);
		}

		if (chr->actiontype == ACT_SKJUMP
				&& chr->act_skjump.state == SKJUMPSTATE_AIRBORNE
				&& !chr->act_skjump.needsnewanim
				&& g_Vars.lvupdate60 != 0) {
#if VERSION >= VERSION_NTSC_1_0
			if (chr_ascend(chr, arg2, spfc, yincrement, true)) {
				chr->manground += yincrement;
			}
#else
			if (chr_ascend(chr, arg2, spfc, yincrement)) {
				chr->manground += yincrement;
				arg2->y += yincrement;
			}
#endif

			chr->sumground = chr->manground * (PAL ? 8.4175090789795f : 9.999998f);
			chr->ground = chr->manground;
			arg2->y -= chr->manground;
		} else {
			struct coord *sp98;
			RoomNum *sp94;
			struct coord sp88;
			RoomNum sp78[8];
			f32 ground;
			struct modelnode *node;
			u16 nodetype;
			f32 fallspeed;
			u8 die;

			if (chr->onladder) {
#if VERSION >= VERSION_NTSC_1_0
				if (chr_ascend(chr, arg2, spfc, yincrement, true)) {
					chr->manground += yincrement;
				}
#else
				if (chr_ascend(chr, arg2, spfc, yincrement)) {
					chr->manground += yincrement;
					arg2->y += yincrement;
				}
#endif

				chr->sumground = chr->manground * (PAL ? 8.4175090789795f : 9.999998f);
				chr->ground = chr->manground;
				arg2->y -= chr->manground;
			} else {
				if (race == RACE_EYESPY) {
					ground = chr->manground;
				} else if (prop->type == PROPTYPE_PLAYER) {
					struct player *player = g_Vars.players[playermgr_get_player_num_by_prop(prop)];
					ground = player->vv_manground;
					chr->floorcol = player->floorcol;
					chr->floortype = player->floortype;
				} else {
					if (arg2->y - manground < 69.0f) {
						sp98 = &sp88;
						sp94 = sp78;

						sp88.x = arg2->x;
						sp88.y = manground + 69.0f;
						sp88.z = arg2->z;

						los_find_final_room_exhaustive(arg2, spfc, &sp88, sp78);
						chr_find_entered_rooms_at_pos(chr, &sp88, sp78);
					} else {
						sp98 = arg2;
						sp94 = spfc;
					}

					ground = cd_find_ground_at_cyl_ctfril(sp98, chr->radius, sp94,
							&chr->floorcol, &chr->floortype, &floorflags, &chr->floorroom, &inlift, &lift);

#if VERSION >= VERSION_NTSC_1_0
					if (chr->aibot
							&& chr->aibot->forceslowupdates == 0
							&& ground < -100000
							&& g_Vars.lvupdate60 >= 5
							&& (chr->prop->flags & PROPFLAG_ONANYSCREENPREVTICK) == 0) {
						// The new position has no ground and is offscreen,
						// So they're about to fall out of the geometry.
						// Run the previous calculations but using their current
						// position instead. This holds them in place.
						chr->aibot->forceslowupdates = 10;

						arg2->x = prop->pos.x;
						arg2->y = prop->pos.y;
						arg2->z = prop->pos.z;

						rooms_copy(prop->rooms, spfc);

						lvupdate60freal = 0.0f;

						ground = cd_find_ground_at_cyl_ctfril(arg2, chr->radius, spfc,
								&chr->floorcol, &chr->floortype, &floorflags, &chr->floorroom, &inlift, &lift);
					}
#endif

					if (inlift) {
						chr->inlift = true;
						chr->lift = lift;
					} else {
						chr->inlift = false;
						chr->lift = NULL;
					}

					if (ground < -100000) {
						ground = -100000;
					}
				}

				chr->ground = ground;

				if (chr->chrflags & CHRCFLAG_FORCETOGROUND) {
					node = model->definition->rootnode;
					nodetype = (u8)node->type;

					arg2->y += yincrement + chr->ground - manground;

					chr->chrflags &= ~CHRCFLAG_FORCETOGROUND;
					chr->manground = chr->ground;
					chr->sumground = chr->ground * (PAL ? 8.4175090789795f : 9.999998f);

					manground = chr->manground;

					if (nodetype == MODELNODETYPE_CHRINFO) {
						union modelrwdata *rwdata = model_get_node_rw_data(model, node);
						rwdata->chrinfo.unk34.y = rwdata->chrinfo.unk24.y;
					}
				} else {
					if (chr->fallspeed.y != 0.0f || chr->ground < chr->manground) {
						die = false;

						if (prop->type == PROPTYPE_CHR && chr->manground <= -30000) {
							die = true;
						}

						fallspeed = chr->fallspeed.y;

						projectile_update_fall(&yincrement, &fallspeed, VAR(lvupdate60freal));

#if VERSION >= VERSION_NTSC_1_0
						if (chr_ascend(chr, arg2, spfc, yincrement, false))
#else
						if (chr_ascend(chr, arg2, spfc, yincrement))
#endif
						{
							chr->manground += yincrement;
							chr->fallspeed.y = fallspeed;
						}

						if (chr->manground <= chr->ground) {
							chr->manground = chr->ground;
							chr->sumground = chr->ground * (PAL ? 8.4175090789795f : 9.999998f);
							chr->fallspeed.y = 0.0f;

							if (floorflags & GEOFLAG_DIE) {
								die = true;
							}
						}

						if (die) {
							if (chr->aibot) {
								s32 shooter;

								if (chr->lastshooter >= 0 && chr->timeshooter > 0) {
									shooter = chr->lastshooter;
								} else {
									shooter = mp_chr_to_chrindex(chr);
								}

								chr_die(chr, shooter);
							} else {
								chr->hidden |= CHRHFLAG_DELETING;
							}
						}
					} else if (chr->manground <= chr->ground) {
						for (i = 0; i < g_Vars.lvupdate60; i++) {
							chr->sumground = chr->sumground * (PAL ? 0.88120001554489f : 0.9f) + chr->ground;
							chr->fallspeed.x *= (PAL ? 0.88120001554489f : 0.9f);
							chr->fallspeed.z *= (PAL ? 0.88120001554489f : 0.9f);
						}

						chr->manground = chr->sumground * (PAL ? 0.11879998445511f : 0.10000002384186f);

						if (chr->manground < chr->ground - 30.0f) {
							chr->manground = chr->ground - 30.0f;
							chr->sumground = (chr->ground - 30.0f) * (PAL ? 8.4175090789795f : 9.999998f);
						}

						if (chr->fallspeed.x < 0.1f && chr->fallspeed.x > -0.1f) {
							if (chr->fallspeed.z < 0.1f && chr->fallspeed.z > -0.1f) {
								chr->fallspeed.z = 0.0f;
								chr->fallspeed.x = 0.0f;
							}
						}
					}

#if VERSION >= VERSION_NTSC_1_0
					if (manground != chr->manground) {
						spd0.x = arg2->x;
						spd0.y = arg2->y;
						spd0.z = arg2->z;

						rooms_copy(spfc, spc0);

						arg2->y += chr->manground - manground;

						los_find_final_room_exhaustive(&spd0, spc0, arg2, spfc);
						chr_find_entered_rooms_at_pos(chr, arg2, spfc);
					}
#endif
				}

#if VERSION < VERSION_NTSC_1_0
				arg2->y += chr->manground - manground;
#endif
				arg2->y -= chr->manground;
			}
		}
	}

	*mangroundptr = chr->manground;

	prop->pos.x = arg2->x;
	prop->pos.y = arg2->y + chr->manground;
	prop->pos.z = arg2->z;

	if (chr->actiontype == ACT_SKJUMP) {
#if VERSION >= VERSION_NTSC_1_0
		f32 ground;
#endif

		ground = chr->act_skjump.ground;

		if (prop->pos.y < ground) {
			prop->pos.y = ground;
			chr->manground = chr->act_skjump.ground;
			*mangroundptr = chr->act_skjump.ground;
		}
	}

	prop_deregister_rooms(prop);
	rooms_copy(spfc, prop->rooms);

#if VERSION >= VERSION_NTSC_1_0
	if (prop->type == PROPTYPE_CHR) {
		for (i = 0; prop->rooms[i] != -1; i++) {
			if (chr->floorroom == prop->rooms[i]) {
				prop_deregister_rooms(prop);
				prop->rooms[0] = chr->floorroom;
				prop->rooms[1] = -1;
				break;
			}
		}
	}
#endif

	chr_detect_rooms(chr);
	prop_calculate_shade_colour(prop, chr->nextcol, chr->floorcol);

	return true;
}

s32 chrs_get_num_free(void)
{
	s32 count = 0;
	s32 i;

	for (i = 0; i < g_NumChrSlots; i++) {
		if (g_ChrSlots[i].chrnum < 0) {
			count++;
		}
	}

	return count;
}

void chr_set_max_damage(struct chrdata *chr, f32 maxdamage)
{
	chr->maxdamage = maxdamage;
}

f32 chr_get_max_damage(struct chrdata *chr)
{
	return chr->maxdamage;
}

void chr_add_health(struct chrdata *chr, f32 health)
{
	chr->damage -= health;
}

f32 chr_get_armor(struct chrdata *chr)
{
	if (chr->damage < 0) {
		return -chr->damage;
	}

	return 0;
}

s16 chrs_get_next_unused_chrnum(void)
{
	s32 chrnum;
	struct chrdata *chr;

	do {
		chrnum = ++g_NextChrnum;

		if (chrnum > 32767) {
			chrnum = g_NextChrnum = 5000;
		}

		chr = chr_find_by_literal_id((s16)chrnum);
	} while (chr);

	return chrnum;
}

/**
 * Allocate a chr from the pool, set default values, register a chrnum
 * and assign it to the prop.
 */
void chr_allocate(struct prop *prop, u8 *ailist)
{
	s32 i;
	struct chrdata *chr = NULL;

	for (i = 0; i < g_NumChrSlots; i++) {
		if (g_ChrSlots[i].chrnum < 0) {
			chr = &g_ChrSlots[i];
			break;
		}
	}

	prop->chr = chr;
	chr->chrnum = chrs_get_next_unused_chrnum();
	chr_register(chr->chrnum, i);

	chr->headnum = 0;
	chr->bodynum = 0;
	chr->prop = prop;
	chr->model = NULL;
	chr->numarghs = 0;
	chr->lastwalk60 = 0;
	chr->invalidmove = 0;
	chr->lastmoveok60 = g_Vars.lvframe60;
	chr->visionrange = 250;

	if (cheat_is_active(CHEAT_PERFECTDARKNESS)) {
		chr->visionrange = 4;
	}

	chr->shotbondsum = 0;
	chr->damage = 0;
	chr->sumground = 0;
	chr->manground = 0;
	chr->ground = 0;
	chr->fallspeed.x = 0;
	chr->fallspeed.y = 0;
	chr->fallspeed.z = 0;
	chr->prevpos.x = 0;
	chr->prevpos.y = 0;
	chr->prevpos.z = 0;
	chr->hearingscale = 1;
	chr->maxdamage = 4;

	chr->lastseetarget60 = 0;
	chr->lastvisibletarget60 = 0;
	chr->lastheartarget60 = 0;
	chr->numclosearghs = 0;
	chr->shadecol[0] = chr->nextcol[0] = 0xff;
	chr->shadecol[1] = chr->nextcol[1] = 0xff;
	chr->shadecol[2] = chr->nextcol[2] = 0xff;
	chr->shadecol[3] = chr->nextcol[3] = 0xff;
	chr->floorcol = 0x0fff;
	chr->floortype = 0;
	chr->floorroom = -1;
	chr->fadealpha = 0xff;

	chr->chrflags = CHRCFLAG_FORCETOGROUND;
	chr->hidden = 0;
	chr->hidden2 = 0;
	chr->actiontype = ACT_INIT;
	chr->sleep = 0;

	chr->ailist = ailist;
	chr->aioffset = 0;
	chr->aireturnlist = -1;
	chr->aishotlist = -1;
	chr->aipunchdodgelist = -1;
	chr->aishootingatmelist = -1;
	chr->aidarkroomlist = -1;
	chr->aiplayerdeadlist = -1;

	chr->radius = 20;
	chr->height = 185;
	chr->morale = 0;
	chr->alertness = 0;
	chr->flags = 0;
	chr->random = 0;
	chr->timer60 = 0;
	chr->soundtimer = 0;
	chr->soundgap = 0;
	chr->talkgap = 0;
	chr->padpreset1 = -1;
	chr->proppreset1 = -1;
	chr->chrseeshot = -1;
	chr->chrseedie = -1;
	chr->chrpreset1 = -1;
	chr->chrdup = -1;
	chr->firecount[0] = 0;
	chr->firecount[1] = 0;

	chr->darkroomthing = 0;
	chr->playerdeadthing = 0;
	chr->unk32c_12 = 0;

	chr->grenadeprob = 0;
	chr->accuracyrating = 0;
	chr->speedrating = 0;
	chr->arghrating = 0;
	chr->dodgerating = 0;
	chr->unarmeddodgerating = 0;
	chr->maxdodgerating = 0;
	chr->flinchcnt = -1;
	chr->aimendcount = 0;
	chr->weapons_held[0] = NULL;
	chr->weapons_held[1] = NULL;
	chr->weapons_held[2] = NULL;
	chr->gunprop = NULL;
	chr->fireslots[0] = -1;
	chr->fireslots[1] = -1;

	chr->aimuplshoulder = 0;
	chr->aimuprshoulder = 0;
	chr->aimupback = 0;
	chr->aimsideback = 0;
	chr->aimendlshoulder = 0;
	chr->aimendrshoulder = 0;
	chr->aimendback = 0;
	chr->aimendsideback = 0;

	if (g_Vars.currentplayer->prop == NULL) {
		chr->target = -2;
	} else {
		chr->target = g_Vars.currentplayer->prop - g_Vars.props;
	}

	chr->path = -1;
	chr->team = TEAM_01;
	chr_set_shield(chr, 0);
	chr->cmnum = 0;
	chr->cmnum2 = 0;
	chr->cmnum3 = 0;
	chr->cmnum4 = 0;
	chr->cmcount = random() % 300;
	chr->footstep = 0;
	chr->magicanim = -1;
	chr->cover = -1;
	chr->bdstart = 0;
	chr->oldframe = 0;
	chr->magicframe = 0;
	chr->magicspeed = VERSION >= VERSION_PAL_BETA ? 1 : 0.25;

	i = 0;

	while (i != 60) {
		chr->bdlist[i++] = 0;
	}

	chr->talktimer = TICKS(3600);
	chr->cloakfadefrac = 0;
	chr->cloakfadefinished = false;
	chr->inlift = false;
	chr->targetlastseenp.x = 0;
	chr->targetlastseenp.y = 0;
	chr->targetlastseenp.z = 0;
	chr->myaction = MA_NONE;
	chr->orders = MA_NONE;
	chr->squadron = 0;
	chr->listening = 0;
	chr->convtalk = 0;
	chr->question = 0;
	chr->runfrompos.x = 0;
	chr->runfrompos.y = 0;
	chr->runfrompos.z = 0;
	chr->oldrooms[0] = -1;
	chr->aibot = NULL;
	chr->blurdrugamount = 0;
	chr->drugheadsway = 0;
	chr->drugheadcount = 0;
	chr->blurnumtimesdied = 0;
	chr->cloakpause = 0;
	chr->timeextra = 0;
	chr->elapseextra = 0;
	chr->extraspeed.x = 0;
	chr->extraspeed.y = 0;
	chr->extraspeed.z = 0;
	chr->hitpart = 0;
	chr->voicebox = 0;
	chr->pushspeed[0] = 0;
	chr->pushspeed[1] = 0;
	chr->gunroty[0] = 0;
	chr->gunrotx[0] = 0;
	chr->gunroty[1] = 0;
	chr->gunrotx[1] = 0;
	chr->unk348[0] = 0;
	chr->unk348[1] = 0;
	chr->onladder = 0;
	chr->laddernormal.x = 0;
	chr->laddernormal.y = 0;
	chr->laddernormal.z = 0;
	chr->liftaction = 0;
	chr->lift = NULL;
	chr->pouncebits = 0;
	chr->specialdie = 0;
	chr->roomtosearch = 0;
	chr->propsoundcount = 0;
	chr->patrolnextstep = -1;
	chr->p1p2 = g_Vars.bondplayernum;
	chr->lastattacker = NULL;
	chr->race = RACE_HUMAN;
	chr->aimtesttimer60 = random() % TICKS(30);
	chr->lastfootsample = 0;
	chr->poisoncounter = 0;
	chr->poisonprop = NULL;
	chr->lastshooter = -1;
	chr->timeshooter = 0;
	chr->noblood = false;
	chr->rtracked = false;

#if VERSION >= VERSION_NTSC_1_0
	chr->goposhitcount = 0;
#endif

	splat_reset_chr(chr);
}

/**
 * Place the chr in the stage at the given position.
 * Allocate a chr struct if the prop doesn't have one yet.
 */
struct prop *chr_place(struct prop *prop, struct model *model,
		struct coord *pos, RoomNum *rooms, f32 faceangle, u8 *ailist)
{
	struct chrdata *chr;
	struct coord testpos;
	f32 ground;
	u32 nodetype;

	prop->type = PROPTYPE_CHR;

	if (prop->chr == NULL) {
		chr_allocate(prop, ailist);
	}

	chr = prop->chr;

	model_set_anim70(model, chr_update_position);
	model->chr = chr;
	model->unk01 = 1;
	chr->model = model;
	chr_set_theta(chr, faceangle);
	model_set_anim_play_speed(model, PALUPF(g_ChrsAnimSpeed), 0);

	testpos.x = pos->x;
	testpos.y = pos->y + 100;
	testpos.z = pos->z;

	chr->ground = chr->manground = ground = cd_find_ground_at_cyl_ctfril(&testpos, chr->radius, rooms, &chr->floorcol, &chr->floortype, NULL, &chr->floorroom, NULL, NULL);

	chr->sumground = ground * (PAL ? 8.4175090789795f : 9.999998f);

	prop->pos.x = testpos.x;
	prop->pos.y = ground + 100;
	prop->pos.z = testpos.z;

	prop_deregister_rooms(prop);
	rooms_copy(rooms, prop->rooms);
	chr_detect_rooms(chr);
	model_set_root_position(model, &prop->pos);

	nodetype = chr->model->definition->rootnode->type;

	if ((nodetype & 0xff) == MODELNODETYPE_CHRINFO) {
		union modelrwdata *rwdata = model_get_node_rw_data(chr->model, chr->model->definition->rootnode);
		rwdata->chrinfo.ground = ground;
	}

	chr->prevpos.x = prop->pos.x;
	chr->prevpos.y = prop->pos.y;
	chr->prevpos.z = prop->pos.z;

	prop_calculate_shade_colour(prop, chr->nextcol, chr->floorcol);

	return prop;
}

struct prop *chr_create_with_model(struct model *model, struct coord *pos, RoomNum *rooms, f32 faceangle, u8 *ailist)
{
	struct prop *prop = prop_allocate();

	if (prop) {
		prop = chr_place(prop, model, pos, rooms, faceangle, ailist);

		if (cheat_is_active(CHEAT_ENEMYSHIELDS)) {
			chr_set_shield(prop->chr, 8);
		}
	}

	return prop;
}

/**
 * Removes a chr. If free is true, free the chr.
 */
void chr_remove(struct prop *prop, bool free)
{
	struct chrdata *chr = prop->chr;
	struct model *model = chr->model;
	struct defaultobj *eyespyobj = NULL;
	struct prop *child;
	u32 stack[2];

	bgun_free_fireslot_wrapper(chr->fireslots[0]);
	bgun_free_fireslot_wrapper(chr->fireslots[1]);

	if (chr->proppreset1 >= 0) {
		struct prop *proppreset = &g_Vars.props[chr->proppreset1];
		struct defaultobj *chair = proppreset->obj;
		chair->hidden &= ~OBJHFLAG_OCCUPIEDCHAIR;
	}

	wallhit_fade_splats_for_removed_chr(prop);
	ps_stop_sound(prop, PSTYPE_GENERAL, 0xffff);
	shieldhits_remove_by_prop(prop);
	model_free_vtxstores(VTXSTORETYPE_CHRVTX, model);
	prop_deregister_rooms(prop);

	if (g_Vars.stagenum == STAGE_CITRAINING) {
		eyespyobj = obj_find_by_tag_id(0x26);
	}

	child = prop->child;

	while (child) {
		struct defaultobj *obj = child->obj;
		struct prop *next = child->next;

		if ((obj->hidden & OBJHFLAG_HASTEXTOVERRIDE) == 0
				&& obj != eyespyobj
				&& (prop->type != PROPTYPE_PLAYER || (obj->flags3 & OBJFLAG3_PLAYERUNDROPPABLE) == 0)) {
			obj_detach(child);
			obj_free_permanently(obj, true);
		}

		child = next;
	}

	modelmgr_free_model(model);
	chr->model = NULL;

	if (free) {
		chr_deregister(chr->chrnum);

		if (chr->cover != -1) {
			cover_set_in_use(chr->cover, false);
			chr->cover = -1;
		}

		chr_clear_references(prop - g_Vars.props);
		projectiles_unref_owner(prop);

		if (g_Vars.normmplayerisrunning == false && g_MissionConfig.iscoop) {
			s32 i;

			for (i = 0; i < g_Vars.numaibuddies && i < ARRAYCOUNT(g_Vars.aibuddies); i++) {
				if (g_Vars.aibuddies[i] == prop) {
					g_Vars.aibuddies[i] = NULL;
				}
			}
		}

		chr->chrnum = -1;

		rebuild_teams();
		rebuild_squadrons();
	}
}

void chr_clear_references(s32 propnum)
{
	s32 i;
	s32 j;
	struct prop *prop = &g_Vars.props[propnum];

	for (i = 0; i < g_NumChrSlots; i++) {
		if (g_ChrSlots[i].target == propnum) {
			if (prop_get_index_by_chr_id(&g_ChrSlots[i], g_ChrSlots[i].chrpreset1) == propnum) {
				g_ChrSlots[i].chrpreset1 = -1;
			}

			g_ChrSlots[i].target = -1;
		}
	}

	for (i = 0; i < PLAYERCOUNT(); i++) {
		if (g_Vars.players[i]->lookingatprop.prop == prop) {
			g_Vars.players[i]->lookingatprop.prop = NULL;
		}

		for (j = 0; j != 4; j++) {
			if (g_Vars.players[i]->trackedprops[j].prop == prop) {
				g_Vars.players[i]->trackedprops[j].prop = NULL;
			}
		}
	}
}

/**
 * For the fast animation cheat from GE.
 *
 * The cheat doesn't exist in PD, but the functions are still here.
 * These functions are not called.
 */
void chrs_set_anim_speed(f32 speed)
{
	s32 i;

	g_ChrsAnimSpeed = speed;

	for (i = 0; i < g_NumChrSlots; i++) {
		if (g_ChrSlots[i].model) {
			model_set_anim_play_speed(g_ChrSlots[i].model, PALUPF(g_ChrsAnimSpeed), 600);
		}
	}
}

f32 chrs_get_anim_speed(void)
{
	return g_ChrsAnimSpeed;
}

/**
 * Tween the chr's aim properties towards their aimend properties.
 */
void chr_tween_aim(struct chrdata *chr)
{
	if (chr->aimendcount >= 2) {
		f32 mult = g_Vars.lvupdate60f / chr->aimendcount;

		if (mult > 1) {
			mult = 1;
		}

		chr->aimuplshoulder += (chr->aimendlshoulder - chr->aimuplshoulder) * mult;
		chr->aimuprshoulder += (chr->aimendrshoulder - chr->aimuprshoulder) * mult;
		chr->aimupback += (chr->aimendback - chr->aimupback) * mult;
		chr->aimsideback += (chr->aimendsideback - chr->aimsideback) * mult;

		chr->aimendcount -= g_Vars.lvupdate60;
	} else {
		chr->aimuplshoulder = chr->aimendlshoulder;
		chr->aimuprshoulder = chr->aimendrshoulder;
		chr->aimupback = chr->aimendback;
		chr->aimsideback = chr->aimendsideback;
	}
}

void chr_flinch_body(struct chrdata *chr)
{
	if (chr->actiontype != ACT_DEAD && chr->flinchcnt < 0) {
		chr->flinchcnt = 1;
		chr->hidden2 &= 0x0fff;
		chr->hidden2 |= (u16)(random() << 13);
	}
}

void chr_flinch_head(struct chrdata *chr, f32 arg1)
{
	s32 value;

	if (chr->flinchcnt < 0) {
		chr->flinchcnt = 1;
	} else if (chr->flinchcnt > 8) {
		chr->flinchcnt = 4;
	}

	chr->hidden2 &= 0x0fff;
	chr->hidden2 |= CHRH2FLAG_HEADSHOTTED;
	value = (arg1 + BADDTOR(22.5f)) * 8.0f / BADDTOR(360);

	if (value < 0) {
		value = 0;
	}

	if (value > 7) {
		value = 7;
	}

	chr->hidden2 |= value << 13;
}

f32 chr_get_flinch_amount(struct chrdata *chr)
{
	f32 value = chr->flinchcnt;

	if (chr->hidden2 & CHRH2FLAG_HEADSHOTTED) {
		if (value < 4) {
			value = sinf(value * BADDTOR(90) / 4);
		} else {
			value = 1 - sinf((value - 4) * (PAL ? RAD(4, 0.07478791475296f) : RAD(3, 0.060405626893044f)));
		}
	} else {
		if (value < TICKS(10)) {
			value = sinf(value * BADDTOR(90) / TICKS(10));
		} else {
			value = 1 - sinf((value - TICKS(10)) * (PAL ? RAD(6, 0.098159141838551f) : RAD(4, 0.078527316451073f)));
		}
	}

	return value;
}

/**
 * This is a callback function that is called by model code after the model's
 * animation has done its positioning. It allows tweaks to be made to the model
 * at particular joints such as changing the angle and scale.
 *
 * The function is called multiple times per model per frame, with the joint
 * argument changing each time.
 *
 * This function implements the following features:
 * - Chicago robot gun angles
 * - DK mode
 * - Head flinching when shot
 * - Body flinching when shot
 * - Chrs aiming up, down, left and right
 */
void chr_handle_joint_positioned(s32 joint, Mtxf *mtx)
{
	f32 scale = 1.0f;
	s32 lshoulderjoint;
	s32 rshoulderjoint;
	s32 waistjoint;
	s32 neckjoint;
	struct coord sp138;
	Mtxf spf8;
	Mtxf spb8;
	f32 gunroty;
	f32 gunrotx;
	f32 theta;
	f32 gunrot;

	// chr is facing into the Z axis
	f32 xrot; // eg. bending over or nodding head
	f32 yrot; // eg. twist left/right or shaking head
	f32 zrot; // eg. cartwheeling

	if (g_CurModelChr->model->definition->skel == &g_SkelRobot) {
		// Handle Chicago robot guns
		theta = chr_get_theta(g_CurModelChr);

		if (joint == 1) {
			gunrotx = g_CurModelChr->gunrotx[0];
			gunroty = g_CurModelChr->gunroty[0];
		} else if (joint == 2) {
			gunrotx = g_CurModelChr->gunrotx[1];
			gunroty = g_CurModelChr->gunroty[1];
		} else {
			return;
		}

		mtx00015be0(cam_get_projection_mtxf(), mtx);

		sp138.x = mtx->m[3][0];
		sp138.y = mtx->m[3][1];
		sp138.z = mtx->m[3][2];

		mtx->m[3][0] = 0.0f;
		mtx->m[3][1] = 0.0f;
		mtx->m[3][2] = 0.0f;

		if (gunrotx < 0.0f) {
			gunrotx += BADDTOR(360);
		}

		if (gunroty < 0.0f) {
			gunroty += BADDTOR(360);
		}

		gunrot = BADDTOR(360) - theta + DTOR(90);

		if (gunrot >= BADDTOR(360)) {
			gunrot -= BADDTOR(360);
		}

		mtx4_load_y_rotation(gunrot, &spb8);
		mtx00015be0(&spb8, mtx);
		mtx4_load_x_rotation(gunrotx, &spf8);
		mtx00015be0(&spf8, mtx);

		gunrot = gunroty + theta;

		if (gunrot >= BADDTOR(360)) {
			gunrot -= BADDTOR(360);
		}

		mtx4_load_y_rotation(gunrot, &spb8);
		mtx00015be0(&spb8, mtx);

		if (scale != 1.0f) {
			mtx00015f04(scale, mtx);
		}

		mtx->m[3][0] = sp138.x;
		mtx->m[3][1] = sp138.y;
		mtx->m[3][2] = sp138.z;

		mtx00015be0(cam_get_world_to_screen_mtxf(), mtx);
	} else {
		if (g_CurModelChr->model->definition->skel == &g_SkelChr) {
			lshoulderjoint = 2;
			rshoulderjoint = 3;
			waistjoint = 1;
			neckjoint = 0;
		} else if (g_CurModelChr->model->definition->skel == &g_SkelSkedar) {
			lshoulderjoint = 3;
			rshoulderjoint = 4;
			waistjoint = 2;
			neckjoint = 1;
		} else {
			lshoulderjoint = -1;
			rshoulderjoint = -1;
			waistjoint = -1;
			neckjoint = -1;
		}

		if (cheat_is_active(CHEAT_DKMODE) && CHRRACE(g_CurModelChr) == RACE_HUMAN) {
			if (joint == neckjoint) {
				scale = 4.0f;
			} else if (joint == lshoulderjoint || joint == rshoulderjoint) {
				scale = 2.5f;
			}
		}

		if (joint == lshoulderjoint || joint == rshoulderjoint || joint == waistjoint || joint == neckjoint) {
			xrot = 0.0f;
			yrot = 0.0f;
			zrot = 0.0f;

			// Apply rotation based on chr's aiming properties
			if (joint == rshoulderjoint) {
				xrot = g_CurModelChr->aimuprshoulder;
			} else if (joint == lshoulderjoint) {
				xrot = g_CurModelChr->aimuplshoulder;
			} else if (joint == waistjoint) {
				// Up/down at the waist
				xrot = g_CurModelChr->aimupback;

				if (g_CurModelChr->hidden2 & CHRH2FLAG_AUTOANIM) {
					if (xrot > BADDTOR(60)) {
						xrot -= BADDTOR(60);
					} else if (xrot < BADDTOR(-50)) {
						xrot += BADDTOR(50);
					} else {
						xrot = 0.0f;
					}
				}

				// Left/right at the waist
				yrot = g_CurModelChr->aimsideback;

				if (g_CurModelChr->aibot) {
					yrot += g_CurModelChr->aibot->angleoffset;
				} else if (g_CurModelChr->prop->type == PROPTYPE_PLAYER) {
					yrot += g_Vars.players[playermgr_get_player_num_by_prop(g_CurModelChr->prop)]->angleoffset;
				}
			} else if (joint == neckjoint) {
				// Head up/down
				if (g_CurModelChr->hidden2 & CHRH2FLAG_AUTOANIM) {
					xrot = g_CurModelChr->aimupback;

					if (xrot > BADDTOR(60)) {
						xrot = BADDTOR(60);
					} else if (xrot < BADDTOR(-50)) {
						xrot = BADDTOR(-50);
					}
				} else if (g_CurModelChr->model->anim->flip) {
					xrot = g_CurModelChr->aimuplshoulder;
				} else {
					xrot = g_CurModelChr->aimuprshoulder;
				}

				// Apply head bobbing when dizzy
				if (g_CurModelChr->blurdrugamount > TICKS(1000)
						&& g_Vars.tickmode != TICKMODE_CUTSCENE
						&& g_CurModelChr->actiontype != ACT_DEAD
						&& g_CurModelChr->actiontype != ACT_DIE) {
					zrot = BADDTOR4(g_CurModelChr->drugheadsway);
					xrot -= (28.0f - ABS(g_CurModelChr->drugheadsway)) / 250.0f * BADDTOR(360);
				}
			}

			// Apply flinch when chr is shot
			if (g_CurModelChr->flinchcnt >= 0
					&& (CHRRACE(g_CurModelChr) == RACE_HUMAN || CHRRACE(g_CurModelChr) == RACE_SKEDAR)) {
				bool isskedar = CHRRACE(g_CurModelChr) == RACE_SKEDAR;

				if (g_CurModelChr->hidden2 & CHRH2FLAG_HEADSHOTTED) {
					if (joint == neckjoint) {
						f32 flinchamount = chr_get_flinch_amount(g_CurModelChr);
						s32 flinchtype = (g_CurModelChr->hidden2 >> 13) & 7;
						f32 degrees = isskedar ? 25.0f : 60.0f;

						if ((flinchtype & 1) == 0) {
							degrees = isskedar ? 37.5f : 85.0f;
						}

						if (flinchtype >= 5 && flinchtype < 8) {
							zrot -= flinchamount * (M_BADTAU * degrees / 360.0f);
						} else if (flinchtype > 0 && flinchtype < 4) {
							zrot += flinchamount * (M_BADTAU * degrees / 360.0f);
						}

						if (flinchtype == 7 || flinchtype == 0 || flinchtype == 1) {
							xrot += flinchamount * (M_BADTAU * degrees / 360.0f);
						} else if (flinchtype >= 3 && flinchtype < 6) {
							xrot -= flinchamount * (M_BADTAU * degrees / 360.0f);
						}
					}
				} else if (joint == rshoulderjoint || joint == lshoulderjoint) {
					s32 flinchtype = (g_CurModelChr->hidden2 >> 13) & 7;
					f32 flinchamount = chr_get_flinch_amount(g_CurModelChr) * BADDTOR(15);

					xrot -= flinchamount;

					if (flinchtype < 3) {
						yrot -= flinchamount;
					} else if (flinchtype >= 3 && flinchtype < 6) {
						yrot += flinchamount;
					}
				} else if (joint == waistjoint) {
					f32 flinchamount;
					s32 flinchtype;

					flinchamount = chr_get_flinch_amount(g_CurModelChr);
					flinchtype = (g_CurModelChr->hidden2 >> 13) & 7;

					xrot += flinchamount * BADDTOR(15);

					if (flinchtype < 3) {
						yrot += flinchamount * BADDTOR(15);
					} else if (flinchtype >= 3 && flinchtype < 6) {
						yrot -= flinchamount * BADDTOR(15);
					}

					if (flinchtype == 2 || flinchtype == 5 || flinchtype == 7) {
						zrot += flinchamount * BADDTOR(10);
					} else if (flinchtype == 1 || flinchtype == 4 || flinchtype == 6) {
						zrot -= flinchamount * BADDTOR(10);
					}
				}
			}

			if (xrot != 0.0f || yrot != 0.0f || zrot != 0.0f || scale != 1.0f) {
				struct coord sp70;
				f32 aimangle;
				Mtxf tmpmtx;

				aimangle = chr_get_aimx_angle(g_CurModelChr);

				if (xrot < 0.0f) {
					xrot = -xrot;
				} else {
					xrot = BADDTOR(360) - xrot;
				}

				if (yrot < 0.0f) {
					yrot += BADDTOR(360);
				}

				mtx00015be0(cam_get_projection_mtxf(), mtx);

				sp70.x = mtx->m[3][0];
				sp70.y = mtx->m[3][1];
				sp70.z = mtx->m[3][2];

				mtx->m[3][0] = 0.0f;
				mtx->m[3][1] = 0.0f;
				mtx->m[3][2] = 0.0f;

				if (xrot != 0.0f || zrot != 0.0f) {
					yrot -= aimangle;

					if (yrot < 0.0f) {
						yrot += BADDTOR(360);
					}

					mtx4_load_y_rotation(yrot, &tmpmtx);
					mtx00015be0(&tmpmtx, mtx);

					if (xrot != 0.0f) {
						mtx4_load_x_rotation(xrot, &tmpmtx);
						mtx00015be0(&tmpmtx, mtx);
					}

					if (zrot != 0.0f) {
						mtx4_load_z_rotation(zrot, &tmpmtx);
						mtx00015be0(&tmpmtx, mtx);
					}

					mtx4_load_y_rotation(aimangle, &tmpmtx);
					mtx00015be0(&tmpmtx, mtx);
				} else {
					mtx4_load_y_rotation(yrot, &tmpmtx);
					mtx00015be0(&tmpmtx, mtx);
				}

				if (scale != 1.0f) {
					mtx00015f04(scale, mtx);
				}

				mtx->m[3][0] = sp70.x;
				mtx->m[3][1] = sp70.y;
				mtx->m[3][2] = sp70.z;

				mtx00015be0(cam_get_world_to_screen_mtxf(), mtx);
			}
		}
	}
}

void chr_find_entered_rooms_at_pos(struct chrdata *chr, struct coord *pos, RoomNum *rooms)
{
	struct coord lower;
	struct coord upper;
	f32 height = 110;

	if (
#if VERSION >= VERSION_NTSC_1_0
			chr && chr->race == RACE_EYESPY
#else
			chr->race == RACE_EYESPY
#endif
			) {
		struct eyespy *eyespy = chr_to_eyespy(chr);

		if (eyespy) {
			height = eyespy->height + 30.0f;
		} else {
			height = 230;
		}
	}

	lower.x = pos->x - 50.0f;
	lower.y = pos->y - height;
	lower.z = pos->z - 50.0f;

	upper.x = pos->x + 50.0f;
	upper.y = pos->y + height;
	upper.z = pos->z + 50.0f;

	bg_find_entered_rooms(&lower, &upper, rooms, 7, true);
}

void chr_find_entered_rooms(struct chrdata *chr, RoomNum *room)
{
	chr_find_entered_rooms_at_pos(chr, &chr->prop->pos, room);
}

void chr_detect_rooms(struct chrdata *chr)
{
	prop_deregister_rooms(chr->prop);
	chr_find_entered_rooms(chr, chr->prop->rooms);
	prop_register_rooms(chr->prop);
}

void chr_update_anim(struct chrdata *chr, s32 lvupdate240, bool arg2)
{
	struct model *model = chr->model;

	if (g_Vars.tickmode == TICKMODE_CUTSCENE) {
		if (chr->prop->type == PROPTYPE_PLAYER) {
			chr->hidden &= ~CHRHFLAG_00000800;
		}

		if (model->anim
				&& (g_Anims[model->anim->animnum].flags & ANIMFLAG_ABSOLUTETRANSLATION)
				&& lvupdate240 > 0
				&& g_Vars.cutsceneskip60ths > 0) {
			lvupdate240 += g_Vars.cutsceneskip60ths * 4;
		}
	}

	if (chr->chrflags & CHRCFLAG_DELAYANIM) {
		chr->chrflags &= ~CHRCFLAG_DELAYANIM;
	} else if (arg2) {
		if ((chr->hidden & CHRHFLAG_00000800) == 0) {
			model_get_root_position(model, &chr->prevpos);
			model_tick_anim_quarter_speed(model, lvupdate240, true);
			model_update_info(model);
		}
	} else {
		model_tick_anim_quarter_speed(model, lvupdate240, false);
	}
}

void chr_tick_child(struct chrdata *chr, struct prop *prop, bool fulltick)
{
	struct defaultobj *obj = prop->obj;
	struct model *model = obj->model;
	struct prop *child;
	struct prop *next;

	if (obj->hidden & OBJHFLAG_DELETING) {
		obj_free(obj, true, obj->hidden2 & OBJH2FLAG_CANREGEN);
		return;
	}

	if (model->attachedtomodel && model->attachedtonode
			&& (obj->hidden & OBJHFLAG_GONE) == 0
			&& (obj->flags2 & OBJFLAG2_INVISIBLE) == 0) {
		Mtxf *mtx0 = model_find_node_mtx(model->attachedtomodel, model->attachedtonode, 0);
		struct modelrenderdata renderdata = { NULL, true, MODELRENDERFLAG_DEFAULT };
		u32 stack;
		Mtxf rendermtx;
		Mtxf sp40;

		prop->flags |= PROPFLAG_ONTHISSCREENTHISTICK | PROPFLAG_ONANYSCREENTHISTICK;

		if (obj->hidden & OBJHFLAG_EMBEDDED) {
			mtx00015be4(mtx0, &obj->embedment->matrix, &rendermtx);
			renderdata.rendermtx = &rendermtx;
		} else if (CHRRACE(chr) == RACE_SKEDAR) {
			// The skedar hand position is rotated weirdly, so compensate for it
			mtx4_load_y_rotation(BADDTOR(75.6), &rendermtx);
			mtx4_load_z_rotation(BADDTOR(90.0), &sp40);
			mtx4_mult_mtx4_in_place(&sp40, &rendermtx);
			mtx4_mult_mtx4_in_place(mtx0, &rendermtx);
			renderdata.rendermtx = &rendermtx;
		} else if (prop == chr->weapons_held[HAND_LEFT]) {
			// Flip the model
			mtx4_load_z_rotation(BADDTOR(180), &rendermtx);
			mtx4_mult_mtx4_in_place(mtx0, &rendermtx);
			renderdata.rendermtx = &rendermtx;
		} else {
			renderdata.rendermtx = mtx0;
		}

		renderdata.matrices = gfx_allocate(model->definition->nummatrices * sizeof(Mtxf));
		model_set_matrices(&renderdata, model);

		obj_child_tick_player(prop, fulltick);

		child = prop->child;

		while (child) {
			if (prop);
			if (prop);

			next = child->next;
			chr_tick_child(chr, child, fulltick);
			child = next;
		}
	} else {
		prop->flags &= ~PROPFLAG_ONTHISSCREENTHISTICK;

		obj_child_tick_player(prop, fulltick);

		child = prop->child;

		while (child) {
			next = child->next;
			obj_child_tick_player_offscreen(child, fulltick);
			child = next;
		}
	}
}

void chr_cloak(struct chrdata *chr, bool value)
{
	if (!chr_is_dead(chr)) {
		chr->hidden |= CHRHFLAG_CLOAKED;

		if (value) {
			ps_create(0, chr->prop, SFXNUM_005B_CLOAK_ON, -1, -1, 0, 0, PSTYPE_NONE, 0, -1, 0, -1, -1, -1, -1);
		}
	}
}

void chr_uncloak(struct chrdata *chr, bool value)
{
	if (chr->hidden & CHRHFLAG_CLOAKED) {
		chr->hidden &= ~CHRHFLAG_CLOAKED;

		if (value) {
			ps_create(0, chr->prop, SFXNUM_005C_CLOAK_OFF, -1, -1, 0, 0, PSTYPE_NONE, 0, -1, 0, -1, -1, -1, -1);
		}

#if PIRACYCHECKS
		{
			u32 checksum = 0;
			u32 *i = (u32 *)&bot_pickup_prop;
			u32 *end = (u32 *)&bot_test_prop_for_pickup;

			while (i < end) {
				checksum += ~*i;
				i++;
			}

			if (checksum != CHECKSUM_PLACEHOLDER) {
				((u32 *)&cd_return_zero)[-2] = 0;
			}
		}
#endif
	}
}

void chr_uncloak_temporarily(struct chrdata *chr)
{
	chr_uncloak(chr, true);
	chr->cloakpause = TICKS(120);
}

void chr_update_cloak(struct chrdata *chr)
{
	s32 qty;
	s32 ammotype;
	u32 prevplayernum;
	f32 fVar14;
	s32 fadefrac;

	// Decrement cloakpause
	if (chr->cloakpause > 0) {
		chr->cloakpause -= g_Vars.lvupdate60;

		if (chr->cloakpause < 1) {
			chr->cloakpause = 0;
		}
	}

	// Handle ammo decrease and determine if cloak is still enabled
	if (chr->aibot) {
		if (chr->aibot->cloakdeviceenabled) {
			qty = chr->aibot->ammoheld[AMMOTYPE_CLOAK];

			if (qty > 0 && !chr_is_dead(chr)) {
				if (chr->hidden & CHRHFLAG_CLOAKED) {
					qty -= g_Vars.lvupdate60;

					if (qty <= 0) {
						qty = 0;
					}

					chr->aibot->ammoheld[AMMOTYPE_CLOAK] = qty;
				}
			} else {
				chr->aibot->cloakdeviceenabled = false;
			}
		} else if (chr->aibot->rcp120cloakenabled) {
			if (chr->aibot->weaponnum == WEAPON_RCP120
					&& !chr_is_dead(chr)
					&& botact_get_ammo_quantity_by_weapon(chr->aibot, WEAPON_RCP120, 0, 1) > 0) {
				if (chr->hidden & CHRHFLAG_CLOAKED) {
					chr->aibot->rcpcloaktimer60 += LVUPDATE60FREAL() * 0.4f;

					if (chr->aibot->rcpcloaktimer60 >= 1) {
						qty = chr->aibot->rcpcloaktimer60;
						chr->aibot->rcpcloaktimer60 -= qty;

						if (chr->aibot->loadedammo[0] > 0) {
							chr->aibot->loadedammo[0] -= qty;

							if (chr->aibot->loadedammo[0] <= 0) {
								chr->aibot->loadedammo[0] = 0;
							}
						} else {
							ammotype = botact_get_ammo_type_by_function(WEAPON_RCP120, 0);

							if (chr->aibot->ammoheld[ammotype] > 0) {
								chr->aibot->ammoheld[ammotype] -= qty;

								if (chr->aibot->ammoheld[ammotype] <= 0) {
									chr->aibot->ammoheld[ammotype] = 0;
								}
							}
						}
					}
				}
			} else {
				chr->aibot->rcp120cloakenabled = false;
			}
		}

		if (chr->aibot->cloakdeviceenabled || chr->aibot->rcp120cloakenabled) {
			if ((chr->hidden & CHRHFLAG_CLOAKED) == 0) {
				if (chr->cloakpause < 1) {
					chr_cloak(chr, true);
				}
			}
		} else if (chr->hidden & CHRHFLAG_CLOAKED) {
			chr_uncloak(chr, true);
		}
	} else if (chr->prop->type == PROPTYPE_PLAYER) {
		prevplayernum = g_Vars.currentplayernum;
		set_current_player_num(playermgr_get_player_num_by_prop(chr->prop));

		if (g_Vars.currentplayer->devicesactive & DEVICE_CLOAKDEVICE) {
			// Cloak is active - but may or may not be in effect due to recent shooting
			s32 qty = bgun_get_reserved_ammo_count(AMMOTYPE_CLOAK);

			if (qty > 0) {
				if (chr->hidden & CHRHFLAG_CLOAKED) {
					// Cloak is effective
					qty -= g_Vars.lvupdate60;

					if (qty < 1) {
						qty = 0;
					}

					bgun_set_ammo_quantity(AMMOTYPE_CLOAK, qty);
				}
			} else {
				// Out of cloak ammo - turn off cloak
				g_Vars.currentplayer->devicesactive &= ~DEVICE_CLOAKDEVICE;
			}
		}

		// If cloak is enabled via cloaking device or via RCP120
		if ((g_Vars.currentplayer->devicesactive & DEVICE_CLOAKDEVICE)
				|| (g_Vars.currentplayer->gunctrl.weaponnum == WEAPON_RCP120
					&& (g_Vars.currentplayer->devicesactive & DEVICE_CLOAKRCP120))) {
			if ((chr->hidden & CHRHFLAG_CLOAKED) == 0 && chr->cloakpause < 1) {
				chr_cloak(chr, true);
			}
		} else {
			if ((g_Vars.currentplayer->devicesactive & DEVICE_CLOAKDEVICE) == false
					&& (chr->hidden & CHRHFLAG_CLOAKED)) {
				chr_uncloak(chr, true);
			}
		}

		set_current_player_num(prevplayernum);
	}

	// Update cloakfade
	if (chr->hidden & CHRHFLAG_CLOAKED) {
		if (chr->cloakfadefinished == false) {
			fadefrac = chr->cloakfadefrac + (g_Vars.lvupdate240 * 5) / 8;

			if (fadefrac >= 128) {
				chr->cloakfadefinished = true;
				chr->cloakfadefrac = 0;
			} else {
				chr->cloakfadefrac = fadefrac;
			}
		} else {
			s32 tmp = chr->cloakfadefrac + g_Vars.lvupdate60;
			chr->cloakfadefrac = tmp % 127;
		}
	} else {
		if (chr->cloakfadefinished == true) {
			chr->cloakfadefinished = false;

			fVar14 = 1.0f - cosf((chr->cloakfadefrac / 127.0f + chr->cloakfadefrac / 127.0f) * DTOR(180));
			chr->cloakfadefrac = (254 - (s32)(fVar14 * 20.0f * 0.5f)) / 2;
		}

		if (chr->cloakfadefrac > 0) {
			fadefrac = chr->cloakfadefrac - (g_Vars.lvupdate240 * 5) / 8;

			if (fadefrac < 0) {
				fadefrac = 0;
			}

			chr->cloakfadefrac = fadefrac;
		}
	}
}

s32 chr_get_cloak_alpha(struct chrdata *chr)
{
	s32 alpha = 255;

	if (chr->cloakfadefrac > 0 || chr->cloakfadefinished == true) {
		if (!chr->cloakfadefinished) {
			alpha = 255 - chr->cloakfadefrac * 2;
		} else {
			f32 fVar3 = (f32)cosf((chr->cloakfadefrac / 127.0f + chr->cloakfadefrac / 127.0f) * DTOR(180));
			alpha = (1.0f - fVar3) * 20.0f * 0.5f;
		}

		if (alpha == 0) {
			alpha = 1;
		}
	}

	return alpha;
}

void chr_set_poisoned(struct chrdata *chr, struct prop *poisonprop)
{
	if (chr->actiontype != ACT_DEAD
			&& chr->actiontype != ACT_DIE
			&& chr->prop->type == PROPTYPE_PLAYER) {
		// This was probably used in a debug print
		playermgr_get_player_num_by_prop(chr->prop);
	}

	if (g_Vars.normmplayerisrunning) {
		chr->poisonprop = poisonprop;
		chr->poisoncounter += TICKS(3360);
	} else if (chr->poisoncounter == 0) {
		chr->poisoncounter = TICKS(1680);
		chr->poisonprop = poisonprop;
	}
}

void chr_tick_poisoned(struct chrdata *chr)
{
	if (chr->poisoncounter > 0) {
		struct coord coord = {0, 0, 0};

		struct gset gset = { WEAPON_COMBATKNIFE, 0, 0, FUNC_POISON };

		if (chr->actiontype == ACT_DEAD || chr->actiontype == ACT_DIE) {
			// Dying chr
			if (!g_Vars.normmplayerisrunning) {
				chr->poisoncounter = 0;
			} else {
				if (chr->poisoncounter > TICKS(3600)) {
					chr->poisoncounter = TICKS(3600);
				}

				if (g_MpSetup.options & MPOPTION_ONEHITKILLS) {
					chr->poisoncounter = 0;
				}
			}
		} else if (chr->prop->type == PROPTYPE_PLAYER
				&& g_Vars.players[playermgr_get_player_num_by_prop(chr->prop)]->bondhealth < 0.001f) {
			// Player who's alive but on almost zero health
			if (g_Vars.normmplayerisrunning) {
				if (chr->poisoncounter > TICKS(3600)) {
					chr->poisoncounter = TICKS(3600);
				}

				if (g_MpSetup.options & MPOPTION_ONEHITKILLS) {
					chr->poisoncounter = 0;
				}
			}
		} else {
			// Alive chr
			chr->poisoncounter -= g_Vars.lvupdate240;

			if (chr->poisoncounter <= 0) {
				if (!g_Vars.normmplayerisrunning) {
					chr_damage_by_dizziness(chr, 100, &coord, &gset, chr->poisonprop);
					chr_flinch_head(chr, DTOR(180));
				}

				chr->poisoncounter = 0;
			} else if (chr->poisoncounter < TICKS(1680)) {
				chr->blurdrugamount += g_Vars.lvupdate240 * 10;
			}

			if (g_Vars.normmplayerisrunning) {
				if (chr->poisoncounter / TICKS(720) != (chr->poisoncounter + g_Vars.lvupdate240) / TICKS(720)) {
					chr_damage_by_dizziness(chr, 1.3f, &coord, &gset, chr->poisonprop);
				}
			}
		}
	}
}

f32 var800629e8 = 1;
u32 var800629ec = 0x00000000;
u32 var800629f0 = 0x00000000;
u32 var800629f4 = 0x00000000;
u32 var800629f8 = 0x00000000;

bool chr_tick_beams(struct prop *prop)
{
	struct chrdata *chr = prop->chr;

	if (chr->fireslots[0] >= 0) {
		beam_tick(&g_Fireslots[chr->fireslots[0]].beam);
	}

	if (chr->fireslots[1] >= 0) {
		beam_tick(&g_Fireslots[chr->fireslots[1]].beam);
	}

	if (chr->aibot && chr->aibot->fadeintimer60 > 0) {
		if (chr->aibot->fadeintimer60 > g_Vars.lvupdate60) {
			chr->aibot->fadeintimer60 -= g_Vars.lvupdate60;
		} else {
			chr->aibot->fadeintimer60 = 0;
		}
	}

	return false;
}

/**
 * Tick the given chr.
 *
 * This function is called once per player per frame. The first time it is
 * called per frame a "fulltick" is done. On consecutive calls for this tick
 * much of the logic is skipped, and only the logic specific to the current
 * player is executed.
 */
s32 chr_tick(struct prop *prop)
{
	struct modelrenderdata renderdata = { NULL, true, MODELRENDERFLAG_DEFAULT };
	struct chrdata *chr = prop->chr;
	struct model *model = chr->model;
	bool needsupdate;
	bool hatvisible = true;
	s32 lvupdate240 = g_Vars.lvupdate240;
	struct prop *child;
	struct prop *next;
	bool fulltick = false;
	s32 race = CHRRACE(chr);
	s32 sp1e8;
	Mtxf rendermtx;
	s32 sp1a4;
	bool isrepeatframe;
	bool isrepeatframe2;
	struct coord sp190;
	f32 angle;
	struct player *player;
	struct coord sp17c;
	f32 sp178;
	struct hoverbikeobj *bike;
	u8 stack[0x28];

	if (prop->flags & PROPFLAG_NOTYETTICKED) {
		fulltick = true;
		prop->flags &= ~PROPFLAG_NOTYETTICKED;
	}

	if (fulltick) {
#if VERSION >= VERSION_NTSC_1_0
		if (chr->goposhitcount > 0 && (chr->hidden & CHRHFLAG_BLOCKINGDOOR) == 0) {
			chr->goposhitcount--;
		}
#endif

		if (g_Vars.in_cutscene) {
			chr->drugheadcount = 0;
			chr->drugheadsway = 0;
		} else if (chr->blurdrugamount > TICKS(1000) && chr->actiontype != ACT_DRUGGEDKO) {
			chr->drugheadcount += g_Vars.lvupdate240 >> 1;
			chr->drugheadsway = cosf(chr->drugheadcount / 255.0f * BADDTOR(360)) * 20.0f;
		} else if (chr->drugheadsway != 0.0f) {
			chr->drugheadcount = 0;

			if (chr->drugheadsway > 0.0f) {
#if VERSION >= VERSION_PAL_BETA
				chr->drugheadsway -= 0.175f * g_Vars.lvupdate60freal;
#else
				chr->drugheadsway -= 0.04375f * g_Vars.lvupdate240;
#endif

				if (chr->drugheadsway < 0.0f) {
					chr->drugheadsway = 0.0f;
				}
			} else if (chr->drugheadsway < 0.0f) {
#if VERSION >= VERSION_PAL_BETA
				chr->drugheadsway += 0.175f * g_Vars.lvupdate60freal;
#else
				chr->drugheadsway += 0.04375f * g_Vars.lvupdate240;
#endif

				if (chr->drugheadsway > 0.0f) {
					chr->drugheadsway = 0.0f;
				}
			}
		}

		chr_update_cloak(chr);
		chr_tick_poisoned(chr);

		if ((chr->chrflags & CHRCFLAG_HIDDEN) == 0 || (chr->chrflags & CHRCFLAG_NEVERSLEEP)) {
			if (g_ChrsAnimDebugSetAll) {
				if (anim_has_frames(g_ChrsAnimDebugAnimNum)) {
					if (model_get_anim_num(model) != g_ChrsAnimDebugAnimNum || !anim_has_frames(model_get_anim_num(model))) {
						model_set_animation(model, g_ChrsAnimDebugAnimNum, 0, 0.0f, 0.5f, 0.0f);
					}
				}
			} else {
				chra_tick(chr);

				if (chr->model == NULL) {
					return TICKOP_FREE;
				}
			}

			if (g_ChrsAnimDebugPaused) {
				lvupdate240 = 0;

				if (g_ChrsAnimDebugSlow) {
					lvupdate240 = 1;
				}
			}
		}

		if (chr->hidden & CHRHFLAG_DELETING) {
			if (chr->hidden & CHRHFLAG_DROPPINGITEM) {
				obj_drop_recursively(prop, true);
			}

			chr_remove(prop, true);
			return TICKOP_FREE;
		}
	}

	if (race == RACE_EYESPY) {
		struct eyespy *eyespy = chr_to_eyespy(chr);

		if (eyespy && eyespy->deployed) {
			if (eyespy == g_Vars.currentplayer->eyespy && eyespy->active) {
				needsupdate = false;
			} else {
				needsupdate = pos_is_onscreen(prop, &prop->pos, model_get_effective_scale(model), true);
			}

			if (fulltick) {
				chr_update_anim(chr, lvupdate240, true);
			}
		} else {
			needsupdate = false;
		}
	} else if (chr->chrflags & CHRCFLAG_HIDDEN) {
		needsupdate = false;
	} else if ((chr->chrflags & CHRCFLAG_UNPLAYABLE)
			|| (prop->type == PROPTYPE_PLAYER
				&& g_Vars.currentplayer == (player = g_Vars.players[playermgr_get_player_num_by_prop(prop)])
				&& player->cameramode == CAMERAMODE_THIRDPERSON
				&& player->visionmode != VISIONMODE_SLAYERROCKET)) {
		// Cutscene chr?
		isrepeatframe = false;

		if (fulltick) {
			model->anim->average = false;

			if (chr->actiontype == ACT_ANIM && !chr->act_anim.movewheninvis && chr->act_anim.lockpos) {
				chr_update_anim(chr, lvupdate240, false);
			} else {
				chr_update_anim(chr, lvupdate240, true);
			}
		}

		if (chr->model && chr->model->anim && (g_Anims[chr->model->anim->animnum].flags & ANIMFLAG_HASREPEATFRAMES)) {
			anim_load_header(chr->model->anim->animnum);

			isrepeatframe = anim_get_remapped_frame(chr->model->anim->animnum, chr->model->anim->framea) < 0
				|| (anim_get_remapped_frame(chr->model->anim->animnum, chr->model->anim->frameb) < 0
						&& chr->model->anim->frac != 0.0f);
		}

		if (isrepeatframe) {
			needsupdate = false;
		} else {
			needsupdate = pos_is_in_draw_distance(&prop->pos);
		}
	} else if (chr->actiontype == ACT_PATROL || chr->actiontype == ACT_GOPOS) {
		if ((chr->actiontype == ACT_PATROL && chr->act_patrol.waydata.mode == WAYMODE_MAGIC)
				|| (chr->actiontype == ACT_GOPOS && chr->act_gopos.waydata.mode == WAYMODE_MAGIC)) {
			needsupdate = pos_is_onscreen(prop, &prop->pos, model_get_effective_scale(model), true);

			if (needsupdate) {
				model->anim->average = false;
				model_get_root_position(model, &chr->prevpos);
				model_update_info(model);
			}
		} else {
			if (fulltick) {
				chr_update_anim(chr, lvupdate240, true);
			}

			needsupdate = pos_is_onscreen(prop, &prop->pos, model_get_effective_scale(model), true);

			if (needsupdate) {
				if (chr->actiontype == ACT_PATROL) {
					chr->act_patrol.waydata.lastvisible60 = g_Vars.lvframe60;
				} else if (chr->actiontype == ACT_GOPOS) {
					chr->act_gopos.waydata.lastvisible60 = g_Vars.lvframe60;
				}
			}

			model->anim->average = !needsupdate
				&& !((prop->flags & (PROPFLAG_ONANYSCREENTHISTICK | PROPFLAG_ONANYSCREENPREVTICK)) != 0);
		}
	} else if (chr->actiontype == ACT_ANIM && !chr->act_anim.movewheninvis) {
		needsupdate = pos_is_onscreen(prop, &prop->pos, model_get_effective_scale(model), true);

		if (fulltick) {
			model->anim->average = false;

			if (needsupdate && !chr->act_anim.lockpos) {
				chr_update_anim(chr, lvupdate240, true);
			} else {
				chr_update_anim(chr, lvupdate240, false);
			}
		}
	} else if (chr->actiontype == ACT_STAND) {
		model->anim->average = false;

		if (chr->chrflags & CHRCFLAG_FORCETOGROUND) {
			chr_update_anim(chr, lvupdate240, true);
			needsupdate = pos_is_onscreen(prop, &prop->pos, model_get_effective_scale(model), true);
		} else {
			needsupdate = pos_is_onscreen(prop, &prop->pos, model_get_effective_scale(model), true);

			if (g_Vars.mplayerisrunning) {
				if (fulltick) {
					if (g_Vars.coopplayernum >= 0 || g_Vars.antiplayernum >= 0) {
						if (needsupdate) {
							chr_update_anim(chr, lvupdate240, true);
						} else if (model->anim->animnum2 != 0) {
							chr_update_anim(chr, lvupdate240, false);
						}
					} else {
						chr_update_anim(chr, lvupdate240, true);
					}
				}
			} else if (needsupdate) {
				if (chr->act_stand.playwalkanim == true) {
					chr_update_anim(chr, lvupdate240, false);
				} else {
					chr_update_anim(chr, lvupdate240, true);
				}
			} else if (model->anim->animnum2 != 0) {
				chr_update_anim(chr, lvupdate240, false);
			}
		}
	} else if (chr->actiontype == ACT_DEAD) {
		needsupdate = pos_is_onscreen(prop, &prop->pos, model_get_effective_scale(model), true);
	} else if (prop->type == PROPTYPE_PLAYER
			&& (g_Vars.mplayerisrunning
				|| (player = g_Vars.players[playermgr_get_player_num_by_prop(prop)], player->cameramode == CAMERAMODE_EYESPY)
				|| (player->cameramode == CAMERAMODE_THIRDPERSON && player->visionmode == VISIONMODE_SLAYERROCKET))) {
		model->anim->average = false;
		chr_update_anim(chr, lvupdate240, true);
		needsupdate = pos_is_onscreen(prop, &prop->pos, model_get_effective_scale(model), true);
	} else {
		isrepeatframe2 = false;

		if (fulltick) {
			model->anim->average = false;
			chr_update_anim(chr, lvupdate240, true);
		}

		if (chr->model && chr->model->anim && (g_Anims[chr->model->anim->animnum].flags & ANIMFLAG_HASREPEATFRAMES)) {
			anim_load_header(chr->model->anim->animnum);

			isrepeatframe2 = anim_get_remapped_frame(chr->model->anim->animnum, chr->model->anim->framea) < 0
				|| (anim_get_remapped_frame(chr->model->anim->animnum, chr->model->anim->frameb) < 0
						&& chr->model->anim->frac != 0.0f);
		}

		if (isrepeatframe2) {
			needsupdate = false;
		} else {
			needsupdate = pos_is_onscreen(prop, &prop->pos, model_get_effective_scale(model), true);
		}
	}

	if (fulltick) {
		if (chr->actiontype != ACT_STAND || model->anim->animnum2 != 0 || prop->type == PROPTYPE_PLAYER) {
#if VERSION >= VERSION_NTSC_1_0
			chr->hidden2 |= CHRH2FLAG_CONSIDERPROXIES;
#else
			chr->hidden |= CHRHFLAG_CONSIDERPROXIES;
#endif
		}

		chr_tween_aim(chr);
	}

	if (prop->pos.y < -65536) {
		needsupdate = false;
	}

#if VERSION >= VERSION_NTSC_1_0
	if (!g_Vars.normmplayerisrunning && needsupdate) {
		if (chr->actiontype == ACT_DEAD
				|| (chr->actiontype == ACT_DRUGGEDKO && (chr->chrflags & CHRCFLAG_KEEPCORPSEKO) == 0)) {
			var8009cdac++;

			if (var8009cdac > 10) {
				needsupdate = false;
				chr_drop_items_for_owner_reap(chr);
				chr->hidden |= CHRHFLAG_DELETING;
			}
		} else {
			var8009cdb0++;
		}

		if (var8009cdb0 + var8009cdac > 30) {
			needsupdate = false;
		}
	}
#endif

	if (needsupdate) {
#ifdef DEBUG
		debug0f1199f0nb();
#endif

		prop->flags |= PROPFLAG_ONTHISSCREENTHISTICK | PROPFLAG_ONANYSCREENTHISTICK;
		chr->chrflags |= CHRCFLAG_EVERONSCREEN;

		if (g_Vars.antiplayernum >= 0 && g_Vars.currentplayer == g_Vars.bond) {
			chr->hidden |= CHRHFLAG_ONBONDSSCREEN;
		}

		if (cheat_is_active(CHEAT_DKMODE)) {
			model_set_distance_scale(0.3125f);
		}

		g_ModelJointPositionedFunc = &chr_handle_joint_positioned;
		g_CurModelChr = chr;

		if (CHRRACE(chr) == RACE_DRCAROLL && g_Vars.tickmode != TICKMODE_CUTSCENE) {
			angle = chr_get_theta(chr);

			sp190.x = sinf(angle) * 19;
			sp190.y = 0.0f;
			sp190.z = cosf(angle) * 19;

			mtx4_load_translation(&sp190, &rendermtx);
			mtx4_mult_mtx4_in_place(cam_get_world_to_screen_mtxf(), &rendermtx);
			renderdata.rendermtx = &rendermtx;
		} else if (prop->type == PROPTYPE_PLAYER) {
			u8 stack[0x14];
			f32 sp130;
			player = g_Vars.players[playermgr_get_player_num_by_prop(prop)];

			if (player->bondmovemode == MOVEMODE_BIKE) {
				sp178 = chr_get_theta(chr);
				bike = (struct hoverbikeobj *)player->hoverbike->obj;
				sp130 = bike->w * 1000;

				sp17c.x = cosf(sp178) * sp130;
				sp17c.y = ABS(bike->w) * 200 + 25;
				sp17c.z = sinf(-sp178) * sp130;

				mtx4_load_translation(&sp17c, &rendermtx);
				mtx4_mult_mtx4_in_place(cam_get_world_to_screen_mtxf(), &rendermtx);
				renderdata.rendermtx = &rendermtx;
			} else {
				renderdata.rendermtx = cam_get_world_to_screen_mtxf();
			}
		} else {
			renderdata.rendermtx = cam_get_world_to_screen_mtxf();
		}

		renderdata.matrices = gfx_allocate(model->definition->nummatrices * sizeof(Mtxf));

		if (fulltick && g_CurModelChr->flinchcnt >= 0) {
			g_CurModelChr->flinchcnt += g_Vars.lvupdate60;

			if (g_CurModelChr->flinchcnt >= (PAL ? 24 : 30)) {
				g_CurModelChr->flinchcnt = -1;
			}
		}

		{
			f32 limit;
			struct anim *anim;
			struct coord *campos = &g_Vars.currentplayer->cam_pos;
			f32 xdiff;
			f32 ydiff;
			f32 zdiff;
			f32 sp114 = cam_get_lod_scale_z();
			bool restore = false;
			f32 prevfrac;
			s32 prevframea;
			f32 prevfrac2;
			s32 prevframe2a;

			if (g_Vars.normmplayerisrunning) {
				if (g_MpSetup.options & (MPOPTION_SLOWMOTION_ON | MPOPTION_SLOWMOTION_SMART)) {
					limit = 2000 * 2000;
				} else {
					limit = 700 * 700;
				}
			} else {
				if (debug_get_slow_motion() != SLOWMOTION_OFF) {
					limit = 2000 * 2000;
				} else {
					limit = 700 * 700;
				}
			}

			anim = model->anim;

			if (anim && anim->animnum != 0) {
				xdiff = prop->pos.x - campos->x;
				ydiff = prop->pos.y - campos->y;
				zdiff = prop->pos.z - campos->z;

				if ((xdiff * xdiff + ydiff * ydiff + zdiff * zdiff) * sp114 * sp114 > limit) {
					prevfrac = anim->frac;
					prevframea = anim->framea;
					prevfrac2 = anim->frac2;
					prevframe2a = anim->frame2a;
					restore = true;

					if (anim->frac != 0 && anim->speed * anim->playspeed >= 0.25f) {
						if (anim->frac > 0.5f) {
							anim->framea = anim->frameb;
						}

						anim->frac = 0;
					}

					if (anim->fracmerge != 0 && anim->speed2 * anim->playspeed >= 0.25f && anim->frac2 != 0) {
						if (anim->frac2 > 0.5f) {
							anim->frame2a = anim->frame2b;
						}

						anim->frac2 = 0;
					}
				}
			}

			model_set_matrices_with_anim(&renderdata, model);

			if (restore) {
				anim->frac = prevfrac;
				anim->framea = prevframea;
				anim->frac2 = prevfrac2;
				anim->frame2a = prevframe2a;
			}

			g_ModelJointPositionedFunc = NULL;
			model_set_distance_scale(var800629e8);

			if (fulltick) {
				colour_tween(chr->shadecol, chr->nextcol);
			}

			prop->z = model_get_screen_distance(model);
			child = prop->child;

			while (child) {
				next = child->next;
				chr_tick_child(chr, child, fulltick);
				child = next;
			}

			if (chr->weapons_held[2] != NULL) {
				s32 index;
				struct defaultobj *obj = chr->weapons_held[2]->obj;
				struct model *hatmodel = obj->model;

				if (chr->headnum >= HEAD_SHAUN && chr->headnum <= HEAD_SHAUN) {
					struct coord hatpos = {0, 0, 0};
					f32 spe4;
					f32 spe0;
					f32 spdc;
					Mtxf sp9c;
					Mtxf sp5c;
					s32 hattype = hat_get_type(chr->weapons_held[2]);
					u8 stack[0x0c];

					index = chr->headnum - HEAD_SHAUN;

					hatpos.x = var8007dae4[index][hattype].x * 21.3f;
					hatpos.y = var8007dae4[index][hattype].y * 21.3f;
					hatpos.z = var8007dae4[index][hattype].z * 21.3f;

					spe4 = var8007dae4[index][hattype].unk0c;
					spe0 = var8007dae4[index][hattype].unk10;
					spdc = var8007dae4[index][hattype].unk14;

					mtx4_load_translation(&hatpos, &sp9c);
					mtx00015e24(spe4, &sp9c);
					mtx00015e80(spe0, &sp9c);
					mtx00015edc(spdc, &sp9c);
					mtx00015be4(hatmodel->matrices, &sp9c, &sp5c);
					mtx4_copy(&sp5c, hatmodel->matrices);

					if (hattype == HATTYPE_2) {
						hatvisible = false;
					}
				}
			}

			if (model->definition->skel == &g_SkelChr) {
				struct modelnode *headspotnode = model_get_part(model->definition, MODELPART_CHR_HEADSPOT);

				if (headspotnode && headspotnode->type == MODELNODETYPE_HEADSPOT) {
					union modelrwdata *rwdata = model_get_node_rw_data(model, headspotnode);

					if (rwdata->headspot.headmodeldef != NULL) {
						struct modelnode *hatnode = model_get_part(rwdata->headspot.headmodeldef, MODELPART_HEAD_HAT);

						if (hatnode != NULL) {
							union modelrwdata *hatrwdata = model_get_node_rw_data(model, hatnode);
							hatrwdata->toggle.visible = hatvisible;
						}
					}
				}
			}
		}
	} else {
		// Offscreen
		prop->flags &= ~PROPFLAG_ONTHISSCREENTHISTICK;

		if (g_Vars.antiplayernum >= 0 && g_Vars.currentplayer == g_Vars.bond) {
			chr->hidden &= ~CHRHFLAG_ONBONDSSCREEN;
		}

		child = prop->child;

		while (child) {
			next = child->next;
			obj_child_tick_player_offscreen(child, fulltick);
			child = next;
		}

		chr->shadecol[0] = chr->nextcol[0];
		chr->shadecol[1] = chr->nextcol[1];
		chr->shadecol[2] = chr->nextcol[2];
		chr->shadecol[3] = chr->nextcol[3];
	}

	if (fulltick && (chr->chrflags & CHRCFLAG_HIDDEN) == 0) {
		if (chr->hidden & CHRHFLAG_DROPPINGITEM) {
			obj_drop_recursively(prop, false);
			chr->hidden &= ~CHRHFLAG_DROPPINGITEM;
		}

		chr_tick_shots(chr);
	}

	return TICKOP_NONE;
}

void chr_drop_concealed_items(struct chrdata *chr)
{
	struct prop *prop = chr->prop->child;

	while (prop) {
		if (prop != chr->weapons_held[2]
				&& prop != chr->weapons_held[1]
				&& prop != chr->weapons_held[0]
				&& (prop->obj->hidden & OBJHFLAG_EMBEDDED) == 0
				&& (prop->obj->flags & OBJFLAG_AIUNDROPPABLE) == 0) {
			obj_set_dropped(prop, DROPTYPE_DEFAULT);
		}

		prop = prop->next;
	}

	chr->hidden |= CHRHFLAG_DROPPINGITEM;
}

void chr_set_hudpiece_visible(struct chrdata *chr, bool visible)
{
	struct modeldef *modeldef = chr->model->definition;

	if (modeldef->skel == &g_SkelChr) {
		struct modelnode *headspotnode = model_get_part(modeldef, MODELPART_CHR_HEADSPOT);

		if (headspotnode && headspotnode->type == MODELNODETYPE_HEADSPOT) {
			union modelrwdata *rwdata = model_get_node_rw_data(chr->model, headspotnode);

			if (rwdata->headspot.headmodeldef) {
				struct modelnode *hudpiecenode = model_get_part(rwdata->headspot.headmodeldef, MODELPART_HEAD_HUDPIECE);

				if (hudpiecenode) {
					union modelrwdata *rwdata2 = model_get_node_rw_data(chr->model, hudpiecenode);
					rwdata2->toggle.visible = visible;
				}
			}
		}
	}
}

void chr_drop_items_for_owner_reap(struct chrdata *chr)
{
	struct prop *prop = chr->prop->child;

	while (prop)  {
		// If prop is not hat
		if (prop != chr->weapons_held[2]) {
			struct defaultobj *obj = prop->obj;

			if ((obj->flags & OBJFLAG_AIUNDROPPABLE) == 0) {
				obj_set_dropped(prop, DROPTYPE_OWNERREAP);
			}
		}

		prop = prop->next;
	}

	chr->hidden |= CHRHFLAG_DROPPINGITEM;
}

u8 g_ChrBloodColour[] = { 0x40, 0x0a, 0x0a };

void chrs_set_blood_colour(u8 *rgb)
{
	g_ChrBloodColour[0] = rgb[0];
	g_ChrBloodColour[1] = rgb[1];
	g_ChrBloodColour[2] = rgb[2];
}

void chrs_get_blood_colour(u8 *rgb)
{
	rgb[0] = g_ChrBloodColour[0];
	rgb[1] = g_ChrBloodColour[1];
	rgb[2] = g_ChrBloodColour[2];
}

void chrs_reset_onscreen_doors(void)
{
	g_ChrsNumOnscreenDoors = 0;
}

bool chr_find_onscreen_doors(struct chrdata *chr)
{
	s16 *propnumptr;
	s16 propnums[256];
	s32 i;
	struct onscreendoor *osd;
	struct coord *campos;
	bool result = false;

	for (i = 0; i < g_ChrsNumOnscreenDoors; i++) {
		g_ChrsOnscreenDoors[i].unk004 = false;
	}

	room_get_props(chr->prop->rooms, propnums, 256);
	propnumptr = propnums;

	while (*propnumptr >= 0) {
		struct prop *prop = &g_Vars.props[*propnumptr];

		if (prop->type == PROPTYPE_DOOR) {
			if (prop->flags & PROPFLAG_ONTHISSCREENTHISTICK) {
				struct defaultobj *obj = prop->obj;
				struct doorobj *door = prop->door;
				struct coord pos;

				if (obj->model->definition->skel != &g_SkelWindowedDoor
						&& door->doortype != DOORTYPE_EYE
						&& door->doortype != DOORTYPE_IRIS
						&& door->doortype != DOORTYPE_FALLAWAY
						&& door->doortype != DOORTYPE_AZTECCHAIR
						&& (obj->flags & (OBJFLAG_00000010 | OBJFLAG_AISEETHROUGH)) == 0
						&& (obj->flags2 & OBJFLAG2_DOOR_ALTCOORDSYSTEM) == 0
						&& !((door->doorflags & DOORFLAG_TRANSLATION) == 0 && door->frac > 0)) {
					for (i = 0; i < g_ChrsNumOnscreenDoors; i++) {
						if (g_ChrsOnscreenDoors[i].prop == prop) {
							break;
						}
					}

					if (i < g_ChrsNumOnscreenDoors) {
						osd = &g_ChrsOnscreenDoors[i];
					} else {
						if (g_ChrsNumOnscreenDoors > 14) {
							goto next;
						}

						osd = &g_ChrsOnscreenDoors[g_ChrsNumOnscreenDoors];
						osd->prop = prop;
						osd->unk00c = 0;
						osd->unk130 = 0;
						osd->unk004 = 0;

						g_ChrsNumOnscreenDoors++;
					}

					if (!osd->unk00c) {
						struct modelrodata_bbox *bbox = obj_find_bbox_rodata(obj);
						osd->bbox = *bbox;

						mtx3_to_mtx4(obj->realrot, &osd->unk02c);
						mtx4_set_translation(&obj->prop->pos, &osd->unk02c);
						mtx000172f0(osd->unk02c.m, osd->unk06c.m);

						campos = &g_Vars.currentplayer->cam_pos;

						osd->unk12c = (
								+ osd->unk06c.m[0][2] * campos->f[0]
								+ osd->unk06c.m[1][2] * campos->f[1]
								+ osd->unk06c.m[2][2] * campos->f[2]) + osd->unk06c.m[3][2];

						mtx00015be4(&osd->unk06c, cam_get_projection_mtxf(), &osd->unk0ac);
						osd->unk00c = true;
					}

					model_get_root_position(chr->model, &pos);

					osd->unk008 = (
							osd->unk06c.m[0][2] * pos.f[0] +
							osd->unk06c.m[1][2] * pos.f[1] +
							osd->unk06c.m[2][2] * pos.f[2]) + osd->unk06c.m[3][2];

					if ((osd->unk008 > osd->bbox.zmax && osd->unk12c < osd->bbox.zmin)
							|| (osd->unk008 < osd->bbox.zmin && osd->unk12c > osd->bbox.zmax)) {
						osd->unk004 = true;
						result = true;
					}
				}
			}
		}

next:
		propnumptr++;
	}

	return result;
}

bool chr_should_render_gundl(struct model *model, struct modelnode *node)
{
	struct model *rootmodel;
	struct modelnode *bboxnode;
	f32 value;
	struct doorobj *door;
	struct modelrodata_bbox *bbox;
	struct onscreendoor *osd;
	s32 i;
	s32 j;
	bool done;
	Mtxf spb4;
	s32 spb0;
	struct chrdata *chr;
	struct coord spa0;
	struct coord sp94;
	struct coord sp88;
	f32 sp80[2];
	Mtxf *mtx;
	struct coord sp70;
	struct coord sp64;

	rootmodel = model;

	while (rootmodel->attachedtonode && rootmodel->attachedtomodel) {
		rootmodel = rootmodel->attachedtomodel;
	}

	chr = rootmodel->chr;

	if (chr) {
		bboxnode = node;

		while (bboxnode) {
			if ((bboxnode->type & 0xff) == MODELNODETYPE_BBOX) {
				break;
			}

			bboxnode = bboxnode->parent;
		}

		if (bboxnode) {
			bbox = &bboxnode->rodata->bbox;
			mtx = model_find_node_mtx(model, node, 0);

			for (i = 0; i < g_ChrsNumOnscreenDoors; i++) {
				if (g_ChrsOnscreenDoors[i].unk004) {
					osd = &g_ChrsOnscreenDoors[i];
					done = false;
					spb0 = false;
					door = osd->prop->door;

					mtx00015be4(&osd->unk0ac, mtx, &spb4);

					if (osd->unk130 == 0) {
						if (door->doortype == DOORTYPE_VERTICAL) {
							spa0.x = osd->bbox.xmin;
							spa0.y = osd->bbox.ymin;
							spa0.z = osd->bbox.zmin;

							sp94.x = osd->bbox.xmax;
							sp94.y = osd->bbox.ymin;
							sp94.z = osd->bbox.zmin;

							sp88.x = osd->bbox.xmax;
							sp88.y = osd->bbox.ymax;
							sp88.z = osd->bbox.zmin;
						} else {
							spa0.x = osd->bbox.xmax;
							spa0.y = osd->bbox.ymax;
							spa0.z = osd->bbox.zmin;

							sp94.x = osd->bbox.xmax;
							sp94.y = osd->bbox.ymin;
							sp94.z = osd->bbox.zmin;

							sp88.x = osd->bbox.xmin;
							sp88.y = osd->bbox.ymin;
							sp88.z = osd->bbox.zmin;
						}

						mtx00015be4(cam_get_world_to_screen_mtxf(), &osd->unk02c, &osd->unk0ec);
						mtx4_transform_vec(&osd->unk0ec, &spa0, &sp70);
						cam0f0b4dec(&sp70, osd->unk134);
						mtx4_transform_vec(&osd->unk0ec, &sp94, &sp70);
						cam0f0b4dec(&sp70, osd->unk13c);
						mtx4_transform_vec(&osd->unk0ec, &sp88, &sp70);
						cam0f0b4dec(&sp70, osd->unk144);

						osd->unk130 = 1;
						osd->unk14c = osd->unk13c[1] - osd->unk134[1];
						osd->unk150 = -(osd->unk13c[0] - osd->unk134[0]);
						osd->unk154 = osd->unk14c * osd->unk134[0] + osd->unk150 * osd->unk134[1];
						osd->unk158 = osd->unk14c * osd->unk144[0] + osd->unk150 * osd->unk144[1] - osd->unk154;
					}

					for (j = 0; j < 8; j++) {
						switch (j) {
						case 0:
							sp64.x = bbox->xmin;
							sp64.y = bbox->ymin;
							sp64.z = bbox->zmin;
							break;
						case 1:
							sp64.x = bbox->xmin;
							sp64.y = bbox->ymin;
							sp64.z = bbox->zmax;
							break;
						case 2:
							sp64.x = bbox->xmin;
							sp64.y = bbox->ymax;
							sp64.z = bbox->zmin;
							break;
						case 3:
							sp64.x = bbox->xmin;
							sp64.y = bbox->ymax;
							sp64.z = bbox->zmax;
							break;
						case 4:
							sp64.x = bbox->xmax;
							sp64.y = bbox->ymin;
							sp64.z = bbox->zmin;
							break;
						case 5:
							sp64.x = bbox->xmax;
							sp64.y = bbox->ymin;
							sp64.z = bbox->zmax;
							break;
						case 6:
							sp64.x = bbox->xmax;
							sp64.y = bbox->ymax;
							sp64.z = bbox->zmin;
							break;
						case 7:
							sp64.x = bbox->xmax;
							sp64.y = bbox->ymax;
							sp64.z = bbox->zmax;
							break;
						}

						mtx4_transform_vec(mtx, &sp64, &sp70);
						cam0f0b4dec(&sp70, sp80);

						value = osd->unk14c * sp80[0] + osd->unk150 * sp80[1] - osd->unk154;

						if ((osd->unk158 >= 0.0f && value < 0.0f) || (osd->unk158 <= 0.0f && value > 0.0f)) {
							spb0 = true;
							break;
						}

						if (!done) {
							mtx4_transform_vec(&spb4, &sp64, &sp70);

							if (sp70.x >= osd->bbox.xmin
									&& sp70.x <= osd->bbox.xmax
									&& sp70.y >= osd->bbox.ymin
									&& sp70.y <= osd->bbox.ymax
									&& ((osd->bbox.zmax < osd->unk008 && sp70.z < osd->bbox.zmax)
										|| (osd->unk008 < osd->bbox.zmin && osd->bbox.zmin < sp70.z))) {
								done = true;
							}
						}
					}

					if (done && !spb0) {
						return false;
					}
				}
			}
		}
	}

	return true;
}

/**
 * Render an object that's attached to or held by a chr such as their weapon,
 * mines that are stuck to them, and knives/bolts which are embedded in them.
 *
 * This function is recursive. The chr's gun can have mines placed on it, and
 * mines can also have further mines placed on them.
 */
void chr_render_attached_object(struct prop *prop, struct modelrenderdata *renderdata, bool xlupass, struct chrdata *chr)
{
	if (prop->flags & PROPFLAG_ONTHISSCREENTHISTICK) {
		u32 stack;
		struct defaultobj *obj = prop->obj;
		struct model *model = obj->model;
		struct prop *child;

		model_render(renderdata, model);

		// Note: OBJH2FLAG_HASOPA << 1 is OBJH2FLAG_HASXLU
		// so this is just checking if the appropriate flag is enabled
		if (obj->hidden2 & (OBJH2FLAG_HASOPA << xlupass)) {
			renderdata->gdl = wallhit_render_prop_hits(renderdata->gdl, prop, xlupass);
		}

		child = prop->child;

		while (child) {
			chr_render_attached_object(child, renderdata, xlupass, chr);
			child = child->next;
		}

		if (xlupass) {
			mtx_f2l_bulk(model->matrices, model->definition->nummatrices);
		}
	}
}

void chr_get_blood_colour(s16 bodynum, u8 *colour1, u32 *colour2)
{
	switch (bodynum) {
	case BODY_ELVIS1:
	case BODY_THEKING:
	case BODY_ELVISWAISTCOAT:
		if (colour1) {
			colour1[0] = 0x0a;
			colour1[1] = 0x40;
			colour1[2] = 0x0a;
		}
		if (colour2) {
			colour2[0] = 0x103010ff;
			colour2[1] = 0x104010ff;
			colour2[2] = 0x005611a0;
		}
		return;
	case BODY_DRCAROLL:
	case BODY_EYESPY:
	case BODY_CHICROB:
		if (colour1) {
			colour1[0] = 0x0a;
			colour1[1] = 0x0a;
			colour1[2] = 0x0a;
		}
		if (colour2) {
			colour2[0] = 0xb0b030a0;
			colour2[1] = 0xe0e030a0;
			colour2[2] = 0xe0e050a0;
		}
		return;
	case BODY_MRBLONDE:
	case BODY_SKEDAR:
	case BODY_MINISKEDAR:
	case BODY_SKEDARKING:
		if (colour1) {
			colour1[0] = 0x40;
			colour1[1] = 0x19;
			colour1[2] = 0x0a;
		}
		if (colour2) {
			colour2[0] = 0x302010ff;
			colour2[1] = 0x402010ff;
			colour2[2] = 0x560011a0;
		}
		return;
	}

	if (colour1) {
		colour1[0] = 0x40;
		colour1[1] = 0x0a;
		colour1[2] = 0x0a;
	}

	if (colour2) {
		colour2[0] = 0x301010ff;
		colour2[1] = 0x401010ff;
		colour2[2] = 0x560011a0;
	}
}

Gfx *chr_render(struct prop *prop, Gfx *gdl, bool xlupass)
{
	struct chrdata *chr = prop->chr;
	struct model *model = chr->model;
	f32 shadecolourfracs[4];
	s32 shademode;
	s32 flags;
	s32 alpha;
	struct eyespy *eyespy;
	struct prop *child;
	f32 xrayalphafrac;
	u8 spec[4];
	u8 speb = 0;

	// Don't render the eyespy if we're the one controlling it
	if (CHRRACE(chr) == RACE_EYESPY) {
		eyespy = chr_to_eyespy(chr);

		if (eyespy) {
			if (!eyespy->deployed) {
				return gdl;
			}

			if (eyespy == g_Vars.currentplayer->eyespy && eyespy->active) {
				return gdl;
			}
		}
	}

	if (chr->chrflags & CHRCFLAG_UNPLAYABLE) {
		alpha = 0xff;
	} else {
		alpha = chr->fadealpha;
	}

	if (chr->aibot && chr->aibot->fadeintimer60 > 0) {
		alpha = (f32)alpha * (TICKS(120) - chr->aibot->fadeintimer60) * (1.0f / TICKS(120));
	}

	chr_get_blood_colour(chr->bodynum, spec, NULL);
	chrs_set_blood_colour(spec);
	alpha *= obj_calculate_fade_dist_opacity_frac(prop, model_get_effective_scale(model));

	if (g_Vars.currentplayer->visionmode == VISIONMODE_XRAY) {
		f32 fadedist;
		f32 chrdist = sqrtf(ERASERSQDIST(prop->pos.f));

		if (chrdist > g_Vars.currentplayer->eraserpropdist) {
			return gdl;
		}

		alpha = 128;
		fadedist = g_Vars.currentplayer->eraserpropdist - 150;

		if (chrdist > fadedist) {
			alpha = (1.0f - (chrdist - fadedist) / 150.0f) * 128;
		}

		xrayalphafrac = chrdist / g_Vars.currentplayer->eraserpropdist;

		if (xrayalphafrac > 1.0f) {
			xrayalphafrac = 1.0f;
		}
	}

	if (!USINGDEVICE(DEVICE_IRSCANNER)) {
		alpha = chr_get_cloak_alpha(chr) * alpha * 0.0039215688593686f;
	}

	if (alpha < 0xff) {
		if (!xlupass) {
			return gdl;
		}

		flags = MODELRENDERFLAG_OPA | MODELRENDERFLAG_XLU;
	} else {
		if (!xlupass) {
			flags = MODELRENDERFLAG_OPA;
		} else {
			flags = MODELRENDERFLAG_XLU;
		}
	}

	shademode = env_get_obj_shade_mode(prop, shadecolourfracs);

	if (chr->unk32c_18) {
		prop_calculate_shade_colour(chr->prop, chr->nextcol, chr->floorcol);
		chr->unk32c_18 = false;
	}

	if (shademode != SHADEMODE_XLU && alpha > 0) {
		struct modelrenderdata renderdata = { NULL, true, MODELRENDERFLAG_DEFAULT };
		struct screenbox screenbox;
		s32 colour[4]; // rgba levels, but allowing > 256 temporarily
		u32 stack;

		if (xlupass && chr->cloakfadefrac > 0 && !chr->cloakfadefinished) {
			gdl = chr_render_cloak(gdl, chr->prop, chr->prop);
		}

		if (rooms_get_cumulative_screenbox(prop->rooms, &screenbox) > 0 && (chr->chrflags & CHRCFLAG_UNPLAYABLE) == 0) {
			gdl = bg_scissor_within_viewport(gdl, screenbox.xmin, screenbox.ymin, screenbox.xmax, screenbox.ymax);
		} else {
			gdl = bg_scissor_to_viewport(gdl);
		}

		renderdata.flags = flags;
		renderdata.zbufferenabled = true;
		renderdata.gdl = gdl;

		// Configure colours for IR scanner or default
		if (USINGDEVICE(DEVICE_IRSCANNER)) {
			colour[0] = 0xff;
			colour[1] = 0;
			colour[2] = 0;
			colour[3] = 0x80;
		} else {
			colour[0] = chr->shadecol[0];
			colour[1] = chr->shadecol[1];
			colour[2] = chr->shadecol[2];
			colour[3] = chr->shadecol[3];
		}

		if (g_Vars.normmplayerisrunning) {
			speb = scenario_highlight_prop(prop, colour);
		}

		if (!speb) {
			colour[3] = colour[3] - obj_get_brightness(prop, true);

			if (colour[3] > 0xff) {
				colour[3] = 0xff;
			}

			if (colour[3] < 0) {
				colour[3] = 0;
			}
		}

		obj_merge_colour_fracs(colour, shademode, shadecolourfracs);

		// Configure colours for night vision if in use
		if (USINGDEVICE(DEVICE_NIGHTVISION)) {
			colour[0] = g_GogglesChrColourIntensity;
			colour[1] = g_GogglesChrColourIntensity;
			colour[2] = g_GogglesChrColourIntensity;
			colour[3] = g_GogglesChrColourAlpha;
		}

		// Configure colours for xray if in use
		if (g_Vars.currentplayer->visionmode == VISIONMODE_XRAY) {
			colour[g_Vars.currentplayer->epcol_0] = xrayalphafrac * 255;
			colour[g_Vars.currentplayer->epcol_1] = (1 - xrayalphafrac) * 255;
			colour[g_Vars.currentplayer->epcol_2] = 0;
			colour[3] = 0xff;
		}

		renderdata.envcolour = g_ChrBloodColour[0] << 24 | g_ChrBloodColour[1] << 16 | g_ChrBloodColour[2] << 8;
		renderdata.fogcolour = colour[0] << 24 | colour[1] << 16 | colour[2] << 8 | colour[3];

		if (alpha < 0xff) {
			renderdata.context = MODELRENDERCONTEXT_CHR_XLU;
			renderdata.envcolour |= (u8)alpha;
		} else {
			renderdata.context = MODELRENDERCONTEXT_CHR_OPA;
		}

		// Set Skedar eyes open or closed
		if (model->definition->skel == &g_SkelSkedar) {
			struct modelnode *node1 = model_get_part(model->definition, MODELPART_SKEDAR_EYESOPEN);
			struct modelnode *node2 = model_get_part(model->definition, MODELPART_SKEDAR_EYESCLOSED);

			if (node1 && node2) {
				union modelrwdata *data1 = model_get_node_rw_data(model, node1);
				union modelrwdata *data2 = model_get_node_rw_data(model, node2);

				data2->toggle.visible = chr->actiontype == ACT_DIE || chr->actiontype == ACT_DEAD;
				data1->toggle.visible = !data2->toggle.visible;
			}
		}

		// Set Maian eyes open or closed
		if (chr->headnum == HEAD_THEKING
				|| chr->headnum == HEAD_ELVIS
				|| chr->headnum == HEAD_MAIAN_S
				|| chr->headnum == HEAD_ELVIS_GOGS) {
			if (model->definition->skel == &g_SkelChr) {
				struct modelnode *headspotnode = model_get_part(model->definition, MODELPART_CHR_HEADSPOT);

				if (headspotnode && headspotnode->type == MODELNODETYPE_HEADSPOT) {
					union modelrwdata *headrwdata = model_get_node_rw_data(model, headspotnode);

					if (headrwdata->headspot.headmodeldef) {
						struct modelnode *node1 = model_get_part(headrwdata->headspot.headmodeldef, MODELPART_HEAD_EYESOPEN);
						struct modelnode *node2 = model_get_part(headrwdata->headspot.headmodeldef, MODELPART_HEAD_EYESCLOSED);

						if (node1 && node2) {
							union modelrwdata *data1 = model_get_node_rw_data(model, node1);
							union modelrwdata *data2 = model_get_node_rw_data(model, node2);

							data2->toggle.visible = chr->actiontype == ACT_DIE || chr->actiontype == ACT_DEAD;
							data1->toggle.visible = !data2->toggle.visible;
						}
					}
				}
			}
		}

		if (chr->race == RACE_DRCAROLL) {
			chr_set_drcaroll_images(chr, chr->drcarollimage_left, chr->drcarollimage_right);
		}

		g_Vars.currentplayerstats->drawplayercount++;

		if (chr_find_onscreen_doors(chr)) {
			g_ModelShouldRenderGunDlCallback = chr_should_render_gundl;
		}

		// Render the chr's model
		model_render(&renderdata, model);

		// Render attached props (eg. held guns and attached mines/knives/bolts)
		child = prop->child;

		while (child) {
			chr_render_attached_object(child, &renderdata, xlupass, chr);
			child = child->next;
		}

		gdl = renderdata.gdl;

		g_ModelShouldRenderGunDlCallback = NULL;

		// Render shadow
		if (xlupass) {
			if (!chr->onladder && chr->actiontype != ACT_SKJUMP) {
				s32 shadowalpha = 0;

				if (chr->ground == 0) {
					shadowalpha = 1;
				}

				// @bug: The wrong variable is being used in the minimum bounds
				// check. However, the approach to this is also flawed. The RSP
				// can crash if drawing outside of its allowed range, which is
				// actually -32768.99 to 32767.99. And this range is relative
				// to the camera, not in world coordinates. This bad check
				// doesn't cause any crashes though, because even if a chr falls
				// out of the geometry they likely wouldn't be rendered due to
				// not being in an active room and also being out of the draw
				// distance.
				if (shadowalpha > -65536.0f && chr->ground < 65536.0f) {
					f32 gaptoground = prop->pos.y - chr->ground;
					f32 radius;

					if (gaptoground <= 400 && g_Vars.currentplayer->visionmode != VISIONMODE_XRAY) {
						if (chr->bodynum == BODY_SKEDAR || chr->bodynum == BODY_SKEDARKING) {
							radius = 80;
						} else if (chr->bodynum == BODY_EYESPY) {
							radius = 12;
						} else {
							radius = 35;
						}

						if (chr->chrflags & CHRCFLAG_NOSHADOW) {
							shadowalpha = 0;
						} else if (shademode == SHADEMODE_FRAC) {
							shadowalpha = (1.0f - shadecolourfracs[3]) * ((alpha * 100) >> 8);
						} else {
							shadowalpha = (s32)(alpha * 100) >> 8;
						}

						if (gaptoground >= 150.0f) {
							shadowalpha = shadowalpha * (400 - gaptoground) * 0.004f;
						}

						if (cheat_is_active(CHEAT_SMALLCHARACTERS)) {
							radius *= 0.4f;
						}

						gdl = gfx_render_radial_shadow(gdl, prop->pos.x, chr->ground, prop->pos.z, chr_get_theta(chr), radius, 0xffffff00 | shadowalpha);
					}
				}
			}

			mtx_f2l_bulk(model->matrices, model->definition->nummatrices);

			if (USINGDEVICE(DEVICE_IRSCANNER)) {
				gdl = chr_render_shield(gdl, chr, 0x80);
			} else {
				gdl = chr_render_shield(gdl, chr, alpha);
			}
		}
	}

	return gdl;
}

struct shieldhit *g_ShieldHits = NULL;

void chr_emit_sparks(struct chrdata *chr, struct prop *prop, s32 hitpart, struct coord *coord, struct coord *coord2, struct chrdata *chr2)
{
	struct prop *chrprop = chr->prop;
	s32 race;

	if (chr_is_using_paintball(chr2)) {
		sparks_create(chrprop->rooms[0], chrprop, coord, coord2, 0, SPARKTYPE_PAINT);
		return;
	}

	if (chr_get_shield(chr) > 0.0f) {
		sparks_create(chrprop->rooms[0], chrprop, coord, coord2, 0, SPARKTYPE_DEFAULT);
		return;
	}

	if (prop->type == PROPTYPE_OBJ
			|| prop->type == PROPTYPE_WEAPON
			|| prop->type == PROPTYPE_DOOR
			|| hitpart == HITPART_GUN
			|| hitpart == HITPART_HAT) {
		sparks_create(chrprop->rooms[0], chrprop, coord, coord2, 0, SPARKTYPE_DEFAULT);
		return;
	}

	race = CHRRACE(chr);

	if (race == RACE_DRCAROLL || race == RACE_ROBOT || race == RACE_EYESPY) {
		sparks_create(chrprop->rooms[0], chrprop, coord, coord2, 0, SPARKTYPE_ELECTRICAL);
		return;
	}

	if (chr->noblood) {
		return;
	}

	if ((random() & 4) == 0) {
		struct coord coord3;
		coord3.x = coord2->x * 42.0f + coord->x;
		coord3.y = coord2->y * 42.0f + coord->y;
		coord3.z = coord2->z * 42.0f + coord->z;

		sparks_create(chrprop->rooms[0], chrprop, &coord3, coord2, 0, SPARKTYPE_FLESH_LARGE);
	}

#if VERSION < VERSION_JPN_FINAL
	sparks_create(chrprop->rooms[0], chrprop, coord, coord2, 0, SPARKTYPE_BLOOD);
	sparks_create(chrprop->rooms[0], chrprop, coord, coord2, 0, SPARKTYPE_FLESH);
#endif
}

void chr_bruise_from_stabby_projectile(struct model *model, s32 hitpart, struct modelnode *node, struct coord *arg3)
{
	struct modelnode *bestnode = NULL;
	s32 mindist = 0x7fffffff;
	s32 bestcoords[3];
	struct modelnode *curnode;
	Gfx *gdlptr;
	Gfx *gdlptr2;
	Vtx *vertices;
	struct modelnode *posnode = NULL;
	struct coord relpos;
	struct coord spd4;
	struct coord spc8;
	s32 spbc[3];
	s32 alpha = 20 + (random() % 50);
	struct modelrodata_dl *rodata;
	struct modelrwdata_dl *rwdata;
	s32 spac = 0;
	s32 op;
	s32 nodetype;

	model_node_get_model_relative_position(model, model_node_find_mtx_node(node), &relpos);

	spc8.f[0] = arg3->x - relpos.x;
	spc8.f[1] = arg3->y - relpos.y;
	spc8.f[2] = arg3->z - relpos.z;

	// This first pass over the node tree is deciding which modelnode to use.
	curnode = node;

	while (curnode) {
		s32 nodetype = curnode->type & 0xff;

		switch (nodetype) {
		case MODELNODETYPE_DL:
			rodata = &curnode->rodata->dl;
			rwdata = model_get_node_rw_data(model, curnode);

			if (rwdata->gdl == NULL) {
				break;
			}

			// By default, the model instance's displaylist points to the
			// one in the model definition. If it hasn't been changed we'll
			// use the space... after the model definition's colour table?
			// Let's hope that's not being used by other instances...
			if (rwdata->gdl == rodata->opagdl) {
				gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((uintptr_t)rodata->opagdl & 0xffffff));
			} else {
				gdlptr = rwdata->gdl;
			}

			if (rodata->xlugdl) {
				gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((uintptr_t)rodata->xlugdl & 0xffffff));
			} else {
				gdlptr2 = NULL;
			}

			// Iterate the primary DL, and once the end is reached
			// iterate the secondary DL if we have one.
			while (true) {
				op = *(s8 *)&gdlptr->words.w0;

				if (op == G_ENDDL) {
					if (gdlptr2) {
						// Switch to second DL
						gdlptr = gdlptr2;
						gdlptr2 = NULL;
					} else {
						// We're done
						gdlptr = NULL;
						break;
					}
				} else {
					// Note: We should have found an MTX op before VTX.
					if (op == G_VTX) {
						u8 *ptr = (u8 *)&gdlptr->words.w0;
						u32 word = gdlptr->words.w1 & 0xffffff;
						s32 numverts;
						s32 i;

						vertices = (Vtx *)((uintptr_t)rodata->vertices + word);
						numverts = (u32)ptr[1] / 16 + 1;

						if (posnode) {
							for (i = 0; i < numverts; i++) {
								s32 x = spbc[0] - vertices[i].x;
								s32 y = spbc[1] - vertices[i].y;
								s32 z = spbc[2] - vertices[i].z;
								s32 dist = x * x + y * y + z * z;

								if (dist < mindist) {
									mindist = dist;
									bestnode = curnode;
									bestcoords[0] = vertices[i].x + (s32)spd4.f[0];
									bestcoords[1] = vertices[i].y + (s32)spd4.f[1];
									bestcoords[2] = vertices[i].z + (s32)spd4.f[2];
								}
							}
						}
					} else if (op == G_MTX) {
						u32 addr = gdlptr->words.w1 & 0xffffff;
						posnode = model_find_node_by_mtx_index(model, addr / sizeof(Mtxf));
						model_node_get_model_relative_position(model, posnode, &spd4);

						spbc[0] = spd4.x + spc8.x;
						spbc[1] = spd4.y + spc8.y;
						spbc[2] = spd4.z + spc8.z;
					}

					gdlptr++;
				}
			}
			break;
		case MODELNODETYPE_DISTANCE:
			model_apply_distance_relations(model, curnode);
			break;
		case MODELNODETYPE_TOGGLE:
			model_apply_toggle_relations(model, curnode);
			break;
		case MODELNODETYPE_HEADSPOT:
			model_apply_head_relations(model, curnode);
			break;
		}

		if (curnode->child && (curnode == node
					|| (nodetype != MODELNODETYPE_BBOX && nodetype != MODELNODETYPE_11))) {
			curnode = curnode->child;
		} else {
			while (curnode) {
				if (curnode == node) {
					curnode = NULL;
					break;
				}

				if (curnode->next) {
					curnode = curnode->next;
					break;
				}

				curnode = curnode->parent;
			}
		}
	}

	if (bestnode == NULL) {
		return;
	}

	// Do a pass over the entire model's tree, looking for vertices that share
	// the chosen vertex, and darken them.
	curnode = model->definition->rootnode;

	while (curnode) {
		nodetype = curnode->type & 0xff;

		switch (nodetype) {
		case MODELNODETYPE_DL:
			rodata = &curnode->rodata->dl;
			rwdata = model_get_node_rw_data(model, curnode);

			if (rwdata->gdl == NULL) {
				break;
			}

			if (rwdata->gdl == rodata->opagdl) {
				gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((u32)rodata->opagdl & 0xffffff));
			} else {
				gdlptr = rwdata->gdl;
			}

			if (rodata->xlugdl) {
				gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((u32)rodata->xlugdl & 0xffffff));
			} else {
				gdlptr2 = NULL;
			}

			while (true) {
				s32 op = *(s8 *)&gdlptr->words.w0;

				if (op == G_ENDDL) {
					if (gdlptr2) {
						// Switch to second DL
						gdlptr = gdlptr2;
						gdlptr2 = NULL;
					} else {
						// We're done
						gdlptr = NULL;
						break;
					}
				} else {
					// Note: We should have found an MTX op before VTX.
					if (op == G_VTX) {
						u8 *ptr = (u8 *)&gdlptr->words.w0;
						u32 word = gdlptr->words.w1 & 0xffffff;
						Vtx *vertices = (Vtx *)((uintptr_t)rodata->vertices + word);
						s32 numverts = (u32)ptr[1] / 16 + 1;
						s32 i;

						if (posnode) {
							for (i = 0; i < numverts; i++) {
								s32 x = vertices[i].x + (s32)spd4.f[0];
								s32 y = vertices[i].y + (s32)spd4.f[1];
								s32 z = vertices[i].z + (s32)spd4.f[2];

								if (x == bestcoords[0] && y == bestcoords[1] && z == bestcoords[2]) {
									if ((uintptr_t)rwdata->colours == ALIGN8((uintptr_t)rodata->vertices + rodata->numvertices * sizeof(Vtx))) {
										Col *colours = vtxstore_allocate(rodata->numcolours, VTXSTORETYPE_CHRCOL, 0, 0);
										s32 j;

										if (colours) {
											for (j = 0; j < rodata->numcolours; j++) {
												colours[j] = rwdata->colours[j];
											}

											rwdata->colours = colours;
										} else {
											// empty
										}
									}

									if ((uintptr_t)rwdata->colours != ALIGN8((uintptr_t)rodata->vertices + rodata->numvertices * sizeof(Vtx))) {
										s32 offset = rwdata->vertices[word / sizeof(Vtx) + i].colour >> 2;
										Col *colours = (Col *) ((uintptr_t)rwdata->colours + spac);

										colours[offset].a = alpha;
									}
								}
							}
						}
					} else if (op == G_MTX) {
						u32 addr = gdlptr->words.w1 & 0xffffff;
						posnode = model_find_node_by_mtx_index(model, addr / sizeof(Mtxf));
						model_node_get_model_relative_position(model, posnode, &spd4);
					} else if (op == G_COL) {
						spac = gdlptr->words.w1 & 0xffffff;
					}

					gdlptr++;
				}
			}
			break;
		case MODELNODETYPE_DISTANCE:
			model_apply_distance_relations(model, curnode);
			break;
		case MODELNODETYPE_TOGGLE:
			model_apply_toggle_relations(model, curnode);
			break;
		case MODELNODETYPE_HEADSPOT:
			model_apply_head_relations(model, curnode);
			break;
		}

		if (curnode->child) {
			curnode = curnode->child;
		} else {
			while (curnode) {
				if (curnode && curnode->next) {
					curnode = curnode->next;
					break;
				}

				curnode = curnode->parent;
			}
		}
	}
}

/**
 * Bruise a chr by darkening their vertices.
 *
 * This happens when the chr is shot, which creates the illusion of blood
 * soaking through their clothing.
 */
void chr_bruise(struct model *model, s32 hitpart, struct modelnode *node, struct coord *arg3)
{
	struct modelnode *bestnode = NULL;
	bool ok;
	s32 nodetype;
	s32 mindist = 0x7fffffff;
	Vtx *vertices;
	s32 bestcoords[3];
	struct modelnode *curnode;
	Gfx *gdlptr;
	Gfx *gdlptr2;
	s32 op;
	struct modelnode *posnode = NULL;
	struct coord relpos;
	struct coord spd4;
	struct coord spc8;
	s32 spbc[3];
	s32 alpha = 20 + (random() % 50);
	struct modelrodata_dl *rodata;
	struct modelrwdata_dl *rwdata;
	s32 spac = 0;

	model_node_get_model_relative_position(model, model_node_find_mtx_node(node), &relpos);

	spc8.f[0] = arg3->f[0] - relpos.f[0];
	spc8.f[1] = arg3->f[1] - relpos.f[1];
	spc8.f[2] = arg3->f[2] - relpos.f[2];

	// This first pass over the node tree is deciding which modelnode to use.
	curnode = node;

	while (curnode) {
		nodetype = curnode->type & 0xff;

		switch (nodetype) {
		case MODELNODETYPE_DL:
			rodata = &curnode->rodata->dl;
			rwdata = model_get_node_rw_data(model, curnode);

			if (rwdata->gdl == NULL) {
				break;
			}

			// By default, the model instance's displaylist points to the
			// one in the model definition. If it hasn't been changed we'll
			// use the space... after the model definition's colour table?
			// Let's hope that's not being used by other instances...
			if (rwdata->gdl == rodata->opagdl) {
				gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((u32)rodata->opagdl & 0xffffff));
			} else {
				gdlptr = rwdata->gdl;
			}

			if (rodata->xlugdl) {
				gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((u32)rodata->xlugdl & 0xffffff));
			} else {
				gdlptr2 = NULL;
			}

			// Iterate the primary DL, and once the end is reached
			// iterate the secondary DL if we have one.
			while (true) {
				op = *(s8 *)&gdlptr->words.w0;

				if (op == G_ENDDL) {
					if (gdlptr2) {
						// Switch to second DL
						gdlptr = gdlptr2;
						gdlptr2 = NULL;
					} else {
						// We're done
						gdlptr = NULL;
						break;
					}
				} else {
					// Note: We should have found an MTX op before VTX.
					if (op == G_VTX) {
						u8 *ptr = (u8 *)&gdlptr->words.w0;
						u32 word = gdlptr->words.w1 & 0xffffff;
						s32 numverts;
						s32 i;

						vertices = (Vtx *)((uintptr_t)rodata->vertices + word);
						numverts = (u32)ptr[1] / 16 + 1;

						if (posnode) {
							for (i = 0; i < numverts; i++) {
								s32 x = spbc[0] - vertices[i].x;
								s32 y = spbc[1] - vertices[i].y;
								s32 z = spbc[2] - vertices[i].z;
								s32 dist = x * x + y * y + z * z;

								if (dist < mindist) {
									mindist = dist;
									bestnode = curnode;
									bestcoords[0] = vertices[i].x + (s32)spd4.f[0];
									bestcoords[1] = vertices[i].y + (s32)spd4.f[1];
									bestcoords[2] = vertices[i].z + (s32)spd4.f[2];
								}
							}
						}
					} else if (op == G_MTX) {
						u32 addr = gdlptr->words.w1 & 0xffffff;
						posnode = model_find_node_by_mtx_index(model, addr / sizeof(Mtxf));
						model_node_get_model_relative_position(model, posnode, &spd4);

						spbc[0] = spd4.x + spc8.x;
						spbc[1] = spd4.y + spc8.y;
						spbc[2] = spd4.z + spc8.z;
					}

					gdlptr++;
				}
			}
			break;
		case MODELNODETYPE_DISTANCE:
			model_apply_distance_relations(model, curnode);
			break;
		case MODELNODETYPE_TOGGLE:
			model_apply_toggle_relations(model, curnode);
			break;
		case MODELNODETYPE_HEADSPOT:
			model_apply_head_relations(model, curnode);
			break;
		}

		if (curnode->child && (curnode == node
					|| (nodetype != MODELNODETYPE_BBOX && nodetype != MODELNODETYPE_11))) {
			curnode = curnode->child;
		} else {
			while (curnode) {
				if (curnode == node) {
					curnode = NULL;
					break;
				}

				if (curnode->next) {
					curnode = curnode->next;
					break;
				}

				curnode = curnode->parent;
			}
		}
	}

	ok = true;

	if (bestnode == NULL) {
		return;
	}

	// Do a pass over the entire model's tree, looking for vertices that share
	// the chosen vertex, and darken then.
	curnode = model->definition->rootnode;

	while (curnode) {
		nodetype = curnode->type & 0xff;

		switch (nodetype) {
		case MODELNODETYPE_BBOX:
			if (g_Vars.hitboundscount) {
				s32 i;

				ok = false;

				for (i = 0; i < g_Vars.hitboundscount; i++) {
					if (g_Vars.hitnodes[i] == curnode) {
						ok = true;
					}
				}
			} else {
				ok = true;
			}

			break;
		case MODELNODETYPE_DL:
			if (ok) {
				rodata = &curnode->rodata->dl;
				rwdata = model_get_node_rw_data(model, curnode);

				if (rwdata->gdl == NULL) {
					break;
				}

				if (rwdata->gdl == rodata->opagdl) {
					gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((u32)rodata->opagdl & 0xffffff));
				} else {
					gdlptr = rwdata->gdl;
				}

				if (rodata->xlugdl) {
					gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((u32)rodata->xlugdl & 0xffffff));
				} else {
					gdlptr2 = NULL;
				}

				while (true) {
					s32 op = *(s8 *)&gdlptr->words.w0;

					if (op == G_ENDDL) {
						if (gdlptr2) {
							// Switch to second DL
							gdlptr = gdlptr2;
							gdlptr2 = NULL;
						} else {
							// We're done
							gdlptr = NULL;
							break;
						}
					} else {
						// Note: We should have found an MTX op before VTX.
						if (op == G_VTX) {
							u8 *ptr = (u8 *)&gdlptr->words.w0;
							u32 word = gdlptr->words.w1 & 0xffffff;
							Vtx *vertices = (Vtx *)((uintptr_t)rodata->vertices + word);
							s32 numverts = (u32)ptr[1] / 16 + 1;
							s32 i;

							if (posnode) {
								for (i = 0; i < numverts; i++) {
									s32 coordinate = vertices[i].x + (s32)spd4.f[0];

									if (coordinate == bestcoords[0]) {
										coordinate = vertices[i].y + (s32)spd4.f[1];

										if (coordinate == bestcoords[1]) {
											coordinate = vertices[i].z + (s32)spd4.f[2];

											if (coordinate == bestcoords[2]) {
												if ((uintptr_t)rwdata->colours == ALIGN8((u32)rodata->vertices + rodata->numvertices * sizeof(Vtx))) {
													Col *colours = vtxstore_allocate(rodata->numcolours, VTXSTORETYPE_CHRCOL, 0, 0);
													s32 j;

													if (colours) {
														for (j = 0; j < rodata->numcolours; j++) {
															colours[j] = rwdata->colours[j];
														}

														rwdata->colours = colours;
													}
												}

												if ((uintptr_t)rwdata->colours != ALIGN8((uintptr_t)rodata->vertices + rodata->numvertices * sizeof(Vtx))) {
													s32 offset = rwdata->vertices[word / sizeof(Vtx) + i].colour >> 2;
													Col *colours = (Col *) ((uintptr_t)rwdata->colours + spac);

													colours[offset].a = alpha;
												}
											}
										}
									}
								}
							}
						} else if (op == G_MTX) {
							u32 addr = gdlptr->words.w1 & 0xffffff;
							posnode = model_find_node_by_mtx_index(model, addr / sizeof(Mtxf));
							model_node_get_model_relative_position(model, posnode, &spd4);
						} else if (op == G_COL) {
							spac = gdlptr->words.w1 & 0xffffff;
						}

						gdlptr++;
					}
				}
			}
			break;
		case MODELNODETYPE_DISTANCE:
			model_apply_distance_relations(model, curnode);
			break;
		case MODELNODETYPE_TOGGLE:
			model_apply_toggle_relations(model, curnode);
			break;
		case MODELNODETYPE_HEADSPOT:
			model_apply_head_relations(model, curnode);
			break;
		}

		if (curnode->child) {
			curnode = curnode->child;
		} else {
			while (curnode) {
				if (curnode && curnode->next) {
					curnode = curnode->next;
					break;
				}

				curnode = curnode->parent;
			}
		}
	}
}

/**
 * Disfigure and darken a chr due to them dying from explosion damage.
 *
 * Vertices and colours are copied from the modeldef into new vtxstore
 * allocations. If the vtxstore is full, the chr will not become disfigured
 * or will only be partially disfigured.
 *
 * The function looks for displaylist nodes in the chr's model. For each DL node
 * found, its vertex and colour information is copied to the vtx store. The GBI
 * commands are then iterated, looking for pointers into the vertex table. For
 * each pointer found, the vertices at that offset in the table are adjusted
 * randomly. Lastly, every colour in the node's colour table is darkened.
 */
void chr_disfigure(struct chrdata *chr, struct coord *exppos, f32 damageradius)
{
	struct modelnode *node;
	struct modelrodata_dl *rodata;
	struct modelrwdata_dl *rwdata;
	Col *colours;
	struct model *model = chr->model;
	Vtx *vertices;
	u32 stack;
	Gfx *gdlptr;
	Gfx *gdlptr2;
	struct modelnode *posnode = NULL;
	struct coord pos;
	s32 i;
	s32 j;

	u32 rand = random();

	if (g_Vars.mplayerisrunning || !chr_is_dead(chr)) {
		return;
	}

	// Iterate the nodes in the chr model
	node = model->definition->rootnode;

	while (node) {
		switch (node->type & 0xff) {
		case MODELNODETYPE_DL:
			rodata = &node->rodata->dl;
			rwdata = model_get_node_rw_data(model, node);

			if (rwdata->gdl == NULL) {
				break;
			}

			// Check that the node is using the modeldef's vertices
			// (ie. we haven't disfigured this node already)
			if (rwdata->vertices == rodata->vertices) {
				// Copy the vertices from the modeldef to the vtxstore
				if (rwdata->vertices == rodata->vertices) {
					Vtx *vertices = vtxstore_allocate(rodata->numvertices, VTXSTORETYPE_CHRVTX, 0, 0);

					if (vertices) {
						for (i = 0; i < rodata->numvertices; i++) {
							vertices[i] = rwdata->vertices[i];
						}

						rwdata->vertices = vertices;
					}
				}

				// Copy the colours from the modeldef to the vtxstore
				if ((uintptr_t)rwdata->colours == ALIGN8((uintptr_t)&rodata->vertices[rodata->numvertices])) {
					colours = vtxstore_allocate(rodata->numcolours, VTXSTORETYPE_CHRCOL, 0, 0);

					if (colours) {
						for (i = 0; i < rodata->numcolours; i++) {
							colours[i] = rwdata->colours[i];
						}

						rwdata->colours = colours;
					}
				}

				// Iterate the node's primary and secondary DLs, looking for
				// MTX and VTX pointers
				if (rwdata->vertices != rodata->vertices
						&& (uintptr_t)rwdata->colours != ALIGN8((uintptr_t)&rodata->vertices[rodata->numvertices])) {
					if (rwdata->gdl == rodata->opagdl) {
						gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((s32)rodata->opagdl & 0xffffff));
					} else {
						gdlptr = rwdata->gdl;
					}

					if (rodata->xlugdl) {
						gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((s32)rodata->xlugdl & 0xffffff));
					} else {
						gdlptr2 = NULL;
					}

					while (true) {
						s32 op = *(s8 *)&gdlptr->words.w0;

						if (op == G_ENDDL) {
							if (gdlptr2 == NULL) {
								// We're done
								gdlptr = NULL;
								break;
							}

							// Switch to second DL
							gdlptr = gdlptr2;
							gdlptr2 = NULL;
						} else {
							// Note: We should have found an MTX op before VTX.
							// MTX sets posnode.
							if (op == G_VTX) {
								// Iterate the vertex table and fudge them
								u8 *ptr = (u8 *)&gdlptr->words.w0;
								s32 word = gdlptr->words.w1 & 0xffffff;
								s32 numverts;

								vertices = (Vtx *)((uintptr_t)rwdata->vertices + word);
								numverts = (u32)ptr[1] / 16 + 1;

								if (posnode) {
									for (i = 0; i < numverts; i++) {
										rng2_set_seed(rand + vertices[i].x + vertices[i].y + vertices[i].z + (u32)pos.f[0] + (u32)pos.f[1] + (u32)pos.f[2]);

										if (vertices[i].x > 0) {
											vertices[i].x -= (s16)(random2() % 20);
										} else if (vertices[i].x < 0) {
											vertices[i].x += (s16)(random2() % 20);
										}

										if (vertices[i].y > 0) {
											vertices[i].y -= (s16)(random2() % 20);
										} else if (vertices[i].y < 0) {
											vertices[i].y += (s16)(random2() % 20);
										}

										if (vertices[i].z > 0) {
											vertices[i].z -= (s16)(random2() % 20);
										} else if (vertices[i].z < 0) {
											// @bug: should be z instead of y
											vertices[i].y += (s16)(random2() % 20);
										}
									}
								}
							} else if (op == G_MTX) {
								// Get the position of the node relative to the model
								u32 addr = gdlptr->words.w1 & 0xffffff;
								posnode = model_find_node_by_mtx_index(model, addr / sizeof(Mtxf));
								model_node_get_model_relative_position(model, posnode, &pos);
							}

							gdlptr++;
						}
					}

					// Darken colours
					for (i = 0; i < rodata->numcolours; i++) {
						for (j = 0; j < 3; j++) {
							s32 tmp = rwdata->colours[i].bytes[j];
							tmp = tmp * 5 / 16;

							if (tmp < 0) {
								tmp = 0;
							}

							rwdata->colours[i].bytes[j] = tmp;
						}
					}
				}
			}
			break;
		case MODELNODETYPE_DISTANCE:
			model_apply_distance_relations(model, node);
			break;
		case MODELNODETYPE_TOGGLE:
			model_apply_toggle_relations(model, node);
			break;
		case MODELNODETYPE_HEADSPOT:
			model_apply_head_relations(model, node);
			break;
		}

		// Find the next node to iterate
		if (node->child) {
			node = node->child;
		} else {
			while (node) {
				if (node->next) {
					node = node->next;
					break;
				}

				node = node->parent;
			}
		}
	}
}

f32 chr_get_hit_radius(struct chrdata *chr)
{
	s32 i;
	f32 result;
	f32 highest = 0;

	if (chr->model) {
		result = model_get_effective_scale(chr->model);

		for (i = 0; i < 2; i++) {
			if (chr->weapons_held[i]) {
				struct defaultobj *obj = chr->weapons_held[i]->obj;
				f32 value = model_get_effective_scale(obj->model) * chr->model->scale;

				if (value > highest) {
					highest = value;
				}
			}
		}

		result += highest;

		if (chr_get_shield(chr) > 0) {
			result += 10;
		}
	} else {
		result = 100;
	}

	return result;
}

void chr_test_hit(struct prop *prop, struct shotdata *shotdata, bool isshooting, bool cheap)
{
	struct coord spdc;
	struct coord spd0;
	struct chrdata *chr = prop->chr;

	if ((chr->chrflags & CHRCFLAG_HIDDEN) == 0 && (prop->flags & PROPFLAG_ONTHISSCREENTHISTICK)) {
		f32 radius = chr_get_hit_radius(chr);

		if (prop->z - radius < shotdata->distance) {
			struct model *model = chr->model;
			s32 hitpart = 0;
			struct modelnode *node = NULL;
			s32 spb8 = 0;
			struct hitthing sp88;
			s32 sp84 = 0;
			struct modelnode *sp80 = NULL;
			Mtxf *rootmtx = model_get_root_mtx(model);
			struct prop *next;
			struct prop *child;
			f32 sp70;
			Mtxf *mtx;
			f32 sp68;

			if (pos_is_facing_pos(&shotdata->gunpos2d, &shotdata->gundir2d, (struct coord *)rootmtx->m[3], radius)) {
				spb8 = 1;
				hitpart = 1;
			}

			if (hitpart) {
				if (chr_get_shield(chr) > 0.0f) {
					var8005efc0 = 10.0f / model->scale;
				}

				child = prop->child;

				while (child) {
					next = child->next;
					obj_attachment_test_hit(child, shotdata);
					child = next;
				}

				if (cheap || var8005efc0 > 0.0f) {
					hitpart = model_test_for_hit(model, &shotdata->gunpos2d, &shotdata->gundir2d, &node);

					while (hitpart > 0) {
						if (obj_find_hitthing_by_bboxrodata_mtx(model, node, &shotdata->gunpos2d, &shotdata->gundir2d, &sp88, &sp84, &sp80)) {
							mtx4_transform_vec(&model->matrices[sp84], &sp88.pos, &spdc);
							mtx4_transform_vec_in_place(cam_get_projection_mtxf(), &spdc);
							mtx4_rotate_vec(&model->matrices[sp84], &sp88.unk0c, &spd0);
							mtx4_rotate_vec_in_place(cam_get_projection_mtxf(), &spd0);
							break;
						}

						hitpart = model_test_for_hit(model, &shotdata->gunpos2d, &shotdata->gundir2d, &node);
					}
				} else {
					hitpart = model_test_for_hit(model, &shotdata->gunpos2d, &shotdata->gundir2d, &node);

					if (hitpart > 0) {
						if (projectile_0f06bea0(model, model->definition->rootnode, model->definition->rootnode, &shotdata->gunpos2d,
									&shotdata->gundir2d, &sp88.pos, &sp70, &node, &hitpart, &sp84, &sp80)) {
							mtx4_transform_vec(cam_get_projection_mtxf(), &sp88.pos, &spdc);
							mtx4_rotate_vec(cam_get_projection_mtxf(), &sp88.unk0c, &spd0);
						} else {
							hitpart = 0;
						}
					}
				}

				if (var8005efc0 > 0.0f) {
					var8005efc0 = 0.0f;
				}
			}

			if (hitpart > 0) {
				mtx = cam_get_world_to_screen_mtxf();
				sp68 = spdc.x * mtx->m[0][2] + spdc.y * mtx->m[1][2] + spdc.z * mtx->m[2][2] + mtx->m[3][2];
				sp68 = -sp68;

				if (sp68 < shotdata->distance) {
					hit_create(shotdata, prop, sp68, hitpart, node, &sp88, sp84, sp80, model, true, chr_get_shield(chr) > 0.0f, &spdc, &spd0);
				}
			}

			if (spb8 && hitpart <= 0 && prop->z <= shotdata->distance && isshooting) {
				if (chr_get_target_prop(chr) == g_Vars.currentplayer->prop) {
					chr->chrflags |= CHRCFLAG_NEAR_MISS;
				}

				chr->numclosearghs++;
			}
		}
	}
}

/**
 * Handle a chr being shot.
 */
void chr_hit(struct shotdata *shotdata, struct hit *hit)
{
	struct prop *prop;
	struct chrdata *chr;
	Mtxf spb0;
	struct coord hitpos;
	struct coord sp98;
	s16 hitpos_s16[3];
	u8 ismelee = false;
	struct funcdef *func = gset_get_funcdef_by_gset(&shotdata->gset);
	f32 shield;

	if (func && (func->type & 0xff) == INVENTORYFUNCTYPE_MELEE) {
		ismelee = true;
	}

	// The prop that was hit could be an item held by the chr,
	// so traverse the parents. The root parent is the chr itself.
	prop = hit->prop;

	while (prop->parent) {
		prop = prop->parent;
	}

	chr = prop->chr;

	if ((chr->chrflags & CHRCFLAG_HIDDEN) == 0) {
		sp98.x = shotdata->gunpos2d.x - (hit->distance * shotdata->gundir2d.x) / shotdata->gundir2d.z;
		sp98.y = shotdata->gunpos2d.y - (hit->distance * shotdata->gundir2d.y) / shotdata->gundir2d.z;
		sp98.z = shotdata->gunpos2d.z - hit->distance;

		mtx4_transform_vec(cam_get_projection_mtxf(), &sp98, &hitpos);
		bgun_set_hit_pos(&hitpos);
		bgun_play_prop_hit_sound(&shotdata->gset, hit->prop, -1);

		chr_emit_sparks(chr, hit->prop, hit->hitpart, &hitpos, &shotdata->gundir3d, g_Vars.currentplayer->prop->chr);

		hitpos_s16[0] = hit->hitthing.pos.x;
		hitpos_s16[1] = hit->hitthing.pos.y;
		hitpos_s16[2] = hit->hitthing.pos.z;

		shield = chr_get_shield(chr);

		chr_damage_by_impact(chr, gset_get_damage(&shotdata->gset), &shotdata->gundir3d, &shotdata->gset,
				g_Vars.currentplayer->prop, hit->hitpart, hit->prop, hit->bboxnode,
				hit->model, hit->hitthing.unk28 / 2, hitpos_s16);

		if (g_Vars.antiplayernum >= 0
				&& g_Vars.currentplayer == g_Vars.anti
				&& (chr->hidden & CHRHFLAG_ANTINONINTERACTABLE)) {
			return;
		}

		if (g_Vars.coopplayernum >= 0
				&& g_Vars.coopfriendlyfire == false
				&& prop->type == PROPTYPE_PLAYER) {
			return;
		}

		if (g_MissionConfig.iscoop && g_Vars.coopfriendlyfire == false && chr->team == TEAM_ALLY) {
			return;
		}

		if (shield <= 0) {
			if (hit->prop->type == PROPTYPE_WEAPON) {
				// Shot a chr's weapon
				struct weaponobj *weapon = hit->prop->weapon;
				struct surfacetype *type;
				s32 surfacetype;
				s32 index;

				// Shooting an explosive in a chr's hand causes it to explode
				if (weapon->weaponnum == WEAPON_GRENADE
						|| weapon->weaponnum == WEAPON_GRENADEROUND
						|| weapon->weaponnum == WEAPON_ROCKET
						|| weapon->weaponnum == WEAPON_HOMINGROCKET
						|| weapon->weaponnum == WEAPON_TIMEDMINE
						|| weapon->weaponnum == WEAPON_REMOTEMINE
						|| weapon->weaponnum == WEAPON_PROXIMITYMINE) {
					obj_set_dropped(hit->prop, DROPTYPE_DEFAULT);
					chr->hidden |= CHRHFLAG_DROPPINGITEM;
					obj_damage(&weapon->base, gset_get_damage(&shotdata->gset), &sp98, shotdata->gset.weaponnum, g_Vars.currentplayernum);
					return;
				}

				// Create decal depending on the weapon's surface type
				if (hit->hitthing.texturenum < 0 || hit->hitthing.texturenum >= NUM_TEXTURES) {
					surfacetype = SURFACETYPE_DEFAULT;
				} else {
					surfacetype = g_Textures[hit->hitthing.texturenum].surfacetype;
				}

				if (surfacetype >= 0 && surfacetype < 15) {
					type = g_SurfaceTypes[surfacetype];

					if (type->numwallhittexes > 0) {
						index = random() % type->numwallhittexes;

						wallhit_create(
								&hit->hitthing.pos,
								&hit->hitthing.unk0c,
								&shotdata->gunpos3d,
								0,
								0,
								type->wallhittexes[index],
								1,
								hit->prop,
								hit->mtxindex,
								0,
								g_Vars.currentplayer->prop->chr,
								0);
					}
				}

				// Drop gun
				if (chr->aibot == NULL && (chr->flags & CHRFLAG0_CANLOSEGUN)) {
					chr->gunprop = hit->prop;
					obj_set_dropped(hit->prop, DROPTYPE_DEFAULT);
					chr->hidden |= CHRHFLAG_DROPPINGITEM;
				}
			} else if (hit->hitpart == HITPART_HAT) {
				// Shot a chr's hat
				struct surfacetype *type;
				s32 index;

				// Create decal depending on the hat's surface type
				if (hit->hitthing.texturenum < 0) {
					type = g_SurfaceTypes[0];
				} else {
					type = g_SurfaceTypes[g_Textures[hit->hitthing.texturenum].surfacetype];
				}

				index = random() % type->numwallhittexes;

				wallhit_create(
						&hit->hitthing.pos,
						&hit->hitthing.unk0c,
						&shotdata->gunpos3d,
						0,
						0,
						type->wallhittexes[index],
						1,
						chr->weapons_held[2],
						hit->mtxindex,
						0,
						g_Vars.currentplayer->prop->chr,
						0);
			} else {
				// Shot a chr in the flesh
				s32 race = CHRRACE(chr);
				struct coord sp5c;
				Mtxf *sp58 = model_find_node_mtx(hit->model, hit->bboxnode, 0);

				// Create blood
				mtx0001719c(sp58->m, spb0.m);
				mtx4_transform_vec(&spb0, &sp98, &sp5c);

#if VERSION >= VERSION_NTSC_1_0
				if (!chr->noblood
						&& race != RACE_DRCAROLL
						&& race != RACE_ROBOT
						&& race != RACE_EYESPY
						&& !ismelee
						&& shotdata->gset.weaponnum != WEAPON_TRANQUILIZER) {
					u8 darker;

					if (chr->bodynum == BODY_MRBLONDE || race == RACE_SKEDAR) {
						darker = true;
					} else {
						darker = false;
					}

					if (!chr_is_using_paintball(g_Vars.currentplayer->prop->chr)) {
						chr_bruise(hit->model, hit->hitpart, hit->bboxnode, &sp5c);
					}

					splats_create_for_chr_hit(prop, shotdata, &sp98, &hitpos, darker, 0, g_Vars.currentplayer->prop->chr);
				}
#else
				// NTSC beta wraps all the blood logic in this paintball check.
				// If paintball is enabled, neither blood nor paint is created.
				if (!chr_is_using_paintball(g_Vars.currentplayer->prop->chr)
						&& !chr->noblood
						&& race != RACE_DRCAROLL
						&& race != RACE_ROBOT
						&& race != RACE_EYESPY
						&& !ismelee
						&& shotdata->gset.weaponnum != WEAPON_TRANQUILIZER) {
					u8 darker;

					if (chr->bodynum == BODY_MRBLONDE || race == RACE_SKEDAR) {
						darker = true;
					} else {
						darker = false;
					}

					chr_bruise(hit->model, hit->hitpart, hit->bboxnode, &sp5c);

					splats_create_for_chr_hit(prop, shotdata, &sp98, &hitpos, darker, 0, g_Vars.currentplayer->prop->chr);
				}
#endif
			}
		}
	}
}

void chrs_set_stage_translation_thing(f32 arg1)
{
	// empty
}

void chranimdebug_everyone(bool enable)
{
	g_ChrsAnimDebugSetAll = enable;
	g_ChrsAnimDebugForceLoop = enable;
}

void chranimdebug_decrement_anim(s32 quantity)
{
	g_ChrsAnimDebugAnimNum -= quantity;

	if (g_ChrsAnimDebugAnimNum <= 0) {
		g_ChrsAnimDebugAnimNum = anim_get_num_animations() - 1;
	}
}

void chranimdebug_increment_anim(s32 quantity)
{
	g_ChrsAnimDebugAnimNum += quantity;

	if (g_ChrsAnimDebugAnimNum >= anim_get_num_animations()) {
		g_ChrsAnimDebugAnimNum = 1;
	}
}

void chranimdebug_toggle_paused(void)
{
	g_ChrsAnimDebugPaused = !g_ChrsAnimDebugPaused;
}

void chranimdebug_select_anim(bool enable)
{
	g_ChrsAnimDebugSlow = enable;

	main_override_variable("selectanimnum", &g_ChrsAnimDebugAnimNum);
}

void chrs_check_for_noise(f32 noiseradius)
{
	s32 i;
	f32 add = 0.075f;

	for (i = 0; i < g_NumChrSlots; i++) {
		if (g_ChrSlots[i].model) {
			struct prop *prop = g_ChrSlots[i].prop;

			if (prop && prop->type == PROPTYPE_CHR &&
					chr_get_target_prop(&g_ChrSlots[i]) == g_Vars.currentplayer->prop) {

				f32 distance = chr_get_distance_to_current_player(&g_ChrSlots[i]);

				if (distance == 0) {
					distance = 2;
				} else {
					distance = (noiseradius * 100 * g_ChrSlots[i].hearingscale * (1.0f + add)) / distance;
				}

				if (distance > 1.0f) {
					chr_record_last_hear_target_time(&g_ChrSlots[i]);
#if PIRACYCHECKS
					{
						s32 *i = (s32 *)&__scHandleRetrace;
						s32 *end = (s32 *)&__scHandleTasks;
						u32 checksum = 0;

						while (i < end) {
							checksum *= 2;
							checksum += *i;
							i++;
						}

						if (checksum != CHECKSUM_PLACEHOLDER) {
							g_HeadsAndBodies[BODY_SKEDARKING].filenum = 0;
						}
					}
#endif
				}
			}
		}
	}
}

struct chrdata *chr_find_by_literal_id(s32 chrnum)
{
	s32 lower = 0;
	s32 upper = g_NumChrs;
	s32 i;

	while (upper >= lower) {
		i = (lower + upper) / 2;

		if (chrnum == g_Chrnums[i]) {
			return &g_ChrSlots[g_ChrIndexes[i]];
		}

		if (chrnum < g_Chrnums[i]) {
			upper = i - 1;
		} else {
			lower = i + 1;
		}
	}

	return NULL;
}

struct prop *chr_get_held_prop(struct chrdata *chr, s32 hand)
{
	return chr->weapons_held[hand];
}

struct prop *chr_get_held_usable_prop(struct chrdata *chr, s32 hand)
{
	struct prop *prop = chr->weapons_held[hand];

	if (prop) {
		struct weaponobj *weapon = prop->weapon;

		if (!gset_has_weapon_flag(weapon->weaponnum, WEAPONFLAG_AICANUSE)) {
			prop = NULL;
		}
	}

	return prop;
}

struct prop *chr_get_target_prop(struct chrdata *chr)
{
	struct prop *ret;

	if (chr->target == -1) {
		ret = g_Vars.players[chr->p1p2]->prop;
	} else {
		ret = g_Vars.props + chr->target;
	}

	return ret;
}

bool chr_get_geometry(struct prop *prop, u8 **start, u8 **end)
{
	struct chrdata *chr = prop->chr;

	if (chr->actiontype != ACT_DEAD &&
			chr->actiontype != ACT_DRUGGEDKO &&
			(chr->chrflags & (CHRCFLAG_PERIMDISABLEDTMP | CHRCFLAG_HIDDEN)) == 0 &&
			(chr->hidden & CHRHFLAG_PERIMDISABLED) == 0) {
		chr->geo.header.type = GEOTYPE_CYL;

		if (chr->actiontype == ACT_DIE || chr->actiontype == ACT_DRUGGEDDROP) {
			chr->geo.header.flags = GEOFLAG_BLOCK_SHOOT;
		} else {
			chr->geo.header.flags = GEOFLAG_WALL | GEOFLAG_BLOCK_SHOOT;
		}

		chr->geo.ymin = chr->manground;
		chr->geo.ymax = chr->manground + chr->height;

		if (chr->actiontype == ACT_SKJUMP) {
			if (chr->manground > chr->act_skjump.ground) {
				chr->geo.ymin = chr->act_skjump.ground;
			}
		}

		chr->geo.x = prop->pos.x;
		chr->geo.z = prop->pos.z;
		chr->geo.radius = chr->radius;

		if (g_Vars.useperimshoot) {
			chr->geo.radius = 15;
		}

		*start = (void *) &chr->geo;
		*end = *start + sizeof(struct geocyl);

		return true;
	}

	*end = NULL;
	*start = NULL;

	return false;
}

void chr_get_bbox(struct prop *prop, f32 *radius, f32 *ymax, f32 *ymin)
{
	struct chrdata *chr = prop->chr;

	*radius = chr->radius;
	*ymax = chr->manground + chr->height;
	*ymin = chr->manground + 20;

	if (chr->actiontype == ACT_SKJUMP && chr->act_skjump.ground < chr->manground) {
		*ymin = chr->act_skjump.ground + 20;
	}
}

f32 chr_get_ground(struct prop *prop)
{
	struct chrdata *chr = prop->chr;
	return chr->ground;
}

bool chr_calculate_autoaim(struct prop *prop, struct coord *screenpos, f32 *xrange, f32 *yrange)
{
	struct chrdata *chr = prop->chr;

	// Check if the chr is eligible for autoaim
	if ((prop->flags & PROPFLAG_ONTHISSCREENTHISTICK)
			&& chr->actiontype != ACT_DIE
			&& chr->actiontype != ACT_DRUGGEDDROP
			&& chr->actiontype != ACT_DRUGGEDKO
			&& chr->actiontype != ACT_DEAD
			&& (chr->chrflags & CHRCFLAG_NOAUTOAIM) == 0
			&& ((chr->hidden & CHRHFLAG_CLOAKED) == 0 || USINGDEVICE(DEVICE_IRSCANNER))
			&& !(prop->type == PROPTYPE_PLAYER && g_Vars.players[playermgr_get_player_num_by_prop(prop)]->isdead)
			&& !(g_Vars.coopplayernum >= 0 && (prop == g_Vars.bond->prop || prop == g_Vars.coop->prop))) {
		struct model *model = chr->model;
		Mtxf *mtx1;
		Mtxf *mtx2;

		if (model->definition->skel == &g_SkelChr) {
			mtx1 = &model->matrices[0];
			mtx2 = &model->matrices[1];
			screenpos->z = mtx2->m[3][2] + (mtx1->m[3][2] - mtx2->m[3][2]) * 0.5f;
		} else if (model->definition->skel == &g_SkelSkedar) {
			mtx2 = &model->matrices[0];
			screenpos->z = mtx2->m[3][2];
		} else if (model->definition->skel == &g_SkelDrCaroll) {
			mtx2 = &model->matrices[0];
			screenpos->z = mtx2->m[3][2];
		} else {
			screenpos->z = model->matrices[0].m[3][2];
		}

		if (screenpos->z < 0) {
			if (model->definition->skel == &g_SkelChr) {
				screenpos->x = mtx2->m[3][0] + (mtx1->m[3][0] - mtx2->m[3][0]) * 0.5f;
				screenpos->y = mtx2->m[3][1] + (mtx1->m[3][1] - mtx2->m[3][1]) * 0.5f;
			} else if (model->definition->skel == &g_SkelSkedar) {
				screenpos->x = mtx2->m[3][0];
				screenpos->y = mtx2->m[3][1];
			} else if (model->definition->skel == &g_SkelDrCaroll) {
				screenpos->x = mtx2->m[3][0];
				screenpos->y = mtx2->m[3][1];
			} else {
				screenpos->x = model->matrices[0].m[3][0];
				screenpos->y = model->matrices[0].m[3][1];
			}

			yrange[0] = yrange[1] = 0;
			xrange[0] = xrange[1] = 0;

			model_get_screen_coords3(model, &xrange[1], &xrange[0], &yrange[1], &yrange[0]);

			return true;
		}
	}

	return false;
}

/**
 * Iterate the iterprop, its children and siblings to find wantprop.
 * Sum the number of matrix slots in the model data of each model that has been iterated.
 *
 * This function is recursive, where each recursion is for an attached child
 * or sibling.
 *
 * @bug: The matrices are counted from the same model definition
 * regardless of what model the children have.
 */
bool shieldhit_find_cmnum_for_prop(struct prop *iterprop, struct prop *wantprop, struct modelnode *node, struct model *model, s32 *total)
{
	if (wantprop == iterprop) {
		*total += model_find_node_mtx_index(node, 0);
		return true;
	}

	*total += model->definition->nummatrices;

	if (iterprop->child && shieldhit_find_cmnum_for_prop(iterprop->child, wantprop, node, model, total) > 0) {
		return true;
	}

	if (iterprop->next && shieldhit_find_cmnum_for_prop(iterprop->next, wantprop, node, model, total) > 0) {
		return true;
	}

	return false;
}

/**
 * Given a model node, find the associated cmnum.
 *
 * The node may be on the root prop (chr or obj). It may also be a node on an
 * attached prop such as a knife or mine.
 */
s32 shieldhit_node_to_cmnum(struct prop *wantprop, struct modelnode *node, struct model *model, struct prop *rootprop)
{
	s32 cmnum = 0;

	if (shieldhit_find_cmnum_for_prop(rootprop, wantprop, node, model, &cmnum)) {
		return cmnum;
	}

	return -1;
}

/**
 * Convert a cmnum to a prop, model and node.
 *
 * For example, a chr might have 14 matrices, and they might have a mine
 * attached to them which has one matrix. cmnums 0-13 will refer to matrices in
 * the chr's model, while cmnum 14 will be the mine.
 *
 * Return true if the cmnum was valid and values were written to the pointers.
 */
bool shieldhit_cmnum_to_node(s32 cmnum, struct prop *prop, struct prop **propptr, struct modelnode **nodeptr, struct model **modelptr)
{ \
	while (true) {
		bool result = false;
		struct model *model;
		s32 stack;

		if (prop->type == PROPTYPE_CHR || prop->type == PROPTYPE_PLAYER) {
			model = prop->chr->model;
		} else {
			model = prop->obj->model;
		}

		if (1);

		if (cmnum >= model->definition->nummatrices) {
			cmnum -= model->definition->nummatrices;

			if (prop->child) {
				result = shieldhit_cmnum_to_node(cmnum, prop->child, propptr, nodeptr, modelptr);
			}

			if (prop->next && !result) {
				prop = prop->next;
				continue;
			}
		} else {
			*propptr = prop;
			*nodeptr = model_find_node_by_mtx_index(model, cmnum);
			*modelptr = model;
			result = true;
		}

		return result;
	}
}

void shieldhit_create(struct prop *rootprop, f32 shield, struct prop *hitprop, struct modelnode *node, struct model *model, s32 side, s16 *hitpos)
{
	struct shieldhit *shieldhit = NULL;
	s32 i;
	s32 j;

	// Find any slot that isn't in use (ie. prop is NULL)
	for (i = 0; i < MAX_SHIELDHITS; i++) {
		if (g_ShieldHits[i].prop == NULL) {
			shieldhit = &g_ShieldHits[i];
			break;
		}
	}

	// If all slots are in use, take the oldest one
	if (shieldhit == NULL) {
		struct shieldhit *oldesthit = NULL;
		s32 oldestframe = g_Vars.lvframe60;

		for (i = 0; i < MAX_SHIELDHITS; i++) {
			if (g_ShieldHits[i].lvframe60 < oldestframe) {
				oldesthit = &g_ShieldHits[i];
				oldestframe = g_ShieldHits[i].lvframe60;
			}
		}

		shieldhit = oldesthit;
	}

	if (shieldhit) {
		shieldhit->prop = rootprop;
		shieldhit->node = node;
		shieldhit->model = model;
		shieldhit->side = side;
		shieldhit->lvframe60 = g_Vars.lvframe60;

		for (i = 0; i < 32; i++) {
			shieldhit->unk018[i] = -1;
		}

		shieldhit->unk011 = 2 + (random() % 6);
		shieldhit->shield = shield;

		if (hitpos) {
			shieldhit->hitposx = hitpos[0];
			shieldhit->hitposy = hitpos[1];
			shieldhit->hitposz = hitpos[2];
		} else {
			shieldhit->hitposx = 0x7fff;
		}

		if (node) {
			bool pass = true;

			for (i = 0; i < MAX_SHIELDHITS; i++) {
				if (g_ShieldHits[i].prop == rootprop) {
					for (j = 0; j < 32; j++) {
						if (shieldhit->unk018[j] != -1 && shieldhit->unk018[j] != -2) {
							pass = false;
							break;
						}
					}

					if (!pass) {
						break;
					}
				}
			}

			if (pass) {
				s32 index = shieldhit_node_to_cmnum(hitprop, node, model, rootprop);

				if (index < 32) {
					shieldhit->unk018[index] = 0;
					shieldhit->unk038[index] = 0;
				}
			}
		}

		if (rootprop->type == PROPTYPE_CHR || rootprop->type == PROPTYPE_PLAYER) {
			rootprop->chr->hidden2 |= CHRH2FLAG_SHIELDHIT;
		} else if (rootprop->type == PROPTYPE_OBJ || rootprop->type == PROPTYPE_WEAPON || rootprop->type == PROPTYPE_DOOR) {
			rootprop->obj->flags3 |= OBJFLAG3_SHIELDHIT;
		}
	}

	g_ShieldHitActive = true;
}

void shieldhit_remove(struct shieldhit *shieldhit)
{
	s32 exists = false;
	s32 i;
	struct prop *prop = shieldhit->prop;
	shieldhit->prop = NULL;

	// Check if there are other shield hits active
	g_ShieldHitActive = false;

	for (i = 0; i < MAX_SHIELDHITS; i++) {
		if (g_ShieldHits[i].prop) {
			g_ShieldHitActive = true;
			break;
		}
	}

	// Check if the prop being removed has other shield hits too
	for (i = 0; i < MAX_SHIELDHITS; i++) {
		if (prop == g_ShieldHits[i].prop) {
			exists = true;
			break;
		}
	}

	if (!exists) {
		// Mark prop as shield no longer visible
		if (prop->type == PROPTYPE_CHR || prop->type == PROPTYPE_PLAYER) {
			struct chrdata *chr = prop->chr;
			chr->hidden2 &= ~CHRH2FLAG_SHIELDHIT;
		} else if (prop->type == PROPTYPE_OBJ
				|| prop->type == PROPTYPE_WEAPON
				|| prop->type == PROPTYPE_DOOR) {
			struct defaultobj *obj = prop->obj;
			obj->flags3 &= ~OBJFLAG3_SHIELDHIT;
		}
	}
}

void shieldhits_remove_by_prop(struct prop *prop)
{
	s32 i;

	for (i = 0; i < MAX_SHIELDHITS; i++) {
		if (prop == g_ShieldHits[i].prop) {
			shieldhit_remove(&g_ShieldHits[i]);
		}
	}
}

s32 shieldhit_find_parentnode_cmnum(struct prop *prop, s32 prevcmnum)
{
	s32 cmnum = -1;
	struct modelnode *node2;
	struct prop *prop2;
	struct modelnode *node;
	struct model *model;

	if (shieldhit_cmnum_to_node(prevcmnum, prop, &prop2, &node, &model) && node) {
		node2 = model_node_find_parent_mtx_node(node);

		if (node2) {
			cmnum = shieldhit_node_to_cmnum(prop2, node2, model, prop);
		} else if (prop2->parent && model->attachedtomodel && model->attachedtonode) {
			cmnum = shieldhit_node_to_cmnum(prop2->parent, model->attachedtonode, model->attachedtomodel, prop);
		}
	}

	return cmnum;
}

s32 shieldhit_find_childnode_cmnum(struct prop *prop, s32 prevcmnum)
{
	s32 cmnum = -1;
	struct modelnode *node2;
	struct prop *prop2;
	struct modelnode *node;
	struct model *model;

	if (shieldhit_cmnum_to_node(prevcmnum, prop, &prop2, &node, &model) && node) {
		node2 = model_node_find_child_mtx_node(node);

		if (node2) {
			cmnum = shieldhit_node_to_cmnum(prop2, node2, model, prop);
		} else {
			struct prop *child = prop2->child;

			while (child) {
				struct model *parentmodel = child->parentmodel;

				if (model == parentmodel->attachedtomodel) {
					if (node == parentmodel->attachedtonode) {
						cmnum = shieldhit_node_to_cmnum(child, parentmodel->definition->rootnode, parentmodel, prop);
						break;
					}
				}

				child = child->next;
			}
		}
	}

	return cmnum;
}

s32 shieldhit_find_anynode_cmnum(struct prop *prop, s32 prevcmnum)
{
	s32 cmnum = -1;
	struct prop *child;
	struct prop *prop2;
	struct modelnode *node2;
	struct model *model2;

	if (shieldhit_cmnum_to_node(prevcmnum, prop, &prop2, &node2, &model2) && node2) {
		struct modelnode *node3 = model_node_find_child_or_parent_mtx_node(node2);

		if (node3) {
			cmnum = shieldhit_node_to_cmnum(prop2, node3, model2, prop);
		} else if (model_node_find_parent_mtx_node(node2) == NULL && prop2->parent) {
			child = prop2->parent->child;

			while (child && child != prop2) {
				child = child->next;
			}

			if (child) {
				child = child->next;

				while (child) {
					struct model *parent = child->parentmodel;

					if (parent->attachedtomodel == model2->attachedtomodel) {
						if (parent->attachedtonode == model2->attachedtonode) {
							cmnum = shieldhit_node_to_cmnum(child, parent->definition->rootnode, parent, prop);
							break;
						}
					}

					child = child->next;
				}
			}
		}
	}

	return cmnum;
}

void shieldhit_health_to_rgb(f32 health, s32 *r, s32 *g, s32 *b)
{
	if (health < 1.5f) {
		*r = 57 - (s32) ((1.5f - health) * 28);
		*g = 75 - (s32) ((1.5f - health) * 20);
		*b = 0;
	} else if (health < 3.0f) {
		*r = 102 - (s32) ((3.0f - health) * 30);
		*g = 90 - (s32) ((3.0f - health) * 10);
		*b = 0;
	} else if (health < 4.5f) {
		*r = 174 - (s32) ((4.5f - health) * 48);
		*g = 129 - (s32) ((4.5f - health) * 26);
		*b = 0;
	} else if (health < 6.0f) {
		*r = 162 - (s32) ((6.0f - health) * -8);
		*g = 54 - (s32) ((6.0f - health) * -50);
		*b = 0;
	} else {
		*r = 162;
		*g = 54;
		*b = 0;
	}
}

f32 shieldhit_get_health(struct prop **propptr)
{
	struct prop *prop = *propptr;

	if (prop->type == PROPTYPE_CHR || prop->type == PROPTYPE_PLAYER) {
		return chr_get_shield(prop->chr);
	}

	if (prop->type == PROPTYPE_OBJ
			|| prop->type == PROPTYPE_WEAPON
			|| prop->type == PROPTYPE_DOOR) {
		if (prop->obj->flags3 & OBJFLAG3_SHOWSHIELD) {
			return 4;
		}

		// Objects don't have shields with health,
		// hence why the max health is returned here.
		return 8;
	}

	return 0;
}

bool g_ShieldHitActive = false;

Gfx *shieldhit_render_component(Gfx *gdl, struct shieldhit *hit, struct prop *prop, struct model *model,
		struct modelnode *node, s32 side, s32 arg6, s32 arg7, s32 alpha)
{
	struct modelrodata_bbox *bbox = &node->rodata->bbox;
	Vtx vtxtemplate = {0};
	Vtx *vertices;
	Col *colours;
	Mtxf *modelmtx;
	s32 i;
	s32 xmin;
	s32 xmax;
	s32 ymin;
	s32 ymax;
	s32 zmin;
	s32 zmax;
	s32 j;
	u32 stack;
	s16 sp180[8][3];
	u8 alpha1;
	u8 alpha2;
	s16 st1;
	s16 st2;
	s16 st4;
	s16 st3;
	f32 gap;
	f32 shieldamount;
	s32 cloakfade;
	s32 cmcount;

	s32 sp104[6][4] = {
		{ 0, 1, 3, 2 },
		{ 7, 5, 4, 6 },
		{ 5, 1, 0, 4 },
		{ 2, 3, 7, 6 },
		{ 0, 2, 6, 4 },
		{ 7, 3, 1, 5 },
	};

	s32 red1;
	s32 green1;
	s32 blue1;
	s32 red2;
	s32 green2;
	s32 blue2;
	s32 red3;
	s32 green3;
	s32 blue3;
	s32 mtxindex;

	if (prop->type == PROPTYPE_CHR || prop->type == PROPTYPE_PLAYER) {
		struct chrdata *chr = prop->chr;
		gap = 10.0f / chr->model->scale;
		shieldamount = chr_get_shield(chr);
		cloakfade = chr->cloakfadefrac;
		cmcount = chr->cmcount;
	} else {
		struct defaultobj *obj = prop->obj;
		gap = 0.0f;
		cloakfade = 64;
		cmcount = 0;
		shieldamount = (obj->flags3 & OBJFLAG3_SHOWSHIELD) ? 4.0f : 8.0f;
	}

	mtxindex = model_find_node_mtx_index(node, 0);
	modelmtx = &model->matrices[mtxindex];

	xmin = bbox->xmin - gap;
	xmax = bbox->xmax + gap;
	ymin = bbox->ymin - gap;
	ymax = bbox->ymax + gap;
	zmin = bbox->zmin - gap;
	zmax = bbox->zmax + gap;

	sp180[0][0] = xmin;
	sp180[0][1] = ymin;
	sp180[0][2] = zmin;

	sp180[1][0] = xmin;
	sp180[1][1] = ymin;
	sp180[1][2] = zmax;

	sp180[2][0] = xmin;
	sp180[2][1] = ymax;
	sp180[2][2] = zmin;

	sp180[3][0] = xmin;
	sp180[3][1] = ymax;
	sp180[3][2] = zmax;

	sp180[4][0] = xmax;
	sp180[4][1] = ymin;
	sp180[4][2] = zmin;

	sp180[5][0] = xmax;
	sp180[5][1] = ymin;
	sp180[5][2] = zmax;

	sp180[6][0] = xmax;
	sp180[6][1] = ymax;
	sp180[6][2] = zmin;

	sp180[7][0] = xmax;
	sp180[7][1] = ymax;
	sp180[7][2] = zmax;

	gSPMatrix(gdl++, osVirtualToPhysical(modelmtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);

	if (side == -7) {
		colours = gfx_allocate_colours(1);

		gSPColor(gdl++, osVirtualToPhysical(colours), 1);

		colours[0].r = 0xff;
		colours[0].g = 0xff;
		colours[0].b = 0xff;

		if (cloakfade < 64) {
			colours[0].a = (s32) (cloakfade * (f32) alpha * (1.0f / 85.0f));
		} else {
			colours[0].a = (s32) ((127 - cloakfade) * (f32) alpha * (1.0f / 85.0f));
		}

		vertices = gfx_allocate_vertices(24);

		for (i = 0; i < ARRAYCOUNT(sp104); i++) {
			for (j = 0; j < ARRAYCOUNT(sp104[i]); j++) {
				vertices[j] = vtxtemplate;
				vertices[j].x = sp180[sp104[i][j]][0];
				vertices[j].y = sp180[sp104[i][j]][1];
				vertices[j].z = sp180[sp104[i][j]][2];
				vertices[j].colour = 0;
			}

			vertices[0].s = 0;
			vertices[0].t = 0;
			vertices[1].s = 512;
			vertices[1].t = 0;
			vertices[2].s = 512;
			vertices[2].t = 512;
			vertices[3].s = 0;
			vertices[3].t = 512;

			gSPVertex(gdl++, osVirtualToPhysical(vertices), 4, 0);

			gSPTri2(gdl++, 0, 1, 2, 0, 2, 3);

			vertices += 4;
		}
	} else {
		f32 shield;

		tex_select(&gdl, &g_TexShieldConfigs[TEX_SHIELD_00], 4, 1, 2, true, NULL);

		if (side >= 0) {
			shield = hit->shield;
		} else {
			shield = shieldamount;

			if (side == -2) {
				if (hit->unk011 < arg7) {
					shield = 0.0f;
				} else {
					shield *= ((4.0f * hit->unk011) - arg7 + 1.0f) / (4.0f * hit->unk011);
				}
			}
		}

		shieldhit_health_to_rgb(shield, &red1, &green1, &blue1);

		red2 = red1 - 20;
		green2 = green1 - 20;
		blue2 = blue1 - 20;

		if (red2 < 0) {
			red2 = 0;
		}

		if (green2 < 0) {
			green2 = 0;
		}

		if (blue2 < 0) {
			blue2 = 0;
		}

		red3 = red1 - 60;
		green3 = green1 - 60;
		blue3 = blue1 - 60;

		if (red3 < 0) {
			red3 = 0;
		}

		if (green3 < 0) {
			green3 = 0;
		}

		if (blue3 < 0) {
			blue3 = 0;
		}

		st1 = (sinf((g_Vars.thisframestart240 % TICKS(1200)) * PALUPF(0.005235154f)) + 1.0f) * 0.5f * 32.0f * 32.0f;
		st2 = (cosf((g_Vars.thisframestart240 % TICKS(1200)) * PALUPF(0.005235154f)) + 1.0f) * 0.5f * 32.0f * 32.0f;
		st3 = st1 + 512;
		st4 = st2 + 512;

		if (side == -3 || side == -4 || side == -5 || side == -6) {
			colours = gfx_allocate_colours(1);

			gSPColor(gdl++, osVirtualToPhysical(colours), 1);

			if (side == -3) {
				colours[0].r = red2;
				colours[0].g = green2;
				colours[0].b = blue2;
				colours[0].a = (cmcount < 10) ? (s32) (alpha * 0.5882353f) : 0;
			} else {
				colours[0].r = red3;
				colours[0].g = green3;
				colours[0].b = blue3;

				if (cmcount < 10) {
					if (side == -4) {
						colours[0].a = (s32) (alpha * 0.3137255f);
					} else if (side == -5) {
						colours[0].a = (s32) (alpha * 0.23529412f);
					} else if (side == -6) {
						colours[0].a = (s32) (alpha * 0.15686275f);
					}
				} else {
					colours[0].a = 0;
				}
			}

			vertices = gfx_allocate_vertices(24);

			if ((prop->type == PROPTYPE_OBJ || prop->type == PROPTYPE_WEAPON || prop->type == PROPTYPE_DOOR)
					&& (prop->obj->flags3 & OBJFLAG3_SHOWSHIELD)) {
				f32 mult = (sinf((g_Vars.thisframestart240 % TICKS(350)) * (PAL ? 0.021588264033198f : 0.0179491f)) + 1.0f) * 0.5f;

				colours->a = 50 + (u8) (s32) (120.0f * mult);
				colours->r = (u8) red2 + 50.0f * mult;
				colours->g = (u8) green2 + 50.0f * mult;
				colours->b = (u8) blue2 + 50.0f * mult;
			} else {
				st3 = 512;
				st1 = 0;
				st2 = 0;
				st4 = 512;
			}

			for (i = 0; i < ARRAYCOUNT(sp104); i++) {
				for (j = 0; j < ARRAYCOUNT(sp104[i]); j++) {
					vertices[j] = vtxtemplate;
					vertices[j].x = sp180[sp104[i][j]][0];
					vertices[j].y = sp180[sp104[i][j]][1];
					vertices[j].z = sp180[sp104[i][j]][2];
					vertices[j].colour = 0;
				}

				vertices[0].s = st1;
				vertices[0].t = st2;
				vertices[1].s = st3;
				vertices[1].t = st2;
				vertices[2].s = st3;
				vertices[2].t = st4;
				vertices[3].s = st1;
				vertices[3].t = st4;

				gSPVertex(gdl++, osVirtualToPhysical(vertices), 4, 0);

				gSPTri2(gdl++, 0, 1, 2, 0, 2, 3);

				vertices += 4;
			}
		} else if (side == -2) {
			f32 alpha3;

			if (hit->unk011 < arg7) {
				alpha3 = 0.0f;
			} else {
#if PAL
				alpha3 = ((TICKS(30.0f) - arg6) * 6.4f + 40.0f) * ((hit->unk011 - (f32) arg7 + 1.0f) / hit->unk011);
#else
				alpha3 = ((TICKS(30.0f) - arg6) * 5.3333335f + 40.0f) * ((hit->unk011 - (f32) arg7 + 1.0f) / hit->unk011);
#endif
				alpha3 *= alpha * (1.0f / 255.0f);
			}

			if (alpha3 > 255.0f) {
				alpha3 = 255.0f;
			} else if (alpha3 < 0.0f) {
				alpha3 = 0.0f;
			}

			colours = gfx_allocate_colours(3);

			gSPColor(gdl++, osVirtualToPhysical(colours), 3);

			colours[0].r = red3;
			colours[1].r = red3;
			colours[0].g = green3;
			colours[1].g = green3;
			colours[0].b = blue3;
			colours[1].b = blue3;
			colours[0].a = (s32) alpha3;
			colours[1].a = 0;

			vertices = gfx_allocate_vertices(30);

			for (i = 0; i < ARRAYCOUNT(sp104); i++) {
				for (j = 0; j < ARRAYCOUNT(sp104[i]); j++) {
					vertices[j] = vtxtemplate;
					vertices[j].x = sp180[sp104[i][j]][0];
					vertices[j].y = sp180[sp104[i][j]][1];
					vertices[j].z = sp180[sp104[i][j]][2];
					vertices[j].colour = 0;
				}

				vertices[0].s = st1;
				vertices[0].t = st2;
				vertices[1].s = st3;
				vertices[1].t = st2;
				vertices[2].s = st3;
				vertices[2].t = st4;
				vertices[3].s = st1;
				vertices[3].t = st4;

				vertices[4] = vtxtemplate;
				vertices[4].x = (vertices[0].x + vertices[1].x + vertices[2].x + vertices[3].x) >> 2;
				vertices[4].y = (vertices[0].y + vertices[1].y + vertices[2].y + vertices[3].y) >> 2;
				vertices[4].z = (vertices[0].z + vertices[1].z + vertices[2].z + vertices[3].z) >> 2;
				vertices[4].s = (st1 + st3) >> 1;
				vertices[4].t = (st2 + st4) >> 1;
				vertices[4].colour = 4;

				gSPVertex(gdl++, osVirtualToPhysical(vertices), 5, 0);

				gSPTri4(gdl++, 0, 1, 4, 1, 2, 4, 2, 3, 4, 3, 0, 4);

				vertices += 5;
			}
		} else if (side < 0) {
			vertices = gfx_allocate_vertices(12);

			if (side == -1) {
				if (g_Vars.lvframe60 - hit->lvframe60 <= TICKS(80)) {
					f32 tmp = (hit->lvframe60 - g_Vars.lvframe60 + TICKS(80)) * (PAL ? 3.8636362552643f : 3.1875f);
					tmp *= alpha * (1.0f / 255.0f);

					alpha1 = (s32) tmp;
				} else {
					alpha1 = 0;
				}

				colours = gfx_allocate_colours(1);

				gSPColor(gdl++, osVirtualToPhysical(colours), 1);

				colours[0].r = red1;
				colours[0].g = green1;
				colours[0].b = blue1;
				colours[0].a = alpha1;
			} else if (side == -2) {
				f32 alpha4;

				if (hit->unk011 < arg7) {
					alpha4 = 0.0f;
				} else {
					alpha4 = (((TICKS(30.0f) - (f32) arg6) * PALUPF(4.0f)) + 40.0f)
						* (((hit->unk011 - (f32) arg7) + 1.0f) / hit->unk011);
					alpha4 *= alpha * (1.0f / 255.0f);
				}

				if (alpha4 > 255.0f) {
					alpha4 = 255.0f;
				} else if (alpha4 < 0.0f) {
					alpha4 = 0.0f;
				}

				colours = gfx_allocate_colours(1);

				gSPColor(gdl++, osVirtualToPhysical(colours), 1);

				colours[0].r = red3;
				colours[0].g = green3;
				colours[0].b = blue3;
				colours[0].a = (s32) alpha4;
			}

			for (j = 0; j < ARRAYCOUNT(sp180); j++) {
				vertices[j] = vtxtemplate;
				vertices[j].x = sp180[j][0];
				vertices[j].y = sp180[j][1];
				vertices[j].z = sp180[j][2];
				vertices[j].colour = 0;
			}

			vertices[0].s = st1;
			vertices[0].t = st2;
			vertices[1].s = st3;
			vertices[1].t = st2;
			vertices[5].s = st3;
			vertices[5].t = st4;
			vertices[4].s = st1;
			vertices[4].t = st4;
			vertices[3].s = st1;
			vertices[3].t = st2;
			vertices[2].t = st2;
			vertices[2].s = st3;
			vertices[6].s = st3;
			vertices[6].t = st4;
			vertices[7].s = st1;
			vertices[7].t = st4;

			vertices[8] = vtxtemplate;
			vertices[8].x = sp180[2][0];
			vertices[8].y = sp180[2][1];
			vertices[8].z = sp180[2][2];
			vertices[8].colour = 0;

			vertices[9] = vtxtemplate;
			vertices[9].x = sp180[3][0];
			vertices[9].y = sp180[3][1];
			vertices[9].z = sp180[3][2];
			vertices[9].colour = 0;

			vertices[8].s = st1;
			vertices[8].t = st4;
			vertices[9].s = st3;
			vertices[9].t = st4;

			vertices[10] = vtxtemplate;
			vertices[10].x = sp180[6][0];
			vertices[10].y = sp180[6][1];
			vertices[10].z = sp180[6][2];
			vertices[10].colour = 0;

			vertices[11] = vtxtemplate;
			vertices[11].x = sp180[7][0];
			vertices[11].y = sp180[7][1];
			vertices[11].z = sp180[7][2];
			vertices[11].colour = 0;

			vertices[10].s = st1;
			vertices[10].t = st2;
			vertices[11].s = st3;
			vertices[11].t = st2;

			gSPVertex(gdl++, osVirtualToPhysical(vertices), 12, 0);

			gSPTri4(gdl++, 0, 1, 9, 0, 9, 8, 11, 5, 4, 11, 4, 10);

			for (j = 2; j < 6; j++) {
				gSPTri2(gdl++,
						sp104[j][0], sp104[j][1], sp104[j][2],
						sp104[j][0], sp104[j][2], sp104[j][3]);
			}
		} else {
			if ((prop->type == PROPTYPE_OBJ || prop->type == PROPTYPE_WEAPON || prop->type == PROPTYPE_DOOR)
					&& (prop->obj->flags3 & OBJFLAG3_SHOWSHIELD)) {
				alpha1 = 0xff;
				alpha2 = 0xff;
			} else if (g_Vars.lvframe60 - hit->lvframe60 <= TICKS(80)) {
				f32 value;

				value = (hit->lvframe60 - g_Vars.lvframe60 + TICKS(80)) * (PAL ? 3.8636362552643f : 3.1875f);
				value *= alpha * (1.0f / 255.0f);
				alpha1 = (s32) value;

				value = (hit->lvframe60 - g_Vars.lvframe60 + TICKS(80)) * (PAL ? 3.8636362552643f : 3.1875f);
				value *= alpha * (1.0f / 255.0f);
				alpha2 = (s32) value;
			} else {
				alpha1 = 0;
				alpha2 = 0;
			}

			colours = gfx_allocate_colours(5);

			gSPColor(gdl++, osVirtualToPhysical(colours), 5);

			colours[0].r = red1;
			colours[0].g = green1;
			colours[0].b = blue1;
			colours[0].a = alpha1;

			colours[1].r = red2;
			colours[1].g = green2;
			colours[1].b = blue2;
			colours[1].a = alpha1;

			colours[2].r = red2;
			colours[2].g = green2;
			colours[2].b = blue2;
			colours[2].a = alpha1;

			red1 += 100;

			if (red1 > 255) {
				red1 = 255;
			}

			colours[3].r = red1;

			green1 += 100;

			if (green1 > 255) {
				green1 = 255;
			}

			colours[3].g = green1;

			blue1 += 100;

			if (blue1 > 255) {
				blue1 = 255;
			}

			colours[3].b = blue1;

			colours[3].a = alpha2;

			red2 += 70;

			if (red2 > 255) {
				red2 = 255;
			}

			colours[4].r = red2;

			green2 += 70;

			if (green2 > 255) {
				green2 = 255;
			}

			colours[4].g = green2;

			blue2 += 70;

			if (blue2 > 255) {
				blue2 = 255;
			}

			colours[4].b = blue2;

			colours[4].a = alpha1;

			vertices = gfx_allocate_vertices(30);

			for (j = 0; j < ARRAYCOUNT(sp104[side]); j++) {
				vertices[j] = vtxtemplate;
				vertices[j].x = sp180[sp104[side][j]][0];
				vertices[j].y = sp180[sp104[side][j]][1];
				vertices[j].z = sp180[sp104[side][j]][2];
				vertices[j].colour = 0;
			}

			vertices[0].s = st1;
			vertices[0].t = st2;
			vertices[1].s = st3;
			vertices[1].t = st2;
			vertices[2].s = st3;
			vertices[2].t = st4;
			vertices[3].s = st1;
			vertices[3].t = st4;

			vertices[4] = vtxtemplate;

			if (hit->hitposx == 0x7fff) {
				vertices[4].x = (vertices[0].x + vertices[1].x + vertices[2].x + vertices[3].x) >> 2;
				vertices[4].y = (vertices[0].y + vertices[1].y + vertices[2].y + vertices[3].y) >> 2;
				vertices[4].z = (vertices[0].z + vertices[1].z + vertices[2].z + vertices[3].z) >> 2;
			} else {
				vertices[4].x = hit->hitposx;
				vertices[4].y = hit->hitposy;
				vertices[4].z = hit->hitposz;
			}

			vertices[4].colour = 0xc;
			vertices[4].s = (st1 + st3) >> 1;
			vertices[4].t = (st2 + st4) >> 1;

			gSPVertex(gdl++, osVirtualToPhysical(vertices), 5, 0);

			gSPTri4(gdl++, 0, 1, 4, 1, 2, 4, 2, 3, 4, 3, 0, 4);

			vertices += 5;

			for (j = 0; j < ARRAYCOUNT(sp104[side]); j++) {
				s32 next = (j + 1) % 4;
				u32 stack;

				vertices[0] = vtxtemplate;
				vertices[0].x = sp180[sp104[side][next]][0];
				vertices[0].y = sp180[sp104[side][next]][1];
				vertices[0].z = sp180[sp104[side][next]][2];
				vertices[0].colour = 4;

				vertices[1] = vtxtemplate;
				vertices[1].x = sp180[sp104[side][j]][0];
				vertices[1].y = sp180[sp104[side][j]][1];
				vertices[1].z = sp180[sp104[side][j]][2];
				vertices[1].colour = 4;

				vertices[2] = vtxtemplate;
				vertices[2].x = sp180[sp104[side][j]][0];
				vertices[2].y = sp180[sp104[side][j]][1];
				vertices[2].z = sp180[sp104[side][j]][2];
				vertices[2].colour = 8;

				if (side == 0) {
					vertices[2].x = xmax;
				} else if (side == 1) {
					vertices[2].x = xmin;
				} else if (side == 2) {
					vertices[2].y = ymax;
				} else if (side == 3) {
					vertices[2].y = ymin;
				} else if (side == 4) {
					vertices[2].z = zmax;
				} else if (side == 5) {
					vertices[2].z = zmin;
				}

				vertices[3] = vtxtemplate;
				vertices[3].x = sp180[sp104[side][next]][0];
				vertices[3].y = sp180[sp104[side][next]][1];
				vertices[3].z = sp180[sp104[side][next]][2];
				vertices[3].colour = 8;

				if (side == 0) {
					vertices[3].x = xmax;
				} else if (side == 1) {
					vertices[3].x = xmin;
				} else if (side == 2) {
					vertices[3].y = ymax;
				} else if (side == 3) {
					vertices[3].y = ymin;
				} else if (side == 4) {
					vertices[3].z = zmax;
				} else if (side == 5) {
					vertices[3].z = zmin;
				}

				vertices[0].s = st1;
				vertices[0].t = st2;
				vertices[1].s = st3;
				vertices[1].t = st2;
				vertices[2].s = st3;
				vertices[2].t = st4;
				vertices[3].s = st1;
				vertices[3].t = st4;

				vertices[4] = vtxtemplate;
				vertices[4].x = (vertices[0].x + vertices[1].x + vertices[2].x + vertices[3].x) >> 2;
				vertices[4].y = (vertices[0].y + vertices[1].y + vertices[2].y + vertices[3].y) >> 2;
				vertices[4].z = (vertices[0].z + vertices[1].z + vertices[2].z + vertices[3].z) >> 2;
				vertices[4].colour = 0x10;
				vertices[4].s = (st1 + st3) >> 1;
				vertices[4].t = (st2 + st4) >> 1;

				gSPVertex(gdl++, osVirtualToPhysical(vertices), 5, 0);

				gSPTri4(gdl++, 0, 1, 4, 1, 2, 4, 2, 3, 4, 3, 0, 4);

				vertices += 5;
			}

			for (j = 0; j < ARRAYCOUNT(sp104[side]); j++) {
				vertices[j] = vtxtemplate;
				vertices[j].x = sp180[sp104[side][3 - j]][0];
				vertices[j].y = sp180[sp104[side][3 - j]][1];
				vertices[j].z = sp180[sp104[side][3 - j]][2];
				vertices[j].colour = 8;

				if (side == 0) {
					vertices[j].x = xmax;
				} else if (side == 1) {
					vertices[j].x = xmin;
				} else if (side == 2) {
					vertices[j].y = ymax;
				} else if (side == 3) {
					vertices[j].y = ymin;
				} else if (side == 4) {
					vertices[j].z = zmax;
				} else if (side == 5) {
					vertices[j].z = zmin;
				}
			}

			vertices[0].s = st1;
			vertices[0].t = st2;
			vertices[1].s = st3;
			vertices[1].t = st2;
			vertices[2].s = st3;
			vertices[2].t = st4;
			vertices[3].s = st1;
			vertices[3].t = st4;

			vertices[4] = vtxtemplate;

			vertices[4].x = (vertices[0].x + vertices[1].x + vertices[2].x + vertices[3].x) >> 2;
			vertices[4].y = (vertices[0].y + vertices[1].y + vertices[2].y + vertices[3].y) >> 2;
			vertices[4].z = (vertices[0].z + vertices[1].z + vertices[2].z + vertices[3].z) >> 2;
			vertices[4].colour = 0x10;
			vertices[4].s = (st1 + st3) >> 1;
			vertices[4].t = (st2 + st4) >> 1;

			gSPVertex(gdl++, osVirtualToPhysical(vertices), 5, 0);

			gSPTri4(gdl++, 0, 1, 4, 1, 2, 4, 2, 3, 4, 3, 0, 4);
		}
	}

	return gdl;
}

/**
 * Render a shield hit.
 *
 * Chrs have shield bounding boxes around each bone. For chrs, a shield hit is
 * rendered around every bone.
 *
 * Objects can have a specific model part for the shield area (eg. hoverbed).
 * If not specified, every bbox node in the object will be used.
 */
Gfx *shieldhit_render(Gfx *gdl, struct prop *prop1, struct prop *prop2, s32 alpha,
		bool arg4, s32 cmnum1, s32 cmnum2, s32 cmnum3, s32 cmnum4)
{
	u32 stack[4];
	struct model *model;
	struct modelnode *specificnode = NULL;
	struct modelnode *node;

	if (prop2->flags & PROPFLAG_ONTHISSCREENTHISTICK) {
		// Find the model and specific node if any
		if (prop2->type == PROPTYPE_CHR || prop2->type == PROPTYPE_PLAYER) {
			struct chrdata *chr = prop2->chr;
			model = chr->model;
		} else {
			model = prop2->obj->model;
			specificnode = model_get_part(model->definition, MODELPART_BASIC_SHIELD);
		}

		node = model->definition->rootnode;

		while (node) {
			if ((node->type & 0xff) == MODELNODETYPE_BBOX) {
				if (specificnode == NULL || specificnode == node) {
					struct shieldhit *s0 = NULL;
					struct shieldhit *s1 = NULL;
					struct shieldhit *s2 = NULL;
					s32 index = shieldhit_node_to_cmnum(prop2, node, model, prop1);
					s32 i;

					for (i = 0; i < MAX_SHIELDHITS; i++) {
						struct shieldhit *iter = &g_ShieldHits[i];

						if (iter->prop == prop1) {
							if (iter->model) {
								if (iter->node == node) {
									if (s0 == NULL || s0->lvframe60 < iter->lvframe60) {
										s0 = iter;
									}
								} else {
									if (index < 32
											&& iter->unk018[index] >= 0
											&& (s2 == NULL || s2->lvframe60 < iter->lvframe60)) {
										s2 = iter;
									}
								}
							} else {
								if (s1 == NULL || s1->lvframe60 < iter->lvframe60) {
									s1 = iter;
								}
							}
						}
					}

					if (s0) {
						gdl = shieldhit_render_component(gdl, s0, prop1, s0->model, s0->node, s0->side, -1, -1, 255);
					} else if (s1) {
						gdl = shieldhit_render_component(gdl, s1, prop1, model, node, -1, -1, -1, 255);
					} else if (s2) {
						gdl = shieldhit_render_component(gdl, s2, prop1, model, node, -2, s2->unk018[index], s2->unk038[index], 255);
					} else {
						if (arg4) {
							if (specificnode) {
								index = 19;
							}

							if (index > 19) {
								index = 0;
							}

							gDPPipeSync(gdl++);
							gDPSetTextureLUT(gdl++, G_TT_NONE);
							gDPLoadTextureBlock(gdl++, var8009ccc0[index], G_IM_FMT_RGBA, G_IM_SIZ_16b, 16, 16, 0, G_TX_MIRROR | G_TX_WRAP, G_TX_MIRROR | G_TX_WRAP, 4, 4, G_TX_NOLOD, G_TX_NOLOD);
							gDPSetCycleType(gdl++, G_CYC_1CYCLE);
							gDPSetRenderMode(gdl++, G_RM_AA_ZB_XLU_SURF, G_RM_AA_ZB_XLU_SURF2);
							gDPSetCombineMode(gdl++, G_CC_MODULATEI, G_CC_MODULATEI);
							gSPTexture(gdl++, 0xffff, 0xffff, 0, G_TX_RENDERTILE, G_ON);
							gDPSetTextureFilter(gdl++, G_TF_BILERP);
							gDPSetColorDither(gdl++, G_CD_BAYER);

							gdl = shieldhit_render_component(gdl, NULL, prop1, model, node, -7, -1, -1, 255);
						} else {
							if (index == cmnum1) {
								gdl = shieldhit_render_component(gdl, NULL, prop1, model, node, -3, -1, -1, alpha);
							} else if (index == cmnum2) {
								gdl = shieldhit_render_component(gdl, NULL, prop1, model, node, -4, -1, -1, alpha);
							} else if (index == cmnum3) {
								gdl = shieldhit_render_component(gdl, NULL, prop1, model, node, -5, -1, -1, alpha);
							} else if (index == cmnum4) {
								gdl = shieldhit_render_component(gdl, NULL, prop1, model, node, -6, -1, -1, alpha);
							}
						}
					}
				}
			}

			if (node->child) {
				node = node->child;
			} else {
				while (node) {
					if (node->next) {
						node = node->next;
						break;
					}

					node = node->parent;
				}
			}
		}

		if (specificnode == NULL) {
			struct prop *child;

			for (child = prop2->child; child != NULL; child = child->next) {
				gdl = shieldhit_render(gdl, prop1, child, alpha, arg4, cmnum1, cmnum2, cmnum3, cmnum4);
			}
		}
	}

	return gdl;
}

/**
 * Render the cloak transition effect for a chr prop and any attached
 * child props such as held weapons or embedded knives.
 *
 * The function is initially called with both prop arguments being the chr prop.
 * The function iterates the child props and calls itself recursively, setting
 * thisprop to the current child being iterated.
 */
Gfx *chr_render_cloak(Gfx *gdl, struct prop *chrprop, struct prop *thisprop)
{
	struct model *model;
	struct modelnode *bbox = NULL;
	struct modelnode *node;

	if (thisprop->flags & PROPFLAG_ONTHISSCREENTHISTICK) {
		if (thisprop->type == PROPTYPE_CHR || thisprop->type == PROPTYPE_PLAYER) {
			model = thisprop->chr->model;
		} else {
			model = thisprop->obj->model;
			bbox = model_get_part(model->definition, MODELPART_BASIC_SHIELD);
		}

		if (thisprop->parent == NULL) {
			// Rendering the chr prop - configure renderer
			gDPPipeSync(gdl++);
			gDPSetScissor(gdl++, G_SC_NON_INTERLACE, 0, 0, 16, 16);
			gDPSetCycleType(gdl++, G_CYC_COPY);
			gDPSetTile(gdl++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 0, 0x0000, 5, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
			gDPSetTile(gdl++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 0, 0x0080, 4, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
			gDPSetTile(gdl++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 160, 0x0000, G_TX_RENDERTILE, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
			gDPSetTile(gdl++, G_IM_FMT_I, G_IM_SIZ_8b, 160, 0x0080, 1, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, 15);
			gSPTexture(gdl++, 0xffff, 0xffff, 0, G_TX_RENDERTILE, G_ON);
			gDPSetEnvColor(gdl++, 0xff, 0xff, 0xff, 0xff);
			gDPSetPrimColor(gdl++, 0, 0, 0xff, 0xff, 0xff, 0xff);
			gDPSetRenderMode(gdl++, G_RM_NOOP, G_RM_NOOP2);
			gDPSetCombineMode(gdl++, G_CC_DECALRGBA, G_CC_DECALRGBA);
			gDPSetTextureFilter(gdl++, G_TF_POINT);
			gDPSetTexturePersp(gdl++, G_TP_NONE);
			gDPSetColorDither(gdl++, G_CD_DISABLE);
			gDPSetAlphaDither(gdl++, G_AD_DISABLE);
			gDPSetTextureLOD(gdl++, G_TL_TILE);
			gDPSetTextureDetail(gdl++, G_TD_CLAMP);
			gDPSetTextureLUT(gdl++, G_TT_NONE);
			gDPSetAlphaCompare(gdl++, G_AC_NONE);
			gSPClearGeometryMode(gdl++, G_ZBUFFER);
		}

		// Iterate nodes in the prop and render each
		node = model->definition->rootnode;

		while (node) {
			if ((node->type & 0xff) == MODELNODETYPE_BBOX) {
				if (bbox == NULL || node == bbox) {
					s32 index = shieldhit_node_to_cmnum(thisprop, node, model, chrprop);

					if (bbox) {
						index = 19;
					}

					if (index <= 19) {
						Mtxf *mtx = model_find_node_mtx(model, model_node_find_mtx_node(node), 0);
						s32 uls; // upper left s coordinate
						s32 ult; // upper left t coordinate
						struct coord coord;
						f32 screenpos[2];
						s32 lrs; // lower right s coordinate
						s32 lrt; // lower right t coordinate

						coord.x = mtx->m[3][0];
						coord.y = mtx->m[3][1];
						coord.z = mtx->m[3][2];

						cam0f0b4d68(&coord, screenpos);

						if (screenpos[0] < 0.0f) {
							screenpos[0] = 0.0f;
						}

						if (screenpos[0] > vi_get_width()) {
							screenpos[0] = vi_get_width();
						}

						if (screenpos[1] < 0.0f) {
							screenpos[1] = 0.0f;
						}

						if (screenpos[1] > vi_get_height()) {
							screenpos[1] = vi_get_height();
						}

						uls = (s32)screenpos[0] - 8;
						ult = (s32)screenpos[1] - 8;

						if (uls < vi_get_view_left()) {
							uls = vi_get_view_left();
						}

						if (uls > vi_get_view_left() + vi_get_view_width() - 16) {
							uls = vi_get_view_left() + vi_get_view_width() - 16;
						}

						if (ult < vi_get_view_top()) {
							ult = vi_get_view_top();
						}

						if (ult > vi_get_view_top() + vi_get_view_height() - 16) {
							ult = vi_get_view_top() + vi_get_view_height() - 16;
						}

						lrs = uls + 15;
						lrt = ult + 15;

						gDPSetColorImage(gdl++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 16, OS_K0_TO_PHYSICAL(var8009ccc0[index]));
						gDPTileSync(gdl++);

						gDPLoadTextureTile(gdl++, vi_get_back_buffer(), G_IM_FMT_RGBA, G_IM_SIZ_16b,
								vi_get_width(), 0, uls, ult, lrs, lrt,
								0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
								4, 4, G_TX_NOLOD, G_TX_NOLOD);

						gDPPipeSync(gdl++);
						gSPTextureRectangle(gdl++, 0, 0, 60, 60, G_TX_RENDERTILE, 0, 0, 4096, 1024);
					}
				}
			}

			if (node->child) {
				node = node->child;
			} else {
				while (node) {
					if (node->next) {
						node = node->next;
						break;
					}

					node = node->parent;
				}
			}
		}

		// Render child props
		if (bbox == NULL) {
			struct prop *child;

			for (child = thisprop->child; child != NULL; child = child->next) {
				gdl = chr_render_cloak(gdl, chrprop, child);
			}
		}

		if (thisprop->parent == NULL) {
			// Back in the chr prop - reconfigure the renderer for normal use
			gDPPipeSync(gdl++);
			gDPLoadSync(gdl++);
			gDPTileSync(gdl++);
			gDPSetColorImage(gdl++, G_IM_FMT_RGBA, G_IM_SIZ_16b, vi_get_buf_width(), OS_K0_TO_PHYSICAL(vi_get_back_buffer()));
			gDPSetScissor(gdl++, G_SC_NON_INTERLACE, 0, 0, vi_get_width(), vi_get_height());
			gDPSetCycleType(gdl++, G_CYC_1CYCLE);
			gDPSetRenderMode(gdl++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
			gDPSetCombineMode(gdl++, G_CC_MODULATEI, G_CC_MODULATEI);
			gDPSetTextureFilter(gdl++, G_TF_BILERP);
			gDPSetTexturePersp(gdl++, G_TP_PERSP);
			gSPSetGeometryMode(gdl++, G_ZBUFFER);
		}
	}

	return gdl;
}

Gfx *chr_render_shield(Gfx *gdl, struct chrdata *chr, u32 alpha)
{
	if (chr_get_shield(chr) > 0 && g_Vars.lvupdate240 > 0) {
		chr->cmcount++;

		if (chr->cmcount > 300) {
			chr->cmcount = 0;
		}
	}

	if ((chr->hidden2 & CHRH2FLAG_SHIELDHIT)
			|| (chr_get_shield(chr) > 0 && chr->cmcount < 10)
			|| (chr->cloakfadefrac > 0 && !chr->cloakfadefinished)) {
		if (chr_get_shield(chr) > 0 && g_Vars.lvupdate240 > 0) {
			s32 numiterations = (random() % 4) + 1;
			s32 newcmnum = chr->cmnum2;
			s32 candidate;
			s8 operation = 0;
			s8 again = true;
			s32 i;

			for (i = 0; i <= numiterations; ) {
				if (operation == 0) {
					candidate = shieldhit_find_parentnode_cmnum(chr->prop, chr->cmnum);
					operation = 1;

					if (candidate >= 0) {
						if (candidate != chr->cmnum2) {
							newcmnum = candidate;
						}

						i++;
					} else {
						again = false;
					}
				} else if (operation == 1) {
					candidate = shieldhit_find_childnode_cmnum(chr->prop, chr->cmnum);

					if (candidate >= 0) {
						operation = 2;

						if (candidate != chr->cmnum2) {
							newcmnum = candidate;
						}

						i++;
					} else {
						if (again) {
							operation = 0;
						} else {
							break;
						}
					}
				} else if (operation == 2) {
					candidate = shieldhit_find_anynode_cmnum(chr->prop, candidate);

					if (candidate >= 0) {
						if (candidate != chr->cmnum2) {
							newcmnum = candidate;
						}

						i++;
					} else {
						operation = 0;
					}
				}
			}

			chr->cmnum4 = chr->cmnum3;
			chr->cmnum3 = chr->cmnum2;
			chr->cmnum2 = chr->cmnum;
			chr->cmnum = newcmnum;
		}

		gSPSetGeometryMode(gdl++, G_CULL_BACK);

		gdl = shieldhit_render(gdl, chr->prop, chr->prop, alpha,
				chr->cloakfadefrac > 0 && !chr->cloakfadefinished,
				chr->cmnum, chr->cmnum2, chr->cmnum3, chr->cmnum4);

		gSPSetGeometryMode(gdl++, G_CULL_BACK);
	}

	return gdl;
}

/**
 * This ticks the shield damage effect when you shoot a shielded chr.
 */
void shieldhits_tick(void)
{
	s32 index;
	bool changed = false;
	s32 time60;
	s32 i;
	s32 j;

	if (g_ShieldHitActive) {
		for (i = 0; i < MAX_SHIELDHITS; i++) {
			if (g_ShieldHits[i].prop) {
				if (g_ShieldHits[i].lvframe60 >= g_Vars.lvframe60 - TICKS(80)) {
					changed = true;
					g_ShieldHits[i].shield += (shieldhit_get_health(&g_ShieldHits[i].prop) - g_ShieldHits[i].shield) * g_Vars.lvupdate60f * (PAL ? 0.0151515156f : 0.0125f);
				}

				for (j = 0; j < 32; j++) {
					if (g_ShieldHits[i].unk018[j] >= 0) {
						changed = true;
						time60 = g_ShieldHits[i].unk018[j] + g_Vars.lvupdate60;

						if (g_ShieldHits[i].unk018[j] < 1 && time60 > 0) {
							index = shieldhit_find_parentnode_cmnum(g_ShieldHits[i].prop, j);

							if (index >= 0 && index < 32) {
								if (g_ShieldHits[i].unk018[index] == -1) {
									g_ShieldHits[i].unk018[index] = -3;
									g_ShieldHits[i].unk038[index] = g_ShieldHits[i].unk038[j] + 1;
								}
							}

							index = shieldhit_find_childnode_cmnum(g_ShieldHits[i].prop, j);

							while (index >= 0) {
								if (index < 32) {
									if (g_ShieldHits[i].unk018[index] == -1) {
										g_ShieldHits[i].unk018[index] = -3;
										g_ShieldHits[i].unk038[index] = g_ShieldHits[i].unk038[j] + 1;
									}
								}

								index = shieldhit_find_anynode_cmnum(g_ShieldHits[i].prop, index);
							}
						}

						if (time60 < TICKS(30)) {
							g_ShieldHits[i].unk018[j] = time60;
						} else {
							g_ShieldHits[i].unk018[j] = -2;
						}
					}
				}

				for (j = 0; j < 32; j++) {
					if (g_ShieldHits[i].unk018[j] == -3) {
						g_ShieldHits[i].unk018[j] = 0;
					}
				}

				if (!changed) {
					shieldhit_remove(&g_ShieldHits[i]);
				}
			}
		}
	}
}

void chr_set_drcaroll_images(struct chrdata *drcaroll, s32 imageleft, s32 imageright)
{
	if (drcaroll
			&& imageleft >= DRCAROLLIMAGE_EYESDEFAULT && imageleft <= DRCAROLLIMAGE_BINARY
			&& imageright >= DRCAROLLIMAGE_EYESDEFAULT && imageright <= DRCAROLLIMAGE_BINARY) {
		struct model *model = drcaroll->model;
		struct modelnode *nodes[2];
		union modelrwdata *rwdata;
		s32 i;
		s32 j;
		u32 stack;

		// Iterate model parts relating to images
		// Parts 0-5 are the left image
		// Parts 6-11 are the right image
		for (i = 0; i < 6; i++) {
			nodes[0] = model_get_part(model->definition, i);
			nodes[1] = model_get_part(model->definition, i + 6);

			for (j = 0; j < ARRAYCOUNT(nodes); j++) {
				if (nodes[j]) {
					rwdata = model_get_node_rw_data(model, nodes[j]);

					if (j == 0) {
						rwdata->toggle.visible = (imageleft == i) ? true : false;
					} else {
						rwdata->toggle.visible = (imageright == i) ? true : false;
					}
				}
			}
		}
	}
}