zydronium/SBSPSS
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Browse source
This commit is contained in:
Charles 2001-05-17 19:28:08 +00:00
parent 9d668cb68e
commit 4d00a63deb
14 changed files with 71 additions and 322 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
source/enemy/npc.cpp
View file

@ -1696,3 +1696,15 @@ void CNpcEnemy::processCoralBlower( int _frames )
m_isBlowerOn = false;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CVECTOR CNpcEnemy::getRGB()
{
CVECTOR rgb;
rgb.r = 0;
rgb.g = 0;
rgb.b = 0;
return( rgb );
}

1
source/enemy/npc.h
View file

@ -110,6 +110,7 @@ public:
virtual int getFrameCount();
virtual int getFrame() {return( m_frame );}
void setSpeed( s16 newSpeed ) {m_speed = newSpeed;}
virtual CVECTOR getRGB();
static CNpcEnemy *Create(sThingActor *ThisActor);
virtual void setupWaypoints( sThingActor *ThisActor );

304
source/enemy/nprojjf.cpp
View file

@ -139,307 +139,3 @@ void CNpcSmallJellyfishProjectileEnemy::think(int _frames)
setToShutdown();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcSmallJellyfishProjectileEnemy::render()
{
SprFrame = NULL;
if ( m_isActive )
{
CEnemyThing::render();
if (canRender())
{
DVECTOR &renderPos=getRenderPos();
SprFrame = m_spriteBank->printRotatedScaledSprite( FRM_JELLYFISH1_SWIM1 + ( m_frame >> 8 ),renderPos.vx,renderPos.vy,4096,4096,m_drawRotation,10);
setRGB0( SprFrame, 255, 128, 255 ); // Let me know if these change! ALso ket me know when the different coloured ones go in pls! (pkg)
// get xmax, xmin, ymax, ymin
s32 XMax;
s32 XMin;
s32 YMax;
s32 YMin;
XMin=SprFrame->x0;
if (XMin>SprFrame->x1) XMin=SprFrame->x1;
if (XMin>SprFrame->x2) XMin=SprFrame->x2;
if (XMin>SprFrame->x3) XMin=SprFrame->x3;
XMax=SprFrame->x0;
if (XMax<SprFrame->x1) XMax=SprFrame->x1;
if (XMax<SprFrame->x2) XMax=SprFrame->x2;
if (XMax<SprFrame->x3) XMax=SprFrame->x3;
YMin=SprFrame->y0;
if (YMin>SprFrame->y1) YMin=SprFrame->y1;
if (YMin>SprFrame->y2) YMin=SprFrame->y2;
if (YMin>SprFrame->y3) YMin=SprFrame->y3;
YMax=SprFrame->y0;
if (YMax<SprFrame->y1) YMax=SprFrame->y1;
if (YMax<SprFrame->y2) YMax=SprFrame->y2;
if (YMax<SprFrame->y3) YMax=SprFrame->y3;
XMax -= renderPos.vx;
XMin -= renderPos.vx;
YMax -= renderPos.vy;
YMin -= renderPos.vy;
setCollisionSize( ( XMax - XMin ), ( YMax - YMin ) );
setCollisionCentreOffset( ( XMax + XMin ) >> 1, ( YMax + YMin ) >> 1 );
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcSmallJellyfishProjectileEnemy::processClose( int _frames )
{
s32 moveX = 0, moveY = 0;
s16 moveDist = 0;
s32 moveVel = 0;
if ( playerXDistSqr + playerYDistSqr > 10000 )
{
this->m_controlFunc = NPC_CONTROL_MOVEMENT;
}
else
{
bool pathComplete;
bool waypointChange;
s32 xDist, yDist;
s16 headingToTarget = m_npcPath.think( Pos, &pathComplete, &waypointChange, &xDist, &yDist );
if ( pathComplete )
{
this->m_controlFunc = NPC_CONTROL_MOVEMENT;
}
else
{
if ( !m_animPlaying )
{
m_animPlaying = true;
m_animNo = m_data[m_type].moveAnim;
m_frame = 0;
}
s16 headingToPlayer = ratan2( playerYDist, playerXDist );
if ( m_evadeClockwise )
{
headingToPlayer += 1024;
}
else
{
headingToPlayer -= 1024;
}
headingToPlayer &= 4095;
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 &= 4095;
moveX = ( _frames * 3 * rcos( m_heading ) ) >> 12;
moveY = ( _frames * 3 * rsin( m_heading ) ) >> 12;
moveVel = ( _frames * 3 ) << 8;
if ( processGroundCollisionReverse( &moveX, &moveY ) )
{
m_evadeClockwise = !m_evadeClockwise;
}
processMovementModifier(_frames, moveX, moveY, moveVel, moveDist);
}
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool CNpcSmallJellyfishProjectileEnemy::processSensor()
{
switch( m_sensorFunc )
{
case NPC_SENSOR_NONE:
return( false );
default:
{
if ( playerXDistSqr + playerYDistSqr < 5625 )
{
m_controlFunc = NPC_CONTROL_CLOSE;
m_evadeClockwise = getRnd() % 2;
return( true );
}
else
{
return( false );
}
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcSmallJellyfishProjectileEnemy::processMovementModifier( int _frames, s32 distX, s32 distY, s32 dist, s16 headingChange )
{
s32 newX, newY;
s32 preShiftX, preShiftY;
s16 headingVal;
//u16 jellyfishData[5] = { 96, 192, 256, 192, 128, };
u16 jellyfishData[6] = { 256, 256, 96, 48, 96, 256, };
u32 dataPoint;
m_movementTimer += _frames;
if ( m_movementTimer > ( GameState::getOneSecondInFrames() >> 1 ) )
{
m_movementTimer = 0;
}
dataPoint = 5 * m_movementTimer;
if ( dataPoint != 0 )
{
dataPoint /= ( GameState::getOneSecondInFrames() >> 1 );
}
m_frame = ( ( m_movementTimer * ( getFrameCount() - 1 ) << 8 ) ) / 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;
headingVal = abs( headingChange );
if ( headingVal > 128 )
{
headingVal = 128;
}
reqVelocity = dist * jellyfishData[dataPoint];
reqVelocity >>= 8;
reqVelocity *= 128 + ( 128 - headingVal );
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;
m_drawRotation = m_heading;
}

19
source/enemy/nprojjf.h
View file

@ -14,34 +14,21 @@
#ifndef __ENEMY_NPROJJF_H__
#define __ENEMY_NPROJJF_H__
#ifndef __ENEMY_NPC_H__
#include "enemy\npc.h"
#ifndef __ENEMY_NSJFISH_H__
#include "enemy\nsjfish.h"
#endif
#ifndef __SPR_SPRITES_H__
#include <sprites.h>
#endif
class CNpcSmallJellyfishProjectileEnemy : public CNpcEnemy
class CNpcSmallJellyfishProjectileEnemy : public CNpcSmallJellyfishEnemy
{
public:
void render();
virtual int getFrameCount() {return( FRM_JELLYFISH1_SWIM6 - FRM_JELLYFISH1_SWIM1 + 1 );}
virtual u8 canCollideWithEnemy() {return( false );}
virtual void postInit();
virtual void think(int _frames);
protected:
virtual bool processSensor();
virtual void processClose( int _frames );
virtual void processMovementModifier( int _frames, s32 distX, s32 distY, s32 dist, s16 headingChange );
enum
{
NPC_JELLYFISH_RESISTANCE = 64,
};
s32 m_lifetime;
bool m_evadeClockwise;
};
#endif

13
source/enemy/nsj2back.cpp
View file

@ -141,3 +141,16 @@ void CNpcSmallJellyfish2BackgroundEnemy::collidedWith( CThing *_thisThing )
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CVECTOR CNpcSmallJellyfish2BackgroundEnemy::getRGB()
{
CVECTOR rgb;
rgb.r = 128;
rgb.g = 128;
rgb.b = 255;
return( rgb );
}

1
source/enemy/nsj2back.h
View file

@ -22,6 +22,7 @@ class CNpcSmallJellyfish2BackgroundEnemy : public CNpcSmallJellyfishBackgroundEn
{
public:
virtual void render();
virtual CVECTOR getRGB();
protected:
virtual void collidedWith(CThing *_thisThing);
};

13
source/enemy/nsjfish.cpp
View file

@ -376,3 +376,16 @@ void CNpcSmallJellyfishEnemy::fireAsProjectile( s16 heading )
projectile->setHasRGB( true );
projectile->setRGB( 255, 128, 255 );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CVECTOR CNpcSmallJellyfishEnemy::getRGB()
{
CVECTOR rgb;
rgb.r = 255;
rgb.g = 128;
rgb.b = 255;
return( rgb );
}

1
source/enemy/nsjfish.h
View file

@ -28,6 +28,7 @@ public:
virtual void render();
virtual int getFrameCount() {return( FRM_JELLYFISH1_SWIM7 - FRM_JELLYFISH1_SWIM1 + 1 );}
virtual u8 canCollideWithEnemy() {return( false );}
virtual CVECTOR getRGB();
protected:
virtual bool processSensor();
virtual void processClose( int _frames );

15
source/hazard/hbbarrel.cpp
View file

@ -159,3 +159,18 @@ void CNpcBouncingBarrelHazard::render()
m_modelGfx->Render(renderPos,&rotation,&scale);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CRECT *CNpcBouncingBarrelHazard::getThinkBBox()
{
CRECT objThinkBox = getCollisionArea();
sBBox &thinkBBox = CThingManager::getThinkBBox();
objThinkBox.x1 = thinkBBox.XMin;
objThinkBox.x2 = thinkBBox.XMax;
objThinkBox.y1 = thinkBBox.YMin;
objThinkBox.y2 = thinkBBox.YMax;
return &objThinkBox;
}

1
source/hazard/hbbarrel.h
View file

@ -23,6 +23,7 @@ class CNpcBouncingBarrelHazard : public CNpcHazard
public:
void init();
void render();
virtual CRECT const *getThinkBBox();
protected:
void processMovement( int _frames );

2
source/player/pmnet.cpp
View file

@ -193,6 +193,7 @@ void CPlayerModeNet::think()
if(((CNpcEnemy*)thing)->canBeCaughtByNet())
{
((CNpcEnemy*)thing)->caughtWithNet();
m_RGB = ((CNpcEnemy*)thing)->getRGB();
m_netState=NET_STATE__JUST_CAUGHT_SOMETHING;
thing=NULL;
if(m_player->getJellyFishAmmo()==0)
@ -238,6 +239,7 @@ void CPlayerModeNet::think()
5*60);
projectile->setLayerCollision( m_player->getLayerCollision() );
projectile->updateCollisionArea();
projectile->setRGB( m_RGB );
m_netState=NET_STATE__JUST_LAUNCHED_SOMETHING;
m_player->useOneJellyFishAmmo();

1
source/player/pmnet.h
View file

@ -60,6 +60,7 @@ private:
int m_netFrame;
NetState m_netState;
int m_netSin;
CVECTOR m_RGB;
};

6
source/projectl/projectl.cpp
View file

@ -428,6 +428,10 @@ void CPlayerProjectile::init( DVECTOR initPos, s16 initHeading )
{
m_reversed = 1;
}
m_RGB.r = 0;
m_RGB.g = 0;
m_RGB.b = 0;
}
void CPlayerProjectile::init( DVECTOR initPos, s16 initHeading, PLAYER_PROJECTILE_MOVEMENT_TYPE initMoveType, PLAYER_PROJECTILE_LIFETIME_TYPE initLifeType )
@ -554,7 +558,7 @@ void CPlayerProjectile::render()
}
SprFrame = m_spriteBank->printFT4(FRM_JELLYFISH1_SWIM1 + m_frame,x,y,m_reversed,0,10);
setRGB0( SprFrame, 255, 128, 255 );
setRGB0( SprFrame, m_RGB.r, m_RGB.g, m_RGB.b );
}
DVECTOR CPlayerProjectile::getScreenOffset()

2
source/projectl/projectl.h
View file

@ -112,6 +112,7 @@ public:
void setLifeTime( PLAYER_PROJECTILE_LIFETIME_TYPE lifeType );
void setPosition( DVECTOR newPos );
void setLayerCollision( class CLayerCollision *_layer ) {m_layerCollision=_layer;}
void setRGB( CVECTOR new_RGB ) {m_RGB = new_RGB;}
private:
class CLayerCollision *m_layerCollision;
@ -131,6 +132,7 @@ protected:
int m_frame;
POLY_FT4 *SprFrame;
u8 m_reversed;
CVECTOR m_RGB;
};