source/enemy/npc.cpp

@@ -33,14 +33,24 @@
 #include	"player\player.h"
 #endif
 
+#ifndef __ENEMY_NPCPATH_H__
+#include	"enemy\npcpath.h"
+#endif
+
+#ifndef	__UTILS_HEADER__
+#include	"utils\utils.h"
+#endif
+
 
 CNpc::NPC_DATA CNpc::m_data[NPC_UNIT_TYPE_MAX] =
 {
 	{
 		NPC_INIT_DEFAULT,
-		NPC_SENSOR_NONE,
-		NPC_MOVEMENT_STATIC,
-		NPC_MOVEMENT_MODIFIER_NONE,
+		NPC_SENSOR_USER_CLOSE,
+		NPC_MOVEMENT_FIXED_PATH,
+		NPC_MOVEMENT_MODIFIER_JELLYFISH,
+		NPC_CLOSE_EVADE,
+		NPC_TIMER_NONE,
 		false,
 	},
 
@@ -49,6 +59,8 @@ CNpc::NPC_DATA CNpc::m_data[NPC_UNIT_TYPE_MAX] =
 		NPC_SENSOR_NONE,
 		NPC_MOVEMENT_STATIC,
 		NPC_MOVEMENT_MODIFIER_NONE,
+		NPC_CLOSE_EVADE,
+		NPC_TIMER_NONE,
 		true,
 	},
 };
@@ -56,13 +68,50 @@ CNpc::NPC_DATA CNpc::m_data[NPC_UNIT_TYPE_MAX] =
 
 void CNpc::init()
 {
-	m_type = NPC_SANDY_CHEEKS;
+	m_type = NPC_TEST_TYPE;
+
+	m_heading = 0;
+	m_movementTimer = 0;
+	m_timerTimer = 0;
+	m_velocity = 0;
+
+	Pos.vx = 100;
+	Pos.vy = 100;
+
+	m_timerFunc = m_data[this->m_type].timerFunc;
+	m_sensorFunc = m_data[this->m_type].sensorFunc;
 
 	switch ( m_data[this->m_type].initFunc )
 	{
 		case NPC_INIT_DEFAULT:
 			m_controlFunc = NPC_CONTROL_MOVEMENT;
 
+			m_npcPath.initPath();
+
+			DVECTOR newPos;
+
+			newPos.vx = 100;
+			newPos.vy = 10;
+
+			m_npcPath.addWaypoint( newPos );
+
+			newPos.vx = 500;
+			newPos.vy = 10;
+
+			m_npcPath.addWaypoint( newPos );
+
+			newPos.vx = 500;
+			newPos.vy = 100;
+
+			m_npcPath.addWaypoint( newPos );
+
+			newPos.vx = 100;
+			newPos.vy = 100;
+
+			m_npcPath.addWaypoint( newPos );
+
+			m_npcPath.setPathType( REPEATING_PATH );
+
 			break;
 
 		default:
@@ -80,14 +129,16 @@ void CNpc::shutdown()
 
 void CNpc::think(int _frames)
 {
-	m_controlFunc = NPC_CONTROL_MOVEMENT;
-
 	switch ( this->m_controlFunc )
 	{
 		case NPC_CONTROL_MOVEMENT:
 			if ( !processSensor() )
 			{
-				processMovement();
+				processMovement(_frames);
+			}
+			else
+			{
+				processClose(_frames);
 			}
 
 			break;
@@ -98,7 +149,7 @@ void CNpc::think(int _frames)
 			break;
 
 		case NPC_CONTROL_CLOSE:
-			processClose();
+			processClose(_frames);
 
 			break;
 
@@ -108,88 +159,423 @@ void CNpc::think(int _frames)
 			break;
 	}
 
-	processTimer();
+	processTimer(_frames);
 }
 
 
 bool CNpc::processSensor()
 {
-	switch( m_data[this->m_type].sensorFunc )
+	switch( m_sensorFunc )
 	{
 		case NPC_SENSOR_NONE:
 			return( false );
 
 		case NPC_SENSOR_USER_CLOSE:
-			/*if ( user is close )
+		{
+			CPlayer *player = GameScene.getPlayer();
+
+			DVECTOR playerPos = player->getPos();
+
+			s32 xDistSqr, yDistSqr;
+
+			xDistSqr = playerPos.vx - this->Pos.vx;
+			xDistSqr *= xDistSqr;
+
+			yDistSqr = playerPos.vy - this->Pos.vy;
+			yDistSqr *= yDistSqr;
+
+			if ( xDistSqr + yDistSqr < 10000 )
 			{
-				this->controlFunc = NPC_CONTROL_CLOSE;
-				processClose();
+				this->m_controlFunc = NPC_CONTROL_CLOSE;
+
+				this->m_evadeClockwise = ( getRnd() % 2 ) - 1;
 
 				return( true );
 			}
-			else*/
+			else
 			{
 				return( false );
 			}
-	}
+		}
 
-	return( false );
+		default:
+			return( false );
+	}
 }
 
-void CNpc::processMovement()
+void CNpc::processMovement(int _frames)
 {
+	if ( _frames > 2 )
+	{
+		_frames = 2;
+	}
+
+	s32 moveX = 0, moveY = 0;
+
+	s16 moveDist = 0;
+
+	s32 moveVel = 0;
+
 	switch( m_data[this->m_type].movementFunc )
 	{
 		case NPC_MOVEMENT_STATIC:
-			switch( m_data[this->m_type].movementModifierFunc )
+		{
+			break;
+		}
+
+		case NPC_MOVEMENT_FIXED_PATH:
+		{
+			bool pathComplete;
+
+			s16 headingToTarget = m_npcPath.think( Pos, &pathComplete );
+
+			if ( !pathComplete )
 			{
-				case NPC_MOVEMENT_MODIFIER_NONE:
-					break;
+				s16 decDir, incDir;
 
-				case NPC_MOVEMENT_MODIFIER_BOB:
-					//staticBob();
+				decDir = m_heading - headingToTarget;
 
-					break;
+				if ( decDir < 0 )
+				{
+					decDir += ONE;
+				}
+
+				incDir = headingToTarget - m_heading;
+
+				if ( incDir < 0 )
+				{
+					incDir += ONE;
+				}
+
+				if ( decDir < incDir )
+				{
+					moveDist = -decDir;
+				}
+				else
+				{
+					moveDist = incDir;
+				}
+
+				if ( moveDist < -128 )
+				{
+					moveDist = -128;
+				}
+				else if ( moveDist > 128 )
+				{
+					moveDist = 128;
+				}
+
+				m_heading += moveDist;
+
+				m_heading = m_heading % ONE;
+				
+				moveX = ( _frames * 3 * rcos( m_heading ) ) >> 12;
+				moveY = ( _frames * 3 * rsin( m_heading ) ) >> 12;
+				moveVel = ( _frames * 3 ) << 8;
 			}
 
 			break;
-
-		case NPC_MOVEMENT_FIXED_PATH:
-
-			break;
+		}
 
 		case NPC_MOVEMENT_USER_SEEK:
+		{
 			CPlayer *player;
 			
 			player = GameScene.getPlayer();
 
 			break;
+		}
 
 		case NPC_MOVEMENT_VERTICAL:
+		{
 			Pos.vy--;
 
 			break;
+		}
 
 		default:
 
 			break;
 	}
+
+	processMovementModifier(_frames, moveX, moveY, moveVel, moveDist);
+}
+
+void CNpc::processMovementModifier(int _frames, s32 distX, s32 distY, s32 dist, s32 headingChange)
+{
+	switch( m_data[m_type].movementModifierFunc )
+	{
+		case NPC_MOVEMENT_MODIFIER_NONE:
+		{
+			Pos.vx += distX;
+			Pos.vy += distY;
+
+			break;
+		}
+
+		case NPC_MOVEMENT_MODIFIER_BOB:
+		{
+			break;
+		}
+
+		case NPC_MOVEMENT_MODIFIER_JELLYFISH:
+		{
+#define NPC_JELLYFISH_RESISTANCE	64
+
+			s32 newX, newY;
+			s32 preShiftX, preShiftY;
+
+			u16 jellyfishData[5] = { 96, 192, 256, 192, 128, };
+
+			u32 dataPoint;
+
+			m_movementTimer += _frames;
+
+			if ( m_movementTimer > GameState::getOneSecondInFrames() )
+			{
+				m_movementTimer = 0;
+			}
+
+			dataPoint = 4 * m_movementTimer;
+
+			if ( dataPoint != 0 )
+			{
+				dataPoint /= GameState::getOneSecondInFrames();
+			}
+
+			s32 resistance;
+			s32 absVelocity = abs( m_velocity );
+			s32 reqVelocity = dist;
+
+			resistance = _frames * NPC_JELLYFISH_RESISTANCE;
+
+			if ( absVelocity < resistance )
+			{
+				resistance = absVelocity;
+			}
+
+			if ( absVelocity != 0 )
+			{
+				resistance = -( resistance * m_velocity ) / absVelocity;
+			}
+			else
+			{
+				resistance = 0;
+			}
+
+			m_velocity += resistance;
+
+			reqVelocity = dist * jellyfishData[dataPoint];
+			reqVelocity >>= 8;
+			reqVelocity *= 128 + ( 128 - headingChange );
+			reqVelocity >>= 8;
+
+			s32 absReqVelocity = abs( reqVelocity );
+
+			if ( absReqVelocity > absVelocity )
+			{
+				m_velocity += reqVelocity >> 1;
+			}
+
+			preShiftX = ( m_velocity >> 8 ) * rcos( m_heading );
+			preShiftY = ( m_velocity >> 8 ) * rsin( m_heading );
+
+			newX = preShiftX >> 12;
+			if ( !newX && preShiftX )
+			{
+				newX = preShiftX / abs( preShiftX );
+			}
+
+			newY = preShiftY >> 12;
+			if ( !newY && preShiftY )
+			{
+				newY = preShiftY / abs( preShiftY );
+			}
+
+			Pos.vx += newX;
+			Pos.vy += newY;
+
+			break;
+		}
+	}
 }
 
 void CNpc::processShot()
 {
 }
 
-void CNpc::processClose()
+void CNpc::processClose(int _frames)
 {
+	switch( m_data[this->m_type].closeFunc )
+	{
+		case NPC_CLOSE_EVADE:
+			{
+				s32 moveX = 0, moveY = 0;
+
+				s16 moveDist = 0;
+
+				s32 moveVel = 0;
+
+				CPlayer *player = GameScene.getPlayer();
+
+				DVECTOR playerPos = player->getPos();
+
+				s32 xDist, yDist;
+				s32 xDistSqr, yDistSqr;
+
+				xDist = playerPos.vx - this->Pos.vx;
+				xDistSqr = xDist * xDist;
+
+				yDist = playerPos.vy - this->Pos.vy;
+				yDistSqr = yDist * yDist;
+
+				if ( xDistSqr + yDistSqr > 22500 )
+				{
+					this->m_controlFunc = NPC_CONTROL_MOVEMENT;
+				}
+				else
+				{
+					bool pathComplete;
+
+					s16 headingToTarget = m_npcPath.think( Pos, &pathComplete );
+
+					if ( pathComplete )
+					{
+						this->m_controlFunc = NPC_CONTROL_MOVEMENT;
+					}
+					else
+					{
+						s16 headingToPlayer = ratan2( yDist, xDist );
+
+						if ( m_evadeClockwise )
+						{
+							headingToPlayer += 1024;
+						}
+						else
+						{
+							headingToPlayer -= 1024;
+						}
+
+						headingToPlayer %= ONE;
+
+						s16 decDir, incDir;
+
+						decDir = headingToPlayer - headingToTarget;
+
+						if ( decDir < 0 )
+						{
+							decDir += ONE;
+						}
+
+						incDir = headingToTarget - headingToPlayer;
+
+						if ( incDir < 0 )
+						{
+							incDir += ONE;
+						}
+
+						if ( decDir < incDir )
+						{
+							moveDist = decDir;
+						}
+						else
+						{
+							moveDist = incDir;
+						}
+
+						if ( moveDist < 128 )
+						{
+							// evasion angle is close to angle required to go to waypoint, hence resume waypoint movement
+
+							this->m_controlFunc = NPC_CONTROL_MOVEMENT;
+							this->m_timerFunc = NPC_TIMER_EVADE_DONE;
+							this->m_timerTimer = GameState::getOneSecondInFrames();
+							this->m_sensorFunc = NPC_SENSOR_NONE;
+						}
+						else
+						{
+							decDir = m_heading - headingToPlayer;
+
+							if ( decDir < 0 )
+							{
+								decDir += ONE;
+							}
+
+							incDir = headingToPlayer - m_heading;
+
+							if ( incDir < 0 )
+							{
+								incDir += ONE;
+							}
+
+							if ( decDir < incDir )
+							{
+								moveDist = -decDir;
+							}
+							else
+							{
+								moveDist = incDir;
+							}
+
+							if ( moveDist < -128 )
+							{
+								moveDist = -128;
+							}
+							else if ( moveDist > 128 )
+							{
+								moveDist = 128;
+							}
+
+							m_heading += moveDist;
+
+							m_heading = m_heading % ONE;
+							
+							moveX = ( _frames * 3 * rcos( m_heading ) ) >> 12;
+							moveY = ( _frames * 3 * rsin( m_heading ) ) >> 12;
+							moveVel = ( _frames * 3 ) << 8;
+
+							processMovementModifier(_frames, moveX, moveY, moveVel, moveDist);
+						}
+					}
+				}
+			}
+
+			break;
+
+		default:
+			break;
+	}
 }
 
 void CNpc::processCollision()
 {
 }
 
-void CNpc::processTimer()
+void CNpc::processTimer(int _frames)
 {
+	switch( m_timerFunc )
+	{
+		case NPC_TIMER_NONE:
+			{
+				break;
+			}
+
+		case NPC_TIMER_EVADE_DONE:
+			{
+				this->m_timerTimer -= _frames;
+
+				if ( m_timerTimer <= 0 )
+				{
+					this->m_timerFunc = NPC_TIMER_NONE;
+					this->m_sensorFunc = NPC_SENSOR_USER_CLOSE;
+				}
+
+				break;
+			}
+
+		default:
+			break;
+	}
 }
 
 void CNpc::render()