mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-09-21 04:00:33 +00:00
1887 lines
61 KiB
C++
1887 lines
61 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 "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)
|
|
|