#ifndef __FIGTH_H__
#define __FIGTH_H__

#include "cocos-ext.h"
#include "include/ILayer.h"
#include "kernel/BaseDefine.h"

USING_NS_CC;
USING_NS_CC_EXT;

class CFigthLayer : public CBaseLayer
{
private:
    enum E_FIGHT
    {
        FIGHT_NIL            = 0,
        FIGHT_NORTH            = 4,    // 北
        FIGHT_NORTHEAST        = 5,    // 东北
        FIGHT_EAST            = 6,    // 东
        FIGHT_EASTSOUTH        = 7,    // 东南
        FIGHT_SOUTH            = 8,    // 南
        FIGHT_WESTSOUTH        = 1,    // 西南
        FIGHT_WEST            = 2,    // 西
        FIGHT_WESTNORTH        = 3,    // 西北

        FIGHT_ACTION        = 101,    // 标记动作
        FIGHT_IMG_RUN        = 102,
        FIGHT_RUNACTION        = 103,
    };

public:
    virtual bool Create();
    virtual void OnTick(){}
    virtual void onEnter();
    virtual void onEnterTransitionDidFinish();
    virtual void onExit();

    virtual void registerWithTouchDispatcher();
    virtual bool ccTouchBegan(CCTouch *pTouch, CCEvent *pEvent);
    virtual void ccTouchEnded(CCTouch *pTouch, CCEvent *pEvent);

private:
    void SetDir(float x, float y);
    void RunDirect(E_FIGHT eFight);
    void RunActionFight(int nImgStart, int nImgEnd);
private:
    CCPoint                m_tPosCurrent;        // 用于存放怪物的当前位置
    CCPoint                m_tPosEnd;            // 这两个用于判断
    CCAnimate*            m_pAction;            // 跑的动作 
    E_FIGHT                m_eFight;
    bool                m_bRun;
};

#endif // __FIGTH_H__

#include "FightLayer.h"
#include <math.h>

#include "kernel/GlobalMgr.h"
#include "kernel/UIMgr.h" 

bool CFigthLayer::Create()
{
    if (!CBaseLayer::Create())
        return false;

    m_eFight            = FIGHT_NIL;
    m_pAction            = NULL;
    m_bRun                = false;

    setTouchEnabled(true);
}

void CFigthLayer::onEnter()
{
    CBaseLayer::onEnter();
}

void CFigthLayer::onEnterTransitionDidFinish()
{
    CBaseLayer::onExitTransitionDidStart();

    std::string g_ImgPath(CGlobalMgr::GetInstance()->GetResourcesEx());
    std::string strPath;

    strPath = g_ImgPath + "rpg000.jpg";
    CCSprite* pImgBg = CCSprite::create(strPath.c_str());
    CC_ERROR(pImgBg, "【CFigthLayer::onEnterTransitionDidFinish】pImgBg为空")
    pImgBg->setPosition(ccp(320, 480));
    pImgBg->setAnchorPoint(ccp(0.5, 0.5));
    this->addChild(pImgBg);

    strPath = g_ImgPath + "image8.png";
    CCSprite* pImgRun = CCSprite::create(strPath.c_str());
    CC_ERROR(pImgRun, "【CFigthLayer::onEnterTransitionDidFinish】pImgRun为空")
    pImgRun->setPosition(ccp(320, 480));
    pImgRun->setAnchorPoint(ccp(0.5, 0.5));
    pImgRun->setTag(FIGHT_IMG_RUN);
    this->addChild(pImgRun);

    m_tPosCurrent = pImgBg->getPosition();
}

void CFigthLayer::onExit()
{
    CBaseLayer::onExit();
}

void CFigthLayer::registerWithTouchDispatcher()
{
    CCDirector::sharedDirector()->getTouchDispatcher()->addTargetedDelegate(this, 0, true);
}

bool CFigthLayer::ccTouchBegan(CCTouch *pTouch, CCEvent *pEvent)
{
    return true;
}

void CFigthLayer::ccTouchEnded(CCTouch *pTouch, CCEvent *pEvent)
{
    m_tPosEnd = pTouch->getLocation();
    this->SetDir(m_tPosEnd.x, m_tPosEnd.y);
}

void CFigthLayer::SetDir(float x, float y)
{
    CCPoint pos = m_tPosCurrent;
    if (pos.equals(ccp(x, y)))
        return;

    if (x > pos.x)
    {
        float t = (y - pos.y) / (x - pos.x);

        if (t > tan(- M_PI_4 / 2) && t <= tan(M_PI_4 / 2))
        {
            m_eFight = (E_FIGHT)2;
        }
        else if (t > tan(M_PI_4 - M_PI_4 / 2) && t <= tan(M_PI_4 + M_PI_4 / 2))
        {
            m_eFight = (E_FIGHT)3;
        }
        else if (t > tan(M_PI_4 + M_PI_4 / 2))
        {
            m_eFight = (E_FIGHT)4;
        }
        else if (t > tan(- M_PI_4 - M_PI_4 / 2) && t <= tan(- M_PI_4 + M_PI_4 / 2))
        {
            m_eFight = (E_FIGHT)1;
        }
        else if (t <= tan(- M_PI_4 - M_PI_4 / 2))
        {
            m_eFight = (E_FIGHT)8;
        }
    }
    else if (x < pos.x)
    {
        float t = (y - pos.y) / (x - pos.x);

        if (t > tan(M_PI - M_PI_4 / 2) && t <= tan(M_PI + M_PI_4 / 2))
        {
            m_eFight = (E_FIGHT)6;
        }
        else if (t > tan(M_PI - M_PI_4 - M_PI_4 / 2) && t <= tan(M_PI - M_PI_4 + M_PI_4 / 2))
        {
            m_eFight = (E_FIGHT)5;
        }
        else if (t <= tan(M_PI - M_PI_4 - M_PI_4 / 2))
        {
            m_eFight = (E_FIGHT)4;
        }
        else if (t > tan(M_PI + M_PI_4 - M_PI_4 / 2) && t <= tan(M_PI + M_PI_4 + M_PI_4 / 2))
        {
            m_eFight = (E_FIGHT)7;
        }
        else if (t > tan(M_PI + M_PI_4 + M_PI_4 / 2))
        {
            m_eFight = (E_FIGHT)8;
        }
    }
    this->RunDirect(m_eFight);
}

void CFigthLayer::RunDirect(E_FIGHT eFight)
{
    switch (eFight)
    {
    case CFigthLayer::FIGHT_NORTH:
        {
            this->RunActionFight(25, 28);
        }
        break;
    case CFigthLayer::FIGHT_NORTHEAST:
        {
            this->RunActionFight(21, 24);
        }
        break;
    case CFigthLayer::FIGHT_EAST:
        {
            this->RunActionFight(16, 20);
        }
        break;
    case CFigthLayer::FIGHT_EASTSOUTH:
        {
            this->RunActionFight(12, 15);
        }
        break;
    case CFigthLayer::FIGHT_SOUTH:
        {
            this->RunActionFight(8, 11);
        }
        break;
    case CFigthLayer::FIGHT_WESTSOUTH:
        {
            this->RunActionFight(74, 77);
        }
        break;
    case CFigthLayer::FIGHT_WEST:
        {
            this->RunActionFight(12, 15);
        }
        break;
    case CFigthLayer::FIGHT_WESTNORTH:
        {
            this->RunActionFight(12, 15);
        }
        break;
    default:
        break;
    }
}

void CFigthLayer::RunActionFight(int nImgStart, int nImgEnd)
{
    std::string g_ImgPath(CGlobalMgr::GetInstance()->GetResourcesEx());
    std::string strPath;

    CCSprite* pImgRun = (CCSprite*)this->getChildByTag(FIGHT_IMG_RUN);
    CC_ERROR(pImgRun, "【CFigthLayer::RunActionFight】pImgRun为空")
    pImgRun->stopAllActions();
    CCActionManager* pActionManager = CCDirector::sharedDirector()->getActionManager();
    CC_ERROR(pActionManager, "【CFigthLayer::RunActionFight】pActionManager为空")
    if (m_bRun == true)
    {
        pActionManager->removeActionByTag(FIGHT_ACTION, m_pAction);
    }

    m_bRun = true;

    CCAnimation* pAnimation = CCAnimation::create();
    CC_ERROR(pAnimation, "【CFigthLayer::RunActionFight】pAnimation为空")
    for( int i = nImgStart; i < nImgEnd + 1; i++)
    {
        CCString* pStrPath = CCString::createWithFormat("%simage%d.png", g_ImgPath.c_str(), i);
        CC_ERROR(pStrPath, "【CFigthLayer::RunActionFight】pStrPath为空")
        pAnimation->addSpriteFrameWithFileName(pStrPath->getCString());
    }
    pAnimation->setDelayPerUnit(0.4f);
    pAnimation->setRestoreOriginalFrame(true);
    m_pAction = CCAnimate::create(pAnimation);
    m_pAction->setTag(FIGHT_ACTION);
    CC_ERROR(m_pAction, "【CFigthLayer::RunActionFight】m_pAction为空")
    pImgRun->runAction(CCRepeatForever::create(m_pAction));
}