/**
* Placeholder event iteration.
*
* @param ticks Time
* @param msps Ticks per step
*
* @return Remaining event
*/
JJ2Event* OtherJJ2Event::step (unsigned int ticks, int msps) {
if (prepareStep(ticks, msps)) return remove();
return this;
}
/**
* Pickup event iteration.
*
* @param ticks Time
* @param msps Ticks per step
*
* @return Remaining event
*/
JJ2Event* PickupJJ2Event::step (unsigned int ticks, int msps) {
if (prepareStep(ticks, msps)) return remove();
if (!floating) {
if (jj2Level->checkMaskDown(x, y + F4, false)) {
dy += 1000 / msps;
} else {
dy = 0;
}
} else {
/// @todo Check for bullet overlap
// floating = false;
}
return this;
}
/**
* Spring event iteration.
*
* @param ticks Time
* @param msps Ticks per step
*
* @return Remaining event
*/
JJ2Event* SpringJJ2Event::step (unsigned int ticks, int msps) {
if (prepareStep(ticks, msps)) return remove();
if (!jj2Level->checkMaskDown(x, y + F1, true)) y += F1;
return this;
}
/**
* Episode B guardian iteration.
*
* @param ticks Time
*
* @return Remaining event
*/
JJ1Event* DeckGuardian::step (unsigned int ticks) {
int count;
set = prepareStep(ticks);
if (!set) return remove(false);
count = level->getEventHits(gridX, gridY);
if (count < 8) stage = 0;
else if (count < 16) stage = 1;
else if (count < 24) stage = 2;
else stage = 3;
// If the event has been destroyed, play its finishing animation and set its
// reaction time
if (set->strength &&
(level->getEventHits(gridX, gridY) >= set->strength) &&
((animType & ~1) != E_LFINISHANIM)) {
destroy(ticks);
}
// If the reaction time has expired
if (level->getEventTime(gridX, gridY) &&
(ticks > level->getEventTime(gridX, gridY))) {
if ((animType & ~1) != E_LFINISHANIM) {
level->setEventTime(gridX, gridY, 0);
}
}
return this;
}
/**
* Bridge iteration.
*
* @param ticks Time
*
* @return Remaining event
*/
JJ1Event* JJ1Bridge::step (unsigned int ticks) {
JJ1LevelPlayer* levelPlayer;
int count;
fixed bridgeLength, playerDipX, playerDipY;
set = prepareStep(ticks);
if (!set) return remove(false);
bridgeLength = set->multiA * set->pieceSize * F4;
// Gradually stop the bridge sagging
if (leftDipX < bridgeLength) leftDipX += 5120;
if (leftDipX > bridgeLength) leftDipX = bridgeLength;
if (rightDipX > 0) rightDipX -= 5120;
if (rightDipX < 0) rightDipX = 0;
for (count = 0; count < nPlayers; count++) {
levelPlayer = players[count].getJJ1LevelPlayer();
playerDipX = levelPlayer->getX() + PXO_MID - x;
if (playerDipX < bridgeLength >> 1) playerDipY = playerDipX >> 3;
else playerDipY = (bridgeLength - playerDipX) >> 3;
if (levelPlayer->overlap(x, y - F8 + playerDipY - F4, bridgeLength, F8) &&
!level->checkMaskDown(x + playerDipX, y - F8 + playerDipY - F32)) {
// Player is on the bridge
if (playerDipX < leftDipX) leftDipX = playerDipX;
if (playerDipX > rightDipX) rightDipX = playerDipX;
levelPlayer->setPlatform(gridX, gridY, 0, y - F8 - F1 + playerDipY);
} else levelPlayer->clearEvent(gridX, gridY);
}
/**
* Episode 1 guardian iteration.
*
* @param ticks Time
*
* @return Remaining event
*/
JJ1Event* MedGuardian::step(unsigned int ticks) {
fixed sin = fSin(ticks / 2);
fixed cos = fCos(ticks / 2);
set = prepareStep(ticks);
if (!set) return remove(false);
if (level->getEventHits(gridX, gridY) >= set->strength / 2)
stage = 1;
if (level->getEventHits(gridX, gridY) >= set->strength)
stage = 2;
// Stage 0: Move in an eight shape and fire the occasional shot
if (stage == 0) {
if (direction == 1) {
// Lower right part of the eight
setAnimType(E_LEFTANIM);
dx = TTOF(gridX) + (sin * 96) - x + ITOF(96);
dy = TTOF(gridY) - (cos * 64) - y;
if (cos > 0) direction = 2;
}
if (direction == 2) {
// Upper left part of the eight
setAnimType(E_LEFTANIM);
dx = TTOF(gridX) - (sin * 96) - x - ITOF(96);
dy = TTOF(gridY) - (cos * 64) - y;
if (cos < 0) direction = 3;
}
if (direction == 3) {
// Lower left part of the eight
setAnimType(E_RIGHTANIM);
dx = TTOF(gridX) - (sin * 96) - x - ITOF(96);
dy = TTOF(gridY) - (cos * 64) - y;
if (cos > 0) direction = 4;
}
if (direction == 4) {
// Upper right part of the eight
setAnimType(E_RIGHTANIM);
dx = TTOF(gridX) + (sin * 96) - x + ITOF(96);
dy = TTOF(gridY) - (cos * 64) - y;
if (cos < 0) direction = 1;
}
// Decide if there should be a shot
if ((ticks % (set->bulletPeriod * 25) >
(unsigned int)(set->bulletPeriod * 25) - 300)) {
level->setEventTime(gridX, gridY, ticks + 300);
shoot = true;
}
// Shoot if there is a shot
if (level->getEventTime(gridX, gridY) &&
(ticks > level->getEventTime(gridX, gridY)) &&
shoot) {
if (set->bullet < 32)
level->createBullet(NULL,
gridX,
gridY,
x + anim->getAccessoryShootX(),
y + anim->getAccessoryShootY(),
set->bullet,
(animType != E_LEFTANIM),
ticks);
shoot = false;
}
}
// Stage 1: Hop back and forth destroying the bottom row of tiles
if (stage == 1) {
fixed startPos = TTOF(gridY) + ITOF(40);
if (direction < 5) {
// Move up or down towards the starting position for hopping
direction = (y > startPos) ? 5 : 6;
}
// Move up to the correct height
if (direction == 5) {
if (y > startPos) {
dx = 0;
dy = ITOF(-2);
}
else direction = 7;
}
// Move down to the correct height
if (direction == 6) {
if (y < startPos) {
dx = 0;
dy = ITOF(2);
} else direction = 7;
}
// Cosinus should be near zero before we start hopping.
if (direction == 7) {
dx = 0;
dy = 0;
if (cos > -100 && cos < 100) direction = 8;
}
// Start hopping
if (direction == 8) {
if (level->checkMaskUp(x, y) ||
level->checkMaskUp(x + width, y))
setAnimType((animType == E_LEFTANIM) ? E_RIGHTANIM : E_LEFTANIM);
dy = startPos - abs(cos * 96) - y;
dx = abs(cos * 6);
if (animType == E_LEFTANIM)
dx *= -1;
if (cos < 0 &&
level->checkMaskDown(x + ITOF(anim->getWidth() / 2), y + TTOF(1)))
direction = 9;
}
// Destroy the block underneath
if (direction == 9) {
// Shake a bit
dx = (FTOI(x) % 2) ? ITOF(1) : ITOF(-1);
dy = 0;
// Remove the tile
if (cos > 0 && cos < 100) {
level->setTile(
FTOT(x + ITOF((anim->getWidth() / 2))),
FTOT(y) + 1,
set->magnitude);
direction = 8;
}
}
}
// Stage 2: End of behavior
if (stage == 2) {
dx = 0;
dy = ITOF(4);
}
x += dx;
y += dy;
dx = dx << 6;
dy = dy << 6;
return this;
}
