khanat-code-old/code/ryzom/client/src/attack_list.cpp

225 lines
7 KiB
C++

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
#include "attack_list.h"
#include "sheet_manager.h"
#include "global.h"
//
#include "client_sheets/attack_list_sheet.h"
//
#include "nel/3d/u_scene.h"
//
#include "nel/misc/sheet_id.h"
//
#include <utility>
H_AUTO_DECL(RZ_AttackList)
using namespace NLMISC;
using namespace std::rel_ops;
extern NL3D::UScene *Scene;
CAttackListManager *CAttackListManager::_Instance = NULL;
// get a .animation_fx sheet from its name (NULL if not found)
static CAnimationFXSetSheet *getAnimFXSetSheetFromName(const std::string &name)
{
CEntitySheet *sheet = SheetMngr.get(NLMISC::CSheetId(name));
if (!sheet) return NULL;
if (sheet->Type == CEntitySheet::ANIMATION_FX_SET) return static_cast<CAnimationFXSetSheet *>(sheet);
return NULL;
}
// build an attack part
static void buildAttackPart(const std::string &sheetName, CAnimationFXSet &fxSet, NL3D::UAnimationSet *as)
{
if (!sheetName.empty())
{
CAnimationFXSetSheet *sheet = getAnimFXSetSheetFromName(sheetName);
if (sheet)
{
fxSet.init(sheet, as);
}
else
{
nlwarning("Sheet %s not found", sheetName.c_str());
}
}
}
// ***********************************************************************************************
CAttack::CAttack()
{
Sheet = NULL;
}
// ***********************************************************************************************
void CAttack::init(const CAttackSheet *sheet, NL3D::UAnimationSet *as)
{
nlassert(!Sheet); // init already done
if (!sheet) return;
Sheet = sheet;
//
buildAttackPart(Sheet->AttackBeginFX, AttackBeginFX, as);
buildAttackPart(Sheet->AttackLoopFX, AttackLoopFX, as);
buildAttackPart(Sheet->AttackEndFX, AttackEndFX, as);
buildAttackPart(Sheet->AttackStaticObjectCastFX, AttackStaticObjectCastFX, as);
buildAttackPart(Sheet->AttackFailFX, AttackFailFX, as);
buildAttackPart(Sheet->ProjectileFX, ProjectileFX, as);
buildAttackPart(Sheet->ImpactFX, ImpactFX, as);
}
// ***********************************************************************************************
void CAttackList::init(const CAttackListSheet *attackList, NL3D::UAnimationSet *as)
{
nlassert(_Attacks.empty());
if (!attackList) return;
_Attacks.resize(attackList->Attacks.size());
for(uint k = 0; k < _Attacks.size(); ++k)
{
_Attacks[k].ID = &attackList->Attacks[k].ID;
_Attacks[k].Attack.init(&(attackList->Attacks[k].Attack), as);
}
// sort all attacks for fast retrieval
std::sort(_Attacks.begin(), _Attacks.end());
}
/*
struct CAttackEntryComp
{
bool operator()(const CAttackListEntry &lhs, const CAttackIDSheet &rhs) const
{
nlassert(lhs.ID);
return *lhs.ID < rhs;
}
};
*/
struct CAttackEntryComp2
{
bool operator()(const CAttackListEntry &lhs, const CAttackListEntry &rhs) const
{
nlassert(lhs.ID);
nlassert(rhs.ID);
return *lhs.ID < *rhs.ID;
}
};
// ***********************************************************************************************
const CAttack *CAttackList::getAttackFromID(const CAttackIDSheet &id) const
{
H_AUTO_USE(RZ_AttackList);
// vl: changed, this line only work with stlport
// std::vector<CAttackListEntry>::const_iterator it = std::lower_bound(_Attacks.begin(), _Attacks.end(), id, CAttackEntryComp());
CAttackListEntry ale(&id);
std::vector<CAttackListEntry>::const_iterator it = std::lower_bound(_Attacks.begin(), _Attacks.end(), ale, CAttackEntryComp2());
if (it == _Attacks.end()) return NULL;
if (*(it->ID) != id) return NULL;
return &(it->Attack);
}
// ***********************************************************************************************
CAttackListManager &CAttackListManager::getInstance()
{
H_AUTO_USE(RZ_AttackList)
if (_Instance) return *_Instance;
_Instance = new CAttackListManager();
return *_Instance;
}
// ***********************************************************************************************
void CAttackListManager::releaseInstance()
{
if( _Instance )
delete _Instance;
_Instance = NULL;
}
// ***********************************************************************************************
void CAttackListManager::init()
{
if (_AnimationSet) return; // init already done
if (!Scene) return; // no scene, can't build anything
_AnimationSet = Driver->createAnimationSet();
if (!_AnimationSet) return;
std::vector<CSheetId> result;
std::vector<std::string> filenames;
NLMISC::CSheetId::buildIdVector(result, filenames, "attack_list");
for(uint k = 0; k < result.size(); ++k)
{
const CAttackListSheet *sheet = dynamic_cast<const CAttackListSheet *>(SheetMngr.get(result[k]));
if (sheet)
{
TAttackListMap::iterator it = _AttackMap.find(filenames[k]);
if (it != _AttackMap.end())
{
nlwarning("attack list duplicated : %s", filenames[k].c_str());
}
CAttackList &al = _AttackMap[filenames[k]];
al.init(sheet, _AnimationSet);
}
}
// auras and links
buildAurasFXs();
buildLinkFXs();
}
// ***********************************************************************************************
void CAttackListManager::release()
{
if (!_AnimationSet) return;
_AttackMap.clear();
if (Driver) Driver->deleteAnimationSet(_AnimationSet);
_Auras.release();
_Links.release();
delete _Instance;
_Instance = NULL;
}
// ***********************************************************************************************
const CAttackList *CAttackListManager::getAttackList(const std::string &name) const
{
H_AUTO_USE(RZ_AttackList)
TAttackListMap::const_iterator it = _AttackMap.find(name);
if (it != _AttackMap.end()) return &(it->second);
return NULL;
}
// ***********************************************************************************************
CAttackListManager::CAttackListManager()
{
_AnimationSet = NULL;
}
// *******************************************************************************************
void CAttackListManager::buildAurasFXs()
{
_Auras.init("auras.id_to_string_array", _AnimationSet, false /* must not delete animset, owned by this object */);
}
// *******************************************************************************************
void CAttackListManager::buildLinkFXs()
{
_Links.init("links.id_to_string_array", _AnimationSet, false /* must not delete animset, owned by this object */);
}