attackenemy.jc

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

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

class AttackEnemy : interface Enemy
{
	// methods
    method          AttackEnemy(long shape);
    method          Start(long x, long y);
    method long     Move();
    method          Kill();
    method long     Alive();
    method long     Index();
    method long     Score();
    method			Link(Screen&);
    method          Unlink(Screen&);

	// data
    long            m_ShieldOn;
    long            m_Timer;
    long            m_Mode;
    long            m_X;
    long            m_Y;
    long            m_Alive;
    long            m_DestX;
    long            m_DestY;
    long            m_Score;
    long            m_Speed;
    BitmapLayer&    m_Layer;
    BitmapLayer&    m_Shield;
}

//------------------------------------------------------------------------------
// class AttackEnemy
//------------------------------------------------------------------------------
// constructor

method AttackEnemy::AttackEnemy(long bitmapID)
{
    m_ShieldOn = false;
    m_Mode = kAttIdle;
    m_Timer = 0;
    m_X = 0;
    m_Y = 0;
    m_DestX = 0;
    m_DestY = 0;
    m_Alive = false;
    m_Score = 500;
    m_Speed = 4;
    m_Layer = new BitmapLayer();
    m_Layer.GroupID( kGrpEnemy );
    m_Layer.Bitmap( kBitmapList[bitmapID] );
    m_Layer.AutoSize();
    m_Shield = new BitmapLayer();
    m_Shield.GroupID( kGrpShield );
    m_Shield.Bitmap( kBitmapList[kBmShield] );
    m_Shield.AutoSize();

    Link( g_Applet.GameApplet::m_Screen );
}

//------------------------------------------------------------------------------
// Start
//------------------------------------------------------------------------------
//

method AttackEnemy::Start(long x, long y)
{
    GameApplet& game = g_Applet;
    m_Mode = kAttIdle;
    m_Timer = stdlib::GetTicks() + kAttIdleTime + stdlib::Rand(0, kAttIdleTime);
    m_X = x;
    m_Y = y;
    m_DestX = x;
    m_DestY = y;
    m_Alive = true;
    m_ShieldOn = true;
    m_Layer.MoveTo( m_X, m_Y );
    m_Layer.Show();
    m_Shield.Show();
}

//------------------------------------------------------------------------------
// Move
//------------------------------------------------------------------------------
//

method long AttackEnemy::Move()
{
    if( m_Alive )
    {
        GameApplet& game = g_Applet;
        m_Layer.MoveTo( m_X, m_Y );
		m_Shield.MoveTo(
			m_X - (m_Shield.Width() - m_Layer.Width() + 3) / 2,
			m_Y - (m_Shield.Height() - m_Layer.Height() + 4) / 2 );

        long dx = (m_X - m_DestX) / m_Speed;
        if( dx < 0 )
            m_X += m_Speed;
        else if( dx > 0 )
            m_X -= m_Speed;
        long dy = (m_Y - m_DestY) / m_Speed;
        if( dy < 0 )
            m_Y += m_Speed;
        else if( dy > 0 )
            m_Y -= m_Speed;

        switch( m_Mode )
        {
            case kAttIdle:
                if( m_Timer < stdlib::GetTicks() )
                {
                    long x = m_X + (m_Layer.Width() - 15) / 2;
                    Player& player = game.m_Player[0];
                    m_DestX = player.m_X;
                    m_DestY = game.m_Screen.Height() * 2 / 3;
                    kSoundList[kSndSqueak].Sound::Play(0, XToPan(x));
                    m_Mode = kAttAttack;
                }
                else
                {
                    if( not m_ShieldOn )
                    {
                        m_ShieldOn = true;
                        m_Shield.Show();
                    }
                }
                break;
            case kAttAttack:
                if( not dx and not dy )
                {
                    long x = m_X + (m_Layer.Width() - 15) / 2;
                    long y = m_Y + m_Layer.Height();
                    game.NewRedMissile( x, y, kEnemyMissileSpeed );
                    kSoundList[kSndBullet].Sound::Play(0, XToPan(x));
                    x = game.m_Screen.Width() - m_Layer.Width();
                    y = game.m_Screen.Height() / 3;
                    m_DestX = stdlib::Rand(0, x);
                    m_DestY = stdlib::Rand(0, y);
                    m_ShieldOn = false;
                    m_Shield.Hide();
                    m_Mode = kAttFlee;
                }
                break;
            case kAttFlee:
                if( not dx and not dy )
                {
                    m_Mode = kAttIdle;
                    m_Timer = stdlib::GetTicks() + kAttIdleTime;
                }
                break;
        }
    }
    return m_Alive;
}

//------------------------------------------------------------------------------
// Kill
//------------------------------------------------------------------------------
//

method AttackEnemy::Kill()
{
    GameApplet& game = g_Applet;
    if( m_Alive and not m_ShieldOn )
    {
        m_Alive = false;
        m_Layer.Hide();
        m_Shield.Hide();
        game.BigExplosion(m_X + m_Layer.Width() / 2, m_Y + m_Layer.Height() / 2);
    }
}

//------------------------------------------------------------------------------
// Alive
//------------------------------------------------------------------------------
//

method long AttackEnemy::Alive()
{
	return m_Alive;
}

//------------------------------------------------------------------------------
// Index
//------------------------------------------------------------------------------
//

method long AttackEnemy::Index()
{
	return m_Layer.Index();
}

//------------------------------------------------------------------------------
// Score
//------------------------------------------------------------------------------
//

method long AttackEnemy::Score()
{
	return m_Score;
}

//------------------------------------------------------------------------------
// Link
//------------------------------------------------------------------------------
//

method AttackEnemy::Link(Screen& screen)
{
	m_Layer.User( this );
	m_Shield.User( this );
    screen.AddLayer( m_Layer );
    screen.AddLayer( m_Shield );
}

//------------------------------------------------------------------------------
// Unlink
//------------------------------------------------------------------------------
//

method AttackEnemy::Unlink(Screen& screen)
{
    m_Alive = false;
    screen.RemoveLayer( m_Layer );
    screen.RemoveLayer( m_Shield );
    m_Layer.User( null );
    m_Shield.User( null );
}