cosmosmash-1.4.8/src/CosmoSmashEngine.cpp

/*  $Id: CosmoSmashEngine.cpp,v 1.70 2017/12/09 18:20:43 sarrazip Exp $

    cosmosmash - A space rock shooting video game.
    Copyright (C) 2000-2011 Pierre Sarrazin <http://sarrazip.com/>

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public
    License along with this program; if not, write to the Free
    Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA  02110-1301, USA.
*/

#include "CosmoSmashEngine.h"

#include "Controller.h"

#include <flatzebra/PixmapLoadError.h>

#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include <stdint.h>

#include <map>
#include <vector>
#include <string>
#include <algorithm>
#include <iomanip>
#include <sstream>

#include "base.xpm"
#include "boosted-base.xpm"
#include "basebullet.xpm"
#include "bigrock0.xpm"
#include "bigrock1.xpm"
#include "bigrock2.xpm"
#include "bigrock3.xpm"
#include "bigrock4.xpm"
#include "bigrock5.xpm"
#include "smallrock0.xpm"
#include "smallrock1.xpm"
#include "smallrock2.xpm"
#include "smallrock3.xpm"
#include "smallrock4.xpm"
#include "smallrock5.xpm"
#include "explosion0.xpm"
#include "explosion1.xpm"
#include "bigspinner_backslash.xpm"
#include "bigspinner_horizontal.xpm"
#include "bigspinner_slash.xpm"
#include "bigspinner_vertical.xpm"
#include "smallspinner_backslash.xpm"
#include "smallspinner_horizontal.xpm"
#include "smallspinner_slash.xpm"
#include "smallspinner_vertical.xpm"
#include "pulsar_empty.xpm"
#include "pulsar_mid.xpm"
#include "pulsar_full.xpm"
#include "saucer0.xpm"
#include "saucer1.xpm"
#include "saucerbullet_empty.xpm"
#include "saucerbullet_mid.xpm"
#include "saucerbullet_full.xpm"
#include "question0.xpm"
#include "question1.xpm"

using namespace std;
using namespace flatzebra;

#ifdef _MSC_VER
    #define snprintf _snprintf
#endif


/*  Various constants:
*/

static const size_t
FRAMES_PER_SECOND = 20;

static const Couple theDrawingPixmapSize(WINDOW_WIDTH, WINDOW_HEIGHT);


static const int
PLAYER_SPEED = 15,
PLAYER_BULLET_SPEED = 36,
PULSAR_SPEED = 20,
SAUCER_SPEED = 8,
SAUCER_BULLET_SPEED = 20,
QUESTION_SPEED = 16;

static const int
SAUCER_Y_POS = 75,
NUM_INIT_LIVES = 5;

static const double TWO_PI = 8.0 * atan(1.0);

static const long
SCORE_LOST_BASE = -100,
SCORE_BIG_ROCK_LANDING = -5,
SCORE_SMALL_ROCK_LANDING = -10,
SCORE_BIG_ROCK = 10,
SCORE_SMALL_ROCK = 20,
SCORE_BIG_SPINNER = 40,
SCORE_SMALL_SPINNER = 80,
SCORE_PULSAR = 50,
SCORE_SAUCER_BULLET = 50,
SCORE_SAUCER = 100,
SCORE_QUESTION = 50;


// Defined as constants for efficiency:
static const size_t
NUM_SPINNER_IMAGES = 4,
NUM_PULSAR_IMAGES = 3,
NUM_ROCK_IMAGES = 6,
NUM_SAUCER_IMAGES = 2,
NUM_SAUCER_BULLET_IMAGES = 3,
NUM_STARS = 40,
NUM_MOUNTAIN_RANGE_POINTS = 10;


inline int
getLevelNum(long score)
{
    if (score >= 100000)
        return 6;
    if (score >= 50000)
        return 5;
    if (score >= 20000)
        return 4;
    if (score >= 5000)
        return 3;
    if (score >= 1000)
        return 2;
    return 1;
}


inline int
discreteUniformRand(const Couple &limits)
/*
    Returns a random integer between limits.x and limits.y inclusively.
    limits.x must be <= limits.y.
*/
{
    return rand() % (limits.y - limits.x + 1) + limits.x;
}


inline int
rnd(int lowerLimit, int upperLimit)
{
    return rand() % (upperLimit - lowerLimit + 1) + lowerLimit;
}


inline int
mulRound(int n, double x)
/*  Multiply the arguments, and round the result to the nearest integer
    according to its sign.
*/
{
    double product = n * x;
    if (product >= 0.0)
        return (int) (product + 0.5);
    return (int) (product - 0.5);
}

inline int
(min)(int a, int b)
{
        return (a < b ? a : b);
}


inline int
(max)(int a, int b)
{
        return (a > b ? a : b);
}


inline int
divideAmplitude(int n, int divisor)
{
    if (n == 0)
        return 0;
    if (n < 0)
        return min(n / divisor, -1);
    return max(n / divisor, +1);
}


inline Couple
divideAmplitude(const Couple &c, int divisor)
{
    return Couple(divideAmplitude(c.x, divisor), divideAmplitude(c.y, divisor));
}


inline int
decrementAmplitude(int n)
{
    if (n > 0)
        return n - 1;
    if (n < 0)
        return n + 1;
    return 0;
}


inline Couple
decrementAmplitude(const Couple &c)
{
    return Couple(decrementAmplitude(c.x), decrementAmplitude(c.y));
}


inline void
removeNullElementsFromSpriteList(SpriteList &slist)
{
    SpriteList::iterator it =
                    remove(slist.begin(), slist.end(), (Sprite *) NULL);
        /*  remove() has "packed" the remaining elements at the beginning
            of the sequence, but has not shortened the list.  This must
            be done by a call to the erase() method.  Doesn't this seem
            unintuitive?  I thought remove() removed stuff.
            @sarrazip 20010501
        */
    slist.erase(it, slist.end());
}


///////////////////////////////////////////////////////////////////////////////


CosmoSmashEngine::CosmoSmashEngine(
                    long initialScore,
                    bool _mirrorHyperspace, bool _useSound,
                    bool fullScreen, Controller *_controller,
                    ostream *_gameScriptStream,
                    bool processActiveEvent)
  : GameEngine(theDrawingPixmapSize, "Cosmosmash", fullScreen, processActiveEvent),
                  // may throw string exception

    pauseState(PLAYING),
    tickCount(0),
    useSound(_useSound),

    levelColors(),
    whiteColor(SDL_MapRGB(theSDLScreen->format, 0xff, 0xff, 0xff)),
    greenColor(SDL_MapRGB(theSDLScreen->format, 0x00, 0xff, 0x00)),
    explosionBGColor(SDL_MapRGB(theSDLScreen->format, 0xff, 0x80, 0x00)),

    mirrorHyperspace(_mirrorHyperspace),
    useGameExtensions(false),
    playerBoostTicks(0),
    playerBoostType(NO_BOOST),

    playerPA(2),
    playerSprite(NULL),

    baseBulletPA(1),
    baseBulletSprites(),

    bigRockPA(NUM_ROCK_IMAGES),
    smallRockPA(NUM_ROCK_IMAGES),
    rockSprites(),

    bigSpinnerPA(NUM_SPINNER_IMAGES),
    smallSpinnerPA(NUM_SPINNER_IMAGES),
    spinnerSprites(),

    pulsarPA(NUM_PULSAR_IMAGES),
    pulsarSprites(),

    saucerPA(NUM_SAUCER_IMAGES),
    saucerSprites(),

    saucerBulletPA(NUM_SAUCER_BULLET_IMAGES),
    saucerBulletSprites(),

    explosionPA(2),
    explosionSprites(),

    questionPA(2),
    questionSprites(),

    groundPos(0),
    groundHeight(0),
    mountainTopPos(0),

    controller(_controller),
    quitKS(SDLK_ESCAPE),

    initScore(initialScore),
    theScore(0),
    thePeakScore(0),
    theLevel(0),
    scoreAreaPos(),
    peakScoreAreaPos(),
    levelNumAreaPos(),

    numLives(0),
    updateNumLives(true),
    numLivesAreaPos(),

    timeBeforeNextPulsar(0),
    timeBeforeNextSaucer(0),
    timeBeforeNextQuestion(0),

    starPositions(),
    mountainRangePositions(),

    theSoundMixer(NULL),
    playerHitSound(),
    pulsarBeepSound(),
    saucerShootingSound(),
    hyperspaceSound(),
    timeBeforeNextCadenceSound(0),

    gameScriptStream(_gameScriptStream)
{
    assert(controller != NULL);

    levelColors[0] = 0;  // unused
    levelColors[1] = SDL_MapRGB(theSDLScreen->format, 0x00, 0x00, 0x00);
    levelColors[2] = SDL_MapRGB(theSDLScreen->format, 0x00, 0x00, 0xff);
    levelColors[3] = SDL_MapRGB(theSDLScreen->format, 0x80, 0x00, 0x80);
    levelColors[4] = SDL_MapRGB(theSDLScreen->format, 0x00, 0x7f, 0x7f);
    levelColors[5] = SDL_MapRGB(theSDLScreen->format, 0x7f, 0x7f, 0x7f);
    levelColors[6] = SDL_MapRGB(theSDLScreen->format, 0x00, 0x00, 0x00);

    assert(initScore >= 0);
    assert(theSDLScreen != NULL);
    assert(theSDLScreen->format != NULL);

    try
    {
        initializeSprites();
    }
    catch (PixmapLoadError &e)
    {
        string msg = "Could not load pixmap " + e.getFilename();
        throw msg;
    }

    initializeMisc(useSound);  // may throw a 'string'
}


CosmoSmashEngine::~CosmoSmashEngine()
{
    // Sprites must be killed to avoid memory leaks.
    killAllAutomaticCharacters();
    killSpritesInList(baseBulletSprites);

    roundbeetle::Engine::destroy();
    theSoundMixer = NULL;

    delete controller;
    delete playerSprite;
}


void
CosmoSmashEngine::initializeSprites()
{
    groundPos = theDrawingPixmapSize.y - 50;
    groundHeight = 10;

    // Load some pixmaps:
    loadPixmap(base_xpm, playerPA, 0);
    loadPixmap(boosted_base_xpm, playerPA, 1);

    // Create and position the player sprite:
    playerSprite = new Sprite(playerPA,
            Couple((theDrawingPixmapSize.x - playerPA.getImageSize().x) / 2,
                    groundPos - playerPA.getImageSize().y),
            Couple(0, 0), Couple(0, 0),
            Couple(6, 6), playerPA.getImageSize() - Couple(12, 12));
        // this Sprite object does not own playerPA


    // Base bullets:
    loadPixmap(basebullet_xpm, baseBulletPA, 0);

    // Rocks:
    loadPixmap(bigrock0_xpm, bigRockPA, 0);
    loadPixmap(bigrock1_xpm, bigRockPA, 1);
    loadPixmap(bigrock2_xpm, bigRockPA, 2);
    loadPixmap(bigrock3_xpm, bigRockPA, 3);
    loadPixmap(bigrock4_xpm, bigRockPA, 4);
    loadPixmap(bigrock5_xpm, bigRockPA, 5);
    loadPixmap(smallrock0_xpm, smallRockPA, 0);
    loadPixmap(smallrock1_xpm, smallRockPA, 1);
    loadPixmap(smallrock2_xpm, smallRockPA, 2);
    loadPixmap(smallrock3_xpm, smallRockPA, 3);
    loadPixmap(smallrock4_xpm, smallRockPA, 4);
    loadPixmap(smallrock5_xpm, smallRockPA, 5);

    // Big spinner:
    loadPixmap(bigspinner_horizontal_xpm, bigSpinnerPA, 0);
    loadPixmap(bigspinner_slash_xpm,      bigSpinnerPA, 1);
    loadPixmap(bigspinner_vertical_xpm,   bigSpinnerPA, 2);
    loadPixmap(bigspinner_backslash_xpm,  bigSpinnerPA, 3);

    // Small spinner:
    loadPixmap(smallspinner_horizontal_xpm, smallSpinnerPA, 0);
    loadPixmap(smallspinner_slash_xpm,      smallSpinnerPA, 1);
    loadPixmap(smallspinner_vertical_xpm,   smallSpinnerPA, 2);
    loadPixmap(smallspinner_backslash_xpm,  smallSpinnerPA, 3);

    // Pulsar:
    loadPixmap(pulsar_empty_xpm, pulsarPA, 0);
    loadPixmap(pulsar_mid_xpm,   pulsarPA, 1);
    loadPixmap(pulsar_full_xpm,  pulsarPA, 2);

    // Saucer:
    loadPixmap(saucer0_xpm, saucerPA, 0);
    loadPixmap(saucer1_xpm, saucerPA, 1);

    // Saucer bullets:
    loadPixmap(saucerbullet_empty_xpm, saucerBulletPA, 0);
    loadPixmap(saucerbullet_mid_xpm,   saucerBulletPA, 1);
    loadPixmap(saucerbullet_full_xpm,  saucerBulletPA, 2);

    // Explosion:
    loadPixmap(explosion0_xpm, explosionPA, 0);
    loadPixmap(explosion1_xpm, explosionPA, 1);

    // Question (surprise) sprites:
    loadPixmap(question0_xpm, questionPA, 0);
    loadPixmap(question1_xpm, questionPA, 1);
}


static
string
getDir(const char *defaultValue, const char *envVarName)
{
    string dir;
    const char *s = getenv(envVarName);
    if (s != NULL)
        dir = s;
    else
        dir = defaultValue;

    if (!dir.empty() && dir[dir.length() - 1] != '/')
        dir += '/';

    return dir;
}


void
CosmoSmashEngine::initializeMisc(bool useSound)
/*
    Throws an error message in a 'string' if an error occurs.
*/
{
    theScore = initScore;
    thePeakScore = initScore;
    theLevel = getLevelNum(theScore);
    scoreAreaPos = Couple(4, theDrawingPixmapSize.y - 31);
    peakScoreAreaPos = scoreAreaPos + Couple(0, 15);
    numLives = 0;
    updateNumLives = true;
    numLivesAreaPos = Couple(theDrawingPixmapSize.x - 79, peakScoreAreaPos.y);
    levelNumAreaPos = Couple(numLivesAreaPos.x, scoreAreaPos.y);
    playerBoostTicks = 0;
    playerBoostType = NO_BOOST;


    setTimeBeforeNextPulsar();
    setTimeBeforeNextSaucer();
    setTimeBeforeNextQuestion();


    /*  Initialize mountain range positions:
    */
    int y0 = groundPos - 100;
    int y1 = groundPos -  70;
    int y2 = groundPos -  50;

    mountainTopPos = y0;

    size_t i;
    for (i = 0; i < NUM_MOUNTAIN_RANGE_POINTS; i++)
    {
        int x = i * theDrawingPixmapSize.x / (NUM_MOUNTAIN_RANGE_POINTS - 1);
        int y;
        if (i & 1)
            y = rnd(y0, y1);
        else
            y = rnd(y1, y2);
        mountainRangePositions.push_back(Couple(x, y));
    }


    /*  Initialize star positions:
    */
    const int padding = 8;
    for (i = 0; i < NUM_STARS; i++)
    {
        int x = rnd(padding, theDrawingPixmapSize.x - padding);
        int y = rnd(padding, mountainTopPos - 10);
        starPositions.push_back(Couple(x, y));
    }


    /*  Sound effects:
    */
    if (useSound)
    {
        string pkgsounddir = getDir(PKGSOUNDDIR, "PKGSOUNDDIR");

        // A high sample rate is necessary for the sound renderer,
        // to make sure the spinner square wave's frequency
        // decreases smoothly to the human ear.
        //
        int status = roundbeetle::Engine::create(44100, 0, NULL);
        if (status != 0)
        {
            stringstream ss;
            ss << "RoundBeetle sound engine initialization error #" << status;
            throw ss.str();
        }

        theSoundMixer = &roundbeetle::Engine::instance();
        assert(theSoundMixer != NULL);
        theSoundMixer->postBusInit();

        try
        {
            for (size_t i = 0; i < NUM_ROCK_HIT_SOUNDS; i++)
            {
                string filename = pkgsounddir + "rock-hit-" + char('0' + i) + ".wav";
                rockHitSounds[i].init(filename);
            }

            playerHitSound.init(pkgsounddir + "player-hit.wav");
            pulsarBeepSound.init(pkgsounddir + "pulsar-beep.wav");
            saucerShootingSound.init(pkgsounddir + "saucer-shooting.wav");
            hyperspaceSound.init(pkgsounddir + "hyperspace.wav");

            timeBeforeNextCadenceSound = 0;
        }
        catch (const string &e)
        {
            throw e;
        }
    }
}


void
CosmoSmashEngine::setTimeBeforeNextPulsar()
{
    int min = 13 - 2 * theLevel;
    int max = 53 - 8 * theLevel;
    timeBeforeNextPulsar = rnd(20 * min, 20 * max);
}


void
CosmoSmashEngine::setTimeBeforeNextSaucer()
{
    int lev = theLevel - 4;
    int min = 5 - lev * 2;
    int max = 30 - lev * 10;
    timeBeforeNextSaucer = rnd(20 * min, 20 * max);
}


void
CosmoSmashEngine::setTimeBeforeNextQuestion()
{
    static const char *q = getenv("Q");
    timeBeforeNextQuestion = (q != NULL ? 100 : rnd(20 * 10, 20 * 30));
}


///////////////////////////////////////////////////////////////////////////////


/*virtual*/
void
CosmoSmashEngine::processKey(SDLKey keysym, bool pressed)
{
    controller->processKey(keysym, pressed);

    quitKS.check(keysym, pressed);
}


/*virtual*/
void
CosmoSmashEngine::processActivation(bool appActive)
{
    if (!appActive)  // if loss of focus:
    {
        assert(pauseState == PLAYING || pauseState == AWAITING_RESUME);

        if (pauseState == PLAYING)
        {
            pause();

            if (numLives > 0)
            {
                // Display the pause message here because tick() will not be called
                // until this method is called again to reactivate the application.
                //
                displayPauseMessage();
            }
        }

        pauseState = LOST_FOCUS;
    }
    else  // gaining focus:
    {
        assert(pauseState == LOST_FOCUS);

        // No resume here. Game waits for user to press resume key.
        //
        pauseState = AWAITING_RESUME;
    }

    registerTickEnd();
}


// CAUTION: does not change 'pauseState', which must be managed
// by the caller.
//
void
CosmoSmashEngine::pause()
{
    registerCommand(COMMAND_PAUSE);
    if (theSoundMixer != NULL)
        (void) theSoundMixer->pauseEngine();
}


void
CosmoSmashEngine::resume()
{
    registerCommand(COMMAND_RESUME);
    if (theSoundMixer != NULL)
        (void) theSoundMixer->resumeEngine();
}


/*virtual*/
bool
CosmoSmashEngine::tick()
{
    if (quitKS.isPressed())
        return false;

    controller->startOfTick();

    bool ret = true;

    if (controller->isFullScreenToggleRequested())
        setVideoMode(theScreenSizeInPixels, !inFullScreenMode());  // ignore failure

    if (pauseState == AWAITING_RESUME)
    {
        if (controller->isResumeRequested())
        {
            resume();
            pauseState = PLAYING;
        }
        else
            displayPauseMessage();
    }
    else
    {
        tickCount++;

        detectCollisions();

        if (!animatePlayer())
            ret = false;
        else
        {
            animateAutomaticCharacters();
            restoreBackground();
            drawSprites();


            /*  If the game is in demo mode, the Space bar starts a new game.
            */
            if (numLives == 0)
            {
                if (controller->isStartRequested(useGameExtensions))
                {
                    registerCommand(COMMAND_START);

                    displayStartMessage(false);

                    killAllAutomaticCharacters();
                    centerPlayerSprite();
                    theScore = initScore;
                    thePeakScore = initScore;
                    numLives = NUM_INIT_LIVES;

                    addToScore(0);
                    addToNumLives(0);
                }
                else
                {
                    /*  At the end of a game, wait for the last base to have
                        finished exploding before displaying the start
                        message again.
                    */
                    bool baseExploding = (playerSprite->getTimeToLive() != 0);
                    if (! baseExploding)
                        displayStartMessage(true);
                }
            }
            else
                playCadenceSound();
        }
    }

    controller->endOfTick();

    registerTickEnd();

    return ret;
}


void
CosmoSmashEngine::fireBullet(Couple pos)
{
    Couple bbSize = baseBulletPA.getImageSize();
    Sprite *s = new Sprite(baseBulletPA,
                pos, Couple(0, -PLAYER_BULLET_SPEED), Couple(0, 0),
                Couple(-4, 0), bbSize + Couple(4, 0));
    baseBulletSprites.push_back(s);

    if (theLevel >= 5)  // double bullet in higher levels
    {
        int n = (theLevel == 5 ? bbSize.y / 2 : bbSize.y);
        Couple pos2 = pos;
        pos2.y -= n;
        Sprite *s = new Sprite(baseBulletPA,
                pos2, Couple(0, -PLAYER_BULLET_SPEED), Couple(0, 0),
                Couple(0, 0), bbSize);
        baseBulletSprites.push_back(s);
    }

    if (playerBoostTicks > 0 && playerBoostType == TRIPLE_BULLETS)
    {
        int vx = 3;
        Couple pos2 = pos;
        pos2.x -= bbSize.x + 1;
        Sprite *s = new Sprite(baseBulletPA,
                    pos2, Couple(-vx, -PLAYER_BULLET_SPEED), Couple(0, 0),
                    Couple(0, 0), bbSize);
        baseBulletSprites.push_back(s);

        pos2 = pos;
        pos2.x += bbSize.x + 1;
        s = new Sprite(baseBulletPA,
                    pos2, Couple(+vx, -PLAYER_BULLET_SPEED), Couple(0, 0),
                    Couple(0, 0), bbSize);
        baseBulletSprites.push_back(s);
    }
}


bool
CosmoSmashEngine::animatePlayer()
/*
    Returns true if the game must continue, or false to have it stop.
*/
{
    // Inform the controller of the current state of the game:
    {
        controller->beginGameState();

        controller->setPlayerPos(playerSprite->getCenterPos());

        SpriteList::iterator its;
        for (its = rockSprites.begin(); its != rockSprites.end(); its++)
            controller->addRockPos((*its)->getCenterPos());
        for (its = spinnerSprites.begin(); its != spinnerSprites.end(); its++)
            controller->addSpinnerPos((*its)->getCenterPos());
        for (its = pulsarSprites.begin(); its != pulsarSprites.end(); its++)
            controller->addPulsarPos((*its)->getCenterPos());
        for (its = saucerBulletSprites.begin(); its != saucerBulletSprites.end(); its++)
            controller->addPulsarPos((*its)->getCenterPos());

        controller->endGameState();
    }

    if (numLives > 0 && controller->isPauseRequested())
    {
        pause();
        pauseState = AWAITING_RESUME;
        return true;
    }

    if (playerSprite->decTimeToLive() != 0)  // if player base exploding
        return true;

    if (controller->isEndRequested())
        numLives = 0;

    if (! playerIsActive())
        return true;


    Couple &playerPos = playerSprite->getPos();
    const Couple &playerSize = playerSprite->getSize();


    /*  Fire a bullet once in a while:
    */
    int ticksBetweenBullets =
           (playerBoostTicks > 0 && playerBoostType == CLOSER_BULLETS ? 2 : 4);
    if (tickCount % ticksBetweenBullets == 0 && controller->isShootingActive())
    {
        registerCommand(COMMAND_SHOOT);

        Couple bbSize = baseBulletPA.getImageSize();
        Couple pos = playerPos + Couple((playerSize.x - bbSize.x) / 2, 0);

        fireBullet(pos);
    }
    if (playerBoostTicks > 0)
        playerBoostTicks--;


    Couple &playerSpeed = playerSprite->getSpeed();

    /*  Get and process user commands:
    */

    playerSpeed.zero();

    if (controller->isHyperspaceRequested())
    {
        registerCommand(COMMAND_HYPERSPACE);

        Couple size = playerSprite->getSize();
        int newX;
        if (mirrorHyperspace)
        {
            // Mirror the player's position WRT the center:
            Couple center = playerSprite->getCenterPos();
            int newXCenter = theScreenSizeInPixels.x - center.x;
            newX = newXCenter - size.x / 2;
            if (newX < 0)
                newX = 0;  // just to be sure...
        }
        else
            newX = rnd(0, theScreenSizeInPixels.x - size.x);

        Couple newPos(newX, groundPos - playerPA.getImageSize().y);
        repositionPlayerSprite(newPos);

        playSoundEffect(hyperspaceSound);

        return true;
    }

    if (controller->isLeftMoveRequested())
    {
        registerCommand(COMMAND_MOVE_LEFT);
        playerSpeed.x = -PLAYER_SPEED;
    }
    if (controller->isRightMoveRequested())
    {
        registerCommand(COMMAND_MOVE_RIGHT);
        playerSpeed.x = +PLAYER_SPEED;
    }

    if (playerSpeed.isZero())
        return true;

    Couple newPos = playerPos + playerSpeed;
    if (newPos.x < 0)
        newPos.x = 0;
    else if (newPos.x + playerSize.x > theDrawingPixmapSize.x)
        newPos.x = theDrawingPixmapSize.x - playerSize.x;

    playerPos = newPos;

    return true;
}


void
CosmoSmashEngine::killSpritesInList(SpriteList &sl)
{
    for (SpriteList::iterator its = sl.begin(); its != sl.end(); its++)
        delete *its;

    sl.clear();
    assert(sl.size() == 0);
}


void
CosmoSmashEngine::centerPlayerSprite()
{
    Couple newPos(
            (theDrawingPixmapSize.x - playerPA.getImageSize().x) / 2,
            groundPos - playerPA.getImageSize().y);
    repositionPlayerSprite(newPos);
}


void
CosmoSmashEngine::repositionPlayerSprite(Couple newPos)
{
    playerSprite->setPos(newPos);
}


void
CosmoSmashEngine::killAllAutomaticCharacters()
{
    killSpritesInList(rockSprites);
    killSpritesInList(spinnerSprites);
    killSpritesInList(pulsarSprites);
    killSpritesInList(saucerSprites);
    killSpritesInList(saucerBulletSprites);
    killSpritesInList(questionSprites);
}


void
CosmoSmashEngine::killPlayerBase()
{
    static const char *noKillEnvVar = getenv("NOKILL");

    if (noKillEnvVar != NULL)
            return;

    playSoundEffect(playerHitSound);

    addToScore(SCORE_LOST_BASE);

    Couple pos = playerSprite->getCenterPos();
    pos.y = playerSprite->getLowerRightPos().y - 1;
    static const Couple directions[] =
    {
        Couple(  10,   0 ),
        Couple(   7,  -7 ),
        Couple(   0, -10 ),
        Couple(  -7,  -7 ),
        Couple( -10,   0 ),
        Couple(   0,   0 )  // zero marks the end
    };

    const int explosionTime = 40;  // in ticks

    for (size_t i = 0; directions[i].isNonZero(); i++)
    {
        Sprite *explosion = createExplosionSprite(pos, explosionTime);
        explosion->setSpeed(directions[i]);
    }

    playerSprite->setTimeToLive(explosionTime);
            /*  The player's "time to live" value is used to mark
                the period during which it is exploding. The player's
                sprite is not displayed during that time. It is
                repositioned for when it starts being displayed again.
            */
    centerPlayerSprite();
    addToNumLives(-1);

    playerBoostTicks = 0;
    playerBoostType = NO_BOOST;

    killAllAutomaticCharacters();
            /*  We kill falling sprites to avoid situations where e.g.,
                spinners keep landing while the player is exploding.
                Such situations could make the player lose many lives in a row.
            */

    killSpritesInList(baseBulletSprites);
}


inline bool
CosmoSmashEngine::playerIsActive() const
/*
    Returns true iff the player still has lives and not currently exploding...
*/
{
    return (numLives > 0 && playerSprite->getTimeToLive() == 0);
}


pair<bool, size_t>
CosmoSmashEngine::animateFallingObjects(SpriteList &sprites)
/*
    Moves the sprites in the designated sprite list.

    If one of the sprites collides with the player, the player dies
    and the sprite is eliminated.
    Sprites that land are eliminated.
    Sprites that go off to the left or right of the screen are
    silently eliminated.

    Returns a boolean value that indicates if the player dies, and the
    number of falling objects that landed.

    When this method exits, pointers to eliminated sprites have been
    removed from 'sprites'.
*/
{
    bool playerDies = false;
    size_t numLandings = 0;  // number of objects that touch the ground

    for (SpriteList::iterator it = sprites.begin(); it != sprites.end(); it++)
    {
        Sprite *s = *it;
        assert(s != NULL);
        s->addSpeedToPos();

        if (playerIsActive() && s->collidesWithSprite(*playerSprite))
        {
            playerDies = true;

            delete s;
            *it = NULL;
            continue;
        }

        // Get y coordinate of bottom of sprite's collision box:
        int collBoxBottom = (s->getPos() + s->getCollBoxPos() + s->getCollBoxSize()).y;
        int height = groundPos - collBoxBottom;

        if (height <= - groundHeight)  // if sprite low enough, it dies
        {
            numLandings++;

            delete s;
            *it = NULL;
            continue;
        }

        const Couple newPos = s->getPos();
        if (newPos.x >= theScreenSizeInPixels.x
                        || newPos.x + s->getSize().x <= 0)
        {
            // object disappears without consequence
            delete s;
            *it = NULL;
            continue;
        }
    }

    removeNullElementsFromSpriteList(sprites);

    return pair<bool, size_t>(playerDies, numLandings);
}


void
CosmoSmashEngine::animateSaucers()
{
    bool playerDies = false;

    for (SpriteList::iterator it = saucerSprites.begin();
                                it != saucerSprites.end(); it++)
    {
        Sprite *saucer = *it;
        Couple &pos = saucer->getPos();
        const Couple &size = saucer->getSize();

        pos += saucer->getSpeed();

        // if the saucer is now off the screen:
        if (pos.x >= theScreenSizeInPixels.x || pos.x + size.x <= 0)
        {
            delete saucer;
            *it = NULL;
            continue;
        }

        // make saucer shoot periodically:
        if (tickCount % 8 == 0 && playerSprite->getTimeToLive() == 0)
        {
            const Couple size = saucerBulletPA.getImageSize();
            Couple bulletPos = pos;

            // Choose speed in direction of player base:
            Couple diff = playerSprite->getPos() - bulletPos;
            double k = SAUCER_BULLET_SPEED / hypot(diff.x, diff.y);
            Couple speed(mulRound(diff.x, k), mulRound(diff.y, k));
            speed = accelerate(speed);
            if (speed.isZero())
                speed = Couple(0, SAUCER_BULLET_SPEED);
            Sprite *s = new Sprite(saucerBulletPA,
                                    pos, speed, Couple(0, 0),
                                    Couple(2, 2), size - Couple(2, 2));
            saucerBulletSprites.push_back(s);

            playSoundEffect(saucerShootingSound);
        }
    }
    removeNullElementsFromSpriteList(saucerSprites);

    if (playerDies)
        killPlayerBase();
}


void
CosmoSmashEngine::startSpinnerSound(SpinnerSprite &s)
{
    if (theSoundMixer == NULL)
        return;
    roundbeetle::ADSR adsr(.0f, .1f, 0, 0, 3600, 0);  // longer than needed
    int req = theSoundMixer->requestSquareWave(s.getLinearMovingFreq(),
                                               adsr,
                                               1,
                                               theSoundMixer->getMainBus());
    s.setSoundReq(req);
}


void
CosmoSmashEngine::animateAutomaticCharacters()
{
    /*  If there are not enough ordinary falling sprites, add some:
    */
    size_t numFallingObjects = rockSprites.size() + spinnerSprites.size();
    size_t min = (theLevel < 5 ? 2 : 3);
    if (numFallingObjects < min && playerSprite->getTimeToLive() == 0)
    {
        int rockFreq = 8;
        if (theLevel >= 2)
            --rockFreq;
        if (theLevel >= 3)
            --rockFreq;
        if (rand() % rockFreq == 0)
        {
            // New spinner (more small spinners starting at level 2):
            int n = (theLevel < 2 ? 3 : 2);
            bool small = (rand() % n == 0);
            const PixmapArray *pa = (small ? &smallSpinnerPA : &bigSpinnerPA);
            const Couple size = pa->getImageSize();
            Couple pos(rnd(0, theScreenSizeInPixels.x - size.x), - size.y);
            Couple speed(rnd(-2, +2), rnd(3, 9));
            speed = accelerate(speed);

            // Specify square wave sound:
            float startFreq = 400 + (small ? 40 : 0) + rand() % 40;
            float endFreq = 80 + (small ? 20 : 0) + rand() % 20;
            float durationInS = float(WINDOW_HEIGHT - groundHeight)
                                / speed.y / FRAMES_PER_SECOND;

            SpinnerSprite *s = new SpinnerSprite(*pa, pos, speed,
                                                 size / 3, size / 3,
                                                 theSoundMixer,
                                                 startFreq,
                                                 endFreq,
                                                 durationInS);
            if (playerIsActive())
                startSpinnerSound(*s);
            spinnerSprites.push_back(s);
        }
        else
        {
            // New rock:
            const PixmapArray *pa =
                        (rand() % 3 == 0 ? &smallRockPA : &bigRockPA);
            const Couple size = pa->getImageSize();
            Couple pos(rnd(0, theScreenSizeInPixels.x - size.x), - size.y);
            Couple speed(rnd(-2, +2), rnd(3 + theLevel, 20 + theLevel));
            speed = accelerate(speed);
            Sprite *s = new Sprite(*pa, pos, speed, Couple(0, 0),
                                    Couple(4, 4), size - Couple(4, 4));
            s->currentPixmapIndex = rnd(0, NUM_ROCK_IMAGES - 1);
            rockSprites.push_back(s);
        }
    }


    /*  Send a new pulsar once in a while.
    */
    if (playerIsActive()
                && playerSprite->getTimeToLive() == 0
                && --timeBeforeNextPulsar == 0)
    {
        setTimeBeforeNextPulsar();
        const Couple size = pulsarPA.getImageSize();
        Couple pos(rnd(0, theScreenSizeInPixels.x - size.x), - size.y);
        Couple speed(0, PULSAR_SPEED + 3 * (theLevel >= 4));
        speed = accelerate(speed);
        Sprite *s = new Sprite(pulsarPA,
                                pos, speed, Couple(0, 0),
                                size / 4, size / 2);
        s->setTimeToLive(4 * 20);
        pulsarSprites.push_back(s);
    }


    /*  Send a new saucer once in a while.
    */
    if (playerIsActive()
                && theLevel >= 4
                && playerSprite->getTimeToLive() == 0
                && --timeBeforeNextSaucer == 0)
    {
        setTimeBeforeNextSaucer();
        const Couple size = saucerPA.getImageSize();

        Couple pos, speed;
        int v = SAUCER_SPEED + 2 * (theLevel >= 5);
        if (rnd(0, 1) == 0)
        {
            pos = Couple(- size.x, SAUCER_Y_POS);
            speed = Couple(v, 0);
        }
        else
        {
            pos = Couple(theScreenSizeInPixels.x, SAUCER_Y_POS);
            speed = Couple(- v, 0);
        }

        Sprite *s = new Sprite(saucerPA,
                                pos, speed, Couple(0, 0),
                                Couple(2, 2), size - Couple(2, 2));
        s->currentPixmapIndex = 0;
        saucerSprites.push_back(s);
    }


    /*  Send a new question mark once in a while.
    */
    if (useGameExtensions
                && playerIsActive()
                && theLevel >= 0
                && playerSprite->getTimeToLive() == 0
                && --timeBeforeNextQuestion == 0)
    {
        setTimeBeforeNextQuestion();
        const Couple size = questionPA.getImageSize();

        Couple pos, speed;
        pos = Couple(
                rnd(size.x * 4, theScreenSizeInPixels.x - size.x * 4),
                - size.y);
        speed = Couple(rnd(-2, +2), QUESTION_SPEED + 2 * (theLevel >= 5));

        Sprite *s = new Sprite(questionPA,
                                pos, speed, Couple(0, 0),
                                Couple(2, 2), size - Couple(2, 2));
        s->currentPixmapIndex = 0;
        questionSprites.push_back(s);
    }


    /*  Let the rocks fall. If they hit the ground or go off the screen
        on the left or right, kill them. If they hit the player (while it
        is not currently exploding), then make the player explode.
    */
    pair<bool, size_t> p = animateFallingObjects(rockSprites);
    if (p.second > 0 && numLives > 0)  // if rocks landed and player has lives
        addToScore(SCORE_BIG_ROCK_LANDING * p.second);
                // NOTE: landing of small rock still scored as big rock
    if (p.first)  // if collision with player
        killPlayerBase();


    /*  Let the question marks fall...
    */
    if (useGameExtensions)
    {
        pair<bool, size_t> p = animateFallingObjects(questionSprites);
        // We don't care when the question marks land.
        if (p.first)  // if collision with player
            killPlayerBase();
    }


    /*  Let the spinners fall. If they hit the ground, the player dies.
        If they go off the screen on the left or right, kill them.
        If they hit the player (while it is not currently exploding),
        then the player dies.
    */
    p = animateFallingObjects(spinnerSprites);
    if (p.second > 0 && playerIsActive())
        killPlayerBase();
    else if (p.first)
        killPlayerBase();


    /*  Let the saucer bullets fall. If they hit the ground, kill them.
        If they go off the screen on the left or right, kill them.
        If they hit the player (while it is not currently exploding),
        then the player dies.
    */
    p = animateFallingObjects(saucerBulletSprites);
    if (p.first)
        killPlayerBase();


    /*  Let the pulsars fall. If they hit the ground, kill them.
        If they go off the screen on the left or right, kill them.
        If they hit the player (while it is not currently exploding),
        then the player dies.
        Pulsars disappear after some time.
        Once in a while, redirect them towards the player.
    */
    p = animateFallingObjects(pulsarSprites);
    if (p.first)
        killPlayerBase();


    int n = (theLevel < 3 ? 8 : 6);  // ticks between direction changes
    SpriteList::iterator it;
    for (it = pulsarSprites.begin(); it != pulsarSprites.end(); it++)
    {
        Sprite *pulsar = *it;
        assert(pulsar != NULL);
        if (pulsar->decTimeToLive() == 0)
        {
            delete pulsar;
            *it = NULL;
        }
        else if (tickCount % n == 0)
        {
            Couple diff = playerSprite->getPos() - pulsar->getPos();
            // NOTE: use projection instead of trig; see animateSaucers()
            double angle = atan2((double) diff.y, (double) diff.x);
            Couple newSpeed(int(PULSAR_SPEED * cos(angle)),
                                        int(PULSAR_SPEED * sin(angle)));
            if (newSpeed.isZero())
                newSpeed = Couple(0, PULSAR_SPEED);
            pulsar->setSpeed(newSpeed);
        }
    }
    removeNullElementsFromSpriteList(pulsarSprites);


    /*  Move the saucers.
    */
    animateSaucers();


    /*  Move the player's bullets:
    */
    for (it = baseBulletSprites.begin(); it != baseBulletSprites.end(); it++)
    {
        Sprite *s = *it;
        assert(s != NULL);
        s->addSpeedToPos();
        if (s->getPos().y + s->getSize().y <= 0)  // if completely above screen
        {
            delete s;
            *it = NULL;
        }
    }
    removeNullElementsFromSpriteList(baseBulletSprites);


    /*  Animate explosions:
    */
    for (it = explosionSprites.begin(); it != explosionSprites.end(); it++)
    {
        Sprite *s = *it;
        assert(s != NULL);

        if (s->currentPixmapIndex > 1)
        {
            fprintf(stderr, "s->currentPixmapIndex = %lu\n", (unsigned long) s->currentPixmapIndex);
            assert(false);
        }
        if (s->decTimeToLive() == 0)
        {
            delete s;
            *it = NULL;
            continue;
        }

        s->addSpeedToPos();  // some explosions move

        s->currentPixmapIndex ^= 1;  // switch between 0 and 1
        assert(s->currentPixmapIndex <= 1);
    }
    removeNullElementsFromSpriteList(explosionSprites);
}


Sprite *
CosmoSmashEngine::createExplosionSprite(Couple posOfCenterOfExplosion,
                                                int timeToLive)
/*
    Creates an explosion sprite centered at 'posOfCenterOfExplosion'.
    Sets the "time to live" value for the new sprite to 'timeToLive',
    which must be expressed in ticks.
    Inserts the address of this sprite in the list 'explosionSprites'.
    The sprite has no speed.
    Returns a pointer to the created sprite.
*/
{
    Couple size = explosionPA.getImageSize();
    Couple pos = posOfCenterOfExplosion - size / 2;
    Sprite *s = new Sprite(explosionPA, pos,
                    Couple(0, 0), Couple(0, 0),
                    size / 4, size / 2);
    s->setTimeToLive(timeToLive);
    explosionSprites.push_back(s);
    return s;
}


pair<Sprite *, Sprite *>
CosmoSmashEngine::splitBigRock(const Sprite &bigRock) const
/*
    Returns two new rock sprites which have not been inserted in
    any sprite list.
*/
{
    const Couple bigRockPos = bigRock.getPos();
    const Couple bigRockSize = bigRock.getSize();

    const Couple smallRockSize = smallRockPA.getImageSize();
    int smallRockY = bigRockPos.y + bigRockSize.y / 2 - smallRockSize.y / 2;
    Couple pos1(bigRockPos.x + bigRockSize.x * 1 / 4, smallRockY);
    Couple pos2(bigRockPos.x + bigRockSize.x * 3 / 4, smallRockY);
    pos2.x -= smallRockSize.x;

    Couple speed1(rnd(-4, -2), bigRock.getSpeed().y);  // must go to the left
    Couple speed2(- speed1.x, speed1.y);  // must go to the right

    // Rotate the speeds of the small rocks some times:
    int dir = rand() % 3;
    for (int times = rand() % 2 + 1; times > 0; times--)
        switch (dir)
        {
            case 0:
                speed1.x--;
                speed2.y++;
                break;
            case 1:
                speed2.x++;
                speed1.y++;
                break;
            default:
                ;
        }

    speed1 = accelerate(speed1);
    speed2 = accelerate(speed2);
    Sprite *smallRock1 = new Sprite(smallRockPA,
                            pos1, speed1, Couple(0, 0), Couple(2, 2),
                            smallRockSize - Couple(2, 2));
    smallRock1->currentPixmapIndex = bigRock.currentPixmapIndex;
    Sprite *smallRock2 = new Sprite(smallRockPA,
                            pos2, speed2, Couple(0, 0), Couple(2, 2),
                            smallRockSize - Couple(2, 2));
    smallRock2->currentPixmapIndex = bigRock.currentPixmapIndex;

    //rockSprites.push_back(smallRock1);
    //rockSprites.push_back(smallRock2);
        /*  We do not insert the two new sprites in the rockSprites list
            right now because this method is called during an iteration
            over that list.  Insertions in the list at this point could
            reallocate the internal data structure and thus disrupt
            the iteration. That is why we return a pair of newly
            created sprites which the caller can insert in the list
            when appropriate.
        */
    return pair<Sprite *, Sprite *>(smallRock1, smallRock2);
}


void
CosmoSmashEngine::makeSpriteExplode(const Sprite *target,
                                    const Sprite *bullet,
                                    long points)
/*
    Makes the 'target' sprite explode.
    'bullet' must be the sprite that triggers the explosion; it is erased
    from the screen.
    The target is erased from the screen and an explosion is started
    at its position.
    'points' is the number of points to add to the player's score.
    The object designated by 'target' is not destroyed.
    'target' and 'bullet' must not be null.
*/
{
    assert(target != NULL);
    assert(bullet != NULL);

    playShortExplosionSound();

    Couple targetPos = target->getPos();

    Couple expPos = target->getCenterPos();
    createExplosionSprite(expPos, 6);

    addToScore(points);
}


bool
CosmoSmashEngine::detectCollisionsWithBullet(const Sprite &bullet,
                                            SpriteList &slist,
                                            int scoreOnCollision)
/*
    Detects fatal collisions between a bullet and sprites in 'slist'.

    'slist' is allowed to contain null pointers; they are ignored.

    If a collision is detected between 'bullet' and an element
    of 'slist', this element is made null in 'slist' and the
    corresponding Sprite object is destroyed with operator delete;
    also, an explosion is created at the point of collision and the
    method returns true.

    The method returns false if no collision is detected.
*/
{
    bool collisionDetected = false;

    for (SpriteList::iterator its = slist.begin(); its != slist.end(); its++)
    {
        Sprite *aSprite = *its;
        if (aSprite == NULL)  // if already dead
            continue;

        if (bullet.collidesWithSprite(*aSprite))
        {
            makeSpriteExplode(aSprite, &bullet, scoreOnCollision);

            delete aSprite;
            *its = NULL;
            collisionDetected = true;
        }
    }

    return collisionDetected;
}


bool
CosmoSmashEngine::detectCollisionsWithExplosions()
/*
    Kills certain sprites if they touch an explosion sprite.
    Explosion sprites do not disappear because of a collision.
    Sprite lists containing killed sprites will contain null
    elements after this method finishes.  The caller is
    responsible for cleaning up those null elements.

    Returns true if the player dies, or false otherwise.
*/
{
    if (!playerIsActive())
        return false;

    /*  Make a local copy of the list of explosion sprites, and iterate
        on the copy.
        We cannot iterate over 'explosionSprites' because the calls
        to detectCollisionsWithBullet() will add elements to it;
        this could invalidate an iterator that would point into the list.

        This technique is not efficient in principle, but the number of
        explosions is normally low, so no visible performance hit should
        be observed.
    */
    SpriteList tempList(explosionSprites.size());
    copy(explosionSprites.begin(), explosionSprites.end(), tempList.begin());

    assert(tempList.size() == explosionSprites.size());

    SpriteList::const_iterator it;
    for (it = tempList.begin(); it != tempList.end(); it++)
    {
        const Sprite *anExplosion = *it;
        if (anExplosion == NULL)
            continue;

        // Consider the explosion sprite as a bullet:
        (void) detectCollisionsWithBullet(*anExplosion, rockSprites, 0);
        (void) detectCollisionsWithBullet(*anExplosion, spinnerSprites, 0);
        (void) detectCollisionsWithBullet(*anExplosion, pulsarSprites, 0);
        (void) detectCollisionsWithBullet(*anExplosion, saucerSprites, 0);
        (void) detectCollisionsWithBullet(*anExplosion, saucerBulletSprites, 0);

        #if 0  // this makes the explosions kill the base also.
        if (anExplosion->collidesWithSprite(*playerSprite))
        {
            killPlayerBase();  // this kills all meanies
            return true;       // no need to continue
        }
        #endif
    }

    return false;
}


void CosmoSmashEngine::detectCollisionsBetweenFallingObjects(SpriteList &slist)
/*
    Sprite lists containing killed sprites will contain null
    elements after this method finishes.  The caller is
    responsible for cleaning up those null elements.
*/
{
    SpriteList::iterator it;
    for (it = slist.begin(); it != slist.end(); it++)
    {
        const Sprite *s = *it;
        if (s == NULL)
            continue;

        bool coll = false;
        if (!coll)
            coll = detectCollisionsWithBullet(*s, rockSprites, 0);
        if (!coll)
            coll = detectCollisionsWithBullet(*s, saucerSprites, 0);
        if (!coll)
            coll = detectCollisionsWithBullet(*s, saucerBulletSprites, 0);
        if (coll)
        {
            *it = NULL;
            delete s;
        }
    }
}


void
CosmoSmashEngine::detectCollisions()
/*
    NOTE: Many collisions are detected here, but there are some others
    that are detected elsewhere, as in animateFallingObjects(), for example.
*/
{
    SpriteList newRocks;
    bool playerBoosted = false;

    /*  Detect collisions involving the player's bullets:
    */
    for (SpriteList::iterator itb = baseBulletSprites.begin();
                                    itb != baseBulletSprites.end(); itb++)
    {
        Sprite *bullet = *itb;
        assert(bullet != NULL);

        for (SpriteList::iterator itr = rockSprites.begin();
                                        itr != rockSprites.end(); itr++)
        {
            Sprite *rock = *itr;
            if (rock == NULL)  // if already dead
                continue;  // next rock

            assert(bullet != NULL);

            if (bullet->collidesWithSprite(*rock))
            {
                long points;
                bool explode = true;
                if (rock->getSize() == bigRockPA.getImageSize())
                {
                    points = SCORE_BIG_ROCK;

                    /*  Some big rocks break into two small rocks.
                    */
                    if (rand() % 3 == 0)
                    {
                        playShortExplosionSound();

                        pair<Sprite *, Sprite *> p = splitBigRock(*rock);
                        newRocks.push_back(p.first);
                        newRocks.push_back(p.second);


                        /*  We don't create an explosion when a big rock splits
                            because an explosion would instantly destroy the
                            two new small rocks.  @sarrazip 20010530
                        */
                        explode = false;
                    }
                }
                else
                    points = SCORE_SMALL_ROCK;

                if (explode)
                    makeSpriteExplode(rock, bullet, points);


                // don't destroy 'bullet' -- only mark it for deletion:
                *itb = NULL;
                delete rock;
                *itr = NULL;
                break;
            }
        }


        assert(bullet != NULL);  // must still be alive for next for()


        SpriteList::iterator its;
        for (its = spinnerSprites.begin(); its != spinnerSprites.end(); its++)
        {
            Sprite *spinner = *its;
            if (spinner == NULL)  // if already dead
                continue;  // next spinner

            assert(bullet != NULL);
            if (bullet->collidesWithSprite(*spinner))
            {
                long points;
                if (spinner->getSize() == bigSpinnerPA.getImageSize())
                    points = SCORE_BIG_SPINNER;
                else
                    points = SCORE_SMALL_SPINNER;

                makeSpriteExplode(spinner, bullet, points);

                // don't destroy 'bullet' -- only mark it for deletion:
                *itb = NULL;
                delete spinner;
                *its = NULL;
                break;
            }
        }


        assert(bullet != NULL);  // must still be alive for next for()


        if (detectCollisionsWithBullet(
                                *bullet, pulsarSprites, SCORE_PULSAR))
            *itb = NULL;  // this marks that the bullet hit something

        if (detectCollisionsWithBullet(
                                *bullet, saucerSprites, SCORE_SAUCER))
            *itb = NULL;

        if (detectCollisionsWithBullet(
                            *bullet, saucerBulletSprites, SCORE_SAUCER_BULLET))
            *itb = NULL;

        if (detectCollisionsWithBullet(
                            *bullet, questionSprites, SCORE_QUESTION))
        {
            *itb = NULL;
            playerBoosted = true;
        }

        if (*itb == NULL)  // if bullet hit something
            delete bullet;

    }   // for each bullet


    detectCollisionsBetweenFallingObjects(pulsarSprites);
    detectCollisionsBetweenFallingObjects(questionSprites);

    (void) detectCollisionsWithExplosions();

    removeNullElementsFromSpriteList(baseBulletSprites);
    removeNullElementsFromSpriteList(rockSprites);
    removeNullElementsFromSpriteList(spinnerSprites);
    removeNullElementsFromSpriteList(pulsarSprites);
    removeNullElementsFromSpriteList(saucerSprites);
    removeNullElementsFromSpriteList(saucerBulletSprites);
    removeNullElementsFromSpriteList(questionSprites);

    rockSprites.insert(rockSprites.end(), newRocks.begin(), newRocks.end());

    if (playerBoosted)
        boostPlayer();
}


void
CosmoSmashEngine::boostPlayer()
{
    playerBoostTicks = rnd(100, 150);

    switch (rnd(0, 1))
    {
        case 0: playerBoostType = TRIPLE_BULLETS; break;
        case 1: playerBoostType = CLOSER_BULLETS; break;
    }
}


///////////////////////////////////////////////////////////////////////////////


void
CosmoSmashEngine::restoreBackground()
{
    bool baseExploding = (playerSprite->getTimeToLive() != 0);

    // Background:
    assert(theLevel >= 1 && theLevel <= NUM_LEVELS);
    Uint32 bgColor = (baseExploding ? explosionBGColor : levelColors[theLevel]);
    fillRect(0, 0, theDrawingPixmapSize.x, theDrawingPixmapSize.y, bgColor);

    // Ground:
    fillRect(0, groundPos, theDrawingPixmapSize.x, groundHeight, greenColor);

    // Stars:
    bool moveStars = (numLives > 0 && ! baseExploding && tickCount % 4 == 0);
    CoupleList::iterator it;
    for (it = starPositions.begin(); it != starPositions.end(); it++)
    {
        Couple &pos = *it;
        drawPixel(pos.x, pos.y, whiteColor);

        if (moveStars)
        {
            pos.y--;
            if (pos.y < 0)
                pos.y = mountainTopPos - 1;
        }
    }

    // Mountain range:
    Couple previous(-1, -1);
    for (it = mountainRangePositions.begin(); it != mountainRangePositions.end(); it++)
    {
        if (previous.x != -1)  // do nothing the first time
            drawLine(previous.x, previous.y, (*it).x, (*it).y, greenColor);
        previous = Couple((*it).x, (*it).y);
    }
}


void
CosmoSmashEngine::drawSprites()
{
    if (playerIsActive())
    {
        int pixmapIndex = (playerBoostTicks > 0 ? ((tickCount & 4) != 0) : 0);
        copySpritePixmap(*playerSprite, pixmapIndex, playerSprite->getPos());
    }

    SpriteList::const_iterator it;
    for (it = rockSprites.begin(); it != rockSprites.end(); it++)
        copySpritePixmap(**it, (**it).currentPixmapIndex, (**it).getPos());

    if (useGameExtensions)
        for (it = questionSprites.begin(); it != questionSprites.end(); it++)
        {
            size_t &index = (**it).currentPixmapIndex;
            index = (tickCount / 8) % 2;
            copySpritePixmap(**it, index, (**it).getPos());
        }

    for (it = spinnerSprites.begin(); it != spinnerSprites.end(); it++)
    {
        size_t &index = (**it).currentPixmapIndex;
        index = (tickCount / 4) % NUM_SPINNER_IMAGES;
        copySpritePixmap(**it, index, (**it).getPos());
    }

    if (!pulsarSprites.empty() && tickCount % (NUM_PULSAR_IMAGES * 4) == 0)
        playSoundEffect(pulsarBeepSound);
    for (it = pulsarSprites.begin(); it != pulsarSprites.end(); it++)
    {
        size_t &index = (**it).currentPixmapIndex;
        index = (tickCount / 2) % NUM_PULSAR_IMAGES;
        copySpritePixmap(**it, index, (**it).getPos());
    }

    for (it = saucerSprites.begin(); it != saucerSprites.end(); it++)
    {
        size_t &index = (**it).currentPixmapIndex;
        index = (tickCount / 4) % NUM_SAUCER_IMAGES;
        copySpritePixmap(**it, index, (**it).getPos());
    }

    for (it = saucerBulletSprites.begin(); it != saucerBulletSprites.end(); it++)
    {
        size_t &index = (**it).currentPixmapIndex;
        index = (tickCount / 2) % NUM_SAUCER_BULLET_IMAGES;
        copySpritePixmap(**it, index, (**it).getPos());
    }

    for (it = baseBulletSprites.begin(); it != baseBulletSprites.end(); it++)
        copySpritePixmap(**it, 0, (**it).getPos());

    for (it = explosionSprites.begin(); it != explosionSprites.end(); it++)
    {
        assert(*it != NULL);
        assert((**it).currentPixmapIndex <= 1);
        copySpritePixmap(**it, (**it).currentPixmapIndex, (**it).getPos());
    }

    {
        int ext = (useGameExtensions ? '*' : ' ');
        char s[64];
        snprintf(s, sizeof(s), " Score      :%8ld%c", theScore, ext);
        writeString(s, scoreAreaPos);
        snprintf(s, sizeof(s), " Peak Score :%8ld%c", thePeakScore, ext);
        writeString(s, peakScoreAreaPos);
    }

    {
        char s[64];
        snprintf(s, sizeof(s), " Level:%3d ", theLevel);
        writeString(s, levelNumAreaPos);
        snprintf(s, sizeof(s), " Lives:%3d ", numLives);
        writeString(s, numLivesAreaPos);
        updateNumLives = false;
    }
}


void
CosmoSmashEngine::addToScore(long n)
{
    theScore += n * theLevel;
    if (theScore > thePeakScore)
    {
        /*  Maintain the peak score. Give the player a new life each time
            the peak score crosses some boundary.
        */
        const long newLifeScoreInterval =
                (useGameExtensions ? 10000 : 1000);
        long before = thePeakScore / newLifeScoreInterval;
        thePeakScore = theScore;
        long after = thePeakScore / newLifeScoreInterval;
        if (before != after)
            addToNumLives(+1);
    }
    theLevel = getLevelNum(theScore);
}


void
CosmoSmashEngine::addToNumLives(int n)
{
    numLives += n;
    updateNumLives = true;
}


Couple
CosmoSmashEngine::accelerate(Couple speed) const
{
    int coef = (theScore >= 100000 ? theScore - 100000 : 0) / 25000 + 1;
    if (speed.x < 0)
        speed.x -= coef;
    else if (speed.x > 0)
        speed.x += coef;
    if (speed.y < 0)
        speed.y -= coef;
    else if (speed.y > 0)
        speed.y += coef;
    return speed;
}


void
CosmoSmashEngine::displayPauseMessage()
{
    displayMessage(10, "PAUSED -- press P to resume");
}


void
CosmoSmashEngine::displayStartMessage(bool display)
/*
    Displays the start message if 'display' is true, or erases the
    corresponding region if 'display' is false.
*/
{
    if (display)
    {
        int lineNum = 0;
        displayMessage(lineNum++, "Cosmosmash " VERSION " - by Pierre Sarrazin  ");
        displayMessage(lineNum++, "                                       ");
        displayMessage(lineNum++, "Press SPACE to start a standard game   ");
        displayMessage(lineNum++, "Press E to start a game with extensions");
        displayMessage(lineNum++, "                                       ");
        displayMessage(lineNum++, "Move:               left/right arrows  ");
        displayMessage(lineNum++, "Hyperspace:         down arrow         ");
        displayMessage(lineNum++, "Pause:              P                  ");
        displayMessage(lineNum++, "Toggle Full Screen: F11                ");

        if (useSound && theSoundMixer == NULL)
        {
            lineNum++;
            lineNum++;
            displayMessage(lineNum++, "*** Sound device not available ***     ");
        }
    }
}


void
CosmoSmashEngine::displayMessage(int row, const char *msg)
{
    const Couple fontdim = getFontDimensions();

    const size_t len = strlen(msg);
    int x = (theScreenSizeInPixels.x - len * fontdim.x) / 2;
    int y = theScreenSizeInPixels.y + (row - 26) * fontdim.y;

    writeString(msg, Couple(x, y));
}


void
CosmoSmashEngine::playShortExplosionSound()
{
    int soundNo = rand() % NUM_ROCK_HIT_SOUNDS;
    playSoundEffect(rockHitSounds[soundNo]);
}


void
CosmoSmashEngine::playSoundEffect(const roundbeetle::WaveFileBuffer &wfb)
{
    if (! playerIsActive() || theSoundMixer == NULL)
        return;

    roundbeetle::Bus &mainBus = theSoundMixer->getMainBus();
    int reqHandle = theSoundMixer->requestWaveFileSound(wfb, mainBus);
    if (reqHandle == -1)
        cout << PACKAGE ": failed to play sound " << &wfb << endl;
}


void
CosmoSmashEngine::registerCommand(Command command)
{
    if (gameScriptStream == NULL)
        return;

    *gameScriptStream << static_cast<int>(command) << ' ';
}


void
CosmoSmashEngine::registerTickEnd()
{
    if (gameScriptStream == NULL)
        return;

    *gameScriptStream << '\n';
}


void
CosmoSmashEngine::playCadenceSound()
{
    if (! playerIsActive() || theSoundMixer == NULL)
        return;

    if (timeBeforeNextCadenceSound > 0)
    {
        --timeBeforeNextCadenceSound;
        return;
    }

    // Compute a period in seconds between cadence sounds.
    // The cadence accelerates with the score.
    // The cadence period has a minimum.
    //
    const double startPeriod = 0.750;  // period in seconds when score is 0
    const double endPeriod   = 0.300;  // period in seconds when score is scoreOfFastestPeriod
    const long scoreOfFastestPeriod = 50000;
    double t = double(theScore) / scoreOfFastestPeriod;
    t = std::max(t, 0.0);
    t = std::min(t, 1.0);
    double cadenceInSeconds = startPeriod + t * (endPeriod - startPeriod);

    timeBeforeNextCadenceSound = (unsigned long) (cadenceInSeconds * 20);
    /*cout << theScore << " -> " << cadenceInSeconds << " s, "
         << timeBeforeNextCadenceSound << " ticks" << endl;*/

    // Play a white noise with decay and release time that fit
    // the computed cadence period.
    //
    float decayTime = cadenceInSeconds * .267f;
    float releaseTime = cadenceInSeconds * .4f;
    roundbeetle::ADSR adsr(.25f, .15f, .0f, decayTime, .0f, releaseTime);
    /*int req =*/ theSoundMixer->requestWhiteNoise(adsr, 1, theSoundMixer->getMainBus());
    //if (req == -1)
    //    cout << PACKAGE ": failed to play cadence sound" << endl;
}