Advanced Demo

This is an advanced demo. More...

Collaboration diagram for Advanced Demo:

This is an advanced demo.

Similar to the basic demo, this details the basic scene header as well as a game object setup with all of the 'able' functions. Here is the beginning scene:

//TankScene.h
 
class Tank; // Forward declaration
class TerrainObject*
     
class TankScene : public Scene {
public:
    // We do not create objects at construction
    TankScene() = {};
    ~TankScene() = {};   
    
    // Create objects within initialization
    void Initialize() override;
    void SceneEnd() override;
    
private:
    // Our object
    Tank* tank; 
    
    // A pointer to a plane
    TerrainObject* terrain;
}

As well as the implementation file:

TankScene::Initialize() {
    pFrigate = new Frigate();
    pFrigate.setPosition(Vect(40, 10, 40)); // This can also be done at construction     
    
    // Assuming a terrain has been properly loaded in the asset manager
    pGlobTerrain = TerrainObjectManager::Get("Grass");
    TerrainManager::SetCurrentTerrain(pGlobTerrain); // Tell the terrain manager about our new terrain
    pGlobTerrain->Initialize(); // Setup the terrain for drawing
}
 
TankScene::SceneEnd() {
    delete pFrigate;
    BulletFactory::Terminate(); // singleton instance of bullets dynamically allocated with an object pool
    
    TerrainManager::DeinitializeCurrentTerrain(); // Tell the terrain manager to stop drawing
}

The header of the Frigate itself includes:

class Frigate : public GameObject {
public:
 
    // Big four
    Frigate();
    Frigate(const Frigate&) = delete;
    Frigate& operator=(const Frigate&) = delete;
    ~Frigate();
 
    // Alarmable overrides
    virtual void Alarm0() override;
    virtual void Alarm1() override;
    virtual void Alarm2() override;
    virtual void Alarm3() override;
 
    // Standard Update and Draw
    virtual void Update() override;
    virtual void Draw() override;
 
    // Inputable
    virtual void KeyPressed(AZUL_KEY k) override;
    virtual void KeyReleased(AZUL_KEY k) override;
 
    // Collidable
    virtual void Collision(Cottage*);
    virtual void Collision(Frigate*) { DebugMsg::out("Collision Frigate with Frigate\n"); }
 
    // Full TRS ship positioning
    Vect shipPos;     // T
    Matrix shipRot;   // R
    Matrix shipScale; // S
 
    // Translation and rotation speed
    const float shipTransSpeed = 1.0f;
    const float shipRotAngle = 0.05f;
    
    // Special camera controls
    Vect CamShipOffset;
    Vect CamLookAt;
 
private:
    // A texture-light graphics object
    GraphicsObject_TextureLight* pObjFT;
 
    Matrix WorldMat1;
 
    float angle;
};

The resulting implementation must define the overloaded functions and do something interesting with the position and activity of the model.

Frigate::Frigate() {
    // Light parameters and graphics object setup.
    Vect LightColor(1.50f, 1.50f, 1.50f, 1.0f);
    Vect LightPos(1.0f, 1.0f, 1.0f, 1.0f);
    pObjFT = new GraphicsObject_TextureLight(ModelManager::Get("Space_Frigate"), ShaderManager::Get("TextureFlatRender"), TextureManager::Get("Space_Frigate"), LightColor, LightPos);
 
    // TRS and World matrix setup
    shipScale.set(SCALE, 0.5f, 0.5f, 0.5f);
    shipRot.set(IDENTITY);
    shipPos.set(0, 20, 0);
    Matrix world = shipScale * shipRot * Matrix(TRANS, shipPos);
    pObjFT->SetWorld(world);
 
    // Submission of all 'able's for registration 
    Updatable::SubmitUpdateRegistration();
    Drawable::SubmitDrawRegistration();
    
    // Setting 3 different alarms with various time indexes
    Alarmable::SubmitAlarmRegistration(0, 1);
    Alarmable::SubmitAlarmRegistration(1, 2);
    Alarmable::SubmitAlarmRegistration(2, 3);
    Alarmable::SubmitAlarmRegistration(3, 4);
 
    // Submitting key registration for space (to fire bullets)
    Inputable::SubmitKeyRegistration(AZUL_KEY::KEY_SPACE, KEY_PRESS);
    Inputable::SubmitKeyRegistration(AZUL_KEY::KEY_END, KEY_RELEASE);
 
    // Setting a collider model for testing collision.
    Collidable::SetColliderModel(pObjFT->getModel(), VolumeType::OBB); // The collider model may be either a BSphere, AABB, or OBB.
    Collidable::SetCollidableGroup<Frigate>(); 
    Collidable::SubmitCollisionRegistration();
}

How these various 'able' functions are defined are going to vary wildly with each implementation of a game object. Below are a few common ways of implementing a couple of these functions.

void Frigate::Alarm0() {
    DebugMsg::out("Alarm0 called in Frigate, deregistering alarm 2\n"); // Lets the user know what alarm triggered
    Alarmable::SubmitAlarmDeregistration(2); // Deregisters a different alarm
}
 
void Frigate::KeyPressed(AZUL_KEY inputKey) {
    switch (inputKey) { // Begrudgingly switch on the input
    case AZUL_KEY::KEY_SPACE:
        //DebugMsg::out("<SPACE> HAS BEEN PRESSED\n");
        EnemyBulletFactory::CreateBullet(shipRot, shipPos); // Factory implementaiton! 
        break;
    default:
        DebugMsg::out("PROBLEM, Key %i was not meant to be processed", inputKey); // No key other than those registered should be present
    }
}
 
void Frigate::Collision(Cottage* theCottage) {
    UNREFERENCED_PARAMETER(theCottage); // Using only for type safety in this demo, though cottage work can be done.
    DebugMsg::out("Collision Frigate with Cottage\n"); 
    Visualizer::ShowBSphere(GetBSphere(), Color::Red); // Display a sphere on screen, be sure to checkout the visualizer tool.
}
 
void Frigate::Update() {
    if (Keyboard::GetKeyState(AZUL_KEY::KEY_W))
    {
        shipPos += Vect(0, 0, 1) * shipRot * shipTransSpeed;
    }
    else if (Keyboard::GetKeyState(AZUL_KEY::KEY_S))
    {
        shipPos += Vect(0, 0, 1) * shipRot * -shipTransSpeed;
    }
 
    // Ship Rotation movement (not using time-based values for simplicity)
    if (Keyboard::GetKeyState(AZUL_KEY::KEY_A))
    {
        shipRot *= Matrix(ROT_Y, shipRotAngle);
    }
    else if (Keyboard::GetKeyState(AZUL_KEY::KEY_D))
    {
        shipRot *= Matrix(ROT_Y, -shipRotAngle);
    }
 
    // Adjust Spaceship Matrix
    Matrix world = shipScale * shipRot * Matrix(TRANS, shipPos);
    pObjFT->SetWorld(world);
    this->UpdateCollisionData(world);
}
 
void Frigate::Draw() {
    pObjFT->Render(SceneManager::GetCurrentScene()->GetCamera());
}
 
Frigate::~Frigate() {
    delete pObjFT;
}