public bool collideThePair( )
{
bool collided;
collided = _pcrittercaller.collide(_pcritterarg);
return(collided);
}
public override bool collide(cCritter pcritter)
{
bool playerhigherthancritter = Position.Y - Radius > pcritter.Position.Y;
/* If you are "higher" than the pcritter, as in jumping on it, you get a point
* and the critter dies. If you are lower than it, you lose health and the
* critter also dies. To be higher, let's say your low point has to higher
* than the critter's center. We compute playerhigherthancritter before the collide,
* as collide can change the positions. */
_baseAccessControl = 1;
bool collided = base.collide(pcritter);
_baseAccessControl = 0;
if (!collided)
{
return(false);
}
/* If you're here, you collided. We'll treat all the guys the same -- the collision
* with a Treasure is different, but we let the Treasure contol that collision. */
if (playerhigherthancritter)
{
Framework.snd.play(Sound.Goopy);
//addScore( 10 );
}
else
{
if (!Shield)
{
damage(1);
Framework.snd.play(Sound.HammerOnce);
}
}
if (pcritter.IsKindOf("KnockbackBullet"))
{
KnockbackBullet bullet = (KnockbackBullet)pcritter;
pcritter.collide(this);
}
return(true);
}
/* Uses _foveaproportion which lies between 0.0 and 1.0. We say something is visible if it
* appears on the inner _foveaproportion central box of the viewer's image screen,
* which is what you see in the view window. */
//overloads
//Use _pownerview to get the CpopDoc and get the cGame from that.
public override void update(ACView pactiveview, float dt)
{
base.update(pactiveview, dt);
ZClipPlanes = Game.Border.outerBox(cSprite.MAXPRISMDZ);
if (_trackplayer &&
!((Listener != null) && Listener.RuntimeClass == "cListenerViewerRide"))
/* The meaning of the visibleplayer() condition is that it doesn't make sense
* to track the player if it's not an onscreen player. The reason for the
* listener condition is that you don't want to stare at the player when
* riding it. */
/* I should explain that the goal here is to not bother turning when the player
* is moving around in the middle of the veiw area, and only to turn when he's near
* the edge, but to have the turning when he's near the edge be smoooth.
* The use of the 0.85 foveaproportion parameter means that you react before the player
* gets right up to the edge. The reactproportion factor in lookAtProportional and
* moveToProportional is delicate and should probably be adjusted according to the
* current player speed relative to the visible window. The issue is that (a) if I make
* reactproportion too small, like 0.01, then the viewer doesn't turn (or move) fast
* enough to catch up with the player and keep it in view, but (b) if I make reactpropotion
* too big, like 0.5, then the turning or moving is such an abrupt jump that the visual
* effect is jerky. The goal is to do turns that are just big enough to not look jerky,
* but to have the turns be big enough so you aren't turning more often than you really
* have to. Another downside of a toosmall reactproportion, by the way, is that it can be
* computationally expensive to react.
* The way we finally solved this is to do a while loop to turn just
* far enough, moving just a little at a time so as to not overshoot. */
{
if (isVisible(Game.Player.Position)) // Uses _foveaproportion
{
_lastgoodplayeroffset = Position - Game.Player.Position;
}
/*I'm not sure about constantly changing _lastgoodplayeroffset. On the
* one hand, the offset I set in setViewpoint was a standard good one, so why
* not keep it. On the other, if I want to move my viewpoint around then I
* do want to be able to get a new value here. It seems ok for now.*/
else //not visible, so do somehting about it.
{
int loopcount = 0; /* Never have a while loop without a loopcount
* to make sure you don't spin inside the while forever under some
* unexpected situation like at startup. */
cVector3 lookat = Game.Player.Position;
cVector3 viewerpos = lookat + _lastgoodplayeroffset;
if (Game.worldShape() == cGame.SHAPE_XSCROLLER)
{
lookat = new cVector3(Game.Player.Position.X,
Game.Border.Midy, Game.Player.Position.Z);
viewerpos = new cVector3(lookat.X, Position.Y, Position.Z);
}
if (Game.worldShape() == cGame.SHAPE_YSCROLLER)
{
lookat = new cVector3(Game.Border.Midx,
Game.Player.Position.Y, Game.Player.Position.Z);
viewerpos = new cVector3(Position.X, lookat.Y, Position.Z);
}
if (_perspective)
{
while (!isVisible(lookat) && loopcount < 100) // Uses _foveaproportion
{
moveToProportional(viewerpos, cCritterViewer.TURNPROPORTION);
loopcount++;
}
}
else //ortho case
{
while (!isVisible(lookat) && loopcount < 100) // Uses _foveaproportion
{
moveToProportional(lookat + Game.Player.Binormal * 10.0f,
cCritterViewer.TURNPROPORTION);
loopcount++;
}
}
}
}
//Possibly ride the player.
if (Listener is cListenerViewerRide)
{
cCritter pplayer = Game.Player;
cVector3 offset = ((cListenerViewerRide)Listener).Offset;
moveTo(pplayer.Position +
pplayer.AttitudeTangent * offset.X +
pplayer.AttitudeNormal * offset.Y +
pplayer.AttitudeBinormal * offset.Z);
cRealBox3 skeleton = pplayer.MoveBox;
if (skeleton.ZSize < 0.5f)
{
skeleton.setZRange(0.0f, offset.Z);
}
if (skeleton.YSize < 0.5f)
{
skeleton.setYRange(0.0f, offset.Z);
}
skeleton.clamp(_position);
for (int i = 0; i < Game.Biota.count(); i++)
{
cCritter pother = Game.Biota.GetAt(i);
if (pother is cCritterWall)
{
pother.collide(this);
}
}
/* colliding with the wall may have twisted the viwer's orientation,
* so align it once again. */
Attitude = pplayer.Attitude; /* Before we call lookAt,
* make sure your attitude matches the player. For one thing,
* you may have gotten twisted around in the COLLIDEVIEWER code. */
lookAt(pplayer.Position +
pplayer.AttitudeTangent * cListenerViewerRide.PLAYERLOOKAHEAD * pplayer.Radius);
/* This has the effect that as offset gets large you change your
* looking direction see right in front of the player. The multiplier
* cCritterViewer.PLAYERLOOKAHEAD is tweaked to work well
* with the default cCritterViewer.OFFSET. */
}
}
