reorder folders

src/dlls/.gitignore

@@ -0,0 +1,3 @@
+msgs/
+opt.*/
+debug.*/

src/dlls/Makefile

@@ -0,0 +1,56 @@
+CPP = gcc
+BASEFLAGS = -Dstricmp=strcasecmp -Dstrcmpi=strcasecmp
+CPPFLAGS = ${BASEFLAGS} -m386 -O2 -w -I. -I../engine -I../common -I../pm_shared -I../../metamod
+
+OBJ = \
+	agrunt.o \
+	AI_BaseNPC_Schedule.o \
+	animating.o \
+	animation.o \
+	apache.o \
+	barney.o \
+	bigmomma.o \
+	bullsquid.o \
+	cmbase.o \
+	combat.o \
+	controller.o \
+	defaultai.o \
+	dllapi.o \
+	effects.o \
+	ggrenade.o \
+	h_ai.o \
+	h_export.o \
+	hassassin.o \
+	headcrab.o \
+	hgrunt.o \
+	hornet.o \
+	houndeye.o \
+	islave.o \
+	monster_api.o \
+	monster_config.o \
+	monsters.o \
+	monsterstate.o \
+	nodes.o \
+	scientist.o \
+	skill.o \
+	sound.o \
+	squeakgrenade.o \
+	subs.o \
+	talkmonster.o \
+	util.o \
+	weapons.o \
+	zombie.o
+
+monster_mm_i386.so: ${OBJ}
+	${CPP} -fPIC -shared -o $@ ${OBJ}
+
+clean:
+	-rm -f *.o
+	-rm -f *.so	
+
+%.o:	%.cpp
+	${CPP} ${CPPFLAGS} -c $< -o $@
+
+%.o:	%.c
+	${CPP} ${CPPFLAGS} -c $< -o $@
+

src/dlls/activity.h

@@ -0,0 +1,109 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+
+#ifndef	ACTIVITY_H
+#define	ACTIVITY_H
+
+
+typedef enum {
+	ACT_RESET = 0,		// Set m_Activity to this invalid value to force a reset to m_IdealActivity
+	ACT_IDLE = 1,
+	ACT_GUARD,
+	ACT_WALK,
+	ACT_RUN,
+	ACT_FLY,				// Fly (and flap if appropriate)
+	ACT_SWIM,
+	ACT_HOP,				// vertical jump
+	ACT_LEAP,				// long forward jump
+	ACT_FALL,
+	ACT_LAND,
+	ACT_STRAFE_LEFT,
+	ACT_STRAFE_RIGHT,
+	ACT_ROLL_LEFT,			// tuck and roll, left
+	ACT_ROLL_RIGHT,			// tuck and roll, right
+	ACT_TURN_LEFT,			// turn quickly left (stationary)
+	ACT_TURN_RIGHT,			// turn quickly right (stationary)
+	ACT_CROUCH,				// the act of crouching down from a standing position
+	ACT_CROUCHIDLE,			// holding body in crouched position (loops)
+	ACT_STAND,				// the act of standing from a crouched position
+	ACT_USE,
+	ACT_SIGNAL1,
+	ACT_SIGNAL2,
+	ACT_SIGNAL3,
+	ACT_TWITCH,
+	ACT_COWER,
+	ACT_SMALL_FLINCH,
+	ACT_BIG_FLINCH,
+	ACT_RANGE_ATTACK1,
+	ACT_RANGE_ATTACK2,
+	ACT_MELEE_ATTACK1,
+	ACT_MELEE_ATTACK2,
+	ACT_RELOAD,
+	ACT_ARM,				// pull out gun, for instance
+	ACT_DISARM,				// reholster gun
+	ACT_EAT,				// monster chowing on a large food item (loop)
+	ACT_DIESIMPLE,
+	ACT_DIEBACKWARD,
+	ACT_DIEFORWARD,
+	ACT_DIEVIOLENT,
+	ACT_BARNACLE_HIT,		// barnacle tongue hits a monster
+	ACT_BARNACLE_PULL,		// barnacle is lifting the monster ( loop )
+	ACT_BARNACLE_CHOMP,		// barnacle latches on to the monster
+	ACT_BARNACLE_CHEW,		// barnacle is holding the monster in its mouth ( loop )
+	ACT_SLEEP,
+	ACT_INSPECT_FLOOR,		// for active idles, look at something on or near the floor
+	ACT_INSPECT_WALL,		// for active idles, look at something directly ahead of you ( doesn't HAVE to be a wall or on a wall )
+	ACT_IDLE_ANGRY,			// alternate idle animation in which the monster is clearly agitated. (loop)
+	ACT_WALK_HURT,			// limp  (loop)
+	ACT_RUN_HURT,			// limp  (loop)
+	ACT_HOVER,				// Idle while in flight
+	ACT_GLIDE,				// Fly (don't flap)
+	ACT_FLY_LEFT,			// Turn left in flight
+	ACT_FLY_RIGHT,			// Turn right in flight
+	ACT_DETECT_SCENT,		// this means the monster smells a scent carried by the air
+	ACT_SNIFF,				// this is the act of actually sniffing an item in front of the monster
+	ACT_BITE,				// some large monsters can eat small things in one bite. This plays one time, EAT loops.
+	ACT_THREAT_DISPLAY,		// without attacking, monster demonstrates that it is angry. (Yell, stick out chest, etc )
+	ACT_FEAR_DISPLAY,		// monster just saw something that it is afraid of
+	ACT_EXCITED,			// for some reason, monster is excited. Sees something he really likes to eat, or whatever.
+	ACT_SPECIAL_ATTACK1,	// very monster specific special attacks.
+	ACT_SPECIAL_ATTACK2,	
+	ACT_COMBAT_IDLE,		// agitated idle.
+	ACT_WALK_SCARED,
+	ACT_RUN_SCARED,
+	ACT_VICTORY_DANCE,		// killed a player, do a victory dance.
+	ACT_DIE_HEADSHOT,		// die, hit in head. 
+	ACT_DIE_CHESTSHOT,		// die, hit in chest
+	ACT_DIE_GUTSHOT,		// die, hit in gut
+	ACT_DIE_BACKSHOT,		// die, hit in back
+	ACT_FLINCH_HEAD,
+	ACT_FLINCH_CHEST,
+	ACT_FLINCH_STOMACH,
+	ACT_FLINCH_LEFTARM,
+	ACT_FLINCH_RIGHTARM,
+	ACT_FLINCH_LEFTLEG,
+	ACT_FLINCH_RIGHTLEG,
+} Activity;
+
+
+typedef struct {
+	int	type;
+	char *name;
+} activity_map_t;
+
+extern activity_map_t activity_map[];
+
+
+#endif	//ACTIVITY_H

src/dlls/activitymap.h

@@ -0,0 +1,97 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+
+#define _A( a ) { a, #a }
+
+activity_map_t activity_map[] =
+{
+_A( ACT_IDLE ),
+_A(	ACT_GUARD ),
+_A(	ACT_WALK ),
+_A(	ACT_RUN ),
+_A(	ACT_FLY ),
+_A(	ACT_SWIM ),
+_A(	ACT_HOP ),
+_A(	ACT_LEAP ),
+_A(	ACT_FALL ),
+_A(	ACT_LAND ),
+_A(	ACT_STRAFE_LEFT ),
+_A(	ACT_STRAFE_RIGHT ),
+_A(	ACT_ROLL_LEFT ),
+_A(	ACT_ROLL_RIGHT ),
+_A(	ACT_TURN_LEFT ),
+_A(	ACT_TURN_RIGHT ),
+_A(	ACT_CROUCH ),
+_A(	ACT_CROUCHIDLE ),
+_A(	ACT_STAND ),
+_A(	ACT_USE ),
+_A(	ACT_SIGNAL1 ),
+_A(	ACT_SIGNAL2 ),
+_A(	ACT_SIGNAL3 ),
+_A(	ACT_TWITCH ),
+_A(	ACT_COWER ),
+_A(	ACT_SMALL_FLINCH ),
+_A(	ACT_BIG_FLINCH ),
+_A(	ACT_RANGE_ATTACK1 ),
+_A(	ACT_RANGE_ATTACK2 ),
+_A(	ACT_MELEE_ATTACK1 ),
+_A(	ACT_MELEE_ATTACK2 ),
+_A(	ACT_RELOAD ),
+_A(	ACT_ARM ),
+_A(	ACT_DISARM ),
+_A(	ACT_EAT ),
+_A(	ACT_DIESIMPLE ),
+_A(	ACT_DIEBACKWARD ),
+_A(	ACT_DIEFORWARD ),
+_A(	ACT_DIEVIOLENT ),
+_A(	ACT_BARNACLE_HIT ),
+_A(	ACT_BARNACLE_PULL ),
+_A(	ACT_BARNACLE_CHOMP ),
+_A(	ACT_BARNACLE_CHEW ),
+_A(	ACT_SLEEP ),
+_A(	ACT_INSPECT_FLOOR ),
+_A(	ACT_INSPECT_WALL ),
+_A(	ACT_IDLE_ANGRY ),
+_A(	ACT_WALK_HURT ),
+_A(	ACT_RUN_HURT ),
+_A(	ACT_HOVER ),
+_A(	ACT_GLIDE ),
+_A(	ACT_FLY_LEFT ),
+_A(	ACT_FLY_RIGHT ),
+_A(	ACT_DETECT_SCENT ),
+_A(	ACT_SNIFF ),		
+_A(	ACT_BITE ),		
+_A(	ACT_THREAT_DISPLAY ),
+_A(	ACT_FEAR_DISPLAY ),
+_A(	ACT_EXCITED ),	
+_A( ACT_SPECIAL_ATTACK1 ),
+_A( ACT_SPECIAL_ATTACK2 ),
+_A( ACT_COMBAT_IDLE		),
+_A(	ACT_WALK_SCARED ),
+_A(	ACT_RUN_SCARED ),
+_A( ACT_VICTORY_DANCE ),
+_A( ACT_DIE_HEADSHOT ),
+_A( ACT_DIE_CHESTSHOT ),
+_A( ACT_DIE_GUTSHOT ),
+_A( ACT_DIE_BACKSHOT ),
+_A(	ACT_FLINCH_HEAD ),
+_A(	ACT_FLINCH_CHEST ),
+_A(	ACT_FLINCH_STOMACH ),
+_A(	ACT_FLINCH_LEFTARM ),
+_A(	ACT_FLINCH_RIGHTARM ),
+_A(	ACT_FLINCH_LEFTLEG ),
+_A(	ACT_FLINCH_RIGHTLEG ),
+0, NULL
+};

src/dlls/animating.cpp

@@ -0,0 +1,306 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/*
+
+===== monsters.cpp ========================================================
+
+  Monster-related utility code
+
+*/
+
+#include "extdll.h"
+#include "util.h"
+#include "cmbase.h"
+#include "animation.h"
+
+
+//=========================================================
+// StudioFrameAdvance - advance the animation frame up to the current time
+// if an flInterval is passed in, only advance animation that number of seconds
+//=========================================================
+float CMBaseAnimating :: StudioFrameAdvance ( float flInterval )
+{
+	if (flInterval == 0.0)
+	{
+		flInterval = (gpGlobals->time - pev->animtime);
+		if (flInterval <= 0.001)
+		{
+			pev->animtime = gpGlobals->time;
+			return 0.0;
+		}
+	}
+	if (! pev->animtime)
+		flInterval = 0.0;
+	
+	pev->frame += flInterval * m_flFrameRate * pev->framerate;
+	pev->animtime = gpGlobals->time;
+
+	if (pev->frame < 0.0 || pev->frame >= 256.0) 
+	{
+		if (m_fSequenceLoops)
+			pev->frame -= (int)(pev->frame / 256.0) * 256.0;
+		else
+			pev->frame = (pev->frame < 0.0) ? 0 : 255;
+		m_fSequenceFinished = TRUE;	// just in case it wasn't caught in GetEvents
+	}
+
+	return flInterval;
+}
+
+//=========================================================
+// LookupActivity
+//=========================================================
+int CMBaseAnimating :: LookupActivity ( int activity )
+{
+	ASSERT( activity != 0 );
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return ::LookupActivity( pmodel, pev, activity );
+}
+
+//=========================================================
+// LookupActivityHeaviest
+//
+// Get activity with highest 'weight'
+//
+//=========================================================
+int CMBaseAnimating :: LookupActivityHeaviest ( int activity )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return ::LookupActivityHeaviest( pmodel, pev, activity );
+}
+
+//=========================================================
+//=========================================================
+int CMBaseAnimating :: LookupSequence ( const char *label )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return ::LookupSequence( pmodel, label );
+}
+
+
+//=========================================================
+//=========================================================
+void CMBaseAnimating :: ResetSequenceInfo ( )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	GetSequenceInfo( pmodel, pev, &m_flFrameRate, &m_flGroundSpeed );
+	m_fSequenceLoops = ((GetSequenceFlags() & STUDIO_LOOPING) != 0);
+	pev->animtime = gpGlobals->time;
+	pev->framerate = 1.0;
+	m_fSequenceFinished = FALSE;
+	m_flLastEventCheck = gpGlobals->time;
+}
+
+
+
+//=========================================================
+//=========================================================
+BOOL CMBaseAnimating :: GetSequenceFlags( )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return ::GetSequenceFlags( pmodel, pev );
+}
+
+//=========================================================
+// DispatchAnimEvents
+//=========================================================
+void CMBaseAnimating :: DispatchAnimEvents ( float flInterval )
+{
+	MonsterEvent_t	event;
+
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	if ( !pmodel )
+	{
+		ALERT( at_aiconsole, "Gibbed monster is thinking!\n" );
+		return;
+	}
+
+	// FIXME: I have to do this or some events get missed, and this is probably causing the problem below
+	flInterval = 0.1;
+
+	// FIX: this still sometimes hits events twice
+	float flStart = pev->frame + (m_flLastEventCheck - pev->animtime) * m_flFrameRate * pev->framerate;
+	float flEnd = pev->frame + flInterval * m_flFrameRate * pev->framerate;
+	m_flLastEventCheck = pev->animtime + flInterval;
+
+	m_fSequenceFinished = FALSE;
+	if (flEnd >= 256 || flEnd <= 0.0) 
+		m_fSequenceFinished = TRUE;
+
+	int index = 0;
+
+	while ( (index = GetAnimationEvent( pmodel, pev, &event, flStart, flEnd, index ) ) != 0 )
+	{
+		HandleAnimEvent( &event );
+	}
+}
+
+
+//=========================================================
+//=========================================================
+float CMBaseAnimating :: SetBoneController ( int iController, float flValue )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return SetController( pmodel, pev, iController, flValue );
+}
+
+//=========================================================
+//=========================================================
+void CMBaseAnimating :: InitBoneControllers ( void )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	SetController( pmodel, pev, 0, 0.0 );
+	SetController( pmodel, pev, 1, 0.0 );
+	SetController( pmodel, pev, 2, 0.0 );
+	SetController( pmodel, pev, 3, 0.0 );
+}
+
+//=========================================================
+//=========================================================
+float CMBaseAnimating :: SetBlending ( int iBlender, float flValue )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+
+	return ::SetBlending( pmodel, pev, iBlender, flValue );
+}
+
+//=========================================================
+//=========================================================
+void CMBaseAnimating :: GetBonePosition ( int iBone, Vector &origin, Vector &angles )
+{
+	GET_BONE_POSITION( ENT(pev), iBone, origin, angles );
+}
+
+//=========================================================
+//=========================================================
+void CMBaseAnimating :: GetAttachment ( int iAttachment, Vector &origin, Vector &angles )
+{
+	GET_ATTACHMENT( ENT(pev), iAttachment, origin, angles );
+}
+
+//=========================================================
+//=========================================================
+int CMBaseAnimating :: FindTransition( int iEndingSequence, int iGoalSequence, int *piDir )
+{
+	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+	
+	if (piDir == NULL)
+	{
+		int iDir;
+		int sequence = ::FindTransition( pmodel, iEndingSequence, iGoalSequence, &iDir );
+		if (iDir != 1)
+			return -1;
+		else
+			return sequence;
+	}
+
+	return ::FindTransition( pmodel, iEndingSequence, iGoalSequence, piDir );
+}
+
+//=========================================================
+//=========================================================
+void CMBaseAnimating :: GetAutomovement( Vector &origin, Vector &angles, float flInterval )
+{
+
+}
+
+void CMBaseAnimating :: SetBodygroup( int iGroup, int iValue )
+{
+	::SetBodygroup( GET_MODEL_PTR( ENT(pev) ), pev, iGroup, iValue );
+}
+
+int CMBaseAnimating :: GetBodygroup( int iGroup )
+{
+	return ::GetBodygroup( GET_MODEL_PTR( ENT(pev) ), pev, iGroup );
+}
+
+
+int CMBaseAnimating :: ExtractBbox( int sequence, float *mins, float *maxs )
+{
+	return ::ExtractBbox( GET_MODEL_PTR( ENT(pev) ), sequence, mins, maxs );
+}
+
+//=========================================================
+//=========================================================
+
+void CMBaseAnimating :: SetSequenceBox( void )
+{
+	Vector mins, maxs;
+
+	// Get sequence bbox
+	if ( ExtractBbox( pev->sequence, mins, maxs ) )
+	{
+		// expand box for rotation
+		// find min / max for rotations
+		float yaw = pev->angles.y * (M_PI / 180.0);
+		
+		Vector xvector, yvector;
+		xvector.x = cos(yaw);
+		xvector.y = sin(yaw);
+		yvector.x = -sin(yaw);
+		yvector.y = cos(yaw);
+		Vector bounds[2];
+
+		bounds[0] = mins;
+		bounds[1] = maxs;
+		
+		Vector rmin( 9999, 9999, 9999 );
+		Vector rmax( -9999, -9999, -9999 );
+		Vector base, transformed;
+
+		for (int i = 0; i <= 1; i++ )
+		{
+			base.x = bounds[i].x;
+			for ( int j = 0; j <= 1; j++ )
+			{
+				base.y = bounds[j].y;
+				for ( int k = 0; k <= 1; k++ )
+				{
+					base.z = bounds[k].z;
+					
+				// transform the point
+					transformed.x = xvector.x*base.x + yvector.x*base.y;
+					transformed.y = xvector.y*base.x + yvector.y*base.y;
+					transformed.z = base.z;
+					
+					if (transformed.x < rmin.x)
+						rmin.x = transformed.x;
+					if (transformed.x > rmax.x)
+						rmax.x = transformed.x;
+					if (transformed.y < rmin.y)
+						rmin.y = transformed.y;
+					if (transformed.y > rmax.y)
+						rmax.y = transformed.y;
+					if (transformed.z < rmin.z)
+						rmin.z = transformed.z;
+					if (transformed.z > rmax.z)
+						rmax.z = transformed.z;
+				}
+			}
+		}
+		rmin.z = 0;
+		rmax.z = rmin.z + 1;
+		UTIL_SetSize( pev, rmin, rmax );
+	}
+}
+

src/dlls/animation.cpp

@@ -0,0 +1,521 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../common/nowin.h"
+
+typedef int BOOL;
+#define TRUE	 1	
+#define FALSE	0
+
+// hack into header files that we can ship
+typedef int qboolean;
+typedef unsigned char byte;
+#include "../utils/common/mathlib.h"
+#include "const.h"
+#include "progdefs.h"
+#include "edict.h"
+#include "eiface.h"
+
+#include "studio.h"
+
+#ifndef ACTIVITY_H
+#include "activity.h"
+#endif
+
+#include "activitymap.h"
+
+#ifndef ANIMATION_H
+#include "animation.h"
+#endif
+
+#ifndef ENGINECALLBACK_H
+#include "enginecallback.h"
+#endif
+
+extern globalvars_t				*gpGlobals;
+
+#pragma warning( disable : 4244 )
+
+
+
+int ExtractBbox( void *pmodel, int sequence, float *mins, float *maxs )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+	
+	mins[0] = pseqdesc[ sequence ].bbmin[0];
+	mins[1] = pseqdesc[ sequence ].bbmin[1];
+	mins[2] = pseqdesc[ sequence ].bbmin[2];
+
+	maxs[0] = pseqdesc[ sequence ].bbmax[0];
+	maxs[1] = pseqdesc[ sequence ].bbmax[1];
+	maxs[2] = pseqdesc[ sequence ].bbmax[2];
+
+	return 1;
+}
+
+
+int LookupActivity( void *pmodel, entvars_t *pev, int activity )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+
+	int weighttotal = 0;
+	int seq = ACTIVITY_NOT_AVAILABLE;
+	for (int i = 0; i < pstudiohdr->numseq; i++)
+	{
+		if (pseqdesc[i].activity == activity)
+		{
+			weighttotal += pseqdesc[i].actweight;
+			if (!weighttotal || RANDOM_LONG(0,weighttotal-1) < pseqdesc[i].actweight)
+				seq = i;
+		}
+	}
+
+	return seq;
+}
+
+
+int LookupActivityHeaviest( void *pmodel, entvars_t *pev, int activity )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if ( !pstudiohdr )
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+
+	int weight = 0;
+	int seq = ACTIVITY_NOT_AVAILABLE;
+	for (int i = 0; i < pstudiohdr->numseq; i++)
+	{
+		if (pseqdesc[i].activity == activity)
+		{
+			if ( pseqdesc[i].actweight > weight )
+			{
+				weight = pseqdesc[i].actweight;
+				seq = i;
+			}
+		}
+	}
+
+	return seq;
+}
+
+void GetEyePosition ( void *pmodel, float *vecEyePosition )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+
+	if ( !pstudiohdr )
+	{
+		ALERT ( at_console, "GetEyePosition() Can't get pstudiohdr ptr!\n" );
+		return;
+	}
+
+	VectorCopy ( pstudiohdr->eyeposition, vecEyePosition );
+}
+
+int LookupSequence( void *pmodel, const char *label )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+
+	for (int i = 0; i < pstudiohdr->numseq; i++)
+	{
+		if (stricmp( pseqdesc[i].label, label ) == 0)
+			return i;
+	}
+
+	return -1;
+}
+
+
+int IsSoundEvent( int eventNumber )
+{
+	return 0;
+}
+
+
+void SequencePrecache( void *pmodel, const char *pSequenceName )
+{
+	int index = LookupSequence( pmodel, pSequenceName );
+	if ( index >= 0 )
+	{
+		studiohdr_t *pstudiohdr;
+	
+		pstudiohdr = (studiohdr_t *)pmodel;
+		if ( !pstudiohdr || index >= pstudiohdr->numseq )
+			return;
+
+		mstudioseqdesc_t	*pseqdesc;
+		mstudioevent_t		*pevent;
+
+		pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + index;
+		pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
+
+		for (int i = 0; i < pseqdesc->numevents; i++)
+		{
+			// Don't send client-side events to the server AI
+			if ( pevent[i].event >= EVENT_CLIENT )
+				continue;
+
+			// UNDONE: Add a callback to check to see if a sound is precached yet and don't allocate a copy
+			// of it's name if it is.
+			if ( IsSoundEvent( pevent[i].event ) )
+			{
+				if ( !strlen(pevent[i].options) )
+				{
+					ALERT( at_error, "Bad sound event %d in sequence %s :: %s (sound is \"%s\")\n", pevent[i].event, pstudiohdr->name, pSequenceName, pevent[i].options );
+				}
+
+				PRECACHE_SOUND( (char *)(gpGlobals->pStringBase + ALLOC_STRING(pevent[i].options) ) );
+			}
+		}
+	}
+}
+
+
+
+void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *pflGroundSpeed )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	if (pev->sequence >= pstudiohdr->numseq)
+	{
+		*pflFrameRate = 0.0;
+		*pflGroundSpeed = 0.0;
+		return;
+	}
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+
+	if (pseqdesc->numframes > 1)
+	{
+		*pflFrameRate = 256 * pseqdesc->fps / (pseqdesc->numframes - 1);
+		*pflGroundSpeed = sqrt( pseqdesc->linearmovement[0]*pseqdesc->linearmovement[0]+ pseqdesc->linearmovement[1]*pseqdesc->linearmovement[1]+ pseqdesc->linearmovement[2]*pseqdesc->linearmovement[2] );
+		*pflGroundSpeed = *pflGroundSpeed * pseqdesc->fps / (pseqdesc->numframes - 1);
+	}
+	else
+	{
+		*pflFrameRate = 256.0;
+		*pflGroundSpeed = 0.0;
+	}
+}
+
+
+int GetSequenceFlags( void *pmodel, entvars_t *pev )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if ( !pstudiohdr || pev->sequence >= pstudiohdr->numseq )
+		return 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+
+	return pseqdesc->flags;
+}
+
+
+int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if ( !pstudiohdr || pev->sequence >= pstudiohdr->numseq || !pMonsterEvent )
+		return 0;
+
+	int events = 0;
+
+	mstudioseqdesc_t	*pseqdesc;
+	mstudioevent_t		*pevent;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+	pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
+
+	if (pseqdesc->numevents == 0 || index > pseqdesc->numevents )
+		return 0;
+
+	if (pseqdesc->numframes > 1)
+	{
+		flStart *= (pseqdesc->numframes - 1) / 256.0;
+		flEnd *= (pseqdesc->numframes - 1) / 256.0;
+	}
+	else
+	{
+		flStart = 0;
+		flEnd = 1.0;
+	}
+
+	for (; index < pseqdesc->numevents; index++)
+	{
+		// Don't send client-side events to the server AI
+		if ( pevent[index].event >= EVENT_CLIENT )
+			continue;
+
+		if ( (pevent[index].frame >= flStart && pevent[index].frame < flEnd) || 
+			((pseqdesc->flags & STUDIO_LOOPING) && flEnd >= pseqdesc->numframes - 1 && pevent[index].frame < flEnd - pseqdesc->numframes + 1) )
+		{
+			pMonsterEvent->event = pevent[index].event;
+			pMonsterEvent->options = pevent[index].options;
+			return index + 1;
+		}
+	}
+	return 0;
+}
+
+float SetController( void *pmodel, entvars_t *pev, int iController, float flValue )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return flValue;
+
+	mstudiobonecontroller_t	*pbonecontroller = (mstudiobonecontroller_t *)((byte *)pstudiohdr + pstudiohdr->bonecontrollerindex);
+
+	// find first controller that matches the index
+	for (int i = 0; i < pstudiohdr->numbonecontrollers; i++, pbonecontroller++)
+	{
+		if (pbonecontroller->index == iController)
+			break;
+	}
+	if (i >= pstudiohdr->numbonecontrollers)
+		return flValue;
+
+	// wrap 0..360 if it's a rotational controller
+
+	if (pbonecontroller->type & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
+	{
+		// ugly hack, invert value if end < start
+		if (pbonecontroller->end < pbonecontroller->start)
+			flValue = -flValue;
+
+		// does the controller not wrap?
+		if (pbonecontroller->start + 359.0 >= pbonecontroller->end)
+		{
+			if (flValue > ((pbonecontroller->start + pbonecontroller->end) / 2.0) + 180)
+				flValue = flValue - 360;
+			if (flValue < ((pbonecontroller->start + pbonecontroller->end) / 2.0) - 180)
+				flValue = flValue + 360;
+		}
+		else
+		{
+			if (flValue > 360)
+				flValue = flValue - (int)(flValue / 360.0) * 360.0;
+			else if (flValue < 0)
+				flValue = flValue + (int)((flValue / -360.0) + 1) * 360.0;
+		}
+	}
+
+	int setting = 255 * (flValue - pbonecontroller->start) / (pbonecontroller->end - pbonecontroller->start);
+
+	if (setting < 0) setting = 0;
+	if (setting > 255) setting = 255;
+	pev->controller[iController] = setting;
+
+	return setting * (1.0 / 255.0) * (pbonecontroller->end - pbonecontroller->start) + pbonecontroller->start;
+}
+
+
+float SetBlending( void *pmodel, entvars_t *pev, int iBlender, float flValue )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return flValue;
+
+	mstudioseqdesc_t	*pseqdesc;
+
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+
+	if (pseqdesc->blendtype[iBlender] == 0)
+		return flValue;
+
+	if (pseqdesc->blendtype[iBlender] & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
+	{
+		// ugly hack, invert value if end < start
+		if (pseqdesc->blendend[iBlender] < pseqdesc->blendstart[iBlender])
+			flValue = -flValue;
+
+		// does the controller not wrap?
+		if (pseqdesc->blendstart[iBlender] + 359.0 >= pseqdesc->blendend[iBlender])
+		{
+			if (flValue > ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) + 180)
+				flValue = flValue - 360;
+			if (flValue < ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) - 180)
+				flValue = flValue + 360;
+		}
+	}
+
+	int setting = 255 * (flValue - pseqdesc->blendstart[iBlender]) / (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]);
+
+	if (setting < 0) setting = 0;
+	if (setting > 255) setting = 255;
+
+	pev->blending[iBlender] = setting;
+
+	return setting * (1.0 / 255.0) * (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]) + pseqdesc->blendstart[iBlender];
+}
+
+
+
+
+int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return iGoalAnim;
+
+	mstudioseqdesc_t	*pseqdesc;
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+
+	// bail if we're going to or from a node 0
+	if (pseqdesc[iEndingAnim].entrynode == 0 || pseqdesc[iGoalAnim].entrynode == 0)
+	{
+		return iGoalAnim;
+	}
+
+	int	iEndNode;
+
+	// ALERT( at_console, "from %d to %d: ", pEndNode->iEndNode, pGoalNode->iStartNode );
+
+	if (*piDir > 0)
+	{
+		iEndNode = pseqdesc[iEndingAnim].exitnode;
+	}
+	else
+	{
+		iEndNode = pseqdesc[iEndingAnim].entrynode;
+	}
+
+	if (iEndNode == pseqdesc[iGoalAnim].entrynode)
+	{
+		*piDir = 1;
+		return iGoalAnim;
+	}
+
+	byte *pTransition = ((byte *)pstudiohdr + pstudiohdr->transitionindex);
+
+	int iInternNode = pTransition[(iEndNode-1)*pstudiohdr->numtransitions + (pseqdesc[iGoalAnim].entrynode-1)];
+
+	if (iInternNode == 0)
+		return iGoalAnim;
+
+	int i;
+
+	// look for someone going
+	for (i = 0; i < pstudiohdr->numseq; i++)
+	{
+		if (pseqdesc[i].entrynode == iEndNode && pseqdesc[i].exitnode == iInternNode)
+		{
+			*piDir = 1;
+			return i;
+		}
+		if (pseqdesc[i].nodeflags)
+		{
+			if (pseqdesc[i].exitnode == iEndNode && pseqdesc[i].entrynode == iInternNode)
+			{
+				*piDir = -1;
+				return i;
+			}
+		}
+	}
+
+	ALERT( at_console, "error in transition graph" );
+	return iGoalAnim;
+}
+
+void SetBodygroup( void *pmodel, entvars_t *pev, int iGroup, int iValue )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return;
+
+	if (iGroup > pstudiohdr->numbodyparts)
+		return;
+
+	mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
+
+	if (iValue >= pbodypart->nummodels)
+		return;
+
+	int iCurrent = (pev->body / pbodypart->base) % pbodypart->nummodels;
+
+	pev->body = (pev->body - (iCurrent * pbodypart->base) + (iValue * pbodypart->base));
+}
+
+
+int GetBodygroup( void *pmodel, entvars_t *pev, int iGroup )
+{
+	studiohdr_t *pstudiohdr;
+	
+	pstudiohdr = (studiohdr_t *)pmodel;
+	if (! pstudiohdr)
+		return 0;
+
+	if (iGroup > pstudiohdr->numbodyparts)
+		return 0;
+
+	mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
+
+	if (pbodypart->nummodels <= 1)
+		return 0;
+
+	int iCurrent = (pev->body / pbodypart->base) % pbodypart->nummodels;
+
+	return iCurrent;
+}

src/dlls/animation.h

@@ -0,0 +1,47 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef ANIMATION_H
+#define ANIMATION_H
+
+#define ACTIVITY_NOT_AVAILABLE		-1
+
+#ifndef MONSTEREVENT_H
+#include "monsterevent.h"
+#endif
+
+extern int IsSoundEvent( int eventNumber );
+
+int LookupActivity( void *pmodel, entvars_t *pev, int activity );
+int LookupActivityHeaviest( void *pmodel, entvars_t *pev, int activity );
+int LookupSequence( void *pmodel, const char *label );
+void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *pflGroundSpeed );
+int GetSequenceFlags( void *pmodel, entvars_t *pev );
+int LookupAnimationEvents( void *pmodel, entvars_t *pev, float flStart, float flEnd );
+float SetController( void *pmodel, entvars_t *pev, int iController, float flValue );
+float SetBlending( void *pmodel, entvars_t *pev, int iBlender, float flValue );
+void GetEyePosition( void *pmodel, float *vecEyePosition );
+void SequencePrecache( void *pmodel, const char *pSequenceName );
+int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir );
+void SetBodygroup( void *pmodel, entvars_t *pev, int iGroup, int iValue );
+int GetBodygroup( void *pmodel, entvars_t *pev, int iGroup );
+
+int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index );
+int ExtractBbox( void *pmodel, int sequence, float *mins, float *maxs );
+
+// From /engine/studio.h
+#define STUDIO_LOOPING		0x0001
+
+
+#endif	//ANIMATION_H

src/dlls/apache.cpp

@@ -0,0 +1,977 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+#ifndef OEM_BUILD
+
+#include "extdll.h"
+#include "util.h"
+#include "cmbase.h"
+#include "cmbasemonster.h"
+#include "monsters.h"
+#include "weapons.h"
+#include "nodes.h"
+#include "effects.h"
+#include "explode.h"
+
+
+#define SF_WAITFORTRIGGER	(0x04 | 0x40) // UNDONE: Fix!
+#define SF_NOWRECKAGE		0x08
+
+void CMApache :: Spawn( void )
+{
+	Precache( );
+	// motor
+	pev->movetype = MOVETYPE_FLY;
+	pev->solid = SOLID_BBOX;
+
+	SET_MODEL(ENT(pev), "models/apache.mdl");
+	UTIL_SetSize( pev, Vector( -32, -32, -64 ), Vector( 32, 32, 0 ) );
+	UTIL_SetOrigin( pev, pev->origin );
+
+	pev->flags |= FL_MONSTER;
+	pev->takedamage		= DAMAGE_AIM;
+	pev->health			= gSkillData.apacheHealth;
+
+	m_flFieldOfView = -0.707; // 270 degrees
+
+	pev->sequence = 0;
+	ResetSequenceInfo( );
+	pev->frame = RANDOM_LONG(0, 0xFF);
+
+	InitBoneControllers();
+
+	if (pev->spawnflags & SF_WAITFORTRIGGER)
+	{
+		SetUse( StartupUse );
+	}
+	else
+	{
+		SetThink( HuntThink );
+		SetTouch( FlyTouch );
+		pev->nextthink = gpGlobals->time + 1.0;
+	}
+
+	m_iRockets = 10;
+	m_pBeam = NULL;
+
+   m_pGoalEnt = NULL;
+	m_flGoalSpeed = 0.0f;
+
+	m_flForce = 0.0f;
+	m_flNextRocket = 0.0f;
+
+	Vector m_vecTarget = g_vecZero;
+	Vector m_posTarget = g_vecZero;
+
+	Vector m_vecDesired = g_vecZero;
+	Vector m_posDesired = g_vecZero;
+
+	Vector m_vecGoal = g_vecZero;
+	Vector m_angGun = g_vecZero;
+
+	m_flLastSeen = 0.0f;
+	m_flPrevSeen = 0.0f;
+
+	m_iSoundState = 0;
+}
+
+
+void CMApache::Precache( void )
+{
+	PRECACHE_MODEL("models/apache.mdl");
+
+	PRECACHE_SOUND("apache/ap_rotor1.wav");
+	PRECACHE_SOUND("apache/ap_rotor2.wav");
+	PRECACHE_SOUND("apache/ap_rotor3.wav");
+	PRECACHE_SOUND("apache/ap_whine1.wav");
+
+	PRECACHE_SOUND("weapons/mortarhit.wav");
+
+	m_iSpriteTexture = PRECACHE_MODEL( "sprites/white.spr" );
+
+	PRECACHE_SOUND("turret/tu_fire1.wav");
+
+	PRECACHE_MODEL("sprites/lgtning.spr");
+
+	m_iExplode	= PRECACHE_MODEL( "sprites/fexplo.spr" );
+	m_iBodyGibs = PRECACHE_MODEL( "models/metalplategibs_green.mdl" );
+
+   CMApacheHVR apache_rocket;
+   apache_rocket.Precache();
+}
+
+
+
+void CMApache::NullThink( void )
+{
+	StudioFrameAdvance( );
+	pev->nextthink = gpGlobals->time + 0.5;
+}
+
+
+void CMApache::StartupUse( edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value )
+{
+	SetThink( HuntThink );
+	SetTouch( FlyTouch );
+	pev->nextthink = gpGlobals->time + 0.1;
+	SetUse( NULL );
+}
+
+void CMApache :: Killed( entvars_t *pevAttacker, int iGib )
+{
+	pev->movetype = MOVETYPE_TOSS;
+	pev->gravity = 0.3;
+
+	STOP_SOUND( ENT(pev), CHAN_STATIC, "apache/ap_rotor2.wav" );
+
+	UTIL_SetSize( pev, Vector( -32, -32, -64), Vector( 32, 32, 0) );
+	SetThink( DyingThink );
+	SetTouch( CrashTouch );
+	pev->nextthink = gpGlobals->time + 0.1;
+	pev->health = 0;
+	pev->takedamage = DAMAGE_NO;
+
+	if (pev->spawnflags & SF_NOWRECKAGE)
+	{
+		m_flNextRocket = gpGlobals->time + 4.0;
+	}
+	else
+	{
+		m_flNextRocket = gpGlobals->time + 15.0;
+	}
+}
+
+void CMApache :: DyingThink( void )
+{
+	StudioFrameAdvance( );
+	pev->nextthink = gpGlobals->time + 0.1;
+
+	pev->avelocity = pev->avelocity * 1.02;
+
+	// still falling?
+	if (m_flNextRocket > gpGlobals->time )
+	{
+		if (g_sModelIndexFireball == 0)
+			g_sModelIndexFireball = PRECACHE_MODEL ("sprites/zerogxplode.spr"); // fireball
+
+		// random explosions
+		MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
+			WRITE_BYTE( TE_EXPLOSION);		// This just makes a dynamic light now
+			WRITE_COORD( pev->origin.x + RANDOM_FLOAT( -150, 150 ));
+			WRITE_COORD( pev->origin.y + RANDOM_FLOAT( -150, 150 ));
+			WRITE_COORD( pev->origin.z + RANDOM_FLOAT( -150, -50 ));
+			WRITE_SHORT( g_sModelIndexFireball );
+			WRITE_BYTE( RANDOM_LONG(0,29) + 30  ); // scale * 10
+			WRITE_BYTE( 12  ); // framerate
+			WRITE_BYTE( TE_EXPLFLAG_NONE );
+		MESSAGE_END();
+
+		if (g_sModelIndexSmoke == 0)
+			g_sModelIndexSmoke = PRECACHE_MODEL ("sprites/steam1.spr"); // smoke
+
+		// lots of smoke
+		MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
+			WRITE_BYTE( TE_SMOKE );
+			WRITE_COORD( pev->origin.x + RANDOM_FLOAT( -150, 150 ));
+			WRITE_COORD( pev->origin.y + RANDOM_FLOAT( -150, 150 ));
+			WRITE_COORD( pev->origin.z + RANDOM_FLOAT( -150, -50 ));
+			WRITE_SHORT( g_sModelIndexSmoke );
+			WRITE_BYTE( 100 ); // scale * 10
+			WRITE_BYTE( 10  ); // framerate
+		MESSAGE_END();
+
+		Vector vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;
+		MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
+			WRITE_BYTE( TE_BREAKMODEL);
+
+			// position
+			WRITE_COORD( vecSpot.x );
+			WRITE_COORD( vecSpot.y );
+			WRITE_COORD( vecSpot.z );
+
+			// size
+			WRITE_COORD( 400 );
+			WRITE_COORD( 400 );
+			WRITE_COORD( 132 );
+
+			// velocity
+			WRITE_COORD( pev->velocity.x ); 
+			WRITE_COORD( pev->velocity.y );
+			WRITE_COORD( pev->velocity.z );
+
+			// randomization
+			WRITE_BYTE( 50 ); 
+
+			// Model
+			WRITE_SHORT( m_iBodyGibs );	//model id#
+
+			// # of shards
+			WRITE_BYTE( 4 );	// let client decide
+
+			// duration
+			WRITE_BYTE( 30 );// 3.0 seconds
+
+			// flags
+
+			WRITE_BYTE( BREAK_METAL );
+		MESSAGE_END();
+
+		// don't stop it we touch a entity
+		pev->flags &= ~FL_ONGROUND;
+		pev->nextthink = gpGlobals->time + 0.2;
+		return;
+	}
+	else
+	{
+		Vector vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;
+
+		/*
+		MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
+			WRITE_BYTE( TE_EXPLOSION);		// This just makes a dynamic light now
+			WRITE_COORD( vecSpot.x );
+			WRITE_COORD( vecSpot.y );
+			WRITE_COORD( vecSpot.z + 300 );
+			WRITE_SHORT( g_sModelIndexFireball );
+			WRITE_BYTE( 250 ); // scale * 10
+			WRITE_BYTE( 8  ); // framerate
+		MESSAGE_END();
+		*/
+
+		// fireball
+		MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
+			WRITE_BYTE( TE_SPRITE );
+			WRITE_COORD( vecSpot.x );
+			WRITE_COORD( vecSpot.y );
+			WRITE_COORD( vecSpot.z + 256 );
+			WRITE_SHORT( m_iExplode );
+			WRITE_BYTE( 120 ); // scale * 10
+			WRITE_BYTE( 255 ); // brightness
+		MESSAGE_END();
+		
+		// big smoke
+		MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
+			WRITE_BYTE( TE_SMOKE );
+			WRITE_COORD( vecSpot.x );
+			WRITE_COORD( vecSpot.y );
+			WRITE_COORD( vecSpot.z + 512 );
+			WRITE_SHORT( g_sModelIndexSmoke );
+			WRITE_BYTE( 250 ); // scale * 10
+			WRITE_BYTE( 5  ); // framerate
+		MESSAGE_END();
+
+		// blast circle
+		MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
+			WRITE_BYTE( TE_BEAMCYLINDER );
+			WRITE_COORD( pev->origin.x);
+			WRITE_COORD( pev->origin.y);
+			WRITE_COORD( pev->origin.z);
+			WRITE_COORD( pev->origin.x);
+			WRITE_COORD( pev->origin.y);
+			WRITE_COORD( pev->origin.z + 2000 ); // reach damage radius over .2 seconds
+			WRITE_SHORT( m_iSpriteTexture );
+			WRITE_BYTE( 0 ); // startframe
+			WRITE_BYTE( 0 ); // framerate
+			WRITE_BYTE( 4 ); // life
+			WRITE_BYTE( 32 );  // width
+			WRITE_BYTE( 0 );   // noise
+			WRITE_BYTE( 255 );   // r, g, b
+			WRITE_BYTE( 255 );   // r, g, b
+			WRITE_BYTE( 192 );   // r, g, b
+			WRITE_BYTE( 128 ); // brightness
+			WRITE_BYTE( 0 );		// speed
+		MESSAGE_END();
+
+		EMIT_SOUND(ENT(pev), CHAN_STATIC, "weapons/mortarhit.wav", 1.0, 0.3);
+
+		RadiusDamage( pev->origin, pev, pev, 300, CLASS_NONE, DMG_BLAST );
+
+		if (/*!(pev->spawnflags & SF_NOWRECKAGE) && */(pev->flags & FL_ONGROUND))
+		{
+/*jlb
+			CMBaseEntity *pWreckage = Create( "cycler_wreckage", pev->origin, pev->angles );
+			// SET_MODEL( ENT(pWreckage->pev), STRING(pev->model) );
+			UTIL_SetSize( pWreckage->pev, Vector( -200, -200, -128 ), Vector( 200, 200, -32 ) );
+			pWreckage->pev->frame = pev->frame;
+			pWreckage->pev->sequence = pev->sequence;
+			pWreckage->pev->framerate = 0;
+			pWreckage->pev->dmgtime = gpGlobals->time + 5;
+jlb*/
+		}
+
+		// gibs
+		vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;
+		MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
+			WRITE_BYTE( TE_BREAKMODEL);
+
+			// position
+			WRITE_COORD( vecSpot.x );
+			WRITE_COORD( vecSpot.y );
+			WRITE_COORD( vecSpot.z + 64);
+
+			// size
+			WRITE_COORD( 400 );
+			WRITE_COORD( 400 );
+			WRITE_COORD( 128 );
+
+			// velocity
+			WRITE_COORD( 0 ); 
+			WRITE_COORD( 0 );
+			WRITE_COORD( 200 );
+
+			// randomization
+			WRITE_BYTE( 30 ); 
+
+			// Model
+			WRITE_SHORT( m_iBodyGibs );	//model id#
+
+			// # of shards
+			WRITE_BYTE( 200 );
+
+			// duration
+			WRITE_BYTE( 200 );// 10.0 seconds
+
+			// flags
+
+			WRITE_BYTE( BREAK_METAL );
+		MESSAGE_END();
+
+		SetThink( SUB_Remove );
+		pev->nextthink = gpGlobals->time + 0.1;
+	}
+}
+
+
+void CMApache::FlyTouch( edict_t *pOther )
+{
+	// bounce if we hit something solid
+	if ( pOther->v.solid == SOLID_BSP) 
+	{
+		TraceResult tr = UTIL_GetGlobalTrace( );
+
+		// UNDONE, do a real bounce
+		pev->velocity = pev->velocity + tr.vecPlaneNormal * (pev->velocity.Length() + 200);
+	}
+}
+
+
+void CMApache::CrashTouch( edict_t *pOther )
+{
+	// only crash if we hit something solid
+	if ( pOther->v.solid == SOLID_BSP) 
+	{
+		SetTouch( NULL );
+		m_flNextRocket = gpGlobals->time;
+		pev->nextthink = gpGlobals->time;
+	}
+}
+
+
+
+void CMApache :: GibMonster( void )
+{
+	// EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "common/bodysplat.wav", 0.75, ATTN_NORM, 0, 200);		
+}
+
+
+void CMApache :: HuntThink( void )
+{
+	StudioFrameAdvance( );
+	pev->nextthink = gpGlobals->time + 0.1;
+
+	ShowDamage( );
+
+	if ( m_pGoalEnt == NULL && !FStringNull(pev->target) )// this monster has a target
+	{
+		m_pGoalEnt = UTIL_FindEntityByTargetname( NULL, STRING( pev->target ) );
+		if (m_pGoalEnt)
+		{
+			m_posDesired = m_pGoalEnt->v.origin;
+			UTIL_MakeAimVectors( m_pGoalEnt->v.angles );
+			m_vecGoal = gpGlobals->v_forward;
+		}
+	}
+
+	// if (m_hEnemy == NULL)
+	{
+		Look( 4092 );
+		m_hEnemy = BestVisibleEnemy( );
+	}
+
+	// generic speed up
+	if (m_flGoalSpeed < 800)
+		m_flGoalSpeed += 5;
+
+	if (m_hEnemy != NULL)
+	{
+		// ALERT( at_console, "%s\n", STRING( m_hEnemy->pev->classname ) );
+		if (UTIL_FVisible( m_hEnemy, this->edict() ))
+		{
+			if (m_flLastSeen < gpGlobals->time - 5)
+				m_flPrevSeen = gpGlobals->time;
+			m_flLastSeen = gpGlobals->time;
+			m_posTarget = UTIL_Center( m_hEnemy );
+		}
+		else
+		{
+			m_hEnemy = NULL;
+		}
+	}
+
+	m_vecTarget = (m_posTarget - pev->origin).Normalize();
+
+	float flLength = (pev->origin - m_posDesired).Length();
+
+	if (m_pGoalEnt)
+	{
+		// ALERT( at_console, "%.0f\n", flLength );
+
+		if (flLength < 128)
+		{
+			m_pGoalEnt = UTIL_FindEntityByTargetname( NULL, STRING( m_pGoalEnt->v.target ) );
+			if (m_pGoalEnt)
+			{
+				m_posDesired = m_pGoalEnt->v.origin;
+				UTIL_MakeAimVectors( m_pGoalEnt->v.angles );
+				m_vecGoal = gpGlobals->v_forward;
+				flLength = (pev->origin - m_posDesired).Length();
+			}
+		}
+	}
+	else
+	{
+		m_posDesired = pev->origin;
+	}
+
+	if (flLength > 250) // 500
+	{
+		// float flLength2 = (m_posTarget - pev->origin).Length() * (1.5 - DotProduct((m_posTarget - pev->origin).Normalize(), pev->velocity.Normalize() ));
+		// if (flLength2 < flLength)
+		if (m_flLastSeen + 90 > gpGlobals->time && DotProduct( (m_posTarget - pev->origin).Normalize(), (m_posDesired - pev->origin).Normalize( )) > 0.25)
+		{
+			m_vecDesired = (m_posTarget - pev->origin).Normalize( );
+		}
+		else
+		{
+			m_vecDesired = (m_posDesired - pev->origin).Normalize( );
+		}
+	}
+	else
+	{
+		m_vecDesired = m_vecGoal;
+	}
+
+	Flight( );
+
+	// ALERT( at_console, "%.0f %.0f %.0f\n", gpGlobals->time, m_flLastSeen, m_flPrevSeen );
+	if ((m_flLastSeen + 1 > gpGlobals->time) && (m_flPrevSeen + 2 < gpGlobals->time))
+	{
+		if (FireGun( ))
+		{
+			// slow down if we're fireing
+			if (m_flGoalSpeed > 400)
+				m_flGoalSpeed = 400;
+		}
+	}
+
+	UTIL_MakeAimVectors( pev->angles );
+	Vector vecEst = (gpGlobals->v_forward * 800 + pev->velocity).Normalize( );
+	// ALERT( at_console, "%d %d %d %4.2f\n", pev->angles.x < 0, DotProduct( pev->velocity, gpGlobals->v_forward ) > -100, m_flNextRocket < gpGlobals->time, DotProduct( m_vecTarget, vecEst ) );
+
+	if ((m_iRockets % 2) == 1)
+	{
+		FireRocket( );
+		m_flNextRocket = gpGlobals->time + 0.5;
+		if (m_iRockets <= 0)
+		{
+			m_flNextRocket = gpGlobals->time + 10;
+			m_iRockets = 10;
+		}
+	}
+	else if (pev->angles.x < 0 && DotProduct( pev->velocity, gpGlobals->v_forward ) > -100 && m_flNextRocket < gpGlobals->time)
+	{
+		if (m_flLastSeen + 60 > gpGlobals->time)
+		{
+			if (m_hEnemy != NULL)
+			{
+				// make sure it's a good shot
+				if (DotProduct( m_vecTarget, vecEst) > .965)
+				{
+					TraceResult tr;
+					
+					UTIL_TraceLine( pev->origin, pev->origin + vecEst * 4096, ignore_monsters, edict(), &tr );
+					if ((tr.vecEndPos - m_posTarget).Length() < 512)
+						FireRocket( );
+				}
+			}
+			else
+			{
+				TraceResult tr;
+				
+				UTIL_TraceLine( pev->origin, pev->origin + vecEst * 4096, dont_ignore_monsters, edict(), &tr );
+				// just fire when close
+				if ((tr.vecEndPos - m_posTarget).Length() < 512)
+					FireRocket( );
+			}
+		}
+	}
+}
+
+
+void CMApache :: Flight( void )
+{
+	// tilt model 5 degrees
+	Vector vecAdj = Vector( 5.0, 0, 0 );
+
+	// estimate where I'll be facing in one seconds
+	UTIL_MakeAimVectors( pev->angles + pev->avelocity * 2 + vecAdj);
+	// Vector vecEst1 = pev->origin + pev->velocity + gpGlobals->v_up * m_flForce - Vector( 0, 0, 384 );
+	// float flSide = DotProduct( m_posDesired - vecEst1, gpGlobals->v_right );
+	
+	float flSide = DotProduct( m_vecDesired, gpGlobals->v_right );
+
+	if (flSide < 0)
+	{
+		if (pev->avelocity.y < 60)
+		{
+			pev->avelocity.y += 8; // 9 * (3.0/2.0);
+		}
+	}
+	else
+	{
+		if (pev->avelocity.y > -60)
+		{
+			pev->avelocity.y -= 8; // 9 * (3.0/2.0);
+		}
+	}
+	pev->avelocity.y *= 0.98;
+
+	// estimate where I'll be in two seconds
+	UTIL_MakeAimVectors( pev->angles + pev->avelocity * 1 + vecAdj);
+	Vector vecEst = pev->origin + pev->velocity * 2.0 + gpGlobals->v_up * m_flForce * 20 - Vector( 0, 0, 384 * 2 );
+
+	// add immediate force
+	UTIL_MakeAimVectors( pev->angles + vecAdj);
+	pev->velocity.x += gpGlobals->v_up.x * m_flForce;
+	pev->velocity.y += gpGlobals->v_up.y * m_flForce;
+	pev->velocity.z += gpGlobals->v_up.z * m_flForce;
+	// add gravity
+	pev->velocity.z -= 38.4; // 32ft/sec
+
+
+	float flSpeed = pev->velocity.Length();
+	float flDir = DotProduct( Vector( gpGlobals->v_forward.x, gpGlobals->v_forward.y, 0 ), Vector( pev->velocity.x, pev->velocity.y, 0 ) );
+	if (flDir < 0)
+		flSpeed = -flSpeed;
+
+	float flDist = DotProduct( m_posDesired - vecEst, gpGlobals->v_forward );
+
+	// float flSlip = DotProduct( pev->velocity, gpGlobals->v_right );
+	float flSlip = -DotProduct( m_posDesired - vecEst, gpGlobals->v_right );
+
+	// fly sideways
+	if (flSlip > 0)
+	{
+		if (pev->angles.z > -30 && pev->avelocity.z > -15)
+			pev->avelocity.z -= 4;
+		else
+			pev->avelocity.z += 2;
+	}
+	else
+	{
+
+		if (pev->angles.z < 30 && pev->avelocity.z < 15)
+			pev->avelocity.z += 4;
+		else
+			pev->avelocity.z -= 2;
+	}
+
+	// sideways drag
+	pev->velocity.x = pev->velocity.x * (1.0 - fabs( gpGlobals->v_right.x ) * 0.05);
+	pev->velocity.y = pev->velocity.y * (1.0 - fabs( gpGlobals->v_right.y ) * 0.05);
+	pev->velocity.z = pev->velocity.z * (1.0 - fabs( gpGlobals->v_right.z ) * 0.05);
+
+	// general drag
+	pev->velocity = pev->velocity * 0.995;
+	
+	// apply power to stay correct height
+	if (m_flForce < 80 && vecEst.z < m_posDesired.z) 
+	{
+		m_flForce += 12;
+	}
+	else if (m_flForce > 30)
+	{
+		if (vecEst.z > m_posDesired.z) 
+			m_flForce -= 8;
+	}
+
+	// pitch forward or back to get to target
+	if (flDist > 0 && flSpeed < m_flGoalSpeed /* && flSpeed < flDist */ && pev->angles.x + pev->avelocity.x > -40)
+	{
+		// ALERT( at_console, "F " );
+		// lean forward
+		pev->avelocity.x -= 12.0;
+	}
+	else if (flDist < 0 && flSpeed > -50 && pev->angles.x + pev->avelocity.x  < 20)
+	{
+		// ALERT( at_console, "B " );
+		// lean backward
+		pev->avelocity.x += 12.0;
+	}
+	else if (pev->angles.x + pev->avelocity.x > 0)
+	{
+		// ALERT( at_console, "f " );
+		pev->avelocity.x -= 4.0;
+	}
+	else if (pev->angles.x + pev->avelocity.x < 0)
+	{
+		// ALERT( at_console, "b " );
+		pev->avelocity.x += 4.0;
+	}
+
+	// ALERT( at_console, "%.0f %.0f : %.0f %.0f : %.0f %.0f : %.0f\n", pev->origin.x, pev->velocity.x, flDist, flSpeed, pev->angles.x, pev->avelocity.x, m_flForce ); 
+	// ALERT( at_console, "%.0f %.0f : %.0f %0.f : %.0f\n", pev->origin.z, pev->velocity.z, vecEst.z, m_posDesired.z, m_flForce ); 
+
+	// make rotor, engine sounds
+	if (m_iSoundState == 0)
+	{
+		EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_rotor2.wav", 1.0, 0.3, 0, 110 );
+		// EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_whine1.wav", 0.5, 0.2, 0, 110 );
+
+		m_iSoundState = SND_CHANGE_PITCH; // hack for going through level transitions
+	}
+	else
+	{
+		edict_t *pPlayer = NULL;
+
+		pPlayer = UTIL_FindEntityByClassname( NULL, "player" );
+		// UNDONE: this needs to send different sounds to every player for multiplayer.	
+		if (pPlayer)
+		{
+
+			float pitch = DotProduct( pev->velocity - pPlayer->v.velocity, (pPlayer->v.origin - pev->origin).Normalize() );
+
+			pitch = (int)(100 + pitch / 50.0);
+
+			if (pitch > 250) 
+				pitch = 250;
+			if (pitch < 50)
+				pitch = 50;
+			if (pitch == 100)
+				pitch = 101;
+
+			float flVol = (m_flForce / 100.0) + .1;
+			if (flVol > 1.0) 
+				flVol = 1.0;
+
+			EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_rotor2.wav", 1.0, 0.3, SND_CHANGE_PITCH | SND_CHANGE_VOL, pitch);
+		}
+		// EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_whine1.wav", flVol, 0.2, SND_CHANGE_PITCH | SND_CHANGE_VOL, pitch);
+	
+		// ALERT( at_console, "%.0f %.2f\n", pitch, flVol );
+	}
+}
+
+
+void CMApache :: FireRocket( void )
+{
+	static float side = 1.0;
+	static int count;
+
+	if (m_iRockets <= 0)
+		return;
+
+	UTIL_MakeAimVectors( pev->angles );
+	Vector vecSrc = pev->origin + 1.5 * (gpGlobals->v_forward * 21 + gpGlobals->v_right * 70 * side + gpGlobals->v_up * -79);
+
+	switch( m_iRockets % 5)
+	{
+	case 0:	vecSrc = vecSrc + gpGlobals->v_right * 10; break;
+	case 1: vecSrc = vecSrc - gpGlobals->v_right * 10; break;
+	case 2: vecSrc = vecSrc + gpGlobals->v_up * 10; break;
+	case 3: vecSrc = vecSrc - gpGlobals->v_up * 10; break;
+	case 4: break;
+	}
+
+	MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSrc );
+		WRITE_BYTE( TE_SMOKE );
+		WRITE_COORD( vecSrc.x );
+		WRITE_COORD( vecSrc.y );
+		WRITE_COORD( vecSrc.z );
+		WRITE_SHORT( g_sModelIndexSmoke );
+		WRITE_BYTE( 20 ); // scale * 10
+		WRITE_BYTE( 12 ); // framerate
+	MESSAGE_END();
+
+//jlb	CMBaseEntity *pRocket = CMBaseEntity::Create( "hvr_rocket", vecSrc, pev->angles, edict() );
+	CMApacheHVR *pRocket = CreateClassPtr((CMApacheHVR *)NULL);
+
+	if (pRocket)
+	{
+		pRocket->pev->origin = vecSrc;
+		pRocket->pev->angles = pev->angles;
+		pRocket->pev->owner = edict();
+
+		// Initialize these for entities who don't link to the world
+		pRocket->pev->absmin = pRocket->pev->origin - Vector(1,1,1);
+		pRocket->pev->absmax = pRocket->pev->origin + Vector(1,1,1);
+
+		pRocket->Spawn();
+
+		pRocket->pev->velocity = pev->velocity + gpGlobals->v_forward * 100;
+	}
+
+	m_iRockets--;
+
+	side = - side;
+}
+
+
+
+BOOL CMApache :: FireGun( )
+{
+	UTIL_MakeAimVectors( pev->angles );
+		
+	Vector posGun, angGun;
+	GetAttachment( 1, posGun, angGun );
+
+	Vector vecTarget = (m_posTarget - posGun).Normalize( );
+
+	Vector vecOut;
+
+	vecOut.x = DotProduct( gpGlobals->v_forward, vecTarget );
+	vecOut.y = -DotProduct( gpGlobals->v_right, vecTarget );
+	vecOut.z = DotProduct( gpGlobals->v_up, vecTarget );
+
+	Vector angles = UTIL_VecToAngles (vecOut);
+
+	angles.x = -angles.x;
+	if (angles.y > 180)
+		angles.y = angles.y - 360;
+	if (angles.y < -180)
+		angles.y = angles.y + 360;
+	if (angles.x > 180)
+		angles.x = angles.x - 360;
+	if (angles.x < -180)
+		angles.x = angles.x + 360;
+
+	if (angles.x > m_angGun.x)
+		m_angGun.x = min( angles.x, m_angGun.x + 12 );
+	if (angles.x < m_angGun.x)
+		m_angGun.x = max( angles.x, m_angGun.x - 12 );
+	if (angles.y > m_angGun.y)
+		m_angGun.y = min( angles.y, m_angGun.y + 12 );
+	if (angles.y < m_angGun.y)
+		m_angGun.y = max( angles.y, m_angGun.y - 12 );
+
+	m_angGun.y = SetBoneController( 0, m_angGun.y );
+	m_angGun.x = SetBoneController( 1, m_angGun.x );
+
+	Vector posBarrel, angBarrel;
+	GetAttachment( 0, posBarrel, angBarrel );
+	Vector vecGun = (posBarrel - posGun).Normalize( );
+
+	if (DotProduct( vecGun, vecTarget ) > 0.98)
+	{
+#if 1
+		FireBullets( 1, posGun, vecGun, VECTOR_CONE_4DEGREES, 8192, BULLET_MONSTER_12MM, 1 );
+		EMIT_SOUND(ENT(pev), CHAN_WEAPON, "turret/tu_fire1.wav", 1, 0.3);
+#else
+		static float flNext;
+		TraceResult tr;
+		UTIL_TraceLine( posGun, posGun + vecGun * 8192, dont_ignore_monsters, ENT( pev ), &tr );
+
+		if (!m_pBeam)
+		{
+			m_pBeam = CBeam::BeamCreate( "sprites/lgtning.spr", 80 );
+			m_pBeam->PointEntInit( pev->origin, entindex( ) );
+			m_pBeam->SetEndAttachment( 1 );
+			m_pBeam->SetColor( 255, 180, 96 );
+			m_pBeam->SetBrightness( 192 );
+		}
+
+		if (flNext < gpGlobals->time)
+		{
+			flNext = gpGlobals->time + 0.5;
+			m_pBeam->SetStartPos( tr.vecEndPos );
+		}
+#endif
+		return TRUE;
+	}
+	else
+	{
+		if (m_pBeam)
+		{
+			UTIL_Remove( m_pBeam->edict() );
+			m_pBeam = NULL;
+		}
+	}
+	return FALSE;
+}
+
+
+
+void CMApache :: ShowDamage( void )
+{
+	if (m_iDoSmokePuff > 0 || RANDOM_LONG(0,99) > pev->health)
+	{
+		MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
+			WRITE_BYTE( TE_SMOKE );
+			WRITE_COORD( pev->origin.x );
+			WRITE_COORD( pev->origin.y );
+			WRITE_COORD( pev->origin.z - 32 );
+			WRITE_SHORT( g_sModelIndexSmoke );
+			WRITE_BYTE( RANDOM_LONG(0,9) + 20 ); // scale * 10
+			WRITE_BYTE( 12 ); // framerate
+		MESSAGE_END();
+	}
+	if (m_iDoSmokePuff > 0)
+		m_iDoSmokePuff--;
+}
+
+
+int CMApache :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType )
+{
+	if (pevInflictor->owner == edict())
+		return 0;
+
+	if (bitsDamageType & DMG_BLAST)
+	{
+		flDamage *= 2;
+	}
+
+	/*
+	if ( (bitsDamageType & DMG_BULLET) && flDamage > 50)
+	{
+		// clip bullet damage at 50
+		flDamage = 50;
+	}
+	*/
+
+	// ALERT( at_console, "%.0f\n", flDamage );
+	return CMBaseEntity::TakeDamage(  pevInflictor, pevAttacker, flDamage, bitsDamageType );
+}
+
+
+
+void CMApache::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
+{
+	// ALERT( at_console, "%d %.0f\n", ptr->iHitgroup, flDamage );
+
+	// ignore blades
+	if (ptr->iHitgroup == 6 && (bitsDamageType & (DMG_ENERGYBEAM|DMG_BULLET|DMG_CLUB)))
+		return;
+
+	// hit hard, hits cockpit, hits engines
+	if (flDamage > 50 || ptr->iHitgroup == 1 || ptr->iHitgroup == 2)
+	{
+		// ALERT( at_console, "%.0f\n", flDamage );
+		AddMultiDamage( pevAttacker, this->edict(), flDamage, bitsDamageType );
+		m_iDoSmokePuff = 3 + (flDamage / 5.0);
+	}
+	else
+	{
+		// do half damage in the body
+		// AddMultiDamage( pevAttacker, this, flDamage / 2.0, bitsDamageType );
+		UTIL_Ricochet( ptr->vecEndPos, 2.0 );
+	}
+}
+
+
+void CMApacheHVR :: Spawn( void )
+{
+	Precache( );
+	// motor
+	pev->movetype = MOVETYPE_FLY;
+	pev->solid = SOLID_BBOX;
+
+	SET_MODEL(ENT(pev), "models/HVR.mdl");
+	UTIL_SetSize(pev, Vector( 0, 0, 0), Vector(0, 0, 0));
+	UTIL_SetOrigin( pev, pev->origin );
+
+	SetThink( IgniteThink );
+	SetTouch( ExplodeTouch );
+
+	UTIL_MakeAimVectors( pev->angles );
+	m_vecForward = gpGlobals->v_forward;
+	pev->gravity = 0.5;
+
+	pev->nextthink = gpGlobals->time + 0.1;
+
+	pev->dmg = 150;
+}
+
+
+void CMApacheHVR :: Precache( void )
+{
+	PRECACHE_MODEL("models/HVR.mdl");
+	m_iTrail = PRECACHE_MODEL("sprites/smoke.spr");
+	PRECACHE_SOUND ("weapons/rocket1.wav");
+}
+
+
+void CMApacheHVR :: IgniteThink( void  )
+{
+	// pev->movetype = MOVETYPE_TOSS;
+
+	// pev->movetype = MOVETYPE_FLY;
+	pev->effects |= EF_LIGHT;
+
+	// make rocket sound
+	EMIT_SOUND( ENT(pev), CHAN_VOICE, "weapons/rocket1.wav", 1, 0.5 );
+
+	// rocket trail
+	MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
+
+		WRITE_BYTE( TE_BEAMFOLLOW );
+		WRITE_SHORT(entindex());	// entity
+		WRITE_SHORT(m_iTrail );	// model
+		WRITE_BYTE( 15 ); // life
+		WRITE_BYTE( 5 );  // width
+		WRITE_BYTE( 224 );   // r, g, b
+		WRITE_BYTE( 224 );   // r, g, b
+		WRITE_BYTE( 255 );   // r, g, b
+		WRITE_BYTE( 255 );	// brightness
+
+	MESSAGE_END();  // move PHS/PVS data sending into here (SEND_ALL, SEND_PVS, SEND_PHS)
+
+	// set to accelerate
+	SetThink( AccelerateThink );
+	pev->nextthink = gpGlobals->time + 0.1;
+}
+
+
+void CMApacheHVR :: AccelerateThink( void  )
+{
+	// check world boundaries
+	if (pev->origin.x < -4096 || pev->origin.x > 4096 || pev->origin.y < -4096 || pev->origin.y > 4096 || pev->origin.z < -4096 || pev->origin.z > 4096)
+	{
+		UTIL_Remove( this->edict() );
+		return;
+	}
+
+	// accelerate
+	float flSpeed = pev->velocity.Length();
+	if (flSpeed < 1800)
+	{
+		pev->velocity = pev->velocity + m_vecForward * 200;
+	}
+
+	// re-aim
+	pev->angles = UTIL_VecToAngles( pev->velocity );
+
+	pev->nextthink = gpGlobals->time + 0.1;
+}
+
+
+#endif

src/dlls/barney.cpp

@@ -0,0 +1,666 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+//=========================================================
+// monster template
+//=========================================================
+// UNDONE: Holster weapon?
+
+#include	"extdll.h"
+#include	"util.h"
+#include	"cmbase.h"
+#include "cmbasemonster.h"
+#include	"monsters.h"
+#include	"schedule.h"
+#include	"defaultai.h"
+#include	"weapons.h"
+
+//=========================================================
+// Monster's Anim Events Go Here
+//=========================================================
+// first flag is barney dying for scripted sequences?
+#define		BARNEY_AE_DRAW		( 2 )
+#define		BARNEY_AE_SHOOT		( 3 )
+#define		BARNEY_AE_HOLSTER	( 4 )
+
+#define	BARNEY_BODY_GUNHOLSTERED	0
+#define	BARNEY_BODY_GUNDRAWN		1
+#define BARNEY_BODY_GUNGONE			2
+
+
+//=========================================================
+// AI Schedules Specific to this monster
+//=========================================================
+Task_t	tlBaFollow[] =
+{
+	{ TASK_MOVE_TO_TARGET_RANGE,(float)128		},	// Move within 128 of target ent (client)
+	{ TASK_SET_SCHEDULE,		(float)SCHED_TARGET_FACE },
+};
+
+Schedule_t	slBaFollow[] =
+{
+	{
+		tlBaFollow,
+		ARRAYSIZE ( tlBaFollow ),
+		bits_COND_NEW_ENEMY		|
+		bits_COND_LIGHT_DAMAGE	|
+		bits_COND_HEAVY_DAMAGE	|
+		bits_COND_HEAR_SOUND |
+		bits_COND_PROVOKED,
+		0,
+		"Follow"
+	},
+};
+
+//=========================================================
+// BarneyDraw- much better looking draw schedule for when
+// barney knows who he's gonna attack.
+//=========================================================
+Task_t	tlBarneyEnemyDraw[] =
+{
+	{ TASK_STOP_MOVING,					0				},
+	{ TASK_FACE_ENEMY,					0				},
+	{ TASK_PLAY_SEQUENCE_FACE_ENEMY,	(float) ACT_ARM },
+};
+
+Schedule_t slBarneyEnemyDraw[] = 
+{
+	{
+		tlBarneyEnemyDraw,
+		ARRAYSIZE ( tlBarneyEnemyDraw ),
+		0,
+		0,
+		"Barney Enemy Draw"
+	}
+};
+
+Task_t	tlBaFaceTarget[] =
+{
+	{ TASK_SET_ACTIVITY,		(float)ACT_IDLE },
+	{ TASK_FACE_TARGET,			(float)0		},
+	{ TASK_SET_ACTIVITY,		(float)ACT_IDLE },
+	{ TASK_SET_SCHEDULE,		(float)SCHED_TARGET_CHASE },
+};
+
+Schedule_t	slBaFaceTarget[] =
+{
+	{
+		tlBaFaceTarget,
+		ARRAYSIZE ( tlBaFaceTarget ),
+		bits_COND_CLIENT_PUSH	|
+		bits_COND_NEW_ENEMY		|
+		bits_COND_LIGHT_DAMAGE	|
+		bits_COND_HEAVY_DAMAGE	|
+		bits_COND_HEAR_SOUND |
+		bits_COND_PROVOKED,
+		0,
+		"FaceTarget"
+	},
+};
+
+
+Task_t	tlIdleBaStand[] =
+{
+	{ TASK_STOP_MOVING,			0				},
+	{ TASK_SET_ACTIVITY,		(float)ACT_IDLE },
+	{ TASK_WAIT,				(float)2		}, // repick IDLESTAND every two seconds.
+	{ TASK_TLK_HEADRESET,		(float)0		}, // reset head position
+};
+
+Schedule_t	slIdleBaStand[] =
+{
+	{ 
+		tlIdleBaStand,
+		ARRAYSIZE ( tlIdleBaStand ), 
+		bits_COND_NEW_ENEMY		|
+		bits_COND_LIGHT_DAMAGE	|
+		bits_COND_HEAVY_DAMAGE	|
+		bits_COND_HEAR_SOUND	|
+		bits_COND_SMELL			|
+		bits_COND_PROVOKED,
+
+		0,
+		"IdleStand"
+	},
+};
+
+DEFINE_CUSTOM_SCHEDULES( CMBarney )
+{
+	slBaFollow,
+	slBarneyEnemyDraw,
+	slBaFaceTarget,
+	slIdleBaStand,
+};
+
+
+IMPLEMENT_CUSTOM_SCHEDULES( CMBarney, CMTalkMonster );
+
+void CMBarney :: StartTask( Task_t *pTask )
+{
+	CMTalkMonster::StartTask( pTask );	
+}
+
+void CMBarney :: RunTask( Task_t *pTask )
+{
+	switch ( pTask->iTask )
+	{
+	case TASK_RANGE_ATTACK1:
+		if (m_hEnemy != NULL && (UTIL_IsPlayer(m_hEnemy)))
+		{
+			pev->framerate = 1.5;
+		}
+		CMTalkMonster::RunTask( pTask );
+		break;
+	default:
+		CMTalkMonster::RunTask( pTask );
+		break;
+	}
+}
+
+
+
+
+//=========================================================
+// ISoundMask - returns a bit mask indicating which types
+// of sounds this monster regards. 
+//=========================================================
+int CMBarney :: ISoundMask ( void) 
+{
+	return 0;
+}
+
+//=========================================================
+// Classify - indicates this monster's place in the 
+// relationship table.
+//=========================================================
+int	CMBarney :: Classify ( void )
+{
+	return	CLASS_PLAYER_ALLY;
+}
+
+//=========================================================
+// ALertSound - barney says "Freeze!"
+//=========================================================
+void CMBarney :: AlertSound( void )
+{
+	if ( m_hEnemy != NULL )
+	{
+		if ( FOkToSpeak() )
+		{
+			PlaySentence( "BA_ATTACK", RANDOM_FLOAT(2.8, 3.2), VOL_NORM, ATTN_IDLE );
+		}
+	}
+
+}
+//=========================================================
+// SetYawSpeed - allows each sequence to have a different
+// turn rate associated with it.
+//=========================================================
+void CMBarney :: SetYawSpeed ( void )
+{
+	int ys;
+
+	ys = 0;
+
+	switch ( m_Activity )
+	{
+	case ACT_IDLE:		
+		ys = 70;
+		break;
+	case ACT_WALK:
+		ys = 70;
+		break;
+	case ACT_RUN:
+		ys = 90;
+		break;
+	default:
+		ys = 70;
+		break;
+	}
+
+	pev->yaw_speed = ys;
+}
+
+
+//=========================================================
+// CheckRangeAttack1
+//=========================================================
+BOOL CMBarney :: CheckRangeAttack1 ( float flDot, float flDist )
+{
+	if ( flDist <= 1024 && flDot >= 0.5 )
+	{
+		if ( gpGlobals->time > m_checkAttackTime )
+		{
+			TraceResult tr;
+			
+			Vector shootOrigin = pev->origin + Vector( 0, 0, 55 );
+
+			edict_t *pEnemy = m_hEnemy;
+
+			Vector shootTarget = ( (UTIL_BodyTarget( pEnemy, shootOrigin ) - pEnemy->v.origin) + m_vecEnemyLKP );
+
+			UTIL_TraceLine( shootOrigin, shootTarget, dont_ignore_monsters, ENT(pev), &tr );
+
+			m_checkAttackTime = gpGlobals->time + 1;
+
+			if ( tr.flFraction == 1.0 || (tr.pHit != NULL) && (tr.pHit == pEnemy) )
+				m_lastAttackCheck = TRUE;
+			else
+				m_lastAttackCheck = FALSE;
+
+			m_checkAttackTime = gpGlobals->time + 1.5;
+		}
+		return m_lastAttackCheck;
+	}
+	return FALSE;
+}
+
+
+//=========================================================
+// BarneyFirePistol - shoots one round from the pistol at
+// the enemy barney is facing.
+//=========================================================
+void CMBarney :: BarneyFirePistol ( void )
+{
+	Vector vecShootOrigin;
+
+	UTIL_MakeVectors(pev->angles);
+	vecShootOrigin = pev->origin + Vector( 0, 0, 55 );
+	Vector vecShootDir = ShootAtEnemy( vecShootOrigin );
+
+	Vector angDir = UTIL_VecToAngles( vecShootDir );
+	SetBlending( 0, angDir.x );
+	pev->effects = EF_MUZZLEFLASH;
+
+	FireBullets(1, vecShootOrigin, vecShootDir, VECTOR_CONE_2DEGREES, 1024, BULLET_MONSTER_9MM );
+	
+	int pitchShift = RANDOM_LONG( 0, 20 );
+	
+	// Only shift about half the time
+	if ( pitchShift > 10 )
+		pitchShift = 0;
+	else
+		pitchShift -= 5;
+	EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "barney/ba_attack2.wav", 1, ATTN_NORM, 0, 100 + pitchShift );
+
+	// UNDONE: Reload?
+	m_cAmmoLoaded--;// take away a bullet!
+}
+		
+//=========================================================
+// HandleAnimEvent - catches the monster-specific messages
+// that occur when tagged animation frames are played.
+//
+// Returns number of events handled, 0 if none.
+//=========================================================
+void CMBarney :: HandleAnimEvent( MonsterEvent_t *pEvent )
+{
+	switch( pEvent->event )
+	{
+	case BARNEY_AE_SHOOT:
+		BarneyFirePistol();
+		break;
+
+	case BARNEY_AE_DRAW:
+		// barney's bodygroup switches here so he can pull gun from holster
+		pev->body = BARNEY_BODY_GUNDRAWN;
+		m_fGunDrawn = TRUE;
+		break;
+
+	case BARNEY_AE_HOLSTER:
+		// change bodygroup to replace gun in holster
+		pev->body = BARNEY_BODY_GUNHOLSTERED;
+		m_fGunDrawn = FALSE;
+		break;
+
+	default:
+		CMTalkMonster::HandleAnimEvent( pEvent );
+	}
+}
+
+//=========================================================
+// Spawn
+//=========================================================
+void CMBarney :: Spawn()
+{
+	Precache( );
+
+	// every new barney must call this, otherwise
+	// when a level is loaded, nobody will talk (time is reset to 0)
+	TalkInit();
+
+	SET_MODEL(ENT(pev), "models/barney.mdl");
+	UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);
+
+	pev->solid			= SOLID_SLIDEBOX;
+	pev->movetype		= MOVETYPE_STEP;
+	m_bloodColor		= BLOOD_COLOR_RED;
+	pev->health			= gSkillData.barneyHealth;
+	pev->view_ofs		= Vector ( 0, 0, 50 );// position of the eyes relative to monster's origin.
+	m_flFieldOfView		= VIEW_FIELD_FULL;
+	m_MonsterState		= MONSTERSTATE_NONE;
+
+	pev->body			= 0; // gun in holster
+	m_fGunDrawn			= FALSE;
+
+	m_afCapability		= bits_CAP_HEAR | bits_CAP_TURN_HEAD | bits_CAP_DOORS_GROUP;
+
+	MonsterInit();
+}
+
+//=========================================================
+// Precache - precaches all resources this monster needs
+//=========================================================
+void CMBarney :: Precache()
+{
+	PRECACHE_MODEL("models/barney.mdl");
+
+	PRECACHE_SOUND("barney/ba_attack1.wav" );
+	PRECACHE_SOUND("barney/ba_attack2.wav" );
+
+	PRECACHE_SOUND("barney/ba_pain1.wav");
+	PRECACHE_SOUND("barney/ba_pain2.wav");
+	PRECACHE_SOUND("barney/ba_pain3.wav");
+
+	PRECACHE_SOUND("barney/ba_die1.wav");
+	PRECACHE_SOUND("barney/ba_die2.wav");
+	PRECACHE_SOUND("barney/ba_die3.wav");
+	
+	CMTalkMonster::Precache();
+}	
+
+// Init talk data
+void CMBarney :: TalkInit()
+{
+	CMTalkMonster::TalkInit();
+
+	// scientists speach group names (group names are in sentences.txt)
+
+	m_szGrp[TLK_ANSWER]  =	"BA_ANSWER";
+	m_szGrp[TLK_QUESTION] =	"BA_QUESTION";
+	m_szGrp[TLK_IDLE] =		"BA_IDLE";
+	m_szGrp[TLK_STARE] =		"BA_STARE";
+	m_szGrp[TLK_USE] =		"BA_OK";
+	m_szGrp[TLK_UNUSE] =	"BA_WAIT";
+	m_szGrp[TLK_STOP] =		"BA_STOP";
+
+	m_szGrp[TLK_NOSHOOT] =	"BA_SCARED";
+	m_szGrp[TLK_HELLO] =	"BA_HELLO";
+
+	m_szGrp[TLK_PLHURT1] =	"!BA_CUREA";
+	m_szGrp[TLK_PLHURT2] =	"!BA_CUREB"; 
+	m_szGrp[TLK_PLHURT3] =	"!BA_CUREC";
+
+	m_szGrp[TLK_PHELLO] =	NULL;	//"BA_PHELLO";		// UNDONE
+	m_szGrp[TLK_PIDLE] =	NULL;	//"BA_PIDLE";			// UNDONE
+	m_szGrp[TLK_PQUESTION] = "BA_PQUEST";		// UNDONE
+
+	m_szGrp[TLK_SMELL] =	"BA_SMELL";
+	
+	m_szGrp[TLK_WOUND] =	"BA_WOUND";
+	m_szGrp[TLK_MORTAL] =	"BA_MORTAL";
+
+	// get voice for head - just one barney voice for now
+	m_voicePitch = 100;
+}
+
+
+static BOOL IsFacing( entvars_t *pevTest, const Vector &reference )
+{
+	Vector vecDir = (reference - pevTest->origin);
+	vecDir.z = 0;
+	vecDir = vecDir.Normalize();
+	Vector forward, angle;
+	angle = pevTest->v_angle;
+	angle.x = 0;
+	UTIL_MakeVectorsPrivate( angle, forward, NULL, NULL );
+	// He's facing me, he meant it
+	if ( DotProduct( forward, vecDir ) > 0.96 )	// +/- 15 degrees or so
+	{
+		return TRUE;
+	}
+	return FALSE;
+}
+
+
+int CMBarney :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType)
+{
+	// make sure friends talk about it if player hurts talkmonsters...
+	int ret = CMTalkMonster::TakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType);
+	if ( !IsAlive() || pev->deadflag == DEAD_DYING )
+		return ret;
+
+	if ( m_MonsterState != MONSTERSTATE_PRONE && (pevAttacker->flags & FL_CLIENT) )
+	{
+		// This is a heurstic to determine if the player intended to harm me
+		// If I have an enemy, we can't establish intent (may just be crossfire)
+		if ( ( m_hEnemy != NULL ) && UTIL_IsPlayer(m_hEnemy) )
+		{
+			Remember( bits_MEMORY_PROVOKED );
+		}
+	}
+
+	return ret;
+}
+
+	
+//=========================================================
+// PainSound
+//=========================================================
+void CMBarney :: PainSound ( void )
+{
+	if (gpGlobals->time < m_painTime)
+		return;
+	
+	m_painTime = gpGlobals->time + RANDOM_FLOAT(0.5, 0.75);
+
+	switch (RANDOM_LONG(0,2))
+	{
+	case 0: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_pain1.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
+	case 1: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_pain2.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
+	case 2: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_pain3.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
+	}
+}
+
+//=========================================================
+// DeathSound 
+//=========================================================
+void CMBarney :: DeathSound ( void )
+{
+	switch (RANDOM_LONG(0,2))
+	{
+	case 0: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_die1.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
+	case 1: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_die2.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
+	case 2: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_die3.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
+	}
+}
+
+
+void CMBarney::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
+{
+	switch( ptr->iHitgroup)
+	{
+	case HITGROUP_CHEST:
+	case HITGROUP_STOMACH:
+		if (bitsDamageType & (DMG_BULLET | DMG_SLASH | DMG_BLAST))
+		{
+			flDamage = flDamage / 2;
+		}
+		break;
+	case 10:
+		if (bitsDamageType & (DMG_BULLET | DMG_SLASH | DMG_CLUB))
+		{
+			flDamage -= 20;
+			if (flDamage <= 0)
+			{
+				UTIL_Ricochet( ptr->vecEndPos, 1.0 );
+				flDamage = 0.01;
+			}
+		}
+		// always a head shot
+		ptr->iHitgroup = HITGROUP_HEAD;
+		break;
+	}
+
+	CMTalkMonster::TraceAttack( pevAttacker, flDamage, vecDir, ptr, bitsDamageType );
+}
+
+
+void CMBarney::Killed( entvars_t *pevAttacker, int iGib )
+{
+	if ( pev->body < BARNEY_BODY_GUNGONE )
+	{// drop the gun!
+		Vector vecGunPos;
+		Vector vecGunAngles;
+
+		pev->body = BARNEY_BODY_GUNGONE;
+
+		GetAttachment( 0, vecGunPos, vecGunAngles );
+	}
+
+	SetUse( NULL );	
+	CMTalkMonster::Killed( pevAttacker, iGib );
+}
+
+//=========================================================
+// AI Schedules Specific to this monster
+//=========================================================
+
+Schedule_t* CMBarney :: GetScheduleOfType ( int Type )
+{
+	Schedule_t *psched;
+
+	switch( Type )
+	{
+	case SCHED_ARM_WEAPON:
+		if ( m_hEnemy != NULL )
+		{
+			// face enemy, then draw.
+			return slBarneyEnemyDraw;
+		}
+		break;
+
+	// Hook these to make a looping schedule
+	case SCHED_TARGET_FACE:
+		// call base class default so that barney will talk
+		// when 'used' 
+		psched = CMTalkMonster::GetScheduleOfType(Type);
+
+		if (psched == slIdleStand)
+			return slBaFaceTarget;	// override this for different target face behavior
+		else
+			return psched;
+
+	case SCHED_TARGET_CHASE:
+		return slBaFollow;
+
+	case SCHED_IDLE_STAND:
+		// call base class default so that scientist will talk
+		// when standing during idle
+		psched = CMTalkMonster::GetScheduleOfType(Type);
+
+		if (psched == slIdleStand)
+		{
+			// just look straight ahead.
+			return slIdleBaStand;
+		}
+		else
+			return psched;	
+	}
+
+	return CMTalkMonster::GetScheduleOfType( Type );
+}
+
+//=========================================================
+// GetSchedule - Decides which type of schedule best suits
+// the monster's current state and conditions. Then calls
+// monster's member function to get a pointer to a schedule
+// of the proper type.
+//=========================================================
+Schedule_t *CMBarney :: GetSchedule ( void )
+{
+	if ( HasConditions( bits_COND_ENEMY_DEAD ) && FOkToSpeak() )
+	{
+		PlaySentence( "BA_KILL", 4, VOL_NORM, ATTN_NORM );
+	}
+
+	switch( m_MonsterState )
+	{
+	case MONSTERSTATE_COMBAT:
+		{
+// dead enemy
+			if ( HasConditions( bits_COND_ENEMY_DEAD ) )
+			{
+				// call base class, all code to handle dead enemies is centralized there.
+				return CMBaseMonster :: GetSchedule();
+			}
+
+			// always act surprized with a new enemy
+			if ( HasConditions( bits_COND_NEW_ENEMY ) && HasConditions( bits_COND_LIGHT_DAMAGE) )
+				return GetScheduleOfType( SCHED_SMALL_FLINCH );
+				
+			// wait for one schedule to draw gun
+			if (!m_fGunDrawn )
+				return GetScheduleOfType( SCHED_ARM_WEAPON );
+
+			if ( HasConditions( bits_COND_HEAVY_DAMAGE ) )
+				return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );
+		}
+		break;
+
+	case MONSTERSTATE_ALERT:	
+	case MONSTERSTATE_IDLE:
+		if ( HasConditions(bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE))
+		{
+			// flinch if hurt
+			return GetScheduleOfType( SCHED_SMALL_FLINCH );
+		}
+
+		if ( m_hEnemy == NULL && IsFollowing() )
+		{
+			if ( !UTIL_IsAlive(m_hTargetEnt) )
+			{
+				// UNDONE: Comment about the recently dead player here?
+				StopFollowing( FALSE );
+				break;
+			}
+			else
+			{
+				if ( HasConditions( bits_COND_CLIENT_PUSH ) )
+				{
+					return GetScheduleOfType( SCHED_MOVE_AWAY_FOLLOW );
+				}
+				return GetScheduleOfType( SCHED_TARGET_FACE );
+			}
+		}
+
+		if ( HasConditions( bits_COND_CLIENT_PUSH ) )
+		{
+			return GetScheduleOfType( SCHED_MOVE_AWAY );
+		}
+
+		// try to say something about smells
+		TrySmellTalk();
+		break;
+	}
+	
+	return CMTalkMonster::GetSchedule();
+}
+
+MONSTERSTATE CMBarney :: GetIdealState ( void )
+{
+	return CMTalkMonster::GetIdealState();
+}
+
+

src/dlls/cdll_dll.h

@@ -0,0 +1,46 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  cdll_dll.h
+
+// this file is included by both the game-dll and the client-dll,
+
+#ifndef CDLL_DLL_H
+#define CDLL_DLL_H
+
+#define MAX_WEAPONS		32		// ???
+
+#define MAX_WEAPON_SLOTS		5	// hud item selection slots
+#define MAX_ITEM_TYPES			6	// hud item selection slots
+
+#define MAX_ITEMS				5	// hard coded item types
+
+#define	HIDEHUD_WEAPONS		( 1<<0 )
+#define	HIDEHUD_FLASHLIGHT	( 1<<1 )
+#define	HIDEHUD_ALL			( 1<<2 )
+#define 	HIDEHUD_HEALTH		( 1<<3 )
+
+#define	MAX_AMMO_TYPES	32		// ???
+#define MAX_AMMO_SLOTS  32		// not really slots
+
+#define HUD_PRINTNOTIFY		1
+#define HUD_PRINTCONSOLE	2
+#define HUD_PRINTTALK		3
+#define HUD_PRINTCENTER		4
+
+
+#define WEAPON_SUIT			31
+
+#endif

src/dlls/cmbase.cpp

@@ -0,0 +1,306 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include	"extdll.h"
+#include	"util.h"
+#include	"cmbase.h"
+#include	"decals.h"
+
+extern Vector VecBModelOrigin( entvars_t* pevBModel );
+extern DLL_GLOBAL Vector		g_vecAttackDir;
+
+edict_t * EHANDLE::Get( void ) 
+{ 
+	if (m_pent)
+	{
+		if (m_pent->serialnumber == m_serialnumber) 
+			return m_pent; 
+		else
+			return NULL;
+	}
+	return NULL; 
+};
+
+edict_t * EHANDLE::Set( edict_t *pent ) 
+{ 
+	m_pent = pent;  
+	if (pent) 
+		m_serialnumber = m_pent->serialnumber; 
+	return pent; 
+};
+
+
+EHANDLE :: operator edict_t *() 
+{ 
+	return Get( ); 
+};
+
+
+edict_t * EHANDLE :: operator = (edict_t *pEntity)
+{
+	if (pEntity)
+	{
+		m_pent = pEntity;
+		if (m_pent)
+			m_serialnumber = m_pent->serialnumber;
+	}
+	else
+	{
+		m_pent = NULL;
+		m_serialnumber = 0;
+	}
+	return pEntity;
+}
+
+
+edict_t * EHANDLE :: operator -> ()
+{
+	return Get( ); 
+}
+
+
+void *CMBaseEntity::operator new( size_t stAllocateBlock )
+{
+	void *mem = ::operator new( stAllocateBlock );
+	memset( mem, 0, stAllocateBlock );
+	return mem;
+}
+
+
+edict_t *CMBaseEntity::CreateEntity(char *classname)
+{
+   int istr = MAKE_STRING(classname);
+
+   edict_t *pent = CREATE_NAMED_ENTITY(istr);
+
+   if ( FNullEnt( pent ) )
+      return NULL;
+
+   pev = VARS(pent);
+
+   pev->movetype = MOVETYPE_NONE;
+   pev->solid = SOLID_NOT;
+   pev->flags = 0;
+
+   m_pfnThink = NULL;
+   m_pfnTouch = NULL;
+   m_pfnUse = NULL;
+   m_pfnBlocked = NULL;
+
+   pev->euser4 = (edict_t *)this;
+
+   return pent;
+}
+
+// give health
+int CMBaseEntity :: TakeHealth( float flHealth, int bitsDamageType )
+{
+	if (!pev->takedamage)
+		return 0;
+
+// heal
+	if ( pev->health >= pev->max_health )
+		return 0;
+
+	pev->health += flHealth;
+
+	if (pev->health > pev->max_health)
+		pev->health = pev->max_health;
+
+	return 1;
+}
+
+// inflict damage on this entity.  bitsDamageType indicates type of damage inflicted, ie: DMG_CRUSH
+
+int CMBaseEntity :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType )
+{
+	Vector			vecTemp;
+
+	if (!pev->takedamage)
+		return 0;
+
+	// UNDONE: some entity types may be immune or resistant to some bitsDamageType
+	
+	// if Attacker == Inflictor, the attack was a melee or other instant-hit attack.
+	// (that is, no actual entity projectile was involved in the attack so use the shooter's origin). 
+	if ( pevAttacker == pevInflictor )	
+	{
+		vecTemp = pevInflictor->origin - ( VecBModelOrigin(pev) );
+	}
+	else
+	// an actual missile was involved.
+	{
+		vecTemp = pevInflictor->origin - ( VecBModelOrigin(pev) );
+	}
+
+// this global is still used for glass and other non-monster killables, along with decals.
+	g_vecAttackDir = vecTemp.Normalize();
+		
+// save damage based on the target's armor level
+
+// figure momentum add (don't let hurt brushes or other triggers move player)
+	if ((!FNullEnt(pevInflictor)) && (pev->movetype == MOVETYPE_WALK || pev->movetype == MOVETYPE_STEP) && (pevAttacker->solid != SOLID_TRIGGER) )
+	{
+		Vector vecDir = pev->origin - (pevInflictor->absmin + pevInflictor->absmax) * 0.5;
+		vecDir = vecDir.Normalize();
+
+		float flForce = flDamage * ((32 * 32 * 72.0) / (pev->size.x * pev->size.y * pev->size.z)) * 5;
+		
+		if (flForce > 1000.0) 
+			flForce = 1000.0;
+		pev->velocity = pev->velocity + vecDir * flForce;
+	}
+
+// do the damage
+	pev->health -= flDamage;
+	if (pev->health <= 0)
+	{
+		Killed( pevAttacker, GIB_NORMAL );
+		return 0;
+	}
+
+	return 1;
+}
+
+
+void CMBaseEntity :: Killed( entvars_t *pevAttacker, int iGib )
+{
+	pev->takedamage = DAMAGE_NO;
+	pev->deadflag = DEAD_DEAD;
+	UTIL_Remove( this->edict() );
+}
+
+
+// Initialize absmin & absmax to the appropriate box
+void SetObjectCollisionBox( entvars_t *pev )
+{
+	if ( (pev->solid == SOLID_BSP) && 
+		 (pev->angles.x || pev->angles.y|| pev->angles.z) )
+	{	// expand for rotation
+		float		max, v;
+		int			i;
+
+		max = 0;
+		for (i=0 ; i<3 ; i++)
+		{
+			v = fabs( ((float *)pev->mins)[i]);
+			if (v > max)
+				max = v;
+			v = fabs( ((float *)pev->maxs)[i]);
+			if (v > max)
+				max = v;
+		}
+		for (i=0 ; i<3 ; i++)
+		{
+			((float *)pev->absmin)[i] = ((float *)pev->origin)[i] - max;
+			((float *)pev->absmax)[i] = ((float *)pev->origin)[i] + max;
+		}
+	}
+	else
+	{
+		pev->absmin = pev->origin + pev->mins;
+		pev->absmax = pev->origin + pev->maxs;
+	}
+
+	pev->absmin.x -= 1;
+	pev->absmin.y -= 1;
+	pev->absmin.z -= 1;
+	pev->absmax.x += 1;
+	pev->absmax.y += 1;
+	pev->absmax.z += 1;
+}
+
+
+void CMBaseEntity::SetObjectCollisionBox( void )
+{
+	::SetObjectCollisionBox( pev );
+}
+
+
+int	CMBaseEntity :: Intersects( CMBaseEntity *pOther )
+{
+	if ( pOther->pev->absmin.x > pev->absmax.x ||
+		 pOther->pev->absmin.y > pev->absmax.y ||
+		 pOther->pev->absmin.z > pev->absmax.z ||
+		 pOther->pev->absmax.x < pev->absmin.x ||
+		 pOther->pev->absmax.y < pev->absmin.y ||
+		 pOther->pev->absmax.z < pev->absmin.z )
+		 return 0;
+	return 1;
+}
+
+void CMBaseEntity :: MakeDormant( void )
+{
+	SetBits( pev->flags, FL_DORMANT );
+	
+	// Don't touch
+	pev->solid = SOLID_NOT;
+	// Don't move
+	pev->movetype = MOVETYPE_NONE;
+	// Don't draw
+	SetBits( pev->effects, EF_NODRAW );
+	// Don't think
+	pev->nextthink = 0;
+	// Relink
+	UTIL_SetOrigin( pev, pev->origin );
+}
+
+int CMBaseEntity :: IsDormant( void )
+{
+	return FBitSet( pev->flags, FL_DORMANT );
+}
+
+BOOL CMBaseEntity :: IsInWorld( void )
+{
+	// position 
+	if (pev->origin.x >= 4096) return FALSE;
+	if (pev->origin.y >= 4096) return FALSE;
+	if (pev->origin.z >= 4096) return FALSE;
+	if (pev->origin.x <= -4096) return FALSE;
+	if (pev->origin.y <= -4096) return FALSE;
+	if (pev->origin.z <= -4096) return FALSE;
+	// speed
+	if (pev->velocity.x >= 2000) return FALSE;
+	if (pev->velocity.y >= 2000) return FALSE;
+	if (pev->velocity.z >= 2000) return FALSE;
+	if (pev->velocity.x <= -2000) return FALSE;
+	if (pev->velocity.y <= -2000) return FALSE;
+	if (pev->velocity.z <= -2000) return FALSE;
+
+	return TRUE;
+}
+
+int CMBaseEntity::ShouldToggle( USE_TYPE useType, BOOL currentState )
+{
+	if ( useType != USE_TOGGLE && useType != USE_SET )
+	{
+		if ( (currentState && useType == USE_ON) || (!currentState && useType == USE_OFF) )
+			return 0;
+	}
+	return 1;
+}
+
+
+int	CMBaseEntity :: DamageDecal( int bitsDamageType )
+{
+	if ( pev->rendermode == kRenderTransAlpha )
+		return -1;
+
+	if ( pev->rendermode != kRenderNormal )
+		return DECAL_BPROOF1;
+
+	return DECAL_GUNSHOT1 + RANDOM_LONG(0,4);
+}
+
+

src/dlls/cmbase.h

@@ -0,0 +1,611 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/*
+
+Class Hierachy
+
+CMBaseEntity
+   CMBaseDelay
+      CMBaseAnimating
+         CMBaseToggle
+            CMBaseMonster
+*/
+
+#include "monster_plugin.h"
+
+#define		MAX_PATH_SIZE	10 // max number of nodes available for a path.
+
+// These are caps bits to indicate what an object's capabilities (currently used for save/restore and level transitions)
+#define		FCAP_CUSTOMSAVE				0x00000001
+#define		FCAP_ACROSS_TRANSITION		0x00000002		// should transfer between transitions
+#define		FCAP_MUST_SPAWN				0x00000004		// Spawn after restore
+#define		FCAP_DONT_SAVE				0x80000000		// Don't save this
+#define		FCAP_IMPULSE_USE			0x00000008		// can be used by the player
+#define		FCAP_CONTINUOUS_USE			0x00000010		// can be used by the player
+#define		FCAP_ONOFF_USE				0x00000020		// can be used by the player
+#define		FCAP_DIRECTIONAL_USE		0x00000040		// Player sends +/- 1 when using (currently only tracktrains)
+#define		FCAP_MASTER					0x00000080		// Can be used to "master" other entities (like multisource)
+
+// UNDONE: This will ignore transition volumes (trigger_transition), but not the PVS!!!
+#define		FCAP_FORCE_TRANSITION		0x00000080		// ALWAYS goes across transitions
+
+#include "schedule.h"
+
+#ifndef MONSTEREVENT_H
+#include "monsterevent.h"
+#endif
+
+// C functions for external declarations that call the appropriate C++ methods
+
+#ifdef _WIN32
+#define EXPORT	_declspec( dllexport )
+#else
+#define EXPORT	/* */
+#endif
+
+typedef enum { USE_OFF = 0, USE_ON = 1, USE_SET = 2, USE_TOGGLE = 3 } USE_TYPE;
+
+class CMBaseEntity;
+
+extern void FireTargets( const char *targetName, edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value );
+
+typedef void (CMBaseEntity::*BASEPTR)(void);
+typedef void (CMBaseEntity::*ENTITYFUNCPTR)(CMBaseEntity *pOther );
+typedef void (CMBaseEntity::*USEPTR)( edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value );
+
+// For CLASSIFY
+#define	CLASS_NONE				0
+#define CLASS_MACHINE			1
+#define CLASS_PLAYER			2
+#define	CLASS_HUMAN_PASSIVE		3
+#define CLASS_HUMAN_MILITARY	4
+#define CLASS_ALIEN_MILITARY	5
+#define CLASS_ALIEN_PASSIVE		6
+#define CLASS_ALIEN_MONSTER		7
+#define CLASS_ALIEN_PREY		8
+#define CLASS_ALIEN_PREDATOR	9
+#define CLASS_INSECT			10
+#define CLASS_PLAYER_ALLY		11
+#define CLASS_PLAYER_BIOWEAPON	12 // hornets and snarks.launched by players
+#define CLASS_ALIEN_BIOWEAPON	13 // hornets and snarks.launched by the alien menace
+#define	CLASS_BARNACLE			99 // special because no one pays attention to it, and it eats a wide cross-section of creatures.
+
+class CMBaseEntity;
+class CMBaseMonster;
+
+
+#define	SF_NORESPAWN	( 1 << 30 )// !!!set this bit on guns and stuff that should never respawn.
+
+//
+// EHANDLE. Safe way to point to edict_t who may die between frames
+//
+class EHANDLE
+{
+private:
+	edict_t *m_pent;
+	int		m_serialnumber;
+public:
+	edict_t *Get( void );
+	edict_t *Set( edict_t *pent );
+
+	operator edict_t *();
+
+	edict_t * operator = (edict_t *pEntity);
+	edict_t * operator ->();
+};
+
+
+template <class T> T * GetClassPtr( T *a );
+
+//
+// Base Entity.  All entity types derive from this
+//
+class CMBaseEntity 
+{
+public:
+	// Constructor.  Set engine to use C/C++ callback functions
+	// pointers to engine data
+	entvars_t *pev;		// Don't need to save/restore this pointer, the engine resets it
+
+	// path corners
+	edict_t		*m_pGoalEnt;// path corner we are heading towards
+
+   edict_t *m_edictList[100];
+   int m_edictList_count;
+
+	void *operator new( size_t stAllocateBlock );
+
+   virtual edict_t *CreateEntity(char *classname);
+
+	// initialization functions
+	virtual void	Spawn( void ) { return; }
+	virtual void	Precache( void ) { return; }
+	virtual void	KeyValue( KeyValueData* pkvd) { pkvd->fHandled = FALSE; }
+	virtual int		ObjectCaps( void ) { return FCAP_ACROSS_TRANSITION; }
+	virtual void	Activate( void ) {}
+	
+	// Setup the object->object collision box (pev->mins / pev->maxs is the object->world collision box)
+	virtual void	SetObjectCollisionBox( void );
+
+// Classify - returns the type of group (i.e, "houndeye", or "human military" so that monsters with different classnames
+// still realize that they are teammates. (overridden for monsters that form groups)
+	virtual int Classify ( void ) { return CLASS_NONE; };
+	virtual void DeathNotice ( entvars_t *pevChild ) {}// monster maker children use this to tell the monster maker that they have died.
+
+	virtual void	TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
+	virtual int		TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
+	virtual int		TakeHealth( float flHealth, int bitsDamageType );
+	virtual void	Killed( entvars_t *pevAttacker, int iGib );
+	virtual int		BloodColor( void ) { return DONT_BLEED; }
+	virtual void	TraceBleed( float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
+	virtual BOOL    IsTriggered( CMBaseEntity *pActivator ) {return TRUE;}
+	virtual CMBaseMonster *MyMonsterPointer( void ) { return NULL;}
+	virtual	int		GetToggleState( void ) { return TS_AT_TOP; }
+	virtual void	AddPoints( int score, BOOL bAllowNegativeScore ) {}
+	virtual void	AddPointsToTeam( int score, BOOL bAllowNegativeScore ) {}
+	virtual float	GetDelay( void ) { return 0; }
+	virtual int		IsMoving( void ) { return pev->velocity != g_vecZero; }
+	virtual void	OverrideReset( void ) {}
+	virtual int		DamageDecal( int bitsDamageType );
+	// This is ONLY used by the node graph to test movement through a door
+	virtual void	SetToggleState( int state ) {}
+	virtual void    StartSneaking( void ) {}
+	virtual void    StopSneaking( void ) {}
+	virtual BOOL	OnControls( entvars_t *pev ) { return FALSE; }
+	virtual BOOL    IsSneaking( void ) { return FALSE; }
+	virtual BOOL	IsAlive( void ) { return (pev->deadflag == DEAD_NO) && pev->health > 0; }
+	virtual BOOL	IsBSPModel( void ) { return pev->solid == SOLID_BSP || pev->movetype == MOVETYPE_PUSHSTEP; }
+	virtual BOOL	ReflectGauss( void ) { return ( IsBSPModel() && !pev->takedamage ); }
+	virtual BOOL	HasTarget( string_t targetname ) { return FStrEq(STRING(targetname), STRING(pev->targetname) ); }
+	virtual BOOL    IsInWorld( void );
+	virtual	BOOL	IsPlayer( void ) { return FALSE; }
+	virtual BOOL	IsNetClient( void ) { return FALSE; }
+	virtual const char *TeamID( void ) { return ""; }
+
+
+//	virtual void	SetActivator( CMBaseEntity *pActivator ) {}
+//jlb	virtual CMBaseEntity *GetNextTarget( void );
+	
+	// fundamental callbacks
+	void (CMBaseEntity ::*m_pfnThink)(void);
+	void (CMBaseEntity ::*m_pfnTouch)( edict_t *pOther );
+	void (CMBaseEntity ::*m_pfnUse)( edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value );
+	void (CMBaseEntity ::*m_pfnBlocked)( edict_t *pOther );
+
+	virtual void Think( void ) { if (m_pfnThink) (this->*m_pfnThink)(); };
+	virtual void Touch( edict_t *pOther ) { if (m_pfnTouch) (this->*m_pfnTouch)( pOther ); };
+	virtual void Use( edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value ) 
+	{ 
+		if (m_pfnUse) 
+			(this->*m_pfnUse)( pActivator, pCaller, useType, value );
+	}
+	virtual void Blocked( edict_t *pOther ) { if (m_pfnBlocked) (this->*m_pfnBlocked)( pOther ); };
+
+	void UpdateOnRemove( void );
+
+	// common member functions
+	void EXPORT SUB_Remove( void );
+	void EXPORT SUB_DoNothing( void );
+	void EXPORT SUB_StartFadeOut ( void );
+	void EXPORT SUB_FadeOut ( void );
+	void EXPORT SUB_CallUseToggle( void ) { this->Use( this->edict(), this->edict(), USE_TOGGLE, 0 ); }
+	int			ShouldToggle( USE_TYPE useType, BOOL currentState );
+	void		FireBullets( ULONG	cShots, Vector  vecSrc, Vector	vecDirShooting,	Vector	vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL  );
+	Vector		FireBulletsPlayer( ULONG	cShots, Vector  vecSrc, Vector	vecDirShooting,	Vector	vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL, int shared_rand = 0 );
+
+	virtual CMBaseEntity *Respawn( void ) { return NULL; }
+
+	void SUB_UseTargets( edict_t *pActivator, USE_TYPE useType, float value );
+	// Do the bounding boxes of these two intersect?
+	int		Intersects( CMBaseEntity *pOther );
+	void	MakeDormant( void );
+	int		IsDormant( void );
+	BOOL    IsLockedByMaster( void ) { return FALSE; }
+
+	static CMBaseEntity *Instance( edict_t *pent )
+	{ 
+		if ( !pent )
+			pent = ENT(0);
+		if ( pent->v.euser4 == NULL )
+			return (CMBaseEntity *)NULL;
+      CMBaseEntity *pEnt = GetClassPtr((CMBaseEntity *)VARS(pent));
+		return pEnt; 
+	}
+
+	static CMBaseEntity *Instance( entvars_t *pev ) { return Instance( ENT( pev ) ); }
+	static CMBaseEntity *Instance( int eoffset) { return Instance( ENT( eoffset) ); }
+
+/*jlb
+	CMBaseMonster *GetMonsterPointer( entvars_t *pevMonster ) 
+	{ 
+		CMBaseEntity *pEntity = Instance( pevMonster );
+		if ( pEntity )
+			return pEntity->MyMonsterPointer();
+		return NULL;
+	}
+	CMBaseMonster *GetMonsterPointer( edict_t *pentMonster ) 
+	{ 
+		CMBaseEntity *pEntity = Instance( pentMonster );
+		if ( pEntity )
+			return pEntity->MyMonsterPointer();
+		return NULL;
+	}
+jlb*/
+
+	// virtual functions used by a few classes
+	
+	// used by monsters that are created by the MonsterMaker
+	virtual	void UpdateOwner( void ) { return; };
+
+
+	//
+//jlb	static CMBaseEntity *Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner = NULL );
+
+	virtual BOOL FBecomeProne( void ) {return FALSE;};
+	edict_t *edict() { return ENT( pev ); };
+	EOFFSET eoffset( ) { return OFFSET( pev ); };
+	int	  entindex( ) { return ENTINDEX( edict() ); };
+
+	virtual Vector Center( ) { return (pev->absmax + pev->absmin) * 0.5; }; // center point of entity
+	virtual Vector EyePosition( ) { return pev->origin + pev->view_ofs; };			// position of eyes
+	virtual Vector EarPosition( ) { return pev->origin + pev->view_ofs; };			// position of ears
+	virtual Vector BodyTarget( const Vector &posSrc ) { return Center( ); };		// position to shoot at
+
+	virtual int Illumination( ) { return GETENTITYILLUM( ENT( pev ) ); };
+
+//	virtual	BOOL FVisible ( edict_t *pEntity );
+//	virtual	BOOL FVisible ( const Vector &vecOrigin );
+
+	//We use this variables to store each ammo count.
+	int ammo_9mm;
+	int ammo_357;
+	int ammo_bolts;
+	int ammo_buckshot;
+	int ammo_rockets;
+	int ammo_uranium;
+	int ammo_hornets;
+	int ammo_argrens;
+	//Special stuff for grenades and satchels.
+	float m_flStartThrow;
+	float m_flReleaseThrow;
+	int m_chargeReady;
+	int m_fInAttack;
+
+	enum EGON_FIRESTATE { FIRE_OFF, FIRE_CHARGE };
+	int m_fireState;
+};
+
+
+
+// Ugly technique to override base member functions
+// Normally it's illegal to cast a pointer to a member function of a derived class to a pointer to a 
+// member function of a base class.  static_cast is a sleezy way around that problem.
+
+#define SetThink( a ) m_pfnThink = static_cast <void (CMBaseEntity::*)(void)> (a)
+#define SetTouch( a ) m_pfnTouch = static_cast <void (CMBaseEntity::*)(edict_t *)> (a)
+#define SetUse( a ) m_pfnUse = static_cast <void (CMBaseEntity::*)( edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value )> (a)
+#define SetBlocked( a ) m_pfnBlocked = static_cast <void (CMBaseEntity::*)(edict_t *)> (a)
+
+
+class CMPointEntity : public CMBaseEntity
+{
+public:
+	void	Spawn( void );
+	virtual int	ObjectCaps( void ) { return CMBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
+private:
+};
+
+
+typedef struct locksounds			// sounds that doors and buttons make when locked/unlocked
+{
+	string_t	sLockedSound;		// sound a door makes when it's locked
+	string_t	sLockedSentence;	// sentence group played when door is locked
+	string_t	sUnlockedSound;		// sound a door makes when it's unlocked
+	string_t	sUnlockedSentence;	// sentence group played when door is unlocked
+
+	int		iLockedSentence;		// which sentence in sentence group to play next
+	int		iUnlockedSentence;		// which sentence in sentence group to play next
+
+	float	flwaitSound;			// time delay between playing consecutive 'locked/unlocked' sounds
+	float	flwaitSentence;			// time delay between playing consecutive sentences
+	BYTE	bEOFLocked;				// true if hit end of list of locked sentences
+	BYTE	bEOFUnlocked;			// true if hit end of list of unlocked sentences
+} locksound_t;
+
+void PlayLockSounds(entvars_t *pev, locksound_t *pls, int flocked, int fbutton);
+
+
+//
+// generic Delay entity.
+//
+class CMBaseDelay : public CMBaseEntity
+{
+public:
+	float		m_flDelay;
+	int			m_iszKillTarget;
+
+	virtual void	KeyValue( KeyValueData* pkvd);
+	
+	// common member functions
+	void SUB_UseTargets( edict_t *pActivator, USE_TYPE useType, float value );
+	void EXPORT DelayThink( void );
+};
+
+
+class CMBaseAnimating : public CMBaseDelay
+{
+public:
+
+	// Basic Monster Animation functions
+	float StudioFrameAdvance( float flInterval = 0.0 ); // accumulate animation frame time from last time called until now
+	int	 GetSequenceFlags( void );
+	int  LookupActivity ( int activity );
+	int  LookupActivityHeaviest ( int activity );
+	int  LookupSequence ( const char *label );
+	void ResetSequenceInfo ( );
+	void DispatchAnimEvents ( float flFutureInterval = 0.1 ); // Handle events that have happend since last time called up until X seconds into the future
+	virtual void HandleAnimEvent( MonsterEvent_t *pEvent ) { return; };
+	float SetBoneController ( int iController, float flValue );
+	void InitBoneControllers ( void );
+	float SetBlending ( int iBlender, float flValue );
+	void GetBonePosition ( int iBone, Vector &origin, Vector &angles );
+	void GetAutomovement( Vector &origin, Vector &angles, float flInterval = 0.1 );
+	int  FindTransition( int iEndingSequence, int iGoalSequence, int *piDir );
+	void GetAttachment ( int iAttachment, Vector &origin, Vector &angles );
+	void SetBodygroup( int iGroup, int iValue );
+	int GetBodygroup( int iGroup );
+	int ExtractBbox( int sequence, float *mins, float *maxs );
+	void SetSequenceBox( void );
+
+	// animation needs
+	float				m_flFrameRate;		// computed FPS for current sequence
+	float				m_flGroundSpeed;	// computed linear movement rate for current sequence
+	float				m_flLastEventCheck;	// last time the event list was checked
+	BOOL				m_fSequenceFinished;// flag set when StudioAdvanceFrame moves across a frame boundry
+	BOOL				m_fSequenceLoops;	// true if the sequence loops
+};
+
+
+//
+// generic Toggle entity.
+//
+#define	SF_ITEM_USE_ONLY	256 //  ITEM_USE_ONLY = BUTTON_USE_ONLY = DOOR_USE_ONLY!!! 
+
+class CMBaseToggle : public CMBaseAnimating
+{
+public:
+	void				KeyValue( KeyValueData *pkvd );
+
+	TOGGLE_STATE		m_toggle_state;
+	float				m_flActivateFinished;//like attack_finished, but for doors
+	float				m_flMoveDistance;// how far a door should slide or rotate
+	float				m_flWait;
+	float				m_flLip;
+	float				m_flTWidth;// for plats
+	float				m_flTLength;// for plats
+
+	Vector				m_vecPosition1;
+	Vector				m_vecPosition2;
+	Vector				m_vecAngle1;
+	Vector				m_vecAngle2;
+
+	int					m_cTriggersLeft;		// trigger_counter only, # of activations remaining
+	float				m_flHeight;
+//jlb	EHANDLE				m_hActivator;
+	void (CMBaseToggle::*m_pfnCallWhenMoveDone)(void);
+	Vector				m_vecFinalDest;
+	Vector				m_vecFinalAngle;
+
+	int					m_bitsDamageInflict;	// DMG_ damage type that the door or tigger does
+
+	virtual int		GetToggleState( void ) { return m_toggle_state; }
+	virtual float	GetDelay( void ) { return m_flWait; }
+
+	// common member functions
+	void LinearMove( Vector	vecDest, float flSpeed );
+	void EXPORT LinearMoveDone( void );
+	void AngularMove( Vector vecDestAngle, float flSpeed );
+	void EXPORT AngularMoveDone( void );
+	BOOL IsLockedByMaster( void );
+
+	static float		AxisValue( int flags, const Vector &angles );
+	static void			AxisDir( entvars_t *pev );
+	static float		AxisDelta( int flags, const Vector &angle1, const Vector &angle2 );
+
+	string_t m_sMaster;		// If this button has a master switch, this is the targetname.
+							// A master switch must be of the multisource type. If all 
+							// of the switches in the multisource have been triggered, then
+							// the button will be allowed to operate. Otherwise, it will be
+							// deactivated.
+};
+#define SetMoveDone( a ) m_pfnCallWhenMoveDone = static_cast <void (CMBaseToggle::*)(void)> (a)
+
+
+// people gib if their health is <= this at the time of death
+#define	GIB_HEALTH_VALUE	-30
+
+#define	ROUTE_SIZE			8 // how many waypoints a monster can store at one time
+#define MAX_OLD_ENEMIES		4 // how many old enemies to remember
+
+#define	bits_CAP_DUCK			( 1 << 0 )// crouch
+#define	bits_CAP_JUMP			( 1 << 1 )// jump/leap
+#define bits_CAP_STRAFE			( 1 << 2 )// strafe ( walk/run sideways)
+//??? #define bits_CAP_SQUAD			( 1 << 3 )// can form squads
+#define	bits_CAP_SWIM			( 1 << 4 )// proficiently navigate in water
+#define bits_CAP_CLIMB			( 1 << 5 )// climb ladders/ropes
+#define bits_CAP_USE			( 1 << 6 )// open doors/push buttons/pull levers
+#define bits_CAP_HEAR			( 1 << 7 )// can hear forced sounds
+#define bits_CAP_AUTO_DOORS		( 1 << 8 )// can trigger auto doors
+#define bits_CAP_OPEN_DOORS		( 1 << 9 )// can open manual doors
+#define bits_CAP_TURN_HEAD		( 1 << 10)// can turn head, always bone controller 0
+
+#define bits_CAP_RANGE_ATTACK1	( 1 << 11)// can do a range attack 1
+#define bits_CAP_RANGE_ATTACK2	( 1 << 12)// can do a range attack 2
+#define bits_CAP_MELEE_ATTACK1	( 1 << 13)// can do a melee attack 1
+#define bits_CAP_MELEE_ATTACK2	( 1 << 14)// can do a melee attack 2
+
+#define bits_CAP_FLY			( 1 << 15)// can fly, move all around
+
+#define bits_CAP_DOORS_GROUP    (bits_CAP_USE | bits_CAP_AUTO_DOORS | bits_CAP_OPEN_DOORS)
+
+// used by suit voice to indicate damage sustained and repaired type to player
+
+// instant damage
+
+#define DMG_GENERIC			0			// generic damage was done
+#define DMG_CRUSH			(1 << 0)	// crushed by falling or moving object
+#define DMG_BULLET			(1 << 1)	// shot
+#define DMG_SLASH			(1 << 2)	// cut, clawed, stabbed
+#define DMG_BURN			(1 << 3)	// heat burned
+#define DMG_FREEZE			(1 << 4)	// frozen
+#define DMG_FALL			(1 << 5)	// fell too far
+#define DMG_BLAST			(1 << 6)	// explosive blast damage
+#define DMG_CLUB			(1 << 7)	// crowbar, punch, headbutt
+#define DMG_SHOCK			(1 << 8)	// electric shock
+#define DMG_SONIC			(1 << 9)	// sound pulse shockwave
+#define DMG_ENERGYBEAM		(1 << 10)	// laser or other high energy beam 
+#define DMG_NEVERGIB		(1 << 12)	// with this bit OR'd in, no damage type will be able to gib victims upon death
+#define DMG_ALWAYSGIB		(1 << 13)	// with this bit OR'd in, any damage type can be made to gib victims upon death.
+#define DMG_DROWN			(1 << 14)	// Drowning
+// time-based damage
+#define DMG_TIMEBASED		(~(0x3fff))	// mask for time-based damage
+
+#define DMG_PARALYZE		(1 << 15)	// slows affected creature down
+#define DMG_NERVEGAS		(1 << 16)	// nerve toxins, very bad
+#define DMG_POISON			(1 << 17)	// blood poisioning
+#define DMG_RADIATION		(1 << 18)	// radiation exposure
+#define DMG_DROWNRECOVER	(1 << 19)	// drowning recovery
+#define DMG_ACID			(1 << 20)	// toxic chemicals or acid burns
+#define DMG_SLOWBURN		(1 << 21)	// in an oven
+#define DMG_SLOWFREEZE		(1 << 22)	// in a subzero freezer
+#define DMG_MORTAR			(1 << 23)	// Hit by air raid (done to distinguish grenade from mortar)
+
+// these are the damage types that are allowed to gib corpses
+#define DMG_GIB_CORPSE		( DMG_CRUSH | DMG_FALL | DMG_BLAST | DMG_SONIC | DMG_CLUB )
+
+// these are the damage types that have client hud art
+#define DMG_SHOWNHUD		(DMG_POISON | DMG_ACID | DMG_FREEZE | DMG_SLOWFREEZE | DMG_DROWN | DMG_BURN | DMG_SLOWBURN | DMG_NERVEGAS | DMG_RADIATION | DMG_SHOCK)
+
+// NOTE: tweak these values based on gameplay feedback:
+
+#define PARALYZE_DURATION	2		// number of 2 second intervals to take damage
+#define PARALYZE_DAMAGE		1.0		// damage to take each 2 second interval
+
+#define NERVEGAS_DURATION	2
+#define NERVEGAS_DAMAGE		5.0
+
+#define POISON_DURATION		5
+#define POISON_DAMAGE		2.0
+
+#define RADIATION_DURATION	2
+#define RADIATION_DAMAGE	1.0
+
+#define ACID_DURATION		2
+#define ACID_DAMAGE			5.0
+
+#define SLOWBURN_DURATION	2
+#define SLOWBURN_DAMAGE		1.0
+
+#define SLOWFREEZE_DURATION	2
+#define SLOWFREEZE_DAMAGE	1.0
+
+
+#define	itbd_Paralyze		0		
+#define	itbd_NerveGas		1
+#define	itbd_Poison			2
+#define	itbd_Radiation		3
+#define	itbd_DrownRecover	4
+#define	itbd_Acid			5
+#define	itbd_SlowBurn		6
+#define	itbd_SlowFreeze		7
+#define CDMG_TIMEBASED		8
+
+// when calling KILLED(), a value that governs gib behavior is expected to be 
+// one of these three values
+#define GIB_NORMAL			0// gib if entity was overkilled
+#define GIB_NEVER			1// never gib, no matter how much death damage is done ( freezing, etc )
+#define GIB_ALWAYS			2// always gib ( Houndeye Shock, Barnacle Bite )
+
+class CMBaseMonster;
+
+
+extern int GetMonsterIndex(void);
+
+//
+// Converts a entvars_t * to a class pointer
+//
+template <class T> T * GetClassPtr( T *a )
+{
+	entvars_t *pev = (entvars_t *)a;
+
+	if (pev == NULL)
+		return NULL;
+
+	// get the private data
+	a = (T *)pev->euser4;
+
+	return a;
+}
+
+//
+// Converts a entvars_t * to a class pointer
+// It will allocate the class and entity
+//
+template <class T> T * CreateClassPtr( T *a )
+{
+	entvars_t *pev = (entvars_t *)a;
+
+	if (pev != NULL)
+		return NULL;  // don't allocate if pointer already provided
+
+	// allocate entity...
+	edict_t *temp_edict;
+	int edict_index;
+	int monster_index;
+
+	if ((monster_index = GetMonsterIndex()) == -1)
+	{
+		(*g_engfuncs.pfnServerPrint)("[MONSTER] ERROR: No FREE Monster edicts in CreateClassPtr!\n" );
+		return NULL;
+	}
+
+	// allocate private data 
+	a = new T;
+
+	if ((temp_edict = a->CreateEntity("func_wall")) == NULL)
+	{
+		(*g_engfuncs.pfnServerPrint)("[MONSTER] ERROR: NULL Ent in CreateClassPtr!\n" );
+		delete a;
+		return NULL;
+	}
+
+	edict_index = (*g_engfuncs.pfnIndexOfEdict)(temp_edict);
+
+	// store the class pointer to the edict pev...
+	pev = VARS(temp_edict);
+	a->pev = pev;
+
+	// store the class pointer in the array here!!!
+	monsters[monster_index].monster_index = edict_index;
+	monsters[monster_index].monster_pent = temp_edict;
+	monsters[monster_index].respawn_index = -1;
+	monsters[monster_index].pMonster = (CMBaseMonster *)a;
+
+	// get the private data
+	a = (T *)pev->euser4;
+
+	return a;
+}
+

src/dlls/cmflyingmonster.h

@@ -0,0 +1,53 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+// Base class for flying monsters.  This overrides the movement test & execution code from CBaseMonster
+
+#ifndef FLYINGMONSTER_H
+#define FLYINGMONSTER_H
+
+class CMFlyingMonster : public CMBaseMonster
+{
+public:
+	int 		CheckLocalMove ( const Vector &vecStart, const Vector &vecEnd, edict_t *pTarget, float *pflDist );// check validity of a straight move through space
+	BOOL		FTriangulate ( const Vector &vecStart , const Vector &vecEnd, float flDist, edict_t *pTargetEnt, Vector *pApex );
+	Activity	GetStoppedActivity( void );
+	void		Killed( entvars_t *pevAttacker, int iGib );
+	void		Stop( void );
+	float		ChangeYaw( int speed );
+	void		HandleAnimEvent( MonsterEvent_t *pEvent );
+	void		MoveExecute( edict_t *pTargetEnt, const Vector &vecDir, float flInterval );
+	void		Move( float flInterval = 0.1 );
+	BOOL		ShouldAdvanceRoute( float flWaypointDist );
+
+	inline void	SetFlyingMomentum( float momentum ) { m_momentum = momentum; }
+	inline void	SetFlyingFlapSound( const char *pFlapSound ) { m_pFlapSound = pFlapSound; }
+	inline void	SetFlyingSpeed( float speed ) { m_flightSpeed = speed; }
+	float		CeilingZ( const Vector &position );
+	float		FloorZ( const Vector &position );
+	BOOL		ProbeZ( const Vector &position, const Vector &probe, float *pFraction );
+	
+	
+	// UNDONE:  Save/restore this stuff!!!
+protected:
+	Vector		m_vecTravel;		// Current direction
+	float		m_flightSpeed;		// Current flight speed (decays when not flapping or gliding)
+	float		m_stopTime;			// Last time we stopped (to avoid switching states too soon)
+	float		m_momentum;			// Weight for desired vs. momentum velocity
+	const char	*m_pFlapSound;
+};
+
+
+#endif		//FLYINGMONSTER_H
+

src/dlls/cmtalkmonster.h

@@ -0,0 +1,178 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+#ifndef TALKMONSTER_H
+#define TALKMONSTER_H
+
+#ifndef MONSTERS_H
+#include "monsters.h"
+#endif
+
+//=========================================================
+// Talking monster base class
+// Used for scientists and barneys
+//=========================================================
+
+#define TALKRANGE_MIN 500.0				// don't talk to anyone farther away than this
+
+#define TLK_STARE_DIST	128				// anyone closer than this and looking at me is probably staring at me.
+
+#define bit_saidDamageLight		(1<<0)	// bits so we don't repeat key sentences
+#define bit_saidDamageMedium	(1<<1)
+#define bit_saidDamageHeavy		(1<<2)
+#define bit_saidHelloPlayer		(1<<3)
+#define bit_saidWoundLight		(1<<4)
+#define bit_saidWoundHeavy		(1<<5)
+#define bit_saidHeard			(1<<6)
+#define bit_saidSmelled			(1<<7)
+
+#define TLK_CFRIENDS		3
+
+typedef enum
+{
+	TLK_ANSWER = 0,
+	TLK_QUESTION,
+	TLK_IDLE,
+	TLK_STARE,
+	TLK_USE,
+	TLK_UNUSE,
+	TLK_STOP,
+	TLK_NOSHOOT,
+	TLK_HELLO,
+	TLK_PHELLO,
+	TLK_PIDLE,
+	TLK_PQUESTION,
+	TLK_PLHURT1,
+	TLK_PLHURT2,
+	TLK_PLHURT3,
+	TLK_SMELL,
+	TLK_WOUND,
+	TLK_MORTAL,
+
+	TLK_CGROUPS,					// MUST be last entry
+} TALKGROUPNAMES;
+
+
+enum
+{
+	SCHED_CANT_FOLLOW = LAST_COMMON_SCHEDULE + 1,
+	SCHED_MOVE_AWAY,		// Try to get out of the player's way
+	SCHED_MOVE_AWAY_FOLLOW,	// same, but follow afterward
+	SCHED_MOVE_AWAY_FAIL,	// Turn back toward player
+
+	LAST_TALKMONSTER_SCHEDULE,		// MUST be last
+};
+
+enum
+{
+	TASK_CANT_FOLLOW = LAST_COMMON_TASK + 1,
+	TASK_MOVE_AWAY_PATH,
+	TASK_WALK_PATH_FOR_UNITS,
+
+	TASK_TLK_RESPOND,		// say my response
+	TASK_TLK_SPEAK,			// question or remark
+	TASK_TLK_HELLO,			// Try to say hello to player
+	TASK_TLK_HEADRESET,		// reset head position
+	TASK_TLK_STOPSHOOTING,	// tell player to stop shooting friend
+	TASK_TLK_STARE,			// let the player know I know he's staring at me.
+	TASK_TLK_LOOK_AT_CLIENT,// faces player if not moving and not talking and in idle.
+	TASK_TLK_CLIENT_STARE,	// same as look at client, but says something if the player stares.
+	TASK_TLK_EYECONTACT,	// maintain eyecontact with person who I'm talking to
+	TASK_TLK_IDEALYAW,		// set ideal yaw to face who I'm talking to
+	TASK_FACE_PLAYER,		// Face the player
+
+	LAST_TALKMONSTER_TASK,			// MUST be last
+};
+
+class CMTalkMonster : public CMBaseMonster
+{
+public:
+	void			TalkInit( void );				
+	edict_t		*FindNearestFriend(BOOL fPlayer);
+	float			TargetDistance( void );
+	void			StopTalking( void ) { SentenceStop(); }
+	
+	// Base Monster functions
+	void			Precache( void );
+	int				TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
+	void			TalkTouch(	edict_t *pOther );
+	void			Killed( entvars_t *pevAttacker, int iGib );
+	int				IRelationship ( CMBaseEntity *pTarget );
+	virtual int		CanPlaySentence( BOOL fDisregardState );
+	virtual void	PlaySentence( const char *pszSentence, float duration, float volume, float attenuation );
+	void			PlayScriptedSentence( const char *pszSentence, float duration, float volume, float attenuation, BOOL bConcurrent, edict_t *pListener );
+	void			KeyValue( KeyValueData *pkvd );
+
+	// AI functions
+	void			SetActivity ( Activity newActivity );
+	Schedule_t		*GetScheduleOfType ( int Type );
+	void			StartTask( Task_t *pTask );
+	void			RunTask( Task_t *pTask );
+	void			HandleAnimEvent( MonsterEvent_t *pEvent );
+	void			PrescheduleThink( void );
+	
+
+	// Conversations / communication
+	int				GetVoicePitch( void );
+	void			IdleRespond( void );
+	int				FIdleSpeak( void );
+	int				FIdleStare( void );
+	int				FIdleHello( void );
+	void			IdleHeadTurn( Vector &vecFriend );
+	int				FOkToSpeak( void );
+	void			TrySmellTalk( void );
+	edict_t		*EnumFriends( edict_t *pentPrevious, int listNumber, BOOL bTrace );
+	void			AlertFriends( void );
+	void			ShutUpFriends( void );
+	BOOL			IsTalking( void );
+	void			Talk( float flDuration );	
+	// For following
+	BOOL			CanFollow( void );
+	BOOL			IsFollowing( void ) { return m_hTargetEnt != NULL && UTIL_IsPlayer(m_hTargetEnt); }
+	void			StopFollowing( BOOL clearSchedule );
+	void			StartFollowing( edict_t *pLeader );
+	virtual void	DeclineFollowing( void ) {}
+	void			LimitFollowers( edict_t *pPlayer, int maxFollowers );
+
+	void EXPORT		FollowerUse( edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value );
+	
+	virtual void	SetAnswerQuestion( edict_t *pSpeaker );
+	virtual int		FriendNumber( int arrayNumber )	{ return arrayNumber; }
+
+	static char *m_szFriends[TLK_CFRIENDS];		// array of friend names
+	static float g_talkWaitTime;
+	
+	int			m_bitsSaid;						// set bits for sentences we don't want repeated
+	int			m_nSpeak;						// number of times initiated talking
+	int			m_voicePitch;					// pitch of voice for this head
+	const char	*m_szGrp[TLK_CGROUPS];			// sentence group names
+	float		m_useTime;						// Don't allow +USE until this time
+	int			m_iszUse;						// Custom +USE sentence group (follow)
+	int			m_iszUnUse;						// Custom +USE sentence group (stop following)
+
+	float		m_flLastSaidSmelled;// last time we talked about something that stinks
+	float		m_flStopTalkTime;// when in the future that I'll be done saying this sentence.
+
+	EHANDLE		m_hTalkTarget;	// who to look at while talking
+	CUSTOM_SCHEDULES;
+};
+
+
+// Clients can push talkmonsters out of their way
+#define		bits_COND_CLIENT_PUSH		( bits_COND_SPECIAL1 )
+// Don't see a client right now.
+#define		bits_COND_CLIENT_UNSEEN		( bits_COND_SPECIAL2 )
+
+
+#endif		//TALKMONSTER_H

src/dlls/decals.h

@@ -0,0 +1,75 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef DECALS_H
+#define DECALS_H
+
+//
+// Dynamic Decals
+//
+enum decal_e 
+{	
+	DECAL_GUNSHOT1 = 0, 
+	DECAL_GUNSHOT2,
+	DECAL_GUNSHOT3,
+	DECAL_GUNSHOT4,
+	DECAL_GUNSHOT5,
+	DECAL_LAMBDA1,
+	DECAL_LAMBDA2,
+	DECAL_LAMBDA3,
+	DECAL_LAMBDA4,
+	DECAL_LAMBDA5,
+	DECAL_LAMBDA6,
+	DECAL_SCORCH1,
+	DECAL_SCORCH2,
+	DECAL_BLOOD1, 
+	DECAL_BLOOD2, 
+	DECAL_BLOOD3, 
+	DECAL_BLOOD4, 
+	DECAL_BLOOD5, 
+	DECAL_BLOOD6, 
+	DECAL_YBLOOD1, 
+	DECAL_YBLOOD2, 
+	DECAL_YBLOOD3, 
+	DECAL_YBLOOD4, 
+	DECAL_YBLOOD5, 
+	DECAL_YBLOOD6, 
+	DECAL_GLASSBREAK1,
+	DECAL_GLASSBREAK2,
+	DECAL_GLASSBREAK3,
+	DECAL_BIGSHOT1,
+	DECAL_BIGSHOT2,
+	DECAL_BIGSHOT3,
+	DECAL_BIGSHOT4,
+	DECAL_BIGSHOT5,
+	DECAL_SPIT1,
+	DECAL_SPIT2,
+	DECAL_BPROOF1,		// Bulletproof glass decal
+	DECAL_GARGSTOMP1,	// Gargantua stomp crack
+	DECAL_SMALLSCORCH1,	// Small scorch mark
+	DECAL_SMALLSCORCH2,	// Small scorch mark
+	DECAL_SMALLSCORCH3,	// Small scorch mark
+	DECAL_MOMMABIRTH,	// Big momma birth splatter
+	DECAL_MOMMASPLAT,
+};
+
+typedef struct 
+{
+	char	*name;
+	int		index;
+} DLL_DECALLIST;
+
+extern DLL_DECALLIST gDecals[];
+
+#endif	// DECALS_H

src/dlls/defaultai.h

@@ -0,0 +1,98 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+#ifndef DEFAULTAI_H
+#define DEFAULTAI_H
+
+//=========================================================
+// Failed
+//=========================================================
+extern Schedule_t	slFail[];
+
+//=========================================================
+//	Idle Schedules
+//=========================================================
+extern Schedule_t	slIdleStand[];
+extern Schedule_t	slIdleTrigger[];
+extern Schedule_t	slIdleWalk[];
+
+//=========================================================
+//	Wake Schedules
+//=========================================================
+extern Schedule_t slWakeAngry[];
+
+//=========================================================
+// AlertTurn Schedules
+//=========================================================
+extern Schedule_t	slAlertFace[];
+
+//=========================================================
+// AlertIdle Schedules
+//=========================================================
+extern Schedule_t	slAlertStand[];
+
+//=========================================================
+// CombatIdle Schedule
+//=========================================================
+extern Schedule_t	slCombatStand[];
+
+//=========================================================
+// CombatFace Schedule
+//=========================================================
+extern Schedule_t	slCombatFace[];
+
+//=========================================================
+// reload schedule
+//=========================================================
+extern Schedule_t slReload[];
+
+//=========================================================
+//	Attack Schedules
+//=========================================================
+
+extern Schedule_t	slRangeAttack1[];
+extern Schedule_t	slRangeAttack2[];
+
+extern Schedule_t	slTakeCoverFromBestSound[];
+
+// primary melee attack
+extern Schedule_t	slMeleeAttack[];
+
+// Chase enemy schedule
+extern Schedule_t slChaseEnemy[];
+
+//=========================================================
+// small flinch, used when a relatively minor bit of damage
+// is inflicted.
+//=========================================================
+extern Schedule_t slSmallFlinch[];
+
+//=========================================================
+// Die!
+//=========================================================
+extern Schedule_t slDie[];
+
+//=========================================================
+//	Universal Error Schedule
+//=========================================================
+extern Schedule_t slError[];
+
+//=========================================================
+//	Scripted sequences
+//=========================================================
+extern Schedule_t slWalkToScript[];
+extern Schedule_t slRunToScript[];
+extern Schedule_t slWaitScript[];
+
+#endif		// DEFAULTAI_H

src/dlls/doors.h

@@ -0,0 +1,33 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef DOORS_H
+#define DOORS_H
+
+// doors
+#define SF_DOOR_ROTATE_Y			0
+#define	SF_DOOR_START_OPEN			1
+#define SF_DOOR_ROTATE_BACKWARDS	2
+#define SF_DOOR_PASSABLE			8
+#define SF_DOOR_ONEWAY				16
+#define	SF_DOOR_NO_AUTO_RETURN		32
+#define SF_DOOR_ROTATE_Z			64
+#define SF_DOOR_ROTATE_X			128
+#define SF_DOOR_USE_ONLY			256	// door must be opened by player's use button.
+#define SF_DOOR_NOMONSTERS			512	// Monster can't open
+#define SF_DOOR_SILENT				0x80000000
+
+
+
+#endif		//DOORS_H

src/dlls/effects.cpp

@@ -0,0 +1,446 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#include "extdll.h"
+#include "util.h"
+#include "cmbase.h"
+#include "cmbasemonster.h"
+#include "monsters.h"
+#include "customentity.h"
+#include "effects.h"
+#include "weapons.h"
+#include "decals.h"
+#include "func_break.h"
+#include "shake.h"
+
+#define	SF_GIBSHOOTER_REPEATABLE	1 // allows a gibshooter to be refired
+
+#define SF_FUNNEL_REVERSE			1 // funnel effect repels particles instead of attracting them.
+
+
+// --------------------------------------------------
+// 
+// Beams
+//
+// --------------------------------------------------
+
+void CMBeam::Spawn( void )
+{
+	pev->solid = SOLID_NOT;							// Remove model & collisions
+	Precache( );
+}
+
+void CMBeam::Precache( void )
+{
+	if ( pev->owner )
+		SetStartEntity( ENTINDEX( pev->owner ) );
+	if ( pev->aiment )
+		SetEndEntity( ENTINDEX( pev->aiment ) );
+}
+
+void CMBeam::SetStartEntity( int entityIndex ) 
+{ 
+	pev->sequence = (entityIndex & 0x0FFF) | ((pev->sequence&0xF000)<<12); 
+	pev->owner = g_engfuncs.pfnPEntityOfEntIndex( entityIndex );
+}
+
+void CMBeam::SetEndEntity( int entityIndex ) 
+{ 
+	pev->skin = (entityIndex & 0x0FFF) | ((pev->skin&0xF000)<<12); 
+	pev->aiment = g_engfuncs.pfnPEntityOfEntIndex( entityIndex );
+}
+
+
+// These don't take attachments into account
+const Vector &CMBeam::GetStartPos( void )
+{
+	if ( GetType() == BEAM_ENTS )
+	{
+		edict_t *pent =  g_engfuncs.pfnPEntityOfEntIndex( GetStartEntity() );
+		return pent->v.origin;
+	}
+	return pev->origin;
+}
+
+
+const Vector &CMBeam::GetEndPos( void )
+{
+	int type = GetType();
+	if ( type == BEAM_POINTS || type == BEAM_HOSE )
+	{
+		return pev->angles;
+	}
+
+	edict_t *pent =  g_engfuncs.pfnPEntityOfEntIndex( GetEndEntity() );
+	if ( pent )
+		return pent->v.origin;
+	return pev->angles;
+}
+
+
+CMBeam *CMBeam::BeamCreate( const char *pSpriteName, int width )
+{
+	// Create a new entity with CMBeam private data
+	CMBeam *pBeam = CreateClassPtr( (CMBeam *)NULL );
+
+   if (pBeam == NULL)
+      return NULL;
+
+	pBeam->pev->classname = MAKE_STRING("beam");
+
+	pBeam->BeamInit( pSpriteName, width );
+
+	return pBeam;
+}
+
+
+void CMBeam::BeamInit( const char *pSpriteName, int width )
+{
+	pev->flags |= FL_CUSTOMENTITY;
+	SetColor( 255, 255, 255 );
+	SetBrightness( 255 );
+	SetNoise( 0 );
+	SetFrame( 0 );
+	SetScrollRate( 0 );
+	pev->model = MAKE_STRING( pSpriteName );
+	SetTexture( PRECACHE_MODEL( (char *)pSpriteName ) );
+	SetWidth( width );
+	pev->skin = 0;
+	pev->sequence = 0;
+	pev->rendermode = 0;
+}
+
+
+void CMBeam::PointsInit( const Vector &start, const Vector &end )
+{
+	SetType( BEAM_POINTS );
+	SetStartPos( start );
+	SetEndPos( end );
+	SetStartAttachment( 0 );
+	SetEndAttachment( 0 );
+	RelinkBeam();
+}
+
+
+void CMBeam::HoseInit( const Vector &start, const Vector &direction )
+{
+	SetType( BEAM_HOSE );
+	SetStartPos( start );
+	SetEndPos( direction );
+	SetStartAttachment( 0 );
+	SetEndAttachment( 0 );
+	RelinkBeam();
+}
+
+
+void CMBeam::PointEntInit( const Vector &start, int endIndex )
+{
+	SetType( BEAM_ENTPOINT );
+	SetStartPos( start );
+	SetEndEntity( endIndex );
+	SetStartAttachment( 0 );
+	SetEndAttachment( 0 );
+	RelinkBeam();
+}
+
+void CMBeam::EntsInit( int startIndex, int endIndex )
+{
+	SetType( BEAM_ENTS );
+	SetStartEntity( startIndex );
+	SetEndEntity( endIndex );
+	SetStartAttachment( 0 );
+	SetEndAttachment( 0 );
+	RelinkBeam();
+}
+
+
+void CMBeam::RelinkBeam( void )
+{
+	const Vector &startPos = GetStartPos(), &endPos = GetEndPos();
+
+	pev->mins.x = min( startPos.x, endPos.x );
+	pev->mins.y = min( startPos.y, endPos.y );
+	pev->mins.z = min( startPos.z, endPos.z );
+	pev->maxs.x = max( startPos.x, endPos.x );
+	pev->maxs.y = max( startPos.y, endPos.y );
+	pev->maxs.z = max( startPos.z, endPos.z );
+	pev->mins = pev->mins - pev->origin;
+	pev->maxs = pev->maxs - pev->origin;
+
+	UTIL_SetSize( pev, pev->mins, pev->maxs );
+	UTIL_SetOrigin( pev, pev->origin );
+}
+
+#if 0
+void CMBeam::SetObjectCollisionBox( void )
+{
+	const Vector &startPos = GetStartPos(), &endPos = GetEndPos();
+
+	pev->absmin.x = min( startPos.x, endPos.x );
+	pev->absmin.y = min( startPos.y, endPos.y );
+	pev->absmin.z = min( startPos.z, endPos.z );
+	pev->absmax.x = max( startPos.x, endPos.x );
+	pev->absmax.y = max( startPos.y, endPos.y );
+	pev->absmax.z = max( startPos.z, endPos.z );
+}
+#endif
+
+
+void CMBeam::TriggerTouch( edict_t *pOther )
+{
+	if ( pOther->v.flags & (FL_CLIENT | FL_MONSTER) )
+	{
+		if ( pev->owner )
+		{
+			if (pev->owner->v.euser4 != NULL)
+			{
+				CMBaseEntity *pOwner = GetClassPtr((CMBaseEntity *)VARS(pev->owner));
+				pOwner->Use( pOther, this->edict(), USE_TOGGLE, 0 );
+			}
+		}
+		ALERT( at_console, "Firing targets!!!\n" );
+	}
+}
+
+
+edict_t *CMBeam::RandomTargetname( const char *szName )
+{
+	int total = 0;
+
+	edict_t *pEntity = NULL;
+	edict_t *pNewEntity = NULL;
+	while ((pNewEntity = UTIL_FindEntityByTargetname( pNewEntity, szName )) != NULL)
+	{
+		total++;
+		if (RANDOM_LONG(0,total-1) < 1)
+			pEntity = pNewEntity;
+	}
+	return pEntity;
+}
+
+
+void CMBeam::DoSparks( const Vector &start, const Vector &end )
+{
+	if ( pev->spawnflags & (SF_BEAM_SPARKSTART|SF_BEAM_SPARKEND) )
+	{
+		if ( pev->spawnflags & SF_BEAM_SPARKSTART )
+		{
+			UTIL_Sparks( start );
+		}
+		if ( pev->spawnflags & SF_BEAM_SPARKEND )
+		{
+			UTIL_Sparks( end );
+		}
+	}
+}
+
+void CMBeam::BeamDamage( TraceResult *ptr )
+{
+	RelinkBeam();
+	if ( ptr->flFraction != 1.0 && ptr->pHit != NULL )
+	{
+		if (UTIL_IsPlayer(ptr->pHit))
+		{
+			ClearMultiDamage();
+			UTIL_TraceAttack(ptr->pHit, pev, pev->dmg * (gpGlobals->time - pev->dmgtime), (ptr->vecEndPos - pev->origin).Normalize(), ptr, DMG_ENERGYBEAM );
+			ApplyMultiDamage( pev, pev );
+
+			if ( pev->spawnflags & SF_BEAM_DECALS )
+			{
+				if ( UTIL_IsBSPModel(ptr->pHit) )
+					UTIL_DecalTrace( ptr, DECAL_BIGSHOT1 + RANDOM_LONG(0,4) );
+			}			
+
+		}
+		else if (ptr->pHit->v.euser4 != NULL)
+		{
+			ClearMultiDamage();
+			CMBaseEntity *pMonster = GetClassPtr((CMBaseEntity *)VARS(ptr->pHit));
+			pMonster->TraceAttack( pev, pev->dmg * (gpGlobals->time - pev->dmgtime), (ptr->vecEndPos - pev->origin).Normalize(), ptr, DMG_ENERGYBEAM );
+			ApplyMultiDamage( pev, pev );
+
+			if ( pev->spawnflags & SF_BEAM_DECALS )
+			{
+				if ( pMonster->IsBSPModel() )
+					UTIL_DecalTrace( ptr, DECAL_BIGSHOT1 + RANDOM_LONG(0,4) );
+			}
+		}
+	}
+	pev->dmgtime = gpGlobals->time;
+}
+
+
+void CMSprite::Spawn( void )
+{
+	pev->solid			= SOLID_NOT;
+	pev->movetype		= MOVETYPE_NONE;
+	pev->effects		= 0;
+	pev->frame			= 0;
+
+	Precache();
+	SET_MODEL( ENT(pev), STRING(pev->model) );
+
+	m_maxFrame = (float) MODEL_FRAMES( pev->modelindex ) - 1;
+	if ( pev->targetname && !(pev->spawnflags & SF_SPRITE_STARTON) )
+		TurnOff();
+	else
+		TurnOn();
+	
+	// Worldcraft only sets y rotation, copy to Z
+	if ( pev->angles.y != 0 && pev->angles.z == 0 )
+	{
+		pev->angles.z = pev->angles.y;
+		pev->angles.y = 0;
+	}
+}
+
+
+void CMSprite::Precache( void )
+{
+	PRECACHE_MODEL( (char *)STRING(pev->model) );
+
+	// Reset attachment after save/restore
+	if ( pev->aiment )
+		SetAttachment( pev->aiment, pev->body );
+	else
+	{
+		// Clear attachment
+		pev->skin = 0;
+		pev->body = 0;
+	}
+}
+
+
+void CMSprite::SpriteInit( const char *pSpriteName, const Vector &origin )
+{
+	pev->model = MAKE_STRING(pSpriteName);
+	pev->origin = origin;
+	Spawn();
+}
+
+CMSprite *CMSprite::SpriteCreate( const char *pSpriteName, const Vector &origin, BOOL animate )
+{
+	CMSprite *pSprite = CreateClassPtr( (CMSprite *)NULL );
+	pSprite->SpriteInit( pSpriteName, origin );
+	pSprite->pev->classname = MAKE_STRING("env_sprite");
+	pSprite->pev->solid = SOLID_NOT;
+	pSprite->pev->movetype = MOVETYPE_NOCLIP;
+	if ( animate )
+		pSprite->TurnOn();
+
+	return pSprite;
+}
+
+
+void CMSprite::AnimateThink( void )
+{
+	Animate( pev->framerate * (gpGlobals->time - m_lastTime) );
+
+	pev->nextthink		= gpGlobals->time + 0.1;
+	m_lastTime			= gpGlobals->time;
+}
+
+void CMSprite::AnimateUntilDead( void )
+{
+	if ( gpGlobals->time > pev->dmgtime )
+		UTIL_Remove(this->edict());
+	else
+	{
+		AnimateThink();
+		pev->nextthink = gpGlobals->time;
+	}
+}
+
+void CMSprite::Expand( float scaleSpeed, float fadeSpeed )
+{
+	pev->speed = scaleSpeed;
+	pev->health = fadeSpeed;
+	SetThink( ExpandThink );
+
+	pev->nextthink	= gpGlobals->time;
+	m_lastTime		= gpGlobals->time;
+}
+
+
+void CMSprite::ExpandThink( void )
+{
+	float frametime = gpGlobals->time - m_lastTime;
+	pev->scale += pev->speed * frametime;
+	pev->renderamt -= pev->health * frametime;
+	if ( pev->renderamt <= 0 )
+	{
+		pev->renderamt = 0;
+		UTIL_Remove( this->edict() );
+	}
+	else
+	{
+		pev->nextthink		= gpGlobals->time + 0.1;
+		m_lastTime			= gpGlobals->time;
+	}
+}
+
+
+void CMSprite::Animate( float frames )
+{ 
+	pev->frame += frames;
+	if ( pev->frame > m_maxFrame )
+	{
+		if ( pev->spawnflags & SF_SPRITE_ONCE )
+		{
+			TurnOff();
+		}
+		else
+		{
+			if ( m_maxFrame > 0 )
+				pev->frame = fmod( pev->frame, m_maxFrame );
+		}
+	}
+}
+
+
+void CMSprite::TurnOff( void )
+{
+	pev->effects = EF_NODRAW;
+	pev->nextthink = 0;
+}
+
+
+void CMSprite::TurnOn( void )
+{
+	pev->effects = 0;
+	if ( (pev->framerate && m_maxFrame > 1.0) || (pev->spawnflags & SF_SPRITE_ONCE) )
+	{
+		SetThink( AnimateThink );
+		pev->nextthink = gpGlobals->time;
+		m_lastTime = gpGlobals->time;
+	}
+	pev->frame = 0;
+}
+
+
+void CMSprite::Use( edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value )
+{
+	int on = pev->effects != EF_NODRAW;
+	if ( ShouldToggle( useType, on ) )
+	{
+		if ( on )
+		{
+			TurnOff();
+		}
+		else
+		{
+			TurnOn();
+		}
+	}
+}

src/dlls/effects.h

@@ -0,0 +1,203 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef EFFECTS_H
+#define EFFECTS_H
+
+#define SF_BEAM_STARTON			0x0001
+#define SF_BEAM_TOGGLE			0x0002
+#define SF_BEAM_RANDOM			0x0004
+#define SF_BEAM_RING			0x0008
+#define SF_BEAM_SPARKSTART		0x0010
+#define SF_BEAM_SPARKEND		0x0020
+#define SF_BEAM_DECALS			0x0040
+#define SF_BEAM_SHADEIN			0x0080
+#define SF_BEAM_SHADEOUT		0x0100
+#define SF_BEAM_TEMPORARY		0x8000
+
+#define SF_SPRITE_STARTON		0x0001
+#define SF_SPRITE_ONCE			0x0002
+#define SF_SPRITE_TEMPORARY		0x8000
+
+class CMSprite : public CMPointEntity
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+
+	int		ObjectCaps( void )
+	{ 
+		int flags = 0;
+		if ( pev->spawnflags & SF_SPRITE_TEMPORARY )
+			flags = FCAP_DONT_SAVE;
+		return (CMBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags; 
+	}
+	void EXPORT AnimateThink( void );
+	void EXPORT ExpandThink( void );
+	void Use( edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value );
+	void Animate( float frames );
+	void Expand( float scaleSpeed, float fadeSpeed );
+	void SpriteInit( const char *pSpriteName, const Vector &origin );
+
+	inline void SetAttachment( edict_t *pEntity, int attachment )
+	{
+		if ( pEntity )
+		{
+			pev->skin = ENTINDEX(pEntity);
+			pev->body = attachment;
+			pev->aiment = pEntity;
+			pev->movetype = MOVETYPE_FOLLOW;
+		}
+	}
+	void TurnOff( void );
+	void TurnOn( void );
+	inline float Frames( void ) { return m_maxFrame; }
+	inline void SetTransparency( int rendermode, int r, int g, int b, int a, int fx )
+	{
+		pev->rendermode = rendermode;
+		pev->rendercolor.x = r;
+		pev->rendercolor.y = g;
+		pev->rendercolor.z = b;
+		pev->renderamt = a;
+		pev->renderfx = fx;
+	}
+	inline void SetTexture( int spriteIndex ) { pev->modelindex = spriteIndex; }
+	inline void SetScale( float scale ) { pev->scale = scale; }
+	inline void SetColor( int r, int g, int b ) { pev->rendercolor.x = r; pev->rendercolor.y = g; pev->rendercolor.z = b; }
+	inline void SetBrightness( int brightness ) { pev->renderamt = brightness; }
+
+	inline void AnimateAndDie( float framerate ) 
+	{ 
+		SetThink(AnimateUntilDead); 
+		pev->framerate = framerate;
+		pev->dmgtime = gpGlobals->time + (m_maxFrame / framerate); 
+		pev->nextthink = gpGlobals->time; 
+	}
+
+	void EXPORT AnimateUntilDead( void );
+
+	static CMSprite *SpriteCreate( const char *pSpriteName, const Vector &origin, BOOL animate );
+
+private:
+
+	float		m_lastTime;
+	float		m_maxFrame;
+};
+
+
+class CMBeam : public CMBaseEntity
+{
+public:
+	void	Spawn( void );
+	void	Precache( void );
+	int		ObjectCaps( void )
+	{ 
+		int flags = 0;
+		if ( pev->spawnflags & SF_BEAM_TEMPORARY )
+			flags = FCAP_DONT_SAVE;
+		return (CMBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags; 
+	}
+
+	void EXPORT TriggerTouch( edict_t *pOther );
+
+	// These functions are here to show the way beams are encoded as entities.
+	// Encoding beams as entities simplifies their management in the client/server architecture
+	inline void	SetType( int type ) { pev->rendermode = (pev->rendermode & 0xF0) | (type&0x0F); }
+	inline void	SetFlags( int flags ) { pev->rendermode = (pev->rendermode & 0x0F) | (flags&0xF0); }
+	inline void SetStartPos( const Vector& pos ) { pev->origin = pos; }
+	inline void SetEndPos( const Vector& pos ) { pev->angles = pos; }
+	void SetStartEntity( int entityIndex );
+	void SetEndEntity( int entityIndex );
+
+	inline void SetStartAttachment( int attachment ) { pev->sequence = (pev->sequence & 0x0FFF) | ((attachment&0xF)<<12); }
+	inline void SetEndAttachment( int attachment ) { pev->skin = (pev->skin & 0x0FFF) | ((attachment&0xF)<<12); }
+
+	inline void SetTexture( int spriteIndex ) { pev->modelindex = spriteIndex; }
+	inline void SetWidth( int width ) { pev->scale = width; }
+	inline void SetNoise( int amplitude ) { pev->body = amplitude; }
+	inline void SetColor( int r, int g, int b ) { pev->rendercolor.x = r; pev->rendercolor.y = g; pev->rendercolor.z = b; }
+	inline void SetBrightness( int brightness ) { pev->renderamt = brightness; }
+	inline void SetFrame( float frame ) { pev->frame = frame; }
+	inline void SetScrollRate( int speed ) { pev->animtime = speed; }
+
+	inline int	GetType( void ) { return pev->rendermode & 0x0F; }
+	inline int	GetFlags( void ) { return pev->rendermode & 0xF0; }
+	inline int	GetStartEntity( void ) { return pev->sequence & 0xFFF; }
+	inline int	GetEndEntity( void ) { return pev->skin & 0xFFF; }
+
+	const Vector &GetStartPos( void );
+	const Vector &GetEndPos( void );
+
+	Vector Center( void ) { return (GetStartPos() + GetEndPos()) * 0.5; }; // center point of beam
+
+	inline int  GetTexture( void ) { return pev->modelindex; }
+	inline int  GetWidth( void ) { return pev->scale; }
+	inline int  GetNoise( void ) { return pev->body; }
+	// inline void GetColor( int r, int g, int b ) { pev->rendercolor.x = r; pev->rendercolor.y = g; pev->rendercolor.z = b; }
+	inline int  GetBrightness( void ) { return pev->renderamt; }
+	inline int  GetFrame( void ) { return pev->frame; }
+	inline int  GetScrollRate( void ) { return pev->animtime; }
+
+	// Call after you change start/end positions
+	void		RelinkBeam( void );
+//	void		SetObjectCollisionBox( void );
+
+	void		DoSparks( const Vector &start, const Vector &end );
+	edict_t *RandomTargetname( const char *szName );
+	void		BeamDamage( TraceResult *ptr );
+	// Init after BeamCreate()
+	void		BeamInit( const char *pSpriteName, int width );
+	void		PointsInit( const Vector &start, const Vector &end );
+	void		PointEntInit( const Vector &start, int endIndex );
+	void		EntsInit( int startIndex, int endIndex );
+	void		HoseInit( const Vector &start, const Vector &direction );
+
+	static CMBeam *BeamCreate( const char *pSpriteName, int width );
+
+	inline void LiveForTime( float time ) { SetThink(SUB_Remove); pev->nextthink = gpGlobals->time + time; }
+	inline void	BeamDamageInstant( TraceResult *ptr, float damage ) 
+	{ 
+		pev->dmg = damage; 
+		pev->dmgtime = gpGlobals->time - 1;
+		BeamDamage(ptr); 
+	}
+};
+
+
+#define SF_MESSAGE_ONCE			0x0001		// Fade in, not out
+#define SF_MESSAGE_ALL			0x0002		// Send to all clients
+
+
+class CMLaser : public CMBeam
+{
+public:
+	void	Spawn( void );
+	void	Precache( void );
+	void	KeyValue( KeyValueData *pkvd );
+
+	void	TurnOn( void );
+	void	TurnOff( void );
+	int		IsOn( void );
+
+	void	FireAtPoint( TraceResult &point );
+
+	void	EXPORT StrikeThink( void );
+	void	Use( edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value );
+
+	CMSprite	*m_pSprite;
+	int		m_iszSpriteName;
+	Vector  m_firePosition;
+};
+
+#endif		//EFFECTS_H

src/dlls/enginecallback.h

@@ -0,0 +1,158 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef ENGINECALLBACK_H
+#define ENGINECALLBACK_H
+#pragma once
+
+#include "event_flags.h"
+
+// Must be provided by user of this code
+extern enginefuncs_t g_engfuncs;
+
+// The actual engine callbacks
+#define GETPLAYERUSERID (*g_engfuncs.pfnGetPlayerUserId)
+#define PRECACHE_MODEL	(*g_engfuncs.pfnPrecacheModel)
+#define PRECACHE_SOUND	(*g_engfuncs.pfnPrecacheSound)
+#define PRECACHE_GENERIC	(*g_engfuncs.pfnPrecacheGeneric)
+#define SET_MODEL		(*g_engfuncs.pfnSetModel)
+#define MODEL_INDEX		(*g_engfuncs.pfnModelIndex)
+#define MODEL_FRAMES	(*g_engfuncs.pfnModelFrames)
+#define SET_SIZE		(*g_engfuncs.pfnSetSize)
+#define CHANGE_LEVEL	(*g_engfuncs.pfnChangeLevel)
+#define GET_SPAWN_PARMS	(*g_engfuncs.pfnGetSpawnParms)
+#define SAVE_SPAWN_PARMS (*g_engfuncs.pfnSaveSpawnParms)
+#define VEC_TO_YAW		(*g_engfuncs.pfnVecToYaw)
+#define VEC_TO_ANGLES	(*g_engfuncs.pfnVecToAngles)
+#define MOVE_TO_ORIGIN  (*g_engfuncs.pfnMoveToOrigin)
+#define oldCHANGE_YAW		(*g_engfuncs.pfnChangeYaw)
+#define CHANGE_PITCH	(*g_engfuncs.pfnChangePitch)
+#define MAKE_VECTORS	(*g_engfuncs.pfnMakeVectors)
+#define CREATE_ENTITY	(*g_engfuncs.pfnCreateEntity)
+#define REMOVE_ENTITY	(*g_engfuncs.pfnRemoveEntity)
+#define CREATE_NAMED_ENTITY		(*g_engfuncs.pfnCreateNamedEntity)
+#define MAKE_STATIC		(*g_engfuncs.pfnMakeStatic)
+#define ENT_IS_ON_FLOOR	(*g_engfuncs.pfnEntIsOnFloor)
+#define DROP_TO_FLOOR	(*g_engfuncs.pfnDropToFloor)
+#define WALK_MOVE		(*g_engfuncs.pfnWalkMove)
+#define SET_ORIGIN		(*g_engfuncs.pfnSetOrigin)
+#define EMIT_SOUND_DYN2 (*g_engfuncs.pfnEmitSound)
+#define BUILD_SOUND_MSG (*g_engfuncs.pfnBuildSoundMsg)
+#define TRACE_LINE		(*g_engfuncs.pfnTraceLine)
+#define TRACE_TOSS		(*g_engfuncs.pfnTraceToss)
+#define TRACE_MONSTER_HULL		(*g_engfuncs.pfnTraceMonsterHull)
+#define TRACE_HULL		(*g_engfuncs.pfnTraceHull)
+#define GET_AIM_VECTOR	(*g_engfuncs.pfnGetAimVector)
+#define SERVER_COMMAND	(*g_engfuncs.pfnServerCommand)
+#define SERVER_EXECUTE	(*g_engfuncs.pfnServerExecute)
+#define CLIENT_COMMAND	(*g_engfuncs.pfnClientCommand)
+#define PARTICLE_EFFECT	(*g_engfuncs.pfnParticleEffect)
+#define LIGHT_STYLE		(*g_engfuncs.pfnLightStyle)
+#define DECAL_INDEX		(*g_engfuncs.pfnDecalIndex)
+#define POINT_CONTENTS	(*g_engfuncs.pfnPointContents)
+#define CRC32_INIT           (*g_engfuncs.pfnCRC32_Init)
+#define CRC32_PROCESS_BUFFER (*g_engfuncs.pfnCRC32_ProcessBuffer)
+#define CRC32_PROCESS_BYTE   (*g_engfuncs.pfnCRC32_ProcessByte)
+#define CRC32_FINAL          (*g_engfuncs.pfnCRC32_Final)
+#define RANDOM_LONG		(*g_engfuncs.pfnRandomLong)
+#define RANDOM_FLOAT	(*g_engfuncs.pfnRandomFloat)
+#define GETPLAYERWONID	(*g_engfuncs.pfnGetPlayerWONId)
+
+inline void MESSAGE_BEGIN( int msg_dest, int msg_type, const float *pOrigin = NULL, edict_t *ed = NULL ) {
+	(*g_engfuncs.pfnMessageBegin)(msg_dest, msg_type, pOrigin, ed);
+}
+#define MESSAGE_END		(*g_engfuncs.pfnMessageEnd)
+#define WRITE_BYTE		(*g_engfuncs.pfnWriteByte)
+#define WRITE_CHAR		(*g_engfuncs.pfnWriteChar)
+#define WRITE_SHORT		(*g_engfuncs.pfnWriteShort)
+#define WRITE_LONG		(*g_engfuncs.pfnWriteLong)
+#define WRITE_ANGLE		(*g_engfuncs.pfnWriteAngle)
+#define WRITE_COORD		(*g_engfuncs.pfnWriteCoord)
+#define WRITE_STRING	(*g_engfuncs.pfnWriteString)
+#define WRITE_ENTITY	(*g_engfuncs.pfnWriteEntity)
+#define CVAR_REGISTER	(*g_engfuncs.pfnCVarRegister)
+#define CVAR_GET_FLOAT	(*g_engfuncs.pfnCVarGetFloat)
+#define CVAR_GET_STRING	(*g_engfuncs.pfnCVarGetString)
+#define CVAR_SET_FLOAT	(*g_engfuncs.pfnCVarSetFloat)
+#define CVAR_SET_STRING	(*g_engfuncs.pfnCVarSetString)
+#define CVAR_GET_POINTER (*g_engfuncs.pfnCVarGetPointer)
+#define ALERT			(*g_engfuncs.pfnAlertMessage)
+#define ENGINE_FPRINTF	(*g_engfuncs.pfnEngineFprintf)
+#define ALLOC_PRIVATE	(*g_engfuncs.pfnPvAllocEntPrivateData)
+inline void *GET_PRIVATE( edict_t *pent )
+{
+	if ( pent )
+		return pent->pvPrivateData;
+	return NULL;
+}
+
+#define FREE_PRIVATE	(*g_engfuncs.pfnFreeEntPrivateData)
+//#define STRING			(*g_engfuncs.pfnSzFromIndex)
+#define ALLOC_STRING	(*g_engfuncs.pfnAllocString)
+#define FIND_ENTITY_BY_STRING	(*g_engfuncs.pfnFindEntityByString)
+#define GETENTITYILLUM	(*g_engfuncs.pfnGetEntityIllum)
+#define FIND_ENTITY_IN_SPHERE		(*g_engfuncs.pfnFindEntityInSphere)
+#define FIND_CLIENT_IN_PVS			(*g_engfuncs.pfnFindClientInPVS)
+#define EMIT_AMBIENT_SOUND			(*g_engfuncs.pfnEmitAmbientSound)
+#define GET_MODEL_PTR				(*g_engfuncs.pfnGetModelPtr)
+#define REG_USER_MSG				(*g_engfuncs.pfnRegUserMsg)
+#define GET_BONE_POSITION			(*g_engfuncs.pfnGetBonePosition)
+#define FUNCTION_FROM_NAME			(*g_engfuncs.pfnFunctionFromName)
+#define NAME_FOR_FUNCTION			(*g_engfuncs.pfnNameForFunction)
+#define TRACE_TEXTURE				(*g_engfuncs.pfnTraceTexture)
+#define CLIENT_PRINTF				(*g_engfuncs.pfnClientPrintf)
+#define CMD_ARGS					(*g_engfuncs.pfnCmd_Args)
+#define CMD_ARGC					(*g_engfuncs.pfnCmd_Argc)
+#define CMD_ARGV					(*g_engfuncs.pfnCmd_Argv)
+#define GET_ATTACHMENT			(*g_engfuncs.pfnGetAttachment)
+#define SET_VIEW				(*g_engfuncs.pfnSetView)
+#define SET_CROSSHAIRANGLE		(*g_engfuncs.pfnCrosshairAngle)
+#define LOAD_FILE_FOR_ME		(*g_engfuncs.pfnLoadFileForMe)
+#define FREE_FILE				(*g_engfuncs.pfnFreeFile)
+#define COMPARE_FILE_TIME		(*g_engfuncs.pfnCompareFileTime)
+#define GET_GAME_DIR			(*g_engfuncs.pfnGetGameDir)
+#define IS_MAP_VALID			(*g_engfuncs.pfnIsMapValid)
+#define NUMBER_OF_ENTITIES		(*g_engfuncs.pfnNumberOfEntities)
+#define IS_DEDICATED_SERVER		(*g_engfuncs.pfnIsDedicatedServer)
+
+#define PRECACHE_EVENT			(*g_engfuncs.pfnPrecacheEvent)
+#define PLAYBACK_EVENT_FULL		(*g_engfuncs.pfnPlaybackEvent)
+
+#define ENGINE_SET_PVS			(*g_engfuncs.pfnSetFatPVS)
+#define ENGINE_SET_PAS			(*g_engfuncs.pfnSetFatPAS)
+
+#define ENGINE_CHECK_VISIBILITY (*g_engfuncs.pfnCheckVisibility)
+
+#define DELTA_SET				( *g_engfuncs.pfnDeltaSetField )
+#define DELTA_UNSET				( *g_engfuncs.pfnDeltaUnsetField )
+#define DELTA_ADDENCODER		( *g_engfuncs.pfnDeltaAddEncoder )
+#define ENGINE_CURRENT_PLAYER   ( *g_engfuncs.pfnGetCurrentPlayer )
+
+#define	ENGINE_CANSKIP			( *g_engfuncs.pfnCanSkipPlayer )
+
+#define DELTA_FINDFIELD			( *g_engfuncs.pfnDeltaFindField )
+#define DELTA_SETBYINDEX		( *g_engfuncs.pfnDeltaSetFieldByIndex )
+#define DELTA_UNSETBYINDEX		( *g_engfuncs.pfnDeltaUnsetFieldByIndex )
+
+#define ENGINE_GETPHYSINFO		( *g_engfuncs.pfnGetPhysicsInfoString )
+
+#define ENGINE_SETGROUPMASK		( *g_engfuncs.pfnSetGroupMask )
+
+#define ENGINE_INSTANCE_BASELINE ( *g_engfuncs.pfnCreateInstancedBaseline )
+
+#define ENGINE_FORCE_UNMODIFIED	( *g_engfuncs.pfnForceUnmodified )
+
+#define PLAYER_CNX_STATS		( *g_engfuncs.pfnGetPlayerStats )
+
+#endif		//ENGINECALLBACK_H

src/dlls/explode.h

@@ -0,0 +1,32 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef EXPLODE_H
+#define EXPLODE_H
+
+
+#define	SF_ENVEXPLOSION_NODAMAGE	( 1 << 0 ) // when set, ENV_EXPLOSION will not actually inflict damage
+#define	SF_ENVEXPLOSION_REPEATABLE	( 1 << 1 ) // can this entity be refired?
+#define SF_ENVEXPLOSION_NOFIREBALL	( 1 << 2 ) // don't draw the fireball
+#define SF_ENVEXPLOSION_NOSMOKE		( 1 << 3 ) // don't draw the smoke
+#define SF_ENVEXPLOSION_NODECAL		( 1 << 4 ) // don't make a scorch mark
+#define SF_ENVEXPLOSION_NOSPARKS	( 1 << 5 ) // don't make a scorch mark
+
+extern DLL_GLOBAL short	g_sModelIndexFireball;
+extern DLL_GLOBAL short	g_sModelIndexSmoke;
+
+
+extern void ExplosionCreate( const Vector &center, const Vector &angles, edict_t *pOwner, int magnitude, BOOL doDamage );
+
+#endif			//EXPLODE_H

src/dlls/extdll.h

@@ -0,0 +1,88 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef EXTDLL_H
+#define EXTDLL_H
+
+
+//
+// Global header file for extension DLLs
+//
+
+// Allow "DEBUG" in addition to default "_DEBUG"
+#ifdef _DEBUG
+#define DEBUG 1
+#endif
+
+// Silence certain warnings
+#pragma warning(disable : 4244)		// int or float down-conversion
+#pragma warning(disable : 4305)		// int or float data truncation
+#pragma warning(disable : 4201)		// nameless struct/union
+#pragma warning(disable : 4514)		// unreferenced inline function removed
+#pragma warning(disable : 4100)		// unreferenced formal parameter
+
+// Prevent tons of unused windows definitions
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#define NOWINRES
+#define NOSERVICE
+#define NOMCX
+#define NOIME
+#include "windows.h"
+#else // _WIN32
+#define FALSE 0
+#define TRUE (!FALSE)
+typedef unsigned long ULONG;
+typedef unsigned char BYTE;
+typedef int BOOL;
+#define MAX_PATH PATH_MAX
+#include <limits.h>
+#include <stdarg.h>
+#ifndef min
+#define min(a,b)  (((a) < (b)) ? (a) : (b))
+#endif
+#ifndef max
+#define max(a,b)  (((a) > (b)) ? (a) : (b))
+#define _vsnprintf(a,b,c,d) vsnprintf(a,b,c,d)
+#endif
+#endif //_WIN32
+
+// Misc C-runtime library headers
+#include "stdio.h"
+#include "stdlib.h"
+#include "math.h"
+
+// Header file containing definition of globalvars_t and entvars_t
+typedef int	func_t;					//
+typedef int	string_t;				// from engine's pr_comp.h;
+typedef float vec_t;				// needed before including progdefs.h
+
+// Vector class
+#include "vector.h"
+
+// Defining it as a (bogus) struct helps enforce type-checking
+#define vec3_t Vector
+
+// Shared engine/DLL constants
+#include "const.h"
+#include "progdefs.h"
+#include "edict.h"
+
+// Shared header describing protocol between engine and DLLs
+#include "eiface.h"
+
+// Shared header between the client DLL and the game DLLs
+#include "cdll_dll.h"
+
+#endif //EXTDLL_H

src/dlls/flyingmonster.cpp

@@ -0,0 +1,281 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+#include "extdll.h"
+#include "util.h"
+#include "cmbase.h"
+#include "cmbasemonster.h"
+#include "monsters.h"
+#include	"schedule.h"
+
+#define FLYING_AE_FLAP		(8)
+#define FLYING_AE_FLAPSOUND	(9)
+
+
+extern DLL_GLOBAL edict_t		*g_pBodyQueueHead;
+
+int CMFlyingMonster :: CheckLocalMove ( const Vector &vecStart, const Vector &vecEnd, edict_t *pTarget, float *pflDist )
+{
+	// UNDONE: need to check more than the endpoint
+	if (FBitSet(pev->flags, FL_SWIM) && (UTIL_PointContents(vecEnd) != CONTENTS_WATER))
+	{
+		// ALERT(at_aiconsole, "can't swim out of water\n");
+		return FALSE;
+	}
+
+	TraceResult tr;
+
+	UTIL_TraceHull( vecStart + Vector( 0, 0, 32 ), vecEnd + Vector( 0, 0, 32 ), dont_ignore_monsters, large_hull, edict(), &tr );
+
+	// ALERT( at_console, "%.0f %.0f %.0f : ", vecStart.x, vecStart.y, vecStart.z );
+	// ALERT( at_console, "%.0f %.0f %.0f\n", vecEnd.x, vecEnd.y, vecEnd.z );
+
+	if (pflDist)
+	{
+		*pflDist = ( (tr.vecEndPos - Vector( 0, 0, 32 )) - vecStart ).Length();// get the distance.
+	}
+
+	// ALERT( at_console, "check %d %d %f\n", tr.fStartSolid, tr.fAllSolid, tr.flFraction );
+	if (tr.fStartSolid || tr.flFraction < 1.0)
+	{
+		if ( pTarget && (pTarget == gpGlobals->trace_ent) )
+			return LOCALMOVE_VALID;
+		return LOCALMOVE_INVALID;
+	}
+
+	return LOCALMOVE_VALID;
+}
+
+
+BOOL CMFlyingMonster :: FTriangulate ( const Vector &vecStart , const Vector &vecEnd, float flDist, edict_t *pTargetEnt, Vector *pApex )
+{
+	return CMBaseMonster::FTriangulate( vecStart, vecEnd, flDist, pTargetEnt, pApex );
+}
+
+
+Activity CMFlyingMonster :: GetStoppedActivity( void )
+{ 
+	if ( pev->movetype != MOVETYPE_FLY )		// UNDONE: Ground idle here, IDLE may be something else
+		return ACT_IDLE;
+
+	return ACT_HOVER; 
+}
+
+
+void CMFlyingMonster :: Stop( void ) 
+{ 
+	Activity stopped = GetStoppedActivity();
+	if ( m_IdealActivity != stopped )
+	{
+		m_flightSpeed = 0;
+		m_IdealActivity = stopped;
+	}
+	pev->angles.z = 0;
+	pev->angles.x = 0;
+	m_vecTravel = g_vecZero;
+}
+
+
+float CMFlyingMonster :: ChangeYaw( int speed )
+{
+	if ( pev->movetype == MOVETYPE_FLY )
+	{
+		float diff = FlYawDiff();
+		float target = 0;
+
+		if ( m_IdealActivity != GetStoppedActivity() )
+		{
+			if ( diff < -20 )
+				target = 90;
+			else if ( diff > 20 )
+				target = -90;
+		}
+		pev->angles.z = UTIL_Approach( target, pev->angles.z, 220.0 * gpGlobals->frametime );
+	}
+	return CMBaseMonster::ChangeYaw( speed );
+}
+
+
+void CMFlyingMonster :: Killed( entvars_t *pevAttacker, int iGib )
+{
+	pev->movetype = MOVETYPE_STEP;
+	ClearBits( pev->flags, FL_ONGROUND );
+	pev->angles.z = 0;
+	pev->angles.x = 0;
+	CMBaseMonster::Killed( pevAttacker, iGib );
+}
+
+
+void CMFlyingMonster :: HandleAnimEvent( MonsterEvent_t *pEvent )
+{
+	switch( pEvent->event )
+	{
+	case FLYING_AE_FLAP:
+		m_flightSpeed = 400;
+		break;
+
+	case FLYING_AE_FLAPSOUND:
+		if ( m_pFlapSound )
+			EMIT_SOUND( edict(), CHAN_BODY, m_pFlapSound, 1, ATTN_NORM );	
+		break;
+
+	default:
+		CMBaseMonster::HandleAnimEvent( pEvent );
+		break;
+	}
+}
+
+
+void CMFlyingMonster :: Move( float flInterval )
+{
+	if ( pev->movetype == MOVETYPE_FLY )
+		m_flGroundSpeed = m_flightSpeed;
+	CMBaseMonster::Move( flInterval );
+}
+
+
+BOOL CMFlyingMonster:: ShouldAdvanceRoute( float flWaypointDist )
+{
+	// Get true 3D distance to the goal so we actually reach the correct height
+	if ( m_Route[ m_iRouteIndex ].iType & bits_MF_IS_GOAL )
+		flWaypointDist = ( m_Route[ m_iRouteIndex ].vecLocation - pev->origin ).Length();
+
+	if ( flWaypointDist <= 64 + (m_flGroundSpeed * gpGlobals->frametime) )
+		return TRUE;
+
+	return FALSE;
+}
+
+
+void CMFlyingMonster::MoveExecute( edict_t *pTargetEnt, const Vector &vecDir, float flInterval )
+{
+	if ( pev->movetype == MOVETYPE_FLY )
+	{
+		if ( gpGlobals->time - m_stopTime > 1.0 )
+		{
+			if ( m_IdealActivity != m_movementActivity )
+			{
+				m_IdealActivity = m_movementActivity;
+				m_flGroundSpeed = m_flightSpeed = 200;
+			}
+		}
+		Vector vecMove = pev->origin + (( vecDir + (m_vecTravel * m_momentum) ).Normalize() * (m_flGroundSpeed * flInterval));
+
+		if ( m_IdealActivity != m_movementActivity )
+		{
+			m_flightSpeed = UTIL_Approach( 100, m_flightSpeed, 75 * gpGlobals->frametime );
+			if ( m_flightSpeed < 100 )
+				m_stopTime = gpGlobals->time;
+		}
+		else
+			m_flightSpeed = UTIL_Approach( 20, m_flightSpeed, 300 * gpGlobals->frametime );
+		
+		if ( CheckLocalMove ( pev->origin, vecMove, pTargetEnt, NULL ) )
+		{
+			m_vecTravel = (vecMove - pev->origin);
+			m_vecTravel = m_vecTravel.Normalize();
+			UTIL_MoveToOrigin(ENT(pev), vecMove, (m_flGroundSpeed * flInterval), MOVE_STRAFE);
+		}
+		else
+		{
+			m_IdealActivity = GetStoppedActivity();
+			m_stopTime = gpGlobals->time;
+			m_vecTravel = g_vecZero;
+		}
+	}
+	else
+		CMBaseMonster::MoveExecute( pTargetEnt, vecDir, flInterval );
+}
+
+
+float CMFlyingMonster::CeilingZ( const Vector &position )
+{
+	TraceResult tr;
+
+	Vector minUp = position;
+	Vector maxUp = position;
+	maxUp.z += 4096.0;
+
+	UTIL_TraceLine(position, maxUp, ignore_monsters, NULL, &tr);
+	if (tr.flFraction != 1.0)
+		maxUp.z = tr.vecEndPos.z;
+
+	if ((pev->flags) & FL_SWIM)
+	{
+		return UTIL_WaterLevel( position, minUp.z, maxUp.z );
+	}
+	return maxUp.z;
+}
+
+BOOL CMFlyingMonster::ProbeZ( const Vector &position, const Vector &probe, float *pFraction)
+{
+	int conPosition = UTIL_PointContents(position);
+	if ( (((pev->flags) & FL_SWIM) == FL_SWIM) ^ (conPosition == CONTENTS_WATER))
+	{
+		//    SWIMING & !WATER
+		// or FLYING  & WATER
+		//
+		*pFraction = 0.0;
+		return TRUE; // We hit a water boundary because we are where we don't belong.
+	}
+	int conProbe = UTIL_PointContents(probe);
+	if (conProbe == conPosition)
+	{
+		// The probe is either entirely inside the water (for fish) or entirely
+		// outside the water (for birds).
+		//
+		*pFraction = 1.0;
+		return FALSE;
+	}
+
+	Vector ProbeUnit = (probe-position).Normalize();
+	float ProbeLength = (probe-position).Length();
+	float maxProbeLength = ProbeLength;
+	float minProbeLength = 0;
+
+	float diff = maxProbeLength - minProbeLength;
+	while (diff > 1.0)
+	{
+		float midProbeLength = minProbeLength + diff/2.0;
+		Vector midProbeVec = midProbeLength * ProbeUnit;
+		if (UTIL_PointContents(position+midProbeVec) == conPosition)
+		{
+			minProbeLength = midProbeLength;
+		}
+		else
+		{
+			maxProbeLength = midProbeLength;
+		}
+		diff = maxProbeLength - minProbeLength;
+	}
+	*pFraction = minProbeLength/ProbeLength;
+
+	return TRUE;
+}
+
+float CMFlyingMonster::FloorZ( const Vector &position )
+{
+	TraceResult tr;
+
+	Vector down = position;
+	down.z -= 2048;
+
+	UTIL_TraceLine( position, down, ignore_monsters, NULL, &tr );
+
+	if ( tr.flFraction != 1.0 )
+		return tr.vecEndPos.z;
+
+	return down.z;
+}
+

src/dlls/func_break.h

@@ -0,0 +1,70 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef FUNC_BREAK_H
+#define FUNC_BREAK_H
+
+typedef enum { expRandom, expDirected} Explosions;
+typedef enum { matGlass = 0, matWood, matMetal, matFlesh, matCinderBlock, matCeilingTile, matComputer, matUnbreakableGlass, matRocks, matNone, matLastMaterial } Materials;
+
+#define	NUM_SHARDS 6 // this many shards spawned when breakable objects break;
+
+class CMBreakable : public CMBaseDelay
+{
+public:
+	// basic functions
+	void Spawn( void );
+	void Precache( void );
+	void KeyValue( KeyValueData* pkvd);
+	void EXPORT BreakTouch( CMBaseEntity *pOther );
+	void Use( CMBaseEntity *pActivator, CMBaseEntity *pCaller, USE_TYPE useType, float value );
+	void DamageSound( void );
+
+	// breakables use an overridden takedamage
+	virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
+	// To spark when hit
+	void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
+
+	BOOL IsBreakable( void );
+	BOOL SparkWhenHit( void );
+
+	int	 DamageDecal( int bitsDamageType );
+
+	void EXPORT		Die( void );
+	virtual int		ObjectCaps( void ) { return (CMBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
+
+	inline BOOL		Explodable( void ) { return ExplosionMagnitude() > 0; }
+	inline int		ExplosionMagnitude( void ) { return pev->impulse; }
+	inline void		ExplosionSetMagnitude( int magnitude ) { pev->impulse = magnitude; }
+
+	static void MaterialSoundPrecache( Materials precacheMaterial );
+	static void MaterialSoundRandom( edict_t *pEdict, Materials soundMaterial, float volume );
+	static const char **MaterialSoundList( Materials precacheMaterial, int &soundCount );
+
+	static const char *pSoundsWood[];
+	static const char *pSoundsFlesh[];
+	static const char *pSoundsGlass[];
+	static const char *pSoundsMetal[];
+	static const char *pSoundsConcrete[];
+	static const char *pSpawnObjects[];
+
+	Materials	m_Material;
+	Explosions	m_Explosion;
+	int			m_idShard;
+	float		m_angle;
+	int			m_iszGibModel;
+	int			m_iszSpawnObject;
+};
+
+#endif	// FUNC_BREAK_H

src/dlls/ggrenade.cpp

@@ -0,0 +1,466 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/*
+
+===== generic grenade.cpp ========================================================
+
+*/
+
+#include "extdll.h"
+#include "util.h"
+#include "cmbase.h"
+#include "cmbasemonster.h"
+#include "monsters.h"
+#include "weapons.h"
+#include "nodes.h"
+#include "decals.h"
+#include "explode.h"
+
+
+//===================grenade
+
+// Grenades flagged with this will be triggered when the owner calls detonateSatchelCharges
+#define SF_DETONATE		0x0001
+
+//
+// Grenade Explode
+//
+void CMGrenade::Explode( Vector vecSrc, Vector vecAim )
+{
+	TraceResult tr;
+	UTIL_TraceLine ( pev->origin, pev->origin + Vector ( 0, 0, -32 ),  ignore_monsters, ENT(pev), & tr);
+
+	Explode( &tr, DMG_BLAST );
+}
+
+// UNDONE: temporary scorching for PreAlpha - find a less sleazy permenant solution.
+void CMGrenade::Explode( TraceResult *pTrace, int bitsDamageType )
+{
+	float		flRndSound;// sound randomizer
+
+	pev->model = iStringNull;//invisible
+	pev->solid = SOLID_NOT;// intangible
+
+	pev->takedamage = DAMAGE_NO;
+
+	// Pull out of the wall a bit
+	if ( pTrace->flFraction != 1.0 )
+	{
+		pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24) * 0.6);
+	}
+
+	int iContents = UTIL_PointContents ( pev->origin );
+	
+	MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, pev->origin );
+		WRITE_BYTE( TE_EXPLOSION );		// This makes a dynamic light and the explosion sprites/sound
+		WRITE_COORD( pev->origin.x );	// Send to PAS because of the sound
+		WRITE_COORD( pev->origin.y );
+		WRITE_COORD( pev->origin.z );
+		if (iContents != CONTENTS_WATER)
+		{
+			WRITE_SHORT( g_sModelIndexFireball );
+		}
+		else
+		{
+			WRITE_SHORT( g_sModelIndexWExplosion );
+		}
+		WRITE_BYTE( (pev->dmg - 50) * .60  ); // scale * 10
+		WRITE_BYTE( 15  ); // framerate
+		WRITE_BYTE( TE_EXPLFLAG_NONE );
+	MESSAGE_END();
+
+	entvars_t *pevOwner;
+	if ( pev->owner )
+		pevOwner = VARS( pev->owner );
+	else
+		pevOwner = NULL;
+
+	pev->owner = NULL; // can't traceline attack owner if this is set
+
+	RadiusDamage ( pev, pevOwner, pev->dmg, CLASS_NONE, bitsDamageType );
+
+	if ( RANDOM_FLOAT( 0 , 1 ) < 0.5 )
+	{
+		UTIL_DecalTrace( pTrace, DECAL_SCORCH1 );
+	}
+	else
+	{
+		UTIL_DecalTrace( pTrace, DECAL_SCORCH2 );
+	}
+
+	flRndSound = RANDOM_FLOAT( 0 , 1 );
+
+	switch ( RANDOM_LONG( 0, 2 ) )
+	{
+		case 0:	EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris1.wav", 0.55, ATTN_NORM);	break;
+		case 1:	EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris2.wav", 0.55, ATTN_NORM);	break;
+		case 2:	EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris3.wav", 0.55, ATTN_NORM);	break;
+	}
+
+	pev->effects |= EF_NODRAW;
+	SetThink( Smoke );
+	pev->velocity = g_vecZero;
+	pev->nextthink = gpGlobals->time + 0.3;
+
+/*jlb
+	if (iContents != CONTENTS_WATER)
+	{
+		int sparkCount = RANDOM_LONG(0,3);
+		for ( int i = 0; i < sparkCount; i++ )
+			Create( "spark_shower", pev->origin, pTrace->vecPlaneNormal, NULL );
+	}
+jlb*/
+}
+
+
+void CMGrenade::Smoke( void )
+{
+	if (UTIL_PointContents ( pev->origin ) == CONTENTS_WATER)
+	{
+		UTIL_Bubbles( pev->origin - Vector( 64, 64, 64 ), pev->origin + Vector( 64, 64, 64 ), 100 );
+	}
+	else
+	{
+		MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
+			WRITE_BYTE( TE_SMOKE );
+			WRITE_COORD( pev->origin.x );
+			WRITE_COORD( pev->origin.y );
+			WRITE_COORD( pev->origin.z );
+			WRITE_SHORT( g_sModelIndexSmoke );
+			WRITE_BYTE( (pev->dmg - 50) * 0.80 ); // scale * 10
+			WRITE_BYTE( 12  ); // framerate
+		MESSAGE_END();
+	}
+	UTIL_Remove( this->edict() );
+}
+
+void CMGrenade::Killed( entvars_t *pevAttacker, int iGib )
+{
+	Detonate( );
+}
+
+
+// Timed grenade, this think is called when time runs out.
+void CMGrenade::DetonateUse( edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value )
+{
+	SetThink( Detonate );
+	pev->nextthink = gpGlobals->time;
+}
+
+void CMGrenade::PreDetonate( void )
+{
+	SetThink( Detonate );
+	pev->nextthink = gpGlobals->time + 1;
+}
+
+
+void CMGrenade::Detonate( void )
+{
+	TraceResult tr;
+	Vector		vecSpot;// trace starts here!
+
+	vecSpot = pev->origin + Vector ( 0 , 0 , 8 );
+	UTIL_TraceLine ( vecSpot, vecSpot + Vector ( 0, 0, -40 ),  ignore_monsters, ENT(pev), & tr);
+
+	Explode( &tr, DMG_BLAST );
+}
+
+
+//
+// Contact grenade, explode when it touches something
+// 
+void CMGrenade::ExplodeTouch( edict_t *pOther )
+{
+	TraceResult tr;
+	Vector		vecSpot;// trace starts here!
+
+	pev->enemy = pOther;
+
+	vecSpot = pev->origin - pev->velocity.Normalize() * 32;
+	UTIL_TraceLine( vecSpot, vecSpot + pev->velocity.Normalize() * 64, ignore_monsters, ENT(pev), &tr );
+
+	Explode( &tr, DMG_BLAST );
+}
+
+
+void CMGrenade::DangerSoundThink( void )
+{
+	if (!IsInWorld())
+	{
+		UTIL_Remove( this->edict() );
+		return;
+	}
+
+	pev->nextthink = gpGlobals->time + 0.2;
+
+	if (pev->waterlevel != 0)
+	{
+		pev->velocity = pev->velocity * 0.5;
+	}
+}
+
+
+void CMGrenade::BounceTouch( edict_t *pOther )
+{
+	// don't hit the guy that launched this grenade
+	if ( pOther == pev->owner )
+		return;
+
+	// only do damage if we're moving fairly fast
+	if (m_flNextAttack < gpGlobals->time && pev->velocity.Length() > 100)
+	{
+		entvars_t *pevOwner = VARS( pev->owner );
+		if (pevOwner)
+		{
+			TraceResult tr = UTIL_GetGlobalTrace( );
+			ClearMultiDamage( );
+
+         if (UTIL_IsPlayer(pOther))
+				UTIL_TraceAttack(pOther, pevOwner, 1, gpGlobals->v_forward, &tr, DMG_CLUB ); 
+         else if (pOther->v.euser4 != NULL)
+         {
+				CMBaseMonster *pMonster = GetClassPtr((CMBaseMonster *)VARS(pOther));
+				pMonster->TraceAttack(pevOwner, 1, gpGlobals->v_forward, &tr, DMG_CLUB ); 
+         }
+
+			ApplyMultiDamage( pev, pevOwner);
+		}
+		m_flNextAttack = gpGlobals->time + 1.0; // debounce
+	}
+
+	Vector vecTestVelocity;
+	// pev->avelocity = Vector (300, 300, 300);
+
+	// this is my heuristic for modulating the grenade velocity because grenades dropped purely vertical
+	// or thrown very far tend to slow down too quickly for me to always catch just by testing velocity. 
+	// trimming the Z velocity a bit seems to help quite a bit.
+	vecTestVelocity = pev->velocity; 
+	vecTestVelocity.z *= 0.45;
+
+	if ( !m_fRegisteredSound && vecTestVelocity.Length() <= 60 )
+	{
+		//ALERT( at_console, "Grenade Registered!: %f\n", vecTestVelocity.Length() );
+
+		// grenade is moving really slow. It's probably very close to where it will ultimately stop moving. 
+		// go ahead and emit the danger sound.
+		
+		// register a radius louder than the explosion, so we make sure everyone gets out of the way
+		m_fRegisteredSound = TRUE;
+	}
+
+	if (pev->flags & FL_ONGROUND)
+	{
+		// add a bit of static friction
+		pev->velocity = pev->velocity * 0.8;
+
+		pev->sequence = RANDOM_LONG( 1, 1 );
+	}
+	else
+	{
+		// play bounce sound
+		BounceSound();
+	}
+	pev->framerate = pev->velocity.Length() / 200.0;
+	if (pev->framerate > 1.0)
+		pev->framerate = 1;
+	else if (pev->framerate < 0.5)
+		pev->framerate = 0;
+
+}
+
+
+
+void CMGrenade::SlideTouch( edict_t *pOther )
+{
+	// don't hit the guy that launched this grenade
+	if ( pOther == pev->owner )
+		return;
+
+	// pev->avelocity = Vector (300, 300, 300);
+
+	if (pev->flags & FL_ONGROUND)
+	{
+		// add a bit of static friction
+		pev->velocity = pev->velocity * 0.95;
+
+		if (pev->velocity.x != 0 || pev->velocity.y != 0)
+		{
+			// maintain sliding sound
+		}
+	}
+	else
+	{
+		BounceSound();
+	}
+}
+
+void CMGrenade :: BounceSound( void )
+{
+	switch ( RANDOM_LONG( 0, 2 ) )
+	{
+	case 0:	EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/grenade_hit1.wav", 0.25, ATTN_NORM);	break;
+	case 1:	EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/grenade_hit2.wav", 0.25, ATTN_NORM);	break;
+	case 2:	EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/grenade_hit3.wav", 0.25, ATTN_NORM);	break;
+	}
+}
+
+void CMGrenade :: TumbleThink( void )
+{
+	if (!IsInWorld())
+	{
+		UTIL_Remove( this->edict() );
+		return;
+	}
+
+	StudioFrameAdvance( );
+	pev->nextthink = gpGlobals->time + 0.1;
+
+	if (pev->dmgtime <= gpGlobals->time)
+	{
+		SetThink( Detonate );
+	}
+	if (pev->waterlevel != 0)
+	{
+		pev->velocity = pev->velocity * 0.5;
+		pev->framerate = 0.2;
+	}
+}
+
+
+void CMGrenade:: Spawn( void )
+{
+	pev->movetype = MOVETYPE_BOUNCE;
+	pev->classname = MAKE_STRING( "grenade" );
+	
+	pev->solid = SOLID_BBOX;
+
+	SET_MODEL(ENT(pev), "models/grenade.mdl");
+	UTIL_SetSize(pev, Vector( 0, 0, 0), Vector(0, 0, 0));
+
+	pev->dmg = 100;
+	m_fRegisteredSound = FALSE;
+}
+
+
+CMGrenade *CMGrenade::ShootContact( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity )
+{
+	CMGrenade *pGrenade = CreateClassPtr( (CMGrenade *)NULL );
+
+   if (pGrenade == NULL)  // no free monster edicts left?
+      return NULL;
+
+	pGrenade->Spawn();
+	// contact grenades arc lower
+	pGrenade->pev->gravity = 0.5;// lower gravity since grenade is aerodynamic and engine doesn't know it.
+	UTIL_SetOrigin( pGrenade->pev, vecStart );
+	pGrenade->pev->velocity = vecVelocity;
+	pGrenade->pev->angles = UTIL_VecToAngles (pGrenade->pev->velocity);
+	pGrenade->pev->owner = ENT(pevOwner);
+	
+	// make monsters afaid of it while in the air
+	pGrenade->SetThink( DangerSoundThink );
+	pGrenade->pev->nextthink = gpGlobals->time;
+	
+	// Tumble in air
+	pGrenade->pev->avelocity.x = RANDOM_FLOAT ( -100, -500 );
+	
+	// Explode on contact
+	pGrenade->SetTouch( ExplodeTouch );
+
+	pGrenade->pev->dmg = gSkillData.monDmgM203Grenade;
+
+	return pGrenade;
+}
+
+
+CMGrenade * CMGrenade:: ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time )
+{
+	CMGrenade *pGrenade = CreateClassPtr( (CMGrenade *)NULL );
+
+   if (pGrenade == NULL)  // no free monster edicts left?
+      return NULL;
+
+	pGrenade->Spawn();
+	UTIL_SetOrigin( pGrenade->pev, vecStart );
+	pGrenade->pev->velocity = vecVelocity;
+	pGrenade->pev->angles = UTIL_VecToAngles(pGrenade->pev->velocity);
+	pGrenade->pev->owner = ENT(pevOwner);
+	
+	pGrenade->SetTouch( BounceTouch );	// Bounce if touched
+	
+	// Take one second off of the desired detonation time and set the think to PreDetonate. PreDetonate
+	// will insert a DANGER sound into the world sound list and delay detonation for one second so that 
+	// the grenade explodes after the exact amount of time specified in the call to ShootTimed(). 
+
+	pGrenade->pev->dmgtime = gpGlobals->time + time;
+	pGrenade->SetThink( TumbleThink );
+	pGrenade->pev->nextthink = gpGlobals->time + 0.1;
+	if (time < 0.1)
+	{
+		pGrenade->pev->nextthink = gpGlobals->time;
+		pGrenade->pev->velocity = Vector( 0, 0, 0 );
+	}
+		
+	pGrenade->pev->sequence = RANDOM_LONG( 3, 6 );
+	pGrenade->pev->framerate = 1.0;
+
+	// Tumble through the air
+	// pGrenade->pev->avelocity.x = -400;
+
+	pGrenade->pev->gravity = 0.5;
+	pGrenade->pev->friction = 0.8;
+
+	SET_MODEL(ENT(pGrenade->pev), "models/w_grenade.mdl");
+	pGrenade->pev->dmg = 100;
+
+	return pGrenade;
+}
+
+
+CMGrenade * CMGrenade :: ShootSatchelCharge( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity )
+{
+	CMGrenade *pGrenade = CreateClassPtr( (CMGrenade *)NULL );
+
+   if (pGrenade == NULL)  // no free monster edicts left?
+      return NULL;
+
+	pGrenade->pev->movetype = MOVETYPE_BOUNCE;
+	pGrenade->pev->classname = MAKE_STRING( "grenade" );
+	
+	pGrenade->pev->solid = SOLID_BBOX;
+
+	SET_MODEL(ENT(pGrenade->pev), "models/grenade.mdl");	// Change this to satchel charge model
+
+	UTIL_SetSize(pGrenade->pev, Vector( 0, 0, 0), Vector(0, 0, 0));
+
+	pGrenade->pev->dmg = 200;
+	UTIL_SetOrigin( pGrenade->pev, vecStart );
+	pGrenade->pev->velocity = vecVelocity;
+	pGrenade->pev->angles = g_vecZero;
+	pGrenade->pev->owner = ENT(pevOwner);
+	
+	// Detonate in "time" seconds
+	pGrenade->SetThink( SUB_DoNothing );
+	pGrenade->SetUse( DetonateUse );
+	pGrenade->SetTouch( SlideTouch );
+	pGrenade->pev->spawnflags = SF_DETONATE;
+
+	pGrenade->pev->friction = 0.9;
+
+	return pGrenade;
+}
+
+//======================end grenade
+

src/dlls/h_ai.cpp

@@ -0,0 +1,199 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/*
+
+  h_ai.cpp - halflife specific ai code
+
+*/
+
+
+#include	"extdll.h"
+#include	"util.h"
+#include	"cmbase.h"
+#include "cmbasemonster.h"
+#include	"monsters.h"
+	
+#define		NUM_LATERAL_CHECKS		13  // how many checks are made on each side of a monster looking for lateral cover
+#define		NUM_LATERAL_LOS_CHECKS		6  // how many checks are made on each side of a monster looking for lateral cover
+
+//float flRandom = RANDOM_FLOAT(0,1);
+
+DLL_GLOBAL	BOOL	g_fDrawLines = FALSE;
+
+//=========================================================
+// 
+// AI UTILITY FUNCTIONS
+//
+// !!!UNDONE - move CBaseMonster functions to monsters.cpp
+//=========================================================
+
+//=========================================================
+// FBoxVisible - a more accurate ( and slower ) version
+// of FVisible. 
+//
+// !!!UNDONE - make this CBaseMonster?
+//=========================================================
+BOOL FBoxVisible ( entvars_t *pevLooker, entvars_t *pevTarget, Vector &vecTargetOrigin, float flSize )
+{
+	// don't look through water
+	if ((pevLooker->waterlevel != 3 && pevTarget->waterlevel == 3) 
+		|| (pevLooker->waterlevel == 3 && pevTarget->waterlevel == 0))
+		return FALSE;
+
+	TraceResult tr;
+	Vector	vecLookerOrigin = pevLooker->origin + pevLooker->view_ofs;//look through the monster's 'eyes'
+	for (int i = 0; i < 5; i++)
+	{
+		Vector vecTarget = pevTarget->origin;
+		vecTarget.x += RANDOM_FLOAT( pevTarget->mins.x + flSize, pevTarget->maxs.x - flSize);
+		vecTarget.y += RANDOM_FLOAT( pevTarget->mins.y + flSize, pevTarget->maxs.y - flSize);
+		vecTarget.z += RANDOM_FLOAT( pevTarget->mins.z + flSize, pevTarget->maxs.z - flSize);
+
+		UTIL_TraceLine(vecLookerOrigin, vecTarget, ignore_monsters, ignore_glass, ENT(pevLooker)/*pentIgnore*/, &tr);
+		
+		if (tr.flFraction == 1.0)
+		{
+			vecTargetOrigin = vecTarget;
+			return TRUE;// line of sight is valid.
+		}
+	}
+	return FALSE;// Line of sight is not established
+}
+
+//
+// VecCheckToss - returns the velocity at which an object should be lobbed from vecspot1 to land near vecspot2.
+// returns g_vecZero if toss is not feasible.
+// 
+Vector VecCheckToss ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flGravityAdj )
+{
+	TraceResult		tr;
+	Vector			vecMidPoint;// halfway point between Spot1 and Spot2
+	Vector			vecApex;// highest point 
+	Vector			vecScale;
+	Vector			vecGrenadeVel;
+	Vector			vecTemp;
+	float			flGravity = g_psv_gravity->value * flGravityAdj;
+
+	if (vecSpot2.z - vecSpot1.z > 500)
+	{
+		// to high, fail
+		return g_vecZero;
+	}
+
+	UTIL_MakeVectors (pev->angles);
+
+	// toss a little bit to the left or right, not right down on the enemy's bean (head). 
+	vecSpot2 = vecSpot2 + gpGlobals->v_right * ( RANDOM_FLOAT(-8,8) + RANDOM_FLOAT(-16,16) );
+	vecSpot2 = vecSpot2 + gpGlobals->v_forward * ( RANDOM_FLOAT(-8,8) + RANDOM_FLOAT(-16,16) );
+	
+	// calculate the midpoint and apex of the 'triangle'
+	// UNDONE: normalize any Z position differences between spot1 and spot2 so that triangle is always RIGHT
+
+	// How much time does it take to get there?
+
+	// get a rough idea of how high it can be thrown
+	vecMidPoint = vecSpot1 + (vecSpot2 - vecSpot1) * 0.5;
+	UTIL_TraceLine(vecMidPoint, vecMidPoint + Vector(0,0,500), ignore_monsters, ENT(pev), &tr);
+	vecMidPoint = tr.vecEndPos;
+	// (subtract 15 so the grenade doesn't hit the ceiling)
+	vecMidPoint.z -= 15;
+
+	if (vecMidPoint.z < vecSpot1.z || vecMidPoint.z < vecSpot2.z)
+	{
+		// to not enough space, fail
+		return g_vecZero;
+	}
+
+	// How high should the grenade travel to reach the apex
+	float distance1 = (vecMidPoint.z - vecSpot1.z);
+	float distance2 = (vecMidPoint.z - vecSpot2.z);
+
+	// How long will it take for the grenade to travel this distance
+	float time1 = sqrt( distance1 / (0.5 * flGravity) );
+	float time2 = sqrt( distance2 / (0.5 * flGravity) );
+
+	if (time1 < 0.1)
+	{
+		// too close
+		return g_vecZero;
+	}
+
+	// how hard to throw sideways to get there in time.
+	vecGrenadeVel = (vecSpot2 - vecSpot1) / (time1 + time2);
+	// how hard upwards to reach the apex at the right time.
+	vecGrenadeVel.z = flGravity * time1;
+
+	// find the apex
+	vecApex  = vecSpot1 + vecGrenadeVel * time1;
+	vecApex.z = vecMidPoint.z;
+
+	UTIL_TraceLine(vecSpot1, vecApex, dont_ignore_monsters, ENT(pev), &tr);
+	if (tr.flFraction != 1.0)
+	{
+		// fail!
+		return g_vecZero;
+	}
+
+	// UNDONE: either ignore monsters or change it to not care if we hit our enemy
+	UTIL_TraceLine(vecSpot2, vecApex, ignore_monsters, ENT(pev), &tr); 
+	if (tr.flFraction != 1.0)
+	{
+		// fail!
+		return g_vecZero;
+	}
+	
+	return vecGrenadeVel;
+}
+
+
+//
+// VecCheckThrow - returns the velocity vector at which an object should be thrown from vecspot1 to hit vecspot2.
+// returns g_vecZero if throw is not feasible.
+// 
+Vector VecCheckThrow ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flSpeed, float flGravityAdj )
+{
+	float			flGravity = g_psv_gravity->value * flGravityAdj;
+
+	Vector vecGrenadeVel = (vecSpot2 - vecSpot1);
+
+	// throw at a constant time
+	float time = vecGrenadeVel.Length( ) / flSpeed;
+	vecGrenadeVel = vecGrenadeVel * (1.0 / time);
+
+	// adjust upward toss to compensate for gravity loss
+	vecGrenadeVel.z += flGravity * time * 0.5;
+
+	Vector vecApex = vecSpot1 + (vecSpot2 - vecSpot1) * 0.5;
+	vecApex.z += 0.5 * flGravity * (time * 0.5) * (time * 0.5);
+	
+	TraceResult tr;
+	UTIL_TraceLine(vecSpot1, vecApex, dont_ignore_monsters, ENT(pev), &tr);
+	if (tr.flFraction != 1.0)
+	{
+		// fail!
+		return g_vecZero;
+	}
+
+	UTIL_TraceLine(vecSpot2, vecApex, ignore_monsters, ENT(pev), &tr);
+	if (tr.flFraction != 1.0)
+	{
+		// fail!
+		return g_vecZero;
+	}
+
+	return vecGrenadeVel;
+}
+
+

src/dlls/h_export.cpp

@@ -0,0 +1,46 @@
+//
+// botman's monster - MetaMOD plugin
+//
+// h_export.cpp
+//
+
+/***
+*
+*   Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*   
+*   This product contains software technology licensed from Id 
+*   Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*   All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/*
+
+===== h_export.cpp ========================================================
+
+  Entity classes exported by Halflife.
+
+*/
+
+#include "extdll.h"
+#include "h_export.h"
+
+// From SDK dlls/h_export.cpp:
+
+//! Holds engine functionality callbacks
+enginefuncs_t g_engfuncs;
+globalvars_t  *gpGlobals;
+
+// Receive engine function table from engine.
+// This appears to be the _first_ DLL routine called by the engine, so we
+// do some setup operations here.
+void WINAPI GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals )
+{
+   memcpy(&g_engfuncs, pengfuncsFromEngine, sizeof(enginefuncs_t));
+   gpGlobals = pGlobals;
+}
+

src/dlls/hassassin.cpp

@@ -0,0 +1,909 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
+
+//=========================================================
+// hassassin - Human assassin, fast and stealthy
+//=========================================================
+
+#include	"extdll.h"
+#include	"util.h"
+#include	"cmbase.h"
+#include "cmbasemonster.h"
+#include	"monsters.h"
+#include	"schedule.h"
+#include	"weapons.h"
+
+//=========================================================
+// monster-specific schedule types
+//=========================================================
+enum
+{
+	SCHED_ASSASSIN_EXPOSED = LAST_COMMON_SCHEDULE + 1,// cover was blown.
+	SCHED_ASSASSIN_JUMP,	// fly through the air
+	SCHED_ASSASSIN_JUMP_ATTACK,	// fly through the air and shoot
+	SCHED_ASSASSIN_JUMP_LAND, // hit and run away
+};
+
+//=========================================================
+// monster-specific tasks
+//=========================================================
+
+enum
+{
+	TASK_ASSASSIN_FALL_TO_GROUND = LAST_COMMON_TASK + 1, // falling and waiting to hit ground
+};
+
+
+//=========================================================
+// Monster's Anim Events Go Here
+//=========================================================
+#define		ASSASSIN_AE_SHOOT1	1
+#define		ASSASSIN_AE_TOSS1	2
+#define		ASSASSIN_AE_JUMP	3
+
+
+#define bits_MEMORY_BADJUMP		(bits_MEMORY_CUSTOM1)
+
+
+//=========================================================
+// DieSound
+//=========================================================
+void CMHAssassin :: DeathSound ( void )
+{
+}
+
+//=========================================================
+// IdleSound
+//=========================================================
+void CMHAssassin :: IdleSound ( void )
+{
+}
+
+//=========================================================
+// ISoundMask - returns a bit mask indicating which types
+// of sounds this monster regards. 
+//=========================================================
+int CMHAssassin :: ISoundMask ( void) 
+{
+	return 0;
+}
+
+
+//=========================================================
+// Classify - indicates this monster's place in the 
+// relationship table.
+//=========================================================
+int	CMHAssassin :: Classify ( void )
+{
+	return	CLASS_HUMAN_MILITARY;
+}
+
+//=========================================================
+// SetYawSpeed - allows each sequence to have a different
+// turn rate associated with it.
+//=========================================================
+void CMHAssassin :: SetYawSpeed ( void )
+{
+	int ys;
+
+	switch ( m_Activity )
+	{
+	case ACT_TURN_LEFT:
+	case ACT_TURN_RIGHT:
+		ys = 360;
+		break;
+	default:			
+		ys = 360;
+		break;
+	}
+
+	pev->yaw_speed = ys;
+}
+
+
+//=========================================================
+// Shoot
+//=========================================================
+void CMHAssassin :: Shoot ( void )
+{
+	if (m_hEnemy == NULL)
+	{
+		return;
+	}
+
+	Vector vecShootOrigin = GetGunPosition();
+	Vector vecShootDir = ShootAtEnemy( vecShootOrigin );
+
+	if (m_flLastShot + 2 < gpGlobals->time)
+	{
+		m_flDiviation = 0.10;
+	}
+	else
+	{
+		m_flDiviation -= 0.01;
+		if (m_flDiviation < 0.02)
+			m_flDiviation = 0.02;
+	}
+	m_flLastShot = gpGlobals->time;
+
+	UTIL_MakeVectors ( pev->angles );
+
+	Vector	vecShellVelocity = gpGlobals->v_right * RANDOM_FLOAT(40,90) + gpGlobals->v_up * RANDOM_FLOAT(75,200) + gpGlobals->v_forward * RANDOM_FLOAT(-40, 40);
+	EjectBrass ( pev->origin + gpGlobals->v_up * 32 + gpGlobals->v_forward * 12, vecShellVelocity, pev->angles.y, m_iShell, TE_BOUNCE_SHELL); 
+	FireBullets(1, vecShootOrigin, vecShootDir, Vector( m_flDiviation, m_flDiviation, m_flDiviation ), 2048, BULLET_MONSTER_9MM ); // shoot +-8 degrees
+
+	switch(RANDOM_LONG(0,1))
+	{
+	case 0:
+		EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/pl_gun1.wav", RANDOM_FLOAT(0.6, 0.8), ATTN_NORM);
+		break;
+	case 1:
+		EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/pl_gun2.wav", RANDOM_FLOAT(0.6, 0.8), ATTN_NORM);
+		break;
+	}
+
+	pev->effects |= EF_MUZZLEFLASH;
+
+	Vector angDir = UTIL_VecToAngles( vecShootDir );
+	SetBlending( 0, angDir.x );
+
+	m_cAmmoLoaded--;
+}
+
+
+//=========================================================
+// HandleAnimEvent - catches the monster-specific messages
+// that occur when tagged animation frames are played.
+//
+// Returns number of events handled, 0 if none.
+//=========================================================
+void CMHAssassin :: HandleAnimEvent( MonsterEvent_t *pEvent )
+{
+	switch( pEvent->event )
+	{
+	case ASSASSIN_AE_SHOOT1:
+		Shoot( );
+		break;
+	case ASSASSIN_AE_TOSS1:
+		{
+			UTIL_MakeVectors( pev->angles );
+			CMGrenade::ShootTimed( pev, pev->origin + gpGlobals->v_forward * 34 + Vector (0, 0, 32), m_vecTossVelocity, 2.0 );
+
+			m_flNextGrenadeCheck = gpGlobals->time + 6;// wait six seconds before even looking again to see if a grenade can be thrown.
+			m_fThrowGrenade = FALSE;
+			// !!!LATER - when in a group, only try to throw grenade if ordered.
+		}
+		break;
+	case ASSASSIN_AE_JUMP:
+		{
+			// ALERT( at_console, "jumping");
+			UTIL_MakeAimVectors( pev->angles );
+			pev->movetype = MOVETYPE_TOSS;
+			pev->flags &= ~FL_ONGROUND;
+			pev->velocity = m_vecJumpVelocity;
+			m_flNextJump = gpGlobals->time + 3.0;
+		}
+		return;
+	default:
+		CMBaseMonster::HandleAnimEvent( pEvent );
+		break;
+	}
+}
+
+//=========================================================
+// Spawn
+//=========================================================
+void CMHAssassin :: Spawn()
+{
+	Precache( );
+
+	SET_MODEL(ENT(pev), "models/hassassin.mdl");
+	UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);
+
+	pev->solid			= SOLID_SLIDEBOX;
+	pev->movetype		= MOVETYPE_STEP;
+	m_bloodColor		= BLOOD_COLOR_RED;
+	pev->effects		= 0;
+	pev->health			= gSkillData.hassassinHealth;
+	m_flFieldOfView		= VIEW_FIELD_WIDE; // indicates the width of this monster's forward view cone ( as a dotproduct result )
+	m_MonsterState		= MONSTERSTATE_NONE;
+	m_afCapability		= bits_CAP_MELEE_ATTACK1 | bits_CAP_DOORS_GROUP;
+	pev->friction		= 1;
+
+	m_HackedGunPos		= Vector( 0, 24, 48 );
+
+	m_iTargetRanderamt	= 20;
+	pev->renderamt		= 20;
+	pev->rendermode		= kRenderTransTexture;
+
+	MonsterInit();
+}
+
+//=========================================================
+// Precache - precaches all resources this monster needs
+//=========================================================
+void CMHAssassin :: Precache()
+{
+	PRECACHE_MODEL("models/hassassin.mdl");
+
+	PRECACHE_SOUND("weapons/pl_gun1.wav");
+	PRECACHE_SOUND("weapons/pl_gun2.wav");
+
+	PRECACHE_SOUND("debris/beamstart1.wav");
+
+	m_iShell = PRECACHE_MODEL ("models/shell.mdl");// brass shell
+}	
+	
+
+
+//=========================================================
+// AI Schedules Specific to this monster
+//=========================================================
+
+//=========================================================
+// Fail Schedule
+//=========================================================
+Task_t	tlAssassinFail[] =
+{
+	{ TASK_STOP_MOVING,			0				},
+	{ TASK_SET_ACTIVITY,		(float)ACT_IDLE },
+	{ TASK_WAIT_FACE_ENEMY,		(float)2		},
+	// { TASK_WAIT_PVS,			(float)0		},
+	{ TASK_SET_SCHEDULE,		(float)SCHED_CHASE_ENEMY },
+};
+
+Schedule_t	slAssassinFail[] =
+{
+	{
+		tlAssassinFail,
+		ARRAYSIZE ( tlAssassinFail ),
+		bits_COND_LIGHT_DAMAGE		|
+		bits_COND_HEAVY_DAMAGE		|
+		bits_COND_PROVOKED			|
+		bits_COND_CAN_RANGE_ATTACK1 |
+		bits_COND_CAN_RANGE_ATTACK2 |
+		bits_COND_CAN_MELEE_ATTACK1 |
+		bits_COND_HEAR_SOUND,
+      0,
+		"AssassinFail"
+	},
+};
+
+
+//=========================================================
+// Enemy exposed Agrunt's cover
+//=========================================================
+Task_t	tlAssassinExposed[] =
+{
+	{ TASK_STOP_MOVING,			(float)0							},
+	{ TASK_RANGE_ATTACK1,		(float)0							},
+	{ TASK_SET_FAIL_SCHEDULE,	(float)SCHED_ASSASSIN_JUMP			},
+	{ TASK_SET_SCHEDULE,		(float)SCHED_TAKE_COVER_FROM_ENEMY	},
+};
+
+Schedule_t slAssassinExposed[] =
+{
+	{
+		tlAssassinExposed,
+		ARRAYSIZE ( tlAssassinExposed ),
+		bits_COND_CAN_MELEE_ATTACK1,
+		0,
+		"AssassinExposed",
+	},
+};
+
+
+//=========================================================
+// Take cover from enemy! Tries lateral cover before node 
+// cover! 
+//=========================================================
+Task_t	tlAssassinTakeCoverFromEnemy[] =
+{
+	{ TASK_STOP_MOVING,				(float)0					},
+	{ TASK_WAIT,					(float)0.2					},
+	{ TASK_SET_FAIL_SCHEDULE,		(float)SCHED_RANGE_ATTACK1	},
+	{ TASK_FIND_COVER_FROM_ENEMY,	(float)0					},
+	{ TASK_RUN_PATH,				(float)0					},
+	{ TASK_WAIT_FOR_MOVEMENT,		(float)0					},
+	{ TASK_REMEMBER,				(float)bits_MEMORY_INCOVER	},
+	{ TASK_FACE_ENEMY,				(float)0					},
+};
+
+Schedule_t	slAssassinTakeCoverFromEnemy[] =
+{
+	{ 
+		tlAssassinTakeCoverFromEnemy,
+		ARRAYSIZE ( tlAssassinTakeCoverFromEnemy ), 
+		bits_COND_NEW_ENEMY |
+		bits_COND_CAN_MELEE_ATTACK1		|
+		bits_COND_HEAR_SOUND,
+		0,
+		"AssassinTakeCoverFromEnemy"
+	},
+};
+
+
+//=========================================================
+// Take cover from enemy! Tries lateral cover before node 
+// cover! 
+//=========================================================
+Task_t	tlAssassinTakeCoverFromEnemy2[] =
+{
+	{ TASK_STOP_MOVING,				(float)0					},
+	{ TASK_WAIT,					(float)0.2					},
+	{ TASK_FACE_ENEMY,				(float)0					},
+	{ TASK_RANGE_ATTACK1,			(float)0					},
+	{ TASK_SET_FAIL_SCHEDULE,		(float)SCHED_RANGE_ATTACK2	},
+	{ TASK_FIND_FAR_NODE_COVER_FROM_ENEMY,	(float)384			},
+	{ TASK_RUN_PATH,				(float)0					},
+	{ TASK_WAIT_FOR_MOVEMENT,		(float)0					},
+	{ TASK_REMEMBER,				(float)bits_MEMORY_INCOVER	},
+	{ TASK_FACE_ENEMY,				(float)0					},
+};
+
+Schedule_t	slAssassinTakeCoverFromEnemy2[] =
+{
+	{ 
+		tlAssassinTakeCoverFromEnemy2,
+		ARRAYSIZE ( tlAssassinTakeCoverFromEnemy2 ), 
+		bits_COND_NEW_ENEMY |
+		bits_COND_CAN_MELEE_ATTACK2		|
+		bits_COND_HEAR_SOUND,
+		0,
+		"AssassinTakeCoverFromEnemy2"
+	},
+};
+
+
+//=========================================================
+// hide from the loudest sound source
+//=========================================================
+Task_t	tlAssassinTakeCoverFromBestSound[] =
+{
+	{ TASK_SET_FAIL_SCHEDULE,			(float)SCHED_MELEE_ATTACK1	},
+	{ TASK_STOP_MOVING,					(float)0					},
+	{ TASK_FIND_COVER_FROM_BEST_SOUND,	(float)0					},
+	{ TASK_RUN_PATH,					(float)0					},
+	{ TASK_WAIT_FOR_MOVEMENT,			(float)0					},
+	{ TASK_REMEMBER,					(float)bits_MEMORY_INCOVER	},
+	{ TASK_TURN_LEFT,					(float)179					},
+};
+
+Schedule_t	slAssassinTakeCoverFromBestSound[] =
+{
+	{ 
+		tlAssassinTakeCoverFromBestSound,
+		ARRAYSIZE ( tlAssassinTakeCoverFromBestSound ), 
+		bits_COND_NEW_ENEMY,
+		0,
+		"AssassinTakeCoverFromBestSound"
+	},
+};
+
+
+
+
+
+//=========================================================
+// AlertIdle Schedules
+//=========================================================
+Task_t	tlAssassinHide[] =
+{
+	{ TASK_STOP_MOVING,			0						 },
+	{ TASK_SET_ACTIVITY,		(float)ACT_IDLE			 },
+	{ TASK_WAIT,				(float)2				 },
+	{ TASK_SET_SCHEDULE,		(float)SCHED_CHASE_ENEMY },
+};
+
+Schedule_t	slAssassinHide[] =
+{
+	{ 
+		tlAssassinHide,
+		ARRAYSIZE ( tlAssassinHide ), 
+		bits_COND_NEW_ENEMY				|
+		bits_COND_SEE_ENEMY				|
+		bits_COND_SEE_FEAR				|
+		bits_COND_LIGHT_DAMAGE			|
+		bits_COND_HEAVY_DAMAGE			|
+		bits_COND_PROVOKED		|
+		bits_COND_HEAR_SOUND,
+		0,
+		"AssassinHide"
+	},
+};
+
+
+
+//=========================================================
+// HUNT Schedules
+//=========================================================
+Task_t tlAssassinHunt[] = 
+{
+	{ TASK_GET_PATH_TO_ENEMY,	(float)0		},
+	{ TASK_RUN_PATH,			(float)0		},
+	{ TASK_WAIT_FOR_MOVEMENT,	(float)0		},
+};
+
+Schedule_t slAssassinHunt[] =
+{
+	{ 
+		tlAssassinHunt,
+		ARRAYSIZE ( tlAssassinHunt ),
+		bits_COND_NEW_ENEMY			|
+		// bits_COND_SEE_ENEMY			|
+		bits_COND_CAN_RANGE_ATTACK1	|
+		bits_COND_HEAR_SOUND,
+		0,
+		"AssassinHunt"
+	},
+};
+
+
+//=========================================================
+// Jumping Schedules
+//=========================================================
+Task_t	tlAssassinJump[] =
+{
+	{ TASK_STOP_MOVING,			(float)0		},
+	{ TASK_PLAY_SEQUENCE,		(float)ACT_HOP	},
+	{ TASK_SET_SCHEDULE,		(float)SCHED_ASSASSIN_JUMP_ATTACK },
+};
+
+Schedule_t	slAssassinJump[] =
+{
+	{ 
+		tlAssassinJump,
+		ARRAYSIZE ( tlAssassinJump ), 
+		0, 
+		0, 
+		"AssassinJump"
+	},
+};
+
+
+//=========================================================
+// repel 
+//=========================================================
+Task_t	tlAssassinJumpAttack[] =
+{
+	{ TASK_SET_FAIL_SCHEDULE,	(float)SCHED_ASSASSIN_JUMP_LAND	},
+	// { TASK_SET_ACTIVITY,		(float)ACT_FLY	},
+	{ TASK_ASSASSIN_FALL_TO_GROUND, (float)0		},
+};
+
+
+Schedule_t	slAssassinJumpAttack[] =
+{
+	{ 
+		tlAssassinJumpAttack,
+		ARRAYSIZE ( tlAssassinJumpAttack ), 
+		0, 
+		0,
+		"AssassinJumpAttack"
+	},
+};
+
+
+//=========================================================
+// repel 
+//=========================================================
+Task_t	tlAssassinJumpLand[] =
+{
+	{ TASK_SET_FAIL_SCHEDULE,		(float)SCHED_ASSASSIN_EXPOSED	},
+	// { TASK_SET_FAIL_SCHEDULE,		(float)SCHED_MELEE_ATTACK1	},
+	{ TASK_SET_ACTIVITY,			(float)ACT_IDLE				},
+	{ TASK_REMEMBER,				(float)bits_MEMORY_BADJUMP	},
+	{ TASK_FIND_NODE_COVER_FROM_ENEMY,	(float)0					},
+	{ TASK_RUN_PATH,				(float)0					},
+	{ TASK_FORGET,					(float)bits_MEMORY_BADJUMP	},
+	{ TASK_WAIT_FOR_MOVEMENT,		(float)0					},
+	{ TASK_REMEMBER,				(float)bits_MEMORY_INCOVER	},
+	{ TASK_FACE_ENEMY,				(float)0					},
+	{ TASK_SET_FAIL_SCHEDULE,		(float)SCHED_RANGE_ATTACK1	},
+};
+
+Schedule_t	slAssassinJumpLand[] =
+{
+	{ 
+		tlAssassinJumpLand,
+		ARRAYSIZE ( tlAssassinJumpLand ), 
+		0, 
+		0,
+		"AssassinJumpLand"
+	},
+};
+
+DEFINE_CUSTOM_SCHEDULES( CMHAssassin )
+{
+	slAssassinFail,
+	slAssassinExposed,
+	slAssassinTakeCoverFromEnemy,
+	slAssassinTakeCoverFromEnemy2,
+	slAssassinTakeCoverFromBestSound,
+	slAssassinHide,
+	slAssassinHunt,
+	slAssassinJump,
+	slAssassinJumpAttack,
+	slAssassinJumpLand,
+};
+
+IMPLEMENT_CUSTOM_SCHEDULES( CMHAssassin, CMBaseMonster );
+
+
+//=========================================================
+// CheckMeleeAttack1 - jump like crazy if the enemy gets too close. 
+//=========================================================
+BOOL CMHAssassin :: CheckMeleeAttack1 ( float flDot, float flDist )
+{
+	if ( m_flNextJump < gpGlobals->time && (flDist <= 128 || HasMemory( bits_MEMORY_BADJUMP )) && m_hEnemy != NULL )
+	{
+		TraceResult	tr;
+
+		Vector vecDest = pev->origin + Vector( RANDOM_FLOAT( -64, 64), RANDOM_FLOAT( -64, 64 ), 160 );
+
+		UTIL_TraceHull( pev->origin + Vector( 0, 0, 36 ), vecDest + Vector( 0, 0, 36 ), dont_ignore_monsters, human_hull, ENT(pev), &tr);
+
+		if ( tr.fStartSolid || tr.flFraction < 1.0)
+		{
+			return FALSE;
+		}
+
+		float flGravity = g_psv_gravity->value;
+
+		float time = sqrt( 160 / (0.5 * flGravity));
+		float speed = flGravity * time / 160;
+		m_vecJumpVelocity = (vecDest - pev->origin) * speed;
+
+		return TRUE;
+	}
+	return FALSE;
+}
+
+//=========================================================
+// CheckRangeAttack1  - drop a cap in their ass
+//
+//=========================================================
+BOOL CMHAssassin :: CheckRangeAttack1 ( float flDot, float flDist )
+{
+	if ( !HasConditions( bits_COND_ENEMY_OCCLUDED ) && flDist > 64 && flDist <= 2048 /* && flDot >= 0.5 */ /* && NoFriendlyFire() */ )
+	{
+		TraceResult	tr;
+
+		Vector vecSrc = GetGunPosition();
+
+		// verify that a bullet fired from the gun will hit the enemy before the world.
+		UTIL_TraceLine( vecSrc, UTIL_BodyTarget(m_hEnemy, vecSrc), dont_ignore_monsters, ENT(pev), &tr);
+
+		if ( tr.flFraction == 1 || tr.pHit == m_hEnemy )
+		{
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+//=========================================================
+// CheckRangeAttack2 - toss grenade is enemy gets in the way and is too close. 
+//=========================================================
+BOOL CMHAssassin :: CheckRangeAttack2 ( float flDot, float flDist )
+{
+	m_fThrowGrenade = FALSE;
+	if ( !FBitSet ( m_hEnemy->v.flags, FL_ONGROUND ) )
+	{
+		// don't throw grenades at anything that isn't on the ground!
+		return FALSE;
+	}
+
+	// don't get grenade happy unless the player starts to piss you off
+	if ( m_iFrustration <= 2)
+		return FALSE;
+
+	if ( m_flNextGrenadeCheck < gpGlobals->time && !HasConditions( bits_COND_ENEMY_OCCLUDED ) && flDist <= 512 /* && flDot >= 0.5 */ /* && NoFriendlyFire() */ )
+	{
+		Vector vecToss = VecCheckThrow( pev, GetGunPosition( ), UTIL_BodyTarget(m_hEnemy, g_vecZero), flDist, 0.5 ); // use dist as speed to get there in 1 second
+
+		if ( vecToss != g_vecZero )
+		{
+			m_vecTossVelocity = vecToss;
+
+			// throw a hand grenade
+			m_fThrowGrenade = TRUE;
+
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+
+//=========================================================
+// RunAI
+//=========================================================
+void CMHAssassin :: RunAI( void )
+{
+	CMBaseMonster :: RunAI();
+
+	// always visible if moving
+	// always visible is not on hard
+	if (m_hEnemy == NULL || pev->deadflag != DEAD_NO || m_Activity == ACT_RUN || m_Activity == ACT_WALK || !(pev->flags & FL_ONGROUND))
+		m_iTargetRanderamt = 255;
+
+	if (pev->renderamt > m_iTargetRanderamt)
+	{
+		if (pev->renderamt == 255)
+		{
+			EMIT_SOUND (ENT(pev), CHAN_BODY, "debris/beamstart1.wav", 0.2, ATTN_NORM );
+		}
+
+		pev->renderamt = max( pev->renderamt - 50, m_iTargetRanderamt );
+		pev->rendermode = kRenderTransTexture;
+	}
+	else if (pev->renderamt < m_iTargetRanderamt)
+	{
+		pev->renderamt = min( pev->renderamt + 50, m_iTargetRanderamt );
+		if (pev->renderamt == 255)
+			pev->rendermode = kRenderNormal;
+	}
+
+	if (m_Activity == ACT_RUN || m_Activity == ACT_WALK)
+	{
+		static int iStep = 0;
+		iStep = ! iStep;
+		if (iStep)
+		{
+			switch( RANDOM_LONG( 0, 3 ) )
+			{
+			case 0:	EMIT_SOUND( ENT(pev), CHAN_BODY, "player/pl_step1.wav", 0.5, ATTN_NORM);	break;
+			case 1:	EMIT_SOUND( ENT(pev), CHAN_BODY, "player/pl_step3.wav", 0.5, ATTN_NORM);	break;
+			case 2:	EMIT_SOUND( ENT(pev), CHAN_BODY, "player/pl_step2.wav", 0.5, ATTN_NORM);	break;
+			case 3:	EMIT_SOUND( ENT(pev), CHAN_BODY, "player/pl_step4.wav", 0.5, ATTN_NORM);	break;
+			}
+		}
+	}
+}
+
+
+//=========================================================
+// StartTask
+//=========================================================
+void CMHAssassin :: StartTask ( Task_t *pTask )
+{
+	switch ( pTask->iTask )
+	{
+	case TASK_RANGE_ATTACK2:
+		if (!m_fThrowGrenade)
+		{
+			TaskComplete( );
+		}
+		else
+		{
+			CMBaseMonster :: StartTask ( pTask );
+		}
+		break;
+	case TASK_ASSASSIN_FALL_TO_GROUND:
+		break;
+	default:
+		CMBaseMonster :: StartTask ( pTask );
+		break;
+	}
+}
+
+
+//=========================================================
+// RunTask 
+//=========================================================
+void CMHAssassin :: RunTask ( Task_t *pTask )
+{
+	switch ( pTask->iTask )
+	{
+	case TASK_ASSASSIN_FALL_TO_GROUND:
+		MakeIdealYaw( m_vecEnemyLKP );
+		ChangeYaw( pev->yaw_speed );
+
+		if (m_fSequenceFinished)
+		{
+			if (pev->velocity.z > 0)
+			{
+				pev->sequence = LookupSequence( "fly_up" );
+			}
+			else if (HasConditions ( bits_COND_SEE_ENEMY ))
+			{
+				pev->sequence = LookupSequence( "fly_attack" );
+				pev->frame = 0;
+			}
+			else
+			{
+				pev->sequence = LookupSequence( "fly_down" );
+				pev->frame = 0;
+			}
+			
+			ResetSequenceInfo( );
+			SetYawSpeed();
+		}
+		if (pev->flags & FL_ONGROUND)
+		{
+			// ALERT( at_console, "on ground\n");
+			TaskComplete( );
+		}
+		break;
+	default: 
+		CMBaseMonster :: RunTask ( pTask );
+		break;
+	}
+}
+
+//=========================================================
+// GetSchedule - Decides which type of schedule best suits
+// the monster's current state and conditions. Then calls
+// monster's member function to get a pointer to a schedule
+// of the proper type.
+//=========================================================
+Schedule_t *CMHAssassin :: GetSchedule ( void )
+{
+	switch	( m_MonsterState )
+	{
+	case MONSTERSTATE_IDLE:
+	case MONSTERSTATE_ALERT:
+		{
+		}
+		break;
+
+	case MONSTERSTATE_COMBAT:
+		{
+// dead enemy
+			if ( HasConditions( bits_COND_ENEMY_DEAD ) )
+			{
+				// call base class, all code to handle dead enemies is centralized there.
+				return CMBaseMonster :: GetSchedule();
+			}
+
+			// flying?
+			if ( pev->movetype == MOVETYPE_TOSS)
+			{
+				if (pev->flags & FL_ONGROUND)
+				{
+					// ALERT( at_console, "landed\n");
+					// just landed
+					pev->movetype = MOVETYPE_STEP;
+					return GetScheduleOfType ( SCHED_ASSASSIN_JUMP_LAND );
+				}
+				else
+				{
+					// ALERT( at_console, "jump\n");
+					// jump or jump/shoot
+					if ( m_MonsterState == MONSTERSTATE_COMBAT )
+						return GetScheduleOfType ( SCHED_ASSASSIN_JUMP );
+					else
+						return GetScheduleOfType ( SCHED_ASSASSIN_JUMP_ATTACK );
+				}
+			}
+
+			if ( HasConditions ( bits_COND_LIGHT_DAMAGE ) )
+			{
+				m_iFrustration++;
+			}
+			if ( HasConditions ( bits_COND_HEAVY_DAMAGE ) )
+			{
+				m_iFrustration++;
+			}
+
+		// jump player!
+			if ( HasConditions ( bits_COND_CAN_MELEE_ATTACK1 ) )
+			{
+				// ALERT( at_console, "melee attack 1\n");
+				return GetScheduleOfType ( SCHED_MELEE_ATTACK1 );
+			}
+
+		// throw grenade
+			if ( HasConditions ( bits_COND_CAN_RANGE_ATTACK2 ) )
+			{
+				// ALERT( at_console, "range attack 2\n");
+				return GetScheduleOfType ( SCHED_RANGE_ATTACK2 );
+			}
+
+		// spotted
+			if ( HasConditions ( bits_COND_SEE_ENEMY ) && HasConditions ( bits_COND_ENEMY_FACING_ME ) )
+			{
+				// ALERT( at_console, "exposed\n");
+				m_iFrustration++;
+				return GetScheduleOfType ( SCHED_ASSASSIN_EXPOSED );
+			}
+
+		// can attack
+			if ( HasConditions ( bits_COND_CAN_RANGE_ATTACK1 ) )
+			{
+				// ALERT( at_console, "range attack 1\n");
+				m_iFrustration = 0;
+				return GetScheduleOfType ( SCHED_RANGE_ATTACK1 );
+			}
+
+			if ( HasConditions ( bits_COND_SEE_ENEMY ) )
+			{
+				// ALERT( at_console, "face\n");
+				return GetScheduleOfType ( SCHED_COMBAT_FACE );
+			}
+
+		// new enemy
+			if ( HasConditions ( bits_COND_NEW_ENEMY ) )
+			{
+				// ALERT( at_console, "take cover\n");
+				return GetScheduleOfType ( SCHED_TAKE_COVER_FROM_ENEMY );
+			}
+
+			// ALERT( at_console, "stand\n");
+			return GetScheduleOfType ( SCHED_ALERT_STAND );
+		}
+		break;
+	}
+
+	return CMBaseMonster :: GetSchedule();
+}
+
+//=========================================================
+//=========================================================
+Schedule_t* CMHAssassin :: GetScheduleOfType ( int Type ) 
+{
+	// ALERT( at_console, "%d\n", m_iFrustration );
+	switch	( Type )
+	{
+	case SCHED_TAKE_COVER_FROM_ENEMY:
+		if (pev->health > 30)
+			return slAssassinTakeCoverFromEnemy;
+		else
+			return slAssassinTakeCoverFromEnemy2;
+	case SCHED_TAKE_COVER_FROM_BEST_SOUND:
+		return slAssassinTakeCoverFromBestSound;
+	case SCHED_ASSASSIN_EXPOSED:
+		return slAssassinExposed;
+	case SCHED_FAIL:
+		if (m_MonsterState == MONSTERSTATE_COMBAT)
+			return slAssassinFail;
+		break;
+	case SCHED_ALERT_STAND:
+		if (m_MonsterState == MONSTERSTATE_COMBAT)
+			return slAssassinHide;
+		break;
+	case SCHED_CHASE_ENEMY:
+		return slAssassinHunt;
+	case SCHED_MELEE_ATTACK1:
+		if (pev->flags & FL_ONGROUND)
+		{
+			if (m_flNextJump > gpGlobals->time)
+			{
+				// can't jump yet, go ahead and fail
+				return slAssassinFail;
+			}
+			else
+			{
+				return slAssassinJump;
+			}
+		}
+		else
+		{
+			return slAssassinJumpAttack;
+		}
+	case SCHED_ASSASSIN_JUMP:
+	case SCHED_ASSASSIN_JUMP_ATTACK:
+		return slAssassinJumpAttack;
+	case SCHED_ASSASSIN_JUMP_LAND:
+		return slAssassinJumpLand;
+	}
+
+	return CMBaseMonster :: GetScheduleOfType( Type );
+}
+
+#endif

src/dlls/headcrab.cpp

@@ -0,0 +1,506 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+//=========================================================
+// headcrab.cpp - tiny, jumpy alien parasite
+//=========================================================
+
+#include	"extdll.h"
+#include	"util.h"
+#include	"cmbase.h"
+#include "cmbasemonster.h"
+#include	"monsters.h"
+#include	"schedule.h"
+
+//=========================================================
+// Monster's Anim Events Go Here
+//=========================================================
+#define		HC_AE_JUMPATTACK	( 2 )
+
+Task_t	tlHCRangeAttack1[] =
+{
+	{ TASK_STOP_MOVING,			(float)0		},
+	{ TASK_FACE_IDEAL,			(float)0		},
+	{ TASK_RANGE_ATTACK1,		(float)0		},
+	{ TASK_SET_ACTIVITY,		(float)ACT_IDLE	},
+	{ TASK_FACE_IDEAL,			(float)0		},
+	{ TASK_WAIT_RANDOM,			(float)0.5		},
+};
+
+Schedule_t	slHCRangeAttack1[] =
+{
+	{ 
+		tlHCRangeAttack1,
+		ARRAYSIZE ( tlHCRangeAttack1 ), 
+		bits_COND_ENEMY_OCCLUDED	|
+		bits_COND_NO_AMMO_LOADED,
+		0,
+		"HCRangeAttack1"
+	},
+};
+
+Task_t	tlHCRangeAttack1Fast[] =
+{
+	{ TASK_STOP_MOVING,			(float)0		},
+	{ TASK_FACE_IDEAL,			(float)0		},
+	{ TASK_RANGE_ATTACK1,		(float)0		},
+	{ TASK_SET_ACTIVITY,		(float)ACT_IDLE	},
+};
+
+Schedule_t	slHCRangeAttack1Fast[] =
+{
+	{ 
+		tlHCRangeAttack1Fast,
+		ARRAYSIZE ( tlHCRangeAttack1Fast ), 
+		bits_COND_ENEMY_OCCLUDED	|
+		bits_COND_NO_AMMO_LOADED,
+		0,
+		"HCRAFast"
+	},
+};
+
+
+DEFINE_CUSTOM_SCHEDULES( CMHeadCrab )
+{
+	slHCRangeAttack1,
+	slHCRangeAttack1Fast,
+};
+
+IMPLEMENT_CUSTOM_SCHEDULES( CMHeadCrab, CMBaseMonster );
+
+const char *CMHeadCrab::pIdleSounds[] = 
+{
+	"headcrab/hc_idle1.wav",
+	"headcrab/hc_idle2.wav",
+	"headcrab/hc_idle3.wav",
+};
+const char *CMHeadCrab::pAlertSounds[] = 
+{
+	"headcrab/hc_alert1.wav",
+};
+const char *CMHeadCrab::pPainSounds[] = 
+{
+	"headcrab/hc_pain1.wav",
+	"headcrab/hc_pain2.wav",
+	"headcrab/hc_pain3.wav",
+};
+const char *CMHeadCrab::pAttackSounds[] = 
+{
+	"headcrab/hc_attack1.wav",
+	"headcrab/hc_attack2.wav",
+	"headcrab/hc_attack3.wav",
+};
+
+const char *CMHeadCrab::pDeathSounds[] = 
+{
+	"headcrab/hc_die1.wav",
+	"headcrab/hc_die2.wav",
+};
+
+const char *CMHeadCrab::pBiteSounds[] = 
+{
+	"headcrab/hc_headbite.wav",
+};
+
+//=========================================================
+// Classify - indicates this monster's place in the 
+// relationship table.
+//=========================================================
+int	CMHeadCrab :: Classify ( void )
+{
+	return	CLASS_ALIEN_PREY;
+}
+
+//=========================================================
+// Center - returns the real center of the headcrab.  The 
+// bounding box is much larger than the actual creature so 
+// this is needed for targeting
+//=========================================================
+Vector CMHeadCrab :: Center ( void )
+{
+	return Vector( pev->origin.x, pev->origin.y, pev->origin.z + 6 );
+}
+
+
+Vector CMHeadCrab :: BodyTarget( const Vector &posSrc ) 
+{ 
+	return Center( );
+}
+
+//=========================================================
+// SetYawSpeed - allows each sequence to have a different
+// turn rate associated with it.
+//=========================================================
+void CMHeadCrab :: SetYawSpeed ( void )
+{
+	int ys;
+
+	switch ( m_Activity )
+	{
+	case ACT_IDLE:			
+		ys = 30;
+		break;
+	case ACT_RUN:			
+	case ACT_WALK:			
+		ys = 20;
+		break;
+	case ACT_TURN_LEFT:
+	case ACT_TURN_RIGHT:
+		ys = 60;
+		break;
+	case ACT_RANGE_ATTACK1:	
+		ys = 30;
+		break;
+	default:
+		ys = 30;
+		break;
+	}
+
+	pev->yaw_speed = ys;
+}
+
+//=========================================================
+// HandleAnimEvent - catches the monster-specific messages
+// that occur when tagged animation frames are played.
+//=========================================================
+void CMHeadCrab :: HandleAnimEvent( MonsterEvent_t *pEvent )
+{
+	switch( pEvent->event )
+	{
+		case HC_AE_JUMPATTACK:
+		{
+			ClearBits( pev->flags, FL_ONGROUND );
+
+			UTIL_SetOrigin (pev, pev->origin + Vector ( 0 , 0 , 1) );// take him off ground so engine doesn't instantly reset onground 
+			UTIL_MakeVectors ( pev->angles );
+
+			Vector vecJumpDir;
+			if (m_hEnemy != NULL)
+			{
+				float gravity = g_psv_gravity->value;
+				if (gravity <= 1)
+					gravity = 1;
+
+				// How fast does the headcrab need to travel to reach that height given gravity?
+				float height = (m_hEnemy->v.origin.z + m_hEnemy->v.view_ofs.z - pev->origin.z);
+				if (height < 16)
+					height = 16;
+				float speed = sqrt( 2 * gravity * height );
+				float time = speed / gravity;
+
+				// Scale the sideways velocity to get there at the right time
+				vecJumpDir = (m_hEnemy->v.origin + m_hEnemy->v.view_ofs - pev->origin);
+				vecJumpDir = vecJumpDir * ( 1.0 / time );
+
+				// Speed to offset gravity at the desired height
+				vecJumpDir.z = speed;
+
+				// Don't jump too far/fast
+				float distance = vecJumpDir.Length();
+				
+				if (distance > 650)
+				{
+					vecJumpDir = vecJumpDir * ( 650.0 / distance );
+				}
+			}
+			else
+			{
+				// jump hop, don't care where
+				vecJumpDir = Vector( gpGlobals->v_forward.x, gpGlobals->v_forward.y, gpGlobals->v_up.z ) * 350;
+			}
+
+			int iSound = RANDOM_LONG(0,2);
+			if ( iSound != 0 )
+				EMIT_SOUND_DYN( edict(), CHAN_VOICE, pAttackSounds[iSound], GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
+
+			pev->velocity = vecJumpDir;
+			m_flNextAttack = gpGlobals->time + 2;
+		}
+		break;
+
+		default:
+			CMBaseMonster::HandleAnimEvent( pEvent );
+			break;
+	}
+}
+
+//=========================================================
+// Spawn
+//=========================================================
+void CMHeadCrab :: Spawn()
+{
+	Precache( );
+
+	SET_MODEL(ENT(pev), "models/headcrab.mdl");
+	UTIL_SetSize(pev, Vector(-12, -12, 0), Vector(12, 12, 24));
+
+	pev->solid			= SOLID_SLIDEBOX;
+	pev->movetype		= MOVETYPE_STEP;
+	m_bloodColor		= BLOOD_COLOR_GREEN;
+	pev->effects		= 0;
+	pev->health			= gSkillData.headcrabHealth;
+	pev->view_ofs		= Vector ( 0, 0, 20 );// position of the eyes relative to monster's origin.
+	pev->yaw_speed		= 5;//!!! should we put this in the monster's changeanim function since turn rates may vary with state/anim?
+	m_flFieldOfView		= 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
+	m_MonsterState		= MONSTERSTATE_NONE;
+
+	MonsterInit();
+}
+
+//=========================================================
+// Precache - precaches all resources this monster needs
+//=========================================================
+void CMHeadCrab :: Precache()
+{
+	PRECACHE_SOUND_ARRAY(pIdleSounds);
+	PRECACHE_SOUND_ARRAY(pAlertSounds);
+	PRECACHE_SOUND_ARRAY(pPainSounds);
+	PRECACHE_SOUND_ARRAY(pAttackSounds);
+	PRECACHE_SOUND_ARRAY(pDeathSounds);
+	PRECACHE_SOUND_ARRAY(pBiteSounds);
+
+	PRECACHE_MODEL("models/headcrab.mdl");
+}	
+
+
+//=========================================================
+// RunTask 
+//=========================================================
+void CMHeadCrab :: RunTask ( Task_t *pTask )
+{
+	switch ( pTask->iTask )
+	{
+	case TASK_RANGE_ATTACK1:
+	case TASK_RANGE_ATTACK2:
+		{
+			if ( m_fSequenceFinished )
+			{
+				TaskComplete();
+				SetTouch( NULL );
+				m_IdealActivity = ACT_IDLE;
+			}
+			break;
+		}
+	default:
+		{
+			CMBaseMonster :: RunTask(pTask);
+		}
+	}
+}
+
+//=========================================================
+// LeapTouch - this is the headcrab's touch function when it
+// is in the air
+//=========================================================
+void CMHeadCrab :: LeapTouch ( edict_t *pOther )
+{
+	if ( !pOther->v.takedamage )
+	{
+		return;
+	}
+
+	// Don't hit if back on ground
+	if ( !FBitSet( pev->flags, FL_ONGROUND ) )
+	{
+		EMIT_SOUND_DYN( edict(), CHAN_WEAPON, RANDOM_SOUND_ARRAY(pBiteSounds), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
+
+		if (UTIL_IsPlayer(pOther))
+			UTIL_TakeDamage( pOther, pev, pev, GetDamageAmount(), DMG_SLASH );
+		else if (pOther->v.euser4 != NULL)
+		{
+			CMBaseMonster *pMonster = GetClassPtr((CMBaseMonster *)VARS(pOther));
+			pMonster->TakeDamage( pev, pev, GetDamageAmount(), DMG_SLASH );
+		}
+	}
+
+	SetTouch( NULL );
+}
+
+//=========================================================
+// PrescheduleThink
+//=========================================================
+void CMHeadCrab :: PrescheduleThink ( void )
+{
+	// make the crab coo a little bit in combat state
+	if ( m_MonsterState == MONSTERSTATE_COMBAT && RANDOM_FLOAT( 0, 5 ) < 0.1 )
+	{
+		IdleSound();
+	}
+}
+
+void CMHeadCrab :: StartTask ( Task_t *pTask )
+{
+	m_iTaskStatus = TASKSTATUS_RUNNING;
+
+	switch ( pTask->iTask )
+	{
+	case TASK_RANGE_ATTACK1:
+		{
+			EMIT_SOUND_DYN( edict(), CHAN_WEAPON, pAttackSounds[0], GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
+			m_IdealActivity = ACT_RANGE_ATTACK1;
+			SetTouch ( LeapTouch );
+			break;
+		}
+	default:
+		{
+			CMBaseMonster :: StartTask( pTask );
+		}
+	}
+}
+
+
+//=========================================================
+// CheckRangeAttack1
+//=========================================================
+BOOL CMHeadCrab :: CheckRangeAttack1 ( float flDot, float flDist )
+{
+	if ( FBitSet( pev->flags, FL_ONGROUND ) && flDist <= 256 && flDot >= 0.65 )
+	{
+		return TRUE;
+	}
+	return FALSE;
+}
+
+//=========================================================
+// CheckRangeAttack2
+//=========================================================
+BOOL CMHeadCrab :: CheckRangeAttack2 ( float flDot, float flDist )
+{
+	return FALSE;
+	// BUGBUG: Why is this code here?  There is no ACT_RANGE_ATTACK2 animation.  I've disabled it for now.
+#if 0
+	if ( FBitSet( pev->flags, FL_ONGROUND ) && flDist > 64 && flDist <= 256 && flDot >= 0.5 )
+	{
+		return TRUE;
+	}
+	return FALSE;
+#endif
+}
+
+int CMHeadCrab :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
+{
+	// Don't take any acid damage -- BigMomma's mortar is acid
+	if ( bitsDamageType & DMG_ACID )
+		flDamage = 0;
+
+	return CMBaseMonster::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
+}
+
+//=========================================================
+// IdleSound
+//=========================================================
+#define CRAB_ATTN_IDLE (float)1.5
+void CMHeadCrab :: IdleSound ( void )
+{
+	EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY(pIdleSounds), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
+}
+
+//=========================================================
+// AlertSound 
+//=========================================================
+void CMHeadCrab :: AlertSound ( void )
+{
+	EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY(pAlertSounds), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
+}
+
+//=========================================================
+// AlertSound 
+//=========================================================
+void CMHeadCrab :: PainSound ( void )
+{
+	EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY(pPainSounds), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
+}
+
+//=========================================================
+// DeathSound 
+//=========================================================
+void CMHeadCrab :: DeathSound ( void )
+{
+	EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY(pDeathSounds), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
+}
+
+Schedule_t* CMHeadCrab :: GetScheduleOfType ( int Type )
+{
+	switch	( Type )
+	{
+		case SCHED_RANGE_ATTACK1:
+		{
+			return &slHCRangeAttack1[ 0 ];
+		}
+		break;
+	}
+
+	return CMBaseMonster::GetScheduleOfType( Type );
+}
+
+
+
+void CMBabyCrab :: Spawn( void )
+{
+	CMHeadCrab::Spawn();
+	SET_MODEL(ENT(pev), "models/baby_headcrab.mdl");
+	pev->rendermode = kRenderTransTexture;
+	pev->renderamt = 192;
+	UTIL_SetSize(pev, Vector(-12, -12, 0), Vector(12, 12, 24));
+	
+	pev->health	= gSkillData.headcrabHealth * 0.25;	// less health than full grown
+}
+
+void CMBabyCrab :: Precache( void )
+{
+	PRECACHE_MODEL( "models/baby_headcrab.mdl" );
+	CMHeadCrab::Precache();
+}
+
+
+void CMBabyCrab :: SetYawSpeed ( void )
+{
+	pev->yaw_speed = 120;
+}
+
+
+BOOL CMBabyCrab :: CheckRangeAttack1( float flDot, float flDist )
+{
+	if ( pev->flags & FL_ONGROUND )
+	{
+		if ( pev->groundentity && (pev->groundentity->v.flags & (FL_CLIENT|FL_MONSTER)) )
+			return TRUE;
+
+		// A little less accurate, but jump from closer
+		if ( flDist <= 180 && flDot >= 0.55 )
+			return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+Schedule_t* CMBabyCrab :: GetScheduleOfType ( int Type )
+{
+	switch( Type )
+	{
+		case SCHED_FAIL:	// If you fail, try to jump!
+			if ( m_hEnemy != NULL )
+				return slHCRangeAttack1Fast;
+		break;
+
+		case SCHED_RANGE_ATTACK1:
+		{
+			return slHCRangeAttack1Fast;
+		}
+		break;
+	}
+
+	return CMHeadCrab::GetScheduleOfType( Type );
+}

src/dlls/hornet.cpp

@@ -0,0 +1,372 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//=========================================================
+// Hornets
+//=========================================================
+
+#include	"extdll.h"
+#include	"util.h"
+#include	"cmbase.h"
+#include "cmbasemonster.h"
+#include	"monsters.h"
+#include	"weapons.h"
+#include	"hornet.h"
+
+
+int iHornetTrail;
+int iHornetPuff;
+
+//=========================================================
+// don't let hornets gib, ever.
+//=========================================================
+int CMHornet :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
+{
+	// filter these bits a little.
+	bitsDamageType &= ~ ( DMG_ALWAYSGIB );
+	bitsDamageType |= DMG_NEVERGIB;
+
+	return CMBaseMonster :: TakeDamage ( pevInflictor, pevAttacker, flDamage, bitsDamageType );
+}
+
+//=========================================================
+//=========================================================
+void CMHornet :: Spawn( void )
+{
+	Precache();
+
+	pev->movetype	= MOVETYPE_FLY;
+	pev->solid		= SOLID_BBOX;
+	pev->takedamage = DAMAGE_YES;
+	pev->flags		|= FL_MONSTER;
+	pev->health		= 1;// weak!
+	
+	// hornets don't live as long in multiplayer
+	m_flStopAttack = gpGlobals->time + 3.5;
+
+	m_flFieldOfView = 0.9; // +- 25 degrees
+
+	if ( RANDOM_LONG ( 1, 5 ) <= 2 )
+	{
+		m_iHornetType = HORNET_TYPE_RED;
+		m_flFlySpeed = HORNET_RED_SPEED;
+	}
+	else
+	{
+		m_iHornetType = HORNET_TYPE_ORANGE;
+		m_flFlySpeed = HORNET_ORANGE_SPEED;
+	}
+
+	SET_MODEL(ENT( pev ), "models/hornet.mdl");
+	UTIL_SetSize( pev, Vector( -4, -4, -4 ), Vector( 4, 4, 4 ) );
+
+	SetTouch( DieTouch );
+	SetThink( StartTrack );
+
+	edict_t *pSoundEnt = pev->owner;
+	if ( !pSoundEnt )
+		pSoundEnt = edict();
+
+	// no real owner, or owner isn't a client. 
+	pev->dmg = gSkillData.monDmgHornet;
+	
+	pev->nextthink = gpGlobals->time + 0.1;
+	ResetSequenceInfo( );
+}
+
+
+void CMHornet :: Precache()
+{
+	PRECACHE_MODEL("models/hornet.mdl");
+
+	PRECACHE_SOUND( "agrunt/ag_fire1.wav" );
+	PRECACHE_SOUND( "agrunt/ag_fire2.wav" );
+	PRECACHE_SOUND( "agrunt/ag_fire3.wav" );
+
+	PRECACHE_SOUND( "hornet/ag_buzz1.wav" );
+	PRECACHE_SOUND( "hornet/ag_buzz2.wav" );
+	PRECACHE_SOUND( "hornet/ag_buzz3.wav" );
+
+	PRECACHE_SOUND( "hornet/ag_hornethit1.wav" );
+	PRECACHE_SOUND( "hornet/ag_hornethit2.wav" );
+	PRECACHE_SOUND( "hornet/ag_hornethit3.wav" );
+
+	iHornetPuff = PRECACHE_MODEL( "sprites/muz1.spr" );
+	iHornetTrail = PRECACHE_MODEL("sprites/laserbeam.spr");
+}	
+
+//=========================================================
+// hornets will never get mad at each other, no matter who the owner is.
+//=========================================================
+int CMHornet::IRelationship ( CMBaseEntity *pTarget )
+{
+	if ( pTarget->pev->modelindex == pev->modelindex )
+	{
+		return R_NO;
+	}
+
+	return CMBaseMonster :: IRelationship( pTarget );
+}
+
+//=========================================================
+// ID's Hornet as their owner
+//=========================================================
+int CMHornet::Classify ( void )
+{
+
+	if ( pev->owner && pev->owner->v.flags & FL_CLIENT)
+	{
+		return CLASS_PLAYER_BIOWEAPON;
+	}
+
+	return	CLASS_ALIEN_BIOWEAPON;
+}
+
+//=========================================================
+// StartTrack - starts a hornet out tracking its target
+//=========================================================
+void CMHornet :: StartTrack ( void )
+{
+	IgniteTrail();
+
+	SetTouch( TrackTouch );
+	SetThink( TrackTarget );
+
+	pev->nextthink = gpGlobals->time + 0.1;
+}
+
+//=========================================================
+// StartDart - starts a hornet out just flying straight.
+//=========================================================
+void CMHornet :: StartDart ( void )
+{
+	IgniteTrail();
+
+	SetTouch( DartTouch );
+
+	SetThink( SUB_Remove );
+	pev->nextthink = gpGlobals->time + 4;
+}
+
+void CMHornet::IgniteTrail( void )
+{
+/*
+
+  ted's suggested trail colors:
+
+r161
+g25
+b97
+
+r173
+g39
+b14
+
+old colors
+		case HORNET_TYPE_RED:
+			WRITE_BYTE( 255 );   // r, g, b
+			WRITE_BYTE( 128 );   // r, g, b
+			WRITE_BYTE( 0 );   // r, g, b
+			break;
+		case HORNET_TYPE_ORANGE:
+			WRITE_BYTE( 0   );   // r, g, b
+			WRITE_BYTE( 100 );   // r, g, b
+			WRITE_BYTE( 255 );   // r, g, b
+			break;
+	
+*/
+
+	// trail
+	MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
+		WRITE_BYTE(  TE_BEAMFOLLOW );
+		WRITE_SHORT( entindex() );	// entity
+		WRITE_SHORT( iHornetTrail );	// model
+		WRITE_BYTE( 10 ); // life
+		WRITE_BYTE( 2 );  // width
+		
+		switch ( m_iHornetType )
+		{
+		case HORNET_TYPE_RED:
+			WRITE_BYTE( 179 );   // r, g, b
+			WRITE_BYTE( 39 );   // r, g, b
+			WRITE_BYTE( 14 );   // r, g, b
+			break;
+		case HORNET_TYPE_ORANGE:
+			WRITE_BYTE( 255 );   // r, g, b
+			WRITE_BYTE( 128 );   // r, g, b
+			WRITE_BYTE( 0 );   // r, g, b
+			break;
+		}
+
+		WRITE_BYTE( 128 );	// brightness
+
+	MESSAGE_END();
+}
+
+//=========================================================
+// Hornet is flying, gently tracking target
+//=========================================================
+void CMHornet :: TrackTarget ( void )
+{
+	Vector	vecFlightDir;
+	Vector	vecDirToEnemy;
+	float	flDelta;
+
+	StudioFrameAdvance( );
+
+	if (gpGlobals->time > m_flStopAttack)
+	{
+		SetTouch( NULL );
+		SetThink( SUB_Remove );
+		pev->nextthink = gpGlobals->time + 0.1;
+		return;
+	}
+
+	// UNDONE: The player pointer should come back after returning from another level
+	if ( m_hEnemy == NULL )
+	{// enemy is dead.
+		Look( 512 );
+		m_hEnemy = BestVisibleEnemy( );
+	}
+	
+	if ( m_hEnemy != NULL && UTIL_FVisible( m_hEnemy, ENT(pev) ))
+	{
+		m_vecEnemyLKP = UTIL_BodyTarget( m_hEnemy, pev->origin );
+	}
+	else
+	{
+		m_vecEnemyLKP = m_vecEnemyLKP + pev->velocity * m_flFlySpeed * 0.1;
+	}
+
+	vecDirToEnemy = ( m_vecEnemyLKP - pev->origin ).Normalize();
+
+	if (pev->velocity.Length() < 0.1)
+		vecFlightDir = vecDirToEnemy;
+	else 
+		vecFlightDir = pev->velocity.Normalize();
+
+	// measure how far the turn is, the wider the turn, the slow we'll go this time.
+	flDelta = DotProduct ( vecFlightDir, vecDirToEnemy );
+	
+	if ( flDelta < 0.5 )
+	{// hafta turn wide again. play sound
+		switch (RANDOM_LONG(0,2))
+		{
+		case 0:	EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_buzz1.wav", HORNET_BUZZ_VOLUME, ATTN_NORM);	break;
+		case 1:	EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_buzz2.wav", HORNET_BUZZ_VOLUME, ATTN_NORM);	break;
+		case 2:	EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_buzz3.wav", HORNET_BUZZ_VOLUME, ATTN_NORM);	break;
+		}
+	}
+
+	if ( flDelta <= 0 && m_iHornetType == HORNET_TYPE_RED )
+	{// no flying backwards, but we don't want to invert this, cause we'd go fast when we have to turn REAL far.
+		flDelta = 0.25;
+	}
+
+	pev->velocity = ( vecFlightDir + vecDirToEnemy).Normalize();
+
+	if ( pev->owner && (pev->owner->v.flags & FL_MONSTER) )
+	{
+		// random pattern only applies to hornets fired by monsters, not players. 
+
+		pev->velocity.x += RANDOM_FLOAT ( -0.10, 0.10 );// scramble the flight dir a bit.
+		pev->velocity.y += RANDOM_FLOAT ( -0.10, 0.10 );
+		pev->velocity.z += RANDOM_FLOAT ( -0.10, 0.10 );
+	}
+	
+	switch ( m_iHornetType )
+	{
+		case HORNET_TYPE_RED:
+			pev->velocity = pev->velocity * ( m_flFlySpeed * flDelta );// scale the dir by the ( speed * width of turn )
+			pev->nextthink = gpGlobals->time + RANDOM_FLOAT( 0.1, 0.3 );
+			break;
+		case HORNET_TYPE_ORANGE:
+			pev->velocity = pev->velocity * m_flFlySpeed;// do not have to slow down to turn.
+			pev->nextthink = gpGlobals->time + 0.1;// fixed think time
+			break;
+	}
+
+	pev->angles = UTIL_VecToAngles (pev->velocity);
+
+	pev->solid = SOLID_BBOX;
+}
+
+//=========================================================
+// Tracking Hornet hit something
+//=========================================================
+void CMHornet :: TrackTouch ( edict_t *pOther )
+{
+	if ( (pOther == pev->owner) || pOther->v.modelindex == pev->modelindex )
+	{// bumped into the guy that shot it.
+		pev->solid = SOLID_NOT;
+		return;
+	}
+
+   // is this NOT a player and IS a monster?
+   if (!UTIL_IsPlayer(pOther) && (pOther->v.euser4 != NULL))
+   {
+		CMBaseMonster *pMonster = GetClassPtr((CMBaseMonster *)VARS(pOther));
+
+		if ( IRelationship( pMonster ) <= R_NO )
+		{
+			// hit something we don't want to hurt, so turn around.
+
+			pev->velocity = pev->velocity.Normalize();
+
+			pev->velocity.x *= -1;
+			pev->velocity.y *= -1;
+
+			pev->origin = pev->origin + pev->velocity * 4; // bounce the hornet off a bit.
+			pev->velocity = pev->velocity * m_flFlySpeed;
+
+			return;
+		}
+	}
+
+	DieTouch( pOther );
+}
+
+void CMHornet::DartTouch( edict_t *pOther )
+{
+	DieTouch( pOther );
+}
+
+void CMHornet::DieTouch ( edict_t *pOther )
+{
+	if ( pOther && pOther->v.takedamage )
+	{// do the damage
+
+		switch (RANDOM_LONG(0,2))
+		{// buzz when you plug someone
+			case 0:	EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_hornethit1.wav", 1, ATTN_NORM);	break;
+			case 1:	EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_hornethit2.wav", 1, ATTN_NORM);	break;
+			case 2:	EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_hornethit3.wav", 1, ATTN_NORM);	break;
+		}
+
+		if (UTIL_IsPlayer(pOther))
+			UTIL_TakeDamage( pOther, pev, VARS( pev->owner ), pev->dmg, DMG_BULLET );
+		else if (pOther->v.euser4 != NULL)
+		{
+			CMBaseMonster *pMonster = GetClassPtr((CMBaseMonster *)VARS(pOther));
+			pMonster->TakeDamage( pev, VARS( pev->owner ), pev->dmg, DMG_BULLET );
+		}
+	}
+
+	pev->modelindex = 0;// so will disappear for the 0.1 secs we wait until NEXTTHINK gets rid
+	pev->solid = SOLID_NOT;
+
+	SetThink ( SUB_Remove );
+	pev->nextthink = gpGlobals->time + 1;// stick around long enough for the sound to finish!
+}
+

src/dlls/hornet.h

@@ -0,0 +1,55 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//=========================================================
+// Hornets
+//=========================================================
+
+//=========================================================
+// Hornet Defines
+//=========================================================
+#define HORNET_TYPE_RED			0
+#define HORNET_TYPE_ORANGE		1
+#define HORNET_RED_SPEED		(float)600
+#define HORNET_ORANGE_SPEED		(float)800
+#define	HORNET_BUZZ_VOLUME		(float)0.8
+
+extern int iHornetPuff;
+
+//=========================================================
+// Hornet - this is the projectile that the Alien Grunt fires.
+//=========================================================
+class CMHornet : public CMBaseMonster
+{
+public:
+	void Spawn( void );
+	void Precache( void );
+	int  Classify ( void );
+	int  IRelationship ( CMBaseEntity *pTarget );
+
+	void IgniteTrail( void );
+	void EXPORT StartTrack ( void );
+	void EXPORT StartDart ( void );
+	void EXPORT TrackTarget ( void );
+	void EXPORT TrackTouch ( edict_t *pOther );
+	void EXPORT DartTouch( edict_t *pOther );
+	void EXPORT DieTouch ( edict_t *pOther );
+	
+	int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
+
+	float			m_flStopAttack;
+	int			m_iHornetType;
+	float			m_flFlySpeed;
+};
+

src/dlls/islave.cpp

@@ -0,0 +1,752 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+//=========================================================
+// Alien slave monster
+//=========================================================
+
+#include	"extdll.h"
+#include	"util.h"
+#include	"cmbase.h"
+#include "cmbasemonster.h"
+#include	"monsters.h"
+#include	"schedule.h"
+#include	"effects.h"
+#include	"weapons.h"
+
+
+//=========================================================
+// Monster's Anim Events Go Here
+//=========================================================
+#define		ISLAVE_AE_CLAW		( 1 )
+#define		ISLAVE_AE_CLAWRAKE	( 2 )
+#define		ISLAVE_AE_ZAP_POWERUP	( 3 )
+#define		ISLAVE_AE_ZAP_SHOOT		( 4 )
+#define		ISLAVE_AE_ZAP_DONE		( 5 )
+
+
+const char *CMISlave::pAttackHitSounds[] = 
+{
+	"zombie/claw_strike1.wav",
+	"zombie/claw_strike2.wav",
+	"zombie/claw_strike3.wav",
+};
+
+const char *CMISlave::pAttackMissSounds[] = 
+{
+	"zombie/claw_miss1.wav",
+	"zombie/claw_miss2.wav",
+};
+
+const char *CMISlave::pPainSounds[] = 
+{
+	"aslave/slv_pain1.wav",
+	"aslave/slv_pain2.wav",
+};
+
+const char *CMISlave::pDeathSounds[] = 
+{
+	"aslave/slv_die1.wav",
+	"aslave/slv_die2.wav",
+};
+
+//=========================================================
+// Classify - indicates this monster's place in the 
+// relationship table.
+//=========================================================
+int	CMISlave :: Classify ( void )
+{
+	return	CLASS_ALIEN_MILITARY;
+}
+
+
+int CMISlave::IRelationship( CMBaseEntity *pTarget )
+{
+	if ( (pTarget->IsPlayer()) )
+		if ( (pev->spawnflags & SF_MONSTER_WAIT_UNTIL_PROVOKED ) && ! (m_afMemory & bits_MEMORY_PROVOKED ))
+			return R_NO;
+	return CMBaseMonster::IRelationship( pTarget );
+}
+
+
+//=========================================================
+// ALertSound - scream
+//=========================================================
+void CMISlave :: AlertSound( void )
+{
+	if ( m_hEnemy != NULL )
+	{
+		SENTENCEG_PlayRndSz(ENT(pev), "SLV_ALERT", 0.85, ATTN_NORM, 0, m_voicePitch);
+	}
+}
+
+//=========================================================
+// IdleSound
+//=========================================================
+void CMISlave :: IdleSound( void )
+{
+	if (RANDOM_LONG( 0, 2 ) == 0)
+	{
+		SENTENCEG_PlayRndSz(ENT(pev), "SLV_IDLE", 0.85, ATTN_NORM, 0, m_voicePitch);
+	}
+
+#if 0
+	int side = RANDOM_LONG( 0, 1 ) * 2 - 1;
+
+	ClearBeams( );
+	ArmBeam( side );
+
+	UTIL_MakeAimVectors( pev->angles );
+	Vector vecSrc = pev->origin + gpGlobals->v_right * 2 * side;
+	MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSrc );
+		WRITE_BYTE(TE_DLIGHT);
+		WRITE_COORD(vecSrc.x);	// X
+		WRITE_COORD(vecSrc.y);	// Y
+		WRITE_COORD(vecSrc.z);	// Z
+		WRITE_BYTE( 8 );		// radius * 0.1
+		WRITE_BYTE( 255 );		// r
+		WRITE_BYTE( 180 );		// g
+		WRITE_BYTE( 96 );		// b
+		WRITE_BYTE( 10 );		// time * 10
+		WRITE_BYTE( 0 );		// decay * 0.1
+	MESSAGE_END( );
+
+	EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "debris/zap1.wav", 1, ATTN_NORM, 0, 100 );
+#endif
+}
+
+//=========================================================
+// PainSound
+//=========================================================
+void CMISlave :: PainSound( void )
+{
+	if (RANDOM_LONG( 0, 2 ) == 0)
+	{
+		EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pPainSounds[ RANDOM_LONG(0,ARRAYSIZE(pPainSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
+	}
+}
+
+//=========================================================
+// DieSound
+//=========================================================
+
+void CMISlave :: DeathSound( void )
+{
+	EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pDeathSounds[ RANDOM_LONG(0,ARRAYSIZE(pDeathSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
+}
+
+
+//=========================================================
+// ISoundMask - returns a bit mask indicating which types
+// of sounds this monster regards. 
+//=========================================================
+int CMISlave :: ISoundMask ( void) 
+{
+	return 0;
+}
+
+
+void CMISlave::Killed( entvars_t *pevAttacker, int iGib )
+{
+	ClearBeams( );
+	CMBaseMonster::Killed( pevAttacker, iGib );
+}
+
+//=========================================================
+// SetYawSpeed - allows each sequence to have a different
+// turn rate associated with it.
+//=========================================================
+void CMISlave :: SetYawSpeed ( void )
+{
+	int ys;
+
+	switch ( m_Activity )
+	{
+	case ACT_WALK:		
+		ys = 50;	
+		break;
+	case ACT_RUN:		
+		ys = 70;
+		break;
+	case ACT_IDLE:		
+		ys = 50;
+		break;
+	default:
+		ys = 90;
+		break;
+	}
+
+	pev->yaw_speed = ys;
+}
+
+//=========================================================
+// HandleAnimEvent - catches the monster-specific messages
+// that occur when tagged animation frames are played.
+//
+// Returns number of events handled, 0 if none.
+//=========================================================
+void CMISlave :: HandleAnimEvent( MonsterEvent_t *pEvent )
+{
+	// ALERT( at_console, "event %d : %f\n", pEvent->event, pev->frame );
+	switch( pEvent->event )
+	{
+		case ISLAVE_AE_CLAW:
+		{
+			// SOUND HERE!
+			edict_t *pHurt = CheckTraceHullAttack( 70, gSkillData.slaveDmgClaw, DMG_SLASH );
+			if ( pHurt )
+			{
+				if ( pHurt->v.flags & (FL_MONSTER|FL_CLIENT) )
+				{
+					pHurt->v.punchangle.z = -18;
+					pHurt->v.punchangle.x = 5;
+				}
+				// Play a random attack hit sound
+				EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackHitSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackHitSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
+			}
+			else
+			{
+				// Play a random attack miss sound
+				EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackMissSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackMissSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
+			}
+		}
+		break;
+
+		case ISLAVE_AE_CLAWRAKE:
+		{
+			edict_t *pHurt = CheckTraceHullAttack( 70, gSkillData.slaveDmgClawrake, DMG_SLASH );
+			if ( pHurt )
+			{
+				if ( pHurt->v.flags & (FL_MONSTER|FL_CLIENT) )
+				{
+					pHurt->v.punchangle.z = -18;
+					pHurt->v.punchangle.x = 5;
+				}
+				EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackHitSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackHitSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
+			}
+			else
+			{
+				EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackMissSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackMissSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
+			}
+		}
+		break;
+
+		case ISLAVE_AE_ZAP_POWERUP:
+		{
+			UTIL_MakeAimVectors( pev->angles );
+
+			if (m_iBeams == 0)
+			{
+				Vector vecSrc = pev->origin + gpGlobals->v_forward * 2;
+				MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSrc );
+					WRITE_BYTE(TE_DLIGHT);
+					WRITE_COORD(vecSrc.x);	// X
+					WRITE_COORD(vecSrc.y);	// Y
+					WRITE_COORD(vecSrc.z);	// Z
+					WRITE_BYTE( 12 );		// radius * 0.1
+					WRITE_BYTE( 255 );		// r
+					WRITE_BYTE( 180 );		// g
+					WRITE_BYTE( 96 );		// b
+					WRITE_BYTE( 20 / pev->framerate );		// time * 10
+					WRITE_BYTE( 0 );		// decay * 0.1
+				MESSAGE_END( );
+
+			}
+/*jlb
+			if (m_hDead != NULL)
+			{
+				WackBeam( -1, m_hDead );
+				WackBeam( 1, m_hDead );
+			}
+			else
+jlb*/
+			{
+				ArmBeam( -1 );
+				ArmBeam( 1 );
+				BeamGlow( );
+			}
+
+			EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "debris/zap4.wav", 1, ATTN_NORM, 0, 100 + m_iBeams * 10 );
+			pev->skin = m_iBeams / 2;
+		}
+		break;
+
+		case ISLAVE_AE_ZAP_SHOOT:
+		{
+			ClearBeams( );
+
+/*jlb
+			if (m_hDead != NULL)
+			{
+				Vector vecDest = m_hDead->v.origin + Vector( 0, 0, 38 );
+				TraceResult trace;
+				UTIL_TraceHull( vecDest, vecDest, dont_ignore_monsters, human_hull, m_hDead, &trace );
+
+				if ( !trace.fStartSolid )
+				{
+					CMBaseEntity *pNew = Create( "monster_alien_slave", m_hDead->pev->origin, m_hDead->pev->angles );
+					CMBaseMonster *pNewMonster = pNew->MyMonsterPointer( );
+					pNew->pev->spawnflags |= 1;
+					WackBeam( -1, pNew );
+					WackBeam( 1, pNew );
+					UTIL_Remove( m_hDead );
+					EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "hassault/hw_shoot1.wav", 1, ATTN_NORM, 0, RANDOM_LONG( 130, 160 ) );
+					break;
+				}
+			}
+jlb*/
+			ClearMultiDamage();
+
+			UTIL_MakeAimVectors( pev->angles );
+
+			ZapBeam( -1 );
+			ZapBeam( 1 );
+
+			EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "hassault/hw_shoot1.wav", 1, ATTN_NORM, 0, RANDOM_LONG( 130, 160 ) );
+			// STOP_SOUND( ENT(pev), CHAN_WEAPON, "debris/zap4.wav" );
+
+			ApplyMultiDamage(pev, pev);
+
+			m_flNextAttack = gpGlobals->time + RANDOM_FLOAT( 0.5, 4.0 );
+		}
+		break;
+
+		case ISLAVE_AE_ZAP_DONE:
+		{
+			ClearBeams( );
+		}
+		break;
+
+		default:
+			CMBaseMonster::HandleAnimEvent( pEvent );
+			break;
+	}
+}
+
+//=========================================================
+// CheckRangeAttack1 - normal beam attack 
+//=========================================================
+BOOL CMISlave :: CheckRangeAttack1 ( float flDot, float flDist )
+{
+	if (m_flNextAttack > gpGlobals->time)
+	{
+		return FALSE;
+	}
+
+	return CMBaseMonster::CheckRangeAttack1( flDot, flDist );
+}
+
+//=========================================================
+// CheckRangeAttack2 - check bravery and try to resurect dead comrades
+//=========================================================
+BOOL CMISlave :: CheckRangeAttack2 ( float flDot, float flDist )
+{
+	return FALSE;
+
+	if (m_flNextAttack > gpGlobals->time)
+	{
+		return FALSE;
+	}
+
+//jlb	m_hDead = NULL;
+	m_iBravery = 0;
+
+	edict_t *pEntity = NULL;
+	while ((pEntity = UTIL_FindEntityByClassname( pEntity, "monster_alien_slave" )) != NULL)
+	{
+		TraceResult tr;
+
+		UTIL_TraceLine( EyePosition( ), UTIL_EyePosition(pEntity), ignore_monsters, ENT(pev), &tr );
+		if (tr.flFraction == 1.0 || tr.pHit == pEntity)
+		{
+			if (pEntity->v.deadflag == DEAD_DEAD)
+			{
+				float d = (pev->origin - pEntity->v.origin).Length();
+				if (d < flDist)
+				{
+//jlb					m_hDead = pEntity;
+					flDist = d;
+				}
+				m_iBravery--;
+			}
+			else
+			{
+				m_iBravery++;
+			}
+		}
+	}
+//jlb	if (m_hDead != NULL)
+//jlb		return TRUE;
+//jlb	else
+		return FALSE;
+}
+
+
+//=========================================================
+// StartTask
+//=========================================================
+void CMISlave :: StartTask ( Task_t *pTask )
+{
+	ClearBeams( );
+
+	CMBaseMonster :: StartTask ( pTask );
+}
+
+
+//=========================================================
+// Spawn
+//=========================================================
+void CMISlave :: Spawn()
+{
+	Precache( );
+
+	SET_MODEL(ENT(pev), "models/islave.mdl");
+	UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);
+
+	pev->solid			= SOLID_SLIDEBOX;
+	pev->movetype		= MOVETYPE_STEP;
+	m_bloodColor		= BLOOD_COLOR_GREEN;
+	pev->effects		= 0;
+	pev->health			= gSkillData.slaveHealth;
+	pev->view_ofs		= Vector ( 0, 0, 64 );// position of the eyes relative to monster's origin.
+	m_flFieldOfView		= 0.5;
+	m_MonsterState		= MONSTERSTATE_NONE;
+	m_afCapability		= bits_CAP_HEAR | bits_CAP_TURN_HEAD | bits_CAP_RANGE_ATTACK2 | bits_CAP_DOORS_GROUP;
+
+	m_voicePitch		= RANDOM_LONG( 85, 110 );
+
+	for (int i = 0; i < ISLAVE_MAX_BEAMS; i++)
+		m_pBeam[i] = NULL;
+
+   m_iBravery = 0;
+   m_flNextAttack = 0.0f;
+
+	MonsterInit();
+}
+
+//=========================================================
+// Precache - precaches all resources this monster needs
+//=========================================================
+void CMISlave :: Precache()
+{
+	int i;
+
+	PRECACHE_MODEL("models/islave.mdl");
+	PRECACHE_MODEL("sprites/lgtning.spr");
+	PRECACHE_SOUND("debris/zap1.wav");
+	PRECACHE_SOUND("debris/zap4.wav");
+	PRECACHE_SOUND("weapons/electro4.wav");
+	PRECACHE_SOUND("hassault/hw_shoot1.wav");
+	PRECACHE_SOUND("zombie/zo_pain2.wav");
+	PRECACHE_SOUND("headcrab/hc_headbite.wav");
+	PRECACHE_SOUND("weapons/cbar_miss1.wav");
+
+	for ( i = 0; i < ARRAYSIZE( pAttackHitSounds ); i++ )
+		PRECACHE_SOUND((char *)pAttackHitSounds[i]);
+
+	for ( i = 0; i < ARRAYSIZE( pAttackMissSounds ); i++ )
+		PRECACHE_SOUND((char *)pAttackMissSounds[i]);
+
+	for ( i = 0; i < ARRAYSIZE( pPainSounds ); i++ )
+		PRECACHE_SOUND((char *)pPainSounds[i]);
+
+	for ( i = 0; i < ARRAYSIZE( pDeathSounds ); i++ )
+		PRECACHE_SOUND((char *)pDeathSounds[i]);
+}	
+
+
+//=========================================================
+// TakeDamage - get provoked when injured
+//=========================================================
+
+int CMISlave :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType)
+{
+	// don't slash one of your own
+	CMBaseMonster *pMonster = GetClassPtr((CMBaseMonster *)VARS(pevAttacker));
+	if (pMonster != NULL)
+	{
+	   if ((bitsDamageType & DMG_SLASH) && pevAttacker && IRelationship( pMonster ) < R_DL)
+		   return 0;
+	}
+
+	m_afMemory |= bits_MEMORY_PROVOKED;
+	return CMBaseMonster::TakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType);
+}
+
+
+void CMISlave::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
+{
+	if (bitsDamageType & DMG_SHOCK)
+		return;
+
+	CMBaseMonster::TraceAttack( pevAttacker, flDamage, vecDir, ptr, bitsDamageType );
+}
+
+
+//=========================================================
+// AI Schedules Specific to this monster
+//=========================================================
+
+
+
+// primary range attack
+Task_t	tlSlaveAttack1[] =
+{
+	{ TASK_STOP_MOVING,			0				},
+	{ TASK_FACE_IDEAL,			(float)0		},
+	{ TASK_RANGE_ATTACK1,		(float)0		},
+};
+
+Schedule_t	slSlaveAttack1[] =
+{
+	{ 
+		tlSlaveAttack1,
+		ARRAYSIZE ( tlSlaveAttack1 ), 
+		bits_COND_CAN_MELEE_ATTACK1 |
+		bits_COND_HEAR_SOUND |
+		bits_COND_HEAVY_DAMAGE, 
+      0,
+		"Slave Range Attack1"
+	},
+};
+
+
+DEFINE_CUSTOM_SCHEDULES( CMISlave )
+{
+	slSlaveAttack1,
+};
+
+IMPLEMENT_CUSTOM_SCHEDULES( CMISlave, CMBaseMonster );
+
+
+//=========================================================
+//=========================================================
+Schedule_t *CMISlave :: GetSchedule( void )
+{
+	ClearBeams( );
+
+/*
+	if (pev->spawnflags)
+	{
+		pev->spawnflags = 0;
+		return GetScheduleOfType( SCHED_RELOAD );
+	}
+*/
+
+	switch (m_MonsterState)
+	{
+	case MONSTERSTATE_COMBAT:
+// dead enemy
+		if ( HasConditions( bits_COND_ENEMY_DEAD ) )
+		{
+			// call base class, all code to handle dead enemies is centralized there.
+			return CMBaseMonster :: GetSchedule();
+		}
+
+		if (pev->health < 20 || m_iBravery < 0)
+		{
+			if (!HasConditions( bits_COND_CAN_MELEE_ATTACK1 ))
+			{
+				m_failSchedule = SCHED_CHASE_ENEMY;
+				if (HasConditions( bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE))
+				{
+					return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );
+				}
+				if ( HasConditions ( bits_COND_SEE_ENEMY ) && HasConditions ( bits_COND_ENEMY_FACING_ME ) )
+				{
+					// ALERT( at_console, "exposed\n");
+					return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );
+				}
+			}
+		}
+		break;
+	}
+	return CMBaseMonster::GetSchedule( );
+}
+
+
+Schedule_t *CMISlave :: GetScheduleOfType ( int Type ) 
+{
+	switch	( Type )
+	{
+	case SCHED_FAIL:
+		if (HasConditions( bits_COND_CAN_MELEE_ATTACK1 ))
+		{
+			return CMBaseMonster :: GetScheduleOfType( SCHED_MELEE_ATTACK1 ); ;
+		}
+		break;
+	case SCHED_RANGE_ATTACK1:
+		return slSlaveAttack1;
+	case SCHED_RANGE_ATTACK2:
+		return slSlaveAttack1;
+	}
+	return CMBaseMonster :: GetScheduleOfType( Type );
+}
+
+
+//=========================================================
+// ArmBeam - small beam from arm to nearby geometry
+//=========================================================
+
+void CMISlave :: ArmBeam( int side )
+{
+	TraceResult tr;
+	float flDist = 1.0;
+	
+	if (m_iBeams >= ISLAVE_MAX_BEAMS)
+		return;
+
+	UTIL_MakeAimVectors( pev->angles );
+	Vector vecSrc = pev->origin + gpGlobals->v_up * 36 + gpGlobals->v_right * side * 16 + gpGlobals->v_forward * 32;
+
+	for (int i = 0; i < 3; i++)
+	{
+		Vector vecAim = gpGlobals->v_right * side * RANDOM_FLOAT( 0, 1 ) + gpGlobals->v_up * RANDOM_FLOAT( -1, 1 );
+		TraceResult tr1;
+		UTIL_TraceLine ( vecSrc, vecSrc + vecAim * 512, dont_ignore_monsters, ENT( pev ), &tr1);
+		if (flDist > tr1.flFraction)
+		{
+			tr = tr1;
+			flDist = tr.flFraction;
+		}
+	}
+
+	// Couldn't find anything close enough
+	if ( flDist == 1.0 )
+		return;
+
+	DecalGunshot( &tr, BULLET_PLAYER_CROWBAR );
+
+	m_pBeam[m_iBeams] = CMBeam::BeamCreate( "sprites/lgtning.spr", 30 );
+	if (!m_pBeam[m_iBeams])
+		return;
+
+	m_pBeam[m_iBeams]->PointEntInit( tr.vecEndPos, entindex( ) );
+	m_pBeam[m_iBeams]->SetEndAttachment( side < 0 ? 2 : 1 );
+	// m_pBeam[m_iBeams]->SetColor( 180, 255, 96 );
+	m_pBeam[m_iBeams]->SetColor( 96, 128, 16 );
+	m_pBeam[m_iBeams]->SetBrightness( 64 );
+	m_pBeam[m_iBeams]->SetNoise( 80 );
+	m_iBeams++;
+}
+
+
+//=========================================================
+// BeamGlow - brighten all beams
+//=========================================================
+void CMISlave :: BeamGlow( )
+{
+	int b = m_iBeams * 32;
+	if (b > 255)
+		b = 255;
+
+	for (int i = 0; i < m_iBeams; i++)
+	{
+		if (m_pBeam[i]->GetBrightness() != 255) 
+		{
+			m_pBeam[i]->SetBrightness( b );
+		}
+	}
+}
+
+
+//=========================================================
+// WackBeam - regenerate dead colleagues
+//=========================================================
+void CMISlave :: WackBeam( int side, edict_t *pEntity )
+{
+	Vector vecDest;
+	float flDist = 1.0;
+	
+	if (m_iBeams >= ISLAVE_MAX_BEAMS)
+		return;
+
+	if (pEntity == NULL)
+		return;
+
+	m_pBeam[m_iBeams] = CMBeam::BeamCreate( "sprites/lgtning.spr", 30 );
+	if (!m_pBeam[m_iBeams])
+		return;
+
+	m_pBeam[m_iBeams]->PointEntInit( UTIL_Center(pEntity), entindex( ) );
+	m_pBeam[m_iBeams]->SetEndAttachment( side < 0 ? 2 : 1 );
+	m_pBeam[m_iBeams]->SetColor( 180, 255, 96 );
+	m_pBeam[m_iBeams]->SetBrightness( 255 );
+	m_pBeam[m_iBeams]->SetNoise( 80 );
+	m_iBeams++;
+}
+
+//=========================================================
+// ZapBeam - heavy damage directly forward
+//=========================================================
+void CMISlave :: ZapBeam( int side )
+{
+	Vector vecSrc, vecAim;
+	TraceResult tr;
+	edict_t *pEntity;
+
+	if (m_iBeams >= ISLAVE_MAX_BEAMS)
+		return;
+
+	vecSrc = pev->origin + gpGlobals->v_up * 36;
+	vecAim = ShootAtEnemy( vecSrc );
+	float deflection = 0.01;
+	vecAim = vecAim + side * gpGlobals->v_right * RANDOM_FLOAT( 0, deflection ) + gpGlobals->v_up * RANDOM_FLOAT( -deflection, deflection );
+	UTIL_TraceLine ( vecSrc, vecSrc + vecAim * 1024, dont_ignore_monsters, ENT( pev ), &tr);
+
+	m_pBeam[m_iBeams] = CMBeam::BeamCreate( "sprites/lgtning.spr", 50 );
+	if (!m_pBeam[m_iBeams])
+		return;
+
+	m_pBeam[m_iBeams]->PointEntInit( tr.vecEndPos, entindex( ) );
+	m_pBeam[m_iBeams]->SetEndAttachment( side < 0 ? 2 : 1 );
+	m_pBeam[m_iBeams]->SetColor( 180, 255, 96 );
+	m_pBeam[m_iBeams]->SetBrightness( 255 );
+	m_pBeam[m_iBeams]->SetNoise( 20 );
+	m_iBeams++;
+
+	pEntity = tr.pHit;
+	if (pEntity != NULL && pEntity->v.takedamage)
+	{
+		if (UTIL_IsPlayer(pEntity))
+			UTIL_TraceAttack( pEntity, pev, gSkillData.slaveDmgZap, vecAim, &tr, DMG_SHOCK );
+		else if (pEntity->v.euser4 != NULL)
+		{
+			CMBaseMonster *pMonster = GetClassPtr((CMBaseMonster *)VARS(pEntity));
+			pMonster->TraceAttack( pev, gSkillData.slaveDmgZap, vecAim, &tr, DMG_SHOCK );
+		}
+	}
+
+	UTIL_EmitAmbientSound( ENT(pev), tr.vecEndPos, "weapons/electro4.wav", 0.5, ATTN_NORM, 0, RANDOM_LONG( 140, 160 ) );
+}
+
+
+//=========================================================
+// ClearBeams - remove all beams
+//=========================================================
+void CMISlave :: ClearBeams( )
+{
+	for (int i = 0; i < ISLAVE_MAX_BEAMS; i++)
+	{
+		if (m_pBeam[i])
+		{
+			UTIL_Remove( m_pBeam[i]->edict() );
+			m_pBeam[i] = NULL;
+		}
+	}
+	m_iBeams = 0;
+	pev->skin = 0;
+
+	STOP_SOUND( ENT(pev), CHAN_WEAPON, "debris/zap4.wav" );
+}

src/dlls/monster_api.cpp

@@ -0,0 +1,146 @@
+//
+// botman's monster - MetaMOD plugin
+//
+// monster_api.cpp
+//
+
+/*
+ *    This is free software; you can redistribute it and/or modify it
+ *    under the terms of the GNU General Public License as published by the
+ *    Free Software Foundation; either version 2 of the License, or (at
+ *    your option) any later version.
+ *
+ *    This is distributed in the hope that it will be useful, but
+ *    WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this code; if not, write to the Free Software Foundation,
+ *    Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *    In addition, as a special exception, the author gives permission to
+ *    link the code of this program with the Half-Life Game Engine ("HL
+ *    Engine") and Modified Game Libraries ("MODs") developed by Valve,
+ *    L.L.C ("Valve").  You must obey the GNU General Public License in all
+ *    respects for all of the code used other than the HL Engine and MODs
+ *    from Valve.  If you modify this file, you may extend this exception
+ *    to your version of the file, but you are not obligated to do so.  If
+ *    you do not wish to do so, delete this exception statement from your
+ *    version.
+ *
+ */
+
+#include "extdll.h"
+#include "meta_api.h"
+#include "sdk_util.h"      // UTIL_LogPrintf, etc
+
+// Must provide at least one of these..
+static META_FUNCTIONS gMetaFunctionTable = {
+   NULL,         // pfnGetEntityAPI            HL SDK; called before game DLL
+   NULL,         // pfnGetEntityAPI_Post       META; called after game DLL
+   GetEntityAPI2,   // pfnGetEntityAPI2        HL SDK2; called before game DLL
+   GetEntityAPI2_Post, // pfnGetEntityAPI2_Post  META; called after game DLL
+   NULL,         // pfnGetNewDLLFunctions   HL SDK2; called before game DLL
+   NULL,         // pfnGetNewDLLFunctions_Post META; called after game DLL
+	NULL,         // pfnGetEngineFunctions	META; called before HL engine
+   NULL,         // pfnGetEngineFunctions_Post META; called after HL engine
+};
+
+// Description of plugin
+plugin_info_t Plugin_info = {
+   META_INTERFACE_VERSION,                // interface version
+   "Monster",                             // name
+   "3.00.00",                             // version
+   "06/30/2002",                          // date
+   "botman <botman@planethalflife.com>",  // author
+   "http://planethalflife.com/botman/",   // url
+   "MONSTER",                             // logtag
+   PT_CHANGELEVEL,                        // (when) loadable
+   PT_CHANGELEVEL,                        // (when) unloadable
+};
+
+char *VNAME=Plugin_info.name;
+char *VVERSION=Plugin_info.version;
+char *VDATE=Plugin_info.date;
+char *VAUTHOR=Plugin_info.author;
+char *VURL=Plugin_info.url;
+char *VLOGTAG=Plugin_info.logtag;
+char *COMPILE_TIME=__DATE__ ", " __TIME__;
+
+// Global vars from metamod:
+meta_globals_t *gpMetaGlobals;      // metamod globals
+gamedll_funcs_t *gpGamedllFuncs;    // gameDLL function tables
+mutil_funcs_t *gpMetaUtilFuncs;     // metamod utility functions
+
+cvar_t init_dllapi_log = {"monster_log", "0", FCVAR_EXTDLL, 0, NULL};
+cvar_t *dllapi_log = NULL;
+cvar_t init_monster_spawn = {"monster_spawn", "1", FCVAR_EXTDLL, 0, NULL};
+cvar_t *monster_spawn = NULL;
+
+
+// Metamod requesting info about this plugin:
+//  ifvers         (given) interface_version metamod is using
+//  pPlugInfo      (requested) struct with info about plugin
+//  pMetaUtilFuncs   (given) table of utility functions provided by metamod
+C_DLLEXPORT int Meta_Query(char *ifvers, plugin_info_t **pPlugInfo,
+      mutil_funcs_t *pMetaUtilFuncs) 
+{
+   if(ifvers);   // to satisfy gcc -Wunused
+   // Give metamod our plugin_info struct
+   *pPlugInfo=&Plugin_info;
+   // Get metamod utility function table.
+   gpMetaUtilFuncs=pMetaUtilFuncs;
+   return(TRUE);
+}
+
+// Metamod attaching plugin to the server.
+//  now            (given) current phase, ie during map, during changelevel, or at startup
+//  pFunctionTable   (requested) table of function tables this plugin catches
+//  pMGlobals      (given) global vars from metamod
+//  pGamedllFuncs   (given) copy of function tables from game dll
+C_DLLEXPORT int Meta_Attach(PLUG_LOADTIME now, META_FUNCTIONS *pFunctionTable, 
+      meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs) 
+{
+   if(now);   // to satisfy gcc -Wunused
+   if(!pMGlobals) {
+      LOG_ERROR(PLID, "Meta_Attach called with null pMGlobals");
+      return(FALSE);
+   }
+   gpMetaGlobals=pMGlobals;
+   if(!pFunctionTable) {
+      LOG_ERROR(PLID, "Meta_Attach called with null pFunctionTable");
+      return(FALSE);
+   }
+   memcpy(pFunctionTable, &gMetaFunctionTable, sizeof(META_FUNCTIONS));
+   gpGamedllFuncs=pGamedllFuncs;
+
+   LOG_MESSAGE(PLID, "%s v%s, %s", VNAME, VVERSION, VDATE);
+   LOG_MESSAGE(PLID, "by %s", VAUTHOR);
+   LOG_MESSAGE(PLID, "   %s", VURL);
+   LOG_MESSAGE(PLID, "compiled: %s CDT", COMPILE_TIME);
+
+   LOG_CONSOLE(PLID, "[%s] %s v%s, %s", VLOGTAG, VNAME, VVERSION, VDATE);
+   LOG_CONSOLE(PLID, "[%s] by %s", VLOGTAG, VAUTHOR);
+
+   CVAR_REGISTER(&init_dllapi_log);
+   dllapi_log = CVAR_GET_POINTER("monster_log");
+
+   CVAR_REGISTER(&init_monster_spawn);
+   monster_spawn = CVAR_GET_POINTER("monster_spawn");
+
+   return(TRUE);
+}
+
+
+extern void monster_unload(void);
+
+// Metamod detaching plugin from the server.
+// now      (given) current phase, ie during map, etc
+// reason   (given) why detaching (refresh, console unload, forced unload, etc)
+C_DLLEXPORT int Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason) {
+   // remove all the monsters currently in the level...
+   monster_unload();
+   return(TRUE);
+}
+

src/dlls/monster_config.cpp

@@ -0,0 +1,418 @@
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifndef __linux__
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
+#include "extdll.h"
+#include "dllapi.h"
+#include "meta_api.h"
+
+#include "monster_plugin.h"
+
+extern cvar_t *dllapi_log;
+
+extern monster_type_t monster_types[];
+extern int monster_spawn_count;
+
+
+bool get_input(FILE *fp, char *input)
+{
+   char line[1024];
+   int len, pos;
+
+   while (!feof(fp))
+   {
+      if (fgets(line, 1023, fp) != NULL)
+      {
+         len = strlen(line);
+
+         if (len == 0)
+            continue;  // skip any null lines
+
+         // remove any trailing newline, carriage return or whitespace...
+         while ((line[len-1] == '\n') || (line[len-1] == '\r') ||
+                isspace(line[len-1]))
+         {
+            line[len-1] = 0;
+            len--;
+            if (len == 0)
+               break;
+         }
+
+         pos = 0;
+
+         while (isspace(line[pos]))
+            pos++;  // skip leading blanks
+
+         if ((line[pos] == '/') && (line[pos+1] == '/'))
+            continue;  // skip comment lines
+
+         if (line[pos] == 0)
+            continue;  // skip empty lines
+
+         strcpy(input, &line[pos]);
+         return TRUE;
+      }
+   }
+
+   return FALSE;  // no input found
+}
+
+
+bool scan_monster_cfg(FILE *fp)
+{
+   char input[1024];
+   bool origin, angle, delay, angle_min, angle_max, monster;
+   float x, y, z;
+
+   while (get_input(fp, input))
+   {
+      if (monster_spawn_count == MAX_MONSTERS)
+         continue;  // skip if max monster spawn count reached
+
+      if (input[0] == '{')
+      {
+         origin = angle = delay = angle_min = angle_max = monster = FALSE;
+
+         monster_spawnpoint[monster_spawn_count].monster_count = 0;
+
+         while (get_input(fp, input))
+         {
+            if (input[0] == '}')
+               break;
+
+            if (strncmp(input, "origin/", 7) == 0)
+            {
+               if (origin)
+               {
+                  META_CONS("[MONSTER] ERROR: origin found twice: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: origin found twice: %s", input);
+                  return TRUE;  // error
+               }
+               if (sscanf(&input[7], "%f %f %f", &x, &y, &z) != 3)
+               {
+                  META_CONS("[MONSTER] ERROR: invalid origin: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: invalid origin: %s", input);
+                  return TRUE;  // error
+               }
+               origin = TRUE;
+               monster_spawnpoint[monster_spawn_count].origin[0] = x;
+               monster_spawnpoint[monster_spawn_count].origin[1] = y;
+               monster_spawnpoint[monster_spawn_count].origin[2] = z;
+            }
+            else if (strncmp(input, "delay/", 6) == 0)
+            {
+               if (delay)
+               {
+                  META_CONS("[MONSTER] ERROR: delay found twice: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: delay found twice: %s", input);
+                  return TRUE;  // error
+               }
+               if (sscanf(&input[6], "%f", &x) != 1)
+               {
+                  META_CONS("[MONSTER] ERROR: invalid delay: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: invalid delay: %s", input);
+                  return TRUE;  // error
+               }
+               delay = TRUE;
+               monster_spawnpoint[monster_spawn_count].delay = x;
+            }
+            else if (strncmp(input, "angle/", 6) == 0)
+            {
+               if (angle)
+               {
+                  META_CONS("[MONSTER] ERROR: angle found twice: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: angle found twice: %s", input);
+                  return TRUE;  // error
+               }
+               if (angle_min || angle_max)
+               {
+                  META_CONS("[MONSTER] ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
+                  return TRUE;  // error
+               }
+               if (sscanf(&input[6], "%f", &x) != 1)
+               {
+                  META_CONS("[MONSTER] ERROR: invalid angle: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: invalid angle: %s", input);
+                  return TRUE;  // error
+               }
+               angle = TRUE;
+               monster_spawnpoint[monster_spawn_count].angle_min = x;
+               monster_spawnpoint[monster_spawn_count].angle_max = x;
+            }
+            else if (strncmp(input, "angle_min/", 10) == 0)
+            {
+               if (angle_min)
+               {
+                  META_CONS("[MONSTER] ERROR: angle_min found twice: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: angle_min found twice: %s", input);
+                  return TRUE;  // error
+               }
+               if (angle)
+               {
+                  META_CONS("[MONSTER] ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
+                  return TRUE;  // error
+               }
+               if (sscanf(&input[10], "%f", &x) != 1)
+               {
+                  META_CONS("[MONSTER] ERROR: invalid angle_min: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: invalid angle_min: %s", input);
+                  return TRUE;  // error
+               }
+               angle_min = TRUE;
+               monster_spawnpoint[monster_spawn_count].angle_min = x;
+            }
+            else if (strncmp(input, "angle_max/", 10) == 0)
+            {
+               if (angle_max)
+               {
+                  META_CONS("[MONSTER] ERROR: angle_max found twice: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: angle_max found twice: %s", input);
+                  return TRUE;  // error
+               }
+               if (angle)
+               {
+                  META_CONS("[MONSTER] ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
+                  return TRUE;  // error
+               }
+               if (sscanf(&input[10], "%f", &x) != 1)
+               {
+                  META_CONS("[MONSTER] ERROR: invalid angle_max: %s", input);
+                  LOG_MESSAGE(PLID, "ERROR: invalid angle_max: %s", input);
+                  return TRUE;  // error
+               }
+               angle_max = TRUE;
+               monster_spawnpoint[monster_spawn_count].angle_max = x;
+            }
+            else if (strncmp(input, "monster/", 8) == 0)
+            {
+               int index;
+               int count = monster_spawnpoint[monster_spawn_count].monster_count;
+               if (count < MAX_MONSTER_COUNT)
+               {
+                  for (index=0; monster_types[index].name[0]; index++)
+                  {
+                     if (strcmp(&input[8], monster_types[index].name) == 0)
+                     {
+                        monster_spawnpoint[monster_spawn_count].monster[count] = index;
+                        monster_spawnpoint[monster_spawn_count].monster_count++;
+
+                        monster_types[index].need_to_precache = TRUE;
+                        break;
+                     }
+                  }
+                  if (monster_types[index].name[0] == 0)
+                  {
+                     META_CONS("[MONSTER] ERROR: invalid monster name: %s", input);
+                     LOG_MESSAGE(PLID, "ERROR: invalid monster name: %s", input);
+                     return TRUE;
+                  }
+               }
+               monster = TRUE;
+            }
+            else
+            {
+               META_CONS("[MONSTER] ERROR: unknown command: %s", input);
+               LOG_MESSAGE(PLID, "ERROR: unknown command: %s", input);
+               return TRUE;  // error occurred
+            }
+         }
+
+         // check for all necessary fields here...
+         if (!origin)
+         {
+            META_CONS("[MONSTER] ERROR: you didn't specify an origin!");
+            LOG_MESSAGE(PLID, "ERROR: you didn't specify an origin!");
+            return TRUE;
+         }
+         if (angle_min && !angle_max)
+         {
+            META_CONS("[MONSTER] ERROR: you specified angle_min but didn't specify angle_max!");
+            LOG_MESSAGE(PLID, "ERROR: you specified angle_min but didn't specify angle_max!");
+            return TRUE;
+         }
+         if (angle_max && !angle_min)
+         {
+            META_CONS("[MONSTER] ERROR: you specified angle_max but didn't specify angle_min!");
+            LOG_MESSAGE(PLID, "ERROR: you specified angle_max but didn't specify angle_min!");
+            return TRUE;
+         }
+         if (!monster)
+         {
+            META_CONS("[MONSTER] ERROR: No monster key found!");
+            LOG_MESSAGE(PLID, "ERROR: No monster key found!");
+            return TRUE;
+         }
+
+         if (!delay)
+            monster_spawnpoint[monster_spawn_count].delay = 30;  // 30 second default delay
+
+         if (monster_spawnpoint[monster_spawn_count].delay < 1)
+            monster_spawnpoint[monster_spawn_count].delay = 1;  // no negative or zero delay
+
+         if (!angle && !angle_min && !angle_max)  // no angle specified, use 0-359 as default
+         {
+            monster_spawnpoint[monster_spawn_count].angle_min = 0;
+            monster_spawnpoint[monster_spawn_count].angle_max = 359;
+         }
+
+         if (monster_spawnpoint[monster_spawn_count].angle_min < 0)
+            monster_spawnpoint[monster_spawn_count].angle_min = 0;  // no negative angles
+
+         if (monster_spawnpoint[monster_spawn_count].angle_max > 359)
+            monster_spawnpoint[monster_spawn_count].angle_max = 359;  // no angle > 359 degrees
+
+         monster_spawnpoint[monster_spawn_count].respawn_time = gpGlobals->time + RANDOM_FLOAT(10.0, 20.0);
+         monster_spawnpoint[monster_spawn_count].need_to_respawn = TRUE;
+
+         if (dllapi_log->value)
+         {
+            char name_monsters[256];
+
+            LOG_MESSAGE(PLID, "Added monster spawn at: %7.2f %7.2f %7.2f",
+               monster_spawnpoint[monster_spawn_count].origin.x,
+               monster_spawnpoint[monster_spawn_count].origin.y,
+               monster_spawnpoint[monster_spawn_count].origin.z);
+            LOG_MESSAGE(PLID, "      with delay = %7.2f, angle_min = %7.2f, angle_max = %7.2f",
+               monster_spawnpoint[monster_spawn_count].delay,
+               monster_spawnpoint[monster_spawn_count].angle_min,
+               monster_spawnpoint[monster_spawn_count].angle_max);
+            name_monsters[0] = 0;
+            for (int i = 0; i < monster_spawnpoint[monster_spawn_count].monster_count; i++)
+            {
+               strcat(name_monsters, monster_types[monster_spawnpoint[monster_spawn_count].monster[i]].name);
+               strcat(name_monsters, " ");
+            }
+            LOG_MESSAGE(PLID, "      monsters = %s", name_monsters);
+         }
+
+         monster_spawn_count++;
+      }
+   }
+
+   return FALSE;
+}
+
+
+bool process_monster_cfg(void)
+{
+   char game_dir[256];
+   char filename[256];
+   FILE *fp = NULL;
+   bool status = FALSE;  // no error
+
+   monster_spawn_count = 0;
+
+   // find the directory name of the currently running MOD...
+   (*g_engfuncs.pfnGetGameDir)(game_dir);
+
+   strcpy(filename, game_dir);
+#ifdef __linux__
+   strcat(filename, "/maps/");
+#else
+   strcat(filename, "\\maps\\");
+#endif
+   strcat(filename, STRING(gpGlobals->mapname));
+   strcat(filename, "_monster.cfg");
+
+   // check if the map specific filename exists...
+   if (access(filename, 0) == 0)
+   {
+      if (dllapi_log->value)
+      {
+         META_CONS("[MONSTER] Processing config file=%s", filename);
+         LOG_MESSAGE(PLID, "Processing config file=%s", filename);
+      }
+
+      if ((fp = fopen(filename, "r")) == NULL)
+      {
+         META_CONS("[MONSTER] ERROR: Could not open \"%s\"!", filename);
+         LOG_MESSAGE(PLID, "ERROR: Could not open \"%s\" file!", filename);
+
+         return TRUE;  // return bad status
+      }
+
+      status = scan_monster_cfg(fp);
+
+      fclose(fp);
+   }
+
+   return status;
+}
+
+
+bool scan_monster_precache_cfg(FILE *fp)
+{
+   char input[1024];
+   bool found;
+
+   while (get_input(fp, input))
+   {
+      found = FALSE;
+
+      for (int index=0; monster_types[index].name[0]; index++)
+      {
+         if (strcmp(input, monster_types[index].name) == 0)
+         {
+            monster_types[index].need_to_precache = TRUE;
+            found = TRUE;
+            break;
+         }
+      }
+
+      if (found == FALSE)
+      {
+         META_CONS("[MONSTER] ERROR: invalid precache monster name: %s", input);
+         LOG_MESSAGE(PLID, "ERROR: invalid precache monster name: %s", input);
+      }
+   }
+
+   return FALSE;
+}
+
+
+bool process_monster_precache_cfg(void)
+{
+   char game_dir[256];
+   char filename[256];
+   FILE *fp = NULL;
+   bool status = FALSE;  // no error
+
+   // find the directory name of the currently running MOD...
+   (*g_engfuncs.pfnGetGameDir)(game_dir);
+
+   strcpy(filename, game_dir);
+   strcat(filename, "/monster_precache.cfg");
+
+   // check if the map specific filename exists...
+   if (access(filename, 0) == 0)
+   {
+      if (dllapi_log->value)
+      {
+         META_CONS("[MONSTER] Processing config file=%s", filename);
+         LOG_MESSAGE(PLID, "Processing config file=%s", filename);
+      }
+
+      if ((fp = fopen(filename, "r")) == NULL)
+      {
+         META_CONS("[MONSTER] ERROR: Could not open \"%s\"!", filename);
+         LOG_MESSAGE(PLID, "ERROR: Could not open \"%s\" file!", filename);
+
+         return TRUE;  // return bad status
+      }
+
+      status = scan_monster_precache_cfg(fp);
+
+      fclose(fp);
+   }
+
+   return status;
+}

src/dlls/monster_mm.def

@@ -0,0 +1,5 @@
+LIBRARY monster_mm
+EXPORTS
+	GiveFnptrsToDll			@1
+SECTIONS
+	.data READ WRITE

src/dlls/monster_mm.dsp

@@ -0,0 +1,378 @@
+# Microsoft Developer Studio Project File - Name="monster_mm" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=monster_mm - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "monster_mm.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "monster_mm.mak" CFG="monster_mm - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "monster_mm - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "monster_mm - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "monster_mm - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "monster_mm_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /I "..\dlls" /I "..\common" /I "..\engine" /I "..\pm_shared" /I "..\..\metamod" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "monster_mm_EXPORTS" /D strcasecmp=stricmp /D strncasecmp=_strnicmp /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /def:".\monster_mm.def"
+# Begin Custom Build - Copying to DLL folder
+TargetPath=.\Release\monster_mm.dll
+TargetName=monster_mm
+InputPath=.\Release\monster_mm.dll
+SOURCE="$(InputPath)"
+
+"$(TargetName)" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	copy $(TargetPath) D:\Half-Life\valve\dlls 
+	copy $(TargetPath) D:\Half-Life\tfc\dlls 
+	copy $(TargetPath) D:\Half-Life\cstrike\dlls 
+	copy $(TargetPath) D:\Half-Life\dmc\dlls 
+	copy $(TargetPath) D:\Half-Life\dod\dlls 
+	copy $(TargetPath) D:\Half-Life\firearms\dlls 
+	copy $(TargetPath) D:\Half-Life\frontline\dlls 
+	
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "monster_mm - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "monster_mm_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "..\dlls" /I "..\common" /I "..\engine" /I "..\pm_shared" /I "..\..\metamod" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "monster_mm_EXPORTS" /D strcasecmp=stricmp /D strncasecmp=_strnicmp /FD /GZ /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /def:".\monster_mm.def" /pdbtype:sept
+# Begin Custom Build - Copying to DLL folder
+TargetPath=.\Debug\monster_mm.dll
+TargetName=monster_mm
+InputPath=.\Debug\monster_mm.dll
+SOURCE="$(InputPath)"
+
+"$(TargetName)" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	copy $(TargetPath) D:\Half-Life\valve\dlls 
+	copy $(TargetPath) D:\Half-Life\tfc\dlls 
+	copy $(TargetPath) D:\Half-Life\cstrike\dlls 
+	copy $(TargetPath) D:\Half-Life\dmc\dlls 
+	copy $(TargetPath) D:\Half-Life\dod\dlls 
+	copy $(TargetPath) D:\Half-Life\firearms\dlls 
+	copy $(TargetPath) D:\Half-Life\frontline\dlls 
+	copy $(TargetPath) D:\Half-Life\gearbox\dlls 
+	
+# End Custom Build
+
+!ENDIF 
+
+# Begin Target
+
+# Name "monster_mm - Win32 Release"
+# Name "monster_mm - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\agrunt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\AI_BaseNPC_Schedule.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\animating.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\animation.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\apache.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\barney.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\bigmomma.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\bullsquid.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cmbase.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\combat.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\controller.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\defaultai.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\dllapi.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\effects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\flyingmonster.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ggrenade.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\h_ai.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\h_export.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\hassassin.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\headcrab.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\hgrunt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\hornet.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\houndeye.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\islave.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\monster_api.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\monster_config.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\monsters.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\monsterstate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\nodes.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\scientist.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\skill.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sound.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\squeakgrenade.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\subs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\talkmonster.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\util.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\weapons.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\zombie.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\activity.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\animation.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cdll_dll.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cmbase.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cmbasemonster.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cmflyingmonster.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cmtalkmonster.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\decals.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\doors.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\effects.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\enginecallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\explode.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\extdll.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\func_break.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\monster_plugin.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\monsters.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\nodes.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\schedule.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\skill.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\util.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\vector.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\weapons.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

src/dlls/monster_plugin.h

@@ -0,0 +1,57 @@
+//
+// monster_plugin.h
+//
+
+#ifndef MONSTER_PLUGIN_H
+#define MONSTER_PLUGIN_H
+
+
+typedef struct
+{
+   char *name;
+   bool need_to_precache;
+} monster_type_t;
+
+
+class CMBaseMonster;
+
+typedef struct
+{
+   int monster_index;
+   edict_t *monster_pent;
+   bool killed;
+   int respawn_index;
+   CMBaseMonster *pMonster;
+} monster_t;
+
+#define MAX_MONSTER_ENTS 200
+
+extern monster_t monsters[MAX_MONSTER_ENTS];
+
+
+#define MAX_MONSTER_COUNT 20
+
+typedef struct {
+   Vector origin;
+   float angle_min, angle_max;
+   float delay;
+   unsigned char monster[MAX_MONSTER_COUNT];
+   int monster_count;
+   float respawn_time;
+   bool need_to_respawn;
+} monster_spawnpoint_t;
+
+#define MAX_MONSTERS 100
+extern monster_spawnpoint_t monster_spawnpoint[MAX_MONSTERS];
+
+extern DLL_GLOBAL short g_sModelIndexFireball;// holds the index for the fireball
+extern DLL_GLOBAL short g_sModelIndexSmoke;// holds the index for the smoke cloud
+extern DLL_GLOBAL short g_sModelIndexWExplosion;// holds the index for the underwater explosion
+extern DLL_GLOBAL short g_sModelIndexBubbles;// holds the index for the bubbles model
+extern DLL_GLOBAL short g_sModelIndexBloodDrop;// holds the sprite index for the initial blood
+extern DLL_GLOBAL short g_sModelIndexBloodSpray;// holds the sprite index for splattered blood
+extern DLL_GLOBAL short g_sModelIndexLaser;// holds the index for the laser beam
+extern DLL_GLOBAL const char *g_pModelNameLaser;
+extern DLL_GLOBAL short g_sModelIndexLaserDot;// holds the index for the laser beam dot
+
+#endif

src/dlls/monsterevent.h

@@ -0,0 +1,34 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef MONSTEREVENT_H
+#define MONSTEREVENT_H
+
+typedef struct
+{
+	int			event;
+	char		*options;
+} MonsterEvent_t;
+
+#define EVENT_SPECIFIC			0
+#define EVENT_SCRIPTED			1000
+#define EVENT_SHARED			2000
+#define EVENT_CLIENT			5000
+
+#define MONSTER_EVENT_BODYDROP_LIGHT	2001
+#define MONSTER_EVENT_BODYDROP_HEAVY	2002
+
+#define MONSTER_EVENT_SWISHSOUND		2010
+
+#endif		// MONSTEREVENT_H

src/dlls/monsters.h

@@ -0,0 +1,180 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+#ifndef MONSTERS_H
+#define MONSTERS_H
+
+/*
+
+===== monsters.h ========================================================
+
+  Header file for monster-related utility code
+
+*/
+
+// CHECKLOCALMOVE result types 
+#define	LOCALMOVE_INVALID					0 // move is not possible
+#define LOCALMOVE_INVALID_DONT_TRIANGULATE	1 // move is not possible, don't try to triangulate
+#define LOCALMOVE_VALID						2 // move is possible
+
+// Hit Group standards
+#define	HITGROUP_GENERIC	0
+#define	HITGROUP_HEAD		1
+#define	HITGROUP_CHEST		2
+#define	HITGROUP_STOMACH	3
+#define HITGROUP_LEFTARM	4	
+#define HITGROUP_RIGHTARM	5
+#define HITGROUP_LEFTLEG	6
+#define HITGROUP_RIGHTLEG	7
+
+
+// Monster Spawnflags
+#define	SF_MONSTER_WAIT_TILL_SEEN		1// spawnflag that makes monsters wait until player can see them before attacking.
+#define	SF_MONSTER_GAG					2 // no idle noises from this monster
+#define SF_MONSTER_HITMONSTERCLIP		4
+//										8
+#define SF_MONSTER_PRISONER				16 // monster won't attack anyone, no one will attacke him.
+//										32
+//										64
+#define	SF_MONSTER_WAIT_FOR_SCRIPT		128 //spawnflag that makes monsters wait to check for attacking until the script is done or they've been attacked
+#define SF_MONSTER_PREDISASTER			256	//this is a predisaster scientist or barney. Influences how they speak.
+#define SF_MONSTER_FADECORPSE			512 // Fade out corpse after death
+#define SF_MONSTER_FALL_TO_GROUND		0x80000000
+
+// specialty spawnflags
+#define SF_MONSTER_TURRET_AUTOACTIVATE	32
+#define SF_MONSTER_TURRET_STARTINACTIVE	64
+#define SF_MONSTER_WAIT_UNTIL_PROVOKED	64 // don't attack the player unless provoked
+
+
+
+// MoveToOrigin stuff
+#define		MOVE_START_TURN_DIST	64 // when this far away from moveGoal, start turning to face next goal
+#define		MOVE_STUCK_DIST			32 // if a monster can't step this far, it is stuck.
+
+
+// MoveToOrigin stuff
+#define		MOVE_NORMAL				0// normal move in the direction monster is facing
+#define		MOVE_STRAFE				1// moves in direction specified, no matter which way monster is facing
+
+// spawn flags 256 and above are already taken by the engine
+extern void UTIL_MoveToOrigin( edict_t* pent, const Vector &vecGoal, float flDist, int iMoveType ); 
+
+Vector VecCheckToss ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flGravityAdj = 1.0 );
+Vector VecCheckThrow ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flSpeed, float flGravityAdj = 1.0 );
+extern DLL_GLOBAL Vector		g_vecAttackDir;
+extern DLL_GLOBAL CONSTANT float g_flMeleeRange;
+extern DLL_GLOBAL CONSTANT float g_flMediumRange;
+extern DLL_GLOBAL CONSTANT float g_flLongRange;
+extern void EjectBrass (const Vector &vecOrigin, const Vector &vecVelocity, float rotation, int model, int soundtype );
+extern void ExplodeModel( const Vector &vecOrigin, float speed, int model, int count );
+
+BOOL FBoxVisible ( entvars_t *pevLooker, entvars_t *pevTarget );
+BOOL FBoxVisible ( entvars_t *pevLooker, entvars_t *pevTarget, Vector &vecTargetOrigin, float flSize = 0.0 );
+
+// monster to monster relationship types
+#define R_AL	-2 // (ALLY) pals. Good alternative to R_NO when applicable.
+#define R_FR	-1// (FEAR)will run
+#define	R_NO	0// (NO RELATIONSHIP) disregard
+#define R_DL	1// (DISLIKE) will attack
+#define R_HT	2// (HATE)will attack this character instead of any visible DISLIKEd characters
+#define R_NM	3// (NEMESIS)  A monster Will ALWAYS attack its nemsis, no matter what
+
+
+// these bits represent the monster's memory
+#define MEMORY_CLEAR					0
+#define bits_MEMORY_PROVOKED			( 1 << 0 )// right now only used for houndeyes.
+#define bits_MEMORY_INCOVER				( 1 << 1 )// monster knows it is in a covered position.
+#define bits_MEMORY_SUSPICIOUS			( 1 << 2 )// Ally is suspicious of the player, and will move to provoked more easily
+#define bits_MEMORY_PATH_FINISHED		( 1 << 3 )// Finished monster path (just used by big momma for now)
+#define bits_MEMORY_ON_PATH				( 1 << 4 )// Moving on a path
+#define bits_MEMORY_MOVE_FAILED			( 1 << 5 )// Movement has already failed
+#define bits_MEMORY_FLINCHED			( 1 << 6 )// Has already flinched
+#define bits_MEMORY_KILLED				( 1 << 7 )// HACKHACK -- remember that I've already called my Killed()
+#define bits_MEMORY_CUSTOM4				( 1 << 28 )	// Monster-specific memory
+#define bits_MEMORY_CUSTOM3				( 1 << 29 )	// Monster-specific memory
+#define bits_MEMORY_CUSTOM2				( 1 << 30 )	// Monster-specific memory
+#define bits_MEMORY_CUSTOM1				( 1 << 31 )	// Monster-specific memory
+
+// trigger conditions for scripted AI
+// these MUST match the CHOICES interface in halflife.fgd for the base monster
+enum 
+{
+	AITRIGGER_NONE = 0,
+	AITRIGGER_SEEPLAYER_ANGRY_AT_PLAYER,
+	AITRIGGER_TAKEDAMAGE,
+	AITRIGGER_HALFHEALTH,
+	AITRIGGER_DEATH,
+	AITRIGGER_SQUADMEMBERDIE,
+	AITRIGGER_SQUADLEADERDIE,
+	AITRIGGER_HEARWORLD,
+	AITRIGGER_HEARPLAYER,
+	AITRIGGER_HEARCOMBAT,
+	AITRIGGER_SEEPLAYER_UNCONDITIONAL,
+	AITRIGGER_SEEPLAYER_NOT_IN_COMBAT,
+};
+/*
+		0 : "No Trigger"
+		1 : "See Player"
+		2 : "Take Damage"
+		3 : "50% Health Remaining"
+		4 : "Death"
+		5 : "Squad Member Dead"
+		6 : "Squad Leader Dead"
+		7 : "Hear World"
+		8 : "Hear Player"
+		9 : "Hear Combat"
+*/
+
+//
+// A gib is a chunk of a body, or a piece of wood/metal/rocks/etc.
+//
+class CMGib : public CMBaseEntity
+{
+public:
+	void Spawn( const char *szGibModel );
+	void EXPORT BounceGibTouch ( edict_t *pOther );
+	void EXPORT StickyGibTouch ( edict_t *pOther );
+	void EXPORT WaitTillLand( void );
+	void		LimitVelocity( void );
+
+	virtual int	ObjectCaps( void ) { return (CMBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_DONT_SAVE; }
+	static	void SpawnHeadGib( entvars_t *pevVictim );
+	static	void SpawnRandomGibs( entvars_t *pevVictim, int cGibs, int human );
+	static  void SpawnStickyGibs( entvars_t *pevVictim, Vector vecOrigin, int cGibs );
+
+	int		m_bloodColor;
+	int		m_cBloodDecals;
+	int		m_material;
+	float	m_lifeTime;
+};
+
+
+#define CUSTOM_SCHEDULES\
+		virtual Schedule_t *ScheduleFromName( const char *pName );\
+		static Schedule_t *m_scheduleList[];
+
+#define DEFINE_CUSTOM_SCHEDULES(derivedClass)\
+	Schedule_t *derivedClass::m_scheduleList[] =
+
+#define IMPLEMENT_CUSTOM_SCHEDULES(derivedClass, baseClass)\
+		Schedule_t *derivedClass::ScheduleFromName( const char *pName )\
+		{\
+			Schedule_t *pSchedule = ScheduleInList( pName, m_scheduleList, ARRAYSIZE(m_scheduleList) );\
+			if ( !pSchedule )\
+				return baseClass::ScheduleFromName(pName);\
+			return pSchedule;\
+		}
+
+#endif	//MONSTERS_H

src/dlls/monsterstate.cpp

@@ -0,0 +1,214 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+//=========================================================
+// monsterstate.cpp - base class monster functions for 
+// controlling core AI.
+//=========================================================
+
+#include "extdll.h"
+#include "util.h"
+#include "cmbase.h"
+#include "cmbasemonster.h"
+#include "nodes.h"
+#include "monsters.h"
+#include "animation.h"
+
+//=========================================================
+// SetState
+//=========================================================
+void CMBaseMonster :: SetState ( MONSTERSTATE State )
+{
+/*
+	if ( State != m_MonsterState )
+	{
+		ALERT ( at_aiconsole, "State Changed to %d\n", State );
+	}
+*/
+	
+	switch( State )
+	{
+	
+	// Drop enemy pointers when going to idle
+	case MONSTERSTATE_IDLE:
+
+		if (( m_hEnemy != NULL ) &&
+			 ( strcmp(STRING(pev->model), "models/scientist.mdl") != 0))
+		{
+			m_hEnemy = NULL;// not allowed to have an enemy anymore.
+			ALERT ( at_aiconsole, "Stripped\n" );
+		}
+		break;
+	}
+
+	m_MonsterState = State;
+	m_IdealMonsterState = State;
+}
+
+//=========================================================
+// RunAI
+//=========================================================
+void CMBaseMonster :: RunAI ( void )
+{
+	// to test model's eye height
+	//UTIL_ParticleEffect ( pev->origin + pev->view_ofs, g_vecZero, 255, 10 );
+
+	// IDLE sound permitted in ALERT state is because monsters were silent in ALERT state. Only play IDLE sound in IDLE state
+	// once we have sounds for that state.
+	if ( ( m_MonsterState == MONSTERSTATE_IDLE || m_MonsterState == MONSTERSTATE_ALERT ) && RANDOM_LONG(0,99) == 0 && !(pev->flags & SF_MONSTER_GAG) )
+	{
+		IdleSound();
+	}
+
+	if ( m_MonsterState != MONSTERSTATE_NONE	&& 
+		 m_MonsterState != MONSTERSTATE_PRONE   && 
+		 m_MonsterState != MONSTERSTATE_DEAD )// don't bother with this crap if monster is prone. 
+	{
+		// collect some sensory Condition information.
+		// don't let monsters outside of the player's PVS act up, or most of the interesting
+		// things will happen before the player gets there!
+		// UPDATE: We now let COMBAT state monsters think and act fully outside of player PVS. This allows the player to leave 
+		// an area where monsters are fighting, and the fight will continue.
+		if ( !FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) || ( m_MonsterState == MONSTERSTATE_COMBAT ) )
+		{
+			Look( m_flDistLook );
+//jlb			Listen();// check for audible sounds. 
+
+			// now filter conditions.
+			ClearConditions( IgnoreConditions() );
+
+			GetEnemy();
+		}
+
+		// do these calculations if monster has an enemy.
+		if ( m_hEnemy != NULL )
+		{
+			CheckEnemy( m_hEnemy );
+		}
+
+		CheckAmmo();
+	}
+
+	FCheckAITrigger();
+
+	PrescheduleThink();
+
+	MaintainSchedule();
+
+	// if the monster didn't use these conditions during the above call to MaintainSchedule() or CheckAITrigger()
+	// we throw them out cause we don't want them sitting around through the lifespan of a schedule
+	// that doesn't use them. 
+	m_afConditions &= ~( bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE );
+}
+
+//=========================================================
+// GetIdealState - surveys the Conditions information available
+// and finds the best new state for a monster.
+//=========================================================
+MONSTERSTATE CMBaseMonster :: GetIdealState ( void )
+{
+	int	iConditions;
+
+	iConditions = IScheduleFlags();
+	
+	// If no schedule conditions, the new ideal state is probably the reason we're in here.
+	switch ( m_MonsterState )
+	{
+	case MONSTERSTATE_IDLE:
+		
+		/*
+		IDLE goes to ALERT upon hearing a sound
+		-IDLE goes to ALERT upon being injured
+		IDLE goes to ALERT upon seeing food
+		-IDLE goes to COMBAT upon sighting an enemy
+		IDLE goes to HUNT upon smelling food
+		*/
+		{
+			if ( iConditions & bits_COND_NEW_ENEMY )			
+			{
+				// new enemy! This means an idle monster has seen someone it dislikes, or 
+				// that a monster in combat has found a more suitable target to attack
+				m_IdealMonsterState = MONSTERSTATE_COMBAT;
+			}
+			else if ( iConditions & bits_COND_LIGHT_DAMAGE )
+			{
+				MakeIdealYaw ( m_vecEnemyLKP );
+				m_IdealMonsterState = MONSTERSTATE_ALERT;
+			}
+			else if ( iConditions & bits_COND_HEAVY_DAMAGE )
+			{
+				MakeIdealYaw ( m_vecEnemyLKP );
+				m_IdealMonsterState = MONSTERSTATE_ALERT;
+			}
+			else if ( iConditions & bits_COND_HEAR_SOUND )
+			{
+			}
+			else if ( iConditions & (bits_COND_SMELL | bits_COND_SMELL_FOOD) )
+			{
+				m_IdealMonsterState = MONSTERSTATE_ALERT;
+			}
+
+			break;
+		}
+	case MONSTERSTATE_ALERT:
+		/*
+		ALERT goes to IDLE upon becoming bored
+		-ALERT goes to COMBAT upon sighting an enemy
+		ALERT goes to HUNT upon hearing a noise
+		*/
+		{
+			if ( iConditions & (bits_COND_NEW_ENEMY|bits_COND_SEE_ENEMY) )			
+			{
+				// see an enemy we MUST attack
+				m_IdealMonsterState = MONSTERSTATE_COMBAT;
+			}
+			else if ( iConditions & bits_COND_HEAR_SOUND )
+			{
+				m_IdealMonsterState = MONSTERSTATE_ALERT;
+			}
+			break;
+		}
+	case MONSTERSTATE_COMBAT:
+		/*
+		COMBAT goes to HUNT upon losing sight of enemy
+		COMBAT goes to ALERT upon death of enemy
+		*/
+		{
+			if ( m_hEnemy == NULL )
+			{
+				m_IdealMonsterState = MONSTERSTATE_ALERT;
+				// pev->effects = EF_BRIGHTFIELD;
+				ALERT ( at_aiconsole, "***Combat state with no enemy!\n" );
+			}
+			break;
+		}
+	case MONSTERSTATE_HUNT:
+		/*
+		HUNT goes to ALERT upon seeing food
+		HUNT goes to ALERT upon being injured
+		HUNT goes to IDLE if goal touched
+		HUNT goes to COMBAT upon seeing enemy
+		*/
+		{
+			break;
+		}
+
+	case MONSTERSTATE_DEAD:
+		m_IdealMonsterState = MONSTERSTATE_DEAD;
+		break;
+	}
+
+	return m_IdealMonsterState;
+}
+

src/dlls/nodes.h

@@ -0,0 +1,374 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+//=========================================================
+// nodes.h
+//=========================================================
+
+//=========================================================
+// DEFINE
+//=========================================================
+#define MAX_STACK_NODES	    100
+#define	NO_NODE				-1
+#define MAX_NODE_HULLS		4
+
+#define bits_NODE_LAND      ( 1 << 0 )  // Land node, so nudge if necessary.
+#define bits_NODE_AIR       ( 1 << 1 )  // Air node, don't nudge.
+#define bits_NODE_WATER     ( 1 << 2 )  // Water node, don't nudge.
+#define bits_NODE_GROUP_REALM (bits_NODE_LAND | bits_NODE_AIR | bits_NODE_WATER)
+
+//=========================================================
+// Instance of a node.
+//=========================================================
+class CNode
+{
+public:
+	Vector	m_vecOrigin;// location of this node in space
+	Vector  m_vecOriginPeek; // location of this node (LAND nodes are NODE_HEIGHT higher).
+	BYTE    m_Region[3]; // Which of 256 regions do each of the coordinate belong?
+	int		m_afNodeInfo;// bits that tell us more about this location
+	
+	int		m_cNumLinks; // how many links this node has
+	int		m_iFirstLink;// index of this node's first link in the link pool.
+
+	// Where to start looking in the compressed routing table (offset into m_pRouteInfo).
+	// (4 hull sizes -- smallest to largest + fly/swim), and secondly, door capability.
+	//
+	int		m_pNextBestNode[MAX_NODE_HULLS][2];
+
+	// Used in finding the shortest path. m_fClosestSoFar is -1 if not visited.
+	// Then it is the distance to the source. If another path uses this node
+	// and has a closer distance, then m_iPreviousNode is also updated.
+	//
+	float   m_flClosestSoFar; // Used in finding the shortest path.
+	int		m_iPreviousNode;
+
+	short	m_sHintType;// there is something interesting in the world at this node's position
+	short	m_sHintActivity;// there is something interesting in the world at this node's position
+	float	m_flHintYaw;// monster on this node should face this yaw to face the hint.
+};
+
+//=========================================================
+// CLink - A link between 2 nodes
+//=========================================================
+#define		bits_LINK_SMALL_HULL	( 1 << 0 )// headcrab box can fit through this connection
+#define		bits_LINK_HUMAN_HULL	( 1 << 1 )// player box can fit through this connection
+#define		bits_LINK_LARGE_HULL	( 1 << 2 )// big box can fit through this connection
+#define		bits_LINK_FLY_HULL		( 1 << 3 )// a flying big box can fit through this connection
+#define		bits_LINK_DISABLED		( 1 << 4 )// link is not valid when the set
+
+#define		NODE_SMALL_HULL			0
+#define		NODE_HUMAN_HULL			1
+#define		NODE_LARGE_HULL			2
+#define		NODE_FLY_HULL			3
+
+class CLink
+{
+public:
+	int		m_iSrcNode;// the node that 'owns' this link ( keeps us from having to make reverse lookups )
+	int		m_iDestNode;// the node on the other end of the link. 
+	
+	entvars_t	*m_pLinkEnt;// the entity that blocks this connection (doors, etc)
+
+	// m_szLinkEntModelname is not necessarily NULL terminated (so we can store it in a more alignment-friendly 4 bytes)
+	char	m_szLinkEntModelname[ 4 ];// the unique name of the brush model that blocks the connection (this is kept for save/restore)
+
+	int		m_afLinkInfo;// information about this link
+	float	m_flWeight;// length of the link line segment
+};
+
+
+typedef struct
+{
+	int m_SortedBy[3];
+	int m_CheckedEvent;
+} DIST_INFO;
+
+typedef struct
+{
+	Vector v;
+	short n;		// Nearest node or -1 if no node found.
+} CACHE_ENTRY;
+
+//=========================================================
+// CGraph 
+//=========================================================
+#define	GRAPH_VERSION	(int)16// !!!increment this whever graph/node/link classes change, to obsolesce older disk files.
+class CGraph
+{
+public:
+
+// the graph has two flags, and should not be accessed unless both flags are TRUE!
+	BOOL	m_fGraphPresent;// is the graph in memory?
+	BOOL	m_fGraphPointersSet;// are the entity pointers for the graph all set?
+	BOOL    m_fRoutingComplete; // are the optimal routes computed, yet?
+
+	CNode	*m_pNodes;// pointer to the memory block that contains all node info
+	CLink	*m_pLinkPool;// big list of all node connections
+	char    *m_pRouteInfo; // compressed routing information the nodes use.
+
+	int		m_cNodes;// total number of nodes
+	int		m_cLinks;// total number of links
+	int     m_nRouteInfo; // size of m_pRouteInfo in bytes.
+
+	// Tables for making nearest node lookup faster. SortedBy provided nodes in a
+	// order of a particular coordinate. Instead of doing a binary search, RangeStart
+	// and RangeEnd let you get to the part of SortedBy that you are interested in.
+	//
+	// Once you have a point of interest, the only way you'll find a closer point is
+	// if at least one of the coordinates is closer than the ones you have now. So we
+	// search each range. After the search is exhausted, we know we have the closest
+	// node.
+	//
+#define CACHE_SIZE 128
+#define NUM_RANGES 256
+	DIST_INFO *m_di;	// This is m_cNodes long, but the entries don't correspond to CNode entries.
+	int m_RangeStart[3][NUM_RANGES];
+	int m_RangeEnd[3][NUM_RANGES];
+	float m_flShortest;
+	int m_iNearest;
+	int m_minX, m_minY, m_minZ, m_maxX, m_maxY, m_maxZ;
+	int m_minBoxX, m_minBoxY, m_minBoxZ, m_maxBoxX, m_maxBoxY, m_maxBoxZ;
+	int m_CheckedCounter;
+	float m_RegionMin[3], m_RegionMax[3]; // The range of nodes.
+	CACHE_ENTRY m_Cache[CACHE_SIZE];
+
+
+	int m_HashPrimes[16];
+	short *m_pHashLinks;
+	int m_nHashLinks;
+
+
+	// kinda sleazy. In order to allow variety in active idles for monster groups in a room with more than one node, 
+	// we keep track of the last node we searched from and store it here. Subsequent searches by other monsters will pick
+	// up where the last search stopped.
+	int		m_iLastActiveIdleSearch;
+
+	// another such system used to track the search for cover nodes, helps greatly with two monsters trying to get to the same node.
+	int		m_iLastCoverSearch;
+
+	// functions to create the graph
+	int		LinkVisibleNodes ( CLink *pLinkPool, FILE *file, int *piBadNode );
+	int		RejectInlineLinks ( CLink *pLinkPool, FILE *file );
+	int		FindShortestPath ( int *piPath, int iStart, int iDest, int iHull, int afCapMask);
+	int		FindNearestNode ( const Vector &vecOrigin, CMBaseEntity *pEntity );
+	int		FindNearestNode ( const Vector &vecOrigin, int afNodeTypes );
+	//int		FindNearestLink ( const Vector &vecTestPoint, int *piNearestLink, BOOL *pfAlongLine );
+	float	PathLength( int iStart, int iDest, int iHull, int afCapMask );
+	int		NextNodeInRoute( int iCurrentNode, int iDest, int iHull, int iCap );
+
+	enum NODEQUERY { NODEGRAPH_DYNAMIC, NODEGRAPH_STATIC };
+	// A static query means we're asking about the possiblity of handling this entity at ANY time
+	// A dynamic query means we're asking about it RIGHT NOW.  So we should query the current state
+	int		HandleLinkEnt ( int iNode, entvars_t *pevLinkEnt, int afCapMask, NODEQUERY queryType );
+	entvars_t*	LinkEntForLink ( CLink *pLink, CNode *pNode );
+	void	ShowNodeConnections ( int iNode );
+	void	InitGraph( void );
+	int		AllocNodes ( void );
+	
+	int		CheckNODFile(char *szMapName);
+	int		FLoadGraph(char *szMapName);
+	int		FSaveGraph(char *szMapName);
+	int		FSetGraphPointers(void);
+	void	CheckNode(Vector vecOrigin, int iNode);
+
+	void    BuildRegionTables(void);
+	void    ComputeStaticRoutingTables(void);
+	void    TestRoutingTables(void);
+
+	void	HashInsert(int iSrcNode, int iDestNode, int iKey);
+	void    HashSearch(int iSrcNode, int iDestNode, int &iKey);
+	void	HashChoosePrimes(int TableSize);
+	void    BuildLinkLookups(void);
+
+	void    SortNodes(void);
+
+	int			HullIndex( const CMBaseEntity *pEntity );	// what hull the monster uses
+	int			NodeType( const CMBaseEntity *pEntity );		// what node type the monster uses
+	inline int	CapIndex( int afCapMask ) 
+	{ 
+		if (afCapMask & (bits_CAP_OPEN_DOORS | bits_CAP_AUTO_DOORS | bits_CAP_USE)) 
+			return 1; 
+		return 0; 
+	}
+
+
+	inline	CNode &Node( int i )
+	{
+#ifdef _DEBUG
+		if ( !m_pNodes || i < 0 || i > m_cNodes )
+			ALERT( at_error, "Bad Node!\n" );
+#endif
+		return m_pNodes[i];
+	}
+
+	inline	CLink &Link( int i )
+	{
+#ifdef _DEBUG
+		if ( !m_pLinkPool || i < 0 || i > m_cLinks )
+			ALERT( at_error, "Bad link!\n" );
+#endif
+		return m_pLinkPool[i];
+	}
+	
+	inline CLink &NodeLink( int iNode, int iLink )
+	{
+		return Link( Node( iNode ).m_iFirstLink + iLink );
+	}
+
+	inline CLink &NodeLink( const CNode &node, int iLink )
+	{
+		return Link( node.m_iFirstLink + iLink );
+	}
+
+	inline  int	INodeLink ( int iNode, int iLink )
+	{
+		return NodeLink( iNode, iLink ).m_iDestNode;
+	}
+
+#if 0
+	inline CNode &SourceNode( int iNode, int iLink )
+	{
+		return Node( NodeLink( iNode, iLink ).m_iSrcNode );
+	}
+
+	inline CNode &DestNode( int iNode, int iLink )
+	{
+		return Node( NodeLink( iNode, iLink ).m_iDestNode );
+	}
+
+	inline	CNode *PNodeLink ( int iNode, int iLink ) 
+	{
+		return &DestNode( iNode, iLink );
+	}
+#endif
+};
+
+//=========================================================
+// Nodes start out as ents in the level. The node graph 
+// is built, then these ents are discarded. 
+//=========================================================
+class CNodeEnt : public CMBaseEntity
+{
+	void Spawn( void );
+	void KeyValue( KeyValueData *pkvd );
+	virtual int	ObjectCaps( void ) { return CMBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
+
+	short m_sHintType;
+	short m_sHintActivity;
+};
+
+
+//=========================================================
+// CStack - last in, first out.
+//=========================================================
+class CStack 
+{
+public:
+			CStack( void );
+	void	Push( int value );
+	int		Pop( void );
+	int		Top( void );
+	int		Empty( void ) { return m_level==0; }
+	int		Size( void ) { return m_level; }
+	void    CopyToArray ( int *piArray );
+
+private:
+	int		m_stack[ MAX_STACK_NODES ];
+	int		m_level;
+};
+
+
+//=========================================================
+// CQueue - first in, first out.
+//=========================================================
+class CQueue
+{
+public:
+
+	CQueue( void );// constructor
+	inline int Full ( void ) { return ( m_cSize == MAX_STACK_NODES ); }
+	inline int Empty ( void ) { return ( m_cSize == 0 ); }
+	//inline int Tail ( void ) { return ( m_queue[ m_tail ] ); }
+	inline int Size ( void ) { return ( m_cSize ); }
+	void Insert( int, float );
+	int Remove( float & );
+
+private:
+	int	m_cSize;
+    struct tag_QUEUE_NODE
+    {
+        int   Id;
+        float Priority;
+    } m_queue[ MAX_STACK_NODES ];
+	int m_head;
+	int m_tail;
+};
+
+//=========================================================
+// CQueuePriority - Priority queue (smallest item out first).
+//
+//=========================================================
+class CQueuePriority
+{
+public:
+
+	CQueuePriority( void );// constructor
+	inline int Full ( void ) { return ( m_cSize == MAX_STACK_NODES ); }
+	inline int Empty ( void ) { return ( m_cSize == 0 ); }
+	//inline int Tail ( float & ) { return ( m_queue[ m_tail ].Id ); }
+	inline int Size ( void ) { return ( m_cSize ); }
+	void Insert( int, float );
+	int Remove( float &);
+
+private:
+	int	m_cSize;
+    struct tag_HEAP_NODE
+    {
+        int   Id;
+        float Priority;
+    } m_heap[ MAX_STACK_NODES ];
+	void Heap_SiftDown(int);
+	void Heap_SiftUp(void);
+
+};
+
+//=========================================================
+// hints - these MUST coincide with the HINTS listed under
+// info_node in the FGD file!
+//=========================================================
+enum
+{
+	HINT_NONE = 0,
+	HINT_WORLD_DOOR,
+	HINT_WORLD_WINDOW,
+	HINT_WORLD_BUTTON,
+	HINT_WORLD_MACHINERY,
+	HINT_WORLD_LEDGE,
+	HINT_WORLD_LIGHT_SOURCE,
+	HINT_WORLD_HEAT_SOURCE,
+	HINT_WORLD_BLINKING_LIGHT,
+	HINT_WORLD_BRIGHT_COLORS,
+	HINT_WORLD_HUMAN_BLOOD,
+	HINT_WORLD_ALIEN_BLOOD,
+
+	HINT_TACTICAL_EXIT = 100,
+	HINT_TACTICAL_VANTAGE,
+	HINT_TACTICAL_AMBUSH,
+
+	HINT_STUKA_PERCH = 300,
+	HINT_STUKA_LANDING,
+};
+
+extern CGraph WorldGraph;

src/dlls/plane.h

@@ -0,0 +1,43 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef PLANE_H
+#define PLANE_H
+
+//=========================================================
+// Plane
+//=========================================================
+class CPlane 
+{
+public:
+	CPlane ( void );
+
+	//=========================================================
+	// InitializePlane - Takes a normal for the plane and a
+	// point on the plane and 
+	//=========================================================
+	void InitializePlane ( const Vector &vecNormal, const Vector &vecPoint );
+
+	//=========================================================
+	// PointInFront - determines whether the given vector is 
+	// in front of the plane. 
+	//=========================================================
+	BOOL PointInFront ( const Vector &vecPoint );
+
+	Vector	m_vecNormal;
+	float	m_flDist;
+	BOOL	m_fInitialized;
+};
+
+#endif // PLANE_H

src/dlls/schedule.h

@@ -0,0 +1,290 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+//=========================================================
+// Scheduling 
+//=========================================================
+
+#ifndef	SCHEDULE_H
+#define	SCHEDULE_H
+
+#define	TASKSTATUS_NEW				0			// Just started
+#define TASKSTATUS_RUNNING			1			// Running task & movement
+#define TASKSTATUS_RUNNING_MOVEMENT	2			// Just running movement
+#define TASKSTATUS_RUNNING_TASK		3			// Just running task
+#define TASKSTATUS_COMPLETE			4			// Completed, get next task
+
+
+//=========================================================
+// These are the schedule types
+//=========================================================
+typedef enum 
+{
+		SCHED_NONE = 0,
+		SCHED_IDLE_STAND,
+		SCHED_IDLE_WALK,
+		SCHED_WAKE_ANGRY,
+		SCHED_WAKE_CALLED,
+		SCHED_ALERT_FACE,
+		SCHED_ALERT_SMALL_FLINCH,
+		SCHED_ALERT_BIG_FLINCH,
+		SCHED_ALERT_STAND,
+		SCHED_INVESTIGATE_SOUND,
+		SCHED_COMBAT_FACE,
+		SCHED_COMBAT_STAND,
+		SCHED_CHASE_ENEMY,
+		SCHED_CHASE_ENEMY_FAILED,
+		SCHED_VICTORY_DANCE,
+		SCHED_TARGET_FACE,
+		SCHED_TARGET_CHASE,
+		SCHED_SMALL_FLINCH,
+		SCHED_TAKE_COVER_FROM_ENEMY,
+		SCHED_TAKE_COVER_FROM_BEST_SOUND,
+		SCHED_TAKE_COVER_FROM_ORIGIN,
+		SCHED_COWER, // usually a last resort!
+		SCHED_MELEE_ATTACK1,
+		SCHED_MELEE_ATTACK2,
+		SCHED_RANGE_ATTACK1,
+		SCHED_RANGE_ATTACK2,
+		SCHED_SPECIAL_ATTACK1,
+		SCHED_SPECIAL_ATTACK2,
+		SCHED_STANDOFF,
+		SCHED_ARM_WEAPON,
+		SCHED_RELOAD,
+		SCHED_GUARD,
+		SCHED_AMBUSH,
+		SCHED_DIE,
+		SCHED_WAIT_TRIGGER,
+		SCHED_FOLLOW,
+		SCHED_SLEEP,
+		SCHED_WAKE,
+		SCHED_BARNACLE_VICTIM_GRAB,
+		SCHED_BARNACLE_VICTIM_CHOMP,
+		SCHED_AISCRIPT,
+		SCHED_FAIL,
+
+		LAST_COMMON_SCHEDULE			// Leave this at the bottom
+} SCHEDULE_TYPE;
+
+//=========================================================
+// These are the shared tasks
+//=========================================================
+typedef enum 
+{
+		TASK_INVALID = 0,
+		TASK_WAIT,
+		TASK_WAIT_FACE_ENEMY,
+		TASK_WAIT_PVS,
+		TASK_SUGGEST_STATE,
+		TASK_WALK_TO_TARGET,
+		TASK_RUN_TO_TARGET,
+		TASK_MOVE_TO_TARGET_RANGE,
+		TASK_GET_PATH_TO_ENEMY,
+		TASK_GET_PATH_TO_ENEMY_LKP,
+		TASK_GET_PATH_TO_ENEMY_CORPSE,
+		TASK_GET_PATH_TO_LEADER,
+		TASK_GET_PATH_TO_SPOT,
+		TASK_GET_PATH_TO_TARGET,
+		TASK_GET_PATH_TO_HINTNODE,
+		TASK_GET_PATH_TO_LASTPOSITION,
+		TASK_GET_PATH_TO_BESTSOUND,
+		TASK_GET_PATH_TO_BESTSCENT,
+		TASK_RUN_PATH,	
+		TASK_WALK_PATH,	
+		TASK_STRAFE_PATH,
+		TASK_CLEAR_MOVE_WAIT,
+		TASK_STORE_LASTPOSITION,
+		TASK_CLEAR_LASTPOSITION,
+		TASK_PLAY_ACTIVE_IDLE,
+		TASK_FIND_HINTNODE,
+		TASK_CLEAR_HINTNODE,
+		TASK_SMALL_FLINCH,
+		TASK_FACE_IDEAL,
+		TASK_FACE_ROUTE,
+		TASK_FACE_ENEMY,
+		TASK_FACE_HINTNODE,
+		TASK_FACE_TARGET,
+		TASK_FACE_LASTPOSITION,
+		TASK_RANGE_ATTACK1,
+		TASK_RANGE_ATTACK2,		
+		TASK_MELEE_ATTACK1,		
+		TASK_MELEE_ATTACK2,		
+		TASK_RELOAD,
+		TASK_RANGE_ATTACK1_NOTURN,
+		TASK_RANGE_ATTACK2_NOTURN,		
+		TASK_MELEE_ATTACK1_NOTURN,		
+		TASK_MELEE_ATTACK2_NOTURN,		
+		TASK_RELOAD_NOTURN,
+		TASK_SPECIAL_ATTACK1,
+		TASK_SPECIAL_ATTACK2,
+		TASK_CROUCH,
+		TASK_STAND,
+		TASK_GUARD,
+		TASK_STEP_LEFT,
+		TASK_STEP_RIGHT,
+		TASK_STEP_FORWARD,
+		TASK_STEP_BACK,
+		TASK_DODGE_LEFT,
+		TASK_DODGE_RIGHT,
+		TASK_SOUND_ANGRY,
+		TASK_SOUND_DEATH,
+		TASK_SET_ACTIVITY,
+		TASK_SET_SCHEDULE,
+		TASK_SET_FAIL_SCHEDULE,
+		TASK_CLEAR_FAIL_SCHEDULE,
+		TASK_PLAY_SEQUENCE,
+		TASK_PLAY_SEQUENCE_FACE_ENEMY,
+		TASK_PLAY_SEQUENCE_FACE_TARGET,
+		TASK_SOUND_IDLE,
+		TASK_SOUND_WAKE,
+		TASK_SOUND_PAIN,
+		TASK_SOUND_DIE,
+		TASK_FIND_COVER_FROM_BEST_SOUND,// tries lateral cover first, then node cover
+		TASK_FIND_COVER_FROM_ENEMY,// tries lateral cover first, then node cover
+		TASK_FIND_LATERAL_COVER_FROM_ENEMY,
+		TASK_FIND_NODE_COVER_FROM_ENEMY,
+		TASK_FIND_NEAR_NODE_COVER_FROM_ENEMY,// data for this one is the MAXIMUM acceptable distance to the cover.
+		TASK_FIND_FAR_NODE_COVER_FROM_ENEMY,// data for this one is there MINIMUM aceptable distance to the cover.
+		TASK_FIND_COVER_FROM_ORIGIN,
+		TASK_EAT,
+		TASK_DIE,
+		TASK_WAIT_FOR_SCRIPT,
+		TASK_PLAY_SCRIPT,
+		TASK_ENABLE_SCRIPT,
+		TASK_PLANT_ON_SCRIPT,
+		TASK_FACE_SCRIPT,
+		TASK_WAIT_RANDOM,
+		TASK_WAIT_INDEFINITE,
+		TASK_STOP_MOVING,
+		TASK_TURN_LEFT,
+		TASK_TURN_RIGHT,
+		TASK_REMEMBER,
+		TASK_FORGET,
+		TASK_WAIT_FOR_MOVEMENT,			// wait until MovementIsComplete()
+		LAST_COMMON_TASK, // LEAVE THIS AT THE BOTTOM!! (sjb)
+} SHARED_TASKS;
+
+
+// These go in the flData member of the TASK_WALK_TO_TARGET, TASK_RUN_TO_TARGET
+enum 
+{
+	TARGET_MOVE_NORMAL = 0,
+	TARGET_MOVE_SCRIPTED = 1,
+};
+
+
+// A goal should be used for a task that requires several schedules to complete.  
+// The goal index should indicate which schedule (ordinally) the monster is running.  
+// That way, when tasks fail, the AI can make decisions based on the context of the 
+// current goal and sequence rather than just the current schedule.
+enum
+{
+	GOAL_ATTACK_ENEMY,
+	GOAL_MOVE,
+	GOAL_TAKE_COVER,
+	GOAL_MOVE_TARGET,
+	GOAL_EAT,
+};
+
+// an array of tasks is a task list
+// an array of schedules is a schedule list
+struct Task_t
+{
+
+	int		iTask;
+	float	flData;
+};
+
+struct Schedule_t
+{
+
+	Task_t	*pTasklist;
+	int		cTasks;	 
+	int		iInterruptMask;// a bit mask of conditions that can interrupt this schedule 
+	
+	// a more specific mask that indicates which TYPES of sounds will interrupt the schedule in the 
+	// event that the schedule is broken by COND_HEAR_SOUND
+	int		iSoundMask;
+	const	char *pName;
+};
+
+// an array of waypoints makes up the monster's route. 
+// !!!LATER- this declaration doesn't belong in this file.
+struct WayPoint_t
+{
+	Vector	vecLocation;
+	int		iType;
+};
+
+// these MoveFlag values are assigned to a WayPoint's TYPE in order to demonstrate the 
+// type of movement the monster should use to get there.
+#define bits_MF_TO_TARGETENT		( 1 << 0 ) // local move to targetent.
+#define bits_MF_TO_ENEMY			( 1 << 1 ) // local move to enemy
+#define bits_MF_TO_COVER			( 1 << 2 ) // local move to a hiding place
+#define bits_MF_TO_DETOUR			( 1 << 3 ) // local move to detour point.
+#define bits_MF_TO_PATHCORNER		( 1 << 4 ) // local move to a path corner
+#define bits_MF_TO_NODE				( 1 << 5 ) // local move to a node
+#define bits_MF_TO_LOCATION			( 1 << 6 ) // local move to an arbitrary point
+#define bits_MF_IS_GOAL				( 1 << 7 ) // this waypoint is the goal of the whole move.
+#define bits_MF_DONT_SIMPLIFY		( 1 << 8 ) // Don't let the route code simplify this waypoint
+
+// If you define any flags that aren't _TO_ flags, add them here so we can mask
+// them off when doing compares.
+#define bits_MF_NOT_TO_MASK (bits_MF_IS_GOAL | bits_MF_DONT_SIMPLIFY)
+
+#define MOVEGOAL_NONE				(0)
+#define MOVEGOAL_TARGETENT			(bits_MF_TO_TARGETENT)
+#define MOVEGOAL_ENEMY				(bits_MF_TO_ENEMY)
+#define MOVEGOAL_PATHCORNER			(bits_MF_TO_PATHCORNER)
+#define MOVEGOAL_LOCATION			(bits_MF_TO_LOCATION)
+#define MOVEGOAL_NODE				(bits_MF_TO_NODE)
+
+// these bits represent conditions that may befall the monster, of which some are allowed 
+// to interrupt certain schedules. 
+#define bits_COND_NO_AMMO_LOADED		( 1 << 0 ) // weapon needs to be reloaded!
+#define	bits_COND_SEE_HATE				( 1 << 1 ) // see something that you hate
+#define bits_COND_SEE_FEAR				( 1 << 2 ) // see something that you are afraid of
+#define bits_COND_SEE_DISLIKE			( 1 << 3 ) // see something that you dislike
+#define bits_COND_SEE_ENEMY				( 1 << 4 ) // target entity is in full view.
+#define bits_COND_ENEMY_OCCLUDED		( 1 << 5 ) // target entity occluded by the world
+#define bits_COND_SMELL_FOOD			( 1 << 6 )
+#define bits_COND_ENEMY_TOOFAR			( 1 << 7 )
+#define bits_COND_LIGHT_DAMAGE			( 1 << 8 ) // hurt a little 
+#define bits_COND_HEAVY_DAMAGE			( 1 << 9 ) // hurt a lot
+#define bits_COND_CAN_RANGE_ATTACK1		( 1 << 10)
+#define bits_COND_CAN_MELEE_ATTACK1		( 1 << 11)
+#define bits_COND_CAN_RANGE_ATTACK2		( 1 << 12)
+#define bits_COND_CAN_MELEE_ATTACK2		( 1 << 13)
+// #define bits_COND_CAN_RANGE_ATTACK3		( 1 << 14)
+#define bits_COND_PROVOKED				( 1 << 15)
+#define bits_COND_NEW_ENEMY				( 1 << 16)
+#define bits_COND_HEAR_SOUND			( 1 << 17) // there is an interesting sound
+#define bits_COND_SMELL					( 1 << 18) // there is an interesting scent
+#define bits_COND_ENEMY_FACING_ME		( 1 << 19) // enemy is facing me
+#define bits_COND_ENEMY_DEAD			( 1 << 20) // enemy was killed. If you get this in combat, try to find another enemy. If you get it in alert, victory dance.
+#define bits_COND_SEE_CLIENT			( 1 << 21) // see a client
+#define bits_COND_SEE_NEMESIS			( 1 << 22) // see my nemesis
+
+#define bits_COND_SPECIAL1				( 1 << 28) // Defined by individual monster
+#define bits_COND_SPECIAL2				( 1 << 29) // Defined by individual monster
+
+#define bits_COND_TASK_FAILED			( 1 << 30)
+#define bits_COND_SCHEDULE_DONE			( 1 << 31)
+
+
+#define bits_COND_ALL_SPECIAL			(bits_COND_SPECIAL1 | bits_COND_SPECIAL2)
+
+#define bits_COND_CAN_ATTACK			(bits_COND_CAN_RANGE_ATTACK1 | bits_COND_CAN_MELEE_ATTACK1 | bits_COND_CAN_RANGE_ATTACK2 | bits_COND_CAN_MELEE_ATTACK2)
+
+#endif	// SCHEDULE_H

src/dlls/skill.cpp

@@ -0,0 +1,254 @@
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifndef __linux__
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
+#include	"extdll.h"
+#include "dllapi.h"
+#include "meta_api.h"
+#include	"skill.h"
+
+extern cvar_t *dllapi_log;
+
+skilldata_t	gSkillData;
+
+struct skill_cfg_t
+{
+   char *name;
+   float *value;
+};
+
+skill_cfg_t skill_cfg[] = {
+   {"sk_agrunt_health", &gSkillData.agruntHealth},
+   {"sk_agrunt_dmg_punch", &gSkillData.agruntDmgPunch},
+   {"sk_apache_health", &gSkillData.apacheHealth},
+   {"sk_barney_health", &gSkillData.barneyHealth},
+   {"sk_bigmomma_health_factor", &gSkillData.bigmommaHealthFactor},
+   {"sk_bigmomma_dmg_slash", &gSkillData.bigmommaDmgSlash},
+   {"sk_bigmomma_dmg_blast", &gSkillData.bigmommaDmgBlast},
+   {"sk_bigmomma_radius_blast", &gSkillData.bigmommaRadiusBlast},
+   {"sk_bullsquid_health", &gSkillData.bullsquidHealth},
+   {"sk_bullsquid_dmg_bite", &gSkillData.bullsquidDmgBite},
+   {"sk_bullsquid_dmg_whip", &gSkillData.bullsquidDmgWhip},
+   {"sk_bullsquid_dmg_spit", &gSkillData.bullsquidDmgSpit},
+   {"sk_gargantua_health", &gSkillData.gargantuaHealth},
+   {"sk_gargantua_dmg_slash", &gSkillData.gargantuaDmgSlash},
+   {"sk_gargantua_dmg_fire", &gSkillData.gargantuaDmgFire},
+   {"sk_gargantua_dmg_stomp", &gSkillData.gargantuaDmgStomp},
+   {"sk_hassassin_health", &gSkillData.hassassinHealth},
+   {"sk_headcrab_health", &gSkillData.headcrabHealth},
+   {"sk_headcrab_dmg_bite", &gSkillData.headcrabDmgBite},
+   {"sk_hgrunt_health", &gSkillData.hgruntHealth},
+   {"sk_hgrunt_kick", &gSkillData.hgruntDmgKick},
+   {"sk_hgrunt_pellets", &gSkillData.hgruntShotgunPellets},
+   {"sk_hgrunt_gspeed", &gSkillData.hgruntGrenadeSpeed},
+   {"sk_houndeye_health", &gSkillData.houndeyeHealth},
+   {"sk_houndeye_dmg_blast", &gSkillData.houndeyeDmgBlast},
+   {"sk_islave_health", &gSkillData.slaveHealth},
+   {"sk_islave_dmg_claw", &gSkillData.slaveDmgClaw},
+   {"sk_islave_dmg_clawrake", &gSkillData.slaveDmgClawrake},
+   {"sk_islave_dmg_zap", &gSkillData.slaveDmgZap},
+   {"sk_ichthyosaur_health", &gSkillData.ichthyosaurHealth},
+   {"sk_ichthyosaur_shake", &gSkillData.ichthyosaurDmgShake},
+   {"sk_leech_health", &gSkillData.leechHealth},
+   {"sk_leech_dmg_bite", &gSkillData.leechDmgBite},
+   {"sk_controller_health", &gSkillData.controllerHealth},
+   {"sk_controller_dmgzap", &gSkillData.controllerDmgZap},
+   {"sk_controller_speedball", &gSkillData.controllerSpeedBall},
+   {"sk_controller_dmgball", &gSkillData.controllerDmgBall},
+   {"sk_nihilanth_health", &gSkillData.nihilanthHealth},
+   {"sk_nihilanth_zap", &gSkillData.nihilanthZap},
+   {"sk_scientist_health", &gSkillData.scientistHealth},
+   {"sk_scientist_heal", &gSkillData.scientistHeal},
+   {"sk_snark_health", &gSkillData.snarkHealth},
+   {"sk_snark_dmg_bite", &gSkillData.snarkDmgBite},
+   {"sk_snark_dmg_pop", &gSkillData.snarkDmgPop},
+   {"sk_zombie_health", &gSkillData.zombieHealth},
+   {"sk_zombie_dmg_one_slash", &gSkillData.zombieDmgOneSlash},
+   {"sk_zombie_dmg_both_slash", &gSkillData.zombieDmgBothSlash},
+   {"sk_12mm_bullet", &gSkillData.monDmg9MM},
+   {"sk_9mmAR_bullet", &gSkillData.monDmgMP5},
+   {"sk_9mm_bullet", &gSkillData.monDmg12MM},
+   {"sk_9mmAR_grenade", &gSkillData.monDmgM203Grenade},
+   {"sk_hornet_dmg", &gSkillData.monDmgHornet},
+   {"", NULL}
+};
+
+bool get_input(FILE *fp, char *input);
+
+
+void scan_monster_skill(FILE *fp)
+{
+   char input[1024];
+   int index, len, pos;
+   bool found;
+
+   while (get_input(fp, input))
+   {
+      index = 0;
+      found = FALSE;
+
+      while (skill_cfg[index].name[0])
+      {
+         len = strlen(skill_cfg[index].name);
+         if (strncmp(input, skill_cfg[index].name, len) == 0)
+         {
+            found = TRUE;
+            pos = len;
+            sscanf(&input[pos], "%f", skill_cfg[index].value);
+
+            if (dllapi_log->value)
+               LOG_MESSAGE(PLID, "skill setting %s set to %f",
+                           skill_cfg[index].name, *skill_cfg[index].value);
+
+            break;
+         }
+         index++;
+      }
+
+      if (!found)
+      {
+         META_CONS("[MONSTER] ERROR: unknown monster_skill.cfg item: %s", input);
+         LOG_MESSAGE(PLID, "ERROR: unknown monster_skill.cfg item: %s", input);
+      }
+   }
+}
+
+
+void monster_skill_init(void)
+{
+   char game_dir[256];
+   char filename[256];
+   FILE *fp = NULL;
+
+	// Alien Grunt (agrunt)
+	gSkillData.agruntHealth = 90.0f;
+	gSkillData.agruntDmgPunch = 20.0f;
+
+	// Apache (apache)
+	gSkillData.apacheHealth = 250.0f;
+
+	// Barney (barney)
+	gSkillData.barneyHealth = 35.0f;
+
+	// Big momma
+	gSkillData.bigmommaHealthFactor = 1.5f;
+	gSkillData.bigmommaDmgSlash = 60.0f;
+	gSkillData.bigmommaDmgBlast = 120.0f;
+	gSkillData.bigmommaRadiusBlast = 250.0f;
+
+	// Bullsquid (bullsquid)
+	gSkillData.bullsquidHealth = 40.0f;
+	gSkillData.bullsquidDmgBite = 25.0f;
+	gSkillData.bullsquidDmgWhip = 35.0f;
+	gSkillData.bullsquidDmgSpit = 10.0f;
+
+	// Gargantua
+	gSkillData.gargantuaHealth = 800.0f;
+	gSkillData.gargantuaDmgSlash = 30.0f;
+	gSkillData.gargantuaDmgFire = 5.0f;
+	gSkillData.gargantuaDmgStomp = 100.0f;
+
+	// Hassassin (hassassin)
+	gSkillData.hassassinHealth = 50.0f;
+
+	// Headcrab (headcrab)
+	gSkillData.headcrabHealth = 10.0f;
+	gSkillData.headcrabDmgBite = 10.0f;
+
+	// Hgrunt (hgrunt)
+	gSkillData.hgruntHealth = 50.0f;
+	gSkillData.hgruntDmgKick = 10.0f;
+	gSkillData.hgruntShotgunPellets = 5.0f;
+	gSkillData.hgruntGrenadeSpeed = 600.0f;
+
+	// Houndeye (houndeye)
+	gSkillData.houndeyeHealth = 20.0f;
+	gSkillData.houndeyeDmgBlast = 15.0f;
+
+	// ISlave (islave)
+	gSkillData.slaveHealth = 30.0f;
+	gSkillData.slaveDmgClaw = 10.0f;
+	gSkillData.slaveDmgClawrake = 25.0f;
+	gSkillData.slaveDmgZap = 10.0f;
+
+	// Icthyosaur
+	gSkillData.ichthyosaurHealth = 200.0f;
+	gSkillData.ichthyosaurDmgShake = 35.0f;
+
+	// Leech
+	gSkillData.leechHealth = 2.0f;
+	gSkillData.leechDmgBite = 2.0f;
+
+	// Controller
+	gSkillData.controllerHealth = 60.0f;
+	gSkillData.controllerDmgZap = 25.0f;
+	gSkillData.controllerSpeedBall = 800.0f;
+	gSkillData.controllerDmgBall = 4.0f;
+
+	// Nihilanth
+	gSkillData.nihilanthHealth = 800.0f;
+	gSkillData.nihilanthZap = 30.0f;
+
+	// Scientist (scientist)
+	gSkillData.scientistHealth = 20.0f;
+	gSkillData.scientistHeal = 25.0f;
+
+	// Snark (snark)
+	gSkillData.snarkHealth = 2.0f;
+	gSkillData.snarkDmgBite = 10.0f;
+	gSkillData.snarkDmgPop = 5.0f;
+
+	// Zombie (zombie)
+	gSkillData.zombieHealth = 50.0f;
+	gSkillData.zombieDmgOneSlash = 20.0f;
+	gSkillData.zombieDmgBothSlash = 40.0f;
+
+	// MONSTER WEAPONS
+	gSkillData.monDmg9MM = 5.0f;
+	gSkillData.monDmgMP5 = 4.0f;
+	gSkillData.monDmg12MM = 10.0f;
+	gSkillData.monDmgM203Grenade = 100.0f;
+
+	// HORNET
+	gSkillData.monDmgHornet = 5.0f;
+
+
+   // find the directory name of the currently running MOD...
+   (*g_engfuncs.pfnGetGameDir)(game_dir);
+
+   strcpy(filename, game_dir);
+   strcat(filename, "/monster_skill.cfg");
+
+   // check if the map specific filename exists...
+   if (access(filename, 0) == 0)
+   {
+      if (dllapi_log->value)
+      {
+         META_CONS("[MONSTER] Processing monster skill file=%s", filename);
+         LOG_MESSAGE(PLID, "Processing monster skill file=%s", filename);
+      }
+
+      if ((fp = fopen(filename, "r")) == NULL)
+      {
+         META_CONS("[MONSTER] ERROR: Could not open \"%s\"!", filename);
+         LOG_MESSAGE(PLID, "ERROR: Could not open \"%s\"!", filename);
+      }
+
+      scan_monster_skill(fp);
+
+      fclose(fp);
+   }
+   else
+   {
+      META_CONS("[MONSTER] ERROR: Could not find \"%s\" (default skill used)", filename);
+      LOG_MESSAGE(PLID, "ERROR: Could not find \"%s\" (default skill used)", filename);
+   }
+}
+

src/dlls/skill.h

@@ -0,0 +1,103 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//=========================================================
+// skill.h - skill level concerns
+//=========================================================
+
+#ifndef SKILL_H
+#define SKILL_H
+
+struct skilldata_t
+{
+// Monster Health & Damage
+	float	agruntHealth;
+	float agruntDmgPunch;
+
+	float apacheHealth;
+	
+	float barneyHealth;
+
+	float bigmommaHealthFactor;		// Multiply each node's health by this
+	float bigmommaDmgSlash;			// melee attack damage
+	float bigmommaDmgBlast;			// mortar attack damage
+	float bigmommaRadiusBlast;		// mortar attack radius
+
+	float bullsquidHealth;
+	float bullsquidDmgBite;
+	float bullsquidDmgWhip;
+	float bullsquidDmgSpit;
+
+	float gargantuaHealth;
+	float gargantuaDmgSlash;
+	float gargantuaDmgFire;
+	float gargantuaDmgStomp;
+
+	float hassassinHealth;
+
+	float headcrabHealth;
+	float headcrabDmgBite;
+
+	float hgruntHealth;
+	float hgruntDmgKick;
+	float hgruntShotgunPellets;
+	float hgruntGrenadeSpeed;
+
+	float houndeyeHealth;
+	float houndeyeDmgBlast;
+
+	float slaveHealth;
+	float slaveDmgClaw;
+	float slaveDmgClawrake;
+	float slaveDmgZap;
+
+	float ichthyosaurHealth;
+	float ichthyosaurDmgShake;
+
+	float leechHealth;
+	float leechDmgBite;
+
+	float controllerHealth;
+	float controllerDmgZap;
+	float controllerSpeedBall;
+	float controllerDmgBall;
+
+	float nihilanthHealth;
+	float nihilanthZap;
+
+	float scientistHealth;
+	float scientistHeal;
+
+	float snarkHealth;
+	float snarkDmgBite;
+	float snarkDmgPop;
+
+	float zombieHealth;
+	float zombieDmgOneSlash;
+	float zombieDmgBothSlash;
+
+// weapons shared by monsters
+	float monDmg9MM;
+	float monDmgMP5;
+	float monDmg12MM;
+	float monDmgM203Grenade;
+
+	float monDmgHornet;
+};
+
+extern	DLL_GLOBAL	skilldata_t	gSkillData;
+
+void monster_skill_init(void);
+
+#endif

src/dlls/sound.cpp

@@ -0,0 +1,915 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//=========================================================
+// sound.cpp 
+//=========================================================
+
+#include "extdll.h"
+#include "util.h"
+#include "cmbase.h"
+#include "cmbasemonster.h"
+#include "weapons.h"
+#include "cmtalkmonster.h"
+#include "pm_materials.h"
+
+
+static char *memfgets( byte *pMemFile, int fileSize, int &filePos, char *pBuffer, int bufferSize );
+
+
+// ==================== GENERIC AMBIENT SOUND ======================================
+
+// runtime pitch shift and volume fadein/out structure
+
+// NOTE: IF YOU CHANGE THIS STRUCT YOU MUST CHANGE THE SAVE/RESTORE VERSION NUMBER
+// SEE BELOW (in the typedescription for the class)
+typedef struct dynpitchvol
+{
+	// NOTE: do not change the order of these parameters 
+	// NOTE: unless you also change order of rgdpvpreset array elements!
+	int preset;
+
+	int pitchrun;		// pitch shift % when sound is running 0 - 255
+	int pitchstart;		// pitch shift % when sound stops or starts 0 - 255
+	int spinup;			// spinup time 0 - 100
+	int spindown;		// spindown time 0 - 100
+
+	int volrun;			// volume change % when sound is running 0 - 10
+	int volstart;		// volume change % when sound stops or starts 0 - 10
+	int fadein;			// volume fade in time 0 - 100
+	int fadeout;		// volume fade out time 0 - 100
+
+						// Low Frequency Oscillator
+	int	lfotype;		// 0) off 1) square 2) triangle 3) random
+	int lforate;		// 0 - 1000, how fast lfo osciallates
+	
+	int lfomodpitch;	// 0-100 mod of current pitch. 0 is off.
+	int lfomodvol;		// 0-100 mod of current volume. 0 is off.
+
+	int cspinup;		// each trigger hit increments counter and spinup pitch
+
+
+	int	cspincount;
+
+	int pitch;			
+	int spinupsav;
+	int spindownsav;
+	int pitchfrac;
+
+	int vol;
+	int fadeinsav;
+	int fadeoutsav;
+	int volfrac;
+
+	int	lfofrac;
+	int	lfomult;
+
+
+} dynpitchvol_t;
+
+#define CDPVPRESETMAX 27
+
+// presets for runtime pitch and vol modulation of ambient sounds
+
+/*jlb
+dynpitchvol_t rgdpvpreset[CDPVPRESETMAX] = 
+{
+// pitch	pstart	spinup	spindwn	volrun	volstrt	fadein	fadeout	lfotype	lforate	modptch modvol	cspnup		
+{1,	255,	 75,	95,		95,		10,		1,		50,		95, 	0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0}, 
+{2,	255,	 85,	70,		88,		10,		1,		20,		88,		0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0}, 
+{3,	255,	100,	50,		75,		10,		1,		10,		75,		0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{4,	100,	100,	0,		0,		10,		1,		90,		90,		0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{5,	100,	100,	0,		0,		10,		1,		80,		80,		0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{6,	100,	100,	0,		0,		10,		1,		50,		70,		0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{7,	100,	100,	0,		0,		 5,		1,		40,		50,		1,		50,		0,		10,		0,		0,0,0,0,0,0,0,0,0,0},
+{8,	100,	100,	0,		0,		 5,		1,		40,		50,		1,		150,	0,		10,		0,		0,0,0,0,0,0,0,0,0,0},
+{9,	100,	100,	0,		0,		 5,		1,		40,		50,		1,		750,	0,		10,		0,		0,0,0,0,0,0,0,0,0,0},
+{10,128,	100,	50,		75,		10,		1,		30,		40,		2,		 8,		20,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{11,128,	100,	50,		75,		10,		1,		30,		40,		2,		25,		20,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{12,128,	100,	50,		75,		10,		1,		30,		40,		2,		70,		20,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{13,50,		 50,	0,		0,		10,		1,		20,		50,		0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{14,70,		 70,	0,		0,		10,		1,		20,		50,		0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{15,90,		 90,	0,		0,		10,		1,		20,		50,		0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{16,120,	120,	0,		0,		10,		1,		20,		50,		0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{17,180,	180,	0,		0,		10,		1,		20,		50,		0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{18,255,	255,	0,		0,		10,		1,		20,		50,		0,		0,		0,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{19,200,	 75,	90,		90,		10,		1,		50,		90,		2,		100,	20,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{20,255,	 75,	97,		90,		10,		1,		50,		90,		1,		40,		50,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{21,100,	100,	0,		0,		10,		1,		30,		50,		3,		15,		20,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{22,160,	160,	0,		0,		10,		1,		50,		50,		3,		500,	25,		0,		0,		0,0,0,0,0,0,0,0,0,0},
+{23,255,	 75,	88,		0,		10,		1,		40,		0,		0,		0,		0,		0,		5,		0,0,0,0,0,0,0,0,0,0}, 
+{24,200,	 20,	95,	    70,		10,		1,		70,		70,		3,		20,		50,		0,		0,		0,0,0,0,0,0,0,0,0,0}, 
+{25,180,	100,	50,		60,		10,		1,		40,		60,		2,		90,		100,	100,	0,		0,0,0,0,0,0,0,0,0,0}, 
+{26,60,		 60,	0,		0,		10,		1,		40,		70,		3,		80,		20,		50,		0,		0,0,0,0,0,0,0,0,0,0}, 
+{27,128,	 90,	10,		10,		10,		1,		20,		40,		1,		5,		10,		20,		0,		0,0,0,0,0,0,0,0,0,0}
+};
+jlb*/
+
+
+// ==================== SENTENCE GROUPS, UTILITY FUNCTIONS  ======================================
+
+#define CSENTENCE_LRU_MAX	32		// max number of elements per sentence group
+
+// group of related sentences
+
+typedef struct sentenceg
+{
+	char szgroupname[CBSENTENCENAME_MAX];
+	int count;
+	unsigned char rgblru[CSENTENCE_LRU_MAX];
+
+} SENTENCEG;
+
+#define CSENTENCEG_MAX 200					// max number of sentence groups
+// globals
+
+SENTENCEG rgsentenceg[CSENTENCEG_MAX];
+int fSentencesInit = FALSE;
+
+char gszallsentencenames[CVOXFILESENTENCEMAX][CBSENTENCENAME_MAX];
+int gcallsentences = 0;
+
+// randomize list of sentence name indices
+
+void USENTENCEG_InitLRU(unsigned char *plru, int count)
+{
+	int i, j, k;
+	unsigned char temp;
+	
+	if (!fSentencesInit)
+		return;
+
+	if (count > CSENTENCE_LRU_MAX)
+		count = CSENTENCE_LRU_MAX;
+
+	for (i = 0; i < count; i++)
+		plru[i] = (unsigned char) i;
+
+	// randomize array
+	for (i = 0; i < (count * 4); i++)
+	{
+		j = RANDOM_LONG(0,count-1);
+		k = RANDOM_LONG(0,count-1);
+		temp = plru[j];
+		plru[j] = plru[k];
+		plru[k] = temp;
+	}
+}
+
+// ignore lru. pick next sentence from sentence group. Go in order until we hit the last sentence, 
+// then repeat list if freset is true.  If freset is false, then repeat last sentence.
+// ipick is passed in as the requested sentence ordinal.
+// ipick 'next' is returned.  
+// return of -1 indicates an error.
+
+int USENTENCEG_PickSequential(int isentenceg, char *szfound, int ipick, int freset)
+{
+	char *szgroupname;
+	unsigned char count;
+	char sznum[8];
+	
+	if (!fSentencesInit)
+		return -1;
+
+	if (isentenceg < 0)
+		return -1;
+
+	szgroupname = rgsentenceg[isentenceg].szgroupname;
+	count = rgsentenceg[isentenceg].count;
+	
+	if (count == 0)
+		return -1;
+
+	if (ipick >= count)
+		ipick = count-1;
+
+	strcpy(szfound, "!");
+	strcat(szfound, szgroupname);
+	sprintf(sznum, "%d", ipick);
+	strcat(szfound, sznum);
+	
+	if (ipick >= count)
+	{
+		if (freset)
+			// reset at end of list
+			return 0;
+		else
+			return count;
+	}
+
+	return ipick + 1;
+}
+
+
+
+// pick a random sentence from rootname0 to rootnameX.
+// picks from the rgsentenceg[isentenceg] least
+// recently used, modifies lru array. returns the sentencename.
+// note, lru must be seeded with 0-n randomized sentence numbers, with the
+// rest of the lru filled with -1. The first integer in the lru is
+// actually the size of the list.  Returns ipick, the ordinal
+// of the picked sentence within the group.
+
+int USENTENCEG_Pick(int isentenceg, char *szfound)
+{
+	char *szgroupname;
+	unsigned char *plru;
+	unsigned char i;
+	unsigned char count;
+	char sznum[8];
+	unsigned char ipick;
+	int ffound = FALSE;
+	
+	if (!fSentencesInit)
+		return -1;
+
+	if (isentenceg < 0)
+		return -1;
+
+	szgroupname = rgsentenceg[isentenceg].szgroupname;
+	count = rgsentenceg[isentenceg].count;
+	plru = rgsentenceg[isentenceg].rgblru;
+
+	while (!ffound)
+	{
+		for (i = 0; i < count; i++)
+			if (plru[i] != 0xFF)
+			{
+				ipick = plru[i];
+				plru[i] = 0xFF;
+				ffound = TRUE;
+				break;
+			}
+
+		if (!ffound)
+			USENTENCEG_InitLRU(plru, count);
+		else
+		{
+			strcpy(szfound, "!");
+			strcat(szfound, szgroupname);
+			sprintf(sznum, "%d", ipick);
+			strcat(szfound, sznum);
+			return ipick;
+		}
+	}
+	return -1;
+}
+
+// ===================== SENTENCE GROUPS, MAIN ROUTINES ========================
+
+// Given sentence group rootname (name without number suffix),
+// get sentence group index (isentenceg). Returns -1 if no such name.
+
+int SENTENCEG_GetIndex(const char *szgroupname)
+{
+	int i;
+
+	if (!fSentencesInit || !szgroupname)
+		return -1;
+
+	// search rgsentenceg for match on szgroupname
+
+	i = 0;
+	while (rgsentenceg[i].count)
+	{
+		if (!strcmp(szgroupname, rgsentenceg[i].szgroupname))
+			return i;
+	i++;
+	}
+
+	return -1;
+}
+
+// given sentence group index, play random sentence for given entity.
+// returns ipick - which sentence was picked to 
+// play from the group. Ipick is only needed if you plan on stopping
+// the sound before playback is done (see SENTENCEG_Stop).
+
+int SENTENCEG_PlayRndI(edict_t *entity, int isentenceg, 
+					  float volume, float attenuation, int flags, int pitch)
+{
+	char name[64];
+	int ipick;
+
+	if (!fSentencesInit)
+		return -1;
+
+	name[0] = 0;
+
+	ipick = USENTENCEG_Pick(isentenceg, name);
+	if (ipick > 0 && name)
+		EMIT_SOUND_DYN(entity, CHAN_VOICE, name, volume, attenuation, flags, pitch);
+	return ipick;
+}
+
+// same as above, but takes sentence group name instead of index
+
+int SENTENCEG_PlayRndSz(edict_t *entity, const char *szgroupname, 
+					  float volume, float attenuation, int flags, int pitch)
+{
+	char name[64];
+	int ipick;
+	int isentenceg;
+
+	if (!fSentencesInit)
+		return -1;
+
+	name[0] = 0;
+
+	isentenceg = SENTENCEG_GetIndex(szgroupname);
+	if (isentenceg < 0)
+	{
+		ALERT( at_console, "No such sentence group %s\n", szgroupname );
+		return -1;
+	}
+
+	ipick = USENTENCEG_Pick(isentenceg, name);
+	if (ipick >= 0 && name[0])
+		EMIT_SOUND_DYN(entity, CHAN_VOICE, name, volume, attenuation, flags, pitch);
+
+	return ipick;
+}
+
+// play sentences in sequential order from sentence group.  Reset after last sentence.
+
+int SENTENCEG_PlaySequentialSz(edict_t *entity, const char *szgroupname, 
+					  float volume, float attenuation, int flags, int pitch, int ipick, int freset)
+{
+	char name[64];
+	int ipicknext;
+	int isentenceg;
+
+	if (!fSentencesInit)
+		return -1;
+
+	name[0] = 0;
+
+	isentenceg = SENTENCEG_GetIndex(szgroupname);
+	if (isentenceg < 0)
+		return -1;
+
+	ipicknext = USENTENCEG_PickSequential(isentenceg, name, ipick, freset);
+	if (ipicknext >= 0 && name[0])
+		EMIT_SOUND_DYN(entity, CHAN_VOICE, name, volume, attenuation, flags, pitch);
+	return ipicknext;
+}
+
+
+// for this entity, for the given sentence within the sentence group, stop
+// the sentence.
+
+void SENTENCEG_Stop(edict_t *entity, int isentenceg, int ipick)
+{
+	char buffer[64];
+	char sznum[8];
+	
+	if (!fSentencesInit)
+		return;
+
+	if (isentenceg < 0 || ipick < 0)
+		return;
+	
+	strcpy(buffer, "!");
+	strcat(buffer, rgsentenceg[isentenceg].szgroupname);
+	sprintf(sznum, "%d", ipick);
+	strcat(buffer, sznum);
+
+	STOP_SOUND(entity, CHAN_VOICE, buffer);
+}
+
+// open sentences.txt, scan for groups, build rgsentenceg
+// Should be called from world spawn, only works on the
+// first call and is ignored subsequently.
+
+void SENTENCEG_Init()
+{
+	char buffer[512];
+	char szgroup[64];
+	int i, j;
+	int isentencegs;
+
+	if (fSentencesInit)
+		return;
+
+	memset(gszallsentencenames, 0, CVOXFILESENTENCEMAX * CBSENTENCENAME_MAX);
+	gcallsentences = 0;
+
+	memset(rgsentenceg, 0, CSENTENCEG_MAX * sizeof(SENTENCEG));
+	memset(buffer, 0, 512);
+	memset(szgroup, 0, 64);
+	isentencegs = -1;
+
+	
+	int filePos = 0, fileSize;
+	byte *pMemFile = g_engfuncs.pfnLoadFileForMe( "sound/sentences.txt", &fileSize );
+	if ( !pMemFile )
+		return;
+
+	// for each line in the file...
+	while ( memfgets(pMemFile, fileSize, filePos, buffer, 511) != NULL )
+	{
+		// skip whitespace
+		i = 0;
+		while(buffer[i] && buffer[i] == ' ')
+			i++;
+		
+		if (!buffer[i])
+			continue;
+
+		if (buffer[i] == '/' || !isalpha(buffer[i]))
+			continue;
+
+		// get sentence name
+		j = i;
+		while (buffer[j] && buffer[j] != ' ')
+			j++;
+
+		if (!buffer[j])
+			continue;
+
+		if (gcallsentences > CVOXFILESENTENCEMAX)
+		{
+			ALERT (at_error, "Too many sentences in sentences.txt!\n");
+			break;
+		}
+
+		// null-terminate name and save in sentences array
+		buffer[j] = 0;
+		const char *pString = buffer + i;
+
+		if ( strlen( pString ) >= CBSENTENCENAME_MAX )
+			ALERT( at_warning, "Sentence %s longer than %d letters\n", pString, CBSENTENCENAME_MAX-1 );
+
+		strcpy( gszallsentencenames[gcallsentences++], pString );
+
+		j--;
+		if (j <= i)
+			continue;
+		if (!isdigit(buffer[j]))
+			continue;
+
+		// cut out suffix numbers
+		while (j > i && isdigit(buffer[j]))
+			j--;
+
+		if (j <= i)
+			continue;
+
+		buffer[j+1] = 0;
+		
+		// if new name doesn't match previous group name, 
+		// make a new group.
+
+		if (strcmp(szgroup, &(buffer[i])))
+		{
+			// name doesn't match with prev name,
+			// copy name into group, init count to 1
+			isentencegs++;
+			if (isentencegs >= CSENTENCEG_MAX)
+			{
+				ALERT (at_error, "Too many sentence groups in sentences.txt!\n");
+				break;
+			}
+
+			strcpy(rgsentenceg[isentencegs].szgroupname, &(buffer[i]));
+			rgsentenceg[isentencegs].count = 1;
+
+			strcpy(szgroup, &(buffer[i]));
+
+			continue;
+		}
+		else
+		{
+			//name matches with previous, increment group count
+			if (isentencegs >= 0)
+				rgsentenceg[isentencegs].count++;
+		}
+	}
+
+	g_engfuncs.pfnFreeFile( pMemFile );
+	
+	fSentencesInit = TRUE;
+
+	// init lru lists
+
+	i = 0;
+
+	while (rgsentenceg[i].count && i < CSENTENCEG_MAX)
+	{
+		USENTENCEG_InitLRU(&(rgsentenceg[i].rgblru[0]), rgsentenceg[i].count);
+		i++;
+	}
+
+}
+
+// convert sentence (sample) name to !sentencenum, return !sentencenum
+
+int SENTENCEG_Lookup(const char *sample, char *sentencenum)
+{
+	char sznum[8];
+
+	int i;
+	// this is a sentence name; lookup sentence number
+	// and give to engine as string.
+	for (i = 0; i < gcallsentences; i++)
+		if (!stricmp(gszallsentencenames[i], sample+1))
+		{
+			if (sentencenum)
+			{
+				strcpy(sentencenum, "!");
+				sprintf(sznum, "%d", i);
+				strcat(sentencenum, sznum);
+			}
+			return i;
+		}
+	// sentence name not found!
+	return -1;
+}
+
+void EMIT_SOUND_DYN(edict_t *entity, int channel, const char *sample, float volume, float attenuation,
+						   int flags, int pitch)
+{
+	if (sample && *sample == '!')
+	{
+		char name[32];
+		if (SENTENCEG_Lookup(sample, name) >= 0)
+				EMIT_SOUND_DYN2(entity, channel, name, volume, attenuation, flags, pitch);
+		else
+			ALERT( at_aiconsole, "Unable to find %s in sentences.txt\n", sample );
+	}
+	else
+		EMIT_SOUND_DYN2(entity, channel, sample, volume, attenuation, flags, pitch);
+}
+
+// play a specific sentence over the HEV suit speaker - just pass player entity, and !sentencename
+
+void EMIT_SOUND_SUIT(edict_t *entity, const char *sample)
+{
+	float fvol;
+	int pitch = PITCH_NORM;
+
+	fvol = CVAR_GET_FLOAT("suitvolume");
+	if (RANDOM_LONG(0,1))
+		pitch = RANDOM_LONG(0,6) + 98;
+
+	if (fvol > 0.05)
+		EMIT_SOUND_DYN(entity, CHAN_STATIC, sample, fvol, ATTN_NORM, 0, pitch);
+}
+
+// play a sentence, randomly selected from the passed in group id, over the HEV suit speaker
+
+void EMIT_GROUPID_SUIT(edict_t *entity, int isentenceg)
+{
+	float fvol;
+	int pitch = PITCH_NORM;
+
+	fvol = CVAR_GET_FLOAT("suitvolume");
+	if (RANDOM_LONG(0,1))
+		pitch = RANDOM_LONG(0,6) + 98;
+
+	if (fvol > 0.05)
+		SENTENCEG_PlayRndI(entity, isentenceg, fvol, ATTN_NORM, 0, pitch);
+}
+
+// play a sentence, randomly selected from the passed in groupname
+
+void EMIT_GROUPNAME_SUIT(edict_t *entity, const char *groupname)
+{
+	float fvol;
+	int pitch = PITCH_NORM;
+
+	fvol = CVAR_GET_FLOAT("suitvolume");
+	if (RANDOM_LONG(0,1))
+		pitch = RANDOM_LONG(0,6) + 98;
+
+	if (fvol > 0.05)
+		SENTENCEG_PlayRndSz(entity, groupname, fvol, ATTN_NORM, 0, pitch);
+}
+
+// ===================== MATERIAL TYPE DETECTION, MAIN ROUTINES ========================
+// 
+// Used to detect the texture the player is standing on, map the
+// texture name to a material type.  Play footstep sound based
+// on material type.
+
+int fTextureTypeInit = FALSE;
+
+#define CTEXTURESMAX		512			// max number of textures loaded
+
+//jlbint gcTextures = 0;
+//jlbchar grgszTextureName[CTEXTURESMAX][CBTEXTURENAMEMAX];	// texture names
+//jlbchar grgchTextureType[CTEXTURESMAX];						// parallel array of texture types
+
+// open materials.txt,  get size, alloc space, 
+// save in array.  Only works first time called, 
+// ignored on subsequent calls.
+
+static char *memfgets( byte *pMemFile, int fileSize, int &filePos, char *pBuffer, int bufferSize )
+{
+	// Bullet-proofing
+	if ( !pMemFile || !pBuffer )
+		return NULL;
+
+	if ( filePos >= fileSize )
+		return NULL;
+
+	int i = filePos;
+	int last = fileSize;
+
+	// fgets always NULL terminates, so only read bufferSize-1 characters
+	if ( last - filePos > (bufferSize-1) )
+		last = filePos + (bufferSize-1);
+
+	int stop = 0;
+
+	// Stop at the next newline (inclusive) or end of buffer
+	while ( i < last && !stop )
+	{
+		if ( pMemFile[i] == '\n' )
+			stop = 1;
+		i++;
+	}
+
+
+	// If we actually advanced the pointer, copy it over
+	if ( i != filePos )
+	{
+		// We read in size bytes
+		int size = i - filePos;
+		// copy it out
+		memcpy( pBuffer, pMemFile + filePos, sizeof(byte)*size );
+		
+		// If the buffer isn't full, terminate (this is always true)
+		if ( size < bufferSize )
+			pBuffer[size] = 0;
+
+		// Update file pointer
+		filePos = i;
+		return pBuffer;
+	}
+
+	// No data read, bail
+	return NULL;
+}
+
+
+void TEXTURETYPE_Init()
+{
+/*jlb
+	char buffer[512];
+	int i, j;
+	byte *pMemFile;
+	int fileSize, filePos;
+
+	if (fTextureTypeInit)
+		return;
+
+	memset(&(grgszTextureName[0][0]), 0, CTEXTURESMAX * CBTEXTURENAMEMAX);
+	memset(grgchTextureType, 0, CTEXTURESMAX);
+
+	gcTextures = 0;
+	memset(buffer, 0, 512);
+
+	pMemFile = g_engfuncs.pfnLoadFileForMe( "sound/materials.txt", &fileSize );
+	if ( !pMemFile )
+		return;
+
+	// for each line in the file...
+	while (memfgets(pMemFile, fileSize, filePos, buffer, 511) != NULL && (gcTextures < CTEXTURESMAX))
+	{
+		// skip whitespace
+		i = 0;
+		while(buffer[i] && isspace(buffer[i]))
+			i++;
+		
+		if (!buffer[i])
+			continue;
+
+		// skip comment lines
+		if (buffer[i] == '/' || !isalpha(buffer[i]))
+			continue;
+
+		// get texture type
+		grgchTextureType[gcTextures] = toupper(buffer[i++]);
+
+		// skip whitespace
+		while(buffer[i] && isspace(buffer[i]))
+			i++;
+		
+		if (!buffer[i])
+			continue;
+
+		// get sentence name
+		j = i;
+		while (buffer[j] && !isspace(buffer[j]))
+			j++;
+
+		if (!buffer[j])
+			continue;
+
+		// null-terminate name and save in sentences array
+		j = min (j, CBTEXTURENAMEMAX-1+i);
+		buffer[j] = 0;
+		strcpy(&(grgszTextureName[gcTextures++][0]), &(buffer[i]));
+	}
+
+	g_engfuncs.pfnFreeFile( pMemFile );
+	
+	fTextureTypeInit = TRUE;
+jlb*/
+}
+
+// given texture name, find texture type
+// if not found, return type 'concrete'
+
+// NOTE: this routine should ONLY be called if the 
+// current texture under the player changes!
+
+char TEXTURETYPE_Find(char *name)
+{
+	// CONSIDER: pre-sort texture names and perform faster binary search here
+/*jlb
+	for (int i = 0; i < gcTextures; i++)
+	{
+		if (!strnicmp(name, &(grgszTextureName[i][0]), CBTEXTURENAMEMAX-1))
+			return (grgchTextureType[i]);
+	}
+jlb*/
+	return CHAR_TEX_CONCRETE;
+}
+
+// play a strike sound based on the texture that was hit by the attack traceline.  VecSrc/VecEnd are the
+// original traceline endpoints used by the attacker, iBulletType is the type of bullet that hit the texture.
+// returns volume of strike instrument (crowbar) to play
+
+float TEXTURETYPE_PlaySound(TraceResult *ptr,  Vector vecSrc, Vector vecEnd, int iBulletType)
+{
+// hit the world, try to play sound based on texture material type
+	
+	char chTextureType;
+	float fvol;
+	float fvolbar;
+	char szbuffer[64];
+	const char *pTextureName;
+	float rgfl1[3];
+	float rgfl2[3];
+	char *rgsz[4];
+	int cnt;
+	float fattn = ATTN_NORM;
+
+	CMBaseEntity *pEntity = CMBaseEntity::Instance(ptr->pHit);
+
+	chTextureType = 0;
+
+	if (pEntity && pEntity->Classify() != CLASS_NONE && pEntity->Classify() != CLASS_MACHINE)
+		// hit body
+		chTextureType = CHAR_TEX_FLESH;
+	else
+	{
+		// hit world
+
+		// find texture under strike, get material type
+
+		// copy trace vector into array for trace_texture
+
+		vecSrc.CopyToArray(rgfl1);
+		vecEnd.CopyToArray(rgfl2);
+
+		// get texture from entity or world (world is ent(0))
+		if (pEntity)
+			pTextureName = TRACE_TEXTURE( ENT(pEntity->pev), rgfl1, rgfl2 );
+		else
+			pTextureName = TRACE_TEXTURE( ENT(0), rgfl1, rgfl2 );
+			
+		if ( pTextureName )
+		{
+			// strip leading '-0' or '+0~' or '{' or '!'
+			if (*pTextureName == '-' || *pTextureName == '+')
+				pTextureName += 2;
+
+			if (*pTextureName == '{' || *pTextureName == '!' || *pTextureName == '~' || *pTextureName == ' ')
+				pTextureName++;
+			// '}}'
+			strcpy(szbuffer, pTextureName);
+			szbuffer[CBTEXTURENAMEMAX - 1] = 0;
+				
+			// ALERT ( at_console, "texture hit: %s\n", szbuffer);
+
+			// get texture type
+			chTextureType = TEXTURETYPE_Find(szbuffer);	
+		}
+	}
+
+	switch (chTextureType)
+	{
+	default:
+	case CHAR_TEX_CONCRETE: fvol = 0.9;	fvolbar = 0.6;
+		rgsz[0] = "player/pl_step1.wav";
+		rgsz[1] = "player/pl_step2.wav";
+		cnt = 2;
+		break;
+	case CHAR_TEX_METAL: fvol = 0.9; fvolbar = 0.3;
+		rgsz[0] = "player/pl_metal1.wav";
+		rgsz[1] = "player/pl_metal2.wav";
+		cnt = 2;
+		break;
+	case CHAR_TEX_DIRT:	fvol = 0.9; fvolbar = 0.1;
+		rgsz[0] = "player/pl_dirt1.wav";
+		rgsz[1] = "player/pl_dirt2.wav";
+		rgsz[2] = "player/pl_dirt3.wav";
+		cnt = 3;
+		break;
+	case CHAR_TEX_VENT:	fvol = 0.5; fvolbar = 0.3;
+		rgsz[0] = "player/pl_duct1.wav";
+		rgsz[1] = "player/pl_duct1.wav";
+		cnt = 2;
+		break;
+	case CHAR_TEX_GRATE: fvol = 0.9; fvolbar = 0.5;
+		rgsz[0] = "player/pl_grate1.wav";
+		rgsz[1] = "player/pl_grate4.wav";
+		cnt = 2;
+		break;
+	case CHAR_TEX_TILE:	fvol = 0.8; fvolbar = 0.2;
+		rgsz[0] = "player/pl_tile1.wav";
+		rgsz[1] = "player/pl_tile3.wav";
+		rgsz[2] = "player/pl_tile2.wav";
+		rgsz[3] = "player/pl_tile4.wav";
+		cnt = 4;
+		break;
+	case CHAR_TEX_SLOSH: fvol = 0.9; fvolbar = 0.0;
+		rgsz[0] = "player/pl_slosh1.wav";
+		rgsz[1] = "player/pl_slosh3.wav";
+		rgsz[2] = "player/pl_slosh2.wav";
+		rgsz[3] = "player/pl_slosh4.wav";
+		cnt = 4;
+		break;
+	case CHAR_TEX_WOOD: fvol = 0.9; fvolbar = 0.2;
+		rgsz[0] = "debris/wood1.wav";
+		rgsz[1] = "debris/wood2.wav";
+		rgsz[2] = "debris/wood3.wav";
+		cnt = 3;
+		break;
+	case CHAR_TEX_GLASS:
+	case CHAR_TEX_COMPUTER:
+		fvol = 0.8; fvolbar = 0.2;
+		rgsz[0] = "debris/glass1.wav";
+		rgsz[1] = "debris/glass2.wav";
+		rgsz[2] = "debris/glass3.wav";
+		cnt = 3;
+		break;
+	case CHAR_TEX_FLESH:
+		if (iBulletType == BULLET_PLAYER_CROWBAR)
+			return 0.0; // crowbar already makes this sound
+		fvol = 1.0;	fvolbar = 0.2;
+		rgsz[0] = "weapons/bullet_hit1.wav";
+		rgsz[1] = "weapons/bullet_hit2.wav";
+		fattn = 1.0;
+		cnt = 2;
+		break;
+	}
+
+	// did we hit a breakable?
+
+	if (pEntity && FClassnameIs(pEntity->pev, "func_breakable"))
+	{
+		// drop volumes, the object will already play a damaged sound
+		fvol /= 1.5;
+		fvolbar /= 2.0;	
+	}
+	else if (chTextureType == CHAR_TEX_COMPUTER)
+	{
+		// play random spark if computer
+
+		if ( ptr->flFraction != 1.0 && RANDOM_LONG(0,1))
+		{
+			UTIL_Sparks( ptr->vecEndPos );
+
+			float flVolume = RANDOM_FLOAT ( 0.7 , 1.0 );//random volume range
+			switch ( RANDOM_LONG(0,1) )
+			{
+				case 0: UTIL_EmitAmbientSound(ENT(0), ptr->vecEndPos, "buttons/spark5.wav", flVolume, ATTN_NORM, 0, 100); break;
+				case 1: UTIL_EmitAmbientSound(ENT(0), ptr->vecEndPos, "buttons/spark6.wav", flVolume, ATTN_NORM, 0, 100); break;
+				// case 0: EMIT_SOUND(ENT(pev), CHAN_VOICE, "buttons/spark5.wav", flVolume, ATTN_NORM);	break;
+				// case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "buttons/spark6.wav", flVolume, ATTN_NORM);	break;
+			}
+		}
+	}
+
+	// play material hit sound
+	UTIL_EmitAmbientSound(ENT(0), ptr->vecEndPos, rgsz[RANDOM_LONG(0,cnt-1)], fvol, fattn, 0, 96 + RANDOM_LONG(0,0xf));
+	//EMIT_SOUND_DYN( ENT(m_pPlayer->pev), CHAN_WEAPON, rgsz[RANDOM_LONG(0,cnt-1)], fvol, ATTN_NORM, 0, 96 + RANDOM_LONG(0,0xf));
+			
+	return fvolbar;
+}
+

src/dlls/squeakgrenade.cpp

@@ -0,0 +1,337 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
+
+#include "extdll.h"
+#include "util.h"
+#include "cmbase.h"
+#include "cmbasemonster.h"
+#include "monsters.h"
+#include "weapons.h"
+#include "nodes.h"
+
+enum w_squeak_e {
+	WSQUEAK_IDLE1 = 0,
+	WSQUEAK_FIDGET,
+	WSQUEAK_JUMP,
+	WSQUEAK_RUN,
+};
+
+enum squeak_e {
+	SQUEAK_IDLE1 = 0,
+	SQUEAK_FIDGETFIT,
+	SQUEAK_FIDGETNIP,
+	SQUEAK_DOWN,
+	SQUEAK_UP,
+	SQUEAK_THROW
+};
+
+#ifndef CLIENT_DLL
+
+
+float CMSqueakGrenade::m_flNextBounceSoundTime = 0;
+
+#define SQUEEK_DETONATE_DELAY	15.0
+
+int CMSqueakGrenade :: Classify ( void )
+{
+	return CLASS_ALIEN_MONSTER;
+}
+
+void CMSqueakGrenade :: Spawn( void )
+{
+	Precache( );
+	// motor
+	pev->movetype = MOVETYPE_BOUNCE;
+	pev->solid = SOLID_BBOX;
+
+	SET_MODEL(ENT(pev), "models/w_squeak.mdl");
+	UTIL_SetSize(pev, Vector( -4, -4, 0), Vector(4, 4, 8));
+	UTIL_SetOrigin( pev, pev->origin );
+
+	SetTouch( SuperBounceTouch );
+	SetThink( HuntThink );
+	pev->nextthink = gpGlobals->time + 0.1;
+	m_flNextHunt = gpGlobals->time + 1E6;
+
+	pev->flags |= FL_MONSTER;
+	pev->takedamage		= DAMAGE_AIM;
+	pev->health			= gSkillData.snarkHealth;
+	pev->gravity		= 0.5;
+	pev->friction		= 0.5;
+
+	pev->dmg = gSkillData.snarkDmgPop;
+
+	m_flDie = gpGlobals->time + SQUEEK_DETONATE_DELAY;
+
+	m_flFieldOfView = 0; // 180 degrees
+
+	m_flNextBounceSoundTime = gpGlobals->time;// reset each time a snark is spawned.
+
+	pev->sequence = WSQUEAK_RUN;
+	ResetSequenceInfo( );
+
+	m_hEnemy = NULL;
+}
+
+void CMSqueakGrenade::Precache( void )
+{
+	PRECACHE_MODEL("models/w_squeak.mdl");
+	PRECACHE_SOUND("squeek/sqk_blast1.wav");
+	PRECACHE_SOUND("common/bodysplat.wav");
+	PRECACHE_SOUND("squeek/sqk_die1.wav");
+	PRECACHE_SOUND("squeek/sqk_hunt1.wav");
+	PRECACHE_SOUND("squeek/sqk_hunt2.wav");
+	PRECACHE_SOUND("squeek/sqk_hunt3.wav");
+	PRECACHE_SOUND("squeek/sqk_deploy1.wav");
+}
+
+
+void CMSqueakGrenade :: Killed( entvars_t *pevAttacker, int iGib )
+{
+	pev->model = iStringNull;// make invisible
+	SetThink( SUB_Remove );
+	SetTouch( NULL );
+	pev->nextthink = gpGlobals->time + 0.1;
+
+	// since squeak grenades never leave a body behind, clear out their takedamage now.
+	// Squeaks do a bit of radius damage when they pop, and that radius damage will
+	// continue to call this function unless we acknowledge the Squeak's death now. (sjb)
+	pev->takedamage = DAMAGE_NO;
+
+	// play squeek blast
+	EMIT_SOUND_DYN(ENT(pev), CHAN_ITEM, "squeek/sqk_blast1.wav", 1, 0.5, 0, PITCH_NORM);	
+
+	UTIL_BloodDrips( pev->origin, g_vecZero, BloodColor(), 80 );
+
+	RadiusDamage ( pev, pev, pev->dmg, CLASS_NONE, DMG_BLAST );
+
+	CMBaseMonster :: Killed( pevAttacker, GIB_ALWAYS );
+}
+
+void CMSqueakGrenade :: GibMonster( void )
+{
+	EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "common/bodysplat.wav", 0.75, ATTN_NORM, 0, 200);		
+}
+
+
+
+void CMSqueakGrenade::HuntThink( void )
+{
+	// ALERT( at_console, "think\n" );
+
+	if (!IsInWorld())
+	{
+		SetTouch( NULL );
+		UTIL_Remove( this->edict() );
+		return;
+	}
+	
+	StudioFrameAdvance( );
+	pev->nextthink = gpGlobals->time + 0.1;
+
+	// explode when ready
+	if (gpGlobals->time >= m_flDie)
+	{
+		g_vecAttackDir = pev->velocity.Normalize( );
+		pev->health = -1;
+		Killed( pev, 0 );
+		return;
+	}
+
+	// float
+	if (pev->waterlevel != 0)
+	{
+		if (pev->movetype == MOVETYPE_BOUNCE)
+		{
+			pev->movetype = MOVETYPE_FLY;
+		}
+		pev->velocity = pev->velocity * 0.9;
+		pev->velocity.z += 8.0;
+	}
+	else if (pev->movetype = MOVETYPE_FLY)
+	{
+		pev->movetype = MOVETYPE_BOUNCE;
+	}
+
+	// return if not time to hunt
+	if (m_flNextHunt > gpGlobals->time)
+		return;
+
+	m_flNextHunt = gpGlobals->time + 2.0;
+	
+	Vector vecDir;
+	TraceResult tr;
+
+	Vector vecFlat = pev->velocity;
+	vecFlat.z = 0;
+	vecFlat = vecFlat.Normalize( );
+
+	UTIL_MakeVectors( pev->angles );
+
+	if (m_hEnemy == NULL || !UTIL_IsAlive(m_hEnemy))
+	{
+		// find target, bounce a bit towards it.
+		Look( 512 );
+		m_hEnemy = BestVisibleEnemy( );
+	}
+
+	// squeek if it's about time blow up
+	if ((m_flDie - gpGlobals->time <= 0.5) && (m_flDie - gpGlobals->time >= 0.3))
+	{
+		EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_die1.wav", 1, ATTN_NORM, 0, 100 + RANDOM_LONG(0,0x3F));
+	}
+
+	// higher pitch as squeeker gets closer to detonation time
+	float flpitch = 155.0 - 60.0 * ((m_flDie - gpGlobals->time) / SQUEEK_DETONATE_DELAY);
+	if (flpitch < 80)
+		flpitch = 80;
+
+	if (m_hEnemy != NULL)
+	{
+		if (UTIL_FVisible( m_hEnemy, ENT(pev) ))
+		{
+			vecDir = (m_hEnemy->v.origin + m_hEnemy->v.view_ofs) - pev->origin;
+			m_vecTarget = vecDir.Normalize( );
+		}
+
+		float flVel = pev->velocity.Length();
+		float flAdj = 50.0 / (flVel + 10.0);
+
+		if (flAdj > 1.2)
+			flAdj = 1.2;
+		
+		// ALERT( at_console, "think : enemy\n");
+
+		// ALERT( at_console, "%.0f %.2f %.2f %.2f\n", flVel, m_vecTarget.x, m_vecTarget.y, m_vecTarget.z );
+
+		pev->velocity = pev->velocity * flAdj + m_vecTarget * 300;
+	}
+
+	if (pev->flags & FL_ONGROUND)
+	{
+		pev->avelocity = Vector( 0, 0, 0 );
+	}
+	else
+	{
+		if (pev->avelocity == Vector( 0, 0, 0))
+		{
+			pev->avelocity.x = RANDOM_FLOAT( -100, 100 );
+			pev->avelocity.z = RANDOM_FLOAT( -100, 100 );
+		}
+	}
+
+	if ((pev->origin - m_posPrev).Length() < 1.0)
+	{
+		pev->velocity.x = RANDOM_FLOAT( -100, 100 );
+		pev->velocity.y = RANDOM_FLOAT( -100, 100 );
+	}
+	m_posPrev = pev->origin;
+
+	pev->angles = UTIL_VecToAngles( pev->velocity );
+	pev->angles.z = 0;
+	pev->angles.x = 0;
+}
+
+
+void CMSqueakGrenade::SuperBounceTouch( edict_t *pOther )
+{
+	float	flpitch;
+
+	TraceResult tr = UTIL_GetGlobalTrace( );
+
+	// don't hit the guy that launched this grenade
+	if ( pev->owner && (pOther == pev->owner) )
+		return;
+
+	// at least until we've bounced once
+	pev->owner = NULL;
+
+	pev->angles.x = 0;
+	pev->angles.z = 0;
+
+	// avoid bouncing too much
+	if (m_flNextHit > gpGlobals->time)
+		return;
+
+	// higher pitch as squeeker gets closer to detonation time
+	flpitch = 155.0 - 60.0 * ((m_flDie - gpGlobals->time) / SQUEEK_DETONATE_DELAY);
+
+	if ( pOther->v.takedamage && m_flNextAttack < gpGlobals->time )
+	{
+		// attack!
+
+		// make sure it's me who has touched them
+		if (tr.pHit == pOther)
+		{
+			// and it's not another squeakgrenade
+			if (tr.pHit->v.modelindex != pev->modelindex)
+			{
+				// ALERT( at_console, "hit enemy\n");
+				ClearMultiDamage( );
+
+            if (UTIL_IsPlayer(pOther))
+					UTIL_TraceAttack(pOther, pev, gSkillData.snarkDmgBite, gpGlobals->v_forward, &tr, DMG_SLASH );
+            else if (pOther->v.euser4 != NULL)
+            {
+					CMBaseMonster *pMonster = GetClassPtr((CMBaseMonster *)VARS(pOther));
+					pMonster->TraceAttack(pev, gSkillData.snarkDmgBite, gpGlobals->v_forward, &tr, DMG_SLASH );
+            }
+
+				ApplyMultiDamage( pev, pev );
+
+				pev->dmg += gSkillData.snarkDmgPop; // add more explosion damage
+				// m_flDie += 2.0; // add more life
+
+				// make bite sound
+				EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, "squeek/sqk_deploy1.wav", 1.0, ATTN_NORM, 0, (int)flpitch);
+				m_flNextAttack = gpGlobals->time + 0.5;
+			}
+		}
+		else
+		{
+			// ALERT( at_console, "been hit\n");
+		}
+	}
+
+	m_flNextHit = gpGlobals->time + 0.1;
+	m_flNextHunt = gpGlobals->time;
+
+		// in multiplayer, we limit how often snarks can make their bounce sounds to prevent overflows.
+	if ( gpGlobals->time < m_flNextBounceSoundTime )
+	{
+		// too soon!
+		return;
+	}
+
+	if (!(pev->flags & FL_ONGROUND))
+	{
+		// play bounce sound
+		float flRndSound = RANDOM_FLOAT ( 0 , 1 );
+
+		if ( flRndSound <= 0.33 )
+			EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_hunt1.wav", 1, ATTN_NORM, 0, (int)flpitch);		
+		else if (flRndSound <= 0.66)
+			EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_hunt2.wav", 1, ATTN_NORM, 0, (int)flpitch);
+		else 
+			EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_hunt3.wav", 1, ATTN_NORM, 0, (int)flpitch);
+	}
+
+	m_flNextBounceSoundTime = gpGlobals->time + 0.5;// half second.
+}
+
+#endif
+
+#endif

src/dlls/subs.cpp

@@ -0,0 +1,470 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/*
+
+===== subs.cpp ========================================================
+
+  frequently used global functions
+
+*/
+
+#include "extdll.h"
+#include "util.h"
+#include "cmbase.h"
+#include "nodes.h"
+#include "doors.h"
+
+extern CGraph WorldGraph;
+
+extern BOOL FEntIsVisible(entvars_t* pev, entvars_t* pevTarget);
+
+void Remove_Entity(edict_t *pEdict);
+
+
+// Landmark class
+void CMPointEntity :: Spawn( void )
+{
+	pev->solid = SOLID_NOT;
+//	UTIL_SetSize(pev, g_vecZero, g_vecZero);
+}
+
+
+// This updates global tables that need to know about entities being removed
+void CMBaseEntity::UpdateOnRemove( void )
+{
+	int	i;
+
+	if ( FBitSet( pev->flags, FL_GRAPHED ) )
+	{
+	// this entity was a LinkEnt in the world node graph, so we must remove it from
+	// the graph since we are removing it from the world.
+		for ( i = 0 ; i < WorldGraph.m_cLinks ; i++ )
+		{
+			if ( WorldGraph.m_pLinkPool [ i ].m_pLinkEnt == pev )
+			{
+				// if this link has a link ent which is the same ent that is removing itself, remove it!
+				WorldGraph.m_pLinkPool [ i ].m_pLinkEnt = NULL;
+			}
+		}
+	}
+//jlb	if ( pev->globalname )
+//jlb		gGlobalState.EntitySetState( pev->globalname, GLOBAL_DEAD );
+}
+
+// Convenient way to delay removing oneself
+void CMBaseEntity :: SUB_Remove( void )
+{
+	UpdateOnRemove();
+	if (pev->health > 0)
+	{
+		// this situation can screw up monsters who can't tell their entity pointers are invalid.
+		pev->health = 0;
+		ALERT( at_aiconsole, "SUB_Remove called on entity with health > 0\n");
+	}
+
+//	REMOVE_ENTITY(ENT(pev));
+   Remove_Entity(ENT(pev));
+}
+
+
+// Convenient way to explicitly do nothing (passed to functions that require a method)
+void CMBaseEntity :: SUB_DoNothing( void )
+{
+}
+
+
+void CMBaseDelay :: KeyValue( KeyValueData *pkvd )
+{
+	if (FStrEq(pkvd->szKeyName, "delay"))
+	{
+		m_flDelay = atof( pkvd->szValue );
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "killtarget"))
+	{
+		m_iszKillTarget = ALLOC_STRING(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else
+	{
+		CMBaseEntity::KeyValue( pkvd );
+	}
+}
+
+
+/*
+==============================
+SUB_UseTargets
+
+If self.delay is set, a DelayedUse entity will be created that will actually
+do the SUB_UseTargets after that many seconds have passed.
+
+Removes all entities with a targetname that match self.killtarget,
+and removes them, so some events can remove other triggers.
+
+Search for (string)targetname in all entities that
+match (string)self.target and call their .use function (if they have one)
+
+==============================
+*/
+void CMBaseEntity :: SUB_UseTargets( edict_t *pActivator, USE_TYPE useType, float value )
+{
+	//
+	// fire targets
+	//
+	if (!FStringNull(pev->target))
+	{
+		FireTargets( STRING(pev->target), pActivator, this->edict(), useType, value );
+	}
+}
+
+
+void FireTargets( const char *targetName, edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value )
+{
+	edict_t *pentTarget = NULL;
+	if ( !targetName )
+		return;
+
+	ALERT( at_aiconsole, "Firing: (%s)\n", targetName );
+
+	for (;;)
+	{
+		pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, targetName);
+		if (FNullEnt(pentTarget))
+			break;
+
+		CMBaseEntity *pTarget = CMBaseEntity::Instance( pentTarget );
+		if ( pTarget && !(pTarget->pev->flags & FL_KILLME) )	// Don't use dying ents
+		{
+			ALERT( at_aiconsole, "Found: %s, firing (%s)\n", STRING(pTarget->pev->classname), targetName );
+			pTarget->Use( pActivator, pCaller, useType, value );
+		}
+	}
+}
+
+void CMBaseDelay :: SUB_UseTargets( edict_t *pActivator, USE_TYPE useType, float value )
+{
+	//
+	// exit immediatly if we don't have a target or kill target
+	//
+	if (FStringNull(pev->target) && !m_iszKillTarget)
+		return;
+
+	//
+	// check for a delay
+	//
+	if (m_flDelay != 0)
+	{
+		// create a temp object to fire at a later time
+		CMBaseDelay *pTemp = CreateClassPtr( (CMBaseDelay *)NULL);
+
+      if (pTemp == NULL)
+         return;
+
+		pTemp->pev->classname = MAKE_STRING("DelayedUse");
+
+		pTemp->pev->nextthink = gpGlobals->time + m_flDelay;
+
+		pTemp->SetThink( DelayThink );
+		
+		// Save the useType
+		pTemp->pev->button = (int)useType;
+		pTemp->m_iszKillTarget = m_iszKillTarget;
+		pTemp->m_flDelay = 0; // prevent "recursion"
+		pTemp->pev->target = pev->target;
+
+		// HACKHACK
+		// This wasn't in the release build of Half-Life.  We should have moved m_hActivator into this class
+		// but changing member variable hierarchy would break save/restore without some ugly code.
+		// This code is not as ugly as that code
+		if ( pActivator && UTIL_IsPlayer(pActivator) )		// If a player activates, then save it
+		{
+			pTemp->pev->owner = pActivator;
+		}
+		else
+		{
+			pTemp->pev->owner = NULL;
+		}
+
+		return;
+	}
+
+	//
+	// kill the killtargets
+	//
+
+	if ( m_iszKillTarget )
+	{
+		edict_t *pentKillTarget = NULL;
+
+		ALERT( at_aiconsole, "KillTarget: %s\n", STRING(m_iszKillTarget) );
+		pentKillTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(m_iszKillTarget) );
+		while ( !FNullEnt(pentKillTarget) )
+		{
+			UTIL_Remove( CMBaseEntity::Instance(pentKillTarget)->edict() );
+
+			ALERT( at_aiconsole, "killing %s\n", STRING( pentKillTarget->v.classname ) );
+			pentKillTarget = FIND_ENTITY_BY_TARGETNAME( pentKillTarget, STRING(m_iszKillTarget) );
+		}
+	}
+	
+	//
+	// fire targets
+	//
+	if (!FStringNull(pev->target))
+	{
+		FireTargets( STRING(pev->target), pActivator, this->edict(), useType, value );
+	}
+}
+
+
+/*
+QuakeEd only writes a single float for angles (bad idea), so up and down are
+just constant angles.
+*/
+void SetMovedir( entvars_t *pev )
+{
+	if (pev->angles == Vector(0, -1, 0))
+	{
+		pev->movedir = Vector(0, 0, 1);
+	}
+	else if (pev->angles == Vector(0, -2, 0))
+	{
+		pev->movedir = Vector(0, 0, -1);
+	}
+	else
+	{
+		UTIL_MakeVectors(pev->angles);
+		pev->movedir = gpGlobals->v_forward;
+	}
+	
+	pev->angles = g_vecZero;
+}
+
+
+
+
+void CMBaseDelay::DelayThink( void )
+{
+	edict_t *pActivator = NULL;
+
+	if ( pev->owner != NULL )		// A player activated this on delay
+	{
+		pActivator = ENT(pev->owner);
+	}
+	// The use type is cached (and stashed) in pev->button
+	SUB_UseTargets( pActivator, (USE_TYPE)pev->button, 0 );
+//	REMOVE_ENTITY(ENT(pev));
+   Remove_Entity(ENT(pev));
+}
+
+
+void CMBaseToggle::KeyValue( KeyValueData *pkvd )
+{
+	if (FStrEq(pkvd->szKeyName, "lip"))
+	{
+		m_flLip = atof(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "wait"))
+	{
+		m_flWait = atof(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "master"))
+	{
+		m_sMaster = ALLOC_STRING(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "distance"))
+	{
+		m_flMoveDistance = atof(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else
+		CMBaseDelay::KeyValue( pkvd );
+}
+
+/*
+=============
+LinearMove
+
+calculate pev->velocity and pev->nextthink to reach vecDest from
+pev->origin traveling at flSpeed
+===============
+*/
+void CMBaseToggle ::  LinearMove( Vector	vecDest, float flSpeed )
+{
+	ASSERTSZ(flSpeed != 0, "LinearMove:  no speed is defined!");
+//	ASSERTSZ(m_pfnCallWhenMoveDone != NULL, "LinearMove: no post-move function defined");
+	
+	m_vecFinalDest = vecDest;
+
+	// Already there?
+	if (vecDest == pev->origin)
+	{
+		LinearMoveDone();
+		return;
+	}
+		
+	// set destdelta to the vector needed to move
+	Vector vecDestDelta = vecDest - pev->origin;
+	
+	// divide vector length by speed to get time to reach dest
+	float flTravelTime = vecDestDelta.Length() / flSpeed;
+
+	// set nextthink to trigger a call to LinearMoveDone when dest is reached
+	pev->nextthink = pev->ltime + flTravelTime;
+	SetThink( LinearMoveDone );
+
+	// scale the destdelta vector by the time spent traveling to get velocity
+	pev->velocity = vecDestDelta / flTravelTime;
+}
+
+
+/*
+============
+After moving, set origin to exact final destination, call "move done" function
+============
+*/
+void CMBaseToggle :: LinearMoveDone( void )
+{
+	UTIL_SetOrigin(pev, m_vecFinalDest);
+	pev->velocity = g_vecZero;
+	pev->nextthink = -1;
+	if ( m_pfnCallWhenMoveDone )
+		(this->*m_pfnCallWhenMoveDone)();
+}
+
+BOOL CMBaseToggle :: IsLockedByMaster( void )
+{
+		return FALSE;
+}
+
+/*
+=============
+AngularMove
+
+calculate pev->velocity and pev->nextthink to reach vecDest from
+pev->origin traveling at flSpeed
+Just like LinearMove, but rotational.
+===============
+*/
+void CMBaseToggle :: AngularMove( Vector vecDestAngle, float flSpeed )
+{
+	ASSERTSZ(flSpeed != 0, "AngularMove:  no speed is defined!");
+//	ASSERTSZ(m_pfnCallWhenMoveDone != NULL, "AngularMove: no post-move function defined");
+	
+	m_vecFinalAngle = vecDestAngle;
+
+	// Already there?
+	if (vecDestAngle == pev->angles)
+	{
+		AngularMoveDone();
+		return;
+	}
+	
+	// set destdelta to the vector needed to move
+	Vector vecDestDelta = vecDestAngle - pev->angles;
+	
+	// divide by speed to get time to reach dest
+	float flTravelTime = vecDestDelta.Length() / flSpeed;
+
+	// set nextthink to trigger a call to AngularMoveDone when dest is reached
+	pev->nextthink = pev->ltime + flTravelTime;
+	SetThink( AngularMoveDone );
+
+	// scale the destdelta vector by the time spent traveling to get velocity
+	pev->avelocity = vecDestDelta / flTravelTime;
+}
+
+
+/*
+============
+After rotating, set angle to exact final angle, call "move done" function
+============
+*/
+void CMBaseToggle :: AngularMoveDone( void )
+{
+	pev->angles = m_vecFinalAngle;
+	pev->avelocity = g_vecZero;
+	pev->nextthink = -1;
+	if ( m_pfnCallWhenMoveDone )
+		(this->*m_pfnCallWhenMoveDone)();
+}
+
+
+float CMBaseToggle :: AxisValue( int flags, const Vector &angles )
+{
+	if ( FBitSet(flags, SF_DOOR_ROTATE_Z) )
+		return angles.z;
+	if ( FBitSet(flags, SF_DOOR_ROTATE_X) )
+		return angles.x;
+
+	return angles.y;
+}
+
+
+void CMBaseToggle :: AxisDir( entvars_t *pev )
+{
+	if ( FBitSet(pev->spawnflags, SF_DOOR_ROTATE_Z) )
+		pev->movedir = Vector ( 0, 0, 1 );	// around z-axis
+	else if ( FBitSet(pev->spawnflags, SF_DOOR_ROTATE_X) )
+		pev->movedir = Vector ( 1, 0, 0 );	// around x-axis
+	else
+		pev->movedir = Vector ( 0, 1, 0 );		// around y-axis
+}
+
+
+float CMBaseToggle :: AxisDelta( int flags, const Vector &angle1, const Vector &angle2 )
+{
+	if ( FBitSet (flags, SF_DOOR_ROTATE_Z) )
+		return angle1.z - angle2.z;
+	
+	if ( FBitSet (flags, SF_DOOR_ROTATE_X) )
+		return angle1.x - angle2.x;
+
+	return angle1.y - angle2.y;
+}
+
+
+/*
+=============
+FEntIsVisible
+
+returns TRUE if the passed entity is visible to caller, even if not infront ()
+=============
+*/
+	BOOL
+FEntIsVisible(
+	entvars_t*		pev,
+	entvars_t*		pevTarget)
+	{
+	Vector vecSpot1 = pev->origin + pev->view_ofs;
+	Vector vecSpot2 = pevTarget->origin + pevTarget->view_ofs;
+	TraceResult tr;
+
+	UTIL_TraceLine(vecSpot1, vecSpot2, ignore_monsters, ENT(pev), &tr);
+	
+	if (tr.fInOpen && tr.fInWater)
+		return FALSE;                   // sight line crossed contents
+
+	if (tr.flFraction == 1)
+		return TRUE;
+
+	return FALSE;
+	}
+
+

src/dlls/util.h

@@ -0,0 +1,539 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+// Misc utility code
+//
+#ifndef ACTIVITY_H
+#include "activity.h"
+#endif
+
+#ifndef ENGINECALLBACK_H
+#include "enginecallback.h"
+#endif
+inline void MESSAGE_BEGIN( int msg_dest, int msg_type, const float *pOrigin, entvars_t *ent );  // implementation later in this file
+
+extern globalvars_t				*gpGlobals;
+extern cvar_t   *g_psv_gravity;
+
+// Use this instead of ALLOC_STRING on constant strings
+#define STRING(offset)		(const char *)(gpGlobals->pStringBase + (int)offset)
+#define MAKE_STRING(str)	((int)str - (int)STRING(0))
+
+inline edict_t *FIND_ENTITY_BY_CLASSNAME(edict_t *entStart, const char *pszName) 
+{
+	return FIND_ENTITY_BY_STRING(entStart, "classname", pszName);
+}	
+
+inline edict_t *FIND_ENTITY_BY_TARGETNAME(edict_t *entStart, const char *pszName) 
+{
+	return FIND_ENTITY_BY_STRING(entStart, "targetname", pszName);
+}	
+
+// for doing a reverse lookup. Say you have a door, and want to find its button.
+inline edict_t *FIND_ENTITY_BY_TARGET(edict_t *entStart, const char *pszName) 
+{
+	return FIND_ENTITY_BY_STRING(entStart, "target", pszName);
+}	
+
+// Keeps clutter down a bit, when writing key-value pairs
+#define WRITEKEY_INT(pf, szKeyName, iKeyValue) ENGINE_FPRINTF(pf, "\"%s\" \"%d\"\n", szKeyName, iKeyValue)
+#define WRITEKEY_FLOAT(pf, szKeyName, flKeyValue)								\
+		ENGINE_FPRINTF(pf, "\"%s\" \"%f\"\n", szKeyName, flKeyValue)
+#define WRITEKEY_STRING(pf, szKeyName, szKeyValue)								\
+		ENGINE_FPRINTF(pf, "\"%s\" \"%s\"\n", szKeyName, szKeyValue)
+#define WRITEKEY_VECTOR(pf, szKeyName, flX, flY, flZ)							\
+		ENGINE_FPRINTF(pf, "\"%s\" \"%f %f %f\"\n", szKeyName, flX, flY, flZ)
+
+// Keeps clutter down a bit, when using a float as a bit-vector
+#define SetBits(flBitVector, bits)		((flBitVector) = (int)(flBitVector) | (bits))
+#define ClearBits(flBitVector, bits)	((flBitVector) = (int)(flBitVector) & ~(bits))
+#define FBitSet(flBitVector, bit)		((int)(flBitVector) & (bit))
+
+// Makes these more explicit, and easier to find
+#define FILE_GLOBAL static
+#define DLL_GLOBAL
+
+// Until we figure out why "const" gives the compiler problems, we'll just have to use
+// this bogus "empty" define to mark things as constant.
+#define CONSTANT
+
+// More explicit than "int"
+typedef int EOFFSET;
+
+// In case it's not alread defined
+typedef int BOOL;
+
+// In case this ever changes
+#define M_PI			3.14159265358979323846
+
+// Keeps clutter down a bit, when declaring external entity/global method prototypes
+#define DECLARE_GLOBAL_METHOD(MethodName)  extern void DLLEXPORT MethodName( void )
+#define GLOBAL_METHOD(funcname)					void DLLEXPORT funcname(void)
+
+//
+// Conversion among the three types of "entity", including identity-conversions.
+//
+#ifdef DEBUG
+	extern edict_t *DBG_EntOfVars(const entvars_t *pev);
+	inline edict_t *ENT(const entvars_t *pev)	{ return DBG_EntOfVars(pev); }
+#else
+	inline edict_t *ENT(const entvars_t *pev)	{ return pev->pContainingEntity; }
+#endif
+inline edict_t *ENT(edict_t *pent)		{ return pent; }
+inline edict_t *ENT(EOFFSET eoffset)			{ return (*g_engfuncs.pfnPEntityOfEntOffset)(eoffset); }
+inline EOFFSET OFFSET(EOFFSET eoffset)			{ return eoffset; }
+inline EOFFSET OFFSET(const edict_t *pent)	
+{ 
+#if _DEBUG
+	if ( !pent )
+		ALERT( at_error, "Bad ent in OFFSET()\n" );
+#endif
+	return (*g_engfuncs.pfnEntOffsetOfPEntity)(pent); 
+}
+inline EOFFSET OFFSET(entvars_t *pev)				
+{ 
+#if _DEBUG
+	if ( !pev )
+		ALERT( at_error, "Bad pev in OFFSET()\n" );
+#endif
+	return OFFSET(ENT(pev)); 
+}
+inline entvars_t *VARS(entvars_t *pev)					{ return pev; }
+
+inline entvars_t *VARS(edict_t *pent)			
+{ 
+	if ( !pent )
+		return NULL;
+
+	return &pent->v; 
+}
+
+inline entvars_t* VARS(EOFFSET eoffset)				{ return VARS(ENT(eoffset)); }
+inline int	  ENTINDEX(edict_t *pEdict)			{ return (*g_engfuncs.pfnIndexOfEdict)(pEdict); }
+inline edict_t* INDEXENT( int iEdictNum )		{ return (*g_engfuncs.pfnPEntityOfEntIndex)(iEdictNum); }
+inline void MESSAGE_BEGIN( int msg_dest, int msg_type, const float *pOrigin, entvars_t *ent ) {
+	(*g_engfuncs.pfnMessageBegin)(msg_dest, msg_type, pOrigin, ENT(ent));
+}
+
+// Testing the three types of "entity" for nullity
+#define eoNullEntity 0
+inline BOOL FNullEnt(EOFFSET eoffset)			{ return eoffset == 0; }
+inline BOOL FNullEnt(const edict_t* pent)	{ return pent == NULL || FNullEnt(OFFSET(pent)); }
+inline BOOL FNullEnt(entvars_t* pev)				{ return pev == NULL || FNullEnt(OFFSET(pev)); }
+
+// Testing strings for nullity
+#define iStringNull 0
+inline BOOL FStringNull(int iString)			{ return iString == iStringNull; }
+
+#define cchMapNameMost 32
+
+// Dot products for view cone checking
+#define VIEW_FIELD_FULL		(float)-1.0 // +-180 degrees
+#define	VIEW_FIELD_WIDE		(float)-0.7 // +-135 degrees 0.1 // +-85 degrees, used for full FOV checks 
+#define	VIEW_FIELD_NARROW	(float)0.7 // +-45 degrees, more narrow check used to set up ranged attacks
+#define	VIEW_FIELD_ULTRA_NARROW	(float)0.9 // +-25 degrees, more narrow check used to set up ranged attacks
+
+// All monsters need this data
+#define		DONT_BLEED			-1
+#define		BLOOD_COLOR_RED		(BYTE)247
+#define		BLOOD_COLOR_YELLOW	(BYTE)195
+#define		BLOOD_COLOR_GREEN	BLOOD_COLOR_YELLOW
+
+typedef enum 
+{
+
+	MONSTERSTATE_NONE = 0,
+	MONSTERSTATE_IDLE,
+	MONSTERSTATE_COMBAT,
+	MONSTERSTATE_ALERT,
+	MONSTERSTATE_HUNT,
+	MONSTERSTATE_PRONE,
+	MONSTERSTATE_SCRIPT,
+	MONSTERSTATE_PLAYDEAD,
+	MONSTERSTATE_DEAD
+
+} MONSTERSTATE;
+
+
+
+// Things that toggle (buttons/triggers/doors) need this
+typedef enum
+	{
+	TS_AT_TOP,
+	TS_AT_BOTTOM,
+	TS_GOING_UP,
+	TS_GOING_DOWN
+	} TOGGLE_STATE;
+
+// Misc useful
+inline BOOL FStrEq(const char*sz1, const char*sz2)
+	{ return (strcmp(sz1, sz2) == 0); }
+inline BOOL FClassnameIs(edict_t* pent, const char* szClassname)
+	{ return FStrEq(STRING(VARS(pent)->classname), szClassname); }
+inline BOOL FClassnameIs(entvars_t* pev, const char* szClassname)
+	{ return FStrEq(STRING(pev->classname), szClassname); }
+
+// Misc. Prototypes
+extern void			UTIL_SetSize			(entvars_t* pev, const Vector &vecMin, const Vector &vecMax);
+extern float		UTIL_VecToYaw			(const Vector &vec);
+extern Vector		UTIL_VecToAngles		(const Vector &vec);
+extern float		UTIL_AngleMod			(float a);
+extern float		UTIL_AngleDiff			( float destAngle, float srcAngle );
+
+extern edict_t	*UTIL_FindEntityInSphere(edict_t *pStartEntity, const Vector &vecCenter, float flRadius);
+extern edict_t	*UTIL_FindEntityByString(edict_t *pStartEntity, const char *szKeyword, const char *szValue );
+extern edict_t	*UTIL_FindEntityByClassname(edict_t *pStartEntity, const char *szName );
+extern edict_t	*UTIL_FindEntityByTargetname(edict_t *pStartEntity, const char *szName );
+extern edict_t	*UTIL_FindEntityGeneric(const char *szName, Vector &vecSrc, float flRadius );
+
+// returns a edict_t pointer to a player by index.  Only returns if the player is spawned and connected
+// otherwise returns NULL
+// Index is 1 based
+extern edict_t	*UTIL_PlayerByIndex( int playerIndex );
+
+#define UTIL_EntitiesInPVS(pent)			(*g_engfuncs.pfnEntitiesInPVS)(pent)
+extern void			UTIL_MakeVectors		(const Vector &vecAngles);
+
+// Pass in an array of pointers and an array size, it fills the array and returns the number inserted
+extern int			UTIL_MonstersInSphere( edict_t **pList, int listMax, const Vector &center, float radius );
+extern int			UTIL_EntitiesInBox( edict_t **pList, int listMax, const Vector &mins, const Vector &maxs, int flagMask );
+
+inline void UTIL_MakeVectorsPrivate( const Vector &vecAngles, float *p_vForward, float *p_vRight, float *p_vUp )
+{
+	g_engfuncs.pfnAngleVectors( vecAngles, p_vForward, p_vRight, p_vUp );
+}
+
+extern void			UTIL_MakeAimVectors		( const Vector &vecAngles ); // like MakeVectors, but assumes pitch isn't inverted
+extern void			UTIL_MakeInvVectors		( const Vector &vec, globalvars_t *pgv );
+
+extern void			UTIL_SetOrigin			( entvars_t* pev, const Vector &vecOrigin );
+extern void			UTIL_EmitAmbientSound	( edict_t *entity, const Vector &vecOrigin, const char *samp, float vol, float attenuation, int fFlags, int pitch );
+extern void			UTIL_ParticleEffect		( const Vector &vecOrigin, const Vector &vecDirection, ULONG ulColor, ULONG ulCount );
+extern void			UTIL_ScreenShake		( const Vector &center, float amplitude, float frequency, float duration, float radius );
+extern void			UTIL_ScreenShakeAll		( const Vector &center, float amplitude, float frequency, float duration );
+extern void			UTIL_ShowMessage		( const char *pString, edict_t *pPlayer );
+extern void			UTIL_ShowMessageAll		( const char *pString );
+extern void			UTIL_ScreenFadeAll		( const Vector &color, float fadeTime, float holdTime, int alpha, int flags );
+extern void			UTIL_ScreenFade			( edict_t *pEntity, const Vector &color, float fadeTime, float fadeHold, int alpha, int flags );
+
+typedef enum { ignore_monsters=1, dont_ignore_monsters=0, missile=2 } IGNORE_MONSTERS;
+typedef enum { ignore_glass=1, dont_ignore_glass=0 } IGNORE_GLASS;
+extern void			UTIL_TraceLine			(const Vector &vecStart, const Vector &vecEnd, IGNORE_MONSTERS igmon, edict_t *pentIgnore, TraceResult *ptr);
+extern void			UTIL_TraceLine			(const Vector &vecStart, const Vector &vecEnd, IGNORE_MONSTERS igmon, IGNORE_GLASS ignoreGlass, edict_t *pentIgnore, TraceResult *ptr);
+typedef enum { point_hull=0, human_hull=1, large_hull=2, head_hull=3 };
+extern void			UTIL_TraceHull			(const Vector &vecStart, const Vector &vecEnd, IGNORE_MONSTERS igmon, int hullNumber, edict_t *pentIgnore, TraceResult *ptr);
+extern TraceResult	UTIL_GetGlobalTrace		(void);
+extern void			UTIL_TraceModel			(const Vector &vecStart, const Vector &vecEnd, int hullNumber, edict_t *pentModel, TraceResult *ptr);
+extern Vector		UTIL_GetAimVector		(edict_t* pent, float flSpeed);
+extern int			UTIL_PointContents		(const Vector &vec);
+
+extern void			UTIL_BloodStream( const Vector &origin, const Vector &direction, int color, int amount );
+extern void			UTIL_BloodDrips( const Vector &origin, const Vector &direction, int color, int amount );
+extern Vector		UTIL_RandomBloodVector( void );
+extern BOOL			UTIL_ShouldShowBlood( int bloodColor );
+extern void			UTIL_BloodDecalTrace( TraceResult *pTrace, int bloodColor );
+extern void			UTIL_DecalTrace( TraceResult *pTrace, int decalNumber );
+extern void			UTIL_PlayerDecalTrace( TraceResult *pTrace, int playernum, int decalNumber, BOOL bIsCustom );
+extern void			UTIL_GunshotDecalTrace( TraceResult *pTrace, int decalNumber );
+extern void			UTIL_Sparks( const Vector &position );
+extern void			UTIL_Ricochet( const Vector &position, float scale );
+extern void			UTIL_StringToVector( float *pVector, const char *pString );
+extern void			UTIL_StringToIntArray( int *pVector, int count, const char *pString );
+extern Vector		UTIL_ClampVectorToBox( const Vector &input, const Vector &clampSize );
+extern float		UTIL_Approach( float target, float value, float speed );
+extern float		UTIL_ApproachAngle( float target, float value, float speed );
+extern float		UTIL_AngleDistance( float next, float cur );
+
+extern char			*UTIL_VarArgs( char *format, ... );
+extern void			UTIL_Remove( edict_t *pEntity );
+extern BOOL			UTIL_IsValidEntity( edict_t *pent );
+
+// Use for ease-in, ease-out style interpolation (accel/decel)
+extern float		UTIL_SplineFraction( float value, float scale );
+
+// Search for water transition along a vertical line
+extern float		UTIL_WaterLevel( const Vector &position, float minz, float maxz );
+extern void			UTIL_Bubbles( Vector mins, Vector maxs, int count );
+extern void			UTIL_BubbleTrail( Vector from, Vector to, int count );
+
+// prints a message to each client
+extern void			UTIL_ClientPrintAll( int msg_dest, const char *msg_name, const char *param1 = NULL, const char *param2 = NULL, const char *param3 = NULL, const char *param4 = NULL );
+inline void			UTIL_CenterPrintAll( const char *msg_name, const char *param1 = NULL, const char *param2 = NULL, const char *param3 = NULL, const char *param4 = NULL ) 
+{
+	UTIL_ClientPrintAll( HUD_PRINTCENTER, msg_name, param1, param2, param3, param4 );
+}
+
+// prints messages through the HUD
+extern void ClientPrint( entvars_t *client, int msg_dest, const char *msg_name, const char *param1 = NULL, const char *param2 = NULL, const char *param3 = NULL, const char *param4 = NULL );
+
+// prints a message to the HUD say (chat)
+extern void			UTIL_SayText( const char *pText, edict_t *pEntity );
+extern void			UTIL_SayTextAll( const char *pText, edict_t *pEntity );
+
+
+typedef struct hudtextparms_s
+{
+	float		x;
+	float		y;
+	int			effect;
+	byte		r1, g1, b1, a1;
+	byte		r2, g2, b2, a2;
+	float		fadeinTime;
+	float		fadeoutTime;
+	float		holdTime;
+	float		fxTime;
+	int			channel;
+} hudtextparms_t;
+
+// prints as transparent 'title' to the HUD
+extern void			UTIL_HudMessageAll( const hudtextparms_t &textparms, const char *pMessage );
+extern void			UTIL_HudMessage( edict_t *pEntity, const hudtextparms_t &textparms, const char *pMessage );
+
+// for handy use with ClientPrint params
+extern char *UTIL_dtos1( int d );
+extern char *UTIL_dtos2( int d );
+extern char *UTIL_dtos3( int d );
+extern char *UTIL_dtos4( int d );
+
+// Writes message to console with timestamp and FragLog header.
+extern void			UTIL_LogPrintf( char *fmt, ... );
+
+// Sorta like FInViewCone, but for nonmonsters. 
+extern float UTIL_DotPoints ( const Vector &vecSrc, const Vector &vecCheck, const Vector &vecDir );
+
+extern void UTIL_StripToken( const char *pKey, char *pDest );// for redundant keynames
+
+// Misc functions
+extern void SetMovedir(entvars_t* pev);
+extern int BuildChangeList( LEVELLIST *pLevelList, int maxList );
+
+//
+// How did I ever live without ASSERT?
+//
+#ifdef	DEBUG
+void DBG_AssertFunction(BOOL fExpr, const char* szExpr, const char* szFile, int szLine, const char* szMessage);
+#define ASSERT(f)		DBG_AssertFunction(f, #f, __FILE__, __LINE__, NULL)
+#define ASSERTSZ(f, sz)	DBG_AssertFunction(f, #f, __FILE__, __LINE__, sz)
+#else	// !DEBUG
+#define ASSERT(f)
+#define ASSERTSZ(f, sz)
+#endif	// !DEBUG
+
+
+extern DLL_GLOBAL const Vector g_vecZero;
+
+//
+// Constants that were used only by QC (maybe not used at all now)
+//
+// Un-comment only as needed
+//
+#define LANGUAGE_ENGLISH				0
+#define LANGUAGE_GERMAN					1
+#define LANGUAGE_FRENCH					2
+#define LANGUAGE_BRITISH				3
+
+#define AMBIENT_SOUND_STATIC			0	// medium radius attenuation
+#define AMBIENT_SOUND_EVERYWHERE		1
+#define AMBIENT_SOUND_SMALLRADIUS		2
+#define AMBIENT_SOUND_MEDIUMRADIUS		4
+#define AMBIENT_SOUND_LARGERADIUS		8
+#define AMBIENT_SOUND_START_SILENT		16
+#define AMBIENT_SOUND_NOT_LOOPING		32
+
+#define SPEAKER_START_SILENT			1	// wait for trigger 'on' to start announcements
+
+#define SND_SPAWNING		(1<<8)		// duplicated in protocol.h we're spawing, used in some cases for ambients 
+#define SND_STOP			(1<<5)		// duplicated in protocol.h stop sound
+#define SND_CHANGE_VOL		(1<<6)		// duplicated in protocol.h change sound vol
+#define SND_CHANGE_PITCH	(1<<7)		// duplicated in protocol.h change sound pitch
+
+#define	LFO_SQUARE			1
+#define LFO_TRIANGLE		2
+#define LFO_RANDOM			3
+
+// func_rotating
+#define SF_BRUSH_ROTATE_Y_AXIS		0
+#define SF_BRUSH_ROTATE_INSTANT		1
+#define SF_BRUSH_ROTATE_BACKWARDS	2
+#define SF_BRUSH_ROTATE_Z_AXIS		4
+#define SF_BRUSH_ROTATE_X_AXIS		8
+#define SF_PENDULUM_AUTO_RETURN		16
+#define	SF_PENDULUM_PASSABLE		32
+
+
+#define SF_BRUSH_ROTATE_SMALLRADIUS	128
+#define SF_BRUSH_ROTATE_MEDIUMRADIUS 256
+#define SF_BRUSH_ROTATE_LARGERADIUS 512
+
+#define PUSH_BLOCK_ONLY_X	1
+#define PUSH_BLOCK_ONLY_Y	2
+
+#define VEC_HULL_MIN		Vector(-16, -16, -36)
+#define VEC_HULL_MAX		Vector( 16,  16,  36)
+#define VEC_HUMAN_HULL_MIN	Vector( -16, -16, 0 )
+#define VEC_HUMAN_HULL_MAX	Vector( 16, 16, 72 )
+#define VEC_HUMAN_HULL_DUCK	Vector( 16, 16, 36 )
+
+#define VEC_VIEW			Vector( 0, 0, 28 )
+
+#define VEC_DUCK_HULL_MIN	Vector(-16, -16, -18 )
+#define VEC_DUCK_HULL_MAX	Vector( 16,  16,  18)
+#define VEC_DUCK_VIEW		Vector( 0, 0, 12 )
+
+#define SVC_TEMPENTITY		23
+#define SVC_INTERMISSION	30
+#define SVC_CDTRACK			32
+#define SVC_WEAPONANIM		35
+#define SVC_ROOMTYPE		37
+#define	SVC_HLTV			50
+
+// prxoy director stuff
+#define DRC_EVENT			3	// informs the dircetor about ann important game event
+
+#define DRC_FLAG_PRIO_MASK		0x0F	//	priorities between 0 and 15 (15 most important)
+#define DRC_FLAG_DRAMATIC		(1<<5)
+
+// triggers
+#define	SF_TRIGGER_ALLOWMONSTERS	1// monsters allowed to fire this trigger
+#define	SF_TRIGGER_NOCLIENTS		2// players not allowed to fire this trigger
+#define SF_TRIGGER_PUSHABLES		4// only pushables can fire this trigger
+
+// func breakable
+#define SF_BREAK_TRIGGER_ONLY	1// may only be broken by trigger
+#define	SF_BREAK_TOUCH			2// can be 'crashed through' by running player (plate glass)
+#define SF_BREAK_PRESSURE		4// can be broken by a player standing on it
+#define SF_BREAK_CROWBAR		256// instant break if hit with crowbar
+
+// func_pushable (it's also func_breakable, so don't collide with those flags)
+#define SF_PUSH_BREAKABLE		128
+
+#define SF_LIGHT_START_OFF		1
+
+#define SPAWNFLAG_NOMESSAGE	1
+#define SPAWNFLAG_NOTOUCH	1
+#define SPAWNFLAG_DROIDONLY	4
+
+#define SPAWNFLAG_USEONLY	1		// can't be touched, must be used (buttons)
+
+#define TELE_PLAYER_ONLY	1
+#define TELE_SILENT			2
+
+#define SF_TRIG_PUSH_ONCE		1
+
+
+// Sound Utilities
+
+// sentence groups
+#define CBSENTENCENAME_MAX 16
+#define CVOXFILESENTENCEMAX		1536		// max number of sentences in game. NOTE: this must match
+											// CVOXFILESENTENCEMAX in engine\sound.h!!!
+
+extern char gszallsentencenames[CVOXFILESENTENCEMAX][CBSENTENCENAME_MAX];
+extern int gcallsentences;
+
+int USENTENCEG_Pick(int isentenceg, char *szfound);
+int USENTENCEG_PickSequential(int isentenceg, char *szfound, int ipick, int freset);
+void USENTENCEG_InitLRU(unsigned char *plru, int count);
+
+void SENTENCEG_Init();
+void SENTENCEG_Stop(edict_t *entity, int isentenceg, int ipick);
+int SENTENCEG_PlayRndI(edict_t *entity, int isentenceg, float volume, float attenuation, int flags, int pitch);
+int SENTENCEG_PlayRndSz(edict_t *entity, const char *szrootname, float volume, float attenuation, int flags, int pitch);
+int SENTENCEG_PlaySequentialSz(edict_t *entity, const char *szrootname, float volume, float attenuation, int flags, int pitch, int ipick, int freset);
+int SENTENCEG_GetIndex(const char *szrootname);
+int SENTENCEG_Lookup(const char *sample, char *sentencenum);
+
+void TEXTURETYPE_Init();
+char TEXTURETYPE_Find(char *name);
+float TEXTURETYPE_PlaySound(TraceResult *ptr,  Vector vecSrc, Vector vecEnd, int iBulletType);
+
+// NOTE: use EMIT_SOUND_DYN to set the pitch of a sound. Pitch of 100
+// is no pitch shift.  Pitch > 100 up to 255 is a higher pitch, pitch < 100
+// down to 1 is a lower pitch.   150 to 70 is the realistic range.
+// EMIT_SOUND_DYN with pitch != 100 should be used sparingly, as it's not quite as
+// fast as EMIT_SOUND (the pitchshift mixer is not native coded).
+
+void EMIT_SOUND_DYN(edict_t *entity, int channel, const char *sample, float volume, float attenuation,
+						   int flags, int pitch);
+
+
+inline void EMIT_SOUND(edict_t *entity, int channel, const char *sample, float volume, float attenuation)
+{
+	EMIT_SOUND_DYN(entity, channel, sample, volume, attenuation, 0, PITCH_NORM);
+}
+
+inline void STOP_SOUND(edict_t *entity, int channel, const char *sample)
+{
+	EMIT_SOUND_DYN(entity, channel, sample, 0, 0, SND_STOP, PITCH_NORM);
+}
+
+void EMIT_SOUND_SUIT(edict_t *entity, const char *sample);
+void EMIT_GROUPID_SUIT(edict_t *entity, int isentenceg);
+void EMIT_GROUPNAME_SUIT(edict_t *entity, const char *groupname);
+
+#define PRECACHE_SOUND_ARRAY( a ) \
+	{ for (int i = 0; i < ARRAYSIZE( a ); i++ ) PRECACHE_SOUND((char *) a [i]); }
+
+#define EMIT_SOUND_ARRAY_DYN( chan, array ) \
+	EMIT_SOUND_DYN ( ENT(pev), chan , array [ RANDOM_LONG(0,ARRAYSIZE( array )-1) ], 1.0, ATTN_NORM, 0, RANDOM_LONG(95,105) ); 
+
+#define RANDOM_SOUND_ARRAY( array ) (array) [ RANDOM_LONG(0,ARRAYSIZE( (array) )-1) ]
+
+#define PLAYBACK_EVENT( flags, who, index ) PLAYBACK_EVENT_FULL( flags, who, index, 0, (float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, 0, 0, 0, 0 );
+#define PLAYBACK_EVENT_DELAY( flags, who, index, delay ) PLAYBACK_EVENT_FULL( flags, who, index, delay, (float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, 0, 0, 0, 0 );
+
+#define GROUP_OP_AND	0
+#define GROUP_OP_NAND	1
+
+extern int g_groupmask;
+extern int g_groupop;
+
+class UTIL_GroupTrace
+{
+public:
+	UTIL_GroupTrace( int groupmask, int op );
+	~UTIL_GroupTrace( void );
+
+private:
+	int m_oldgroupmask, m_oldgroupop;
+};
+
+void UTIL_SetGroupTrace( int groupmask, int op );
+void UTIL_UnsetGroupTrace( void );
+
+int UTIL_SharedRandomLong( unsigned int seed, int low, int high );
+float UTIL_SharedRandomFloat( unsigned int seed, float low, float high );
+
+float UTIL_WeaponTimeBase( void );
+
+Vector VecBModelOrigin( entvars_t* pevBModel );
+bool UTIL_IsAlive(entvars_t *pev);
+bool UTIL_IsAlive(edict_t *pEdict);
+bool UTIL_IsPlayer(edict_t *pEdict);
+Vector UTIL_BodyTarget(edict_t *pEdict, Vector posSrc);
+bool UTIL_FVisible(edict_t *pEdict, edict_t *pLooker);
+bool UTIL_FVisible ( const Vector &vecOrigin, edict_t *pLooker );
+bool UTIL_FInViewCone ( edict_t *pEntity, edict_t *pLooker, float fov );
+bool UTIL_FInViewCone ( Vector *pOrigin, edict_t *pLooker, float fov );
+int UTIL_TakeDamage( edict_t *pEdict, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
+int UTIL_TakeHealth (edict_t *pEdict, float flHealth, int bitsDamageType);
+void UTIL_TraceBleed( edict_t *pEdict, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
+void UTIL_TraceAttack( edict_t *pEdict, entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
+int UTIL_IsMoving(edict_t *pEdict);
+Vector UTIL_EyePosition(edict_t *pEdict);
+Vector UTIL_Center(edict_t *pEdict);
+edict_t *UTIL_GetNextTarget( edict_t *pEntity );
+edict_t *UTIL_FindNearestPlayer(edict_t *pEdict, float m_flFieldOfView);
+bool UTIL_IsBSPModel( edict_t *pent );

src/dlls/vector.h

@@ -0,0 +1,112 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef VECTOR_H
+#define VECTOR_H
+
+//=========================================================
+// 2DVector - used for many pathfinding and many other 
+// operations that are treated as planar rather than 3d.
+//=========================================================
+class Vector2D
+{
+public:
+	inline Vector2D(void)									{ }
+	inline Vector2D(float X, float Y)						{ x = X; y = Y; }
+	inline Vector2D operator+(const Vector2D& v)	const	{ return Vector2D(x+v.x, y+v.y);	}
+	inline Vector2D operator-(const Vector2D& v)	const	{ return Vector2D(x-v.x, y-v.y);	}
+	inline Vector2D operator*(float fl)				const	{ return Vector2D(x*fl, y*fl);	}
+	inline Vector2D operator/(float fl)				const	{ return Vector2D(x/fl, y/fl);	}
+	
+	inline float Length(void)						const	{ return sqrt(x*x + y*y );		}
+
+	inline Vector2D Normalize ( void ) const
+	{
+		Vector2D vec2;
+
+		float flLen = Length();
+		if ( flLen == 0 )
+		{
+			return Vector2D( 0, 0 );
+		}
+		else
+		{
+			flLen = 1 / flLen;
+			return Vector2D( x * flLen, y * flLen );
+		}
+	}
+
+	vec_t	x, y;
+};
+
+inline float DotProduct(const Vector2D& a, const Vector2D& b) { return( a.x*b.x + a.y*b.y ); }
+inline Vector2D operator*(float fl, const Vector2D& v)	{ return v * fl; }
+
+//=========================================================
+// 3D Vector
+//=========================================================
+class Vector						// same data-layout as engine's vec3_t,
+{								//		which is a vec_t[3]
+public:
+	// Construction/destruction
+	inline Vector(void)								{ }
+	inline Vector(float X, float Y, float Z)		{ x = X; y = Y; z = Z;						}
+	//inline Vector(double X, double Y, double Z)		{ x = (float)X; y = (float)Y; z = (float)Z;	}
+	//inline Vector(int X, int Y, int Z)				{ x = (float)X; y = (float)Y; z = (float)Z;	}
+	inline Vector(const Vector& v)					{ x = v.x; y = v.y; z = v.z;				} 
+	inline Vector(float rgfl[3])					{ x = rgfl[0]; y = rgfl[1]; z = rgfl[2];	}
+
+	// Operators
+	inline Vector operator-(void) const				{ return Vector(-x,-y,-z);				}
+	inline int operator==(const Vector& v) const	{ return x==v.x && y==v.y && z==v.z;	}
+	inline int operator!=(const Vector& v) const	{ return !(*this==v);					}
+	inline Vector operator+(const Vector& v) const	{ return Vector(x+v.x, y+v.y, z+v.z);	}
+	inline Vector operator-(const Vector& v) const	{ return Vector(x-v.x, y-v.y, z-v.z);	}
+	inline Vector operator*(float fl) const			{ return Vector(x*fl, y*fl, z*fl);		}
+	inline Vector operator/(float fl) const			{ return Vector(x/fl, y/fl, z/fl);		}
+	
+	// Methods
+	inline void CopyToArray(float* rgfl) const		{ rgfl[0] = x, rgfl[1] = y, rgfl[2] = z; }
+	inline float Length(void) const					{ return sqrt(x*x + y*y + z*z); }
+	operator float *()								{ return &x; } // Vectors will now automatically convert to float * when needed
+	operator const float *() const					{ return &x; } // Vectors will now automatically convert to float * when needed
+	inline Vector Normalize(void) const
+	{
+		float flLen = Length();
+		if (flLen == 0) return Vector(0,0,1); // ????
+		flLen = 1 / flLen;
+		return Vector(x * flLen, y * flLen, z * flLen);
+	}
+
+	inline Vector2D Make2D ( void ) const
+	{
+		Vector2D	Vec2;
+
+		Vec2.x = x;
+		Vec2.y = y;
+
+		return Vec2;
+	}
+	inline float Length2D(void) const					{ return sqrt(x*x + y*y); }
+
+	// Members
+	vec_t x, y, z;
+};
+inline Vector operator*(float fl, const Vector& v)	{ return v * fl; }
+inline float DotProduct(const Vector& a, const Vector& b) { return(a.x*b.x+a.y*b.y+a.z*b.z); }
+inline Vector CrossProduct(const Vector& a, const Vector& b) { return Vector( a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x ); }
+
+
+
+#endif

src/dlls/weapons.cpp

@@ -0,0 +1,218 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/*
+
+===== weapons.cpp ========================================================
+
+  functions governing the selection/use of weapons for players
+
+*/
+
+#include "extdll.h"
+#include "util.h"
+#include "cmbase.h"
+#include "cmbasemonster.h"
+#include "monsters.h"
+#include "weapons.h"
+#include "nodes.h"
+#include "decals.h"
+
+extern CGraph	WorldGraph;
+
+MULTIDAMAGE gMultiDamage;
+
+#define TRACER_FREQ		4			// Tracers fire every fourth bullet
+
+
+/*
+==============================================================================
+
+MULTI-DAMAGE
+
+Collects multiple small damages into a single damage
+
+==============================================================================
+*/
+
+//
+// ClearMultiDamage - resets the global multi damage accumulator
+//
+void ClearMultiDamage(void)
+{
+	gMultiDamage.pEntity = NULL;
+	gMultiDamage.amount	= 0;
+	gMultiDamage.type = 0;
+}
+
+
+//
+// ApplyMultiDamage - inflicts contents of global multi damage register on gMultiDamage.pEntity
+//
+// GLOBALS USED:
+//		gMultiDamage
+
+void ApplyMultiDamage(entvars_t *pevInflictor, entvars_t *pevAttacker )
+{
+	Vector		vecSpot1;//where blood comes from
+	Vector		vecDir;//direction blood should go
+	TraceResult	tr;
+	
+	if ( !gMultiDamage.pEntity )
+		return;
+
+	if (UTIL_IsPlayer(gMultiDamage.pEntity))
+		UTIL_TakeDamage(gMultiDamage.pEntity, pevInflictor, pevAttacker, gMultiDamage.amount, gMultiDamage.type );
+	else if (gMultiDamage.pEntity->v.euser4 != NULL)
+	{
+		CMBaseMonster *pMonster = GetClassPtr((CMBaseMonster *)VARS(gMultiDamage.pEntity));
+		pMonster->TakeDamage(pevInflictor, pevAttacker, gMultiDamage.amount, gMultiDamage.type );
+	}
+}
+
+
+// GLOBALS USED:
+//		gMultiDamage
+
+void AddMultiDamage( entvars_t *pevInflictor, edict_t *pEntity, float flDamage, int bitsDamageType)
+{
+	if ( !pEntity )
+		return;
+	
+	gMultiDamage.type |= bitsDamageType;
+
+	if ( pEntity != gMultiDamage.pEntity )
+	{
+		ApplyMultiDamage(pevInflictor,pevInflictor); // UNDONE: wrong attacker!
+		gMultiDamage.pEntity	= pEntity;
+		gMultiDamage.amount		= 0;
+	}
+
+	gMultiDamage.amount += flDamage;
+}
+
+/*
+================
+SpawnBlood
+================
+*/
+void SpawnBlood(Vector vecSpot, int bloodColor, float flDamage)
+{
+	UTIL_BloodDrips( vecSpot, g_vecAttackDir, bloodColor, (int)flDamage );
+}
+
+
+int DamageDecal( CMBaseEntity *pEntity, int bitsDamageType )
+{
+	if ( !pEntity )
+		return (DECAL_GUNSHOT1 + RANDOM_LONG(0,4));
+	
+	return pEntity->DamageDecal( bitsDamageType );
+}
+
+void DecalGunshot( TraceResult *pTrace, int iBulletType )
+{
+	// Is the entity valid
+	if ( !UTIL_IsValidEntity( pTrace->pHit ) )
+		return;
+
+	if ( VARS(pTrace->pHit)->solid == SOLID_BSP || VARS(pTrace->pHit)->movetype == MOVETYPE_PUSHSTEP )
+	{
+		CMBaseEntity *pEntity = NULL;
+		// Decal the wall with a gunshot
+		if ( !FNullEnt(pTrace->pHit) )
+			pEntity = CMBaseEntity::Instance(pTrace->pHit);
+
+		switch( iBulletType )
+		{
+		case BULLET_PLAYER_9MM:
+		case BULLET_MONSTER_9MM:
+		case BULLET_PLAYER_MP5:
+		case BULLET_MONSTER_MP5:
+		case BULLET_PLAYER_BUCKSHOT:
+		case BULLET_PLAYER_357:
+		default:
+			// smoke and decal
+			UTIL_GunshotDecalTrace( pTrace, DamageDecal( pEntity, DMG_BULLET ) );
+			break;
+		case BULLET_MONSTER_12MM:
+			// smoke and decal
+			UTIL_GunshotDecalTrace( pTrace, DamageDecal( pEntity, DMG_BULLET ) );
+			break;
+		case BULLET_PLAYER_CROWBAR:
+			// wall decal
+			UTIL_DecalTrace( pTrace, DamageDecal( pEntity, DMG_CLUB ) );
+			break;
+		}
+	}
+}
+
+
+
+//
+// EjectBrass - tosses a brass shell from passed origin at passed velocity
+//
+void EjectBrass ( const Vector &vecOrigin, const Vector &vecVelocity, float rotation, int model, int soundtype )
+{
+	// FIX: when the player shoots, their gun isn't in the same position as it is on the model other players see.
+
+	MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecOrigin );
+		WRITE_BYTE( TE_MODEL);
+		WRITE_COORD( vecOrigin.x);
+		WRITE_COORD( vecOrigin.y);
+		WRITE_COORD( vecOrigin.z);
+		WRITE_COORD( vecVelocity.x);
+		WRITE_COORD( vecVelocity.y);
+		WRITE_COORD( vecVelocity.z);
+		WRITE_ANGLE( rotation );
+		WRITE_SHORT( model );
+		WRITE_BYTE ( soundtype);
+		WRITE_BYTE ( 25 );// 2.5 seconds
+	MESSAGE_END();
+}
+
+
+#if 0
+// UNDONE: This is no longer used?
+void ExplodeModel( const Vector &vecOrigin, float speed, int model, int count )
+{
+	MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecOrigin );
+		WRITE_BYTE ( TE_EXPLODEMODEL );
+		WRITE_COORD( vecOrigin.x );
+		WRITE_COORD( vecOrigin.y );
+		WRITE_COORD( vecOrigin.z );
+		WRITE_COORD( speed );
+		WRITE_SHORT( model );
+		WRITE_SHORT( count );
+		WRITE_BYTE ( 15 );// 1.5 seconds
+	MESSAGE_END();
+}
+#endif
+
+
+BOOL CanAttack( float attack_time, float curtime, BOOL isPredicted )
+{
+#if defined( CLIENT_WEAPONS )
+	if ( !isPredicted )
+#else
+	if ( 1 )
+#endif
+	{
+		return ( attack_time <= curtime ) ? TRUE : FALSE;
+	}
+	else
+	{
+		return ( attack_time <= 0.0 ) ? TRUE : FALSE;
+	}
+}

src/dlls/weapons.h

@@ -0,0 +1,258 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef WEAPONS_H
+#define WEAPONS_H
+
+#include "effects.h"
+
+// Contact Grenade / Timed grenade / Satchel Charge
+class CMGrenade : public CMBaseMonster
+{
+public:
+	void Spawn( void );
+
+	typedef enum { SATCHEL_DETONATE = 0, SATCHEL_RELEASE } SATCHELCODE;
+
+	static CMGrenade *ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time );
+	static CMGrenade *ShootContact( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity );
+	static CMGrenade *ShootSatchelCharge( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity );
+
+	void Explode( Vector vecSrc, Vector vecAim );
+	void Explode( TraceResult *pTrace, int bitsDamageType );
+	void EXPORT Smoke( void );
+
+	void EXPORT BounceTouch( edict_t *pOther );
+	void EXPORT SlideTouch( edict_t *pOther );
+	void EXPORT ExplodeTouch( edict_t *pOther );
+	void EXPORT DangerSoundThink( void );
+	void EXPORT PreDetonate( void );
+	void EXPORT Detonate( void );
+	void EXPORT DetonateUse( edict_t *pActivator, edict_t *pCaller, USE_TYPE useType, float value );
+	void EXPORT TumbleThink( void );
+
+	virtual void BounceSound( void );
+	virtual int	BloodColor( void ) { return DONT_BLEED; }
+	virtual void Killed( entvars_t *pevAttacker, int iGib );
+
+	BOOL m_fRegisteredSound;// whether or not this grenade has issued its DANGER sound to the world sound list yet.
+};
+
+
+// constant items
+#define ITEM_HEALTHKIT		1
+#define ITEM_ANTIDOTE		2
+#define ITEM_SECURITY		3
+#define ITEM_BATTERY			4
+
+#define WEAPON_NONE				0
+#define WEAPON_CROWBAR			1
+#define WEAPON_GLOCK				2
+#define WEAPON_PYTHON			3
+#define WEAPON_MP5				4
+#define WEAPON_CHAINGUN			5
+#define WEAPON_CROSSBOW			6
+#define WEAPON_SHOTGUN			7
+#define WEAPON_RPG				8
+#define WEAPON_GAUSS				9
+#define WEAPON_EGON				10
+#define WEAPON_HORNETGUN		11
+#define WEAPON_HANDGRENADE		12
+#define WEAPON_TRIPMINE			13
+#define	WEAPON_SATCHEL			14
+#define	WEAPON_SNARK			15
+
+#define WEAPON_ALLWEAPONS		(~(1<<WEAPON_SUIT))
+
+#define WEAPON_SUIT				31	// ?????
+
+#define MAX_WEAPONS			32
+
+
+#define MAX_NORMAL_BATTERY	100
+
+
+// weapon weight factors (for auto-switching)   (-1 = noswitch)
+#define CROWBAR_WEIGHT		0
+#define GLOCK_WEIGHT			10
+#define PYTHON_WEIGHT		15
+#define MP5_WEIGHT			15
+#define SHOTGUN_WEIGHT		15
+#define CROSSBOW_WEIGHT		10
+#define RPG_WEIGHT			20
+#define GAUSS_WEIGHT			20
+#define EGON_WEIGHT			20
+#define HORNETGUN_WEIGHT	10
+#define HANDGRENADE_WEIGHT	5
+#define SNARK_WEIGHT			5
+#define SATCHEL_WEIGHT		-10
+#define TRIPMINE_WEIGHT		-10
+
+
+// weapon clip/carry ammo capacities
+#define URANIUM_MAX_CARRY		100
+#define	_9MM_MAX_CARRY			250
+#define _357_MAX_CARRY			36
+#define BUCKSHOT_MAX_CARRY		125
+#define BOLT_MAX_CARRY			50
+#define ROCKET_MAX_CARRY		5
+#define HANDGRENADE_MAX_CARRY	10
+#define SATCHEL_MAX_CARRY		5
+#define TRIPMINE_MAX_CARRY		5
+#define SNARK_MAX_CARRY			15
+#define HORNET_MAX_CARRY		8
+#define M203_GRENADE_MAX_CARRY	10
+
+// the maximum amount of ammo each weapon's clip can hold
+#define WEAPON_NOCLIP			-1
+
+//#define CROWBAR_MAX_CLIP		WEAPON_NOCLIP
+#define GLOCK_MAX_CLIP			17
+#define PYTHON_MAX_CLIP			6
+#define MP5_MAX_CLIP				50
+#define MP5_DEFAULT_AMMO		25
+#define SHOTGUN_MAX_CLIP		8
+#define CROSSBOW_MAX_CLIP		5
+#define RPG_MAX_CLIP				1
+#define GAUSS_MAX_CLIP			WEAPON_NOCLIP
+#define EGON_MAX_CLIP			WEAPON_NOCLIP
+#define HORNETGUN_MAX_CLIP		WEAPON_NOCLIP
+#define HANDGRENADE_MAX_CLIP	WEAPON_NOCLIP
+#define SATCHEL_MAX_CLIP		WEAPON_NOCLIP
+#define TRIPMINE_MAX_CLIP		WEAPON_NOCLIP
+#define SNARK_MAX_CLIP			WEAPON_NOCLIP
+
+
+// the default amount of ammo that comes with each gun when it spawns
+#define GLOCK_DEFAULT_GIVE			17
+#define PYTHON_DEFAULT_GIVE		6
+#define MP5_DEFAULT_GIVE			25
+#define MP5_DEFAULT_AMMO			25
+#define MP5_M203_DEFAULT_GIVE		0
+#define SHOTGUN_DEFAULT_GIVE		12
+#define CROSSBOW_DEFAULT_GIVE		5
+#define RPG_DEFAULT_GIVE			1
+#define GAUSS_DEFAULT_GIVE			20
+#define EGON_DEFAULT_GIVE			20
+#define HANDGRENADE_DEFAULT_GIVE	5
+#define SATCHEL_DEFAULT_GIVE		1
+#define TRIPMINE_DEFAULT_GIVE		1
+#define SNARK_DEFAULT_GIVE			5
+#define HIVEHAND_DEFAULT_GIVE		8
+
+// The amount of ammo given to a player by an ammo item.
+#define AMMO_URANIUMBOX_GIVE	20
+#define AMMO_GLOCKCLIP_GIVE	GLOCK_MAX_CLIP
+#define AMMO_357BOX_GIVE		PYTHON_MAX_CLIP
+#define AMMO_MP5CLIP_GIVE		MP5_MAX_CLIP
+#define AMMO_CHAINBOX_GIVE		200
+#define AMMO_M203BOX_GIVE		2
+#define AMMO_BUCKSHOTBOX_GIVE	12
+#define AMMO_CROSSBOWCLIP_GIVE	CROSSBOW_MAX_CLIP
+#define AMMO_RPGCLIP_GIVE		RPG_MAX_CLIP
+#define AMMO_URANIUMBOX_GIVE	20
+#define AMMO_SNARKBOX_GIVE		5
+
+// bullet types
+typedef	enum
+{
+	BULLET_NONE = 0,
+	BULLET_PLAYER_9MM, // glock
+	BULLET_PLAYER_MP5, // mp5
+	BULLET_PLAYER_357, // python
+	BULLET_PLAYER_BUCKSHOT, // shotgun
+	BULLET_PLAYER_CROWBAR, // crowbar swipe
+
+	BULLET_MONSTER_9MM,
+	BULLET_MONSTER_MP5,
+	BULLET_MONSTER_12MM,
+} Bullet;
+
+
+#define ITEM_FLAG_SELECTONEMPTY		1
+#define ITEM_FLAG_NOAUTORELOAD		2
+#define ITEM_FLAG_NOAUTOSWITCHEMPTY	4
+#define ITEM_FLAG_LIMITINWORLD		8
+#define ITEM_FLAG_EXHAUSTIBLE		16 // A player can totally exhaust their ammo supply and lose this weapon
+
+#define WEAPON_IS_ONTARGET 0x40
+
+typedef struct
+{
+	int		iSlot;
+	int		iPosition;
+	const char	*pszAmmo1;	// ammo 1 type
+	int		iMaxAmmo1;		// max ammo 1
+	const char	*pszAmmo2;	// ammo 2 type
+	int		iMaxAmmo2;		// max ammo 2
+	const char	*pszName;
+	int		iMaxClip;
+	int		iId;
+	int		iFlags;
+	int		iWeight;// this value used to determine this weapon's importance in autoselection.
+} ItemInfo;
+
+typedef struct
+{
+	const char *pszName;
+	int iId;
+} AmmoInfo;
+
+extern void ClearMultiDamage(void);
+extern void ApplyMultiDamage(entvars_t* pevInflictor, entvars_t* pevAttacker );
+extern void AddMultiDamage( entvars_t *pevInflictor, edict_t *pEntity, float flDamage, int bitsDamageType);
+
+extern void DecalGunshot( TraceResult *pTrace, int iBulletType );
+extern void SpawnBlood(Vector vecSpot, int bloodColor, float flDamage);
+extern int DamageDecal( CMBaseEntity *pEntity, int bitsDamageType );
+extern void RadiusDamage( Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, float flRadius, int iClassIgnore, int bitsDamageType );
+
+typedef struct 
+{
+	edict_t		*pEntity;
+	float			amount;
+	int				type;
+} MULTIDAMAGE;
+
+extern MULTIDAMAGE gMultiDamage;
+
+
+#define LOUD_GUN_VOLUME			1000
+#define NORMAL_GUN_VOLUME		600
+#define QUIET_GUN_VOLUME		200
+
+#define	BRIGHT_GUN_FLASH		512
+#define NORMAL_GUN_FLASH		256
+#define	DIM_GUN_FLASH			128
+
+#define BIG_EXPLOSION_VOLUME	2048
+#define NORMAL_EXPLOSION_VOLUME	1024
+#define SMALL_EXPLOSION_VOLUME	512
+
+#define	WEAPON_ACTIVITY_VOLUME	64
+
+#define VECTOR_CONE_1DEGREES	Vector( 0.00873, 0.00873, 0.00873 )
+#define VECTOR_CONE_2DEGREES	Vector( 0.01745, 0.01745, 0.01745 )
+#define VECTOR_CONE_3DEGREES	Vector( 0.02618, 0.02618, 0.02618 )
+#define VECTOR_CONE_4DEGREES	Vector( 0.03490, 0.03490, 0.03490 )
+#define VECTOR_CONE_5DEGREES	Vector( 0.04362, 0.04362, 0.04362 )
+#define VECTOR_CONE_6DEGREES	Vector( 0.05234, 0.05234, 0.05234 )
+#define VECTOR_CONE_7DEGREES	Vector( 0.06105, 0.06105, 0.06105 )
+#define VECTOR_CONE_8DEGREES	Vector( 0.06976, 0.06976, 0.06976 )
+#define VECTOR_CONE_9DEGREES	Vector( 0.07846, 0.07846, 0.07846 )
+#define VECTOR_CONE_10DEGREES	Vector( 0.08716, 0.08716, 0.08716 )
+#define VECTOR_CONE_15DEGREES	Vector( 0.13053, 0.13053, 0.13053 )
+#define VECTOR_CONE_20DEGREES	Vector( 0.17365, 0.17365, 0.17365 )
+
+#endif // WEAPONS_H

src/dlls/zombie.cpp

@@ -0,0 +1,316 @@
+/***
+*
+*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   This source code contains proprietary and confidential information of
+*   Valve LLC and its suppliers.  Access to this code is restricted to
+*   persons who have executed a written SDK license with Valve.  Any access,
+*   use or distribution of this code by or to any unlicensed person is illegal.
+*
+****/
+//=========================================================
+// Zombie
+//=========================================================
+
+// UNDONE: Don't flinch every time you get hit
+
+#include	"extdll.h"
+#include	"util.h"
+#include	"cmbase.h"
+#include "cmbasemonster.h"
+#include	"monsters.h"
+#include	"schedule.h"
+
+
+//=========================================================
+// Monster's Anim Events Go Here
+//=========================================================
+#define	ZOMBIE_AE_ATTACK_RIGHT		0x01
+#define	ZOMBIE_AE_ATTACK_LEFT		0x02
+#define	ZOMBIE_AE_ATTACK_BOTH		0x03
+
+#define ZOMBIE_FLINCH_DELAY			2		// at most one flinch every n secs
+
+
+const char *CMZombie::pAttackHitSounds[] = 
+{
+	"zombie/claw_strike1.wav",
+	"zombie/claw_strike2.wav",
+	"zombie/claw_strike3.wav",
+};
+
+const char *CMZombie::pAttackMissSounds[] = 
+{
+	"zombie/claw_miss1.wav",
+	"zombie/claw_miss2.wav",
+};
+
+const char *CMZombie::pAttackSounds[] = 
+{
+	"zombie/zo_attack1.wav",
+	"zombie/zo_attack2.wav",
+};
+
+const char *CMZombie::pIdleSounds[] = 
+{
+	"zombie/zo_idle1.wav",
+	"zombie/zo_idle2.wav",
+	"zombie/zo_idle3.wav",
+	"zombie/zo_idle4.wav",
+};
+
+const char *CMZombie::pAlertSounds[] = 
+{
+	"zombie/zo_alert10.wav",
+	"zombie/zo_alert20.wav",
+	"zombie/zo_alert30.wav",
+};
+
+const char *CMZombie::pPainSounds[] = 
+{
+	"zombie/zo_pain1.wav",
+	"zombie/zo_pain2.wav",
+};
+
+//=========================================================
+// Classify - indicates this monster's place in the 
+// relationship table.
+//=========================================================
+int	CMZombie :: Classify ( void )
+{
+	return	CLASS_ALIEN_MONSTER;
+}
+
+//=========================================================
+// SetYawSpeed - allows each sequence to have a different
+// turn rate associated with it.
+//=========================================================
+void CMZombie :: SetYawSpeed ( void )
+{
+	int ys;
+
+	ys = 120;
+
+#if 0
+	switch ( m_Activity )
+	{
+	}
+#endif
+
+	pev->yaw_speed = ys;
+}
+
+int CMZombie :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
+{
+	// Take 30% damage from bullets
+	if ( bitsDamageType == DMG_BULLET )
+	{
+		Vector vecDir = pev->origin - (pevInflictor->absmin + pevInflictor->absmax) * 0.5;
+		vecDir = vecDir.Normalize();
+		float flForce = DamageForce( flDamage );
+		pev->velocity = pev->velocity + vecDir * flForce;
+		flDamage *= 0.3;
+	}
+
+	// HACK HACK -- until we fix this.
+	if ( IsAlive() )
+		PainSound();
+	return CMBaseMonster::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
+}
+
+void CMZombie :: PainSound( void )
+{
+	int pitch = 95 + RANDOM_LONG(0,9);
+
+	if (RANDOM_LONG(0,5) < 2)
+		EMIT_SOUND_DYN ( ENT(pev), CHAN_VOICE, pPainSounds[ RANDOM_LONG(0,ARRAYSIZE(pPainSounds)-1) ], 1.0, ATTN_NORM, 0, pitch );
+}
+
+void CMZombie :: AlertSound( void )
+{
+	int pitch = 95 + RANDOM_LONG(0,9);
+
+	EMIT_SOUND_DYN ( ENT(pev), CHAN_VOICE, pAlertSounds[ RANDOM_LONG(0,ARRAYSIZE(pAlertSounds)-1) ], 1.0, ATTN_NORM, 0, pitch );
+}
+
+void CMZombie :: IdleSound( void )
+{
+	int pitch = 95 + RANDOM_LONG(0,9);
+
+	// Play a random idle sound
+	EMIT_SOUND_DYN ( ENT(pev), CHAN_VOICE, pIdleSounds[ RANDOM_LONG(0,ARRAYSIZE(pIdleSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
+}
+
+void CMZombie :: AttackSound( void )
+{
+	// Play a random attack sound
+	EMIT_SOUND_DYN ( ENT(pev), CHAN_VOICE, pAttackSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
+}
+
+
+//=========================================================
+// HandleAnimEvent - catches the monster-specific messages
+// that occur when tagged animation frames are played.
+//=========================================================
+void CMZombie :: HandleAnimEvent( MonsterEvent_t *pEvent )
+{
+	switch( pEvent->event )
+	{
+		case ZOMBIE_AE_ATTACK_RIGHT:
+		{
+			// do stuff for this event.
+	//		ALERT( at_console, "Slash right!\n" );
+			edict_t *pHurt = CheckTraceHullAttack( 70, gSkillData.zombieDmgOneSlash, DMG_SLASH );
+			if ( pHurt )
+			{
+				if ( pHurt->v.flags & (FL_MONSTER|FL_CLIENT) )
+				{
+					pHurt->v.punchangle.z = -18;
+					pHurt->v.punchangle.x = 5;
+					pHurt->v.velocity = pHurt->v.velocity - gpGlobals->v_right * 100;
+				}
+				// Play a random attack hit sound
+				EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackHitSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackHitSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
+			}
+			else // Play a random attack miss sound
+				EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackMissSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackMissSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
+
+			if (RANDOM_LONG(0,1))
+				AttackSound();
+		}
+		break;
+
+		case ZOMBIE_AE_ATTACK_LEFT:
+		{
+			// do stuff for this event.
+	//		ALERT( at_console, "Slash left!\n" );
+			edict_t *pHurt = CheckTraceHullAttack( 70, gSkillData.zombieDmgOneSlash, DMG_SLASH );
+			if ( pHurt )
+			{
+				if ( pHurt->v.flags & (FL_MONSTER|FL_CLIENT) )
+				{
+					pHurt->v.punchangle.z = 18;
+					pHurt->v.punchangle.x = 5;
+					pHurt->v.velocity = pHurt->v.velocity + gpGlobals->v_right * 100;
+				}
+				EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackHitSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackHitSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
+			}
+			else
+				EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackMissSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackMissSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
+
+			if (RANDOM_LONG(0,1))
+				AttackSound();
+		}
+		break;
+
+		case ZOMBIE_AE_ATTACK_BOTH:
+		{
+			// do stuff for this event.
+			edict_t *pHurt = CheckTraceHullAttack( 70, gSkillData.zombieDmgBothSlash, DMG_SLASH );
+			if ( pHurt )
+			{
+				if ( pHurt->v.flags & (FL_MONSTER|FL_CLIENT) )
+				{
+					pHurt->v.punchangle.x = 5;
+					pHurt->v.velocity = pHurt->v.velocity + gpGlobals->v_forward * -100;
+				}
+				EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackHitSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackHitSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
+			}
+			else
+				EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackMissSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackMissSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
+
+			if (RANDOM_LONG(0,1))
+				AttackSound();
+		}
+		break;
+
+		default:
+			CMBaseMonster::HandleAnimEvent( pEvent );
+			break;
+	}
+}
+
+//=========================================================
+// Spawn
+//=========================================================
+void CMZombie :: Spawn()
+{
+	Precache( );
+
+	SET_MODEL(ENT(pev), "models/zombie.mdl");
+	UTIL_SetSize( pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX );
+
+	pev->solid			= SOLID_SLIDEBOX;
+	pev->movetype		= MOVETYPE_STEP;
+	m_bloodColor		= BLOOD_COLOR_GREEN;
+	pev->health			= gSkillData.zombieHealth;
+	pev->view_ofs		= VEC_VIEW;// position of the eyes relative to monster's origin.
+	m_flFieldOfView		= 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
+	m_MonsterState		= MONSTERSTATE_NONE;
+	m_afCapability		= bits_CAP_DOORS_GROUP;
+
+	MonsterInit();
+}
+
+//=========================================================
+// Precache - precaches all resources this monster needs
+//=========================================================
+void CMZombie :: Precache()
+{
+	int i;
+
+	PRECACHE_MODEL("models/zombie.mdl");
+
+	for ( i = 0; i < ARRAYSIZE( pAttackHitSounds ); i++ )
+		PRECACHE_SOUND((char *)pAttackHitSounds[i]);
+
+	for ( i = 0; i < ARRAYSIZE( pAttackMissSounds ); i++ )
+		PRECACHE_SOUND((char *)pAttackMissSounds[i]);
+
+	for ( i = 0; i < ARRAYSIZE( pAttackSounds ); i++ )
+		PRECACHE_SOUND((char *)pAttackSounds[i]);
+
+	for ( i = 0; i < ARRAYSIZE( pIdleSounds ); i++ )
+		PRECACHE_SOUND((char *)pIdleSounds[i]);
+
+	for ( i = 0; i < ARRAYSIZE( pAlertSounds ); i++ )
+		PRECACHE_SOUND((char *)pAlertSounds[i]);
+
+	for ( i = 0; i < ARRAYSIZE( pPainSounds ); i++ )
+		PRECACHE_SOUND((char *)pPainSounds[i]);
+}	
+
+//=========================================================
+// AI Schedules Specific to this monster
+//=========================================================
+
+
+
+int CMZombie::IgnoreConditions ( void )
+{
+	int iIgnore = CMBaseMonster::IgnoreConditions();
+
+	if ((m_Activity == ACT_MELEE_ATTACK1) || (m_Activity == ACT_MELEE_ATTACK1))
+	{
+#if 0
+		if (pev->health < 20)
+			iIgnore |= (bits_COND_LIGHT_DAMAGE|bits_COND_HEAVY_DAMAGE);
+		else
+#endif			
+		if (m_flNextFlinch >= gpGlobals->time)
+			iIgnore |= (bits_COND_LIGHT_DAMAGE|bits_COND_HEAVY_DAMAGE);
+	}
+
+	if ((m_Activity == ACT_SMALL_FLINCH) || (m_Activity == ACT_BIG_FLINCH))
+	{
+		if (m_flNextFlinch < gpGlobals->time)
+			m_flNextFlinch = gpGlobals->time + ZOMBIE_FLINCH_DELAY;
+	}
+
+	return iIgnore;
+	
+}