gameapplet.jc

JILRuntime A general purpose, register based virtual machine (VM) that supports object-oriented feat

//------------------------------------------------------------------------------
// File: GameApplet.jc
//------------------------------------------------------------------------------
//
// Description:
// ------------
//  Class definition for invaders game applet.
//------------------------------------------------------------------------------

class GameApplet : interface Applet
{
	// inherited from interface Applet
    method          GameApplet(Screen& screen);
    method			OnOpen();
    method			OnClose();
    method          OnClick(long button, long x, long y);
    method          OnKey(long key);
    method          Idle();

	// new methods
    method          BigExplosion(long x, long y);
    method          SmallExplosion(long x, long y);
    method          NewRedMissile(long x, long y, long deltaY);
    method          AddBonusShip();
    method          RemoveBonusShip();
    method          AlignBonusShips();
    method          SpawnEnemy(long x, long y);
    method          AddMoreEnemies();
    method          KillAll();
    method          OnInit();
    method          OnStart();
    method          OnContinue();
    method          OnTimeOut();
    method          OnNextLevel();
    method          OnGameOver();
    method          AddScore(long points);

	// data
    Screen&         m_Screen;
    array&          m_BigExplo;
    array&          m_SmallExplo;
    array&          m_RedMissiles;
    array&          m_Enemies;
    array&          m_Player;
    long            m_Level;
    long            m_NumBonus;
    long            m_RunMode;
    long            m_NextMode;
    long            m_Timer;
    long            m_Score;
    long			m_NumFire;
    TextLayer&      m_WinLayer;
    TextLayer&      m_LoseLayer;
    TextLayer&      m_BossAlert;
    TextLayer&      m_Message;
    TextLayer&      m_LevelDisplay;
    TextLayer&      m_ScoreDisplay;
    BitmapLayer&    m_Background;
}

//------------------------------------------------------------------------------
// class GameApplet
//------------------------------------------------------------------------------
// constructor

method GameApplet::GameApplet(Screen& screen)
{
    // store reference to screen for later...
    m_Screen = screen;

    // set fixed size
    screen.FixedSize( 640, 480 );

	// initialize all our members
    m_BigExplo = new array;
    m_SmallExplo = new array;
    m_RedMissiles = new array;
    m_Enemies = new array;
    m_Player = new array;
    m_Background = new BitmapLayer();
    m_WinLayer = new TextLayer();
    m_LoseLayer = new TextLayer();
    m_BossAlert = new TextLayer();
    m_Message = new TextLayer();
    m_LevelDisplay = new TextLayer();
    m_ScoreDisplay = new TextLayer();
    m_Level = 1;
    m_NumBonus = 0;
    m_RunMode = kModeInit;
    m_NextMode = kModeContinue;
    m_Timer = 0;
    m_Score = 0;
    m_NumFire = 0;
}

//------------------------------------------------------------------------------
// OnOpen
//------------------------------------------------------------------------------
// Called when the ScriptApp window is opened.

method GameApplet::OnOpen()
{
	// set up our layers
    m_Background.Bitmap( kBitmapList[kBmBackground] );
    m_Background.AutoSize();
    m_Background.Show();
    m_Screen.AddLayer( m_Background );

    m_WinLayer.Text( "YOU WIN!" );
    m_WinLayer.Font( 8 );
    m_WinLayer.SetColor( 60, 240, 60 );
    m_WinLayer.AutoSize();
    m_Screen.AddLayer( m_WinLayer );

    m_LoseLayer.Text( "GAME OVER!" );
    m_LoseLayer.Font( 8 );
    m_LoseLayer.SetColor( 240, 60, 60 );
    m_LoseLayer.AutoSize();
    m_Screen.AddLayer( m_LoseLayer );

    m_BossAlert.Text( "MOTHERSHIP ATTACK!" );
    m_BossAlert.Font( 8 );
    m_BossAlert.SetColor( 240, 60, 60 );
    m_BossAlert.AutoSize();
    m_Screen.AddLayer( m_BossAlert );

    m_Message.Font( 0 );
    m_Message.SetColor( 255, 255, 255 );
    m_Message.ResizeTo( 250, 110 );
    m_Screen.AddLayer( m_Message );

    m_LevelDisplay.Text( "Level 1" );
    m_LevelDisplay.Font( 6 );
    m_LevelDisplay.SetColor( 255, 255, 255 );
    m_LevelDisplay.AutoSize();
    m_LevelDisplay.Show();
    m_LevelDisplay.MoveTo(5,5);
    m_Screen.AddLayer( m_LevelDisplay );

    m_ScoreDisplay.Font( 6 );
    m_ScoreDisplay.SetColor( 255, 255, 255 );
    m_ScoreDisplay.Show();
    m_ScoreDisplay.MoveTo(520,5);
    m_Screen.AddLayer( m_ScoreDisplay );

    // init random generator
    stdlib::RandInit();
}

//------------------------------------------------------------------------------
// OnClose
//------------------------------------------------------------------------------
// Called when the ScriptApp window is closed.

method GameApplet::OnClose()
{
	long i;

	// unlink all layers
    for( i = 0; i < m_Player.length; i++ )
		m_Player[i].Player::Unlink( m_Screen );

    for( i = 0; i < m_Enemies.length; i++ )
		m_Enemies[i].Enemy::Unlink( m_Screen );

    for( i = 0; i < m_BigExplo.length; i++ )
        m_BigExplo[i].Explosion::Unlink( m_Screen );

    for( i = 0; i < m_SmallExplo.length; i++ )
        m_SmallExplo[i].Explosion::Unlink( m_Screen );

    for( i = 0; i < m_RedMissiles.length; i++ )
        m_RedMissiles[i].Missile::Unlink( m_Screen );
}

//------------------------------------------------------------------------------
// OnClick
//------------------------------------------------------------------------------
// Called when the user clicks with a mouse button

method GameApplet::OnClick(long button, long x, long y)
{
    if( m_RunMode == kModeContinue )
    {
		long bFire = false;
        for( long i = 0; i < m_Player.length; i++ )
        {
			if( m_Player[i].Player::Fire() )
			{
				m_NumFire++;
				bFire = true;
			}
        }
        if( bFire )
        {
			kSoundList[kSndBullet].Sound::Play(0, XToPan(x));
		}
    }
}

//------------------------------------------------------------------------------
// OnKey
//------------------------------------------------------------------------------
// Called when the user presses a key

method GameApplet::OnKey(long key)
{
    switch( key )
    {
        case kSpace:
            if( m_RunMode == kModeWait )
                m_RunMode = m_NextMode;
            break;
        case 27:
        	__brk;
        	break;
    }
}

//------------------------------------------------------------------------------
// Idle
//------------------------------------------------------------------------------
// Called in regular intervals when nothing else to do

method GameApplet::Idle()
{
    switch( m_RunMode )
    {
        case kModeInit:
            OnInit();
            break;
        case kModeStart:
            OnStart();
            break;
        case kModeContinue:
            OnContinue();
            break;
        case kModeTimeOut:
            OnTimeOut();
            break;
        case kModeNextLevel:
            OnNextLevel();
            break;
        case kModeGameOver:
            OnGameOver();
            break;
    }
    // redraw screen
    m_Screen.Redraw();
}

//------------------------------------------------------------------------------
// BigExplosion
//------------------------------------------------------------------------------
// Add a new big explosion

method GameApplet::BigExplosion(long x, long y)
{
    for( long i = 0; i < m_BigExplo.length; i++ )
    {
        if( not m_BigExplo[i].Explosion::m_Alive )
        {
            m_BigExplo[i].Explosion::Start(x, y);
            kSoundList[kSndExplo].Sound::Play(-600, XToPan(x));
            return;
        }
    }
    Explosion& exp = new Explosion(kBmExplo24, 24, 24, 125);
    exp.Start(x, y);
    m_BigExplo += exp;
    kSoundList[kSndExplo].Sound::Play(-600, XToPan(x));
}

//------------------------------------------------------------------------------
// SmallExplosion
//------------------------------------------------------------------------------
// Add a new small explosion

method GameApplet::SmallExplosion(long x, long y)
{
    for( long i = 0; i < m_SmallExplo.length; i++ )
    {
        if( not m_SmallExplo[i].Explosion::m_Alive )
        {
            m_SmallExplo[i].Explosion::Start(x, y);
			kSoundList[kSndExplo2].Sound::Play(-400, XToPan(x));
            return;
        }
    }
    Explosion& exp = new Explosion(kBmExplo16, 16, 16, 75);
    exp.Start(x, y);
    m_SmallExplo += exp;
    kSoundList[kSndExplo2].Sound::Play(-400, XToPan(x));
}

//------------------------------------------------------------------------------
// NewRedMissile
//------------------------------------------------------------------------------
// Add a new red missile

method GameApplet::NewRedMissile(long x, long y, long deltaY)
{
    for( long i = 0; i < m_RedMissiles.length; i++ )
    {
        if( not m_RedMissiles[i].Missile::m_Alive )
        {
            m_RedMissiles[i].Missile::Start(x, y, deltaY);
            return;
        }
    }
    Missile& missile = new Missile(kBmRedMissile, 15, 19 );
    missile.Start(x, y, deltaY);
    m_RedMissiles += missile;
}

//------------------------------------------------------------------------------
// AddBonusShip
//------------------------------------------------------------------------------
//

method GameApplet::AddBonusShip()
{
    if( m_NumBonus < 3 )
        m_NumBonus++;
    AlignBonusShips();
}

//------------------------------------------------------------------------------
// RemoveBonusShip
//------------------------------------------------------------------------------
//

method GameApplet::RemoveBonusShip()
{
    if( m_NumBonus )
    {
        m_NumBonus--;
    }
}

//------------------------------------------------------------------------------
// AlignBonusShips
//------------------------------------------------------------------------------
//

method GameApplet::AlignBonusShips()
{
    Player& player = m_Player[0];
    Player& bonus = m_Player[1];
    long playerWidth = player.m_Layer.Width();
    long playerHeight = player.m_Layer.Height();
    long bonusWidth = bonus.m_Layer.Width();
    long bonusHeight = bonus.m_Layer.Height();
    long allY = playerHeight + bonusHeight;
    long leftX = -bonusWidth;
    long centerX = (playerWidth - bonusWidth) / 2;
    long rightX = playerWidth - 4;
    for( long i = 1; i < m_Player.length; i++ )
    {
        m_Player[i].Player::m_Alive = false;
        m_Player[i].Player::m_Layer.Hide();
    }
    switch( m_NumBonus )
    {
        case 1:
            m_Player[1].Player::Start(centerX, allY);
            break;
        case 2:
            m_Player[1].Player::Start(leftX, allY);
            m_Player[2].Player::Start(rightX, allY);
            break;
        case 3:
            m_Player[1].Player::Start(leftX, allY);