laFightingCreature.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: laFightingCreature.cpp
//
// Copyright (C) 2007-2013 Atanas Laskov, <latanas@gmail.com>
//
#include "stdafx.h"
#include "Core-Level-JR.h"

// Constructor
//
laFightingCreature::laFightingCreature(rpgSheet* pSheet):
    laMovingCreature( pSheet ? pSheet : new rpgSheet_Fighter() )
{
    // Initial state
    //
    _bAttack = _bAttack_Quick = M_FALSE;
    _nSelectedAttack = 0;

    _ttDeath.parameters(M_DEATHFX_DURATION);    // time to play the death anim
    _ttDeath.reset();
    _ttDeath.enable(M_FALSE);

    _ttHitImmunity.parameters(0.5);             // imunity after an attack is initated
    _ttHitImmunity.enable();
    _ttHitImmunity.force();

    // No sounds by defaults
    //
    _pAttackSound = NULL;
    _pSufferSound = NULL;
    _pDieSound = NULL;

    // Load blood fx
    //
    laFileParser fxp;
    char strFilePath[128]=M_DIR_FX;
    fxParticleSystem_params param;

    sprintf(strFilePath, "%s%s", M_DIR_FX, "creature_blood.fx");
    fxp.fileOpen(strFilePath);
    fxp.readObj(&param, M_FALSE);
    fxp.fileClose();

    _fxBlood.create(param);
    _fxBlood.enable(M_TRUE);
    _fxBlood.enableGeneration(M_TRUE);
    _fxBlood.ctlRewind();

}

laFightingCreature::~laFightingCreature(void)
{
}


// This method is part of the laLoadableObj interface
//
void  laFightingCreature::load(class laFileParser *fp)
{
    ERRORLEVEL_BEGIN;

    //Do the laStateObject loading
    laMovingCreature::load(fp);

    //Misc
    getObject()->getModel(M_STATE_DIE)->cycle(M_FALSE);

    //_ttAttackCharge.parameters( ((rpgSheet_Fighter*)_pSheet)->modAttack(0).dChargeTime );
    _ttAttackCharge.enable(M_FALSE);

    _ttAttack.parameters( getObject()->getModel(M_STATE_ATTACK)->duration() );
    _ttAttack.enable(M_FALSE);

    ERRORLEVEL_END;
}

// Respawn
//
void laFightingCreature::respawn()
{
    laMovingCreature::respawn();

    //Reset attack state
    //
    _bAttack = _bAttack_Quick = M_FALSE;

    _ttDeath.reset();
    _ttDeath.enable(M_FALSE);

    _color[3]= _outline.color[3]= 255;
}

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

    if( (!_ttAttackCharge.isEnabled()) /*&& (_ptPivot.bOnGround) /*&& (!_bJumping)*/ )
    {
        //_nSelectedAttack = nAttack;
        _bAttack_Quick = bQuick;

        //MSG("%lf", selectedAttack().dChargeTime );
        _ttAttackCharge.parameters( selectedAttack().dChargeTime );
        _ttAttackCharge.enable();
        _ttAttackCharge.reset();

        if(bQuick)
            if(!_bAttack_Quick) fxMessages.add(0.8, laColor(255,255,0), "Haste!");

        //Play sound
        //
        if(_pAttackSound) _pAttackSound->play();
    }
}

// Stop attack (e.g. in the case of a jump)
//
void laFightingCreature::attackStop()
{
    //if(_ttAttackCharge.isEnabled() || _ttAttack.isEnabled())
    {
        _bAttack = _bAttack_Quick = M_FALSE;

        _ttAttackCharge.reset();
        _ttAttackCharge.enable(M_FALSE);

        _ttAttack.reset();
        _ttAttack.enable(M_FALSE);
    }
}

// Hit another creature
//
void laFightingCreature::attack( unsigned nAttackIndex, laFightingCreature* pTarget ) {
    ASSERT(pTarget, "Nil target object");
    ASSERT(nAttackIndex < ((rpgSheet_Fighter*)_pSheet)->properties()->vAttacks.size(), "Attack %d not registered", nAttackIndex);

    pTarget->hit( ((rpgSheet_Fighter*)_pSheet)->modAttack( nAttackIndex ) );
}

// Another creature, or trap, hits me
//
// NOTE: This method disregards the AP modifier of the attacker,
// and therefore it is more suitable for attacks performed by traps
// or other object that don't have modifiers.
//
// Attacking monsters should use the attack() methods instead of the hit() method;
//
void laFightingCreature::hit(rpgAttack attack)
{
    //Check conditions
    //
    if( (!isAlive()) || isImmune() || getLevelObject()->isCompleted() ) return;

    // Hit
    //
    unsigned nDamage = ((rpgSheet_Fighter*)_pSheet)->hit( attack );

    // Perform actions after the hit
    //
    _hit_actions(nDamage);
}

// Actions to be performed when the creature is hit
//
void laFightingCreature::_hit_actions(unsigned nDamage)
{
    if( nDamage <=0 )
    {
        fxMessages.add(0.8, laColor(255,255,0), "Resist");
        //TODO: play miss sound
        return;
    }

    if( ! ((rpgSheet_Fighter*)_pSheet)->isAlive() )
    {
        //fxMessages.add(1.5, laColor(255,0,0), "x_x");

        if(_pDieSound)  _pDieSound->play();
        //_pObject->getModel(M_CREATURE_MDIE)->frameIndex(0);
    }
    else if(_pSufferSound) _pSufferSound->play();

    //Activate blood FX
    _fxBlood.reset();

    //Display HP change message
    fxMessages.add(1, laColor(255,0,0), "-%d", (int)nDamage);

    //Enable Hit Immunity
    _ttHitImmunity.reset();
    //_ttHitImmunity.enable(M_TRUE);
    //_bHitImmunity = M_TRUE;
}

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

    _ttAttackCharge.animate(t);
    _ttAttack.animate(t);

    _ttHitImmunity.animate(t);
    _ttDeath.animate(t);

    // Animate attacks
    _animate_attacks();

    //Animate blood FX
    //
    //_fxBlood.position( _ptPivot );
    _fxBlood.animate(t);

    // Default animation
    //
    laMovingCreature::animate(t);
    ERRORLEVEL_END;
}

void laFightingCreature::_animate_attacks()
{
    // Hit immunity trigger
    //
    //if(_ttHitImmunity.isElapsed()) _bHitImmunity = M_FALSE;

    //Reset attacks
    //
    if( _ttAttackCharge.isElapsed() && (!_bAttack) )
    {
        _bAttack = M_TRUE;
        _ttAttack.enable();
        _ttAttack.reset();

        if(_bAttack_Quick)
        {
            getObject()->getModel(M_STATE_QATTACK)->frameIndex(0);
            getObject()->getModel(M_STATE_QATTACK)->toggleTraceFx(M_TRUE);
        }
        else
            getObject()->getModel(M_STATE_ATTACK)->frameIndex(0);
    }

    if( _ttAttack.isElapsed() )
    {
        attackStop();
    }
}

unsigned laFightingCreature::_next_state( unsigned nCurrentState )
{
    // Death state
    //
    if( (!isAlive()) && (!_ttDeath.isEnabled()) )
    {
        _ttDeath.enable(M_TRUE);
        _ttDeath.reset();

        setBlendTime(0.2);
        return M_STATE_DIE;
    }

    // Attack state
    //
    else if(_bAttack)
    {
        setBlendTime(0.15);
        if(_bAttack_Quick)  return M_STATE_QATTACK;
        else                return M_STATE_ATTACK;
    }

    /*if( ((getOldState()==M_STATE_ATTACK) || (getOldState()==M_STATE_QATTACK))
        && (getState()!=M_STATE_ATTACK) && (getState()!=M_STATE_QATTACK) )
    {
        setBlendTime(0.2);
    }*/

    return laMovingCreature::_next_state( nCurrentState );
}


// Draw geometry
//
void laFightingCreature::_draw_positioned_rotated(laRenderer *r)
{
    // Death effect
    //
    if(_ttDeath.isEnabled())
    {
        r->transPush();
            _trans_deathfx(r);
            laStateObject::_draw_positioned_rotated(r);
        r->transPop();
    }
    else laMovingCreature::_draw_positioned_rotated(r);
}

// Apply death Fx rotation and offset, and style changes
//
void laFightingCreature::_trans_deathfx(laRenderer *r)
{
    _color[3]= _outline.color[3]= _ttDeath.reminder() * 250;
    r->styleSet(_color);
    r->modeOutline(_outline);

    if(_ptPivot.bOnGround) r->transTranslate(laPoint3(0, -1*_ttDeath.progress()*M_DEATHFX_OFFSET, 0));
    r->transRotate(_ttDeath.progress()*M_DEATHFX_ROTATION, laPoint3(0,1,0));
}

// Draw specific FX
//
void laFightingCreature::_drawFx_positioned(laRenderer *r)
{
    _fxBlood.draw(r);

    if(_ttDeath.isEnabled())
        _ptPivot.dShadowY = _ptPivot.y() + _ttDeath.progress()*M_DEATHFX_OFFSET;

    if(_ptPivot.y() < M_UNIT * (M_SEGH - 1))
        laMovingCreature::_drawFx_positioned(r);
}

/*void laFightingCreature::heal(unsigned hp)
{
    if ( ((rpgSheet_Fighter*)_pSheet)->heal(hp) )
    {
        fxMessages.add(1, laColor(255,0,0), "+%d", (int)hp);
    }
}*/