Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/ryzom/client/src/interface_v3/action_handler_phrase.cpp
kervala 23fddefef6 Changed: optimizations for PCH
2010-07-10 15:02:07 +02:00

1887 lines
61 KiB
C++
Raw Blame History

// 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 "action_handler.h"
#include "../motion/user_controls.h"
#include "../view.h"
#include "../misc.h"
#include "../input.h"
#include "../client_cfg.h"
#include "../actions_client.h"
#include "../sheet_manager.h"
#include "interface_manager.h"
#include "dbctrl_sheet.h"
#include "dbgroup_build_phrase.h"
#include "group_container.h"
#include "sphrase_manager.h"
#include "sbrick_manager.h"
#include "ctrl_button.h"
#include "../user_entity.h"
#include "skill_manager.h"
#include "inventory_manager.h"
#include "game_share/memorization_set_types.h"
#include "action_handler_help.h"
#include "bot_chat_page_all.h"
#include "bot_chat_page_trade.h"
#include "../net_manager.h"
#include "../entities.h"
#include "macrocmd_manager.h"
#include "group_menu.h"
#include "group_tree.h"
extern CSheetManager SheetMngr;
using namespace std;
using namespace NLMISC;
// ***************************************************************************
void launchPhraseComposition(bool creation);
const std::string PhraseComposition="ui:interface:phrase_composition";
const std::string PhraseCompositionGroup="ui:interface:phrase_composition:header_opened";
const std::string PhraseMemoryCtrlBase= "ui:interface:gestionsets:shortcuts:s";
// **********************************************************************************************************
// debug update the action bar
void debugUpdateActionBar()
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
pIM->getDbProp("SERVER:USER:ACT_TSTART")->setValue64(NetMngr.getCurrentServerTick());
pIM->getDbProp("SERVER:USER:ACT_TEND")->setValue64(NetMngr.getCurrentServerTick()+30);
}
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// PHRASE BOOK EDITION
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
class CHandlerPhraseEdit : public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
CDBCtrlSheet *pCSDst = dynamic_cast<CDBCtrlSheet*>(pCaller);
if (pCSDst == NULL || !pCSDst->isSPhraseId())
return;
// get the phrase id.
sint32 id= pCSDst->getSPhraseId();
// Nb: Yoyo: this slot can come from eiter the Action Book, or the Memorized sentence
// set the phrase to edit
CSPhraseManager *pPM= CSPhraseManager::getInstance();
pPM->CompositionPhraseId= id;
pPM->CompositionPhraseMemoryLineDest= -1;
pPM->CompositionPhraseMemorySlotDest= -1;
// Launch the composition window
launchPhraseComposition(false);
}
};
REGISTER_ACTION_HANDLER( CHandlerPhraseEdit, "phrase_edit" );
// ***************************************************************************
class CHandlerPhraseNew : public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
// Get A free slot to edit (not allocated).
CSPhraseManager *pPM= CSPhraseManager::getInstance();
// if possible
if(pPM->hasFreeSlot())
{
// Set the phrase to edit to 0, to indicate a new phrase. CANNOT "ALLOCATE" THE ID NOW, else may
// crash if buy a botchatphrase, while editing a new phrase!!!!
pPM->CompositionPhraseId= 0;
// If the caller is ctrl sheet (may be a standard button else), and if comes from memory
CDBCtrlSheet *pCSDst= dynamic_cast<CDBCtrlSheet*>(pCaller);
if(pCSDst && pCSDst->isSPhraseId() && pCSDst->isSPhraseIdMemory())
{
// then will auto-memorize it in this slot
pPM->CompositionPhraseMemoryLineDest= pPM->getSelectedMemoryLineDB();
pPM->CompositionPhraseMemorySlotDest= pCSDst->getIndexInDB();
}
// else no auto memorize
else
{
pPM->CompositionPhraseMemoryLineDest= -1;
pPM->CompositionPhraseMemorySlotDest= -1;
}
// Launch the composition window
launchPhraseComposition(true);
}
}
};
REGISTER_ACTION_HANDLER( CHandlerPhraseNew, "phrase_new" );
// ***************************************************************************
class CHandlerPhraseValidate : public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
// NB: The user can validate only if the server was OK.
// get our father build sentence
CInterfaceGroup *parent = pCaller->getParent();
if (parent)
{
CSPhraseManager *pPM= CSPhraseManager::getInstance();
CDBGroupBuildPhrase *buildGroup= dynamic_cast<CDBGroupBuildPhrase*>(parent->getParent());
if(!buildGroup)
return;
// is this an action creation or action edition?
bool actionCreation= pPM->CompositionPhraseId==0;
// For a new created phrase, the CompositionPhraseId is 0, allocate it now
if(!pPM->CompositionPhraseId)
{
pPM->CompositionPhraseId= pPM->allocatePhraseSlot();
// fail?
if(!pPM->CompositionPhraseId)
return;
}
// build the edited phrase
CSPhraseCom newPhrase;
buildGroup->buildCurrentPhrase(newPhrase);
// the new slot of the phrase
uint32 slotId= pPM->CompositionPhraseId;
// Action Creation case.
if(actionCreation)
{
// Append in the Phrase Manager.
pPM->setPhrase(slotId, newPhrase);
// inform the server of our book change, with the edited name
pPM->sendLearnToServer(slotId);
// if this action creation requires an auto "memorize in slot"
sint32 memoryLine= pPM->CompositionPhraseMemoryLineDest;
sint32 memorySlot= pPM->CompositionPhraseMemorySlotDest;
if( memoryLine>=0 &&
memorySlot>=0 &&
memorySlot<PHRASE_MAX_MEMORY_SLOT)
{
// then memorize auto, client and server
pPM->memorizePhrase(memoryLine, memorySlot, slotId);
pPM->sendMemorizeToServer(memoryLine, memorySlot, slotId);
}
}
// Action edition case
else
{
// Replace in the Phrase Manager.
pPM->setPhrase(slotId, newPhrase);
// inform the server of our book change, with the edited name
pPM->sendLearnToServer(slotId);
// Then, auto-re_memorize all after, changing Ctrl Gray States if needed, and sending msg to server
pPM->rememorizeAllThatUsePhrase(slotId);
}
// Close the Composition Window
pCaller->getRootWindow()->setActive(false);
}
}
};
REGISTER_ACTION_HANDLER( CHandlerPhraseValidate, "phrase_validate" );
// ***************************************************************************
class CHandlerPhraseValidateOnEnter : public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
// Test if the OK control is valid.
CGroupContainer *pGC= dynamic_cast<CGroupContainer*>(pCaller);
if(!pGC) return;
if(!pGC->getHeaderOpened()) return;
CDBGroupBuildPhrase *buildPhrase= dynamic_cast<CDBGroupBuildPhrase*>(pGC->getHeaderOpened());
if(!buildPhrase) return;
CCtrlBaseButton *button= buildPhrase->getValidateButton();
// Ok, button found. test if active and not frozen.
if( button && button->getActive() && !button->getFrozen() )
{
// Act as if the player click on this button
CInterfaceManager *pIM = CInterfaceManager::getInstance();
pIM->runActionHandler(button->getActionOnLeftClick(), button, button->getParamsOnLeftClick() );
}
}
};
REGISTER_ACTION_HANDLER( CHandlerPhraseValidateOnEnter, "phrase_validate_on_enter");
// ***************************************************************************
void launchPhraseComposition(bool creation)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
// Launch the composition window
CGroupContainer *window= dynamic_cast<CGroupContainer*>( pIM->getElementFromId(PhraseComposition) );
if(window)
{
CDBGroupBuildPhrase *buildSentenceTarget= dynamic_cast<CDBGroupBuildPhrase*>( pIM->getElementFromId(PhraseCompositionGroup) );
// if found
if(buildSentenceTarget)
{
// enable the window
window->setActive(true);
// Set the Text of the Window
if(creation)
window->setUCTitle(CI18N::get("uiPhraseCreate"));
else
window->setUCTitle(CI18N::get("uiPhraseEdit"));
// clear the sentence for a New Phrase creation.
buildSentenceTarget->clearBuildingPhrase();
// copy phrase to edit
CSPhraseManager *pPM= CSPhraseManager::getInstance();
// get the edited (or empty if new) phrase.
const CSPhraseCom &phrase= pPM->getPhrase(pPM->CompositionPhraseId);
// Start the composition
buildSentenceTarget->startComposition(phrase);
/** if edition, avoid changing the root type, it behaves better
*/
// Default, no filter (important for creation)
if(creation)
{
// all root are possible => no filter
buildSentenceTarget->setRootBrickTypeFilter(BRICK_TYPE::UNKNOWN);
}
// if edition
else
{
if(phrase.empty())
{
buildSentenceTarget->setRootBrickTypeFilter(BRICK_TYPE::UNKNOWN);
}
else
{
CSBrickManager *pBM= CSBrickManager::getInstance();
const CSBrickSheet *rootBrick= pBM->getBrick(phrase.Bricks[0]);
// can select only bricks of the same type
if(rootBrick)
buildSentenceTarget->setRootBrickTypeFilter(BRICK_FAMILIES::brickType(rootBrick->BrickFamily));
// maybe data error: filter nothing
else
buildSentenceTarget->setRootBrickTypeFilter(BRICK_TYPE::UNKNOWN);
}
}
}
}
}
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// PHRASE COMPOSITION
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// **********************************************************************************************************
/** Called when the user select a brick from the list of possible bricks
*/
class CHandlerPhraseValidateBrick : public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CDBCtrlSheet *pCSSrc = dynamic_cast<CDBCtrlSheet*>(pCaller);
if(!pCSSrc || !pCSSrc->isSBrick())
return;
// get the selected brick
const CSBrickSheet *brick= pCSSrc->asSBrickSheet();
if(brick==NULL)
return;
// and validate the composition
// Standard Case: selection for action composition
if(BrickType != FaberPlan)
{
nlassert(BuildPhraseGroup);
switch(BrickType)
{
case Root: BuildPhraseGroup->validateRoot(brick); break;
case OtherMain: BuildPhraseGroup->validateMain(Index, brick); break;
case Param: BuildPhraseGroup->validateParam(Index, ParamIndex, brick); break;
case NewOpCredit: BuildPhraseGroup->validateNewOpCredit(brick); break;
default: break;
}
}
// Special Case: selection for faber plan
else
{
extern void validateFaberPlanSelection(CSBrickSheet *itemPlanBrick);
validateFaberPlanSelection(const_cast<CSBrickSheet*>(brick));
}
// And hide the modal
pIM->disableModalWindow();
}
public:
enum TType {Root, OtherMain, Param, NewOpCredit, FaberPlan};
static TType BrickType;
static uint Index;
static uint ParamIndex;
static CDBGroupBuildPhrase *BuildPhraseGroup;
};
REGISTER_ACTION_HANDLER( CHandlerPhraseValidateBrick, "phrase_validate_brick" );
CHandlerPhraseValidateBrick::TType CHandlerPhraseValidateBrick::BrickType;
uint CHandlerPhraseValidateBrick::Index;
uint CHandlerPhraseValidateBrick::ParamIndex;
CDBGroupBuildPhrase *CHandlerPhraseValidateBrick::BuildPhraseGroup= NULL;
// ***************************************************************************
class CHandlerPhraseSelectMainBrick : public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &Params)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
// get the type and index in the current build sentence
uint index;
fromString(getParam(Params, "index"), index);
CHandlerPhraseValidateBrick::Index= index;
if(index==0)
CHandlerPhraseValidateBrick::BrickType= CHandlerPhraseValidateBrick::Root;
else
CHandlerPhraseValidateBrick::BrickType= CHandlerPhraseValidateBrick::OtherMain;
// get our father build sentence
CDBGroupBuildPhrase *buildGroup= dynamic_cast<CDBGroupBuildPhrase*>(pCaller->getParent()->getParent());
if(!buildGroup)
return;
// setup the validation
CHandlerPhraseValidateBrick::BuildPhraseGroup= buildGroup;
// build the list of possible bricks
if(index==0)
buildGroup->fillSelectionRoot();
else
buildGroup->fillSelectionMain(index);
// launch the modal
CInterfaceGroup *group= dynamic_cast<CInterfaceGroup*>( pIM->getElementFromId( CDBGroupBuildPhrase::BrickSelectionModal ) );
if(group)
{
// enable the modal
pIM->enableModalWindow(pCaller, group);
}
}
};
REGISTER_ACTION_HANDLER( CHandlerPhraseSelectMainBrick, "phrase_select_main_brick" );
// ***************************************************************************
class CHandlerPhraseSelectParamBrick : public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &Params)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
// get the type and index in the current build sentence
CHandlerPhraseValidateBrick::BrickType= CHandlerPhraseValidateBrick::Param;
uint index, paramIndex;
fromString(getParam(Params, "index"), index);
CHandlerPhraseValidateBrick::Index= index;
fromString(getParam(Params, "param_index"), paramIndex);
CHandlerPhraseValidateBrick::ParamIndex= paramIndex;
// get our father build sentence
CDBGroupBuildPhrase *buildGroup= dynamic_cast<CDBGroupBuildPhrase*>(pCaller->getParent()->getParent());
if(!buildGroup)
return;
// setup the validation
CHandlerPhraseValidateBrick::BuildPhraseGroup= buildGroup;
// build the list of possible bricks
buildGroup->fillSelectionParam(index, paramIndex);
// launch the modal
CInterfaceGroup *group= dynamic_cast<CInterfaceGroup*>( pIM->getElementFromId( CDBGroupBuildPhrase::BrickSelectionModal ) );
if(group)
{
// enable the modal
pIM->enableModalWindow(pCaller, group);
}
}
};
REGISTER_ACTION_HANDLER( CHandlerPhraseSelectParamBrick, "phrase_select_param_brick" );
// ***************************************************************************
class CHandlerPhraseSelectNewBrick : public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &Params)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
// get the type and index in the current build sentence
CHandlerPhraseValidateBrick::BrickType= CHandlerPhraseValidateBrick::NewOpCredit;
string typeStr= getParam(Params, "type");
// get our father build sentence
CDBGroupBuildPhrase *buildGroup= dynamic_cast<CDBGroupBuildPhrase*>(pCaller->getParent()->getParent());
if(!buildGroup)
return;
// setup the validation
CHandlerPhraseValidateBrick::BuildPhraseGroup= buildGroup;
// build the list of possible bricks
if(typeStr=="optional")
buildGroup->fillSelectionNewOp();
else if(typeStr=="credit")
buildGroup->fillSelectionNewCredit();
// launch the modal
CInterfaceGroup *group= dynamic_cast<CInterfaceGroup*>( pIM->getElementFromId( CDBGroupBuildPhrase::BrickSelectionModal ) );
if(group)
{
// enable the modal
pIM->enableModalWindow(pCaller, group);
}
}
};
REGISTER_ACTION_HANDLER( CHandlerPhraseSelectNewBrick, "phrase_select_new_brick" );
// ***************************************************************************
class CHandlerPhraseChangeName : public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
// The BuildPhrase should be the grandParent
CDBGroupBuildPhrase *buildPhrase= dynamic_cast<CDBGroupBuildPhrase*>(pCaller->getParent()->getParent());
if(!buildPhrase)
return;
// update the edited icon
buildPhrase->updateSpellView();
}
};
REGISTER_ACTION_HANDLER( CHandlerPhraseChangeName, "phrase_change_name");
// ***************************************************************************
/*
* Special For Faber Plan selection
*/
class CHandlerPhraseFaberSelectPlan : public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
// Launch the modal to select the faber plan
extern void fillFaberPlanSelection(const std::string &brickDB, uint maxSelection);
fillFaberPlanSelection(CDBGroupBuildPhrase::BrickSelectionDB, CDBGroupBuildPhrase::MaxSelection);
// setup the validation
CHandlerPhraseValidateBrick::BuildPhraseGroup= NULL;
CHandlerPhraseValidateBrick::BrickType= CHandlerPhraseValidateBrick::FaberPlan;
// launch the modal
CInterfaceGroup *group= dynamic_cast<CInterfaceGroup*>( pIM->getElementFromId( CDBGroupBuildPhrase::BrickSelectionModal ) );
if(group)
{
// enable the modal
pIM->enableModalWindow(pCaller, group);
}
}
};
REGISTER_ACTION_HANDLER( CHandlerPhraseFaberSelectPlan, "phrase_faber_select_plan" );
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// PHRASE MEMORISATION / EXECUTION / MISC
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
static void updateAllSPhraseInfo()
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
// update all info windows
CInterfaceHelp::updateWindowSPhraseTexts();
// If the composition is opened, refresh
CInterfaceGroup *pIG= dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId("ui:interface:phrase_composition"));
if(pIG && pIG->getActive())
{
CDBGroupBuildPhrase *buildPhrase= dynamic_cast<CDBGroupBuildPhrase*>(pIG->getGroup("header_opened"));
if(buildPhrase)
buildPhrase->updateAllDisplay();
}
// update bot chat
if(BotChatPageAll && BotChatPageAll->Trade)
BotChatPageAll->Trade->updateSPhraseBuyDialog();
}
// **********************************************************************************************************
/** Called when the Item in Right Hand change
*/
class CHandlerPhraseUpdateFromHand : public IActionHandler
{
public:
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
{
CSPhraseManager *pPM = CSPhraseManager::getInstance();
// **** Update the grayed state of all memory ctrls
pPM->updateAllMemoryCtrlState();
// **** Update misc Action Infos related to items weared
updateAllSPhraseInfo();
}
};
REGISTER_ACTION_HANDLER (CHandlerPhraseUpdateFromHand, "phrase_update_from_hand");
// **********************************************************************************************************
/** Called when the Item in equip change (Action Malus due to armor)
*/
class CHandlerPhraseUpdateFromActionMalus : public IActionHandler
{
public:
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
{
// **** Update misc Action Infos related to items weared
updateAllSPhraseInfo();
}
};
REGISTER_ACTION_HANDLER(CHandlerPhraseUpdateFromActionMalus, "phrase_update_from_action_malus");
// **********************************************************************************************************
/** drag'n'drop: cannot drag PhraseSheet that are not castable
*/
class CHandlerCanDragPhrase : public IActionHandler
{
public:
virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
{
CSPhraseManager *pPM= CSPhraseManager::getInstance();
CDBCtrlSheet *pCSSrc = dynamic_cast<CDBCtrlSheet*>(pCaller);
if(!pCSSrc || !pCSSrc->isSPhrase())
return;
// can drag only if memorizable
pCSSrc->setTempCanDrag(pPM->isPhraseCastable(pCSSrc->getSheetId()));
}
};
REGISTER_ACTION_HANDLER (CHandlerCanDragPhrase, "phrase_can_drag_castable");
// **********************************************************************************************************
/** drag'n'drop: true if the src ctrlSheet is a Phrase and the dest is in memory. Or if both are in memory
*/
class CHandlerCanMemorizePhraseOrMacro : public IActionHandler
{
public:
virtual void execute (CCtrlBase *pCaller, const string &Params)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CSPhraseManager *pPM = CSPhraseManager::getInstance();
CSBrickManager *pBM = CSBrickManager::getInstance();
CMacroCmdManager *pMM = CMacroCmdManager::getInstance();
string src = getParam(Params, "src");
CInterfaceElement *pElt = pIM->getElementFromId(src);
CDBCtrlSheet *pCSSrc = dynamic_cast<CDBCtrlSheet*>(pElt);
CDBCtrlSheet *pCSDst = dynamic_cast<CDBCtrlSheet*>(pCaller);
// can be a phrase id (comes from memory), a phraseSheet (comes from progression), or a macro,
if (pCSSrc->isSPhraseId() || pCSSrc->isMacro() || pCSSrc->isSPhrase())
if (pCSDst->isSPhraseId() || pCSDst->isMacro())
{
// check if incoming phrase ok
if(pCSSrc->isSPhraseId())
{
// get the src phrase.
const CSPhraseCom &phrase= pPM->getPhrase(pCSSrc->getSPhraseId());
if(!phrase.empty())
{
// Get the RootBrick of the Phrase
CSBrickSheet *brick= pBM->getBrick(phrase.Bricks[0]);
if(brick)
pCSDst->setCanDrop (true);
}
}
// can be a phrase sheet
else if(pCSSrc->isSPhrase())
{
CSPhraseSheet *phrase= dynamic_cast<CSPhraseSheet*>(SheetMngr.get(NLMISC::CSheetId(pCSSrc->getSheetId())));
if(phrase && !phrase->Bricks.empty())
{
// Get the RootBrick of the Phrase
CSBrickSheet *brick= pBM->getBrick(phrase->Bricks[0]);
if(brick)
pCSDst->setCanDrop (true);
}
}
// check if incoming macro ok
else
{
// get the macro
const CMacroCmd *macroCmd= pMM->getMacroFromMacroID(pCSSrc->getMacroId());
if(macroCmd)
pCSDst->setCanDrop(true);
}
}
}
};
REGISTER_ACTION_HANDLER (CHandlerCanMemorizePhraseOrMacro, "can_memorize_phrase_or_macro");
class CHandlerPhraseMemoryCopy : public IActionHandler
{
public:
static bool haveLastPhraseElement;
static bool isMacro;
static sint32 sPhraseId;
static sint32 macroId;
virtual void execute(CCtrlBase *pCaller, const string &Params)
{
CDBCtrlSheet *ctrl= dynamic_cast<CDBCtrlSheet*>(pCaller);
if(ctrl && ctrl->isSPhraseIdMemory())
{
haveLastPhraseElement = true;
isMacro = ctrl->isMacro();
sPhraseId = ctrl->getSPhraseId();
macroId = ctrl->getMacroId();
string mode = getParam(Params, "mode"); //default mode is copy
if (mode == "cut") //need delete src
{
CInterfaceManager::getInstance()->runActionHandler("forget_phrase_or_macro", ctrl);
}
}
}
};
REGISTER_ACTION_HANDLER( CHandlerPhraseMemoryCopy, "phrase_memory_copy");
bool CHandlerPhraseMemoryCopy::haveLastPhraseElement = false;
bool CHandlerPhraseMemoryCopy::isMacro = false;
sint32 CHandlerPhraseMemoryCopy::sPhraseId = 0;
sint32 CHandlerPhraseMemoryCopy::macroId = 0;
// **********************************************************************************************************
// debug update the action bar
extern void debugUpdateActionBar();
// **********************************************************************************************************
/** Memorize a combat Brick into a Memory slot.
* Called when the user drop a combat brick on a spell slot.
*/
class CHandlerMemorizePhraseOrMacro : public IActionHandler
{
public:
virtual void execute (CCtrlBase *pCaller, const string &Params);
void memorizePhraseOrMacro(uint dstMemoryIndex, bool isMacro, sint32 phraseId, sint32 macroId);
void memorizePhraseSheet(uint dstMemoryIndex, uint32 sheetId);
};
REGISTER_ACTION_HANDLER( CHandlerMemorizePhraseOrMacro, "memorize_phrase_or_macro");
void CHandlerMemorizePhraseOrMacro::execute (CCtrlBase *pCaller, const string &Params)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CSPhraseManager *pPM = CSPhraseManager::getInstance();
string src = getParam(Params, "src");
CDBCtrlSheet *pCSSrc;
CDBCtrlSheet *pCSDst = dynamic_cast<CDBCtrlSheet*>(pCaller);
// NB: THIS IS UGLY BUT WORKS BECAUSE Memory ctrls are first initialized as SPhrase (branchname init)
// type check
if (pCSDst == NULL) return;
// The dest must be a memory or a macro memory
if (!pCSDst->isSPhraseIdMemory() && !pCSDst->isMacroMemory()) return;
// get the memory line and memory index
sint32 dstMemoryLine= pPM->getSelectedMemoryLineDB();
uint dstMemoryIndex= pCSDst->getIndexInDB();
bool srcIsMacro;
sint32 srcPhraseId;
sint32 srcMacroId;
bool dstIsMacro= pCSDst->isMacro();
sint32 dstPhraseId= pCSDst->getSPhraseId();
sint32 dstMacroId= pCSDst->getMacroId();
if ((src == "") && (CHandlerPhraseMemoryCopy::haveLastPhraseElement))
{
// get the slot ids from save
srcIsMacro= CHandlerPhraseMemoryCopy::isMacro;
srcPhraseId= CHandlerPhraseMemoryCopy::sPhraseId;
srcMacroId= CHandlerPhraseMemoryCopy::macroId;
// if a phrase
if(!srcIsMacro)
{
// \toto yoyo: There is a Network BUG which prevents us from simply doing {Forget(),Delete()} Old phrase,
// then {Learn(),Memorize()} new one (Messages are shuffled).
// Instead, replace the old phrase if needed
uint16 newPhraseId= (uint16)pPM->getMemorizedPhraseIfLastOrNewSlot(dstMemoryLine, dstMemoryIndex);
if(!newPhraseId)
return;
// set it, copy from srcPhraseId
pPM->setPhrase(newPhraseId, pPM->getPhrase(srcPhraseId));
// send learn to server
pPM->sendLearnToServer(newPhraseId);
// memorize the new phrase
memorizePhraseOrMacro(dstMemoryIndex, srcIsMacro, newPhraseId, srcMacroId);
}
}
else
{
CInterfaceElement *pElt = pIM->getElementFromId(src);
pCSSrc = dynamic_cast<CDBCtrlSheet*>(pElt);
// type check
if (pCSSrc == NULL) return;
// The src must be a phraseid, a phrasesheet, or a macro droped
if (!pCSSrc->isSPhraseId() && !pCSSrc->isSPhrase() && !pCSSrc->isMacro()) return;
// get the slot ids.
srcIsMacro= pCSSrc->isMacro();
srcPhraseId= pCSSrc->getSPhraseId();
srcMacroId= pCSSrc->getMacroId();
// If the src comes not from a memory
if(!pCSSrc->isSPhraseIdMemory() && !pCSSrc->isMacroMemory())
{
// if the src is a phrase sheet
if(pCSSrc->isSPhrase())
{
// learn and memorize this phrase
memorizePhraseSheet(dstMemoryIndex, pCSSrc->getSheetId());
}
else
{
// We may replace a phrase with a macro => must delete the phrase under us
if(srcIsMacro)
pPM->fullDeletePhraseIfLast(dstMemoryLine, dstMemoryIndex);
// memorize the phrase or macro
memorizePhraseOrMacro(dstMemoryIndex, srcIsMacro, srcPhraseId, srcMacroId);
}
}
// Else the src is a memory too
else
{
// if Drag copy => this is a copy!
if(pCSSrc->canDragCopy() && pIM->testDragCopyKey())
{
// if a phrase
if(!srcIsMacro)
{
// \toto yoyo: There is a Network BUG which prevents us from simply doing {Forget(),Delete()} Old phrase,
// then {Learn(),Memorize()} new one (Messages are shuffled).
// Instead, replace the old phrase if needed
uint16 newPhraseId= (uint16)pPM->getMemorizedPhraseIfLastOrNewSlot(dstMemoryLine, dstMemoryIndex);
if(!newPhraseId)
return;
// set it, copy from srcPhraseId
pPM->setPhrase(newPhraseId, pPM->getPhrase(srcPhraseId));
// send learn to server
pPM->sendLearnToServer(newPhraseId);
// memorize the new phrase
memorizePhraseOrMacro(dstMemoryIndex, srcIsMacro, newPhraseId, srcMacroId);
}
else
{
// We may replace a phrase with a macro => must delete the phrase under us
pPM->fullDeletePhraseIfLast(dstMemoryLine, dstMemoryIndex);
// memorize the macro (still a reference)
memorizePhraseOrMacro(dstMemoryIndex, srcIsMacro, srcPhraseId, srcMacroId);
}
}
// else this is a swap!
else
{
// if the dest exist, swap
if(dstPhraseId || dstIsMacro)
{
// get the memory index for src
uint srcMemoryIndex= pCSSrc->getIndexInDB();
// memorize dst into src
memorizePhraseOrMacro(srcMemoryIndex, dstIsMacro, dstPhraseId, dstMacroId);
// memorize src into dst
memorizePhraseOrMacro(dstMemoryIndex, srcIsMacro, srcPhraseId, srcMacroId);
}
// else, it's a move
else
{
// copy
memorizePhraseOrMacro(dstMemoryIndex, srcIsMacro, srcPhraseId, srcMacroId);
// forget src (after shorctut change!)
pIM->runActionHandler("forget_phrase_or_macro", pCSSrc);
}
}
}
}
}
// memorize a spell
void CHandlerMemorizePhraseOrMacro::memorizePhraseOrMacro(uint memoryIndex, bool isMacro, sint32 phraseId, sint32 macroId)
{
CSPhraseManager *pPM= CSPhraseManager::getInstance();
sint32 memoryLine= pPM->getSelectedMemoryLineDB();
if(memoryLine<0)
return;
if(isMacro)
{
pPM->memorizeMacro(memoryLine, memoryIndex, macroId);
}
else
{
// memorize in local
pPM->memorizePhrase(memoryLine, memoryIndex, phraseId);
// Send the Server msg
pPM->sendMemorizeToServer(memoryLine, memoryIndex, phraseId);
}
}
// memorize a default spell
void CHandlerMemorizePhraseOrMacro::memorizePhraseSheet(uint memoryIndex, uint32 sheetId)
{
CSPhraseManager *pPM= CSPhraseManager::getInstance();
sint32 memoryLine= pPM->getSelectedMemoryLineDB();
if(memoryLine<0)
return;
// this should have been checked in CanDrag
if(!pPM->isPhraseCastable(sheetId))
return;
// build the com phrase
CSPhraseCom phraseCom;
pPM->buildPhraseFromSheet(phraseCom, sheetId);
if(phraseCom.empty())
return;
// **** first learn this phrase
// \toto yoyo: There is a Network BUG which prevents us from simply doing {Forget(),Delete()} Old phrase,
// then {Learn(),Memorize()} new one (Messages are shuffled).
// Instead, replace the old phrase if needed
uint16 newPhraseId= (uint16)pPM->getMemorizedPhraseIfLastOrNewSlot(memoryLine, memoryIndex);
if(!newPhraseId)
return;
// set it
pPM->setPhrase(newPhraseId, phraseCom);
// send learn to server
pPM->sendLearnToServer(newPhraseId);
// **** memorize
// memorize in local
pPM->memorizePhrase(memoryLine, memoryIndex, newPhraseId);
// Send the Server msg
pPM->sendMemorizeToServer(memoryLine, memoryIndex, newPhraseId);
}
// **********************************************************************************************************
/** Forget a Phrase from a Memory slot
* Called when the user choose to free a spell memory slot
*/
class CHandlerForgetPhraseOrMacro : public IActionHandler
{
public:
virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
{
CSPhraseManager *pPM = CSPhraseManager::getInstance();
CDBCtrlSheet *pCSDst = dynamic_cast<CDBCtrlSheet*>(pCaller);
if (pCSDst == NULL) return;
if (!pCSDst->isSPhraseIdMemory() && !pCSDst->isMacroMemory())
return;
// Ok, the user try to forget a phrase slot.
sint32 memoryLine= pPM->getSelectedMemoryLineDB();
if(memoryLine<0)
return;
// get the memory index
uint memoryIndex= pCSDst->getIndexInDB();
if(pCSDst->isMacro())
{
pPM->forgetMacro(memoryLine, memoryIndex);
}
else
{
// forget in local.
pPM->forgetPhrase(memoryLine, memoryIndex);
// Server com.
pPM->sendForgetToServer(memoryLine, memoryIndex);
}
}
};
REGISTER_ACTION_HANDLER( CHandlerForgetPhraseOrMacro, "forget_phrase_or_macro");
// **********************************************************************************************************
/** Forget a Phrase from a Memory slot
* Called when the user choose to free a spell memory slot
*/
class CHandlerDeletePhraseOrForgetMacro : public IActionHandler
{
public:
virtual void execute (CCtrlBase *pCaller, const string & Params)
{
CDBCtrlSheet *pCSDst = dynamic_cast<CDBCtrlSheet*>(pCaller);
if (pCSDst == NULL) return;
if (!pCSDst->isSPhraseIdMemory() && !pCSDst->isMacroMemory())
return;
// get the memory index
uint memoryIndex = pCSDst->getIndexInDB();
bool isMacro = pCSDst->isMacro();
sint32 phraseId = pCSDst->getSPhraseId();
// build params string
string sParams;
sParams.append("memoryIndex=");
sParams.append(toString(memoryIndex));
sParams.append("|isMacro=");
sParams.append(toString(isMacro));
sParams.append("|phraseId=");
sParams.append(toString(phraseId));
if (!Params.empty())
{
sParams.append("|");
sParams.append(Params);
}
// Ask if ok before
CInterfaceManager *pIM = CInterfaceManager::getInstance();
pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQDeleteAction"), "do_delete_phrase_or_forget_macro", sParams);
}
};
REGISTER_ACTION_HANDLER( CHandlerDeletePhraseOrForgetMacro, "delete_phrase_or_forget_macro");
// **********************************************************************************************************
/** Forget a Phrase from a Memory slot
* Called when the user confirmed that he want to free a spell memory slot
*/
class CHandlerDoDeletePhraseOrForgetMacro : public IActionHandler
{
public:
virtual void execute (CCtrlBase *pCaller, const string &Params)
{
// Ok, the user try to forget a phrase slot
CSPhraseManager *pPM = CSPhraseManager::getInstance();
sint32 memoryLine = pPM->getSelectedMemoryLineDB();
if (memoryLine<0)
return;
// get params
uint memoryIndex;
fromString(getParam(Params, "memoryIndex"), memoryIndex);
bool isMacro;
fromString(getParam(Params, "isMacro"),isMacro);
sint32 phraseId;
fromString(getParam(Params, "phraseId"),phraseId);
if (isMacro)
{
pPM->forgetMacro(memoryLine, memoryIndex);
}
else
{
// do all the thing to delete properly this phrase
pPM->fullDelete(phraseId);
}
}
};
REGISTER_ACTION_HANDLER( CHandlerDoDeletePhraseOrForgetMacro, "do_delete_phrase_or_forget_macro");
// **********************************************************************************************************
/** Cast a spell from a memory slot (combat or magic)
* Called when the user click on a memory slot. Can be called also from CAHRunShortcut, or from
* MoveToAction system (in CSPhraseManager)
*/
class CHandlerCastPhrase : public IActionHandler
{
public:
static sint64 LastHitTime;
static sint LastIndex;
public:
virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CSPhraseManager *pPM = CSPhraseManager::getInstance();
CSBrickManager *pBM= CSBrickManager::getInstance();
CDBCtrlSheet *pCSDst = dynamic_cast<CDBCtrlSheet*>(pCaller);
if (pCSDst == NULL) return;
if (!pCSDst->isSPhraseIdMemory())
return;
// Can cast only if not Latent (ie grayed) !!
if (pCSDst->getGrayed())
return;
// Ok, the user try to cast a phrase slot.
sint32 memoryLine= pPM->getSelectedMemoryLineDB();
if(memoryLine<0)
return;
// get the memory index
uint memoryIndex= pCSDst->getIndexInDB();
// Check If the phrase exist
sint phraseId= pCSDst->getSPhraseId();
if(!phraseId)
return;
const CSPhraseCom &phraseCom= pPM->getPhrase(phraseId);
if(phraseCom.empty())
return;
CSBrickSheet *rootBrick= pBM->getBrick(phraseCom.Bricks[0]);
if(!rootBrick)
return;
// **** Check If the phrase is a Craft Phrase.
if( rootBrick->isFaber() )
{
extern void launchFaberCastWindow(sint32 , uint , CSBrickSheet *);
launchFaberCastWindow(memoryLine, memoryIndex, rootBrick);
// Cancel any moveTo, because don't want to continue reaching the prec entity
UserEntity->resetAnyMoveTo();
}
// **** Else standart cast
else
{
// **** Cyclic Cast? (dblclick)
bool cyclic;
// Manage "DblHit"
uint dbclickDelay = pIM->getUserDblClickDelay();
// if success to "dblclick"
if(LastIndex==(sint)memoryIndex && T1<=LastHitTime+dbclickDelay )
cyclic= true;
else
cyclic= false;
// for next hit
LastHitTime= T1;
LastIndex= memoryIndex;
// can't cast magic phrase while moving
if( rootBrick->isMagic() )
{
if( UserControls.isMoving() || (UserEntity && UserEntity->follow() && UserEntity->speed()!=0.0) )
{
// display "you can't cast while moving"
CInterfaceManager *pIM= CInterfaceManager::getInstance();
ucstring msg = CI18N::get("msgNoCastWhileMoving");
string cat = getStringCategory(msg, msg);
pIM->displaySystemInfo(msg, cat);
return;
}
}
// Can't cyclic cast Magic, SpecialPower or Harvest phrases (forage_extraction are auto)
if( rootBrick->isMagic() || rootBrick->isHarvest() || rootBrick->isSpecialPower() )
cyclic= false;
// auto cyclic for forage extraction
if( rootBrick->isForageExtraction() )
cyclic= true;
// even for extraction, if AvoidCyclic in any bricks, no cyclic!
if( pPM->avoidCyclicForPhrase(phraseCom) )
cyclic= false;
// **** Launch the cast
// Cast only if their is a target, or if it is not a combat action
CEntityCL *target = EntitiesMngr.entity(UserEntity->targetSlot());
if(target || !rootBrick->isCombat())
{
// combat (may moveTo before) ?
if(rootBrick->isCombat())
{
if( !UserEntity->canEngageCombat() )
return;
UserEntity->executeCombatWithPhrase(target, memoryLine, memoryIndex, cyclic);
}
// else can cast soon!
else if ( rootBrick->isForageExtraction() && (! UserEntity->isRiding()) ) // if mounted, send directly to server (without moving) to receive the error message
{
// Yoyo: TEMP if a target selected, must be a forage source
if(!target || target->isForageSource())
{
// Cancel any follow
UserEntity->disableFollow();
// reset any moveTo also (if target==NULL, moveToExtractionPhrase() and therefore resetAnyMoveTo() not called)
// VERY important if previous MoveTo was a SPhrase MoveTo (because cancelClientExecute() must be called)
UserEntity->resetAnyMoveTo();
// Move to targetted source
if ( target )
UserEntity->moveToExtractionPhrase( target->slot(), MaxExtractionDistance, memoryLine, memoryIndex, cyclic );
// start client execution
pPM->clientExecute(memoryLine, memoryIndex, cyclic);
if ( ! target )
{
// inform Server of phrase cast
pPM->sendExecuteToServer(memoryLine, memoryIndex, cyclic);
}
}
}
else
{
// Cancel any moveTo(), because don't want to continue reaching the prec entity
// VERY important if previous MoveTo was a SPhrase MoveTo (because cancelClientExecute() must be called)
UserEntity->resetAnyMoveTo();
// start client execution: NB: start client execution even if it
pPM->clientExecute(memoryLine, memoryIndex, cyclic);
// inform Server of phrase cast
pPM->sendExecuteToServer(memoryLine, memoryIndex, cyclic);
}
}
}
}
};
REGISTER_ACTION_HANDLER( CHandlerCastPhrase, "cast_phrase");
sint64 CHandlerCastPhrase::LastHitTime= 0;
sint CHandlerCastPhrase::LastIndex= -1;
// ***************************************************************************
/** Called when user hit the 1.2.3.4.5..... key
*/
class CAHRunShortcut : public IActionHandler
{
public:
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
{
sint shortcut;
fromString(Params, shortcut);
if (shortcut>=0 && shortcut <= RYZOM_MAX_SHORTCUT)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
// get the control
CInterfaceElement *elm= pIM->getElementFromId(PhraseMemoryCtrlBase + toString(shortcut) );
CDBCtrlSheet *ctrl= dynamic_cast<CDBCtrlSheet*>(elm);
if(ctrl)
{
// run the standard cast case.
if(ctrl->isMacro())
pIM->runActionHandler("cast_macro", ctrl);
else
pIM->runActionHandler("cast_phrase", ctrl);
}
}
}
};
REGISTER_ACTION_HANDLER (CAHRunShortcut, "run_shortcut");
// ***************************************************************************
/** Called when the user click on a memory slot. Different AH called if the slot is empty or full
*/
class CHandlerCastPhraseOrCreateNew : public IActionHandler
{
public:
virtual void execute (CCtrlBase *pCaller, const string &Params)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CDBCtrlSheet *pCSDst = dynamic_cast<CDBCtrlSheet*>(pCaller);
if (pCSDst == NULL) return;
if (!pCSDst->isSPhraseIdMemory())
return;
// get the phrase id under it
sint phraseId= pCSDst->getSPhraseId();
// if a phrase is on this slot, just cast the phrase
if(phraseId)
{
pIM->runActionHandler("cast_phrase", pCaller, Params);
}
// else open the RightMenuEmpty, to have "NewAction"
else
{
string menu= pCSDst->getListMenuRightEmptySlot();
// opens only if no dragged sheet
if( !menu.empty() && CDBCtrlSheet::getDraggedSheet()==NULL )
{
// opens the menu
CDBCtrlSheet::setCurrSelSheet(pCSDst);
pIM->enableModalWindow (pCSDst, menu);
}
}
}
};
REGISTER_ACTION_HANDLER (CHandlerCastPhraseOrCreateNew, "cast_phrase_or_create_new");
// ***************************************************************************
/** Called to get info on Phrase Link
*/
class CHandlerPhraseLinkCtrlRClick : public IActionHandler
{
public:
virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
CInterfaceGroup *parent= pCaller->getParent();
if(parent)
{
// Get the Brother CtrlSheet
CDBCtrlSheet *ctrl= dynamic_cast<CDBCtrlSheet*>(parent->getCtrl("ctrl_phrase"));
if(ctrl)
{
pIM->runActionHandler(ctrl->getActionOnRightClick(), ctrl, ctrl->getParamsOnRightClick());
}
}
}
};
REGISTER_ACTION_HANDLER (CHandlerPhraseLinkCtrlRClick, "phrase_link_ctrl_rclick");
// ***************************************************************************
/** Called to cancel a Phrase link
*/
class CHandlerPhraseLinkStop : public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &Params)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
// get the link index
uint8 index;
fromString(Params, index);
// Get the link counter. Used to verify that the client cancel the correct link according to server
uint8 counter= 0;
CCDBNodeLeaf *node= pIM->getDbProp(toString("SERVER:EXECUTE_PHRASE:LINK:%d:COUNTER", index), false);
if(node)
counter= node->getValue8();
// Send msg to server
if (!ClientCfg.Local)
{
NLMISC::CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream("PHRASE:CANCEL_LINK", out))
{
out.serial(index);
out.serial(counter);
NetMngr.push(out);
}
else
{
nlwarning(" unknown message name '%s'", "PHRASE:CANCEL_LINK");
}
}
else
{
// debug:
pIM->displaySystemInfo( toString("PHRASE:CANCEL_LINK %d, %d", index, counter) );
}
}
};
REGISTER_ACTION_HANDLER(CHandlerPhraseLinkStop, "phrase_link_stop");
// ***************************************************************************
/** Called to cancel a Phrase link
*/
class CHandlerPhraseCancelCast: public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &/* Params */)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
// Send msg to server
if (!ClientCfg.Local)
{
UserEntity->cancelAllPhrases();
}
else
{
// debug:
pIM->displaySystemInfo( ucstring("PHRASE:CANCEL_ALL") );
}
}
};
REGISTER_ACTION_HANDLER(CHandlerPhraseCancelCast, "phrase_cancel_cast");
// ***************************************************************************
/// Called when one of the BRICK_TICK_RANGE has changed
class CHandlerPhraseUpdateAllMemoryRegenTickRange : public IActionHandler
{
public:
virtual void execute(CCtrlBase *, const string &)
{
CSPhraseManager *pPM= CSPhraseManager::getInstance();
pPM->updateAllMemoryCtrlState();
pPM->touchRegenTickRangeFlag();
}
};
REGISTER_ACTION_HANDLER(CHandlerPhraseUpdateAllMemoryRegenTickRange, "phrase_update_all_memory_ctrl_regen_tick_range");
// ***************************************************************************
/// Called when we right click on a brick in the memories
class CHandlerPhraseCheckCanCristalize: public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
const string sCristalizePath = "ui:interface:cm_memory_phrase:cri";
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CSPhraseManager *pPM = CSPhraseManager::getInstance();
CSBrickManager *pBM = CSBrickManager::getInstance();
CInterfaceElement *pCristalizeMenuOption = pIM->getElementFromId(sCristalizePath);
if (pCristalizeMenuOption == NULL) return;
// The default is to not display the cristalize menu option
pCristalizeMenuOption->setActive(false);
if (pCaller == NULL) return;
// Get the interface control sheet
CDBCtrlSheet *pCS = dynamic_cast<CDBCtrlSheet*>(pIM->getCtrlLaunchingModal());
if (pCS == NULL) return;
if (!pCS->isSPhraseIdMemory()) return;
// If its a phrase id in memory then get the phrase
const CSPhraseCom &phrase = pPM->getPhrase(pCS->getSheetId());
if (phrase.empty()) return;
// If the phrase is not empty get the root to known if its a magic phrase or not
// And if its a magic phrase display the cristalize menu option
CSBrickSheet *pBrick = pBM->getBrick(phrase.Bricks[0]);
if (pBrick != NULL)
{
if (pBrick->isMagic())
{
pCristalizeMenuOption->setActive(true);
// Disable the cristalize item if the player has a forage in progress
CViewTextMenu* vtm = dynamic_cast<CViewTextMenu*>(pCristalizeMenuOption);
if ( vtm )
{
CTempInvManager *tim = CTempInvManager::getInstance();
bool isForageInProgress = tim && tim->isOpened() && (tim->getMode() == TEMP_INV_MODE::Forage);
vtm->setGrayed( isForageInProgress );
}
}
}
}
};
REGISTER_ACTION_HANDLER(CHandlerPhraseCheckCanCristalize, "phrase_check_can_cristalize");
// ***************************************************************************
/// Called after the cm_memory_phrase menu has been opened on a magic phrase
class CHandlerPhraseCristalize: public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
CSPhraseManager *pPM = CSPhraseManager::getInstance();
CDBCtrlSheet *pCSDst = dynamic_cast<CDBCtrlSheet*>(pCaller);
if (pCSDst == NULL) return;
if (!pCSDst->isSPhraseIdMemory())
return;
// Can cast only if not Latent (ie grayed) !!
if (pCSDst->getGrayed())
return;
// Ok, the user try to cast a phrase slot.
sint32 memoryLine= pPM->getSelectedMemoryLineDB();
if(memoryLine<0)
return;
// get the memory index
uint memoryIndex= pCSDst->getIndexInDB();
// execute both client and server
pPM->executeCristalize(memoryLine, memoryIndex);
}
};
REGISTER_ACTION_HANDLER(CHandlerPhraseCristalize, "phrase_cristalize");
// ***************************************************************************
class CHandlerPhraseBookSkillFilter : public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &Params)
{
CSPhraseManager *pPM= CSPhraseManager::getInstance();
// If the param is a BrickType Filter...
string btFilter= getParam(Params, "bt");
if(!btFilter.empty())
{
BRICK_TYPE::EBrickType bt= BRICK_TYPE::toBrickType(btFilter);
if(bt!=BRICK_TYPE::UNKNOWN)
pPM->setBookFilter(bt, SKILLS::unknown);
}
// else it is a skill filter
else
{
sint index;
fromString(Params, index);
if(index>=0 && index<SKILLS::NUM_SKILLS)
pPM->setBookFilter(BRICK_TYPE::UNKNOWN, (SKILLS::ESkills)index);
else
pPM->setBookFilter(BRICK_TYPE::UNKNOWN, SKILLS::unknown);
}
}
};
REGISTER_ACTION_HANDLER(CHandlerPhraseBookSkillFilter, "phrase_book_skill_filter");
// ***************************************************************************
class CHandlerPhraseSelectMemory : public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &Params)
{
string expr = getParam (Params, "value");
CInterfaceExprValue value;
if (CInterfaceExpr::eval(expr, value, NULL))
{
if (!value.toInteger())
{
nlwarning("<CHandlerPhraseSelectMemory:execute> expression doesn't evaluate to a numerical value");
}
else
{
CSPhraseManager *pPM= CSPhraseManager::getInstance();
sint val= (sint32)value.getInteger();
clamp(val, 0, MEM_SET_TYPES::NumMemories-1);
pPM->selectMemoryLineDB(val);
}
}
}
};
REGISTER_ACTION_HANDLER(CHandlerPhraseSelectMemory, "phrase_select_memory");
// ***************************************************************************
class CHandlerPhraseSelectShortcutBar : public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &Params)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
CCDBNodeLeaf *node= pIM->getDbProp("UI:PHRASE:SELECT_MEMORY", false);
if(node)
{
sint32 val;
fromString(Params, val);
node->setValue32(val);
}
}
};
REGISTER_ACTION_HANDLER(CHandlerPhraseSelectShortcutBar, "select_shortcut_bar");
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// HELP / LINKS
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// This expr is used only for define in phrase.xml.
DECLARE_INTERFACE_CONSTANT(getPhraseBrickSelectionMax, CDBGroupBuildPhrase::MaxSelection)
// ***************************************************************************
// Get the UC name of a phraseId
static DECLARE_INTERFACE_USER_FCT(getSPhraseName)
{
if (args.size() > 0)
{
if(!args[0].toInteger())
return false;
sint sphraseId= (sint)args[0].getInteger();
CSPhraseManager *pPM= CSPhraseManager::getInstance();
result.setUCString(pPM->getPhrase(sphraseId).Name);
return true;
}
else
{
return false;
}
}
REGISTER_INTERFACE_USER_FCT("getSPhraseName", getSPhraseName)
// ***************************************************************************
// Get the tooltip of a Combat Weapon restriction brick
class CHandlerCombatRestrictTooltip : public IActionHandler
{
public:
virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
CDBCtrlSheet *ctrlSheet= dynamic_cast<CDBCtrlSheet*>(pCaller);
if(!ctrlSheet)
return;
ucstring str(STRING_MANAGER::CStringManagerClient::getSBrickLocalizedName(CSheetId(ctrlSheet->getSheetId())));
// According to locked state
if(ctrlSheet->getGrayed())
strFindReplace(str, "%comp", CI18N::get("uittPhraseCombatRestrictKO"));
else
strFindReplace(str, "%comp", CI18N::get("uittPhraseCombatRestrictOK"));
pIM->setContextHelpText(str);
}
};
REGISTER_ACTION_HANDLER( CHandlerCombatRestrictTooltip, "phrase_combat_restrict_tooltip");
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// BOT CHAT
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void phraseBotChatBuyBySheet(NLMISC::CSheetId sheetId, uint16 phraseId)
{
uint32 sheetNum= sheetId.asInt();
if (!ClientCfg.Local)
{
NLMISC::CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream("PHRASE:BUY_SHEET", out))
{
out.serial(sheetNum);
out.serial(phraseId);
NetMngr.push(out);
}
else
{
nlwarning(" unknown message name '%s'", "PHRASE:BUY_SHEET");
}
}
else
{
// debug:
CInterfaceManager *pIM= CInterfaceManager::getInstance();
pIM->displaySystemInfo( toString("PHRASE:BUY_SHEET => ") + toString(phraseId) );
// **** Server emulation
// learn all bricks of this phrase
CSPhraseSheet *phrase= dynamic_cast<CSPhraseSheet*>(SheetMngr.get(sheetId));
if(phrase)
{
CSBrickManager *pBM= CSBrickManager::getInstance();
// For all bricks of this phrase
for(uint i=0;i<phrase->Bricks.size();i++)
{
CSBrickSheet *brick= pBM->getBrick(phrase->Bricks[i]);
if(brick)
{
// force learn it.
CCDBNodeLeaf * node= pBM->getKnownBrickBitFieldDB(brick->BrickFamily);
if(node)
{
uint64 flags= node->getValue64();
flags|= uint64(1)<<(brick->IndexInFamily-1);
node->setValue64(flags);
}
}
}
}
// ack phrase learn
CSPhraseManager *pPM= CSPhraseManager::getInstance();
if(phraseId)
pPM->receiveBotChatConfirmBuy(phraseId, true);
// synchronize
uint counter= pIM->getLocalSyncActionCounter();
pIM->getDbProp("SERVER:INVENTORY:COUNTER")->setValue32(counter);
pIM->getDbProp("SERVER:EXCHANGE:COUNTER")->setValue32(counter);
pIM->getDbProp("SERVER:TARGET:CONTEXT_MENU:COUNTER")->setValue32(counter);
pIM->getDbProp("SERVER:USER:COUNTER")->setValue32(counter);
}
}
// ***************************************************************************
void phraseBotChatBuyActionByIndex(uint8 index, uint16 phraseId)
{
if (!ClientCfg.Local)
{
// send the selection to the server
NLMISC::CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream("PHRASE:BUY", out))
{
out.serial(index);
out.serial(phraseId);
NetMngr.push(out);
}
else
nlwarning(" unknown message name 'PHRASE:BUY");
}
else
{
// debug:
CInterfaceManager *pIM= CInterfaceManager::getInstance();
pIM->displaySystemInfo("PHRASE:BUY => " + toString(phraseId) );
}
}
// ***************************************************************************
/* Called from CConfirmBuyItem action handler
*/
void phraseBuyBotChat(CDBCtrlSheet *ctrl, uint8 index, bool useBuySheetMsg)
{
CSBrickManager *pBM= CSBrickManager::getInstance();
CSPhraseManager *pSM= CSPhraseManager::getInstance();
if(!ctrl->isSPhrase())
return;
// Get the SPhrase
const CSPhraseSheet *sp= ctrl->asSPhraseSheet();
if(!sp || sp->Bricks.empty())
return;
// Verify that the phrase is not a special "CHARACTERISTIC BUYING" phrase
bool isCharacBuying= false;
CSBrickSheet *brickSheet= pBM->getBrick(CSheetId(sp->Bricks[0]));
if(brickSheet && BRICK_FAMILIES::isCharacBuyFamily(brickSheet->BrickFamily) )
isCharacBuying= true;
// confirm the buy
{
// default: not append to the manager
uint16 phraseId= 0;
// Append the phrase to the manager. ONLY if this phrase is castable
if(sp->Castable && !isCharacBuying)
{
CSPhraseCom phraseCom;
pSM->buildPhraseFromSheet(phraseCom, ctrl->getSheetId());
if(phraseCom.empty())
return;
// get the new phraseId
phraseId= (uint16)pSM->allocatePhraseSlot();
// Since we are not sure this slot work, lock it!
pSM->setPhrase(phraseId, phraseCom, true);
}
// Special for LOCAL:USER:SKILL_POINTS_ update
CInterfaceManager *pIM= CInterfaceManager::getInstance();
pIM->incLocalSyncActionCounter();
// Send msg to server
if(useBuySheetMsg)
phraseBotChatBuyBySheet(sp->Id, phraseId);
else
phraseBotChatBuyActionByIndex(index, phraseId);
}
}
// ***************************************************************************
// Command for Debug BotChat ACK.
NLMISC_COMMAND(phraseComfirmBuy, "Debug: confirm a phrase BotChat buy", "")
{
if(args.size() != 2) return false;
uint phraseId;
fromString(args[0], phraseId);
bool confirm;
fromString(args[1], confirm);
CSPhraseManager *pSM= CSPhraseManager::getInstance();
pSM->receiveBotChatConfirmBuy(phraseId, confirm);
return true;
}
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// MACRO
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
class CHandlerCastMacro : public IActionHandler
{
public:
virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
{
CMacroCmdManager *pMM = CMacroCmdManager::getInstance();
CDBCtrlSheet *pCSDst = dynamic_cast<CDBCtrlSheet*>(pCaller);
if (pCSDst == NULL) return;
if (!pCSDst->isMacroMemory())
return;
// Can cast only if not grayed
if (pCSDst->getGrayed())
return;
// execute the macro id
pMM->executeID(pCSDst->getMacroId());
}
};
REGISTER_ACTION_HANDLER( CHandlerCastMacro, "cast_macro");
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// MISC
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
class CHandlerPhraseMemoryBeforeMenu : public IActionHandler
{
public:
static uint32 LastPhraseIdMenu;
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
CDBCtrlSheet *ctrl= dynamic_cast<CDBCtrlSheet*>(pCaller);
if(ctrl && ctrl->isSPhraseIdMemory())
{
LastPhraseIdMenu= ctrl->getSPhraseId();
}
}
};
REGISTER_ACTION_HANDLER( CHandlerPhraseMemoryBeforeMenu, "phrase_memory_before_menu");
uint32 CHandlerPhraseMemoryBeforeMenu::LastPhraseIdMenu= 0;
// ***************************************************************************
static DECLARE_INTERFACE_USER_FCT(isPhraseMenuNotExecuting)
{
bool ok= true;
// if the PhraseId for this menu is equal to either cyclic action, or next action, fails
CSPhraseManager *pPM= CSPhraseManager::getInstance();
if(CHandlerPhraseMemoryBeforeMenu::LastPhraseIdMenu!=0)
{
if(pPM->getCycleExecutePhraseId()==CHandlerPhraseMemoryBeforeMenu::LastPhraseIdMenu)
ok= false;
if(pPM->getNextExecutePhraseId()==CHandlerPhraseMemoryBeforeMenu::LastPhraseIdMenu)
ok= false;
}
result.setBool(ok);
return true;
}
REGISTER_INTERFACE_USER_FCT("isPhraseMenuNotExecuting", isPhraseMenuNotExecuting)
Reference in a new issue View git blame Copy permalink