laPlayer.cpp

/*

Jump'n'Run Engine
http://www.atanaslaskov.com/jnr/

BSD LICENSE
Copyright (c) 2007-2013, Atanas Laskov
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL ATANAS LASKOV BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

//
// FILE: laPlayer.cpp
//
// Playable character class
//
// Copyright (C) 2007-2013 Atanas Laskov, <latanas@gmail.com>
//
#include "stdafx.h"
#include "Core-Level-JR.h"

#include "AI\ai.h"
#include "AI\aiNPCDialog.h"

// Constructor
//
laPlayer::laPlayer(rpgSheet* pSheet):
    laFightingCreature( pSheet ? pSheet : new rpgSheet_PlayableChar() ),
    _uiInventoryWindow( &( ((rpgSheet_PlayableChar*)getSheet())->properties()->items ) /*&_inventory*/ ),
    _uiPotionsWindow( &( ((rpgSheet_PlayableChar*)getSheet())->properties()->potions ) )
{
    _uiPotionsWindow.toggleHorizontal(M_FALSE);
    _uiPotionsWindow.toggleSelection(M_FALSE);

    _ttTurn.parameters(0.2);

    // Battle zoom mode
    //
    laSettings* ps = laSystemIntegrator::getSettings();
    enableBattleZoom(ps->gp_enable_battle_zoom);
    _bBattleMode = M_TRUE;

    getLevelObject()->zoom(1.8);

    _ttBattleStance.parameters(1, 1, M_FALSE);
    _ttBattleStance.force();

    _ptPivot.size.y( M_UNIT );

    //Initialize time triggers
    //
    _ttAttack.parameters(M_PLAYER_ATTACK_INTERVAL);
    _ttAttack.enable(M_FALSE);

    shutterDeath.parameters( laColor(), 2);
    shutterHit.parameters( laColor(200,0,0,100), 0.5, M_FALSE, M_TRUE);

    // Misc
    fxMessages.parameters(2.5*M_UNIT, 2, M_UNIT*0.22);  // slightly bigger messages for the player
    _pActiveTrap = NULL;

    _pNPCDialog = NULL;

    //_bPeacefulMode = M_FALSE;
    _ttPeacefulAction.parameters(1);
    _ttPeacefulAction.enable();
    _ttPeacefulAction.force();

    _nLastWeapon = 0;
    _pwPeace = NULL;
}

laPlayer::~laPlayer(void)
{
    delete _pwPeace;
}

// Respawn character
//
void laPlayer::respawn()
{
    ERRORLEVEL_BEGIN;

    _pSheet->bResetProperties = M_FALSE;    // reset only modifiers
    laFightingCreature::respawn();

    rpgSheet_PlayableChar *psh = ((rpgSheet_PlayableChar*)_pSheet);
    psh->properties()->nHP  = psh->properties()->nHP_Max;

    // Save curent state of the RPG sheet in the profile
    // NOTE: Important to save before laFightingCreature::respawn(), in order to keep XP
    //
    // TODO: load_inventory(), in order to restore to the start of level state, before saving
    this->getLevelObject()->forceSave();

    laSettings* ps = laSystemIntegrator::getSettings();
    enableBattleZoom(ps->gp_enable_battle_zoom);

    //Tweak pivot
    _ptPivot.x( _ptPivot.x() + M_UNIT/2 );

    // Add the "Peaceful" weapon
    // i.e. attacks disabled when this item is active
    //
    rpgInventory* pInv = & ( ((rpgSheet_PlayableChar*)getSheet())->properties()->items );
    pInv->add( _pwPeace );

    ERRORLEVEL_END;
}

void laPlayer::_load_profile(char* strName)
{
    ERRORLEVEL_BEGIN;
    if(strName[0] == '\0') return;  //NOTE: No profile, ignore the load;


    char strfile[64];
    sprintf(strfile, "save\\%s.profile", strName);
    laFileParser fp;

    if( fp.fileOpen(strfile) )
    {
        try{
            laPropertyList pl;
            fp.readObj(&pl, M_FALSE);

            _pSheet->load( pl.getChild("rpg-sheet") );
            //TODO: load inventory
            //TODO: load skills
        }
        catch(laError&) { MLOG("Defaulting to Level 1 RPG sheet for the player object."); };
    }

    // Else keep default RPG props loaded from the TS

    ERRORLEVEL_END;
}

void laPlayer::saveProfile(FILE* f)
{
    ERRORLEVEL_BEGIN;

    ((rpgSheet_PlayableChar*)_pSheet)->properties()->save(f);
    //TODO: Save inventory
    //TODO: Save skills

    ERRORLEVEL_END;
}


// Load from level file
//
void laPlayer::load(class laFileParser *fp)
{
    ERRORLEVEL_BEGIN;

    //laSettings* ps = laSystemIntegrator::getSettings();
    //enableBattleZoom(ps->gp_enable_battle_zoom);

    laFightingCreature::load(fp);
    _ptPivot.x( _ptPivot.x() + M_UNIT/2 );

    // Read property sheet form the save file
    //
    // TODO: fix this; Its part of saving/loading the level
    //
    _load_profile(laSystemIntegrator::getSettings()->load_player_name);
    /*_pSheet->reset();
    laFileParser fp_save("save/player.jrsv");
    fp_save.readObj(_pSheet, M_FALSE);*/

    // Initialzie GUI
    //
    _IndicatorHP.setColor(laColor(255,255,255));
    _IndicatorHP.setSize(512, 128);
    _IndicatorHP.setMaxValue( ((rpgSheet_PlayableChar*)_pSheet)->properties()->nHP_Max );
    _IndicatorHP.setTextures("gui\\HP_empty.png", "gui\\HP_full.png", 32, 512-360);

    _IndicatorXP.setColor(laColor(255,255,255));
    _IndicatorXP.setSize(512, 128);
    _IndicatorXP.setMaxValue( ((rpgSheet_PlayableChar*)_pSheet)->properties()->nXP_Next );
    _IndicatorXP.setTextures("gui\\XP_empty.png", "gui\\XP_full.png", 260, 512-444);

    // Load custom sounds for the player
    //
    _pDieSound = laSystemIntegrator::getSound()->soundCreate("sound\\die(hearth beath).mp3");
    _pLevelupSound = laSystemIntegrator::getSound()->soundCreate("sound\\_level_up(chant).wav");

    _pLandSound = laSystemIntegrator::getSound()->soundCreate("sound\\land(klick).WAV");
    _pCollectSound = laSystemIntegrator::getSound()->soundCreate("sound\\collect(sonar).mp3");

    _pAttackSound = laSystemIntegrator::getSound()->soundCreate("sound\\attack(sword).mp3");

    // Initialize level-up fx
    //
    laFileParser fx_fp("fx\\creature_levelup.fx");
    fxParticleSystem_params par;

    par.load(&fx_fp);
    _cbLevelUp.create(par);
    _cbLevelUp.enable(M_FALSE);

    // Initialize skill-up fx
    //
    laFileParser sk_fp("fx\\creature_skillup.fx");
    //fxParticleSystem_params par;

    par.load(&sk_fp);
    _cbSkillUp.create(par);
    _cbSkillUp.enable(M_FALSE);


    _outline.bTopmost = M_TRUE;
    //_outline.id = 0x10;

    // Add the "Peaceful" weapon
    // i.e. attacks disabled when this item is active
    //
    _pwPeace = new rpgWeapon();
    _pwPeace->load( getTS()->getElement("Peaceful")->getChild("weapon") );

    rpgInventory* pInv = & ( ((rpgSheet_PlayableChar*)getSheet())->properties()->items );
    pInv->add( _pwPeace );

    // Note: need to set this again for the player to work with ai (eg. as an auto-palyer)
    _ai.controllers(this, this, getLevelObject()->getGlobalPercepts() );

    ERRORLEVEL_END;
}

// Reflect trajectory (after touch damage is inflicted)
//
void  laPlayer::reflect(/*M_BOOL bAffectX*/ const laRect2 &rReference)
{
    if(!isAlive() ) return;
    if( isImmune() ) return;

    /*int sx = _nFaceDirection;
    int sy = M_SIGN(_ptPivot.velocity.y());

    if(bAffectX) _ptPivot.velocity[0] = - 0.5 * M_UNIT * M_PLAYER_SPEED * sx;
    _ptPivot.velocity[1] = - 0.8 * M_UNIT * M_PLAYER_JUMP * sy;*/
}

void laPlayer::attackInitiate(M_BOOL bQuick)
{
    if(!isControlEnabled()) return;

    if( isPeaceful() )
    {
        if( _ttPeacefulAction.isElapsed() )
            _ttPeacefulAction.reset();
    }
    else
    {
        laFightingCreature::attackInitiate(bQuick);
        //_ttBattleStance.reset();
    }
}

void laPlayer::hit( rpgAttack attack )
{
    ERRORLEVEL_BEGIN;

    // Potion-like effect, associated with the attack
    if( attack.spPotion && (!isImmune()) )
    {
        // Register animator in the potion
        //attack.spPotion.get()->pAnimatorObj = pAO;

        // Drink it
        // NOTE: forceCollect() collects the potion automatically,
        // otherwise it will exist in an "uncollected" state, which is not what we want
        //
        //collect( attack.spPotion.get() );

        if( ! attack.spPotion.get()->pAnimatorObj )
        {
            //MSG("new");
            // Unlkie potion collectables, the potion-like effects of an attack don't have a level obj
            // Bulid an object that will animate the potion
            //
            laCollectable * pAO = new laCollectable();
            unsigned nTS = getTS()->getElementIndex( attack.spPotion.get()->strName );
            //MSG( attack.spPotion.get()->strName );

            pAO->setTS( getTS() );
            pAO->setObject( nTS, getTS()->getElement( nTS) );
            pAO->setLevel( getLevelObject() );
            pAO->create( getPosition() + laPoint3(0, -M_UNIT), attack.spPotion.get() );
            pAO->forceCollect();

            attack.spPotion.get()->pAnimatorObj = pAO;
            nestedAdd( pAO );
        }
        else
        {
            //MSG("reuse");

            //delete pAO;   // There is already and AO for this type of potion

            // Strictly speaking, onIdentical() should not be called in this case
            // but for rpgPotion this is necessary, when the potion is added as part of an attack
            // (otherwise no way to notivy the laColelctable to reset)
            //
            //attack.spPotion->onIdentical();
            attack.spPotion.get()->pAnimatorObj->resetPotion();
            attack.spPotion.get()->pAnimatorObj->setPosition( getPosition() + laPoint3(0, -M_UNIT) );
        }
    }

    laFightingCreature::hit(attack);
    ERRORLEVEL_END;
}


// Draw geometry
//

void  laPlayer::_draw_positioned(laRenderer *r) {
    // Sommersault tweak: Compensate for the adjustment of the rotation pivot
    if( getState()==M_STATE_SOMERSAULT ) r->transTranslate( laPoint3(0, -0.8*M_UNIT, 0) );

    //Default _draw_positioned()
    laFightingCreature::_draw_positioned(r);
}

void  laPlayer::_draw_positioned_rotated(laRenderer *r) {
    ERRORLEVEL_BEGIN;

    // Sommersault tweak: Move rotation pivot up
    if( getState()==M_STATE_SOMERSAULT ) r->transTranslate( laPoint3(0, +0.8*M_UNIT, 0) );

    // Draw active weapon
    //
    rpgInventory* pInv = & ( ((rpgSheet_PlayableChar*)getSheet())->properties()->items );

    if( pInv->size() && (!isPeaceful()) )
    {
        rpgItem *pItem = pInv->activePtr();
        pItem->hook.sample( getStateModel() );

        r->transPush();
        //_offset_and_rotation(r, ptBasePos);           // Standard offset and rotation for the object
        if(_ttDeath.isEnabled()) _trans_deathfx(r);     // Death Fx rotation and offset, if active

        r->transTranslate(  pItem->hook.arPointSample[0] );
        r->transRotate( M_R2D(pItem->hook.angle)-180, pItem->hook.rotationAxis() );

        r->modeOutline( _outline );
        r->styleSet( _color /*w.pTSE->getColor("color")*/ );
        ((laElement*) (pItem->pTSE->getParent()) )->drawGeometry( r );

        r->transPop();
    }

    // Draw player geometry
    laFightingCreature::_draw_positioned_rotated(r);

    ERRORLEVEL_END;
}

// Draw visual FX
//
void  laPlayer::drawFx(laRenderer *r, laPoint3 ptBasePos)
{
    ERRORLEVEL_BEGIN;
    if(_pNPCDialog) _pNPCDialog->draw(r, ptBasePos);
    laFightingCreature::drawFx(r, ptBasePos);
    ERRORLEVEL_END;
}

void  laPlayer::_drawFx_positioned(laRenderer *r)
{
    _cbLevelUp.draw(r);
    _cbSkillUp.draw(r);

    laFightingCreature::_drawFx_positioned(r);
}

// Draw GUI associated with the player character
//
void laPlayer::drawInterface(laRenderer *r, laPoint3 ptBasePos)
{
    ERRORLEVEL_BEGIN;
    /*laSettings* ps = laSystemIntegrator::getSettings();
    double w = ps->graphics_resolution_w;
    double h = ps->graphics_resolution_h;*/

    _uiInventoryWindow.draw();
    _uiPotionsWindow.draw();

    shutterHit.draw(r, ptBasePos);
    _draw_status_ui(r, ptBasePos);

    if(_pNPCDialog)
        _pNPCDialog->drawGUI(r, ptBasePos);

    laFightingCreature::drawInterface(r, ptBasePos);
    shutterDeath.draw(r, ptBasePos);

    ERRORLEVEL_END;
}

// State-switch mechanics
//
unsigned laPlayer::_next_state( unsigned nCurrentState )
{
    // Battle stance
    //
    static int nOldFacing;

    if( (!_ttBattleStance.isElapsed()) && (nCurrentState==M_STATE_STAND))
        return M_STATE_BSTAND;

    if( M_ABS(_dMonsterDistance) < M_PLAYER_ATTACK_RANGE )
    {
        nOldFacing = getFaceDirection();
        setExplicitFacing(M_TRUE);
        setFaceDirection( M_SIGN(_dMonsterDistance) );
        if(getState()==M_STATE_WALK) return M_STATE_BWALK;
    }
    else if(isFacingExplict())
    {
        setFaceDirection(nOldFacing);
        setExplicitFacing(M_FALSE);
    }

    // Default state switch mechanics
    return laFightingCreature::_next_state( nCurrentState );
}

// Animate
//
void laPlayer::animate(laTimer &t)
{
    ERRORLEVEL_BEGIN;

    _uiInventoryWindow.reply();
    _uiPotionsWindow.reply();

    // Animation sub-routines
    //
    animate_DeathMode(t);
    //animate__level_up(t);
    animate_TrapDamage(t);
    animate_BattleZoom(t);
    animate_Attack(t);
    animate_Movement(t);

    // Animate various triggers and FX
    //
    _ttPeacefulAction.animate(t);
    _ttBattleStance.animate(t);
    _cbLevelUp.animate(t);
    _cbSkillUp.animate(t);

    shutterDeath.animate(t);
    shutterHit.animate(t);

    // Any nearby monster can set the battle flag;
    // Erase the previous state
    _bBattleMode = M_FALSE;
    _dMonsterDistance = 100 * M_UNIT;

    // Active NPC dialog
    if(_pNPCDialog) _pNPCDialog->animate(t);

    laFightingCreature::animate(t);

    // Move the inventory at every frane, because it resizes dynamically
    //
    _uiInventoryWindow.move( laPoint3( 25, -15 ), M_AL, M_AB);
    _uiPotionsWindow.move( laPoint3( -15, 25 ), M_AR, M_AT);

    ERRORLEVEL_END;
}

// Animate death mode
//
void laPlayer::animate_DeathMode(laTimer &t)
{
    // Hit effect
    //
    if(  isAlive() && (!_ttHitImmunity.isElapsed()) && (!shutterHit.isActive()) )
        shutterHit.activate();
    else if( _ttHitImmunity.isElapsed() && shutterHit.isActive() )
        shutterHit.activate(M_FALSE);

    // Respawn effect
    //
    if( ( !isAlive() ) && (!shutterDeath.isActive()) )  shutterDeath.activate();
    else if( isAlive() && shutterDeath.isActive() )     shutterDeath.activate(M_FALSE);

    // Respawn
    //
    if( !isAlive() )
    {
        move(0);
        _bBattleMode = M_TRUE;

        if( (!_ttDeath.isEnabled()) )
        {
            _ttDeath.reset();
            _ttDeath.enable(M_TRUE);
        }

        if( _ttDeath.isElapsed() )
            getLevelObject()->reset();
    }
    else if( _ttDeath.isElapsed() )
        _ttDeath.enable(M_FALSE);
}

// Animate Battle Zoom
//
void laPlayer::animate_BattleZoom(laTimer &t)
{
    if(_bEnableBattleZoom)
    {
        double current = getLevelObject()->zoom(),  target = 1;

        if(_bBattleMode){
            //Zoom in (quick)
            if( current < 1.499 )   target = current + 1.7*t.delta();
            else target = 1.50;     // NOTE: Small difference ensures no trembling
        }
        else{
            //Zoom out (slower)
            if( current > 1.001 )   target = current - 0.4*t.delta();
            else target = 1.0;
        }

        getLevelObject()->zoom( target );
    }
}

// Animate trap damage
//
void laPlayer::animate_TrapDamage(laTimer &t)
{
    if(!isAlive() ) return;

    if(_pActiveTrap)
    {
        _pActiveTrap->timer.animate(t);
        if(_pActiveTrap->timer.isElapsed()) _pActiveTrap = NULL;
    }
    else if(_ptPivot.pTrap)
    {
        _pActiveTrap = _ptPivot.pTrap;

        /*reflect(M_FALSE);*/
        hit( *_pActiveTrap );   //rpgAttack(M_ELEMENT_TOXIC, _pActiveTrap->nDamage)

        _pActiveTrap->timer.enable(M_TRUE);
        _pActiveTrap->timer.reset();
    }

    //Bottom of level trap
    if( (_ptPivot.y()>1.1*M_UNIT*M_SEGH) ) ((rpgSheet_Fighter*)_pSheet)->properties()->nHP = 0;
}

// Animate player attacks
//
void laPlayer::animate_Attack(laTimer &t)
{
}

// Animate movement
//
void laPlayer::animate_Movement(laTimer &t)
{
    static M_BOOL bOnGround=M_TRUE;

    // Detect if the player is on the ground;
    // Play a 'tud' sound when landing
    if( (_ptPivot.bOnGround) && (!bOnGround) )
    {
        _pLandSound->play();
    }

    bOnGround = _ptPivot.bOnGround;

    // Touch damage tweak; Invalidate any non-conforming movment along X,
    // when immunity expires
    //
    if( (! isImmune() ) && (_nMovementDirection != M_SIGN(_ptPivot.velocity.x())) )
    {
        _ptPivot.velocity.x(0);
    }
}

void laPlayer::_draw_status_ui(laRenderer *r, laPoint3 ptBasePos)
{
    ERRORLEVEL_BEGIN;
    //_nHP = getHP();
    _IndicatorHP.value( ((rpgSheet_Fighter*)_pSheet)->properties()->nHP) ;
    _IndicatorHP.draw(r, ptBasePos);

    _IndicatorXP.value( ((rpgSheet_PlayableChar*)_pSheet)->properties()->nXP );
    _IndicatorXP.draw(r, ptBasePos);

    r->font("deco")->ctlAlignH(M_AC);
    r->font("deco")->ctlSize(16);
    r->font("deco")->ctlAlignV(M_AT);

    r->styleSet(laColor(255,117,117,255));
    r->font("deco")->draw(ptBasePos+laPoint3(118, 86), "%d / %d",
        ((rpgSheet_Fighter*)_pSheet)->properties()->nHP, ((rpgSheet_Fighter*)_pSheet)->properties()->nHP_Max );

    //r->styleSet(laColor(193,180,44,255));
    //r->font("deco")->draw(ptBasePos+laPoint3(168, 86), "%d", (int)(_ModifierAttack*_nAttack));

    //r->styleSet(laColor(150,250,150,255));
    //r->font("deco")->draw(ptBasePos+laPoint3(214, 86), "%d", (int)(_ModifierDefence*_nDefence));

    ERRORLEVEL_END;
}

void laPlayer::_level_up()
{
    ERRORLEVEL_BEGIN;
    //Upgrade player properties
    //((rpgSheet_PlayableChar*)_pSheet)->_level_up();

    //Ajust indicators
    _IndicatorXP.setMaxValue( ((rpgSheet_PlayableChar*)_pSheet)->properties()->nXP_Next );
    _IndicatorHP.setMaxValue( ((rpgSheet_PlayableChar*)_pSheet)->properties()->nHP_Max );

    //Level up message timing
    fxMessages.add(1.2, laColor(255,0,255), "* Level %d *", (int)((rpgSheet_PlayableChar*)_pSheet)->properties()->nLevel);

    _pLevelupSound->play();

    _cbLevelUp.enable();
    _cbLevelUp.reset();

    ERRORLEVEL_END;
}

void laPlayer::heal( unsigned nHP )
{
    ERRORLEVEL_BEGIN;

    ((rpgSheet_PlayableChar*)_pSheet)->heal( nHP );

    _pCollectSound->play();
    fxMessages.add(1, laColor(255,0,0), "+%d HP", (int)nHP);

    ERRORLEVEL_END;
}

void laPlayer::collect(unsigned nXP )
{
    ERRORLEVEL_BEGIN;
    unsigned nLevel = ((rpgSheet_PlayableChar*)_pSheet)->properties()->nLevel;

    ((rpgSheet_PlayableChar*)_pSheet)->collect( nXP );

    if( nLevel < ((rpgSheet_PlayableChar*)_pSheet)->properties()->nLevel)
        _level_up();

    _pCollectSound->play();
    fxMessages.add(1, laColor(255,0,255), "%d Crystals", (int)nXP );

    ERRORLEVEL_END;
}

M_BOOL laPlayer::collect( rpgItem *item )
{
    ERRORLEVEL_BEGIN;
    rpgInventory* pInv = NULL;
    laColor color = laColor(255,255,0);

    if( !strcmp(item->name().c_str(), "rpgPotion") )
    {
        // Put potion in the potions inventory
        pInv = & ( ((rpgSheet_PlayableChar*)getSheet())->properties()->potions );
        color = ((rpgPotion*) item)->color;
    }
    else
    {
        // Other itmes in the normal inventory
        pInv = & ( ((rpgSheet_PlayableChar*)getSheet())->properties()->items );
    }

    _pCollectSound->play();
    fxMessages.add(1, color, "%s", item->strName);

    M_BOOL nNewEntry = pInv->add( item );

    if( strcmp(item->name().c_str(), "rpgPotion") )
        _uiInventoryWindow.select( pInv->size()-1 );

    return nNewEntry;
    ERRORLEVEL_END;
}

void laPlayer::skillUp( unsigned nSkill )
{
    ERRORLEVEL_BEGIN;
    rpgSkillsInventory* psi = &(((rpgSheet_PlayableChar*)( getSheet() ))->properties()->skills);

    if( psi->skill(nSkill)->getCurrentIndex() + 1 < psi->skill(nSkill)->getUpgradeCount() )
    {
        psi->skill(nSkill)->upgrade();

        fxMessages.add(1, laColor(255,255,0), "Skill Acquired");
        _cbSkillUp.reset();
        _cbSkillUp.enable();
    }
    else
    {
        // TODO: play sound
        // fxMessages.add(1, laColor(255,255,0), "Max reached");
    }

    ERRORLEVEL_END;
}