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-06-29 14:19:28 +00:00
parent cd87d0818d
commit 57b4d19ca6
48 changed files with 8 additions and 395 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
source/enemy/nssnake.cpp
View file

@ -1018,21 +1018,6 @@ void CNpcSeaSnakeEnemy::processShot( int _frames )
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcSeaSnakeEnemy::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;
}*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcSeaSnakeEnemy::processUserCollision( CThing *thisThing )
{
}

1
source/enemy/nssnake.h
View file

@ -59,7 +59,6 @@ public:
virtual void shutdown();
virtual void render();
virtual int checkCollisionAgainst(CThing *_thisThing, int _frames);
//virtual CRECT const *getThinkBBox();
protected:
virtual s32 getFrameShift( int _frames );
virtual bool processSensor();

15
source/enemy/nsstomp.cpp
View file

@ -158,21 +158,6 @@ void CNpcSkullStomperEnemy::processClose( int _frames )
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcSkullStomperEnemy::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;
}*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcSkullStomperEnemy::collidedWith( CThing *_thisThing )
{
if ( m_isActive && !m_isCaught && !m_isDying )

1
source/enemy/nsstomp.h
View file

@ -18,7 +18,6 @@ class CNpcSkullStomperEnemy : public CNpcEnemy
{
public:
virtual void postInit();
//virtual CRECT const *getThinkBBox();
protected:
virtual void processEnemyCollision( CThing *thisThing );
virtual bool processSensor();

15
source/friend/fgary.cpp
View file

@ -282,21 +282,6 @@ void CNpcGaryFriend::startRight()
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CRECT *CNpcGaryFriend::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;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcGaryFriend::start()
{
if ( !m_started )

2
source/friend/fgary.h
View file

@ -24,7 +24,7 @@ public:
virtual void postInit();
virtual void think( int _frames );
virtual void setupWaypoints( sThingActor *ThisActor );
virtual CRECT const *getThinkBBox();
bool alwaysThink() {return(true);}
DVECTOR const &getTriggerPos() {return( m_triggerPos );}
void start();
void stop();

15
source/hazard/hbarrel.cpp
View file

@ -152,18 +152,3 @@ void CNpcBarrelHazard::render()
m_modelGfx->Render(renderPos,&rotation,&scale);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcBarrelHazard::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/hbarrel.h
View file

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

15
source/hazard/hbbarrel.cpp
View file

@ -198,21 +198,6 @@ void CNpcBouncingBarrelHazard::render()
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*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;
}*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcBouncingBarrelHazard::collidedWith( CThing *_thisThing )
{
if ( m_isActive )

1
source/hazard/hbbarrel.h
View file

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

15
source/hazard/hbwheel.cpp
View file

@ -76,18 +76,3 @@ void CNpcBigWheelHazard::collidedWith( CThing *_thisThing )
{
// do not collide
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CRECT *CNpcBigWheelHazard::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;
}

2
source/hazard/hbwheel.h
View file

@ -23,7 +23,7 @@ class CNpcBigWheelHazard : public CNpcHazard
public:
void init();
virtual void render();
virtual CRECT const *getThinkBBox();
bool alwaysThink() {return(true);}
protected:
void processMovement( int _frames );
virtual void collidedWith(CThing *_thisThing);

15
source/hazard/hdbarrel.cpp
View file

@ -178,18 +178,3 @@ void CNpcDualPlatformBarrelHazard::render()
m_modelGfx->Render(renderPos,&rotation,&scale);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcDualPlatformBarrelHazard::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/hdbarrel.h
View file

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

12
source/hazard/hfalling.cpp
View file

@ -225,18 +225,6 @@ void CNpcFallingHazard::collidedWith( CThing *_thisThing )
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcFallingHazard::getThinkBBox()
{
CRECT objThinkBox = getCollisionArea();
sBBox &thinkBBox = CThingManager::getThinkBBox();
objThinkBox.y2 = thinkBBox.YMin + 1;
return &objThinkBox;
}*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcFallingHazard::setWaypoints( sThingHazard *ThisHazard )
{
int pointNum;

1
source/hazard/hfalling.h
View file

@ -22,7 +22,6 @@ class CNpcFallingHazard : public CNpcHazard
{
public:
void init();
//virtual CRECT const *getThinkBBox();
virtual void setWaypoints( sThingHazard *ThisHazard );
void render();
protected:

15
source/hazard/hrrock.cpp
View file

@ -199,18 +199,3 @@ void CNpcRollingRockHazard::render()
m_modelGfx->Render(renderPos,&rotation,&scale);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcRollingRockHazard::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/hrrock.h
View file

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

15
source/hazard/hspikes.cpp
View file

@ -95,21 +95,6 @@ void CNpcSpikesHazard::processMovement( int _frames )
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CRECT *CNpcSpikesHazard::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;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcSpikesHazard::processTimer( int _frames )
{
if ( m_timer > 0 )

2
source/hazard/hspikes.h
View file

@ -22,7 +22,7 @@ class CNpcSpikesHazard : public CNpcHazard
{
public:
void init();
virtual CRECT const *getThinkBBox();
bool alwaysThink() {return(true);}
protected:
virtual void processTimer( int _frames );
void processMovement( int _frames );

15
source/platform/pbgeyser.cpp
View file

@ -89,18 +89,3 @@ void CNpcGeyserPlatformGenerator::think( int _frames )
newPlatform->postInit();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcGeyserPlatformGenerator::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/platform/pbgeyser.h
View file

@ -23,7 +23,6 @@ class CNpcGeyserPlatformGenerator : public CNpcPlatform
public:
void setTargetType( NPC_PLATFORM_UNIT_TYPE targetType ) {m_targetType = targetType;}
virtual void render();
//virtual CRECT const *getThinkBBox();
protected:
virtual void think( int _frames );
virtual void collidedWith(CThing *_thisThing);

15
source/platform/pbubble.cpp
View file

@ -128,18 +128,3 @@ void CNpcBubblePlatform::processLifetime( int _frames )
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcBubblePlatform::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/platform/pbubble.h
View file

@ -23,7 +23,6 @@ class CNpcBubblePlatform : public CNpcPlatform
public:
virtual void render();
virtual void postInit();
//virtual CRECT const *getThinkBBox();
protected:
virtual void processLifetime( int _frames );
virtual void processMovement( int _frames );

15
source/platform/pbwheel.cpp
View file

@ -98,21 +98,6 @@ void CNpcBigWheelPlatform::setWaypoints( sThingPlatform *ThisPlatform )
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CRECT *CNpcBigWheelPlatform::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;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int CNpcBigWheelPlatform::getHeightFromPlatformAtPosition(int _x,int _y, int offsetX, int offsetY)
{
DVECTOR top;

2
source/platform/pbwheel.h
View file

@ -21,7 +21,7 @@
class CNpcBigWheelPlatform : public CNpcPlatform
{
public:
virtual CRECT const *getThinkBBox();
bool alwaysThink() {return(true);}
virtual void postInit();
virtual int getHeightFromPlatformAtPosition(int _x,int _y, int offsetX = 0, int offsetY = 0);
protected:

30
source/platform/pconveyr.cpp
View file

@ -87,21 +87,6 @@ void CNpcConveyorPlatformGenerator::think( int _frames )
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcConveyorPlatformGenerator::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;
}*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcConveyorPlatform::postInit()
{
CNpcPlatform::postInit();
@ -183,21 +168,6 @@ void CNpcConveyorPlatform::processMovement( int _frames )
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcConveyorPlatform::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;
}*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcConveyorPlatform::collidedWith( CThing *_thisThing )
{
switch(_thisThing->getThingType())

2
source/platform/pconveyr.h
View file

@ -22,7 +22,6 @@ class CNpcConveyorPlatform : public CNpcPlatform
{
public:
virtual void postInit();
//virtual CRECT const *getThinkBBox();
virtual void render();
virtual int checkCollisionAgainst(CThing *_thisThing, int _frames);
protected:
@ -37,7 +36,6 @@ class CNpcConveyorPlatformGenerator : public CNpcPlatform
{
public:
virtual void render();
//virtual CRECT const *getThinkBBox();
protected:
virtual void think( int _frames );
virtual void collidedWith(CThing *_thisThing);

15
source/platform/pdrop.cpp
View file

@ -35,18 +35,3 @@ void CNpcDropPlatform::processMovement( int _frames )
Pos.vy += moveY;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcDropPlatform::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;
}*/

2
source/platform/pdrop.h
View file

@ -20,8 +20,6 @@
class CNpcDropPlatform : public CNpcPlatform
{
//public:
//virtual CRECT const *getThinkBBox();
protected:
virtual void processMovement( int _frames );
};

15
source/platform/pdual.cpp
View file

@ -336,21 +336,6 @@ void CNpcDualPlatform::render()
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcDualPlatform::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;
}*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcDualPlatform::collidedWith( CThing *_thisThing )
{
switch(_thisThing->getThingType())

1
source/platform/pdual.h
View file

@ -29,7 +29,6 @@ public:
DVECTOR getLineBase() {return( m_lineBase );}
virtual void render();
void setThinkArea( CRECT &newArea );
//virtual CRECT const *getThinkBBox();
protected:
virtual void setWaypoints( sThingPlatform *ThisPlatform );
virtual void processMovement( int _frames );

15
source/platform/pfallnor.cpp
View file

@ -124,21 +124,6 @@ void CNpcFallingNoRespawnPlatform::processMovement( int _frames )
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CRECT *CNpcFallingNoRespawnPlatform::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;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CNpcFallingNoRespawnPlatform::render()
{
if ( m_isActive )

2
source/platform/pfallnor.h
View file

@ -22,7 +22,7 @@ class CNpcFallingNoRespawnPlatform : public CNpcPlatform
{
public:
virtual void postInit();
virtual CRECT const *getThinkBBox();
bool alwaysThink() {return(true);}
virtual int checkCollisionAgainst(CThing *_thisThing, int _frames);
protected:
virtual void render();

15
source/platform/pfgen.cpp
View file

@ -97,18 +97,3 @@ void CNpcFallingPlatformGenerator::think( int _frames )
newPlatform->postInit();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CRECT *CNpcFallingPlatformGenerator::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;
}

2
source/platform/pfgen.h
View file

@ -23,7 +23,7 @@ class CNpcFallingPlatformGenerator : public CNpcPlatform
public:
void setTargetType( NPC_PLATFORM_UNIT_TYPE targetType ) {m_targetType = targetType;}
virtual void render();
virtual CRECT const *getThinkBBox();
bool alwaysThink() {return(true);}
protected:
virtual void think( int _frames );
virtual void collidedWith(CThing *_thisThing);

15
source/platform/pjellfsh.cpp
View file

@ -140,18 +140,3 @@ void CNpcJellyfishPlatform::think( int _frames )
CNpcLinearPlatform::think( _frames );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcJellyfishPlatform::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/platform/pjellfsh.h
View file

@ -23,7 +23,6 @@ class CNpcJellyfishPlatform : public CNpcLinearPlatform
public:
virtual void postInit();
virtual void think( int _frames );
//virtual CRECT const *getThinkBBox();
protected:
virtual void collidedWith(CThing *_thisThing);

15
source/platform/plantern.cpp
View file

@ -118,18 +118,3 @@ void CNpcLanternPlatform::processMovement( int _frames )
Pos.vx = m_base.vx + ( ( m_length * rcos( m_heading + m_extension ) ) >> 12 );
Pos.vy = m_base.vy + ( ( m_length * rsin( m_heading + m_extension ) ) >> 12 );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CRECT *CNpcLanternPlatform::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;
}

2
source/platform/plantern.h
View file

@ -22,7 +22,7 @@ class CNpcLanternPlatform : public CNpcPlatform
{
public:
virtual void postInit();
virtual CRECT const *getThinkBBox();
bool alwaysThink() {return(true);}
protected:
virtual void setWaypoints( sThingPlatform *ThisPlatform );
virtual void processMovement( int _frames );

15
source/platform/plinear.cpp
View file

@ -136,18 +136,3 @@ void CNpcLinearPlatform::processMovement( int _frames )
Pos.vx += moveX;
Pos.vy += moveY;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcLinearPlatform::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/platform/plinear.h
View file

@ -22,7 +22,6 @@ class CNpcLinearPlatform : public CNpcPlatform
{
public:
virtual void postInit();
//virtual CRECT const *getThinkBBox();
protected:
virtual void processMovement( int _frames );
};

12
source/platform/ppendulm.cpp
View file

@ -196,15 +196,3 @@ void CNpcPendulumPlatform::render()
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcPendulumPlatform::getThinkBBox()
{
CRECT objThinkBox = getCollisionArea();
sBBox &thinkBBox = CThingManager::getThinkBBox();
objThinkBox.y1 = thinkBBox.YMax - 1;
return &objThinkBox;
}*/

1
source/platform/ppendulm.h
View file

@ -23,7 +23,6 @@ class CNpcPendulumPlatform : public CNpcPlatform
public:
virtual void postInit();
virtual void render();
//virtual CRECT const *getThinkBBox();
protected:
virtual void setWaypoints( sThingPlatform *ThisPlatform );
virtual void processMovement( int _frames );

15
source/platform/praft.cpp
View file

@ -212,18 +212,3 @@ void CNpcRaftPlatform::render()
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*const CRECT *CNpcRaftPlatform::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/platform/praft.h
View file

@ -23,7 +23,6 @@ class CNpcRaftPlatform : public CNpcPlatform
public:
virtual void postInit();
virtual void render();
//virtual CRECT const *getThinkBBox();
protected:
virtual void processMovement( int _frames );

15
source/triggers/tgbowl.cpp
View file

@ -68,20 +68,5 @@ void CGaryBowlTrigger::collidedWith(CThing *_thisThing)
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CRECT *CGaryBowlTrigger::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;
}
/*===========================================================================
end */

2
source/triggers/tgbowl.h
View file

@ -37,7 +37,7 @@
class CGaryBowlTrigger : public CTrigger
{
public:
virtual CRECT const *getThinkBBox();
bool alwaysThink() {return(true);}
protected:
virtual void collidedWith(CThing *_thisThing);
};