FuelPoint.cpp

Go to the documentation of this file.

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------

#include "FuelPoint.h"

#include "ngl/Vector.h"

#include "GLWindow.h"

//----------------------------------------------------------------------------------------------------------------------
// ctor of point
FuelPoint::FuelPoint(
                    ngl::Vector _pointPosition,
                    int _pointStatus
                    )
{
    m_position = _pointPosition;

    if(_pointStatus==1)             // flammable point starts with 100 fuel power
    {
        // ----- flammable point
        m_isFlammable = true;
        m_isBurning = false;
        m_fuel = 100.0;
        // set initial colour to green, depends on the fuel amount
        float m_fuelColour = m_fuel/100;
        m_currentColour = ngl::Vector(0.0f,m_fuelColour,0.0f);

        m_moisture = 0.1;
        m_isMountainPoint = false;
        m_isOrigin = false;
    }
    else                            // non-flammable starts with no fuel
    {
        // ----- non-flammable point
        m_isFlammable = false;
        m_isBurning = false;
        m_fuel = 0.0;
        // set initial colour
        m_currentColour = ngl::Vector(0.0f,0.0f,1.0f);

        m_moisture = 0.8;
        m_isMountainPoint = false;
        m_isOrigin = false;
    }

    m_pointCircleSize = 1.0f;
    m_pointCircleHeight = 1.0f;
    m_isFuel = false;

    m_burningTimeAtThePoint = 10.0;

    m_emittedHeat = 0.0;

    m_generation = 0;

    m_gridIndex = 0;
    m_burningFormNumber = -10;   // negative 10 means it has not been burnt yet
    m_isBurningDown = false;
    m_draw = true;
}

//----------------------------------------------------------------------------------------------------------------------
bool FuelPoint::canDraw()
{
    return m_draw;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setDrawingFlag(bool _drawFlag)
{
    m_draw = _drawFlag;
}

//----------------------------------------------------------------------------------------------------------------------
bool FuelPoint::isBurningDown()
{
    return m_isBurningDown;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setToBeBurningDown()
{
    m_isBurningDown = true;
}

//----------------------------------------------------------------------------------------------------------------------
int FuelPoint::getBurningFormNumber()
{
    return m_burningFormNumber;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setBurningFormNumber(int _formNumber)
{
    m_burningFormNumber = _formNumber;
}

//----------------------------------------------------------------------------------------------------------------------
int FuelPoint::getGridIndex()
{
    return m_gridIndex;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setGridIndex(int _gridIndex)
{
    m_gridIndex = _gridIndex;
}

//----------------------------------------------------------------------------------------------------------------------
bool FuelPoint::isMointain()
{
    return m_isMountainPoint;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setGeneration(
                             int _generationNumber
                             )
{
    m_generation = _generationNumber;
}

//----------------------------------------------------------------------------------------------------------------------
int FuelPoint::getGeneration()
{
    return m_generation;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setToBeBigFuel(
                              float _fuelAmount
                              )
{
    m_fuel = _fuelAmount;
    m_isFuel = true;
}

//----------------------------------------------------------------------------------------------------------------------
bool FuelPoint::isFuel()
{
    return m_isFuel;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setToBeNonBigFuel()
{
    m_isFuel = false;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setBurningTime(
                              float _burningTime
                              )
{
    if(_burningTime<0)
        _burningTime = 1;
    else if(_burningTime>15)
        _burningTime = 15;

    m_burningTimeAtThePoint = _burningTime;
}

//----------------------------------------------------------------------------------------------------------------------
float FuelPoint::getBurningTime()
{
    return m_burningTimeAtThePoint;
}

//----------------------------------------------------------------------------------------------------------------------
float FuelPoint::getEmittedHeat()
{
    return m_emittedHeat;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setEmittedHeat(
                              float _heat
                              )
{
    m_emittedHeat = _heat;

    // set the colour along the heat
    m_currentColour = ngl::Vector(_heat/1000, (1000-_heat)/1000 , 0.0);

}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setToBeMountain(
                               float _circleSize,
                               float _circleHeight
                               )
{
    m_isMountainPoint = true;
    m_pointCircleSize = _circleSize;
    m_pointCircleHeight = _circleHeight;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setPosition(
                           ngl::Vector _newPosition
                           )
{
    m_position = _newPosition;
}

//----------------------------------------------------------------------------------------------------------------------
ngl::Vector& FuelPoint::getPosition()
{
    return m_position;
}

//----------------------------------------------------------------------------------------------------------------------
ngl::Vector& FuelPoint::getColour()
{
    return m_currentColour;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::changeColour(
                            ngl::Vector _assignedColour
                            )
{
    m_currentColour = _assignedColour;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::makeToBeNonflammable()
{
    m_isFlammable = false;
    m_fuel = 0.0;
    // set initial colour to blue
    m_currentColour = ngl::Vector(0.0f,0.0f,1.0f);

    m_moisture = 1.0;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::makeToBeflammable(
                                 float _fuel
                                 )
{
    m_isFlammable = true;
    m_fuel = _fuel;
    float m_fuelColour = m_fuel/100;
    // set initial colour to green, depends on the adding fuel
    m_currentColour = ngl::Vector(0.0f,m_fuelColour,0.0f);
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setFire()
{
    m_isBurning = true;
    float m_fuelColour = m_fuel/100;
    // set colour of the burning point to red, depends on fuel amount
    m_currentColour = ngl::Vector(m_fuelColour,0.0f,0.0f);
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setFuelAmount(
                             float _newFuel
                             )
{
    m_fuel = _newFuel;
    float m_fuelColour = m_fuel/100;
    // set colour of the burning point to red, depends on fuel amount
    m_currentColour = ngl::Vector(0.0f,m_fuelColour,0.0f);
}

//----------------------------------------------------------------------------------------------------------------------
// this function will change the colour if the point is in burning state
void FuelPoint::subtractFuel(
                            float _decreaseAmount
                            )
{
    if(m_fuel>0.0)
    {
        m_fuel = m_fuel-_decreaseAmount;

        //float m_fuelColour = m_fuel/100;
        // set colour of the burning point to red, depends on fuel amount
        //m_currentColour = ngl::Vector(m_fuelColour,0.0f,0.0f);
    }
    else
    {
        m_fuel = 0.0;
    }

}

//----------------------------------------------------------------------------------------------------------------------
bool FuelPoint::isFlammable()
{
    return m_isFlammable;
}

//----------------------------------------------------------------------------------------------------------------------
bool FuelPoint::isBurning()
{
    return m_isBurning;
}

//----------------------------------------------------------------------------------------------------------------------
float FuelPoint::getCurrentFuelValue()
{
    return m_fuel;
}

//----------------------------------------------------------------------------------------------------------------------
float FuelPoint::getMoisture()
{
    return m_moisture;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setNewMoisture(
                              float _moistureAmount
                              )
{
    m_moisture = _moistureAmount;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::decreaseMoisture(
                                float _decreasedAmount
                                )
{
    m_moisture -= _decreasedAmount;
}

//----------------------------------------------------------------------------------------------------------------------
float FuelPoint::getCircleHeight()
{
    return m_pointCircleHeight;
}

//----------------------------------------------------------------------------------------------------------------------
float FuelPoint::getCircleSize()
{
    return m_pointCircleSize;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setCircleHeight(
                               float m_circleHeight
                               )
{
    m_pointCircleHeight = m_circleHeight;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setToOrigin()
{
    m_isOrigin = true;
}

//----------------------------------------------------------------------------------------------------------------------
void FuelPoint::setToRegular()
{
    m_isOrigin = false;
}

//----------------------------------------------------------------------------------------------------------------------
bool FuelPoint::isOrigin()
{
    return m_isOrigin;
}