aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-11-08 00:09:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/ryzom/client/src/r2/editor.cpp

7841 lines
241 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 <sstream>
#include "nel/misc/path.h"
#include "nel/misc/i18n.h"
#include "nel/misc/sheet_id.h"
#include "nel/misc/polygon.h"
#include "nel/misc/time_nl.h"
//
#include "nel/3d/u_driver.h"
#include "nel/3d/u_text_context.h"
//
#include "nel/ligo/ligo_config.h"
#include "nel/net/unified_network.h"
#include "nel/net/module_manager.h"
#include "nel/pacs/u_global_retriever.h"
//
#include "r2_lua.h"
#include "game_share/r2_share_itf.h"
#include "game_share/r2_messages.h"
#include "game_share/scenario_entry_points.h"
//
#include "dmc/dmc.h" // client interface to the dynamic scenario service
#include "dmc/client_edition_module.h"
#include "dmc/property_accessor.h"
#include "dmc/com_lua_module.h"
#include "game_share/dms.h"
//
#include "../client_sheets/item_sheet.h"
#include "editor.h"
//
#include "../interface_v3/lua_helper.h"
#include "../interface_v3/group_tree.h"
#include "../interface_v3/interface_manager.h"
#include "../contextual_cursor.h"
#include "../cursor_functions.h"
#include "../entities.h"
#include "../events_listener.h"
#include "../interface_v3/group_list.h"
#include "../interface_v3/event_descriptor.h"
#include "../interface_v3/group_tree.h"
#include "../client_cfg.h"
#include "../interface_v3/lua_ihm.h"
#include "../interface_v3/lua_object.h"
#include "../global.h"
#include "../connection.h"
#include "../main_loop.h"
#include "../interface_v3/people_interraction.h"
#include "../time_client.h"
#include "../pacs_client.h"
#include "../interface_v3/lua_ihm.h"
#include "../actions.h"
#include "../actions_client.h"
#include "object_factory_client.h"
#include "../weather.h"
#include "../light_cycle_manager.h"
#include "../dummy_progress.h"
#include "../continent_manager.h"
#include "../world_database_manager.h"
#include "../init_main_loop.h"
#include "../net_manager.h"
#include "../interface_v3/input_handler_manager.h"
#include "../connection.h"
#include "../init_main_loop.h"
#include "../interface_v3/group_editbox.h"
#include "../landscape_poly_drawer.h"
#include "../input.h"
#include "../motion/user_controls.h"
#include "../game_context_menu.h"
#include "../interface_v3/macrocmd_manager.h"
//
#include "../player_r2_cl.h"
#include "palette_node.h"
#include "tool_create_entity.h"
#include "tool_select_move.h"
#include "tool_new_vertex.h"
#include "displayer_visual_entity.h"
#include "displayer_visual_group.h"
#include "displayer_visual_shape.h"
#include "displayer_visual_activity_sequence.h"
#include "displayer_lua.h"
#include "verbose_clock.h"
#include "r2_config.h"
#include "entity_sorter.h"
//
#include "tool_draw_prim.h"
#include "tool_select_move.h"
#include "tool_select_rotate.h"
#include "tool_choose_pos_lua.h"
//
#include "../sheet_manager.h"
#include "../session_browser_impl.h"
#include "../far_tp.h"
using namespace NLMISC;
using namespace NLNET;
using namespace NL3D;
extern CEventsListener EventsListener;
extern CLog g_log;
extern CGameContextMenu GameContextMenu;
extern void badXMLParseMessageBox();
R2::TUserRole UserRoleInSession;
#define OPERATOR_EQUAL(X,Y) X==Y
//#define OPERATOR_EQUAL(X, Y) ::operator==(X,Y)
namespace R2
{
class CEditorCheck
{
public:
CEditorCheck() { check(); }
~CEditorCheck() { check(); }
void check()
{
if (!EditorCreated) return; // avoid infinite loop
if (getEditor().getMode() != CEditor::NotInitialized)
{
nlassert(getEditor().getEnv().isValid());
}
}
static bool EditorCreated;
};
bool CEditorCheck::EditorCreated = false;
#ifdef NL_DEBUG
#define CHECK_EDITOR CEditorCheck __ec;
#else
#define CHECK_EDITOR (void) 0;
#endif
const char *DEFAULT_CURSOR = "curs_default.tga";
bool ResetWanted = false;
bool ReloadUIFlag = true; // by default, CEditor loads its own UI
bool ResetScenarioWanted = false;
bool ReloadScenarioWanted = false;
bool ConnectionWanted = false;
std::string CEditor::_ScenarioToLoadWhenEntreringIntoAnimation="";
bool CEditor::_IsStartingScenario=false;
// *********************************************************************************************************
/** this class forward modification events from the network so that the editor can
* update its state to match the current state of the map
*/
class CDynamicMapClientEventForwarder : public CDynamicMapClient
{
public:
CDynamicMapClientEventForwarder(const std::string &eid, NLNET::IModuleSocket * clientGateway, lua_State *luaState);
virtual void nodeErased(const std::string& instanceId, const std::string& attrName, sint32 position);
virtual void nodeSet(const std::string& instanceId, const std::string& attrName, CObject* value);
virtual void nodeInserted(const std::string& instanceId, const std::string& attrName, sint32 position,
const std::string& key, CObject* value);
virtual void nodeMoved(const std::string& instanceId, const std::string& attrName, sint32 position,
const std::string& destInstanceId, const std::string& destAttrName, sint32 destPosition);
virtual void scenarioUpdated(CObject* highLevel, bool willTP, uint32 initialActIndex);
virtual void onAnimationModeConnected(const CClientMessageAdventureUserConnection& connected);
virtual void onEditionModeConnected( uint32 userSlotId, uint32 adventureId, CObject* highLevel, const std::string& versionName, bool willTP, uint32 initialActIndex);
virtual void onEditionModeDisconnected();
virtual void onResetEditionMode();
virtual void onTestModeConnected();
virtual void onTestModeDisconnected(TSessionId sessionId, uint32 lasAct, TScenarioSessionType sessionType);
};
CDynamicMapClientEventForwarder::CDynamicMapClientEventForwarder(const std::string &eid, NLNET::IModuleSocket * clientGateway, lua_State *luaState) :
CDynamicMapClient(eid, clientGateway, luaState)
{
}
void CDynamicMapClientEventForwarder::nodeErased(const std::string& instanceId, const std::string& attrName, sint32 position)
{
//H_AUTO(R2_CDynamicMapClientEventForwarder_nodeErased)
if (!getEditor().getMode() == CEditor::EditionMode) return;
getEditor().nodeErased(instanceId, attrName, position);
}
void CDynamicMapClientEventForwarder::nodeSet(const std::string& instanceId, const std::string& attrName, CObject* value)
{
//H_AUTO(R2_CDynamicMapClientEventForwarder_nodeSet)
if (!getEditor().getMode() == CEditor::EditionMode) return;
getEditor().nodeSet(instanceId, attrName, value);
}
void CDynamicMapClientEventForwarder::nodeInserted(const std::string& instanceId, const std::string& attrName, sint32 position,
const std::string& key, CObject* value)
{
//H_AUTO(R2_CDynamicMapClientEventForwarder_nodeInserted)
if (!getEditor().getMode() == CEditor::EditionMode) return;
getEditor().nodeInserted(instanceId, attrName, position, key, value);
}
void CDynamicMapClientEventForwarder::nodeMoved(
const std::string& instanceId, const std::string& attrName, sint32 position,
const std::string& destInstanceId, const std::string& destAttrName, sint32 destPosition)
{
//H_AUTO(R2_CDynamicMapClientEventForwarder_nodeMoved)
if (!getEditor().getMode() == CEditor::EditionMode) return;
getEditor().nodeMoved(instanceId, attrName, position, destInstanceId, destAttrName, destPosition);
}
void CDynamicMapClientEventForwarder::scenarioUpdated(CObject* highLevel, bool willTP, uint32 initialActIndex)
{
//H_AUTO(R2_CDynamicMapClientEventForwarder_scenarioUpdated)
if (!getEditor().getMode() == CEditor::EditionMode) return;
getEditor().scenarioUpdated(highLevel, willTP, initialActIndex);
}
void CDynamicMapClientEventForwarder::onEditionModeConnected( uint32 userSlotId, uint32 adventureId, CObject* highLevel, const std::string& versionName, bool willTP, uint32 initialActIndex )
{
//H_AUTO(R2_CDynamicMapClientEventForwarder_onEditionModeConnected)
getEditor().onEditionModeConnected(userSlotId, adventureId, highLevel, versionName, willTP, initialActIndex);
}
void CDynamicMapClientEventForwarder::onEditionModeDisconnected()
{
//H_AUTO(R2_CDynamicMapClientEventForwarder_onEditionModeDisconnected)
getEditor().onEditionModeDisconnected();
}
void CDynamicMapClientEventForwarder::onResetEditionMode()
{
//H_AUTO(R2_CDynamicMapClientEventForwarder_onResetEditionMode)
getEditor().onResetEditionMode();
}
void CDynamicMapClientEventForwarder::onTestModeConnected()
{
//H_AUTO(R2_CDynamicMapClientEventForwarder_onTestModeConnected)
getEditor().onTestModeConnected();
}
void CDynamicMapClientEventForwarder::onTestModeDisconnected(TSessionId sessionId, uint32 lastAct, TScenarioSessionType sessionType)
{
//H_AUTO(R2_CDynamicMapClientEventForwarder_onTestModeDisconnected)
getEditor().onTestModeDisconnected(sessionId, lastAct, sessionType);
}
void CDynamicMapClientEventForwarder::onAnimationModeConnected(const CClientMessageAdventureUserConnection& connected)
{
//H_AUTO(R2_CDynamicMapClientEventForwarder_onAnimationModeConnected)
getEditor().onAnimationModeConnected(connected);
}
// *********************************************************************************************************
CEditor::CEditor()
{
//H_AUTO(R2_CEditor_CEditor)
_SelectedInstance = NULL;
_FocusedInstance = NULL;
_Scenario = NULL;
_EnteredInSetSelectedInstance = false;
_DecalRefTime = 0;
_Initialized = false;
//vianney?? _LastUIModificationDate = 0;
_InstanceObserverHandleCounter = 0;
// module are initialized one time and never reconnected
_DMC = NULL;
_DMS = NULL;
_Mode = NotInitialized;
_AccessMode = AccessModeUnknown;
_SerializeUIConfig = true;
_LastAutoSaveTime = NLMISC::CTime::getLocalTime();// wait ClientCfg.R2EDAutoSaveWait
setForceDesktopReset(false);
CEditorCheck::EditorCreated = true;
_ClearingContent = false;
_Season = UnknownSeason;
_IsWaitingTPForSeasonChange = true;
_UpdatingScenario = false;
_WillTP = false;
_FixedLighting = false;
//
_ScenarioReceivedFlag = false;
_TPReceivedFlag = false;
_WaitScenarioScreenWanted = false;
_WaitScenarioScreenActive = false;
_NewScenario = NULL;
_NewScenarioInitialAct = 0;
_EditionModeDisconnectedFlag = true;
_PostponeScenarioUpdated = false;
_EntitySorter = NULL;
_MaxVisibleEntityExceededFlag = false;
}
// *********************************************************************************************************
void CEditor::setForceDesktopReset(bool force)
{
//H_AUTO(R2_CEditor_setForceDesktopReset)
CHECK_EDITOR
std::fill(_ForceDesktopReset, _ForceDesktopReset + sizeofarray(_ForceDesktopReset), force);
}
// *********************************************************************************************************
void CEditor::autoConfigInit(bool serverIsRingSession)
{
//H_AUTO(R2_CEditor_autoConfigInit)
// R2ED enabled ?
if (ClientCfg.R2EDEnabled)
{
// Editor and Animator (DM) modes
initModules(true);
TMode initialMode;
TAccessMode initialAccessMode;
switch (UserRoleInSession.getValue())
{
case R2::TUserRole::ur_editor:
initialMode = R2::CEditor::EditionMode;
initialAccessMode = R2::CEditor::AccessEditor;
break;
case R2::TUserRole::ur_animator:
initialMode = R2::CEditor::AnimationModeDm;
initialAccessMode = R2::CEditor::AccessDM;
break;
case R2::TUserRole::ur_outland_owner:
initialMode = R2::CEditor::AnimationModeDm;
initialAccessMode = R2::CEditor::AccessOutlandOwner;
break;
case R2::TUserRole::ur_player:
initialMode = R2::CEditor::AnimationModePlay;
// NOTE: I'm not sure if 'editor' is the right mode here - but I can't find anything better for now
// If I try 'AccessModeUnknown' the code asserts later on.
initialAccessMode = R2::CEditor::AccessEditor;
break;
default:
nlwarning( "Unexpected user role %u while editor enabled", (uint)(UserRoleInSession.getValue()) );
initialMode = R2::CEditor::EditionMode;
initialAccessMode = R2::CEditor::AccessEditor;
}
init(initialMode, initialAccessMode);
}
else
{
// Normal player and Ring player modes
ActionsContext.setContext("game");
if (serverIsRingSession)
initModules(false);
if (UserRoleInSession.getValue() != R2::TUserRole::ur_player)
nlwarning( "Unexpected user role %u while editor disabled", (uint)(UserRoleInSession.getValue()) );
}
}
// *********************************************************************************************************
void CEditor::autoConfigRelease(bool serverIsRingSession)
{
//H_AUTO(R2_CEditor_autoConfigRelease)
if (ClientCfg.R2EDEnabled)
{
R2::getEditor().release();
R2::getEditor().releaseModules();
}
else if (serverIsRingSession)
R2::getEditor().releaseModules();
}
// *********************************************************************************************************
void CEditor::initModules(bool connectDMC)
{
//H_AUTO(R2_CEditor_initModules)
CHECK_EDITOR
IModuleManager &mm = IModuleManager::getInstance();
IModule *gateway = mm.createModule("StandardGateway", "clientGw", "");
nlassert(gateway != NULL);
NLNET::IModuleSocket *socketClientGw = mm.getModuleSocket("clientGw");
nlassert(socketClientGw != NULL);
// connect the client gateway to the server
CCommandRegistry::getInstance().execute("clientGw.transportAdd FEClient fec", *InfoLog);
if (!ClientCfg.Local)
{
CCommandRegistry::getInstance().execute("clientGw.transportCmd fec(open)", *InfoLog);
}
if (ClientCfg.Local)
{
_DMS = new CDynamicMapService(ClientCfg.ConfigFile, socketClientGw);
_DMS->init();
}
else
{
_DMS = 0;
}
if (connectDMC)
_DMC = new CDynamicMapClientEventForwarder("Client0",socketClientGw, getLua().getStatePointer());
else
_DMC = new CDynamicMapClient("Client0",socketClientGw, getLua().getStatePointer());
_DMC->setInstantFeedBackFlag(true);
}
// *********************************************************************************************************
void CEditor::releaseModules()
{
//H_AUTO(R2_CEditor_releaseModules)
CHECK_EDITOR
delete _DMC; // must have a virtual destructor
if (ClientCfg.Local)
delete _DMS;
_DMC = NULL;
_DMS = NULL;
IModuleManager &mm = IModuleManager::getInstance();
NLNET::IModule* clientGw = mm.getLocalModule("clientGw");
if (clientGw)
{
mm.deleteModule(clientGw);
}
_Initialized = false;
}
// *********************************************************************************************************
void CEditor::inGameSelection(const CLFECOMMON::TCLEntityId &/* slot */)
{
//H_AUTO(R2_CEditor_inGameSelection)
switch(_Mode)
{
case DMMode:
case AnimationModeDm:
// reset current selection options
getEditor().callEnvMethod("updateAnimBarActions", 0);
getLua().push("");
getEditor().callEnvMethod("dssTarget", 1);
break;
default:
// no-op
break;
}
}
// *********************************************************************************************************
CEditor::~CEditor()
{
release();
}
// ***************************************************************
void CEditor::requestSetLocalNode(const std::string& instanceId, const std::string& attrName, const CObject *value)
{
//H_AUTO(R2_CEditor_requestSetLocalNode)
CHECK_EDITOR
CObject* obj = NULL;
{
CObject *src = _DMC->find(instanceId);
if (!src)
{
nlwarning("Can't find object with id %s", instanceId.c_str());
return;
}
if (!attrName.empty())
{
CObject *subObj = src->getAttr(attrName);
if (!subObj)
{
CObject * valueBase = (CObject *) getObject(src, attrName); // from Base
if (!valueBase)
{
nlwarning("Can't find attribute %s inside object (or is base) with InstanceId = %s", attrName.c_str(), instanceId.c_str());
return;
}
CObject *valueClone = valueBase->clone();
valueClone->setParent(0);
src->setObject(attrName, valueClone);
subObj = src->getAttr(attrName);
}
if (!subObj)
{
nlwarning("Can't find attribute %s inside object with InstanceId = %s", attrName.c_str(), instanceId.c_str());
return;
}
obj = subObj;
}
}
getDMC().getPropertyAccessor().shadowValue(obj, value->clone());
// trigger handlers
onAttrModified(obj);
}
// *****************************************
void CEditor::requestCommitLocalNode(const std::string& instanceId, const std::string& attrName)
{
//H_AUTO(R2_CEditor_requestCommitLocalNode)
CHECK_EDITOR
CObject *obj = _DMC->find(instanceId, attrName);
if (!obj)
{
nlwarning("(while calling requestSetLocalNode");
return;
}
//nlwarning("**** current unshadowed value");
//obj->dump();
/*
// when requestSetNode is called, the old value can't be retrieved because it will
// be erased by 'commitValue', so backup old value
CObject *oldValueBackup = obj->clone();
// send net request
getDMC().getPropertyAccessor().commitValue(obj);
getDMC().requestSetNode(instanceId, attrName, obj);
*/
CObject *localValue = getDMC().getPropertyAccessor().getShadowingValue(obj);
if (!localValue)
{
nlwarning("value is not shadowed : ");
obj->dump();
return;
}
CObject *localValueBackup = localValue->clone();
getDMC().getPropertyAccessor().rollbackValue(obj);
getDMC().requestSetNode(instanceId, attrName, localValueBackup);
}
// ***************************************************************
void CEditor::requestRollbackLocalNode(const std::string& instanceId, const std::string& attrName)
{
//H_AUTO(R2_CEditor_requestRollbackLocalNode)
CHECK_EDITOR
CObject *obj = _DMC->find(instanceId, attrName);
if (!obj)
{
nlwarning("(while calling requestSetLocalNode");
return;
}
getDMC().getPropertyAccessor().rollbackValue(obj);
// force the displayer to update their state from the shadowed value in place of the local value
onAttrModified(obj);
}
// ***************************************************************
CInterfaceManager &CEditor::getUI()
{
//H_AUTO(R2_CEditor_getUI)
CHECK_EDITOR
CInterfaceManager *im = CInterfaceManager::getInstance();
nlassert(im);
return *im;
}
// *********************************************************************************************************
CLuaState &CEditor::getLua()
{
//H_AUTO(R2_CEditor_getLua)
CHECK_EDITOR
CLuaState *ls = getUI().getLuaState();
nlassert(ls);
return *ls;
}
// *********************************************************************************************************
CLuaObject &CEditor::getEnv()
{
//H_AUTO(R2_CEditor_getEnv)
nlassert(_Env.isValid());
return _Env;
}
// *********************************************************************************************************
CLuaObject CEditor::getConfig()
{
//H_AUTO(R2_CEditor_getConfig)
CHECK_EDITOR
return getEnv()["Config"];
}
// *********************************************************************************************************
void CEditor::clearDebugWindow()
{
//H_AUTO(R2_CEditor_clearDebugWindow)
CHECK_EDITOR
getUI().flushDebugWindow();
CGroupList *gl = dynamic_cast<CGroupList *>(getUI().getElementFromId("ui:interface:debug_info:content:cb:text_list"));
if (gl)
{
gl->deleteAllChildren();
}
}
// *********************************************************************************************************
// callback to reload the editor when one of the config files changed
void CEditor::reloadEditorCallback(const std::string &filename)
{
//H_AUTO(R2_CEditor_reloadEditorCallback)
CHECK_EDITOR
ResetWanted = true;
if (nlstricmp(CFile::getExtension(filename), "xml") == 0 ||
nlstricmp(CFile::getExtension(filename), "uxt") == 0)
{
ReloadUIFlag = true;
}
}
// *********************************************************************************************************
void CEditor::setFixedLighting(bool enabled)
{
//H_AUTO(R2_CEditor_setFixedLighting)
if (_FixedLighting == enabled) return;
_FixedLighting = enabled;
LightCycleManager.touch();
}
// *********************************************************************************************************
int CEditor::luaGetSelectedInstanceId(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetSelectedInstanceId)
CHECK_EDITOR
if (!getEditor().getSelectedInstance())
{
ls.pushNil();
}
else
{
ls.push(toString(getEditor().getSelectedInstance()->getId()));
}
return 1;
}
void CEditor::setStartingAnimationFilename(const std::string& filename)
{
//H_AUTO(R2_CEditor_setStartingAnimationFilename)
_ScenarioToLoadWhenEntreringIntoAnimation = filename;
}
// *********************************************************************************************************
int CEditor::luaGetStartingAnimationFilename(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetStartingAnimationFilename)
ls.push( _ScenarioToLoadWhenEntreringIntoAnimation);
return 1;
}
// *********************************************************************************************************
int CEditor::luaSetSelectedInstanceId(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaSetSelectedInstanceId)
CHECK_EDITOR
CLuaIHM::checkArgCount(ls, "setSelectedInstance (method)", 2);
CLuaIHM::checkArgType(ls, "setSelectedInstance", 2, LUA_TSTRING);
if (strcmp(ls.toString(2), "") == 0)
{
getEditor().setSelectedInstance(NULL);
return 0;
}
CInstance *inst = getEditor().getInstanceFromId(ls.toString(2));
if (!inst)
{
nlwarning("setSelectedInstance : Instance with Id %s not found", ls.toString(2));
return 0;
}
if (!inst->getSelectableFromRoot())
{
nlwarning("Instance with id %s or one of its ancestor is not selectable", ls.toString(2));
return 0;
}
getEditor().setSelectedInstance(inst);
return 0;
}
// *********************************************************************************************************
int CEditor::luaSetCurrentTool(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaSetCurrentTool)
CHECK_EDITOR
CLuaIHM::check(ls, ls.getTop() == 2 || ls.getTop() == 3, "luaSetCurrentTool (method)");
CLuaIHM::checkArgType(ls, "setCurrentTool", 2, LUA_TSTRING);
if (ls.strlen(2) == 0)
{
getEditor().setCurrentTool(NULL);
}
else
{
CTool *tool = createObjectFromClassName<CTool>(ls.toString(2));
if (tool)
{
if (ls.getTop() == 3)
{
CLuaObject initParams(ls);
tool->init(initParams);
}
getEditor().setCurrentTool(tool);
}
}
return 0;
}
// *********************************************************************************************************
int CEditor::luaGetCurrentTool(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetCurrentTool)
CHECK_EDITOR
CLuaIHM::checkArgCount(ls, "getCurrentTool", 1); // 1 because of the method call
CLuaIHM::pushReflectableOnStack(ls, getEditor().getCurrentTool());
return 1;
}
// *********************************************************************************************************
int CEditor::luaGetSelectedInstance(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetSelectedInstance)
CHECK_EDITOR
if (!getEditor().getSelectedInstance())
{
ls.pushNil();
}
else
{
getEditor().projectInLua(getEditor().getSelectedInstance()->getObjectTable());
}
return 1;
}
// *********************************************************************************************************
int CEditor::luaGetInstanceFromId(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetInstanceFromId)
CHECK_EDITOR
const char *funcName = "getInstanceFromId";
CLuaIHM::checkArgCount(ls, funcName, 2);
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
CInstance *inst = getEditor().getInstanceFromId(ls.toString(2));
if (inst == NULL)
{
ls.pushNil();
return 1;
}
else
{
getEditor().projectInLua(inst->getObjectTable());
return 1;
}
return 0;
}
// ********************************************************************************************************
int CEditor::luaGetVisualPropertiesFromInstanceId(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetVisualPropertiesFromInstanceId)
const char *funcName = "getVisualPropertiesFromInstanceId";
CLuaIHM::checkArgCount(ls, funcName, 1);
CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING); // instance sheetClient
CInstance *inst = getEditor().getInstanceFromId(ls.toString(1));
if (!inst) { return 0; }
CObject *object = inst->getObjectTable();
if (!object) { return 0; }
SPropVisualA vA;
SPropVisualB vB;
SPropVisualC vC;
bool ok = getEditor().getVisualPropertiesFromObject(object, vA, vB, vC);
if (!ok)
{
return 0; //no param
}
uint64 uVPA = vA.get();
uint64 uVPB = vB.get();
uint64 uVPC = vC.get();
std::string strVPABC = NLMISC::toString( "VPA:%016.16"NL_I64"x\nVPB:%016.16"NL_I64"x\nVPC:%016.16"NL_I64"x", uVPA, uVPB, uVPC );
ls.push(strVPABC);
return 1; //3 string
}
// *********************************************************************************************************
int CEditor::luaDisplayContextMenu(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaDisplayContextMenu)
CHECK_EDITOR
CLuaIHM::checkArgCount(ls, "displayContextMenu", 1); // this is a method
getEditor().displayContextMenu();
return 0;
}
// *********************************************************************************************************
int CEditor::luaConnectAsCreator(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaConnectAsCreator)
CHECK_EDITOR
CLuaIHM::checkArgCount(ls, "connectAsCreator", 1); // this is a method
//getEditor().connectAsCreator();
return 0;
}
// *********************************************************************************************************
int CEditor::luaDofile(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaDofile)
CHECK_EDITOR
CLuaIHM::checkArgCount(ls, "doFile", 1);
CLuaIHM::checkArgType(ls, "doFile", 1, LUA_TSTRING);
getEditor().doLuaScript(ls.toString(-1), ls.toString(-1));
return 0;
}
// *********************************************************************************************************
int CEditor::luaTryFile(CLuaState &/* ls */)
{
//H_AUTO(R2_CEditor_luaTryFile)
/* CHECK_EDITOR
CLuaIHM::checkArgCount(ls, "doFile", 1);
CLuaIHM::checkArgType(ls, "doFile", 1, LUA_TSTRING);
getEditor().doLuaScript(ls.toString(-1), ls.toString(-1));*/
return 0;
}
// *********************************************************************************************************
int CEditor::luaSetEntityCustomSelectBox(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaSetEntityCustomSelectBox)
CHECK_EDITOR
CLuaIHM::checkArgCount(ls, "setEntityCustomSelectBox", 3); // 3 because of method call
CLuaIHM::checkArgType(ls, "setEntityCustomSelectBox", 2, LUA_TSTRING);
CLuaIHM::checkArgType(ls, "setEntityCustomSelectBox", 3, LUA_TTABLE);
std::string sheetName = ls.toString(2);
CEntityCustomSelectBox selectBox;
CLuaObject obj(ls);
selectBox.fromTable(obj);
TEntityCustomSelectBoxMap &boxMap = getEditor().getEntityCustomSelectBoxMap();
boxMap[sheetName] = selectBox;
/*
static volatile bool dumpMap = false;
if (dumpMap)
{
for (TEntityCustomSelectBoxMap::const_iterator watchIt = boxMap.begin(); watchIt != boxMap.end(); ++ watchIt)
{
nlwarning(watchIt->first.c_str());
}
}
*/
return 0;
}
// *********************************************************************************************************
int CEditor::luaGetEntityCustomSelectBox(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetEntityCustomSelectBox)
CHECK_EDITOR
CLuaIHM::checkArgCount(ls, "getEntityCustomSelectBox", 2); // 3 because of method call
CLuaIHM::checkArgType(ls, "getEntityCustomSelectBox", 2, LUA_TSTRING);
std::string sheetName = ls.toString(2);
TEntityCustomSelectBoxMap boxMap = getEditor().getEntityCustomSelectBoxMap();
if (boxMap.count(sheetName))
{
ls.newTable();
CLuaObject result(ls);
boxMap[sheetName].toTable(result);
result.push();
}
else
{
ls.pushNil();
}
return 1;
}
// *********************************************************************************************************
int CEditor::luaChoosePos(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaChoosePos)
CHECK_EDITOR
const char *funcName = "choosePos";
CLuaIHM::checkArgMin(ls, funcName, 5);
CLuaIHM::checkArgMax(ls, funcName, 10);
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
CLuaIHM::checkArgType(ls, funcName, 5, LUA_TSTRING);
std::string toolName = ls.toString(5);
std::string cursValid = "curs_create.tga";
std::string cursInvalid = "curs_stop.tga";
if (ls.getTop() >= 6)
{
CLuaIHM::checkArgType(ls, funcName, 6, LUA_TSTRING);
cursValid = ls.toString(6);
}
if (ls.getTop() >= 7)
{
CLuaIHM::checkArgType(ls, funcName, 7, LUA_TSTRING);
cursInvalid = ls.toString(7);
}
// method param 1 -> sheet id
// method param 2 -> ok function
// method param 3 -> cancel function
ls.pushValue(3);
CLuaObject validFunc(ls); // pop valid function
ls.pushValue(4);
CLuaObject cancelFunc(ls); // pop cancel function
//
sint ghostSlot;
if (ls.strlen(2) != 0)
{
CSheetId sheetId(ls.toString(2));
if (sheetId == CSheetId::Unknown)
{
nlwarning("Can't get sheet %s", ls.toString(2));
return 0;
}
ghostSlot = 1; // TMP TMP
if (!createEntity(ghostSlot, sheetId, CVector::Null, 0.f))
{
nlwarning("Cannot create entity for sheet %s", ls.toString(2));
return 0;
}
}
else
{
ghostSlot = -1; // no representation in scene
}
// additionnal polys displayed by the choose pos
std::vector<NLMISC::CPolygon2D> polys;
CPrimLook validLook;
CPrimLook invalidLook;
if (ls.getTop() >= 8)
{
CLuaStackRestorer lsr(&ls, ls.getTop());
CLuaIHM::checkArgType(ls, funcName, 8, LUA_TTABLE);
ls.pushValue(8);
CLuaObject poly;
poly.pop(ls);
ENUM_LUA_TABLE(poly, it)
{
NLMISC::CPolygon2D newPoly;
it.nextValue().push();
CLuaIHM::getPoly2DOnStack(ls, -1, newPoly);
ls.pop();
polys.push_back(newPoly);
}
}
if (ls.getTop() >= 9)
{
ls.pushValue(9);
CLuaObject look;
look.pop(ls);
validLook.init(look);
}
if (ls.getTop() >= 10)
{
ls.pushValue(10);
CLuaObject look;
look.pop(ls);
invalidLook.init(look);
}
//
getEditor().setCurrentTool(new CToolChoosePosLua(ghostSlot, validFunc, cancelFunc, toolName, cursValid, cursInvalid, polys, validLook, invalidLook));
return 0;
}
// *********************************************************************************************************
int CEditor::luaSnapPosToGround(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaSnapPosToGround)
CHECK_EDITOR
const char *funcName = "snapPosToGround";
CLuaIHM::checkArgCount(ls, funcName, 3);
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TNUMBER);
CLuaIHM::checkArgType(ls, funcName, 3, LUA_TNUMBER);
//
/*NLPACS::UGlobalPosition gpos = GR->retrievePosition(CVector((float) ls.toNumber(2), (float) ls.toNumber(3), 2000.f));
if (gpos.InstanceId != -1)
{
CVector snappedPos = GR->getGlobalPosition(gpos);
ls.push((double) snappedPos.x);
ls.push((double) snappedPos.y);
ls.push((double) snappedPos.z);
return 3;
}
else
{
// default z to 0
ls.push(0.f);
return 3;
}*/
// new algo : to avoid to snapping to a cliff, start from the approximate (valid) height found in the height map
CVector inter;
if (CTool::computeWorldMapIntersection((float) ls.toNumber(2), (float) ls.toNumber(3), inter) != CTool::NoIntersection)
{
ls.push((double) inter.x);
ls.push((double) inter.y);
ls.push((double) inter.z);
return 3;
}
else
{
// default z to 0
ls.push(0.f);
return 3;
}
}
// *********************************************************************************************************
int CEditor::luaGetUserEntityPosition(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetUserEntityPosition)
CHECK_EDITOR
const char *funcName = "getUserEntityPosition";
CLuaIHM::checkArgCount(ls, funcName, 1);
ls.push((double) UserEntity->pos().x);
ls.push((double) UserEntity->pos().y);
ls.push((double) UserEntity->pos().z);
return 3;
}
// *********************************************************************************************************
int CEditor::luaGetUserEntityFront(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetUserEntityFront)
CHECK_EDITOR
const char *funcName = "getUserEntityPosition";
CLuaIHM::checkArgCount(ls, funcName, 1);
ls.push((double) UserEntity->front().x);
ls.push((double) UserEntity->front().y);
return 2;
}
// *********************************************************************************************************
int CEditor::luaRequestSetLocalNode(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaRequestSetLocalNode)
CHECK_EDITOR
const char *funcName = "requestSetLocalNode";
CLuaIHM::checkArgCount(ls, funcName, 3);
CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
CObject *object = CComLuaModule::getObjectFromLua(ls.getStatePointer());
if (!object)
{
CLuaIHM::fails(ls, "%s : can't read object from parameter 3", funcName);
}
getEditor().requestSetLocalNode(ls.toString(1), ls.toString(2), object);
delete object;
return 0;
}
// *********************************************************************************************************
int CEditor::luaRequestCommitLocalNode(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaRequestCommitLocalNode)
CHECK_EDITOR
const char *funcName = "requestCommitLocalNode";
CLuaIHM::checkArgCount(ls, funcName, 2);
CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
getEditor().requestCommitLocalNode(ls.toString(1), ls.toString(2));
return 0;
}
// *********************************************************************************************************
int CEditor::luaRequestRollbackLocalNode(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaRequestRollbackLocalNode)
CHECK_EDITOR
const char *funcName = "requestRollbackLocalNode";
CLuaIHM::checkArgCount(ls, funcName, 2);
CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
getEditor().requestRollbackLocalNode(ls.toString(1), ls.toString(2));
return 0;
}
// *********************************************************************************************************
int CEditor::luaSetCurrentActFromId(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaSetCurrentActFromId)
CHECK_EDITOR
const char *funcName = "setCurrentActFromId";
CLuaIHM::checkArgCount(ls, funcName, 2); // this is a method
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
CInstance *act = getEditor().getInstanceFromId(ls.toString(2));
if (getEditor()._ClearingContent) { return 0; }
if (!act)
{
nlwarning("%s : act with id %s not found", funcName, ls.toString(1));
return 0;
}
if (!act->isKindOf("Act"))
{
nlwarning("%s : instance with id %s is not an act", funcName, ls.toString(1));
return 0;
}
getEditor().setCurrentAct(act);
return 0;
}
// *********************************************************************************************************
int CEditor::luaGetCurrentAct(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetCurrentAct)
CHECK_EDITOR
const char *funcName = "getCurrentAct";
CLuaIHM::checkArgCount(ls, funcName, 1); // this is a method
if (getEditor().getCurrentAct())
{
getEditor().projectInLua(getEditor().getCurrentAct()->getObjectTable());
}
else
{
ls.pushNil();
}
return 1;
}
// *********************************************************************************************************
int CEditor::luaGenInstanceName(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGenInstanceName)
CHECK_EDITOR
const char *funcName = "genInstanceName";
CLuaIHM::checkArgCount(ls, funcName, 2); // this is a method
CLuaIHM::checkArgTypeUCString(ls, funcName, 2); // name
ucstring baseName;
nlverify(CLuaIHM::getUCStringOnStack(ls, 2, baseName));
CLuaIHM::push(ls, getEditor().genInstanceName(baseName));
return 1;
}
// *********************************************************************************************************
int CEditor::luaIsPostFixedByNumber(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaIsPostFixedByNumber)
CHECK_EDITOR
const char *funcName = "isPostFixedByNumber";
CLuaIHM::checkArgCount(ls, funcName, 2); // this is a method
CLuaIHM::checkArgTypeUCString(ls, funcName, 2); // name
ucstring baseName;
nlverify(CLuaIHM::getUCStringOnStack(ls, 2, baseName));
ls.push(getEditor().isPostFixedByNumber(baseName));
return 1;
}
// *********************************************************************************************************
int CEditor::luaIsClearingContent(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaIsPostFixedByNumber)
CHECK_EDITOR
const char *funcName = "isClearingContent";
CLuaIHM::checkArgCount(ls, funcName, 1); // this is a method
ls.push(getEditor().isClearingContent());
return 1;
}
// *********************************************************************************************************
int CEditor::luaSetCookie(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaSetCookie)
CHECK_EDITOR
const char *funcName = "setCookie";
CLuaIHM::checkArgCount(ls, funcName, 4); // this is a method (self + 3 params)
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING); // instance id
CLuaIHM::checkArgType(ls, funcName, 3, LUA_TSTRING); // key
// last parameters may have any type
CLuaObject value(ls); // pop it
getEditor().setCookie(ls.toString(2), ls.toString(3), value);
return 0;
}
// *********************************************************************************************************
int CEditor::luaIsCreature(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaIsCreature)
CHECK_EDITOR
const char *funcName = "isCreature";
CLuaIHM::checkArgCount(ls, funcName, 1);
CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING); // instance sheetClient
CInstance *inst = getEditor().getInstanceFromId(ls.toString(1));
if (!inst) return 0;
const CCharacterSheet *sheet = dynamic_cast<const CCharacterSheet *>(SheetMngr.get(NLMISC::CSheetId(inst->getSheet())));
if (!sheet) return 0;
bool isNPC = sheet->Race < EGSPD::CPeople::Creature;
// neither NPC, not Kami, nor Karavan
bool creature = !(isNPC || (!isNPC && (sheet->Race==EGSPD::CPeople::Kami || sheet->Race==EGSPD::CPeople::Karavan)));
ls.push(creature);
return 1;
}
// *********************************************************************************************************
int CEditor::luaSetEditorSeason(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaSetEditorSeason)
CHECK_EDITOR
const char *funcName = "setEditorSeason";
if (getEditor().getMode() != CEditor::EditionMode
&& getEditor().getMode() != CEditor::AnimationModeLoading )
{
CLuaIHM::fails(ls, "%s : cannot set weather value outside of edit mode", funcName);
}
CLuaIHM::checkArgCount(ls, funcName, 2);
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING); // this is a method (self + 1 param)
if (strcmp(ls.toString(2), "Automatic") == 0) getEditor()._Season = Automatic;
else if (strcmp(ls.toString(2), "Spring") == 0) getEditor()._Season = Spring;
else if (strcmp(ls.toString(2), "Summer") == 0) getEditor()._Season = Summer;
else if (strcmp(ls.toString(2), "Autumn") == 0) getEditor()._Season = Autumn;
else if (strcmp(ls.toString(2), "Winter") == 0) getEditor()._Season = Winter;
else CLuaIHM::fails(ls, "%s, invalid season name : %s", ls.toString(2));
// If season is changed while scenario is being received, we do not have received the tp command yet,
// so signal the weather system that the season should not be changed for now
if ((getEditor()._UpdatingScenario && getEditor()._WillTP)
|| getEditor().getMode() != CEditor::AnimationModeLoading )
{
getEditor()._IsWaitingTPForSeasonChange = true;
}
else
{
getEditor()._IsWaitingTPForSeasonChange = false;
}
return 0;
}
// *********************************************************************************************************
int CEditor::luaSetFixedLighting(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaSetFixedLighting)
const char *funcName = "setEditorSeason";
CLuaIHM::checkArgCount(ls, funcName, 2);
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TBOOLEAN); // this is a method (self + 1 param)
getEditor().setFixedLighting(ls.toBoolean(2));
return 0;
}
// *********************************************************************************************************
int CEditor::luaGetFixedLighting(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetFixedLighting)
const char *funcName = "getEditorSeason";
CLuaIHM::checkArgCount(ls, funcName, 1); // this is a method
ls.push(getEditor().getFixedLighting());
return 1;
}
// *********************************************************************************************************
int CEditor::luaSetPlotItemInfos(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaSetPlotItemInfos)
const char *funcName = "setPlotItemInfos";
CLuaIHM::checkArgCount(ls, funcName, 5); // a method with 4 args
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TNUMBER);
CLuaIHM::checkArgTypeUCString(ls, funcName, 3);
CLuaIHM::checkArgTypeUCString(ls, funcName, 4);
CLuaIHM::checkArgTypeUCString(ls, funcName, 5);
CItemSheet *item = dynamic_cast<CItemSheet *>(SheetMngr.get(CSheetId((uint32) ls.toNumber(2))));
if (!item || item->Family != ITEMFAMILY::SCROLL_R2)
{
CLuaIHM::fails(ls, "%s : bad sheet, r2 plot item required", funcName);
}
R2::TMissionItem mi;
mi.SheetId = (uint32) ls.toNumber(2);
CLuaIHM::getUCStringOnStack(ls, 3, mi.Name);
CLuaIHM::getUCStringOnStack(ls, 4, mi.Description);
CLuaIHM::getUCStringOnStack(ls, 5, mi.Comment);
getEditor().setPlotItemInfos(mi);
return 0;
}
// *********************************************************************************************************
int CEditor::luaIsCurrentSelectionPlayer(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaIsCurrentSelectionPlayer)
const char *funcName = "isCurrentSelectionPlayer";
CLuaIHM::checkArgCount(ls, funcName, 1); // method with 0 args
CPlayerCL *player = dynamic_cast<CPlayerCL *>(EntitiesMngr.entity(UserEntity->getTargetSlotNoLag()));
ls.push(player != NULL);
return 1;
}
// *********************************************************************************************************
int CEditor::luaFindEmptyPlace(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaFindEmptyPlace)
const char *funcName = "findEmptyPlace";
CLuaIHM::checkArgCount(ls, funcName, 3); // method with 2 args
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TNUMBER);
CLuaIHM::checkArgType(ls, funcName, 3, LUA_TNUMBER);
CVector result;
if (getEditor().getIslandCollision().findEmptyPlace(CVector2f((float) ls.toNumber(2), (float) ls.toNumber(3)), result))
{
ls.push(result.x);
ls.push(result.y);
ls.push(result.z);
return 3;
}
return 0;
}
// *********************************************************************************************************
int CEditor::luaIsInIslandRect(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaIsInIslandRect)
const char *funcName = "isInIslandRect";
CLuaIHM::checkArgCount(ls, funcName, 3); // method with 2 args
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TNUMBER);
CLuaIHM::checkArgType(ls, funcName, 3, LUA_TNUMBER);
const R2::CScenarioEntryPoints::CCompleteIsland *island = getEditor().getIslandCollision().getCurrIslandDesc();
if (!island)
{
ls.push(true);
return 1;
}
float x = (float) ls.toNumber(2);
float y = (float) ls.toNumber(3);
ls.push(x >= island->XMin && y >= island->YMin &&
x <= island->XMax && y <= island->YMax);
return 1;
}
// *********************************************************************************************************
int CEditor::luaGetCurrentIslandName(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetCurrentIslandName)
const char *funcName = "getCurrentIslandName";
CLuaIHM::checkArgCount(ls, funcName, 1); // method with no args
R2::CScenarioEntryPoints::CCompleteIsland *ci = getEditor().getIslandCollision().getCurrIslandDesc();
ls.push(ci ? ci->Island.c_str() : "");
return 1;
}
// *********************************************************************************************************
int CEditor::luaKickCharacter(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaKickCharacter)
const char *funcName = "kickCharacter";
CLuaIHM::checkArgCount(ls, funcName, 2); // this is a method (self + 1 params)
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TNUMBER);
CSessionBrowserImpl &sb = CSessionBrowserImpl::getInstance();
sb.kickCharacter(sb.getCharId(), R2::getEditor().getDMC().getEditionModule().getCurrentAdventureId(),
(uint32)ls.toNumber(2));
if(!sb.waitOneMessage(sb.getMessageName("on_invokeResult")))
nlwarning("kickCharacter callback return false");
return 0;
}
// *********************************************************************************************************
int CEditor::luaUnkickCharacter(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaUnkickCharacter)
const char *funcName = "unkickCharacter";
CLuaIHM::checkArgCount(ls, funcName, 2); // this is a method (self + 1 params)
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TNUMBER);
CSessionBrowserImpl &sb = CSessionBrowserImpl::getInstance();
sb.unkickCharacter(sb.getCharId(), R2::getEditor().getDMC().getEditionModule().getCurrentAdventureId(),
(uint32)ls.toNumber(2));
if(!sb.waitOneMessage(sb.getMessageName("on_invokeResult")))
nlwarning("unkickCharacter callback return false");
return 0;
}
// *********************************************************************************************************
int CEditor::luaTeleportToCharacter(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaTeleportToCharacter)
const char *funcName = "teleportToCharacter";
CLuaIHM::checkArgCount(ls, funcName, 2); // this is a method (self + 1 params)
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TNUMBER);
CClientEditionModule & cem = R2::getEditor().getDMC().getEditionModule();
cem.requestTeleportOneCharacterToAnother(cem.getCurrentAdventureId(), CSessionBrowserImpl::getInstance().getCharId(),
(uint32)ls.toNumber(2));
return 0;
}
// *********************************************************************************************************
int CEditor::luaWaitScenarioScreen(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaWaitScenarioScreen)
const char *funcName = "waitScenarioScreen";
CLuaIHM::checkArgCount(ls, funcName, 1); // method with no args
if (!ClientCfg.Local)
{
getEditor()._WaitScenarioScreenWanted = true;
}
return 0;
}
// *********************************************************************************************************
int CEditor::luaIsScenarioUpdating(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaIsScenarioUpdating)
const char *funcName = "isScenarioUpdating";
CLuaIHM::checkArgCount(ls, funcName, 1); // method with no args
ls.push( (double)getEditor()._UpdatingScenario );
return 1;
}
/*
// *********************************************************************************************************
int CEditor::luaIsValidPoly(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaIsValidPoly)
const char *funcName = "isValidPoly";
CLuaIHM::checkArgCount(ls, funcName, 2); // method with no args
CLuaIHM::checkArgType(ls, funcName, 3, LUA_TTABLE); // method with no args
ls.pushValue(3);
CLuaObject poly;
NLMISC::CPolygon2D poly2D;
poly.pop(luaState);
ENUM_LUA_TABLE(table, it)
{
NLMISC::CVector2f pos;
if (!CLuaIHM::pop(ls, pos))
{
CLuaIHM::fails(ls, "%s expects CVector2f for poly coordinates);
}
poly2D.Vertices.push_back(pos);
}
ls.push(getEditor().getIslandCollision().isValidPoly(poly2D);
return 1;
}
// *********************************************************************************************************
int CEditor::luaIsValidPosition(CLuaState &ls)
{
CHECK_EDITOR
const char *funcName = "snapPosToGround";
CLuaIHM::checkArgCount(ls, funcName, 3);
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TNUMBER);
CLuaIHM::checkArgType(ls, funcName, 3, LUA_TNUMBER);
//
/*NLPACS::UGlobalPosition gpos = GR->retrievePosition(CVector((float) ls.toNumber(2), (float) ls.toNumber(3), 2000.f));
if (gpos.InstanceId != -1)
{
CVector snappedPos = GR->getGlobalPosition(gpos);
ls.push((double) snappedPos.x);
ls.push((double) snappedPos.y);
ls.push((double) snappedPos.z);
return 3;
}
else
{
// default z to 0
ls.push(0.f);
return 3;
}
// new algo : to avoid to snapping to a cliff, start from the approximate (valid) height found in the height map
CVector inter;
if (CTool::computeWorldMapIntersection((float) ls.toNumber(2), (float) ls.toNumber(3), inter) != CTool::NoIntersection)
{
ls.push((double) inter.x);
ls.push((double) inter.y);
ls.push((double) inter.z);
}
*/
// *********************************************************************************************************
int CEditor::luaCanUndo(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaCanUndo)
const char *funcName = "canUndo";
CLuaIHM::checkArgCount(ls, funcName, 1); // method with no args
ls.push(getEditor().getDMC().getActionHistoric().canUndo());
return 1;
}
// *********************************************************************************************************
int CEditor::luaCanRedo(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaCanRedo)
const char *funcName = "canRedo";
CLuaIHM::checkArgCount(ls, funcName, 1); // method with no args
ls.push(getEditor().getDMC().getActionHistoric().canRedo());
return 1;
}
// *********************************************************************************************************
int CEditor::luaGetUserEntityName(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaGetUserEntityName)
const char *funcName = "getUserEntityName";
CLuaIHM::checkArgCount(ls, funcName, 1); // this is a method
if (UserEntity)
{
ucstring name = UserEntity->getEntityName()+PlayerSelectedHomeShardNameWithParenthesis;
ls.push( std::string( name.toUtf8() ) );
}
else
{
ls.push(std::string(""));
}
return 1;
}
static CLuaString lstr_Next("next");
// *********************************************************************************************************
int CEditor::luaEnumInstances(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaEnumInstances)
CLuaStackChecker lsc(&ls, 1);
// return an enumerator that allows to iterate over instance, by kind
const char *funcName = "enumInstances";
CLuaIHM::checkArgCount(ls, funcName, 2); // method with no args
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
struct CInstanceEnumerator
{
CSortedInstances *InstMap;
TInstanceByName::iterator Current;
static int next(CLuaState &ls)
{
const char *funcName = "InstanceEnumerator:next";
CLuaIHM::checkArgCount(ls, funcName, 1);
CLuaIHM::checkArgType(ls, funcName, 1, LUA_TUSERDATA);
CInstanceEnumerator *ie = (CInstanceEnumerator *) ls.toUserData(1);
CEditor &ed = getEditor();
while(ie->Current != ie->InstMap->end())
{
CInstance *inst = ie->Current->second;
if (!inst->getGhost())
{
// object must be in current act or base act
CInstance *parentAct = inst->getParentAct();
if (!parentAct || parentAct == ed.getCurrentAct() || parentAct == ed.getBaseAct())
{
inst->getLuaProjection().push();
++ ie->Current;
return 1;
}
}
++ ie->Current;
}
return 0;
}
//
static int gc(CLuaState &ls)
{
const char *funcName = "InstanceEnumerator:next";
CLuaIHM::checkArgCount(ls, funcName, 1);
CLuaIHM::checkArgType(ls, funcName, 1, LUA_TUSERDATA);
CInstanceEnumerator *ie = (CInstanceEnumerator *) ls.toUserData(1);
ie->~CInstanceEnumerator(); // no real effect for now...
return 0;
}
static int index(CLuaState &ls)
{
const char *funcName = "InstanceEnumerator.__index";
CLuaIHM::checkArgCount(ls, funcName, 2);
CLuaIHM::checkArgType(ls, funcName, 1, LUA_TUSERDATA);
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
if (ls.toString(2) == lstr_Next)
{
ls.push(CInstanceEnumerator::next);
return 1;
}
return 0;
}
};
sint classIndex = getEditor().classToIndex(ls.toString(2));
if (classIndex < 0)
{
CLuaIHM::fails(ls, "Trying to iterate over unknown class : %s", ls.toString(2));
}
ls.newTable();
CLuaObject mt;
mt.pop(ls);
ls.push(CInstanceEnumerator::index);
mt.setValue("__index", CLuaObject(ls));
ls.push(CInstanceEnumerator::gc);
mt.setValue("__gc", CLuaObject(ls));
//
void *newIter = ls.newUserData(sizeof(CInstanceEnumerator));
CInstanceEnumerator *ie = new (newIter) CInstanceEnumerator;
ie->InstMap = &getEditor()._InstancesByDispName[classIndex];
ie->Current = ie->InstMap->begin();
mt.push();
ls.setMetaTable(-2);
//
return 1;
}
// *********************************************************************************************************
void CEditor::waitScenarioScreen()
{
//H_AUTO(R2_CEditor_waitScenarioScreen)
if (ClientCfg.Local) return;
if (_Mode==EditionMode)
{
setMode(GoingToEditionMode);
}
getUI().hideAllWindows();
CInterfaceGroup *waitScreen = dynamic_cast<CInterfaceGroup *>(getUI().getElementFromId("ui:interface:r2ed_connecting"));
if (waitScreen)
{
waitScreen->setActive(true);
getUI().setTopWindow(waitScreen);
}
//
enum TState { WaitingScenario, WaitingTP, DoExit };
TState state = WaitingScenario;
//
getEditor()._ScenarioReceivedFlag = false;
getEditor()._TPReceivedFlag = false;
bool firewallTimeout = false;
//
ActionsContext.setContext("waiting_network");
TGameCycle serverTick = NetMngr.getCurrentServerTick();
getUI().setCaptureKeyboard(NULL);
getUI().setDefaultCaptureKeyboard(NULL);
loadBackgroundBitmap (StartBackground);
// patch for the 'sys info that pop' prb (cause unknown for now ...)
CInterfaceElement *sysInfo = getUI().getElementFromId("ui:interface:system_info");
bool sysInfoActive = false;
if (sysInfo) sysInfoActive = sysInfo->getActive();
for (;;)
{
switch(state)
{
case WaitingScenario:
if (getEditor()._ScenarioReceivedFlag)
{
if (getEditor()._WillTP)
{
state = WaitingTP;
}
else
{
state = DoExit;
}
}
break;
case WaitingTP:
// no-op
break;
default:
nlassert(0);
break;
}
if (state == DoExit)
{
break;
}
// Update network.
try
{
if ( ! firewallTimeout )
NetMngr.update();
}
catch ( EBlockedByFirewall& )
{
if ( NetMngr.getConnectionState() == CNetManager::Disconnect )
{
firewallTimeout = true;
}
else
{
// Display the firewall alert string
CViewText *pVT = dynamic_cast<CViewText*>(getUI().getElementFromId("ui:interface:r2ed_connecting:title"));
if (pVT != NULL)
pVT->setText(CI18N::get("uiFirewallAlert")+ucstring("..."));
// The mouse and fullscreen mode should be unlocked for the user to set the firewall permission
nlSleep( 30 ); // 'nice' the client, and prevent to make too many send attempts
}
}
CCDBNodeBranch::flushObserversCalls();
// check if we can send another dated block
if (NetMngr.getCurrentServerTick() != serverTick)
{
//
serverTick = NetMngr.getCurrentServerTick();
NetMngr.send(serverTick);
}
else
{
// Send dummy info
NetMngr.send();
}
// update module manager
NLNET::IModuleManager::getInstance().updateModules();
// Update the DT T0 and T1 global variables
updateClientTime();
CInputHandlerManager::getInstance()->pumpEvents();
Driver->clearBuffers(CRGBA::Black);
Driver->setMatrixMode2D11();
drawLoadingBitmap (1);
if ( state==WaitingTP && getEditor()._TPReceivedFlag)
{
break; // don't want an additionnal swap buffer here, so exit now (the loading bitmap is good,
// has just been reloaded by the tp screen...
}
// Interface handling & displaying (processes clicks...)
getUI().updateFrameEvents();
if (waitScreen)
{
getUI().setTopWindow(waitScreen);
}
if (sysInfo) sysInfo->setActive(false);
getUI().updateFrameViews(NULL);
CCDBNodeBranch::flushObserversCalls();
// Movie shooter
globalMenuMovieShooter();
// Force the client to sleep a bit.
if(ClientCfg.Sleep >= 0)
{
nlSleep(ClientCfg.Sleep);
}
//
if (!waitScreen)
{
TextContext->setShaded(true);
TextContext->setFontSize(40);
TextContext->setColor(CRGBA::White);
// TOP LEFT //
//----------//
TextContext->setHotSpot(NL3D::UTextContext::MiddleMiddle);
TextContext->printfAt(0.5f, 0.5f, "(UI NOT FOUND) Waiting scenario from server.");
}
// Display
Driver->swapBuffers();
//
if (NetMngr.getConnectionState() == CNetManager::Disconnect)
{
if ( firewallTimeout )
{
// Display the firewall error string instead of the normal failure string
CViewText *pVT = dynamic_cast<CViewText*>(getUI().getElementFromId("ui:interface:r2ed_connecting:title"));
if (pVT != NULL)
{
pVT->setMultiLine( true );
pVT->setText(CI18N::get("uiFirewallFail")+ucstring(".\n")+
CI18N::get("uiFirewallAlert")+ucstring("."));
}
}
}
}
if (sysInfo) sysInfo->setActive(sysInfoActive);
destroyLoadingBitmap ();
if (_Mode == GoingToEditionMode)
{
setMode(EditionMode);
}
return;
}
// *********************************************************************************************************
// lua instance observer
class CInstanceObserverLua : public CEditor::IInstanceObserver
{
public:
CInstanceObserverLua(CLuaObject &receiver);
~CInstanceObserverLua();
CLuaObject &getReceiver() { return _Receiver; }
// from IInstanceObserver
virtual void onInstanceCreated(CInstance &instance);
virtual void onInstanceErased(CInstance &instance);
virtual void onInstancePreHrcMove(CInstance &instance);
virtual void onInstancePostHrcMove(CInstance &instance);
virtual void onPreHrcMove(CInstance &instance);
virtual void onPostHrcMove(CInstance &instance);
virtual void onAttrModified(CInstance &instance, const std::string &attrName, sint32 attrIndex);
private:
CLuaObject _Receiver; // table that will receive the notifications
static uint _Count;
};
uint CInstanceObserverLua::_Count = 0;
CInstanceObserverLua::CInstanceObserverLua(CLuaObject &receiver) : _Receiver(receiver)
{
++ _Count;
}
CInstanceObserverLua::~CInstanceObserverLua()
{
#ifdef NL_DEBUG
nlassert(!getEditor().isInstanceObserver(this));
#endif
nlassert(_Count >= 0);
-- _Count;
}
void CInstanceObserverLua::onInstanceCreated(CInstance &instance)
{
//H_AUTO(R2_CInstanceObserverLua_onInstanceCreated)
nlassert(_Receiver.isValid());
if (_Receiver["onInstanceCreated"].isNil()) return; // no-op if not handled
getEditor().projectInLua(instance.getObjectTable());
_Receiver.callMethodByNameNoThrow("onInstanceCreated", 1, 0);
}
void CInstanceObserverLua::onInstanceErased(CInstance &instance)
{
//H_AUTO(R2_CInstanceObserverLua_onInstanceErased)
nlassert(_Receiver.isValid());
if (_Receiver["onInstanceErased"].isNil()) return; // no-op if not handled
getEditor().projectInLua(instance.getObjectTable());
_Receiver.callMethodByNameNoThrow("onInstanceErased", 1, 0);
}
void CInstanceObserverLua::onInstancePreHrcMove(CInstance &instance)
{
//H_AUTO(R2_CInstanceObserverLua_onInstancePreHrcMove)
nlassert(_Receiver.isValid());
if (_Receiver["onInstanceCreated"].isNil()) return; // no-op if not handled
getEditor().projectInLua(instance.getObjectTable());
_Receiver.callMethodByNameNoThrow("onInstancePreHrcMove", 1, 0);
}
void CInstanceObserverLua::onInstancePostHrcMove(CInstance &instance)
{
//H_AUTO(R2_CInstanceObserverLua_onInstancePostHrcMove)
nlassert(_Receiver.isValid());
if (_Receiver["onInstanceCreated"].isNil()) return; // no-op if not handled
getEditor().projectInLua(instance.getObjectTable());
_Receiver.callMethodByNameNoThrow("onInstancePostHrcMove", 1, 0);
}
void CInstanceObserverLua::onPreHrcMove(CInstance &instance)
{
//H_AUTO(R2_CInstanceObserverLua_onPreHrcMove)
nlassert(_Receiver.isValid());
if (_Receiver["onPreHrcMove"].isNil()) return; // no-op if not handled
getEditor().projectInLua(instance.getObjectTable());
_Receiver.callMethodByNameNoThrow("onPreHrcMove", 1, 0);
}
void CInstanceObserverLua::onPostHrcMove(CInstance &instance)
{
//H_AUTO(R2_CInstanceObserverLua_onPostHrcMove)
nlassert(_Receiver.isValid());
if (_Receiver["onPostHrcMove"].isNil()) return; // no-op if not handled
getEditor().projectInLua(instance.getObjectTable());
_Receiver.callMethodByNameNoThrow("onPostHrcMove", 1, 0);
}
void CInstanceObserverLua::onAttrModified(CInstance &instance, const std::string &attrName, sint32 attrIndex)
{
//H_AUTO(R2_CInstanceObserverLua_onAttrModified)
nlassert(_Receiver.isValid());
if (_Receiver["onAttrModified"].isNil()) return; // no-op if not handled
getEditor().projectInLua(instance.getObjectTable());
getEditor().getLua().push(attrName);
getEditor().getLua().push((double) attrIndex);
_Receiver.callMethodByNameNoThrow("onAttrModified", 3, 0);
}
// *********************************************************************************************************
int CEditor::luaAddInstanceObserver(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaAddInstanceObserver)
CHECK_EDITOR
const char *funcName = "addInstanceObserver";
CLuaIHM::checkArgCount(ls, funcName, 3); // this is a method (self + 2 params)
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING); // instance id
CLuaIHM::checkArgType(ls, funcName, 3, LUA_TTABLE); // receiver
CLuaObject receiver(ls); // pop the receiver
ls.push((double) getEditor().addInstanceObserver(ls.toString(2), new CInstanceObserverLua(receiver)));
return 1;
}
// *********************************************************************************************************
int CEditor::luaRemoveInstanceObserver(CLuaState &ls)
{
//H_AUTO(R2_CEditor_luaRemoveInstanceObserver)
CHECK_EDITOR
const char *funcName = "removeInstanceObserver";
CLuaIHM::checkArgCount(ls, funcName, 2); // this is a method (self + 1 params)
CLuaIHM::checkArgType(ls, funcName, 2, LUA_TNUMBER); // instance id
IInstanceObserver *observer = getEditor().getInstanceObserver((TInstanceObserverHandle) ls.toNumber(2));
if (observer == NULL)
{
CLuaIHM::fails(ls, "Instance observer not found for handle = %d", (int) ls.toNumber(2));
}
CInstanceObserverLua *luaObserver = dynamic_cast<CInstanceObserverLua *>(observer);
if (luaObserver == NULL)
{
CLuaIHM::fails(ls, "Instance observer found for handle %d, but has bad type, it wasn't registered from lua.", (int) ls.toNumber(2));
}
getEditor().removeInstanceObserver((TInstanceObserverHandle) ls.toNumber(2));
CLuaObject receiver = luaObserver->getReceiver();
delete luaObserver;
receiver.push();
return 1;
}
// *********************************************************************************************************
bool CEditor::isInstanceObserver(IInstanceObserver *observer) const
{
//H_AUTO(R2_CEditor_isInstanceObserver)
for(TInstanceObserverMap::const_iterator it = _InstanceObservers.begin(); it != _InstanceObservers.end(); ++it)
{
if (it->second == observer) return true;
}
return false;
}
// *********************************************************************************************************
const CObjectTable *CEditor::getObjectTableFromId(const TInstanceId &id) const
{
//H_AUTO(R2_CEditor_getObjectTableFromId)
CHECK_EDITOR
nlassert(_DMC);
const CObject *obj = _DMC->find(id);
if (!obj) return NULL;
nlassert(obj->isTable());
return (CObjectTable *) obj;
}
// *********************************************************************************************************
CInstance *CEditor::getInstanceFromObject(const CObject *obj) const
{
//H_AUTO(R2_CEditor_getInstanceFromObject)
CHECK_EDITOR
if (!obj->isTable()) return NULL;
TInstanceMap::const_iterator it = _Instances.find((CObjectTable *) obj);
if (it != _Instances.end())
{
return it->second;
}
return NULL;
}
// *********************************************************************************************************
void CEditor::registerEnvMethod(const char *name,TLuaWrappedFunction func)
{
//H_AUTO(R2_CEditor_registerEnvMethod)
CHECK_EDITOR
nlassert(name);
getEnv().setValue(name, func);
}
// *********************************************************************************************************
void CEditor::registerEnvFunction(const char *name, TLuaWrappedFunction func)
{
//H_AUTO(R2_CEditor_registerEnvFunction)
CHECK_EDITOR
nlassert(name);
getEnv().setValue(name, func);
}
// *********************************************************************************************************
void CEditor::registerLuaFunc()
{
//H_AUTO(R2_CEditor_registerLuaFunc)
CHECK_EDITOR
registerEnvMethod("getSelectedInstanceId", luaGetSelectedInstanceId);
registerEnvMethod("setSelectedInstanceId", luaSetSelectedInstanceId);
registerEnvMethod("setCurrentTool", luaSetCurrentTool);
registerEnvMethod("getCurrentTool", luaGetCurrentTool);
registerEnvMethod("getVisualPropertiesFromInstanceId", luaGetVisualPropertiesFromInstanceId);
registerEnvMethod("getInstanceFromId", luaGetInstanceFromId);
registerEnvMethod("displayContextMenu", luaDisplayContextMenu);
registerEnvMethod("getSelectedInstance", luaGetSelectedInstance);
registerEnvMethod("connectAsCreator", luaConnectAsCreator);
registerEnvMethod("doFile", luaDofile);
registerEnvMethod("tryFile", luaTryFile);
registerEnvMethod("setEntityCustomSelectBox", luaSetEntityCustomSelectBox);
registerEnvMethod("getEntityCustomSelectBox", luaGetEntityCustomSelectBox);
registerEnvMethod("choosePos", luaChoosePos);
registerEnvMethod("snapPosToGround", luaSnapPosToGround);
registerEnvMethod("getUserEntityPosition", luaGetUserEntityPosition);
registerEnvMethod("getUserEntityFront", luaGetUserEntityFront);
registerEnvMethod("setCurrentActFromId", luaSetCurrentActFromId);
registerEnvMethod("getCurrentAct", luaGetCurrentAct);
registerEnvMethod("genInstanceName", luaGenInstanceName);
registerEnvMethod("isPostFixedByNumber", luaIsPostFixedByNumber);
registerEnvMethod("setCookie", luaSetCookie);
registerEnvMethod("addInstanceObserver", luaAddInstanceObserver);
registerEnvMethod("removeInstanceObserver", luaRemoveInstanceObserver);
registerEnvFunction("requestSetLocalNode", luaRequestSetLocalNode);
registerEnvFunction("requestCommitLocalNode", luaRequestCommitLocalNode);
registerEnvFunction("requestRollbackLocalNode", luaRequestRollbackLocalNode);
registerEnvMethod("isCreature", luaIsCreature);
registerEnvMethod("setEditorSeason", luaSetEditorSeason);
registerEnvMethod("setFixedLighting", luaSetFixedLighting);
registerEnvMethod("getFixedLighting", luaGetFixedLighting);
registerEnvMethod("setPlotItemInfos", luaSetPlotItemInfos);
registerEnvMethod("isCurrentSelectionPlayer", luaIsCurrentSelectionPlayer);
registerEnvMethod("findEmptyPlace", luaFindEmptyPlace);
registerEnvMethod("isInIslandRect", luaIsInIslandRect);
registerEnvMethod("getCurrentIslandName", luaGetCurrentIslandName);
registerEnvMethod("waitScenarioScreen", luaWaitScenarioScreen);
registerEnvMethod("isScenarioUpdating", luaIsScenarioUpdating);
registerEnvMethod("canUndo", luaCanUndo);
registerEnvMethod("canRedo", luaCanRedo);
registerEnvMethod("getUserEntityName", luaGetUserEntityName);
registerEnvMethod("getStartingAnimationFilename", luaGetStartingAnimationFilename);
registerEnvMethod("kickCharacter", luaKickCharacter);
registerEnvMethod("unkickCharacter", luaUnkickCharacter);
registerEnvMethod("teleportToCharacter", luaTeleportToCharacter);
registerEnvMethod("enumInstances", luaEnumInstances);
registerEnvMethod("isClearingContent", luaIsClearingContent);
}
/*
static void polyUnitTest()
{
CPolygon2D poly;
poly.Vertices.push_back(CVector2f(0.f, 0.f));
poly.Vertices.push_back(CVector2f(1.f, 0.f));
poly.Vertices.push_back(CVector2f(1.f, 1.f));
poly.Vertices.push_back(CVector2f(0.f, 1.f));
nlassert(poly.contains(CVector2f(0.f, 0.f), false));
nlassert(poly.contains(CVector2f(1.f, 0.f), false));
nlassert(poly.contains(CVector2f(1.f, 1.f), false));
nlassert(poly.contains(CVector2f(0.f, 1.f), false));
nlassert(poly.contains(CVector2f(0.5f, 0.f), false))
nlassert(poly.contains(CVector2f(1.f, 0.5f), false));
nlassert(poly.contains(CVector2f(0.5f, 1.f), false));
nlassert(poly.contains(CVector2f(0.f, 0.5f), false));
nlassert(poly.contains(CVector2f(0.5f, 0.5f), false));
//
nlassert(!poly.contains(CVector2f(-0.5f, 0.5f), false));
nlassert(!poly.contains(CVector2f(1.5f, 0.5f), false));
nlassert(!poly.contains(CVector2f(0.5f, -0.5f), false));
nlassert(!poly.contains(CVector2f(0.5f, 1.5f), false));
}
*/
// *********************************************************************************************************
void CEditor::loadLanguageFile()
{
//H_AUTO(R2_CEditor_loadLanguageFile)
CHECK_EDITOR
static bool reload = false;
CI18N::ILoadProxy *oldLoadProxy = CI18N::getLoadProxy();
CI18N::setLoadProxy(NULL);
string lc = ClientCfg.LanguageCode;
nlinfo("Reloading the r2_%s.uxt", lc.c_str());
CI18N::loadFromFilename("r2_"+lc+".uxt", reload);
CI18N::setLoadProxy(oldLoadProxy);
reload = true;
}
// *********************************************************************************************************
void CEditor::loadKeySet(const std::string &keySet)
{
//H_AUTO(R2_CEditor_loadKeySet)
CHECK_EDITOR
if (keySet.empty()) return;
CVerboseClock clock("Parsing of keyset " + keySet);
// remove all existing keys
ActionsContext.removeAllCombos();
CMacroCmdManager::getInstance()->removeAllMacros();
// parse keys that are specific to r2ed
std::vector<string> xmlFilesToParse;
// Does the r2ed keys file exist ?
std::string userKeyFileName = "save/" + keySet + "_"+PlayerSelectedFileName+".xml";
if (CFile::fileExists(userKeyFileName) && CFile::getFileSize(userKeyFileName) > 0)
{
// Load the user key file
xmlFilesToParse.push_back (userKeyFileName);
}
// Load the default key (but don't replace existings bounds, see keys.xml "key_def_no_replace")
xmlFilesToParse.push_back (keySet + ".xml");
if (!CInterfaceManager::getInstance()->parseInterface (xmlFilesToParse, true))
{
badXMLParseMessageBox();
}
CActionsManager *actionManager = ActionsContext.getActionsManager();
if (actionManager)
{
// if some mode are unavailable, forbid the associated shortcuts
/*if (!_ModeEnabled[EditionMode])
{
actionManager->removeBaseAction("r2ed_stop_test");
}
if (!_ModeEnabled[TestMode] || !_ModeEnabled[DMMode])
{
actionManager->removeBaseAction("r2ed_try_go_test");
}*/
}
}
// *********************************************************************************************************
void CEditor::saveCurrentKeySet()
{
//H_AUTO(R2_CEditor_saveCurrentKeySet)
CHECK_EDITOR
std::string prefix = getKeySetPrefix(getMode());
if (prefix.empty()) return;
getUI().saveKeys ("save/" + prefix + "_" + PlayerSelectedFileName + ".xml");
}
// *********************************************************************************************************
std::string CEditor::getKeySetPrefix(TMode mode)
{
//H_AUTO(R2_CEditor_getKeySetPrefix)
CHECK_EDITOR
switch(mode)
{
case EditionMode: return "keys_r2ed";
case GoingToDMMode:
case GoingToEditionMode:
case AnimationModeLoading:
case AnimationModeWaitingForLoading:
case AnimationModeGoingToDm:
case AnimationModeGoingToPlay:
return "";
case AnimationModePlay:
return "keys";
default:
return "keys";
}
return std::string();
}
// *********************************************************************************************************
void CEditor::setUIMode(uint8 mode)
{
//H_AUTO(R2_CEditor_setUIMode)
CHECK_EDITOR
getUI().setMode(mode);
if (_ForceDesktopReset[mode])
{
// force to call reset when reloading the ui
getLua().push((double) mode);
callEnvMethod("resetDesktop", 1, 0);
_ForceDesktopReset[mode] = false;
}
getLua().push((double) mode);
callEnvMethod("onChangeDesktop", 1, 0);
}
// *********************************************************************************************************
void CEditor::loadStandardUI()
{
//H_AUTO(R2_CEditor_loadStandardUI)
getUI().setMode(0);
// force to reload the standard interface
ClientCfg.R2EDEnabled = false;
loadUIConfig("");
ClientCfg.R2EDEnabled = true;
getUI().updateAllLocalisedElements();
}
// *********************************************************************************************************
bool CEditor::isDMing() const
{
//H_AUTO(R2_CEditor_isDMing)
if (getMode() == AnimationModePlay) return false; // masterless mode -> not a dm
return getMode() == DMMode ||
getMode() == AnimationModeDm ||
(
getMode() != NotInitialized &&
getAccessMode() == AccessDM
);
}
// *********************************************************************************************************
void CEditor::setMode(TMode mode)
{
switch(mode)
{
case NotInitialized: nlwarning("*R2* Setting mode to NotInitialized"); break;
case EditionMode: nlwarning("*R2* Setting mode to EditionMode"); break;
case GoingToDMMode: nlwarning("*R2* Setting mode to GoingToDMMode"); break;
case GoingToEditionMode: nlwarning("*R2* Setting mode to GoingToEditionMode"); break;
case TestMode: nlwarning("*R2* Setting mode to TestMode"); break;
case DMMode: nlwarning("*R2* Setting mode to DMMode"); break;
case AnimationModeLoading: nlwarning("*R2* Setting mode to AnimationModeLoading"); break;
case AnimationModeWaitingForLoading: nlwarning("*R2* Setting mode to AnimationModeWaitingForLoading"); break;
case AnimationModeDm: nlwarning("*R2* Setting mode to AnimationModeDm"); break;
case AnimationModePlay: nlwarning("*R2* Setting mode to AnimationModePlay"); break;
case AnimationModeGoingToDm: nlwarning("*R2* Setting mode to AnimationModeGoingToDm"); break;
case AnimationModeGoingToPlay: nlwarning("*R2* Setting mode to AnimationModeGoingToPlay"); break;
default:
nlwarning("Setting mode to 'unknown'");
break;
}
if (mode != EditionMode)
{
delete _EntitySorter;
_EntitySorter = NULL;
}
//H_AUTO(R2_CEditor_setMode)
CHECK_EDITOR
//nlassert(_ModeEnabled[mode]);
if (mode == _Mode && !_ForceDesktopReset[mode]) return;
if (mode != _Mode)
{
if ((_Mode == AnimationModeDm || _Mode == AnimationModePlay)
&& !((mode == AnimationModeDm || mode == AnimationModePlay)))
{
// remove the chat windows when leaving animation mode
PeopleInterraction.removeAllFreeTellers();
}
CVerboseClock clock("Saving windows & key at a mode change ...");
if (_Mode != NotInitialized)
{
saveCurrentKeySet();
}
//if (_Mode != NotInitialized) saveUIConfig();
if (_Mode == EditionMode || _Mode == AnimationModeLoading)
{
getDMC().getActionHistoric().clear(); // no backup of undo/redo for now
clearContent(); // when leaving edition, remove content from tree
}
else if (mode == EditionMode || mode == GoingToEditionMode)
{
removeAllEntitySlots(); // when leaving test or dm, remove the entities slots
}
if (mode == DMMode || mode == AnimationModeDm)
{
getEditor().getDMC().getEditionModule().askUpdateCharMode(TCharMode::Dm);
}
else if (mode == EditionMode)
{
getEditor().getDMC().getEditionModule().askUpdateCharMode(TCharMode::Editer);
}
else if (mode == AnimationModePlay)
{
if(_Mode != NotInitialized)
{
if (_SerializeUIConfig)
{
saveUIConfig();
}
}
getEditor().getDMC().getEditionModule().askUpdateCharMode(TCharMode::Player);
// if access mode is DM, then load the whole ui
if (_AccessMode == AccessDM)
{
loadStandardUI();
}
}
else if (mode == TestMode)
{
getEditor().getDMC().getEditionModule().askUpdateCharMode(TCharMode::Tester);
}
else // Other like going to dm ...
{
}
}
// reset any selection
if ((!IngameDbMngr.initInProgress()) && UserEntity) // prevent from calling selection() if coming from a FarTP, otherwise the server will mess up the action counter because it can't know our datasetrow so early (initInProgress(): heuristic to ensure the setTarget() will work on the EGS)
{
UserEntity->selection(CLFECOMMON::INVALID_SLOT);
}
//
ContextCur.release();
_Mode = mode;
loadKeySet(getKeySetPrefix(_Mode));
getUI().disableModalWindow();
getUI().setCapturePointerLeft(NULL);
getUI().setCapturePointerRight(NULL);
getUI().setCaptureKeyboard(NULL);
// Season is now unknown, until server force it (in test mode), or first set act set it (in edit mode)
_Season = UnknownSeason;
//
switch(_Mode)
{
case EditionMode:
if (!_EntitySorter)
{
_EntitySorter = new CEntitySorter;
}
ActionsContext.setContext("r2ed");
// set new mode in lua
_Env.setValue("Mode", "Edit");
setUIMode(0);
::IgnoreEntityDbUpdates = true;
::SlotUnderCursor = CLFECOMMON::INVALID_SLOT;
/**
* nb we manage mouse bitmap ourselves, so there's only one cursor context here, and it never changes:
* its sole purpose is to route messages to the current tool
*/
ContextCur.add(false, "STAND BY", DEFAULT_CURSOR, 0.0f, CEditor::checkCursor, CEditor::mouseClick);
forceSetSelectedInstance(NULL);
initReferencePlotItems();
// force speed to "run" ("walk" not available in edition)
if (!UserEntity->running())
{
UserEntity->switchVelocity();
}
break;
case TestMode:
ActionsContext.setContext("r2ed_anim_test");
// set new mode in lua
_Env.setValue("Mode", "Test");
setUIMode(1);
::IgnoreEntityDbUpdates = false;
::initContextualCursor();
nlassert(CDisplayerBase::ObjCount == 0);
resetPlotItems();
break;
case DMMode:
ActionsContext.setContext("r2ed_anim_dm");
// set new mode in lua
_Env.setValue("Mode", "DM");
setUIMode(2);
::IgnoreEntityDbUpdates = false;
::initContextualCursor();
nlassert(CDisplayerBase::ObjCount == 0);
// when in local mode, init fake plot item to test the 'dm gift' interface
initDummyPlotItems();
break;
case GoingToDMMode:
ActionsContext.setContext("waiting_network");
// set new mode in lua
_Env.setValue("Mode", "GoingToDM");
setUIMode(3);
connexionMsg(_ConnexionMsg); // update connexion window
::IgnoreEntityDbUpdates = false;
::initContextualCursor();
nlassert(CDisplayerBase::ObjCount == 0);
resetPlotItems();
break;
case GoingToEditionMode:
nlassert(CDisplayerBase::ObjCount == 0);
ActionsContext.setContext("waiting_network");
// set new mode in lua
_Env.setValue("Mode", "BackToEditing");
setUIMode(3);
connexionMsg(_ConnexionMsg); // update connexion window
::IgnoreEntityDbUpdates = true;
::initContextualCursor();
resetPlotItems();
break;
case AnimationModeLoading:
nlassert(CDisplayerBase::ObjCount == 0);
ActionsContext.setContext("waiting_network");
// set new mode in lua
_Env.setValue("Mode", "AnimationModeLoading");
setUIMode(3);
connexionMsg(_ConnexionMsg); // update connexion window
// ::IgnoreEntityDbUpdates = true;
::initContextualCursor();
resetPlotItems();
break;
case AnimationModeWaitingForLoading:
nlassert(CDisplayerBase::ObjCount == 0);
ActionsContext.setContext("waiting_network");
// set new mode in lua
_Env.setValue("Mode", "AnimationModeWaitingForLoading");
setUIMode(3);
connexionMsg(_ConnexionMsg); // update connexion window
// ::IgnoreEntityDbUpdates = true;
::initContextualCursor();
resetPlotItems();
break;
case AnimationModeDm:
PeopleInterraction.updateAllFreeTellerHeaders(); // if invitation were received during loading, add 'invite' button to the new windows
nlassert(CDisplayerBase::ObjCount == 0);
ActionsContext.setContext("r2ed_anim_dm");
// set new mode in lua
_Env.setValue("Mode", "AnimationModeDm");
setUIMode(2);
::IgnoreEntityDbUpdates = false;
::initContextualCursor();
resetPlotItems();
break;
case AnimationModePlay:
{
// animation mode play is still visible in masterless mode
nlassert(CDisplayerBase::ObjCount == 0);
// no op here, just a player
ActionsContext.setContext("game");
//ActionsContext.setContext("r2ed_anim_test");
// set new mode in lua
_Env.setValue("Mode", "r2ed_anim_test");
// hide all ring windows that may remain
hideRingWindows();
// setUIMode(1); // don't change desktop here, because virtual desktops are allowed in this mode
getUI().setMode(0); // default to desktop 0 as with standard game
::IgnoreEntityDbUpdates = false;
::initContextualCursor();
resetPlotItems();
if (getDMC().getEditionModule().isSessionOwner())
{
// if we are not a player, pop the ui to pop control player window & to quit
callEnvMethod("popDMToolbarWindow", 0, 0);
}
else
{
callEnvMethod("playerModeUIFix", 0, 0);
}
}
break;
case AnimationModeGoingToDm:
nlassert(CDisplayerBase::ObjCount == 0);
ActionsContext.setContext("waiting_network");
//set new mode in lua
_Env.setValue("Mode", "AnimationModeGoingToDM");
setUIMode(3);
connexionMsg(_ConnexionMsg); // update connexion window
::IgnoreEntityDbUpdates = false;
::initContextualCursor();
resetPlotItems();
break;
default:
nlassert(0);
break;
}
ClientCfg.ManualWeatherSetup = false;
ContextCur.context("STAND BY");
_Mode = mode;
// warn lua that mode has changed
callEnvMethod("onModeChanged", 0, 0);
//
setCurrentTool(NULL);
// display the bars over the player (not available during edition, but available at test time)
UserEntity->buildInSceneInterface();
if (_Mode == EditionMode)
{
// special context menu for edition
GameContextMenu.init("game_context_menu_edition");
}
else
{
GameContextMenu.init("");
}
}
// *********************************************************************************************************
void CEditor::hideRingWindows()
{
//H_AUTO(R2_CEditor_hideRingWindows)
static const char *ringWindows[] =
{
"r2ed_palette",
"r2ed_connect",
"r2ed_property_sheet_no_selection",
"r2ed_property_sheet_no_properties",
"r2ed_bbox_edit",
"r2ed_toolbar",
"r2ed_windows_dm_bar",
"r2ed_toolbar_window",
"r2ed_windows_bar",
"r2ed_main_bl",
"r2ed_animation_loading",
"r2ed_animation_waiting",
"dm_controlled_entities",
"r2ed_current_session",
"r2ed_toolbar_admin",
"lua_inspector",
"r2ed_npc",
"r2ed_select_bar",
"r2ed_main_menu_button",
"r2ed_contextual_toolbar_new",
"feature_help",
"r2ed_logic_entities",
"r2ed_events",
"r2ed_activities",
"r2ed_edit_activity_sequence",
"r2ed_dialogs",
"r2ed_edit_chat_sequence",
"r2ed_mini_activity_view",
"r2ed_acts",
"r2ed_connecting",
"r2ed_scenario",
"r2ed_dm_gift",
"r2ed_scenario_filter",
"r2ed_testbar"
};
for (uint k = 0; k < sizeofarray(ringWindows); ++k)
{
std::string id = "ui:interface:" + std::string(ringWindows[k]);
CInterfaceElement *grp = getUI().getElementFromId(id);
if (grp)
{
grp->setActive(false);
}
else
{
nlwarning("Can't find group with id : %s", id.c_str());
}
}
}
// *********************************************************************************************************
void CEditor::init(TMode initialMode, TAccessMode accessMode)
{
nlwarning("*R2* init");
_EntitySorter = NULL;
//H_AUTO(R2_CEditor_init)
CNiceInputAuto niceInputs;
nlassert((uint) initialMode < ModeCount);
nlassert((uint) accessMode < AccessModeCount);
//nlassert(_ModeEnabled[initialMode]; // mode not enabled ...
CHECK_EDITOR
CVerboseClock clock("Init of editor ");
_Initialized = true;
_AccessMode = accessMode;
// add a list of files for which modifications will trigger R2ED reset
for(uint k = 0; k < ClientCfg.R2EDReloadFiles.size(); ++k)
{
CFile::removeFileChangeCallback(ClientCfg.R2EDReloadFiles[k]); // avoid to add twice when a reset ...
CFile::addFileChangeCallback(ClientCfg.R2EDReloadFiles[k], reloadEditorCallback);
}
//
CLuaStackChecker lsc(&getLua());
getLua().pushValue(LUA_GLOBALSINDEX);
_Globals.pop(getLua());
getLua().pushValue(LUA_REGISTRYINDEX);
_Registry.pop(getLua());
// create R2 environment, and keep a reference on it
_Env = _Globals.newTable(R2_LUA_PATH);
_Config = _Env.newTable("Config");
//
_Env.setValue("InClient", true); // TMP : signal to the script that it is initialised by the client
//
switch (accessMode)
{
case AccessEditor: _Env.setValue("AccessMode", "Editor"); break;
case AccessDM: _Env.setValue("AccessMode", "DM"); break;
case AccessOutlandOwner: _Env.setValue("AccessMode", "OutlandOwner"); break;
default:
nlassert(0);
break;
}
// Load the UI files
if (ReloadUIFlag)
{
loadLanguageFile();
reloadUI();
// setForceDesktopReset is done below
ReloadUIFlag = false;
}
//
registerDisplayers();
registerTools();
//
std::vector<std::string> emptyArgsList;
// Calling window init proc
registerLuaFunc();
//
_DMC->init(getLua().getStatePointer());
//
initObjectProjectionMetatable(); // init system to access to scenary objects from lua
// init client/server stuffs
CConfigVarBase::getConfigFileTimeStamp() ++; // invalidate all var taken from the config file
// load r2 features & components
{
CVerboseClock clock("Execution of r2_core.lua");
doLuaScript("r2_core.lua", "r2ed common functions and definitions");
}
initClassInheritanceTable();
//
{
CLuaStackChecker lsc4(&getLua());
setCurrentTool(NULL); // force the default tool (select / move)
}
initDecals();
// TMP nico : unit test for newpoly stuff
//polyUnitTest();
_Initialized = true;
_LuaUIMainLoop = _Env["UIMainLoop"];
if (_SerializeUIConfig)
{
// load virtual desktops configs
bool configLoaded = false;
{
CVerboseClock clock("Load of ui config from disk ");
// if access mode is DM, then load the whole ui (else it has been previuously loaded)
if (initialMode == AnimationModePlay)
{
loadStandardUI();
}
else
{
configLoaded = loadUIConfig(getUIPrefix(initialMode));
}
}
// if not found then reset all virtual desktops (one for each mode of the editor)
if (!configLoaded)
{
nlwarning("No interface config found, resetting editor windows to their default");
setForceDesktopReset(true);
}
}
setMode(initialMode);
{
CVerboseClock clock("Update of localized elements");
getUI().updateAllLocalisedElements();
}
}
// *********************************************************************************************************
std::string CEditor::getUIPrefix(TMode mode) const
{
//H_AUTO(R2_CEditor_getUIPrefix)
switch(mode)
{
case AnimationModePlay:
return "";
break;
default:
return "r2ed_interface_";
break;
}
}
// *********************************************************************************************************
uint CEditor::getMaxNumPlotItems()
{
//H_AUTO(R2_CEditor_getMaxNumPlotItems)
uint ret;
fromString(getUI().getDefine("r2ed_max_num_plot_item_sheets"), ret);
return ret;
}
// *********************************************************************************************************
CCDBNodeLeaf *CEditor::getRefPlotItemSheetDBLeaf(uint index)
{
//H_AUTO(R2_CEditor_getRefPlotItemSheetDBLeaf)
return getUI().getDbProp(toString("LOCAL:R2:REFERENCE_PLOT_ITEMS:%d:SHEET", (int) index), false);
}
// *********************************************************************************************************
CCDBNodeLeaf *CEditor::getPlotItemSheetDBLeaf(uint index)
{
//H_AUTO(R2_CEditor_getPlotItemSheetDBLeaf)
return getUI().getDbProp(toString("LOCAL:R2:PLOT_ITEMS:%d:SHEET", (int) index), false);
}
// *********************************************************************************************************
void CEditor::setReferencePlotItemSheet(uint index, uint32 sheetId)
{
//H_AUTO(R2_CEditor_setReferencePlotItemSheet)
CCDBNodeLeaf *leaf = getRefPlotItemSheetDBLeaf(index);
if (leaf)
{
leaf->setValue32(sheetId);
}
leaf = getUI().getDbProp(toString("LOCAL:R2:AVAILABLE_PLOT_ITEMS:%d:SHEET", (int) index), false);
if (leaf)
{
leaf->setValue32(sheetId);
}
}
// *********************************************************************************************************
void CEditor::initDummyPlotItems()
{
//H_AUTO(R2_CEditor_initDummyPlotItems)
uint maxNumPlotItems = getMaxNumPlotItems();
uint numItems = std::min(10u, maxNumPlotItems);
uint k;
for(k = 0; k < numItems; ++k)
{
CCDBNodeLeaf *destLeaf = getPlotItemSheetDBLeaf(k);
if (!destLeaf) continue;
CCDBNodeLeaf *srcLeaf = getRefPlotItemSheetDBLeaf(k);
destLeaf->setValue32(srcLeaf ? srcLeaf->getValue32() : 0u);
}
for(; k < maxNumPlotItems; ++k)
{
CCDBNodeLeaf *destLeaf = getPlotItemSheetDBLeaf(k);
if (!destLeaf) continue;
destLeaf->setValue32(0);
}
}
// *********************************************************************************************************
void CEditor::resetPlotItems()
{
//H_AUTO(R2_CEditor_resetPlotItems)
uint maxNumPlotItems = getMaxNumPlotItems();
// uint numItems = std::min(10u, maxNumPlotItems);
for(uint k = 0; k < maxNumPlotItems; ++k)
{
CCDBNodeLeaf *destLeaf = getPlotItemSheetDBLeaf(k);
if (!destLeaf) continue;
destLeaf->setValue32(0);
}
_PlotItemInfos.clear();
}
// *********************************************************************************************************
void CEditor::initReferencePlotItems()
{
//H_AUTO(R2_CEditor_initReferencePlotItems)
{
CVerboseClock clock("InitReferencePlotItems");
uint maxNumPlotItems = getMaxNumPlotItems();
clamp(maxNumPlotItems, 0u, 1024u);
uint currIndex = 0;
// look for plot item sheets
const CSheetManager::TEntitySheetMap &sheets = SheetMngr.getSheets();
for(CSheetManager::TEntitySheetMap::const_iterator it = sheets.begin(); it != sheets.end(); ++it)
{
if (it->second.EntitySheet && it->second.EntitySheet->Type == CEntitySheet::ITEM)
{
std::string name = it->second.EntitySheet->Id.toString();
if (strstr(name.c_str(), "r2_plot_item"))
{
uint32 sheetId = it->second.EntitySheet->Id.asInt();
setReferencePlotItemSheet(currIndex, sheetId);
++ currIndex;
}
}
}
for (; currIndex < maxNumPlotItems; ++currIndex)
{
setReferencePlotItemSheet(currIndex, 0);
}
resetPlotItems();
}
}
// *********************************************************************************************************
bool CEditor::loadUIConfig(const std::string &prefix)
{
//H_AUTO(R2_CEditor_loadUIConfig)
CHECK_EDITOR
return getUI().loadConfig("save/" + prefix + PlayerSelectedFileName + ".icfg");
}
// *********************************************************************************************************
void CEditor::saveUIConfig()
{
//H_AUTO(R2_CEditor_saveUIConfig)
CHECK_EDITOR
// if there are dirt desktop, update all of them
if (_Mode != AnimationModePlay)
{
bool restoreMode = false;
uint8 oldMode = getUI().getMode();
for (uint k = 0; k < 4; ++k)
{
if (_ForceDesktopReset[k])
{
setUIMode(k);
restoreMode = true;
_ForceDesktopReset[k] = false;
}
if (restoreMode)
{
setUIMode(oldMode);
}
}
}
getUI().saveConfig("save/" + getUIPrefix(_Mode) + PlayerSelectedFileName + ".icfg");
}
// *********************************************************************************************************
void CEditor::initDecals()
{
//H_AUTO(R2_CEditor_initDecals)
CHECK_EDITOR
// highlight
CLuaObject config = getEnv()["Config"];
CLuaObject objHighlight = config["HightlightDecalLook"];
CLuaObject objSelect = config["SelectDecalLook"];
CLuaObject objSelecting = config["SelectingDecalLook"];
CLuaObject objPioneer = config["PionneerDecalLook"];
_HighlightDecalAnim.buildFromLuaTable(objHighlight);
_SelectDecalAnim.buildFromLuaTable(objSelect);
_SelectingDecalAnim.buildFromLuaTable(objSelecting);
_PionneerDecalAnim.buildFromLuaTable(objPioneer);
_HighlightDecal.setClipDownFacing(true);
_SelectDecal.setClipDownFacing(true);
_PionneerDecal.setClipDownFacing(true);
//
CPrimLook boxLook;
boxLook.init(getEnv()["PrimRender"]["SelectBoxLook"]);
_SelectBox.setLook(boxLook);
boxLook.init(getEnv()["PrimRender"]["HighlightBoxLook"]);
_HighlightBox.setLook(boxLook);
}
// *********************************************************************************************************
void CEditor::showPrimRender(CPrimRender &dest, const NLMISC::CAABBox &localBox, const NLMISC::CMatrix &worldMat, const CDecalAnim &refDecalAnim)
{
//H_AUTO(R2_CEditor_showPrimRender)
CHECK_EDITOR
static NLMISC::CPolygon2D poly2D;
poly2D.Vertices.resize(4);
CVector pmin = localBox.getMin();
CVector pmax = localBox.getMax();
poly2D.Vertices[0] = worldMat * CVector(pmin.x, pmin.y, pmin.z);
poly2D.Vertices[1] = worldMat * CVector(pmax.x, pmin.y, pmin.z);
poly2D.Vertices[2] = worldMat * CVector(pmax.x, pmax.y, pmin.z);
poly2D.Vertices[3] = worldMat * CVector(pmin.x, pmax.y, pmin.z);
NLMISC::CAABBox bbox;
CLandscapePolyDrawer::computeBBoxFromPolygon(poly2D, bbox);
dest.setVertices(poly2D.Vertices);
//dest.setWorldMapPolyColor(polyColor);
float animRatio = refDecalAnim.DurationInMs == 0 ? 0.f : (T1 % refDecalAnim.DurationInMs) / (float) refDecalAnim.DurationInMs;
animRatio = 0.5f * cosf(2.f * (float) Pi * animRatio) + 0.5f;
CRGBA color = blend(refDecalAnim.StartDiffuse, refDecalAnim.EndDiffuse, animRatio);
CPrimLook pl = dest.getLook();
pl.EdgeLook.DecalColor = pl.VertexLook.DecalColor = pl.FirstVertexLook.DecalColor = color;
dest.setLook(pl);
dest.addDecalsToRenderList();
static volatile bool showPoly = true;
if (showPoly)
{
CLandscapePolyDrawer::getInstance().addPoly(poly2D, dest.getLook().EdgeLook.WorldMapColor, bbox);
}
}
// *********************************************************************************************************
void CEditor::showSelectBox(const NLMISC::CAABBox &localBox, const NLMISC::CMatrix &worldMat)
{
//H_AUTO(R2_CEditor_showSelectBox)
CHECK_EDITOR
showPrimRender(_SelectBox, localBox, worldMat, _SelectDecalAnim);
}
// *********************************************************************************************************
void CEditor::showHighlightBox(const NLMISC::CAABBox &localBox, const NLMISC::CMatrix &worldMat)
{
//H_AUTO(R2_CEditor_showHighlightBox)
CHECK_EDITOR
showPrimRender(_HighlightBox, localBox, worldMat, _HighlightDecalAnim);
}
// *********************************************************************************************************
void CEditor::showSelectDecal(const NLMISC::CVector &pos, float scale)
{
//H_AUTO(R2_CEditor_showSelectDecal)
CHECK_EDITOR
updateDecalBlendRegion(_SelectDecal, pos);
showDecal(pos, scale, _SelectDecal, _SelectDecalAnim);
}
// *********************************************************************************************************
void CEditor::showHighlightDecal(const NLMISC::CVector &pos, float scale)
{
//H_AUTO(R2_CEditor_showHighlightDecal)
CHECK_EDITOR
updateDecalBlendRegion(_HighlightDecal, pos);
showDecal(pos, scale, _HighlightDecal, _HighlightDecalAnim);
}
// *********************************************************************************************************
void CEditor::showDecal(const NLMISC::CVector2f &pos, float scale, CDecal &decal, const CDecalAnim &decalAnim)
{
//H_AUTO(R2_CEditor_showDecal)
CHECK_EDITOR
float animRatio = decalAnim.DurationInMs == 0 ? 0.f : ((T1 - _DecalRefTime) % decalAnim.DurationInMs) / (float) decalAnim.DurationInMs;
animRatio = 0.5f * cosf(2.f * (float) Pi * animRatio) + 0.5f;
decalAnim.updateDecal(pos, animRatio, decal, scale);
decal.addToRenderList();
}
// *********************************************************************************************************
void CEditor::addSelectingDecal(const NLMISC::CVector &pos, float scale)
{
//H_AUTO(R2_CEditor_addSelectingDecal)
CHECK_EDITOR
CSelectingDecal *decal = NULL;
// see if there's an unused decal in the list
for(uint k = 0; k < _SelectingDecals.size(); ++k)
{
if (_SelectingDecals[k]->EndDate < T1)
{
decal = _SelectingDecals[k];
break;
}
}
if (decal == NULL)
{
_SelectingDecals.push_back(new CSelectingDecal);
decal = _SelectingDecals.back();
}
decal->EndDate = T1 + _SelectingDecalAnim.DurationInMs;
decal->Pos = pos;
decal->Scale = scale;
//
updateDecalBlendRegion(decal->Decal, pos);
_DecalRefTime = T1;
}
// *********************************************************************************************************
void CEditor::updateSelectingDecals()
{
//H_AUTO(R2_CEditor_updateSelectingDecals)
CHECK_EDITOR
if (_SelectingDecalAnim.DurationInMs == 0) return;
for(uint k = 0; k < _SelectingDecals.size(); ++k)
{
CSelectingDecal *decal = _SelectingDecals[k];
if (decal)
{
if (decal->EndDate > T1)
{
float animRatio = (float) (T1 - (decal->EndDate - _SelectingDecalAnim.DurationInMs)) / (float) _SelectingDecalAnim.DurationInMs;
_SelectingDecalAnim.updateDecal(decal->Pos, animRatio, decal->Decal, decal->Scale);
decal->Decal.addToRenderList();
}
}
}
}
// *******************************************************************************************************
void CEditor::reset()
{
//H_AUTO(R2_CEditor_reset)
if (ClientCfg.R2EDExtendedDebug)
Driver->setWindowTitle(ucstring("Resetting R2ED editor ..."));
CHECK_EDITOR
_SerializeUIConfig = false; // prevent reloading of ui for speed
_WantedActOnInit.clear();
if (getCurrentAct())
{
R2::CObjectTable* act = getCurrentAct()->getObjectTable();
if (act->isString("Name"))
{
_WantedActOnInit = act->toString("Name");
}
else
{
_WantedActOnInit = act->toString("Title"); //obsolete
}
}
CVerboseClock clock("Reset of editor ");
TMode oldMode = _Mode;
TAccessMode oldAccessMode = _AccessMode;
if (_Mode == EditionMode)
{
R2::getEditor().getLua().executeScriptNoThrow("r2.Version.save(\"data/r2_buffer.dat\")");
}
release();
clearDebugWindow();
if (ReloadUIFlag)
{
loadLanguageFile();
reloadUI();
setForceDesktopReset(true); // next changes of desktop should force a reset, since ui has been reloaded
ReloadUIFlag = false;
}
init(oldMode, oldAccessMode);
if (oldMode == EditionMode)
{
CVerboseClock clock("Request reconnection ");
getLua().executeScriptNoThrow("r2.requestReconnection()");
}
// try to return to the act with the same title
_SerializeUIConfig = true;
if (ClientCfg.R2EDExtendedDebug)
{
Driver->setWindowTitle(CI18N::get("TheSagaOfRyzom"));
// Show the window
Driver->showWindow();
}
getUI().displaySystemInfo(CI18N::get("uiR2EDEditorReseted"), "BC");
}
// *********************************************************************************************************
void CEditor::reloadUI()
{
//H_AUTO(R2_CEditor_reloadUI)
CHECK_EDITOR
CVerboseClock clock("Reload ui");
// reload same list than at startup (given in client.cfg)
for (uint k = 0; k < ClientCfg.XMLR2EDInterfaceFiles.size(); ++k)
{
reloadUI(ClientCfg.XMLR2EDInterfaceFiles[k].c_str());
}
}
// *********************************************************************************************************
void CEditor::reloadUI(const char *filename)
{
//H_AUTO(R2_CEditor_reloadUI)
CHECK_EDITOR
CVerboseClock clock("Loading ui " + std::string(filename));
CLuaStackChecker ls(&getLua());
std::string path = CPath::lookup(filename, false);
if (path.empty())
{
nlwarning("File %s not found, r2 ui not (re)loaded.", filename);
return;
}
uint32 fileDate = CFile::getFileModificationDate(path);
if (_LastUIModificationDate.count(filename) == 0)
{
_LastUIModificationDate[filename] = 0;
}
uint32 &lastUIModificationDate = _LastUIModificationDate[filename];
if (fileDate > lastUIModificationDate || !ClientCfg.R2EDDontReparseUnchangedUIFiles) // TMP (init not complete else ...)
{
// reload the ui files
NLMISC::ICommand::execute(toString("loadui %s", filename).c_str(), g_log);
lastUIModificationDate = fileDate;
}
else
{
if (!ClientCfg.R2EDDontReparseUnchangedUIFiles)
{
nlwarning("ui file %s date unchanged, not reloading.", filename);
}
}
}
// *********************************************************************************************************
void CEditor::connectAsCreator()
{
//H_AUTO(R2_CEditor_connectAsCreator)
CHECK_EDITOR
nlassert(_DMC);
{
CLuaStackChecker lsc2(&getLua());
_DMC->testConnectionAsCreator();
}
}
// string cached into lua for fast comparison
static CLuaString lstr_isNil("isNil");
static CLuaString lstr_Parent("Parent");
static CLuaString lstr_ParentInstance("ParentInstance");
static CLuaString lstr_IndexInParent("IndexInParent");
static CLuaString lstr_User("User");
static CLuaString lstr_Size("Size");
static CLuaString lstr_DisplayerUI("DisplayerUI");
static CLuaString lstr_DisplayerVisual("DisplayerVisual");
static CLuaString lstr_DisplayerProperties("DisplayerProperties");
// *********************************************************************************************************
void CEditor::initObjectProjectionMetatable()
{
//H_AUTO(R2_CEditor_initObjectProjectionMetatable)
CHECK_EDITOR
_ObjectProjectionMetatable = getEnv().newTable("_instance_projection_metatable");
// projection functions
struct CProjector
{
static bool checkTag(CLuaState &ls)
{
CLuaStackChecker lsc(&ls);
ls.getMetaTable(1);
ls.push("tag");
ls.getTable(-2);
bool ok = false;
if (ls.isString(-1))
{
if (strcmp(ls.toString(-1), "CObjectTable") == 0)
{
ok = true;
}
}
ls.pop(2);
if (!ok)
{
nlwarning("metatable error : Editor object expected");
}
return ok;
}
static int index(CLuaState &ls)
{
nlassert(ls.getTop() == 2);
#ifdef NL_DEBUG
if (!checkTag(ls)) return false;
#endif
CObjectTable::TRefPtrConst &obj= *(CObjectTable::TRefPtrConst *) ls.toUserData(1);
if (OPERATOR_EQUAL(obj, NULL))
//NLMISC::operator==(obj, NULL))
{
std::string index = ls.toString(2);
// special members
if ( index == "isNil")
//if (std::operator==(index "isNil")
{
ls.push(true);
return 1;
}
CLuaIHM::dumpCallStack();
// object has been deleted but the script maintains a reference on it
throw ELuaWrappedFunctionException(&ls, "Attempt to access an erased object");
}
if (ls.isNumber(2))
{
// index is a number
const CObject *other = obj->getValue((uint32) ls.toNumber(2));
if (other)
{
pushValue(ls, other);
return 1;
}
else
{
// 'bad index' message already printed by CObject::getValue
CLuaIHM::dumpCallStack();
}
}
if (!ls.isString(2))
{
nlwarning("String expected when accessing an object property, %s found instead", ls.getTypename(2));
CLuaIHM::dumpCallStack(0);
return 0;
}
const char *strId = ls.toString(2); // strings are shared in lua, so a pointer comparison is sufficient
// special members
// NB nico : this was added before the R2::CInstance class derived from CReflectable,
// -> see if some of the following properties may better fit into R2::CInstance exported properties
if (OPERATOR_EQUAL( lstr_isNil, strId))
{
ls.push(false);
return 1;
}
else
if (OPERATOR_EQUAL(strId, lstr_Parent))
{
if (!obj->getParent())
{
ls.pushNil();
return 1;
}
nlassert(obj->getParent()->isTable());
getEditor().projectInLua((CObjectTable *) obj->getParent());
return 1;
}
else if (OPERATOR_EQUAL(strId, lstr_ParentInstance))
{
// look for parent instance (that is, not the
CObject *parent = obj->getParent();
while (parent)
{
if (parent->findAttr("InstanceId"))
{
getEditor().projectInLua((CObjectTable *) parent);
return 1;
}
parent = parent->getParent();
}
ls.pushNil();
return 1;
}
if (OPERATOR_EQUAL(strId, lstr_IndexInParent))
{
if (!obj->getParent())
{
ls.pushNil();
return 1;
}
sint32 index = obj->getParent()->findIndex(obj);
if (obj->getParent()->getKey(index).empty())
{
ls.push((double) index);
}
else
{
ls.push((double) -1);
}
return 1;
}
else if (OPERATOR_EQUAL(strId, lstr_User))
{
// push user table on stack
CEditor::getLuaUserTableFromObject(ls, *obj);
return 1;
}
else if (OPERATOR_EQUAL(strId, lstr_Size))
{
if (obj->isTable())
{
ls.push((double) obj->getSize());
}
else
{
ls.pushNil();
}
return 1;
}
else
if (OPERATOR_EQUAL(strId, lstr_DisplayerUI))
{
CInstance *instance = getEditor().getInstanceFromObject(obj);
if (!instance)
{
ls.pushNil();
return 1;
}
else
{
if (instance->getDisplayerUI())
{
instance->getDisplayerUI()->pushLuaAccess(ls);
}
else
{
ls.pushNil();
}
return 1;
}
}
else
if (OPERATOR_EQUAL(strId, lstr_DisplayerVisual))
{
CInstance *instance = getEditor().getInstanceFromObject(obj);
if (!instance)
{
ls.pushNil();
return 1;
}
else
{
if (instance->getDisplayerVisual())
{
instance->getDisplayerVisual()->pushLuaAccess(ls);
}
else
{
ls.pushNil();
}
return 1;
}
}
else
if (OPERATOR_EQUAL(strId, lstr_DisplayerProperties))
{
CInstance *instance = getEditor().getInstanceFromObject(obj);
if (!instance)
{
ls.pushNil();
return 1;
}
else
{
if (instance->getDisplayerProperties())
{
instance->getDisplayerProperties()->pushLuaAccess(ls);
}
else
{
ls.pushNil();
}
return 1;
}
}
// else tries with a string
std::string index = ls.toString(2);
const CObject *other = getObject(obj, index);
if (other)
{
pushValue(ls, other);
return 1;
}
// this is not an attribute of the class
// -> maybe this is a method ?
// look in the parent class is there is a function with the wanted name
// NOTE : calling a method on an editor object in the script can be done by doing
// r2:getClass(instance).methodName(instance, parameters ...)
// with this trick, one can do instance:methodName(parameters ...)
CObject *className = obj->findAttr("Class");
if (className)
{
CLuaObject method = getEditor().getClasses()[className->toString()][index];
if (method.isFunction())
{
method.push();
return 1;
}
}
// Try with a property exported from CInstance
// Is is ok to test thos properties after those defined in lua classes definition
// because the init check that no "native" property is declared by the user
CInstance *instance = getEditor().getInstanceFromObject(obj);
if (instance)
{
const CReflectedProperty *prop = instance->getReflectedProperty(index, false);
if (prop)
{
CLuaIHM::luaValueFromReflectedProperty(ls, *instance, *prop);
return 1;
}
}
// unknown attribute
ls.pushNil();
return 1;
}
static int newIndex(CLuaState &ls)
{
nlassert(ls.getTop() == 3);
#ifdef NL_DEBUG
if (!checkTag(ls)) return false;
#endif
CObjectTable::TRefPtrConst &obj= *(CObjectTable::TRefPtrConst *) ls.toUserData(1);
if (obj == NULL)
{
throw ELuaWrappedFunctionException(&ls, "Trying to set a property in an erased object, returning nil");
}
#ifdef NL_DEBUG
if (!checkTag(ls)) return false;
#endif
// try with a native (local ..) property exported from CInstance
CInstance *instance = getEditor().getInstanceFromObject(obj);
if (instance)
{
const CReflectedProperty *prop = instance->getReflectedProperty(ls.toString(2));
if (prop)
{
CLuaIHM::luaValueToReflectedProperty(ls, 3, *instance, *prop);
return 1;
}
}
// other instances properties are read only !!
throw ELuaWrappedFunctionException(&ls, "Property %s of editor object is read-only. You must use 'r2.requestSetNode' function to change it", ls.toString(2));
}
static int gc(CLuaState &ls)
{
#ifdef NL_DEBUG
if (!checkTag(ls)) return false;
#endif
// TODO : maybe not useful ...
CObjectTable::TRefPtrConst &obj= *(CObjectTable::TRefPtrConst *) ls.toUserData(1);
typedef CObjectTable::TRefPtrConst TRefPtrConst;
obj.~TRefPtrConst();
return 0;
}
// tool function used by 'next'
// TODO : put this code in a better place ...
static void pushValue(CLuaState &ls, const CObject *obj)
{
if (!obj)
{
ls.pushNil();
return;
}
if (obj->isString())
{
ls.push(obj->toString());
}
else if (obj->isNumber())
{
ls.push(obj->toNumber());
}
else if (obj->isTable())
{
getEditor().projectInLua((CObjectTable *) obj);
}
else
{
nlassert(0); // type not supported ...
}
}
// helper function used by 'next' : push a key
static void pushKey(CLuaState &ls, const CObject *obj, sint32 index)
{
if (!obj)
{
ls.pushNil();
return;
}
if (obj->getKey(index).empty())
{
ls.push((double) index);
}
else
{
ls.push(obj->getKey(index));
}
}
// special : we redefine the 'next' global function found in the standard
// lua library in order to allow fields traversal for the projected object.
// This is done in lua in the 'r2_core.lua' script
// The new 'next' function will look into the object metatable
// If a __next function is found, then it will be called for traversal
// otherwise, the standard 'next' function is called instead.
// This allow to have a traversal for objects that are not tables
static int next(CLuaState &ls)
{
if (ls.getTop() != 2)
{
CLuaIHM::fails(ls, "__next metamethod require 2 arguments (table & key)");
}
#ifdef NL_DEBUG
if (!checkTag(ls)) return false;
#endif
CObjectTable::TRefPtrConst &obj= *(CObjectTable::TRefPtrConst *) ls.toUserData(1);
if (obj == NULL)
{
throw ELuaWrappedFunctionException(&ls, "editor object '__next' metatmethod : Attempt to access an erased object");
}
if (ls.isNil(2))
{
// key is nil -> start of traversal
if(obj->getSize() == 0)
{
ls.remove(-2);
ls.pushNil();
return 2; // let (nil, nil) on the stack
}
else
{
// look for duplicated keys (ignoring empty keys, because in this case th index is the key)
std::set<std::string> keys;
for(uint k = 0; k < obj->getSize(); ++k)
{
std::string key = obj->getKey((sint32) k);
if (!key.empty())
{
if (keys.count(key))
{
nlwarning("Duplicated key of type string found while attempting to enumerate an instance content.");
nlwarning("key is %s", key.c_str());
CLuaIHM::dumpCallStack(1);
CLuaIHM::fails(ls, "Aborting to avoid infinite loop.");
}
keys.insert(key);
}
}
ls.pop(2);
pushKey(ls, obj, 0);
pushValue(ls, obj->getValue(0));
return 2;
}
}
else
{
// continuation of traversal
// -> retrieve index from the key
sint32 index;
if (ls.isNumber(2))
{
index = (uint32) ls.toNumber(2);
}
else
{
if (!ls.isString(2))
{
nlwarning("__next metamethod : string expected");
ls.pop();
ls.pushNil();
return 2;
}
else
{
index = obj->findIndex(ls.toString(2));
}
}
if (index == -1)
{
nlwarning("__next metamethod : key not found");
ls.pop(2);
ls.pushNil();
ls.pushNil();
return 2;
}
// retrieve next key
sint32 newIndex = (uint32) (index + 1);
if (newIndex == (sint32) obj->getSize())
{
// this was the last element, returns nil
ls.pop(2);
ls.pushNil();
ls.pushNil();
return 2;
}
else
{
ls.pop(2);
pushKey(ls, obj, newIndex);
pushValue(ls, obj->getValue(newIndex));
return 2;
}
}
return 0;
}
static int equal(CLuaState &ls)
{
// TMP TMP TMP
static volatile bool from = false;
if (from)
{
CLuaIHM::dumpCallStack(0);
}
nlassert(ls.getTop() == 2);
if (!checkTag(ls)) return false;
CObjectTable::TRefPtrConst &lhs= *(CObjectTable::TRefPtrConst *) ls.toUserData(1);
CObjectTable::TRefPtrConst &rhs= *(CObjectTable::TRefPtrConst *) ls.toUserData(2);
ls.push(OPERATOR_EQUAL(lhs, rhs));
return 1;
}
};
// affect functions to the metatable
getLua().push(CProjector::index);
_ObjectProjectionMetatable.setValue("__index", CLuaObject(getLua()));
getLua().push(CProjector::newIndex);
_ObjectProjectionMetatable.setValue("__newindex", CLuaObject(getLua()));
getLua().push(CProjector::gc);
_ObjectProjectionMetatable.setValue("__gc", CLuaObject(getLua()));
getLua().push(CProjector::next);
_ObjectProjectionMetatable.setValue("__next", CLuaObject(getLua()));
getLua().push(CProjector::equal);
_ObjectProjectionMetatable.setValue("__eq", CLuaObject(getLua()));
// tag to mark that the user data is a CObjectTable ref ptr
_ObjectProjectionMetatable.setValue("tag", std::string("CObjectTable"));
}
// *********************************************************************************************************
void CEditor::getLuaUserTableFromObject(CLuaState &ls, const CObjectTable &table)
{
//H_AUTO(R2_CEditor_getLuaUserTableFromObject)
CHECK_EDITOR
CLuaStackChecker lsc(&ls, 1);
// read write environement accessible from lua
ls.pushLightUserData((void *) &table);
ls.getTable(LUA_REGISTRYINDEX);
if (ls.isNil())
{
ls.pop();
// no user table created yet ?... create it
ls.pushLightUserData((void *) &table);
ls.newTable();
ls.pushValue(-1); // saves the table
ls.insert(-3);
ls.setTable(LUA_REGISTRYINDEX);
// table remains on the stack
}
}
// *********************************************************************************************************
void CEditor::setCurrentAct(CInstance *act)
{
//H_AUTO(R2_CEditor_setCurrentAct)
CHECK_EDITOR
if (!_ScenarioInstance) return;
if (_ClearingContent) return;
bool currentActSelected = _SelectedInstance && (_SelectedInstance == _CurrentAct);
CInstance* previousAct = _CurrentAct;
_CurrentAct = act ? act : getBaseAct();
//
struct CPreActChangedVisitor : public IInstanceVisitor
{
virtual void visit(CInstance &inst)
{
inst.onPreActChanged();
}
};
CPreActChangedVisitor preActChangedVisitor;
_ScenarioInstance->visit(preActChangedVisitor);
struct CActChangedVisitor : public IInstanceVisitor
{
virtual void visit(CInstance &inst)
{
inst.onActChanged();
}
};
CActChangedVisitor actChangedVisitor;
_ScenarioInstance->visit(actChangedVisitor);
//TP if necesary
// warn lua that current act has changed
if (!previousAct)
{
getLua().pushNil();
}
else
{
previousAct->getLuaProjection().push();
}
if (!_CurrentAct)
{
getLua().pushNil();
}
else
{
_CurrentAct->getLuaProjection().push();
}
callEnvMethod("onActChanged", 2, 0);
setSelectedInstance(currentActSelected ? _CurrentAct : NULL);
setCurrentTool(NULL);
}
// *********************************************************************************************************
void CEditor::setCurrentActFromTitle(const std::string &wantedTitle)
{
//H_AUTO(R2_CEditor_setCurrentActFromTitle)
CHECK_EDITOR
if (!_Scenario)
{
nlwarning("Scenario initialisation failed, can't set current act");
return;
}
CObject *actTable = _Scenario->getAttr("Acts");
if (actTable->isTable())
{
for(uint k = 0; k < actTable->getSize(); ++k)
{
R2::CObject *act = actTable->getValue(k);
nlassert(act);
std::string actTitle;
if (act->isString("Name"))
{
actTitle = act->toString("Name");
}
else
{
actTitle = act->toString("Title"); //obsolete
}
if (actTitle == wantedTitle)
{
setCurrentAct(getInstanceFromObject(act));
break;
}
}
}
else
{
nlwarning("'Acts' field in scenario should be a table");
}
}
// *********************************************************************************************************
void CEditor::projectInLua(const CObjectTable *table)
{
//H_AUTO(R2_CEditor_projectInLua)
CHECK_EDITOR
nlassert(table);
const CObjectTableClient *otc = NLMISC::safe_cast<const CObjectTableClient *>(table);
otc->pushOnLuaStack(getLua(), _ObjectProjectionMetatable);
}
// *********************************************************************************************************
void CEditor::backupRequestCommands()
{
//H_AUTO(R2_CEditor_backupRequestCommands)
nlassert(!_OldLuaRequestInsertNode.isValid()); // restoreRequestCommands not called ?
nlassert(!_OldLuaRequestInsertGhostNode.isValid());
nlassert(!_OldLuaRequestSetNode.isValid());
nlassert(!_OldLuaRequestEraseNode.isValid());
nlassert(!_OldLuaRequestMoveNode.isValid());
_OldLuaRequestInsertNode = getEnv()["requestInsertNode"];
_OldLuaRequestInsertGhostNode = getEnv()["requestInsertGhostNode"];
_OldLuaRequestSetNode = getEnv()["requestSetNode"];
_OldLuaRequestEraseNode = getEnv()["requestEraseNode"];
_OldLuaRequestMoveNode = getEnv()["requestMoveNode"];
struct CIgnoreRequestCall
{
static int requestSomething(CLuaState &)
{
nlwarning("PAS BIEN C MAL !!!");
/*
CLuaIHM::debugInfo("Can't call a 'r2.request' command while object are erased in displayers, or are just being created (in this case, use onPostCreate instead) !");
CLuaIHM::debugInfo("Callstack is :");
CLuaIHM::dumpCallStack(1);*/
return 0;
}
};
// While we delete the object tree, displayers will be triggered
// Make sure that they don't call any r2.requestSomething commands, end if so,
// print an error message
getEnv().setValue("requestInsertNode", CIgnoreRequestCall::requestSomething);
getEnv().setValue("requestInsertGhostNode", CIgnoreRequestCall::requestSomething);
getEnv().setValue("requestSetNode", CIgnoreRequestCall::requestSomething);
getEnv().setValue("requestEraseNode", CIgnoreRequestCall::requestSomething);
getEnv().setValue("requestMoveNode", CIgnoreRequestCall::requestSomething);
}
// *********************************************************************************************************
void CEditor::restoreRequestCommands()
{
//H_AUTO(R2_CEditor_restoreRequestCommands)
nlassert(_OldLuaRequestInsertNode.isValid()); // backupRequestCommands not called ?
nlassert(_OldLuaRequestInsertGhostNode.isValid());
nlassert(_OldLuaRequestSetNode.isValid());
nlassert(_OldLuaRequestEraseNode.isValid());
nlassert(_OldLuaRequestMoveNode.isValid());
// restore old functions
getEnv().setValue("requestInsertNode", _OldLuaRequestInsertNode);
getEnv().setValue("requestInsertGhostNode", _OldLuaRequestInsertGhostNode);
getEnv().setValue("requestSetNode", _OldLuaRequestSetNode);
getEnv().setValue("requestEraseNode", _OldLuaRequestEraseNode);
getEnv().setValue("requestMoveNode", _OldLuaRequestMoveNode);
//
_OldLuaRequestInsertNode.release();
_OldLuaRequestInsertGhostNode.release();
_OldLuaRequestSetNode.release();
_OldLuaRequestEraseNode.release();
_OldLuaRequestMoveNode.release();
}
// *********************************************************************************************************
void CEditor::clearContent()
{
nlwarning("*R2* clear content");
setMaxVisibleEntityExceededFlag(false);
//H_AUTO(R2_CEditor_clearContent)
if (_Mode != EditionMode && _Mode != AnimationModeLoading) return;
_ClearingContent = true;
CHECK_EDITOR
setSelectedInstance(NULL);
setFocusedInstance(NULL);
// backup all "requestCommand"
if (_CurrentTool) _CurrentTool->cancel();
CTool::releaseMouse();
delete _NewScenario; // will be not NULL only if quit is called during the scenario connection screen
_NewScenario = NULL;
eraseScenario();
_InstancesByDispName.clear();
_InstancesByDispName.resize(_ClassNameToIndex.size());
_InstanceObservers.clear();
_InstanceObserverHandles.clear();
_Cookies.clear();
_LocalGeneratedNames.clear();
_Instances.clear();
_BaseAct = NULL;
_CurrentAct = NULL;
_SelectedInstance = NULL;
_FocusedInstance = NULL;
_ScenarioInstance = NULL;
_Scenario = NULL;
_SelectingDecals.clear();
_InstanceObservers.clear();
_InstanceObserverHandles.clear();
_LastInstanceUnderPos = NULL;
_CurrentTool = NULL;
removeAllEntitySlots(); // for safety...
_DMC->CDynamicMapClient::scenarioUpdated(NULL, false, 1); // clear scenario for real
_ClearingContent = false;
_PlotItemInfos.clear();
PeopleInterraction.removeAllFreeTellers();
}
// *********************************************************************************************************
void CEditor::setPlotItemInfos(const TMissionItem &infos)
{
//H_AUTO(R2_CEditor_setPlotItemInfos)
_PlotItemInfos[infos.SheetId.asInt()] = infos;
}
// *********************************************************************************************************
const TMissionItem *CEditor::getPlotItemInfos(uint32 sheetId) const
{
//H_AUTO(R2_CEditor_getPlotItemInfos)
std::map<uint32, TMissionItem>::const_iterator it = _PlotItemInfos.find(sheetId);
if (it == _PlotItemInfos.end()) return NULL;
return &it->second;
}
// *********************************************************************************************************
void CEditor::release()
{
nlwarning("*R2* release");
//H_AUTO(R2_CEditor_release)
GameContextMenu.init("");
setFixedLighting(false);
CHECK_EDITOR
if (_Mode == NotInitialized)
{
// nothing more to do there
return;
}
// warn lua of final release
callEnvMethod("onFinalRelease", 0, 0);
if (_SerializeUIConfig)
{
// serialization disabled when resetting the editor (for speed)
saveCurrentKeySet();
saveUIConfig();
}
getUI().hideAllWindows(); // make sure all action handlers are called while the r2 lua environment is still active
clearContent();
_EntityCustomSelectBoxMap.clear();
// must do this after clearContent, which sets the default tool
if (_CurrentTool)
{
_CurrentTool->cancel();
_CurrentTool = NULL;
}
// clear the environment
if (getUI().getLuaState())
{
getLua().push(R2_LUA_PATH);
getLua().pushNil();
getLua().setTable(LUA_GLOBALSINDEX);
_Globals.release();
_Registry.release();
_ObjectProjectionMetatable.release(); // AJM
_Env.release();
_Config.release();
CEditorCheck::EditorCreated = false;
// force a garbage collection to free the mem for real
getLua().setGCThreshold(0);
}
// stop at login
if (_DMC)
{
_DMC->release();
}
//
nlassert(CDisplayerBase::ObjCount == 0);
_Initialized = false;
CEditorCheck::EditorCreated = false; // AJM
_Mode = NotInitialized;
_AccessMode = AccessModeUnknown;
::IgnoreEntityDbUpdates = false;
//
_IslandCollision.release();
//
_LastUIModificationDate.clear();
_InstancesByDispName.clear();
//
delete _EntitySorter;
_EntitySorter = NULL;
}
// *********************************************************************************************************
void CEditor::removeAllEntitySlots()
{
//H_AUTO(R2_CEditor_removeAllEntitySlots)
CHECK_EDITOR
for (uint k = 1; k < 255; ++k)
{
if (EntitiesMngr.entity(k) != NULL)
{
EntitiesMngr.remove(k, false);
}
}
}
// *********************************************************************************************************
void CEditor::registerDisplayers()
{
//H_AUTO(R2_CEditor_registerDisplayers)
CHECK_EDITOR
static bool registered = false;
if (registered) return;
NLMISC_REGISTER_CLASS(R2::CDisplayerVisualActivitySequence);
NLMISC_REGISTER_CLASS(R2::CDisplayerVisualEntity);
NLMISC_REGISTER_CLASS(R2::CDisplayerVisualGroup)
NLMISC_REGISTER_CLASS(R2::CDisplayerVisualShape)
NLMISC_REGISTER_CLASS(R2::CDisplayerLua)
registered = true;
}
// *********************************************************************************************************
void CEditor::registerTools()
{
//H_AUTO(R2_CEditor_registerTools)
CHECK_EDITOR
static bool registered = false;
if (registered) return;
NLMISC_REGISTER_CLASS(R2::CToolDrawPrim);
NLMISC_REGISTER_CLASS(R2::CToolSelectMove);
NLMISC_REGISTER_CLASS(R2::CToolSelectRotate);
NLMISC_REGISTER_CLASS(R2::CToolNewVertex);
registered = true;
}
// *********************************************************************************************************
void CEditor::setSelectedInstance(CInstance *inst)
{
//H_AUTO(R2_CEditor_setSelectedInstance)
CHECK_EDITOR
if (inst == _SelectedInstance) return;
forceSetSelectedInstance(inst);
}
// *********************************************************************************************************
void CEditor::forceSetSelectedInstance(CInstance *inst)
{
//H_AUTO(R2_CEditor_forceSetSelectedInstance)
CHECK_EDITOR
if (_EnteredInSetSelectedInstance) return; // prevent recursive call (may happen because selection highlight an item in a menu, which trigger selection in turn)
if (inst)
{
nlassert(inst->getSelectableFromRoot());
}
_EnteredInSetSelectedInstance = true;
if (inst)
{
nlassert(hasInstance(inst)); // must have been added in the editor !
}
if (_SelectedInstance)
{
_SelectedInstance->onSelect(false);
}
_SelectedInstance = inst;
if (_SelectedInstance)
{
_SelectedInstance->onSelect(true);
}
// call r2 method 'onSelectInstance'
if (!_SelectedInstance)
{
getLua().pushNil();
}
else
{
_SelectedInstance->getLuaProjection().push();
}
callEnvMethod("onSelectInstance", 1, 0);
_EnteredInSetSelectedInstance = false;
}
// *********************************************************************************************************
CInstance *CEditor::getSelectedInstance() const
{
//H_AUTO(R2_CEditor_getSelectedInstance)
CHECK_EDITOR
return _SelectedInstance;
}
// *********************************************************************************************************
void CEditor::setFocusedInstance(CInstance *inst)
{
//H_AUTO(R2_CEditor_setFocusedInstance)
CHECK_EDITOR
if (inst == _FocusedInstance) return;
if (inst)
{
nlassert(hasInstance(inst)); // must have been added in the editor !
}
if (_FocusedInstance)
{
_FocusedInstance->onFocus(false);
}
_FocusedInstance = inst;
if (_FocusedInstance)
{
_FocusedInstance->onFocus(true);
}
}
// *********************************************************************************************************
CInstance *CEditor::getFocusedInstance() const
{
//H_AUTO(R2_CEditor_getFocusedInstance)
CHECK_EDITOR
return _FocusedInstance;
}
// *********************************************************************************************************
bool CEditor::hasInstance(const CInstance *instance) const
{
//H_AUTO(R2_CEditor_hasInstance)
CHECK_EDITOR
// TMP : slow test for debug
for(TInstanceMap::const_iterator it = _Instances.begin(); it != _Instances.end(); ++it)
{
if (it->second == instance) return true;
}
return false;
}
// *********************************************************************************************************
bool CEditor::hasInstanceWithId(const TInstanceId &id) const
{
//H_AUTO(R2_CEditor_hasInstanceWithId)
CHECK_EDITOR
return getInstanceFromId(id) != NULL;
}
// *********************************************************************************************************
CInstance *CEditor::getInstanceFromId(const TInstanceId &id) const
{
//H_AUTO(R2_CEditor_getInstanceFromId)
CHECK_EDITOR
const CObjectTable *objTable = getObjectTableFromId(id);
if (!objTable) return NULL;
return getInstanceFromObject(objTable);
}
// *********************************************************************************************************
sint CEditor::getGeneratedNameIndex(const std::string &nameUtf8, const std::string &baseNameUtf8)
{
//H_AUTO(R2_CEditor_getGeneratedNameIndex)
CHECK_EDITOR
if (nameUtf8.size() >= baseNameUtf8.size() + 2)
{
if (nameUtf8.substr(0, baseNameUtf8.size()) == baseNameUtf8)
{
std::string::const_iterator strIt = nameUtf8.begin() + baseNameUtf8.size();
std::string::const_iterator endStrIt = nameUtf8.end();
if (*strIt == ' ')
{
++ strIt;
const char *numberStart = &*strIt;
for (; strIt != endStrIt && isdigit(*strIt); ++strIt) {}
if (strIt == endStrIt)
{
sint ret;
fromString(numberStart, ret);
return ret;
}
}
}
}
return -1;
}
// *********************************************************************************************************
bool CEditor::isPostFixedByNumber(const ucstring &baseName)
{
//H_AUTO(R2_CEditor_isPostFixedByNumber)
// strip number & spaces at the end of the name
sint lastIndex = (sint)baseName.length() - 1;
while (lastIndex > 0)
{
int currChar = (int) baseName[lastIndex];
if (!isdigit(currChar) &&
currChar != ' ' &&
currChar != '\t')
{
break;
}
-- lastIndex;
}
return lastIndex != (sint) baseName.length() - 1;
}
// *********************************************************************************************************
ucstring CEditor::genInstanceName(const ucstring &baseName)
{
//H_AUTO(R2_CEditor_genInstanceName)
CHECK_EDITOR
uint maxIndex = 0;
// strip number & spaces at the end of the name
ucstring strippedName = baseName;
sint lastIndex = (sint)strippedName.length() - 1;
while (lastIndex > 0)
{
int currChar = (int) strippedName[lastIndex];
if (!isdigit(currChar) &&
currChar != ' ' &&
currChar != '\t')
{
break;
}
-- lastIndex;
}
strippedName = strippedName.substr(0, lastIndex + 1);
std::string baseNameUtf8 = strippedName.toUtf8();
//
for(TInstanceMap::const_iterator it = _Instances.begin(); it != _Instances.end(); ++it)
{
maxIndex = (uint) std::max((sint) maxIndex, getGeneratedNameIndex(it->second->getName(), baseNameUtf8));
}
nlinfo("CEditor::genInstanceName newVersion");
// Old part : used when there was a delay between net command and effect
// did not work in some parts if genInstance is not followed by creation of an instance with that name
// cf RT 11560
/*
// now, look in local generated names (instance that have not been already added to the scene)
TGeneratedNameMap::iterator nameSetIt = _LocalGeneratedNames.find(baseNameUtf8);
if (nameSetIt != _LocalGeneratedNames.end())
{
if (!nameSetIt->second.empty())
{
maxIndex = std::max(maxIndex, *(nameSetIt->second.rbegin())); // take bigger element of the set (the last element)
}
}
// add max index in the map (will be removed when object is truly created)
_LocalGeneratedNames[baseNameUtf8].insert(maxIndex + 1);
*/
return strippedName + " " + toString(maxIndex + 1);
}
// *********************************************************************************************************
void CEditor::setCookie(const TInstanceId &instanceId, const std::string &key, CLuaObject &value)
{
//H_AUTO(R2_CEditor_setCookie)
CHECK_EDITOR
TCookieList &cl = _Cookies[instanceId];
cl.push_front(CCookie());
CCookie &cookie = cl.front(); // don't build struct and push to avoid costly copy of a CLuaObject
cookie.Key = key;
cookie.Value = value;
}
// *********************************************************************************************************
void CEditor::setCookie(const TInstanceId &instanceId, const std::string &key, bool value)
{
//H_AUTO(R2_CEditor_setCookie)
CHECK_EDITOR
getLua().push(value);
CLuaObject obj(getLua());
setCookie(instanceId, key, obj);
}
// *********************************************************************************************************
void CEditor::setCurrentTool(CTool *tool)
{
//H_AUTO(R2_CEditor_setCurrentTool)
CHECK_EDITOR
if (_CurrentTool)
{
_CurrentTool->cancel();
}
else
{
if (tool)
{
// setting a tool in non R2 mode force to change the contextual cursor
ContextCur.release();
ContextCur.add(false, "STAND BY", DEFAULT_CURSOR, 0.0f, CEditor::checkCursor, CEditor::mouseClick);
ContextCur.context("STAND BY");
}
}
CTool::setContextHelp(ucstring(""));
if (tool == NULL)
{
if (_Mode == EditionMode)
{
_CurrentTool = new CToolSelectMove;
}
else
{
_CurrentTool = NULL;
ContextCur.release();
::initContextualCursor();
ContextCur.context("STAND BY");
CTool::setMouseCursor(DEFAULT_CURSOR);
}
}
else
{
_CurrentTool = tool;
}
if (_CurrentTool)
{
_CurrentTool->onActivate();
}
{
CLuaStackChecker lsc(&getLua());
// activate tool in the ui
getLua().push(_CurrentTool ? _CurrentTool->getToolUIName() : "");
getEnv()["ToolUI"].callMethodByNameNoThrow("setActiveToolUIByName", 1, 0);
}
}
// *********************************************************************************************************
CLuaObject CEditor::getClasses() throw(ELuaError)
{
//H_AUTO(R2_getClasses_throw)
CHECK_EDITOR
return getEnv().at("Classes");
}
// *********************************************************************************************************
bool CEditor::callEnvFunc(const char *funcName, int numArgs, int numRet /*=0*/)
{
//H_AUTO(R2_CEditor_callEnvFunc)
CHECK_EDITOR
static volatile bool dumpStackWanted = false;
if (dumpStackWanted) getLua().dumpStack();
nlassert(funcName);
nlassert(getLua().getTop() >= numArgs);
int initialStackSize = getLua().getTop();
getEnv().push();
if (dumpStackWanted) getLua().dumpStack();
getLua().insert(-1 - numArgs); // put the table before the args
if (dumpStackWanted) getLua().dumpStack();
int result = getLua().pcallByName(funcName, numArgs, numRet, -1 - numArgs);
if (dumpStackWanted) getLua().dumpStack();
if (result != 0)
{
nlwarning("Error while calling function %s : %s", funcName, getLua().toString());
getLua().setTop(initialStackSize - numArgs + numRet); // clean the stack
return false;
}
// remove the R2 table from the stack
int newSize = getLua().getTop();
if (dumpStackWanted) getLua().dumpStack();
nlassert(newSize == initialStackSize + 1 - numArgs + numRet); // -1 is because of the r2 table
if (dumpStackWanted) getLua().dumpStack();
getLua().remove(- numRet - 1); // remove the 'R2' table
if (dumpStackWanted) getLua().dumpStack();
return true; // results remains on the stack
}
// *********************************************************************************************************
bool CEditor::callEnvMethod(const char *funcName, int numArgs, int numRet /*= 0*/)
{
//H_AUTO(R2_CEditor_callEnvMethod)
CHECK_EDITOR
nlassert(funcName);
nlassert(getLua().getTop() >= numArgs);
getEnv().push();
getLua().insert(-1 - numArgs); // put the table before the args (self parameter)
return callEnvFunc(funcName, numArgs + 1, numRet);
}
// *********************************************************************************************************
bool CEditor::doLuaScript(const char *filename, const char *fileDescText)
{
//H_AUTO(R2_CEditor_doLuaScript)
CHECK_EDITOR
CVerboseClock clock("parsing of " + std::string(filename));
// load the classes definition file
std::string filePath = NLMISC::CPath::lookup(filename, false, true);
if (filePath.empty())
{
nlwarning("Can't find %s : %s", fileDescText, filename);
return false;
}
if( 0 && FINAL_VERSION == 1) // deactivated for the moment because there are lua file that must be loaded from example
{
const static std::string path = "data_common.bnp@";
const static std::string::size_type len= path.size();
if (filePath.size() < len || filePath.substr(0, len) != path)
{
nlwarning("Can't find %s : %s in ('%s')", fileDescText, filename, path.c_str());
return false;
}
}
try
{
if (!getLua().executeFile(filePath))
{
nlwarning("Couldn't open file %s : %s for R2 is not loaded", filename, fileDescText);
}
CLuaStackChecker ls(&getLua());
return true;
}
catch(NLMISC::EStream &e)
{
nlwarning("Error while loading R2 %s (file = %s) : %s", fileDescText, filename, e.what());
}
catch(ELuaError &e)
{
//char filename[MAX_PATH];
std::string msg = e.what();
if (testWildCard(msg, "*.lua:*:*")) // TODO nico : more accurate testing for filename format
{
std::string::size_type extPos = msg.find(".lua");
nlassert(extPos != std::string::npos);
std::string filename = msg.substr(0, extPos + 4); // extract filename including extension
int line;
fromString(&*(msg.begin() + extPos + 5), line); // line number follows
nlwarning((CLuaIHM::createGotoFileButtonTag(filename.c_str(), line) + e.what()).c_str());
}
else
{
// no filename / line in the result, so maybe the parse error was in an 'inline' script
nlwarning("Error in R2 %s (file = %s) : %s", fileDescText, filename, e.what());
}
}
return false;
}
///////////////////////
// CONTEXTUAL CURSOR //
///////////////////////
// *********************************************************************************************************
void CEditor::checkCursor()
{
//H_AUTO(R2_CEditor_checkCursor)
CHECK_EDITOR
// no-op there : we delegate management of mouse to the CTool derived classes
}
// *********************************************************************************************************
void CEditor::mouseClick(bool rightButton, bool /* dblClick */)
{
//H_AUTO(R2_CEditor_mouseClick)
CHECK_EDITOR
CTool *currentTool = getEditor().getCurrentTool();
if (!currentTool) return;
if (!rightButton)
{
// nb : result not handled there (no defaut action for left click)
currentTool->onMouseLeftButtonClicked();
}
else
{
bool handled = currentTool->onMouseRightButtonClicked();
if (!handled)
{
getEditor().displayContextMenu();
}
}
}
// *********************************************************************************************************
void CEditor::updatePreCamera()
{
//H_AUTO(R2_CEditor_updatePreCamera)
if (_Mode == EditionMode)
{
static uint32 loop = 0;
++loop;
if (loop % 200 == 0) // minimal wait between to save = 20 seconds
{
if ( (CTime::getLocalTime() -_LastAutoSaveTime)/1000 > ClientCfg.R2EDAutoSaveWait) // 5 minutes if not change in Confile
{
autoSave();
}
loop = 0;
}
// if there's no pending action, then start a new one at each frame
if (!_DMC->getActionHistoric().isPendingActionInProgress())
{
_DMC->newAction(CI18N::get("uiR2EDUnamedAction"));
}
else
{
_DMC->getActionHistoric().flushPendingAction();
}
}
}
// *********************************************************************************************************
void CEditor::updatePrimitiveContextualVisibility()
{
//H_AUTO(R2_CEditor_updatePrimitiveContextualVisibility)
if (!_SelectedInstance) return;
// if selected instance remains in last contextual prim list, then they may remain visible
bool ok = false;
for(uint k = 0; k < _LastContextualPrims.size(); ++k)
{
if (_LastContextualPrims[k] == _SelectedInstance ||
_SelectedInstance->isSonOf(_LastContextualPrims[k])
)
{
ok = true;
break;
}
}
_LastContextualPrims.clear();
bool isLogicEntity = _SelectedInstance->isKindOf("LogicEntity");
if (!ok && !isLogicEntity) return;
if (isLogicEntity)
{
_LastContextualLogicEntity = _SelectedInstance;
}
if (!_LastContextualLogicEntity) return;
//
CObject *seq = _LastContextualLogicEntity->getGroupSelectedSequence();
if (!seq) return;
if (seq)
{
CObjectTable *activities = seq->toTable("Components");
if (activities)
{
// get first world object parent to get start position
for(uint k = 0; k < activities->getSize(); ++k)
{
// search next zone of activity
CObjectTable *activity = activities->getValue(k)->toTable();
if (!activity) continue;
std::string zoneId = getString(activity, "ActivityZoneId");
CInstance *primitive = getInstanceFromId(zoneId);
if (primitive)
{
CDisplayerVisualGroup *primDisp = dynamic_cast<CDisplayerVisualGroup *>(primitive->getDisplayerVisual());
if (primDisp)
{
_LastContextualPrims.push_back(primitive);
primDisp->setContextualVisibilityDate(T1);
}
}
}
}
}
}
// *********************************************************************************************************
CEntitySorter *CEditor::getEntitySorter() const
{
return _EntitySorter;
}
// *********************************************************************************************************
void CEditor::updateBeforeRender()
{
//H_AUTO(R2_CEditor_updateBeforeRender)
CHECK_EDITOR
//
_IslandCollision.updateCurrPackedIsland();
// update contextual visibility of primitive from current selection
updatePrimitiveContextualVisibility();
//
if (ConnectionWanted) return; // TMP special case for connection
if (_CurrentTool)
{
_CurrentTool->updateBeforeRender();
}
for(TInstanceMap::iterator it = _Instances.begin(); it != _Instances.end(); ++it)
{
if (it->second->getDisplayerVisual())
{
it->second->getDisplayerVisual()->onPreRender();
}
}
updateSelectingDecals();
// hide or show user depending on the mode
if (UserEntity)
{
if (_Mode == EditionMode || isDMing())
{
updateDecalBlendRegion(_PionneerDecal, UserEntity->pos());
showDecal(CVector2f((float) UserEntity->pos().x, (float) UserEntity->pos().y), 1.f, _PionneerDecal, _PionneerDecalAnim);
}
}
if ((_SelectedInstance && _SelectedInstance->maxVisibleEntityExceeded()) ||
(_FocusedInstance && _FocusedInstance->maxVisibleEntityExceeded()))
{
setMaxVisibleEntityExceededFlag(true);
}
else
{
setMaxVisibleEntityExceededFlag(false);
}
}
// *********************************************************************************************************
void CEditor::updateDecalBlendRegion(CDecal &decal, const NLMISC::CVector &pos)
{
//H_AUTO(R2_CEditor_updateDecalBlendRegion)
float topBlendDist = CV_DecalTopBlendStartDist.get();
float bottomBlendDist = CV_DecalBottomBlendStartDist.get();
float blendLength = CV_DecalBlendLength.get();
decal.setBottomBlend(pos.z - bottomBlendDist - blendLength,
pos.z - bottomBlendDist);
decal.setTopBlend(pos.z + topBlendDist,
pos.z + topBlendDist + blendLength);
}
// *********************************************************************************************************
void CEditor::updateBeforeSwapBuffer()
{
//H_AUTO(R2_CEditor_updateBeforeSwapBuffer)
CHECK_EDITOR
if (_WaitScenarioScreenWanted)
{
waitScenario();
_WaitScenarioScreenWanted= false;
}
}
// *********************************************************************************************************
void CEditor::waitScenario()
{
//H_AUTO(R2_CEditor_waitScenario)
_EditionModeDisconnectedFlag = false;
_WaitScenarioScreenActive = true;
waitScenarioScreen();
_WaitScenarioScreenActive = false;
if (_PostponeScenarioUpdated)
{
scenarioUpdated(_NewScenario, false, _NewScenarioInitialAct);
_PostponeScenarioUpdated = false;
_NewScenario = NULL;
}
}
// *********************************************************************************************************
void CEditor::updateAfterRender()
{
if (_EntitySorter) _EntitySorter->clipEntitiesByDist();
//H_AUTO(R2_CEditor_updateAfterRender)
_IslandCollision.updateCurrPackedIsland();
CHECK_EDITOR
if (ConnectionWanted)
{
connect();
return;
}
//
if (_CurrentTool)
{
_CurrentTool->updateAfterRender();
}
if (!_LuaUIMainLoop.isNil())
{
_LuaUIMainLoop.callMethodByNameNoThrow("onPostSceneRender", 0, 0);
}
//
for(TInstanceMap::iterator it = _Instances.begin(); it != _Instances.end(); ++it)
{
if (it->second->getDisplayerVisual())
{
it->second->getDisplayerVisual()->onPostRender();
}
}
}
// *********************************************************************************************************
void CEditor::autoSave()
{
//H_AUTO(R2_CEditor_autoSave)
_LastAutoSaveTime = NLMISC::CTime::getLocalTime();
uint32 maxAutoSave = ClientCfg.R2EDAutoSaveSlot;
std::string lastFile = toString("autosave_%u", maxAutoSave);
uint32 i = maxAutoSave -1;
for ( ; i != 0 ; --i )
{
std::string current = NLMISC::toString("autosave_%02u.r2", i);
std::string next = NLMISC::toString("autosave_%02u.r2", i+1);
if (CFile::fileExists(current))
{
if (CFile::fileExists(next)) // true only for i = maxAutoSave -1
{
CFile::deleteFile(next);
}
CFile::moveFile(next.c_str(), current.c_str());
}
}
if (CFile::fileExists("data/r2_buffer.dat"))
{
CFile::copyFile("autosave_01.r2", "data/r2_buffer.dat");
}
R2::getEditor().getLua().executeScriptNoThrow("r2.Version.save(\"data/r2_buffer.dat\")");
}
// *********************************************************************************************************
bool CEditor::handleEvent (const CEventDescriptor &eventDesc)
{
//H_AUTO(R2_CEditor_handleEvent )
CHECK_EDITOR
if (ConnectionWanted || !_CurrentTool) return false; // TMP special case for connection
if (eventDesc.getType() == CEventDescriptor::system)
{
const CEventDescriptorSystem &eds = (const CEventDescriptorSystem &) eventDesc;
if (eds.getEventTypeExtended() == CEventDescriptorSystem::setfocus)
{
const CEventDescriptorSetFocus &edsf = (const CEventDescriptorSetFocus &) eds;
if (edsf.hasFocus() == false)
{
// cancel current tool
setCurrentTool(NULL);
return true;
}
}
}
if (_CurrentTool)
{
return _CurrentTool->handleEvent(eventDesc);
}
return false;
}
// *********************************************************************************************************
void CEditor::copy()
{
//H_AUTO(R2_CEditor_copy)
// forward to lua
callEnvMethod("copy", 0);
}
// *********************************************************************************************************
void CEditor::paste()
{
//H_AUTO(R2_CEditor_paste)
// forward to lua
callEnvMethod("paste", 0);
}
// *********************************************************************************************************
/*
void CEditor::updateEvents()
{
if (!_CurrentTool) return;
//
if(EventsListener.isMouseButtonPushed(leftButton))
{
nlwarning("onMouseLeftButtonDown");
_CurrentTool->onMouseLeftButtonDown();
}
if(EventsListener.isMouseButtonReleased(leftButton))
{
nlwarning("isMouseButtonReleased");
_CurrentTool->onMouseLeftButtonUp();
}
if(EventsListener.isMouseButtonPushed(rightButton))
{
nlwarning("isMouseButtonPushed");
_CurrentTool->onMouseRightButtonDown();
}
if(EventsListener.isMouseButtonReleased(rightButton))
{
nlwarning("onMouseRightButtonUp");
_CurrentTool->onMouseRightButtonUp();
}
}*/
// *********************************************************************************************************
CEntityCL *CEditor::createEntity(uint slot, const NLMISC::CSheetId &sheetId, const NLMISC::CVector &pos, float heading, const std::string & permanentStatutIcon)
{
//H_AUTO(R2_CEditor_createEntity)
CHECK_EDITOR
if (sheetId == NLMISC::CSheetId::Unknown) return NULL;
CInterfaceManager *im = CInterfaceManager::getInstance();
if (EntitiesMngr.entity(slot))
{
EntitiesMngr.remove(slot, false);
}
// Create the temporary entity in the entity manager
TNewEntityInfo emptyEntityInfo;
emptyEntityInfo.reset();
CEntityCL *entity = EntitiesMngr.create(slot, sheetId.asInt(), emptyEntityInfo);
if (!entity)
{
nlwarning("Can't create entity");
return NULL;
}
// Set the permanent statut icon
entity->setPermanentStatutIcon(permanentStatutIcon);
// TMP TMP : code taken from /entity command
sint64 *prop = 0;
CCDBNodeLeaf *node = 0;
// Set The property 'CLFECOMMON::PROPERTY_POSITION'.
node = im->getDbProp("SERVER:Entities:E" + NLMISC::toString("%d", slot)+":P" + NLMISC::toString("%d", CLFECOMMON::PROPERTY_POSX), false);
if(node)
{
sint64 x = (sint64)(pos.x*1000.0);
sint64 y = (sint64)(pos.y*1000.0);
sint64 z = (sint64)(pos.z*1000.0);
node->setValue64(x);
node = im->getDbProp("SERVER:Entities:E"+toString("%d", slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_POSY), false);
if(node)
{
node->setValue64(y);
node = im->getDbProp("SERVER:Entities:E"+toString("%d", slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_POSZ), false);
if(node)
node->setValue64(z);
}
}
// Set The property 'PROPERTY_ORIENTATION'.
node = im->getDbProp("SERVER:Entities:E"+toString("%d", slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_ORIENTATION), false);
if(node)
{
union
{
uint64 heading64;
float headingFloat;
};
headingFloat = heading;
node->setValue64(heading64);
}
// Set Mode
node = im->getDbProp("SERVER:Entities:E"+toString("%d", slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_MODE), false);
if(node)
{
MBEHAV::EMode m = MBEHAV::NORMAL;
prop = (sint64 *)&m;
node->setValue64(*prop);
EntitiesMngr.updateVisualProperty(0, slot, CLFECOMMON::PROPERTY_MODE);
}
// Set Visual Properties
SPropVisualA visualA;
//visualA.PropertySubData.LTrail = 1;
// Set alternate look
SAltLookProp altLookProp;
// fill infos for look
prop = (sint64 *)&visualA;
if(dynamic_cast<CPlayerCL *>(entity))
{
// visual property A depends on the type of the entity
visualA.PropertySubData.Sex = ClientCfg.Sex;
}
else if(dynamic_cast<CPlayerR2CL *>(entity) == NULL)
{
// Get the database entry.
// Get the old value (not useful since we change the whole property).
altLookProp.Summary = 0;
altLookProp.Element.ColorTop = 0;
altLookProp.Element.ColorBot = 2;
altLookProp.Element.WeaponRightHand = 0;
altLookProp.Element.WeaponLeftHand = 0;
altLookProp.Element.Seed = 100;
altLookProp.Element.ColorHair = 4;
altLookProp.Element.Hat = 0;
// old colors
altLookProp.Element.ColorGlove = altLookProp.Element.ColorTop;
altLookProp.Element.ColorArm = altLookProp.Element.ColorTop;
altLookProp.Element.ColorBoot = altLookProp.Element.ColorBot;
// fill alt infos for look
prop = (sint64 *)&altLookProp.Summary;
}
// Set the database.
im->getDbProp("SERVER:Entities:E"+toString("%d", slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_VPA))->setValue64(*prop);
// Set Visual Properties
SPropVisualB visualB;
visualB.PropertySubData.LTrail = 1;
// fill infos for look
sint64 *propB = 0;
propB = (sint64 *)&visualB;
// Set the database.
im->getDbProp("SERVER:Entities:E"+toString("%d", slot)+":P"+toString("%d", CLFECOMMON::PROPERTY_VPB))->setValue64(*propB);
// Apply Changes.
EntitiesMngr.updateVisualProperty(0, slot, CLFECOMMON::PROPERTY_VPA);
EntitiesMngr.updateVisualProperty(0, slot, CLFECOMMON::PROPERTY_VPB);
return entity;
}
// *********************************************************************************************************
CInstance *CEditor::getInstanceFromEntity(CEntityCL *entity) const
{
//H_AUTO(R2_CEditor_getInstanceFromEntity)
CHECK_EDITOR
for(TInstanceMap::const_iterator it = _Instances.begin(); it != _Instances.end(); ++it)
{
if (it->second->getEntity() == entity) return it->second;
}
return NULL;
}
// *********************************************************************************************************
void CEditor::displayContextMenu()
{
//H_AUTO(R2_CEditor_displayContextMenu)
CHECK_EDITOR
if (!_SelectedInstance)
{
// launch standard context menu (for free look & move options)
getUI().launchContextMenuInGame("ui:interface:game_context_menu_edition");
return;
}
if (getCurrentTool() && getCurrentTool()->isCreationTool())
{
setCurrentTool(NULL);
}
// retrieve the context menu depending on the type of the entity
CLuaObject classDesc = _SelectedInstance->getClass();
if (classDesc.isNil())
{
nlwarning("Can't retrieve object class");
return;
}
std::string menu = classDesc["Menu"];
if (menu.empty()) return; // no menu for that instance ?
//
CLuaObject menuSetupFunction = classDesc["onSetupMenu"];
if (menuSetupFunction.isFunction())
{
_SelectedInstance->getLuaProjection().push();
menuSetupFunction.callNoThrow(1, 0);
}
//
getUI().launchContextMenuInGame(menu);
}
// *********************************************************************************************************
void CEditor::triggerInstanceObserver(const TInstanceId &id, IObserverAction &action)
{
//H_AUTO(R2_CEditor_triggerInstanceObserver)
TInstanceObserverMap::iterator lb = _InstanceObservers.lower_bound(id);
TInstanceObserverMap::iterator ub = _InstanceObservers.upper_bound(id);
if (lb == ub) return;
// must do a copy, because an observer may erase himself from the list when it is triggered
static std::vector<IInstanceObserver::TRefPtr> dest;
dest.clear();
for (TInstanceObserverMap::iterator it = lb; it != ub; ++it)
{
dest.push_back(it->second);
}
for (std::vector<IInstanceObserver::TRefPtr>::iterator it = dest.begin(); it != dest.end(); ++it)
{
if (*it) action.doAction(**it);
}
}
// *********************************************************************************************************
void CEditor::onErase(CObject *object)
{
//H_AUTO(R2_CEditor_onErase)
bool dummyFoundInBase;
std::string dummyNameInParent;
onErase(object, dummyFoundInBase, dummyNameInParent);
}
// *********************************************************************************************************
void CEditor::onErase(CObject *root, bool &foundInBase, std::string &nameInParent)
{
//H_AUTO(R2_CEditor_onErase)
foundInBase = false;
CHECK_EDITOR
if (!root) return;
CInstance *inst = getInstanceFromObject(root);
// sons
if (root->isTable())
{
for(uint k = 0; k < root->getSize(); ++k)
{
CObject *obj = root->getValue(k);
if (obj->isTable())
{
onErase(obj);
}
}
}
//
CObject *parent = NULL;
//
if (inst)
{
// Add an 'Erased' flag to the object so that
// any pending property in the property sheet
// won't send a 'requestSetNode' when it is closed
try
{
(*inst).getLuaProjection()["User"].setValue("Erased", true);
}
catch (ELuaNotATable &e)
{
nlwarning(e.what());
}
// if object is selected or focused, then clear these flags
if (inst == getSelectedInstance())
{
setSelectedInstance(NULL);
}
if (inst == getFocusedInstance())
{
setFocusedInstance(NULL);
}
}
// if object can be found in its base, then not really a deletion, but
// rather a change of attribute to the "default value' (may happen in an undo operation)
parent = root->getParent();
if (parent)
{
sint32 sonIndex = parent->findIndex(root);
if (sonIndex != -1)
{
nameInParent = parent->getKey(sonIndex);
if (!nameInParent.empty() && getDMC().getPropertyAccessor().hasValueInBase(parent, nameInParent))
{
foundInBase = true;
}
}
}
if (inst && !foundInBase)
{
// send event to instance & displayers
inst->onErase();
// trigger observers
class CEraseNotification : public IObserverAction
{
public:
CEraseNotification(CInstance &instance) : Instance(instance) {}
virtual void doAction(IInstanceObserver &obs)
{
obs.onInstanceErased(Instance);
}
CInstance &Instance;
};
CEraseNotification eraseNotification(*inst);
triggerInstanceObserver(inst->getId(), eraseNotification);
}
// if object has a user environment attached to it, remove it from lua
if (inst)
{
CLuaStackChecker lsc(&getLua());
getLua().pushLightUserData((void *) root);
getLua().getTable(LUA_REGISTRYINDEX);
if (!getLua().isNil())
{
getLua().pushLightUserData((void *) root); // key
getLua().pushNil(); // value
getLua().setTable(LUA_REGISTRYINDEX); // erase
}
getLua().pop();
}
if (root->isTable())
{
// special patch: ref ids under this object should not be triggered any more for that object
CObjectTable *rootTable = root->toTable();
for (uint32 k = 0; k < rootTable->getSize(); ++k)
{
CObject *obj = rootTable->getValue(k);
CObjectRefIdClient *objRefId = dynamic_cast<CObjectRefIdClient *>(obj);
if (objRefId)
{
objRefId->enable(false); // don't observe anything
}
}
}
if (!_ClearingContent)
{
if (inst)
{
nlassert(_Instances.count((const CObjectTable *) root) == 1);
//nlwarning("Instance with id %s deleted, but not inserted", inst->getId().c_str());
}
}
// really remove object
//nlwarning("Removing instance with id %s (table = 0x%s)", inst->getId().c_str(), (int) root);
if (inst)
{
_Instances.erase((const CObjectTable *) root);
}
}
// *********************************************************************************************************
void CEditor::nodeErased(const std::string& instanceId, const std::string& attrName, sint32 position)
{
//H_AUTO(R2_CEditor_nodeErased)
CHECK_EDITOR
CObject *obj = _DMC->find(instanceId, attrName, position);
if (!obj) return;
bool foundInBase;
std::string nameInParent;
onErase(obj, foundInBase, nameInParent);
CObject *parent = obj->getParent();
_DMC->CDynamicMapClient::nodeErased(instanceId, attrName, position);
if (foundInBase)
{
nlassert(parent);
// erased, but reading in the base will give a new value, so the real
// action from observers standpoint is 'modified'
CInstance *parentInstance = getInstanceFromObject(parent);
if (parentInstance)
{
onAttrModified(*parentInstance, nameInParent);
}
else
{
nlwarning("Can't found instance in which %s was modified", nameInParent.c_str());
}
}
// warn the parent that it has been modified
onAttrModified(parent);
// NB : msg for deleted attribute does not exist yet, so the parent is warned that it is modified, but
// 'onTableModified' is not called (because key doesn't exist any more)
}
void CEditor::onResetEditionMode()
{
//H_AUTO(R2_CEditor_onResetEditionMode)
CHECK_EDITOR
// called when a scenario just before a scenario is created
// no-op, to clean
}
void CEditor::onEditionModeConnected( uint32 userSlotId, uint32 adventureId, CObject* highLevel, const std::string& versionName, bool willTP, uint32 initialActIndex)
{
//H_AUTO(R2_CEditor_onEditionModeConnected)
CHECK_EDITOR
if (!_WaitScenarioScreenActive)
{
setMode(EditionMode);
}
CInterfaceGroup *currentSessionGroup = dynamic_cast<CInterfaceGroup *>(getUI().getElementFromId("ui:interface:r2ed_current_session"));
if (currentSessionGroup)
{
CViewText *text = dynamic_cast<CViewText *>(currentSessionGroup->getView("current_session"));
if (text)
{
text->setText(toString("Edition Session = %d (%s)", adventureId, versionName.c_str()));
}
}
setDefaultChatWindow(PeopleInterraction.ChatGroup.Window);
_DMC->CDynamicMapClient::onEditionModeConnected(userSlotId, adventureId, highLevel, versionName, willTP, initialActIndex);
}
void CEditor::setAccessMode(TAccessMode mode)
{
//H_AUTO(R2_CEditor_setAccessMode)
_AccessMode = mode;
switch ( mode)
{
case AccessEditor: _Env.setValue("AccessMode", "Editor"); break;
case AccessDM:
_Env.setValue("AccessMode", "DM");
if (_Mode == AnimationModePlay)
{
loadStandardUI();
}
break;
case AccessOutlandOwner: _Env.setValue("AccessMode", "OutlandOwner"); break;
default:
nlassert(0);
break;
}
}
void CEditor::onAnimationModeConnected(const CClientMessageAdventureUserConnection& connected)
{
//H_AUTO(R2_CEditor_onAnimationModeConnected)
_ScenarioReceivedFlag = true; // end wait screen
// TMP PATCH
// _WillTP = true;
CHECK_EDITOR
switch(connected.Mode)
{
case 0: setMode(AnimationModeLoading); break;
case 1: setMode(AnimationModeWaitingForLoading); break;
case 2: setMode(AnimationModeDm); break;
case 3: setMode(AnimationModePlay); break;
default: nlwarning("Unhandled %u in Animation Session", connected.Mode);
}
CInterfaceGroup *currentSessionGroup = dynamic_cast<CInterfaceGroup *>(getUI().getElementFromId("ui:interface:r2ed_current_session"));
if (currentSessionGroup)
{
CViewText *text = dynamic_cast<CViewText *>(currentSessionGroup->getView("current_session"));
if (text)
{
text->setText(toString("Animation Session = %d (%s)", connected.SessionId.asInt(), connected.VersionName.c_str()));
}
}
setDefaultChatWindow(PeopleInterraction.ChatGroup.Window);
_DMC->CDynamicMapClient::onAnimationModeConnected(connected);
}
void CEditor::onEditionModeDisconnected()
{
//H_AUTO(R2_CEditor_onEditionModeDisconnected)
_EditionModeDisconnectedFlag = true;
delete _NewScenario;
_NewScenario = NULL;
CHECK_EDITOR
// Usefull only for the pionner that does not do requestTranslateFeatures()
// Because avec using the button the currentScenario = 0
try
{
R2::getEditor().getLua().executeScript("r2.Version.save(\"data/r2_buffer.dat\")");
}
catch (const std::exception& e)
{
nlwarning("Can't start Edition Mode", e.what());
}
_DMC->CDynamicMapClient::onEditionModeDisconnected();
}
void CEditor::onTestModeConnected()
{
//H_AUTO(R2_CEditor_onTestModeConnected)
CHECK_EDITOR
// TODO nico : change the name of the function : should rather be 'onAnimationModeConnected'
// start as a GM
getUI().runActionHandler("r2ed_anim_dm_mode", NULL, "");
_DMC->CDynamicMapClient::onTestModeConnected();
}
void CEditor::onTestModeDisconnected(TSessionId sessionId, uint32 lastAct, TScenarioSessionType sessionType)
{
//H_AUTO(R2_CEditor_onTestModeDisconnected)
CHECK_EDITOR
_DMC->CDynamicMapClient::onTestModeDisconnected(sessionId, lastAct, sessionType);
}
// *********************************************************************************************************
void CEditor::nodeInserted(const std::string& instanceId, const std::string& attrName, sint32 position, const std::string& key, CObject* value)
{
//H_AUTO(R2_CEditor_nodeInserted)
CHECK_EDITOR
_DMC->CDynamicMapClient::nodeInserted(instanceId, attrName, position, key, value);
if (value->isTable())
{
std::string id = getString(value, "InstanceId");
if (!id.empty())
{
const CObject *clonedValue = _DMC->find(id);
// bad insert
if (clonedValue)
{
createNewInstanceForObjectTable(clonedValue);
onAttrModified(clonedValue->getParent()); // parent table is modified
// so -> only parent of parent table will be notified of change
// maybe we need another msg "onInsert" that is sent
// to the parent table.
}
}
}
}
// *********************************************************************************************************
void CEditor::createNewInstanceForObjectTable(const CObject *obj)
{
//H_AUTO(R2_CEditor_createNewInstanceForObjectTable)
CHECK_EDITOR
createNewInstanceForObjectTableInternal(obj);
onPostCreate(obj);
}
// *********************************************************************************************************
void CEditor::notifyInstanceObserversOfCreation(CInstance &inst)
{
//H_AUTO(R2_CEditor_notifyInstanceObserversOfCreation)
CHECK_EDITOR
// if there are observers watching this instance, warn them
const std::string &id = inst.getId();
// trigger observers
class CCreationNotification : public IObserverAction
{
public:
CCreationNotification(CInstance &instance) : Instance(instance) {}
virtual void doAction(IInstanceObserver &obs)
{
obs.onInstanceCreated(Instance);
}
CInstance &Instance;
};
CCreationNotification creationNotification(inst);
triggerInstanceObserver(id, creationNotification);
}
// *********************************************************************************************************
void CEditor::onPostCreate(const CObject *obj)
{
//H_AUTO(R2_CEditor_onPostCreate)
CHECK_EDITOR
struct CPostCreateVisitor : public IObjectVisitor
{
virtual void visit(CObjectTable &obj)
{
// if table has a "InstanceId" field there is a matching editor object
CInstance *inst = getEditor().getInstanceFromObject(&obj);
if (inst)
{
inst->onPostCreate();
getEditor().notifyInstanceObserversOfCreation(*inst);
}
}
};
if (obj)
{
CPostCreateVisitor postCreateVisitor;
const_cast<CObject *>(obj)->visit(postCreateVisitor);
}
}
// *********************************************************************************************************
sint CEditor::getLeftQuota()
{
//H_AUTO(R2_CEditor_getLeftQuota)
CLuaState &ls = getLua();
CLuaStackChecker lsc(&ls);
callEnvMethod("getLeftQuota", 0, 1);
if (!ls.isNumber(-1))
{
ls.pop(1);
return 0;
}
sint result = (sint) ls.toNumber(-1);
ls.pop(1);
return result;
}
// *********************************************************************************************************
bool CEditor::checkRoomLeft()
{
//H_AUTO(R2_CEditor_checkRoomLeft)
return getLeftQuota() > 0;
}
// *********************************************************************************************************
void CEditor::makeRoomMsg()
{
//H_AUTO(R2_CEditor_makeRoomMsg)
// delegate ui display to lua
callEnvMethod("makeRoomMsg", 0, 0);
}
// *********************************************************************************************************
bool CEditor::verifyRoomLeft(uint aiCost, uint staticCost)
{
//H_AUTO(R2_CEditor_verifyRoomLeft)
CLuaState &ls = getLua();
if (aiCost)
{
CLuaStackChecker lsc(&ls);
getEditor().getLua().push((lua_Number)aiCost);
callEnvMethod("checkAiQuota", 1, 1);
if (!ls.isBoolean(-1))
{
ls.pop(1);
return false;
}
sint result = (sint) ls.toBoolean(-1);
ls.pop(1);
return result != 0;
}
if (staticCost)
{
CLuaStackChecker lsc(&ls);
getEditor().getLua().push((lua_Number)staticCost);
callEnvMethod("checkStaticQuota", 1, 1);
if (!ls.isBoolean(-1))
{
ls.pop(1);
return false;
}
sint result = (sint) ls.toBoolean(-1);
ls.pop(1);
return result != 0;
}
return true;
}
// *********************************************************************************************************
void CEditor::createNewInstanceForObjectTableInternal(const CObject *obj)
{
//H_AUTO(R2_CEditor_createNewInstanceForObjectTableInternal)
CHECK_EDITOR
if (!obj) return;
if (!obj->isTable()) return; // not a table ...
const CObjectTable *table = (const CObjectTable *) obj;
std::string id = getString(obj, "InstanceId");
if (!id.empty())
{
// CInstance is created only for objects with an instance id
CInstance *inst = new CInstance(table, getLua());
nlassert(_Instances.count(table) == 0);
_Instances[table] = inst;
// if a cookie was created, add in in the instance lua 'User' table
TCookieMap::iterator cookieList = _Cookies.find(id);
if (cookieList != _Cookies.end())
{
if (obj->isTable())
{
CLuaState &ls = getLua();
getLuaUserTableFromObject(ls, * (CObjectTable *) obj);
CLuaObject userTable(ls); // pop the table into a CLuaObject for convenience
for (TCookieList::iterator it = cookieList->second.begin(); it != cookieList->second.end(); ++it)
{
userTable.setValue(it->Key, it->Value);
}
}
_Cookies.erase(cookieList);
}
// create displayers
CLuaObject classDesc = inst->getClass();
if (!classDesc.isNil())
{
CLuaStackChecker lsc(&getLua());
CDisplayerVisual *dispViz= createObjectFromClassName<CDisplayerVisual>(classDesc["DisplayerVisual"].toString());
if (dispViz)
{
bool ok = dispViz->init(classDesc["DisplayerVisualParams"]);
if (!ok)
{
nlwarning("Error when calling init on visual displayer of class %s", classDesc["Name"].toString().c_str());
}
}
inst->setDisplayerVisual(dispViz);
//
CDisplayerBase *dispUI = createObjectFromClassName<CDisplayerBase>(classDesc["DisplayerUI"].toString());
if (dispUI)
{
bool ok = dispUI->init(classDesc["DisplayerUIParams"]);
if (!ok)
{
nlwarning("Error when calling init on ui displayer of class %s", classDesc["Name"].toString().c_str());
}
}
inst->setDisplayerUI(dispUI);
//
CDisplayerBase *dispProp = createObjectFromClassName<CDisplayerBase>(classDesc["DisplayerProperties"].toString());
if (dispProp)
{
bool ok = dispProp->init(classDesc["DisplayerPropertiesParams"]);
if (!ok)
{
nlwarning("Error when calling init on property displayer of class %s", classDesc["Name"].toString().c_str());
}
}
inst->setDisplayerProperties(dispProp);
}
// prevent completion of the tree while an instance is being created
//backupRequestCommands();
inst->onCreate();
//restoreRequestCommands();
//
// if a name was generated locally, erase from the local name map.
std::string className = getString(obj, "Class");
std::string name = getString(obj, "Name");
if (!className.empty() && !name.empty())
{
for (TGeneratedNameMap::iterator it = _LocalGeneratedNames.begin(); it != _LocalGeneratedNames.end(); ++it)
{
sint index = getGeneratedNameIndex(name, it->first);
if (index != -1)
{
it->second.erase(index);
break;
}
}
}
}
// do the same on sons
for(uint k = 0; k < table->getSize(); ++k)
{
createNewInstanceForObjectTableInternal(table->getValue(k));
}
}
// *********************************************************************************************************
void CEditor::onAttrModified(CInstance &parentInstance, const std::string &attrName, sint32 indexInArray)
{
//H_AUTO(R2_CEditor_onAttrModified)
parentInstance.onAttrModified(attrName, indexInArray);
class CAttrModifiedNotification : public IObserverAction
{
public:
CAttrModifiedNotification(CInstance &instance, const std::string &key, sint32 indexInArray)
: Instance(instance), Key(key), IndexInArray(indexInArray) {}
virtual void doAction(IInstanceObserver &obs)
{
obs.onAttrModified(Instance, Key, IndexInArray);
}
CInstance &Instance;
const std::string &Key;
sint32 IndexInArray;
};
CAttrModifiedNotification attrModifiedNotification(parentInstance, attrName, indexInArray);
triggerInstanceObserver(parentInstance.getId(), attrModifiedNotification);
}
// *********************************************************************************************************
void CEditor::onAttrModified(const CObject *value)
{
//H_AUTO(R2_CEditor_onAttrModified)
CHECK_EDITOR
if (!value) return;
const CObject *son = value;
const CObject *parent = value->getParent();
sint32 indexInArray = -1;
while (parent)
{
CInstance *parentInstance = getInstanceFromObject(parent);
sint32 indexInParent = parent->findIndex(son);
nlassert(indexInParent != -1);
if (parentInstance)
{
// we are in an instance (a CObjectTable with an instance id)
// TODO nico : a cache for the 'name' in the parent like with CObjectRefId ...
std::string key = parent->getKey(indexInParent);
onAttrModified(*parentInstance, key, indexInArray);
indexInArray = -1;
}
else
{
// we are in an array in an instance -> memorize index in that array for next call to "onAttrModified"...
indexInArray = indexInParent;
}
son = parent;
parent = parent->getParent();
}
}
// *********************************************************************************************************
void CEditor::nodeSet(const std::string& instanceId, const std::string& attrName, CObject* value)
{
//H_AUTO(R2_CEditor_nodeSet)
CHECK_EDITOR
CObject *obj = _DMC->find(instanceId);
if (!obj) return;
// erase previous object
nlassert(obj->isTable());
//
if (!attrName.empty())
{
obj = obj->findAttr(attrName);
}
if (obj)
{
onErase(obj);
}
// change the actual value
_DMC->CDynamicMapClient::nodeSet(instanceId, attrName, value);
//
nlassert(!getInstanceFromObject(value)); // this must be a new object...
//
if (value->isTable())
{
std::string id = getString(value, "InstanceId");
if (!id.empty())
{
const CObject *clonedValue = _DMC->find(id);
if (clonedValue)
{
createNewInstanceForObjectTable(clonedValue); // if the created object is a table, warn him that he has been created
onAttrModified(clonedValue);
return;
}
}
}
// no instance id for object, retrieve object pointer from parent
const CObject *parent = _DMC->find(instanceId);
if (!parent) return;
onAttrModified(parent->getAttr(attrName));
}
// *********************************************************************************************************
void CEditor::eraseScenario()
{
//H_AUTO(R2_CEditor_eraseScenario)
if (_Scenario)
{
backupRequestCommands();
onErase(_Scenario);
restoreRequestCommands();
_Scenario = NULL;
}
}
// *********************************************************************************************************
void CEditor::scenarioUpdated(CObject* highLevel, bool willTP, uint32 initialActIndex)
{
//H_AUTO(R2_CEditor_scenarioUpdated)
CHECK_EDITOR
_ScenarioReceivedFlag = true;
if (_WaitScenarioScreenActive)
{
// defer scenario update to the end of the wait screen
_NewScenario = highLevel ? highLevel->clone() : NULL;
_NewScenarioInitialAct = initialActIndex;
_PostponeScenarioUpdated = true;
return;
}
if (!highLevel)
{
_IsStartingScenario = false;
_WillTP = false;
callEnvFunc("onEmptyScenarioUpdated", 0);
return;
}
// _WillTP = willTP;
_WillTP = false; // TMP TMP
_UpdatingScenario = true;
_BaseAct = NULL;
_CurrentAct = NULL;
CLuaStackRestorer lsc(&getLua(), getLua().getTop());
//nlwarning("Scenario updated, start highlevel = ");
//highLevel->dump();
eraseScenario();
_IsStartingScenario = false;
if (_DMC->getEditionModule().getMustStartScenario())
{
_IsStartingScenario = true;
}
nlassert(_Instances.empty());
nlassert(CDisplayerBase::ObjCount == 0);
//
_DMC->CDynamicMapClient::scenarioUpdated(highLevel, willTP, initialActIndex);
//nlwarning("Scenario updated, content is = ");
/*
if (_DMC->getHighLevel())
{
_DMC->getHighLevel()->dump();
}
else
{
nlwarning("NULL");
}
*/
createNewInstanceForObjectTableInternal(_DMC->getHighLevel());
nlassert(highLevel->isTable());
_Scenario = (CObjectTable *) _DMC->getHighLevel();
if (_Scenario->getAttr("InstanceId"))
{
_ScenarioInstance = getInstanceFromId(_Scenario->getAttr("InstanceId")->toString());
}
else
{
_ScenarioInstance = NULL;
nlwarning("Can't retrieve scenario (no instance id)");
_Scenario->dump();
}
static volatile bool forceDump = false;
if (forceDump)
{
_Scenario->dump();
}
//
projectInLua(_Scenario); // push on the lua stack
getLua().push(float(initialActIndex)); // example reconnect after test in act4
// update value in the framework
callEnvFunc("onScenarioUpdated", 2);
//nlwarning("Instance list now is :");
//dumpInstances();
CObject *acts = _Scenario->getAttr("Acts");
if (acts)
{
CObject *baseAct = acts->getValue(0);
if (baseAct)
{
_BaseAct = getInstanceFromId(baseAct->toString("InstanceId"));
}
}
if (!_BaseAct)
{
nlwarning("Base act not found at scenario update");
}
if (_WantedActOnInit.empty())
{
if (!_CurrentAct) // if act not currently setted at scenario creation ...
{
setCurrentAct(_BaseAct); // ...then default to the base act
}
}
else
{
setCurrentActFromTitle(_WantedActOnInit);
_WantedActOnInit.clear();
}
_DMC->getActionHistoric().clear(highLevel); // reinit the undo / redo stack
onPostCreate(_Scenario); // post creation require that current act has been set
//TP is done via the onTpPositionSimulated message
/*
// teleport in good island
if (ClientCfg.Local)
{
sint locationId = (uint) _ScenarioInstance->getLuaProjection()["Description"]["LocationId"].toNumber();
CScenarioEntryPoints &sep = CScenarioEntryPoints::getInstance();
_IslandCollision.loadEntryPoints();
if (sep.getCompleteIslands().empty())
{
nlwarning("Entry points not loaded, teleport not done (local mode)");
}
else if (locationId >= (sint) sep.getCompleteIslands().size())
{
nlwarning("Bad location id %d", locationId);
}
else
{
// check if already in this entry point (no tp if so)
const CScenarioEntryPoints::CCompleteIsland &ci = sep.getCompleteIslands()[locationId];
CVectorD playerPos = UserEntity->pos();
//
if (playerPos.x <= ci.XMin ||
playerPos.x >= ci.XMax ||
playerPos.y <= ci.YMin ||
playerPos.y >= ci.YMax)
{
if(ci.EntryPoints.size()>0)
{
const CScenarioEntryPoints::CShortEntryPoint & shortEntryPoint = ci.EntryPoints[0];
CVector dest((float) shortEntryPoint.X, (float) shortEntryPoint.Y, 0.f);
UserEntity->pos(dest); // change position in pacs
// Select the closest continent from the new position.
beginLoading (LoadingBackground);
#define BAR_STEP_TP 2 // fixme : this define is duplicated....
ProgressBar.reset (BAR_STEP_TP);
ucstring nmsg("Loading...");
ProgressBar.newMessage ( ClientCfg.buildLoadingString(nmsg) );
ProgressBar.progress(0);
ContinentMngr.select(dest, ProgressBar);
endLoading();
// Teleport the User.
UserEntity->tp(dest);
}
}
}
}
*/
_UpdatingScenario = false;
if (_DMC->getEditionModule().getMustStartScenario()
&& _DMC->getEditionModule().getScenarioUpToDate())
{
_DMC->getEditionModule().setMustStartScenario( false);
if ( _DMC->getCurrentScenario()->getHighLevel())
{
bool result = true;
if (ClientCfg.R2EDMustVerifyRingAccessWhileLoadingAnimation)
{
CLuaState &ls = getLua();
CLuaStackChecker lsc(&ls);
callEnvFunc( "verifyScenario", 0, 1);
if (!ls.isBoolean(-1))
{
nlassert(0 && "verifyScenario return wrong type");
}
result = ls.toBoolean(-1);
ls.pop();
}
if (result) //Start scenario only if allowed
{
ConnectionWanted = true; // ugly
}
}
}
}
// *********************************************************************************************************
CInstance *CEditor::getDefaultFeature(CInstance *act)
{
//H_AUTO(R2_CEditor_getDefaultFeature)
CHECK_EDITOR
if (!act) return NULL;
CObject *defaultFeature = act->getObjectTable()->getAttr("Features");
if (!defaultFeature) return NULL;
defaultFeature = defaultFeature->getValue(0);
if (!defaultFeature) return NULL; // 0 should be the default feature
CInstance *result = getInstanceFromId(defaultFeature->toString("InstanceId"));
if (!result) return NULL;
if (!result->isKindOf("DefaultFeature"))
{
nlwarning("Can't retrieve default feature.");
}
return result;
}
// *********************************************************************************************************
CInstance *CEditor::getDefaultFeature()
{
//H_AUTO(R2_CEditor_getDefaultFeature)
CHECK_EDITOR
return getDefaultFeature(getCurrentAct());
}
// *********************************************************************************************************
void CEditor::nodeMoved(const std::string& instanceId, const std::string& attrName, sint32 position, const std::string& destInstanceId, const std::string& destAttrName, sint32 destPosition)
{
//H_AUTO(R2_CEditor_nodeMoved)
CHECK_EDITOR
const CObject *src = _DMC->find(instanceId, attrName, position);
if (!src) return;
//
CObject *oldParent = src->getParent();
//
CInstance *inst = getInstanceFromObject(src);
// tells object that he is about to move
if (inst)
{
inst->onPreHrcMove();
// notify possible observers that this instance will move
class CPreHrcMoveNotification : public IObserverAction
{
public:
CPreHrcMoveNotification(CInstance &instance) : Instance(instance) {}
virtual void doAction(IInstanceObserver &obs)
{
obs.onPreHrcMove(Instance);
}
CInstance &Instance;
};
CPreHrcMoveNotification preHrcMoveNotification(*inst);
triggerInstanceObserver(inst->getId(), preHrcMoveNotification);
}
// do the move
_DMC->CDynamicMapClient::nodeMoved(instanceId, attrName, position, destInstanceId, destAttrName, destPosition);
// warn the previous parent that it has been modified
if (src->getParent() != oldParent)
{
onAttrModified(oldParent); // the old parent is modified so send appropriate msg
}
// else ... if new parent is the same then send message only at the end (else object believe it has been modified twice in a row)
// tells object that he has moved
if (inst)
{
inst->onPostHrcMove();
// notify possible observers that this instance has moved
class CPostHrcMoveNotification : public IObserverAction
{
public:
CPostHrcMoveNotification(CInstance &instance) : Instance(instance) {}
virtual void doAction(IInstanceObserver &obs)
{
obs.onPostHrcMove(Instance);
}
CInstance &Instance;
};
CPostHrcMoveNotification postHrcMoveNotification(*inst);
triggerInstanceObserver(inst->getId(), postHrcMoveNotification);
}
onAttrModified(src); // the new parent is modified so send appropriate msg
}
// *********************************************************************************************************
void CEditor::dumpInstances()
{
//H_AUTO(R2_CEditor_dumpInstances)
CHECK_EDITOR
for(TInstanceMap::iterator it = _Instances.begin(); it != _Instances.end(); ++it)
{
nlwarning("Obj = %p, id = %s, instance = %p", it->first, it->second->getId().c_str(), &(*it->second));
}
}
// ***************************************************************
struct CSortSelectableObject
{
ISelectableObject *Object;
float Depth;
CVector RayStart, RayStartClipped, RayEndClipped;
NLMISC::CAABBox SelectBox;
bool SelectBoxInWorld;
bool operator<(const CSortSelectableObject &o) const
{
return Depth<o.Depth;
}
};
// special selectable object to detect that mouse is over user
class CSelectableUser : public ISelectableObject
{
public:
virtual bool isSelectable() const { return true; }
virtual bool getLastClip() const { return UserEntity->getLastClip(); }
virtual NLMISC::CAABBox getSelectBox() const
{
return UserEntity->localSelectBox();
}
virtual const NLMISC::CMatrix &getInvertedMatrix() const
{
static CMatrix invertedMatrix;
invertedMatrix = UserEntity->dirMatrix();
invertedMatrix.setPos(UserEntity->pos());
invertedMatrix.invert();
return invertedMatrix;
}
virtual float preciseIntersectionTest(const NLMISC::CVector &worldRayStart, const NLMISC::CVector &worldRayDir) const
{
if (!UserEntity) return FLT_MAX;
return CEditor::preciseEntityIntersectionTest(*UserEntity, worldRayStart, worldRayDir);
}
virtual CInstance *getInstanceInEditor() const { return NULL; }
};
// ***************************************************************
static CSelectableUser SelectableUser;
//
CInstance *CEditor::getInstanceUnderPos(float x, float y, float distSelection, bool &isPlayerUnderCursor)
{
static volatile bool ignore = false;
if (ignore)
{
return NULL;
}
//H_AUTO(R2_CEditor_getInstanceUnderPos)
CHECK_EDITOR
// TODO nico: this code was copied from CEntityManager::getEntityUnderPos
// then modified, so some factoring could be made ...
uint i;
// valid only if bbox still intersect
CInstance *precInstanceUnderPos= _LastInstanceUnderPos;
bool precInstanceUnderPosValid= false;
// reset result
isPlayerUnderCursor= false;
_LastInstanceUnderPos = NULL;
// build the ray
CMatrix camMatrix = MainCam.getMatrix();
NL3D::CFrustum camFrust = MainCam.getFrustum();
NL3D::CViewport viewport = Driver->getViewport();
// Get the Ray made by the mouse.
CTool::CWorldViewRay worldViewRay;
worldViewRay.OnMiniMap = false;
worldViewRay.Valid = true;
//
viewport.getRayWithPoint(x, y, worldViewRay.Origin, worldViewRay.Dir, camMatrix, camFrust);
worldViewRay.Dir.normalize();
worldViewRay.Right = camMatrix.getI().normed();
worldViewRay.Up = camMatrix.getK().normed();
// **** Get entities with box intersecting the ray.
static std::vector<ISelectableObject *> validObjects;
validObjects.clear();
static std::vector<CSortSelectableObject> intersectedObjects;
intersectedObjects.clear();
ISelectableObject *precSelectableObject = NULL;
validObjects.push_back(&SelectableUser); // add fake object for test with user entity
for(TInstanceMap::iterator it = _Instances.begin(); it != _Instances.end(); ++it)
{
CInstance *instance = it->second;
CDisplayerVisual *vd = instance->getDisplayerVisual();
if (!vd) continue;
if (!vd->isSelectable()) continue;
if (instance == getEditor().getSelectedInstance())
{
precSelectableObject = vd;
}
validObjects.push_back(vd);
}
// compute intersection of mouse with landscape / batiments for test with projected object like region & decals
CVector sceneInter;
CTool::TRayIntersectionType rayInterType = CTool::computeLandscapeRayIntersection(worldViewRay, sceneInter);
CSortSelectableObject selectObj;
ISelectableObject *borderSelected = NULL;
for(uint k = 0; k < validObjects.size(); ++k)
{
ISelectableObject *object = validObjects[k];
// if entity not visible, skip
if(object->getLastClip())
continue;
float depth = FLT_MAX;
ISelectableObject::TSelectionType selectionType = object->getSelectionType();
bool borderSelection = false;
switch(selectionType)
{
case ISelectableObject::GroundProjected:
if (rayInterType != CTool::NoIntersection)
{
CVector2f testPos(sceneInter.x, sceneInter.y);
borderSelection = object->isInProjectionBorder(testPos);
if (borderSelection || object->isInProjection(testPos))
{
depth = (worldViewRay.Origin - sceneInter).norm();
}
}
break;
case ISelectableObject::LocalSelectBox:
case ISelectableObject::WorldSelectBox:
{
const CMatrix &rayMatrix = (selectionType == ISelectableObject::LocalSelectBox) ? object->getInvertedMatrix()
: CMatrix::Identity;
selectObj.RayStart = rayMatrix * worldViewRay.Origin;
selectObj.RayStartClipped = selectObj.RayStart;
selectObj.RayEndClipped = rayMatrix * (worldViewRay.Origin + worldViewRay.Dir * distSelection);
// if intersect the bbox
selectObj.SelectBox = object->getSelectBox();
selectObj.SelectBoxInWorld = false;
if (selectObj.SelectBox.clipSegment(selectObj.RayStartClipped, selectObj.RayEndClipped))
{
depth = (selectObj.RayStartClipped - selectObj.RayStart).norm();
// is it the last entity under pos?
if(object->getInstanceInEditor() ==precInstanceUnderPos)
precInstanceUnderPosValid= true;
}
}
break;
default:
nlassert(0);
break;
}
if (depth != FLT_MAX)
{
selectObj.Object = object;
selectObj.Depth = depth;
if (borderSelection)
{
borderSelected = object;
}
// add this entity to the list of possible entities
intersectedObjects.push_back(selectObj);
}
}
// if no intersected entities, quit
if(intersectedObjects.empty())
return NULL;
// Compute startDistBox: nearest entity distance, but the user
float startDistBox;
if(intersectedObjects[0].Object == &SelectableUser)
{
// if the nearest entity is the user, set res
isPlayerUnderCursor= true;
// if only player intersected, return NULL!
if(intersectedObjects.size()==1)
return NULL;
// so take the second for startDistBox
startDistBox= intersectedObjects[1].Depth;
}
else
{
// ok, take it.
startDistBox= intersectedObjects[0].Depth;
}
/*static std::vector<ISelectableObject *> projectedObjects;
projectedObjects.clear();*/
// **** get best entity according to distance face-camera or box-ray if no face intersection
ISelectableObject *objectSelected= NULL;
float bestDistBox= FLT_MAX;
float bestDistZ= FLT_MAX;
for(i=0;i<intersectedObjects.size();i++)
{
ISelectableObject *object = intersectedObjects[i].Object;
// If this entity is the UserEntity, skip!!
if(object == &SelectableUser)
continue;
float distZ = 0.f;
bool preciseInterFound = false;
ISelectableObject::TSelectionType selectionType = object->getSelectionType();
switch(selectionType)
{
case ISelectableObject::GroundProjected:
{
// if current selection remains selected, keep it
bool keepSelection = objectSelected &&
objectSelected->getSelectionType() == ISelectableObject::GroundProjected &&
objectSelected == precSelectableObject;
if (!keepSelection)
{
preciseInterFound = true;
distZ = intersectedObjects[i].Depth;
}
}
break;
case ISelectableObject::LocalSelectBox:
case ISelectableObject::WorldSelectBox:
// if (!object->intersectionTest(bbox, pos, dir, dist2D, distZ, distSelection)) continue;
distZ = object->preciseIntersectionTest(worldViewRay.Origin, worldViewRay.Dir);
if (distZ != FLT_MAX)
{
preciseInterFound = true;
}
break;
default:
nlassert(0);
break;
}
// *** if intersect face, then take the best face-intersection, else use box-ray cost
// true face-col found?
if(preciseInterFound)
{
// yes, get the nearest
if(distZ<=bestDistZ)
{
bestDistBox= 0;
bestDistZ= distZ;
objectSelected= object;
/*if (selectionType == ISelectableObject::GroundProjected)
{
projectedObjects.push_back(object);
}*/
}
}
// else
else
{
// if a true face-intersection has not been found for others entities
if(bestDistZ==FLT_MAX)
{
// get the "distance to camera" contribution.
// NB: ray & select box are in the same space (local or world)
CVector c= selectObj.SelectBox.getCenter();
float distCamCost= intersectedObjects[i].Depth;
// get relative to the nearest intersected entity
distCamCost-= startDistBox;
// take the middle of the clipped segment. suppose that this middle is the "nearest ray point to center"
// This is false, but gives better results.
CVector m= (selectObj.RayStartClipped + selectObj.RayEndClipped) / 2;
// get the distance to center. NB: small entities are preferred since smaller mean lower cost
float outBBoxCost= (m - c).norm();
// the final cost is a weighted sum of the both. NB: distCamCost is in meter,
// and outBBBoxCost is meters. Hence ClientCfg.SelectionOutBBoxWeight is a factor
float boxCost= distCamCost + outBBoxCost * ClientCfg.SelectionOutBBoxWeight;
// take the lowest cost
if(boxCost<bestDistBox)
{
objectSelected= object;
bestDistBox= boxCost;
}
}
}
}
// If precise intersection not found
if(bestDistZ==FLT_MAX)
{
// if the last entity under pos is valid, prefer it among all other approximate ones
if(precInstanceUnderPos && precInstanceUnderPosValid)
objectSelected= precInstanceUnderPos->getDisplayerVisual();
}
if (objectSelected->getSelectionType() == ISelectableObject::GroundProjected)
{
if (borderSelected && borderSelected != objectSelected)
{
if (!objectSelected || !objectSelected->isInProjectionBorder(CVector2f(sceneInter.x, sceneInter.y)))
{
// when mouse over zone border, preffered over other zones
objectSelected = borderSelected;
}
}
// TODO nico: list not really needed here (comes from old code)
/*uint k;
for(k = 0; k < projectedObjects.size(); ++k)
{
if (projectedObjects[k] == objectSelected) break;
}
objectSelected = projectedObjects[(k + 1) % projectedObjects.size()];
*/
}
// return the best entity
_LastInstanceUnderPos = objectSelected ? objectSelected->getInstanceInEditor() : NULL;
return _LastInstanceUnderPos;
}// getEntityUnderPos //
// *********************************************************************************************************
float CEditor::preciseEntityIntersectionTest(CEntityCL &entity, const NLMISC::CVector &worldRayStart, const NLMISC::CVector &worldRayDir)
{
//H_AUTO(R2_CEditor_preciseEntityIntersectionTest)
CHECK_EDITOR
// if entity skeleton model was clipped, skip
NL3D::USkeleton *skeleton = entity.skeleton();
if(!ClientCfg.Light && skeleton && !skeleton->getLastClippedState())
return FLT_MAX;
H_AUTO(RZ_Client_GEUP_face_intersect)
// *** Try get face-intersection, result in distZ
// if the entity support fast and precise intersection (and if it succeeds)
// bool trueIntersectComputed= false;
float dist2D, distZ;
if(!ClientCfg.Light)
{
if(skeleton)
{
if(skeleton->supportFastIntersect() && skeleton->fastIntersect(worldRayStart, worldRayDir, dist2D, distZ, false))
{
if (dist2D == 0.f)
{
return distZ;
}
}
}
// get the intersection with the instance (bot object)
else if(!entity.instances().empty() && !entity.instances()[0].Current.empty())
{
NL3D::UInstance inst= entity.instances()[0].Current;
if(inst.supportFastIntersect())
{
if (inst.fastIntersect(worldRayStart, worldRayDir, dist2D, distZ, false))
{
if (dist2D == 0.f)
{
return distZ;
}
}
}
else
{
// TMP
// precise test was asked, but there's no better test than bbox, so return the dist for bbox middle
return (entity.pos().asVector() + entity.localSelectBox().getCenter() - worldRayStart).norm();
}
}
}
return FLT_MAX;
}
// *********************************************************************************************************
const NLMISC::CAABBox &CEditor::getLocalSelectBox(CEntityCL &entity) const
{
//H_AUTO(R2_CEditor_getLocalSelectBox)
CHECK_EDITOR
const TEntityCustomSelectBoxMap &boxMap = getEditor().getEntityCustomSelectBoxMap();
TEntityCustomSelectBoxMap::const_iterator it = boxMap.find(CSheetId(entity.sheetId()).toString());
if (it != boxMap.end())
{
if (it->second.Enabled)
{
return it->second.Box;
}
}
return entity.localSelectBox();
}
// *********************************************************************************************************
NLMISC::CAABBox CEditor::getSelectBox(CEntityCL &entity) const
{
//H_AUTO(R2_CEditor_getSelectBox)
CHECK_EDITOR
const TEntityCustomSelectBoxMap &boxMap = getEditor().getEntityCustomSelectBoxMap();
TEntityCustomSelectBoxMap::const_iterator it = boxMap.find(CSheetId(entity.sheetId()).toString());
if (it != boxMap.end())
{
if (it->second.Enabled)
{
// box is local, transform in world
CMatrix modelMatrix;
modelMatrix = entity.dirMatrix();
modelMatrix.setPos(entity.pos().asVector());
return CAABBox::transformAABBox(modelMatrix, it->second.Box);
}
}
return entity.selectBox();
}
// *********************************************************************************************************
void CEditor::connexionMsg(const std::string &stringId)
{
//H_AUTO(R2_CEditor_connexionMsg)
CHECK_EDITOR
getEditor()._ConnexionMsg = stringId;
// ignore if current ui desktop is not the third
if (getUI().getMode() != 3) return;
// show the connection window
CInterfaceGroup *r2ConnectWindow = dynamic_cast<CInterfaceGroup *>(getUI().getElementFromId("ui:interface:r2ed_connect"));
if (!r2ConnectWindow) return;
if (stringId.empty())
{
r2ConnectWindow->setActive(false);
return;
}
else
{
if (!r2ConnectWindow->getActive())
{
// center for the first display
r2ConnectWindow->setActive(true);
r2ConnectWindow->center();
}
CViewText *vt = dynamic_cast<CViewText *>(r2ConnectWindow->getView("connexionMsg"));
if (vt)
{
vt->setText(CI18N::get(stringId));
}
}
}
// *********************************************************************************************************
void CEditor::connect()
{
//H_AUTO(R2_CEditor_connect)
CHECK_EDITOR
if (_Mode == EditionMode || _Mode == AnimationModeLoading)
{
bool ok = false;
if (_ScenarioInstance)
{
try
{
if (_ScenarioInstance->getLuaProjection().callMethodByNameNoThrow("validateForTesting", 0, 1))
{
if (getLua().toBoolean(-1) == true)
{
R2::getEditor().getDMC().getEditionModule().requestStartScenario();
ok = true;
}
}
}
catch (const std::exception& )
{
// 'ok' still == false ...
}
}
if (!ok)
{
nlwarning("Can't go live");
}
}
else if (_Mode == TestMode || _Mode == DMMode)
{
try
{
R2::getEditor().getLua().executeScript("r2.requestStopLive()");
if (ClientCfg.Local)
{
R2::getEditor().setMode(CEditor::EditionMode);
getLua().executeScriptNoThrow("r2.requestReconnection()");
}
else
{
R2::getEditor().setMode(CEditor::GoingToEditionMode);
}
CEditor::connexionMsg("uimR2EDGoToEditingMode");
}
catch (const std::exception& e)
{
nlwarning("Can't go live: %s", e.what());
}
}
// TODO Nico : reset the good capture keyboard
setDefaultChatWindow(PeopleInterraction.ChatGroup.Window);
ConnectionWanted = false;
return;
}
// *********************************************************************************************************
CEditor::TInstanceObserverHandle CEditor::addInstanceObserver(const TInstanceId &instanceId, IInstanceObserver *observer)
{
//H_AUTO(R2_CEditor_addInstanceObserver)
CHECK_EDITOR
//nlwarning("#adding instance observer 0x%x", (int) observer);
nlassert(_InstanceObservers.size() == _InstanceObserverHandles.size());
const TInstanceObserverMap::const_iterator lb = _InstanceObservers.lower_bound(instanceId);
const TInstanceObserverMap::const_iterator ub = _InstanceObservers.upper_bound(instanceId);
// NB nico : removed the inserted twice stuff below because observer pointers are not used as keys,
// so sharing is possible
// see if not inserted twice
/*
for (TInstanceObserverMap::const_iterator it = lb; it != ub; ++it)
{
if (it->second == observer)
{
nlwarning("addInstanceObserver : Instance observer inserted twice");
return BadInstanceObserverHandle;
}
}
*/
// insert the handle
TInstanceObserverHandle handle = _InstanceObserverHandleCounter++;
if (_InstanceObserverHandleCounter == BadInstanceObserverHandle)
{
++ _InstanceObserverHandleCounter; // avoid bad handle
}
_InstanceObserverHandles[handle] = _InstanceObservers.insert(TInstanceObserverMap::value_type(instanceId, observer));
nlassert(_InstanceObservers.size() == _InstanceObserverHandles.size());
return handle;
}
// *********************************************************************************************************
CEditor::IInstanceObserver *CEditor::removeInstanceObserver(TInstanceObserverHandle handle)
{
//H_AUTO(R2_CEditor_removeInstanceObserver)
CHECK_EDITOR
nlassert(_InstanceObservers.size() == _InstanceObserverHandles.size());
TInstanceObserverHandleMap::iterator it = _InstanceObserverHandles.find(handle);
if (it == _InstanceObserverHandles.end())
{
nlwarning("removeInstanceObserver : Instance observer handle not found : %d", (int) handle);
return NULL;
}
IInstanceObserver *observer = it->second->second;
//nlwarning("#removing instance observer 0x%x", (int) observer);
_InstanceObservers.erase(it->second); // remove from observer map
_InstanceObserverHandles.erase(it);
nlassert(_InstanceObservers.size() == _InstanceObserverHandles.size());
return observer;
}
// *********************************************************************************************************
CEditor::IInstanceObserver *CEditor::getInstanceObserver(TInstanceObserverHandle handle)
{
//H_AUTO(R2_CEditor_getInstanceObserver)
CHECK_EDITOR
nlassert(_InstanceObservers.size() == _InstanceObserverHandles.size());
TInstanceObserverHandleMap::iterator it = _InstanceObserverHandles.find(handle);
if (it == _InstanceObserverHandles.end())
{
return NULL;
}
return it->second->second;
}
// *********************************************************************************************************
CEditor::TSeason CEditor::getSeason() const
{
//H_AUTO(R2_CEditor_getSeason)
if (_IsWaitingTPForSeasonChange) return UnknownSeason; // as long at the teleport message hasn't been received, don't change
// the season for nothing -> pretend that we don't know the season so that it remains unchnged
return _Season;
}
// *********************************************************************************************************
void CEditor::tpReceived()
{
//H_AUTO(R2_CEditor_tpReceived)
_IsWaitingTPForSeasonChange = false; // season can be changed now
_TPReceivedFlag = true;
}
// *********************************************************************************************************
void CEditor::checkMissingCollisions()
{
//H_AUTO(R2_CEditor_checkMissingCollisions)
CScenarioEntryPoints &sep = CScenarioEntryPoints::getInstance();
sep.loadCompleteIslands();
const CScenarioEntryPoints::TCompleteIslands &islands = sep.getCompleteIslands();
for(uint k = 0; k < islands.size(); ++k)
{
bool found = !(CPath::lookup(islands[k].Island + ".packed_island", false, false).empty());
if (!found)
{
nlwarning("ISLAND COLLISION MISSING FOR : %s", islands[k].Island.c_str());
}
found = !(CPath::lookup(islands[k].Island + ".island_hm", false, false).empty());
if (!found)
{
nlwarning("ISLAND HEIGHTMAP MISSING FOR : %s", islands[k].Island.c_str());
}
}
}
// *********************************************************************************************************
// move
class CAHEdContextMenu : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
getEditor().displayContextMenu();
}
};
REGISTER_ACTION_HANDLER(CAHEdContextMenu, "r2ed_context_menu");
// *********************************************************************************************************
NLMISC::CVector getVector(const CObject *obj)
{
return getVectorD(obj).asVector();
}
// *********************************************************************************************************
NLMISC::CVectorD getVectorD(const CObject *obj)
{
return CVectorD(getNumber(obj, "x"), getNumber(obj, "y"), getNumber(obj, "z"));
}
// *********************************************************************************************************
CObject *buildVector(const NLMISC::CVectorD &vector, const std::string &instanceId /*= ""*/)
{
CObject *table;
if (instanceId == "")
{
table = getEditor().getDMC().newComponent("Position");
table->set("x", vector.x);
table->set("y", vector.y);
table->set("z", vector.z);
}
else
{
table = new CObjectTableClient;
table->insert("InstanceId", new CObjectString(instanceId));
table->insert("Class", new CObjectString("Position"));
table->insert("x", new CObjectNumber(vector.x));
table->insert("y", new CObjectNumber(vector.y));
table->insert("z", new CObjectNumber(vector.z));
}
return table;
}
// *********************************************************************************************************
const CObject *getObject(const CObject *obj,const std::string &attrName)
{
if (!obj) return NULL;
return getEditor().getDMC().getPropertyAccessor().getPropertyValue(obj, attrName);
}
// *********************************************************************************************************
std::string getString(const CObject *obj, const std::string &attrName)
{
obj = getObject(obj, attrName);
if (!obj) return "";
return obj->isString() ? obj->toString() : "";
}
// *********************************************************************************************************
double getNumber(const CObject *obj, const std::string &attrName)
{
obj = getObject(obj, attrName);
if (!obj) return 0;
return obj->isNumber() ? obj->toNumber() : 0;
}
bool isEditionCurrent()
{
CEditor &ed = getEditor();
return ClientCfg.R2EDEnabled && ed.getMode() == CEditor::EditionMode;
}
// *********************************************************************************************************
void CEditor::onContinentChanged()
{
//H_AUTO(R2_CEditor_onContinentChanged)
if (_Mode != EditionMode) return;
// refresh all collisions
if (_ScenarioInstance)
{
struct CContinentChangedVisitor : public IInstanceVisitor
{
virtual void visit(CInstance &inst)
{
inst.onContinentChanged();
}
};
CContinentChangedVisitor continentChangedVisitor;
_ScenarioInstance->visit(continentChangedVisitor);
}
}
//-----------------------------
bool CEditor::getVisualPropertiesFromObject(CObject* object, SPropVisualA& vA, SPropVisualB& vB, SPropVisualC& vC)
{
//H_AUTO(R2_CEditor_getVisualPropertiesFromObject)
std::string sheetClient = getString(object, "SheetClient");
const CEntitySheet *entitySheet = SheetMngr.get(CSheetId(sheetClient));
if (!entitySheet)
{
nlwarning("Can't find client sheet %s", sheetClient.c_str());
return false;
}
CSheetId sheetId(sheetClient);
if (sheetId == CSheetId::Unknown)
{
nlwarning("Can't get sheet");
return false;
}
//-------------------------random init npc visual properties
std::map< std::string, double > visualProps;
static const char* keys[] = { "GabaritHeight", "GabaritTorsoWidth", "GabaritArmsWidth", "GabaritLegsWidth", "GabaritBreastSize"
, "HairType", "HairColor", "Tattoo", "EyesColor"
, "MorphTarget1", "MorphTarget2", "MorphTarget3", "MorphTarget4"
, "MorphTarget5", "MorphTarget6", "MorphTarget7", "MorphTarget8"
, "JacketModel", "TrouserModel", "FeetModel", "HandsModel"
, "ArmModel", "WeaponRightHand", "WeaponLeftHand"
, "JacketColor", "ArmColor", "HandsColor"
, "TrouserColor", "FeetColor"};
unsigned int first = 0;
unsigned int last = sizeof(keys) / sizeof(keys[0]);
for (; first != last; ++first)
{
visualProps[keys[first]] = getNumber(object, keys[first]);
}
//vA.PropertySubData.Sex = (uint) visualProps["Sex"];
if(entitySheet)
{
const CCharacterSheet *chSheet = dynamic_cast<const CCharacterSheet *>(entitySheet);
if(chSheet)
{
vA.PropertySubData.Sex = (chSheet->Gender == GSGENDER::female);
}
}
vC.PropertySubData.CharacterHeight = (uint) visualProps["GabaritHeight"];
vC.PropertySubData.ArmsWidth = (uint) visualProps["GabaritArmsWidth"];
vC.PropertySubData.TorsoWidth = (uint) visualProps["GabaritTorsoWidth"];
vC.PropertySubData.LegsWidth = (uint) visualProps["GabaritLegsWidth"];
vC.PropertySubData.BreastSize = (uint) visualProps["GabaritBreastSize"];
int itemNb = (int) visualProps["HairType"];
std::string itemFileName;
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.HatModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::HEAD_SLOT);
}
else
{
vA.PropertySubData.HatModel = 0;
}
vA.PropertySubData.HatColor = (uint) visualProps["HairColor"];
vC.PropertySubData.Tattoo = (uint) visualProps["Tattoo"];
vC.PropertySubData.EyesColor = (uint) visualProps["EyesColor"];
vC.PropertySubData.MorphTarget1 = (uint) visualProps["MorphTarget1"];
vC.PropertySubData.MorphTarget2 = (uint) visualProps["MorphTarget2"];
vC.PropertySubData.MorphTarget3 = (uint) visualProps["MorphTarget3"];
vC.PropertySubData.MorphTarget4 = (uint) visualProps["MorphTarget4"];
vC.PropertySubData.MorphTarget5 = (uint) visualProps["MorphTarget5"];
vC.PropertySubData.MorphTarget6 = (uint) visualProps["MorphTarget6"];
vC.PropertySubData.MorphTarget7 = (uint) visualProps["MorphTarget7"];
vC.PropertySubData.MorphTarget8 = (uint) visualProps["MorphTarget8"];
itemNb = (int) visualProps["JacketModel"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.JacketModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::CHEST_SLOT);
}
else
{
vA.PropertySubData.JacketModel = 0;
}
itemNb = (int) visualProps["TrouserModel"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.TrouserModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::LEGS_SLOT);
}
else
{
vA.PropertySubData.TrouserModel = 0;
}
itemNb = (int) visualProps["FeetModel"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vB.PropertySubData.FeetModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::FEET_SLOT);
}
else
{
vB.PropertySubData.FeetModel = 0;
}
itemNb = (int) visualProps["HandsModel"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vB.PropertySubData.HandsModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::HANDS_SLOT);
}
else
{
vB.PropertySubData.HandsModel = 0;
}
itemNb = (int) visualProps["ArmModel"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.ArmModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::ARMS_SLOT);
}
else
{
vA.PropertySubData.ArmModel = 0;
}
vA.PropertySubData.JacketColor = (uint) visualProps["JacketColor"];
vA.PropertySubData.TrouserColor = (uint) visualProps["TrouserColor"];
vB.PropertySubData.FeetColor = (uint) visualProps["FeetColor"];
vB.PropertySubData.HandsColor = (uint) visualProps["HandsColor"];
vA.PropertySubData.ArmColor = (uint) visualProps["ArmColor"];
itemNb = (int) visualProps["WeaponRightHand"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.WeaponRightHand = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::RIGHT_HAND_SLOT);
}
else
{
vA.PropertySubData.WeaponRightHand = 0;
}
itemNb = (int) visualProps["WeaponLeftHand"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.WeaponLeftHand = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::LEFT_HAND_SLOT);
}
else
{
vA.PropertySubData.WeaponLeftHand = 0;
}
return true;
}
// *********************************************************************************************************
bool CEditor::CSortedInstances::contains(CInstance *inst) const
{
TInstanceToIter::const_iterator it = _InstanceToIter.find(inst);
#ifdef NL_DEBUG
if (it == _InstanceToIter.end())
{
for(TInstanceByName::const_iterator it = _ByName.begin(); it != _ByName.end(); ++it)
{
nlassert(it->second != inst); // should be empty
}
}
#endif
return it != _InstanceToIter.end();
}
// *********************************************************************************************************
void CEditor::CSortedInstances::insert(const ucstring &name, CInstance *inst)
{
nlassert(inst);
#ifdef NL_DEBUG
static volatile bool doTest = true;
if (doTest)
{
nlassert(!contains(inst)); // inserted twice !!
}
#endif
_InstanceToIter[inst] = _ByName.insert(std::make_pair(name, inst));
}
// *********************************************************************************************************
void CEditor::CSortedInstances::remove(CInstance *inst)
{
nlassert(inst);
TInstanceToIter::iterator it = _InstanceToIter.find(inst);
nlassert(it != _InstanceToIter.end());
_ByName.erase(it->second);
_InstanceToIter.erase(it);
#ifdef NL_DEBUG
nlassert(!contains(inst));
#endif
}
// *********************************************************************************************************
bool CEditor::isRegisteredByDispName(CInstance *inst) const
{
nlassert(inst);
for (uint k = 0; k < _InstancesByDispName.size(); ++k)
{
if (_InstancesByDispName[k].contains(inst)) return true; // registered twice !!
}
return false;
}
// *********************************************************************************************************
void CEditor::registerInstanceDispName(const ucstring &displayName, CInstance *inst)
{
nlassert(inst);
sint currClass = inst->getClassIndex();
if (currClass < 0)
{
nlwarning("Classindex not found for class %s", inst->getClassName().c_str());
return;
}
#ifdef NL_DEBUG
nlassert(!isRegisteredByDispName(inst));
#endif
// for each class & subclass of the object, insert in the matching list
while (currClass >= 0)
{
nlassert(currClass < (sint) _InstancesByDispName.size());
_InstancesByDispName[currClass].insert(displayName, inst);
currClass = getBaseClass(currClass);
}
//
#ifdef NL_DEBUG
nlassert(isRegisteredByDispName(inst));
#endif
}
// *********************************************************************************************************
void CEditor::unregisterInstanceDispName(CInstance *inst)
{
nlassert(inst);
sint currClass = inst->getClassIndex();
if (currClass < 0)
{
nlwarning("Classindex not found for class %s", inst->getClassName().c_str());
return;
}
#ifdef NL_DEBUG
nlassert(isRegisteredByDispName(inst));
#endif
while (currClass >= 0)
{
nlassert(currClass < (sint) _InstancesByDispName.size());
_InstancesByDispName[currClass].remove(inst);
currClass = getBaseClass(currClass);
}
#ifdef NL_DEBUG
nlassert(!isRegisteredByDispName(inst));
#endif
}
// *********************************************************************************************************
//
// Creation of a new entity in scene
//
class CAHCreateEntity : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &sParams)
{
CHECK_EDITOR
if (getEditor().getMode() != CEditor::EditionMode)
{
nlwarning("Can't modify scenario while testing");
return;
}
CInterfaceManager *im = CInterfaceManager::getInstance();
// Retrieve sheet for entity that is to be created.
std::string paletteId = getParam(sParams, "PaletteId");
CObject *paletteNode = getEditor().getDMC().getPaletteElement(paletteId);
if (!paletteNode)
{
nlwarning("Can't retrieve palette node for id %s", paletteId.c_str());
return;
}
if (!paletteNode->isTable())
{
nlwarning("Bad type for palette node %s (should be a table)", paletteId.c_str());
return;
}
std::string sheetClient = getString(paletteNode, "SheetClient");
const CEntitySheet *entitySheet = SheetMngr.get(CSheetId(sheetClient));
if (!entitySheet)
{
nlwarning("Can't find client sheet %s", sheetClient.c_str());
return;
}
const CCharacterSheet *chSheet = dynamic_cast<const CCharacterSheet *>(entitySheet);
if(chSheet->R2Npc)
{
getEditor().getLua().push(sheetClient);
if (getEditor().getEnv().callMethodByNameNoThrow("randomNPCSex", 1, 1))
{
CLuaObject result(getEditor().getLua());
sheetClient = result.toString();
}
}
CSheetId sheetId(sheetClient);
if (sheetId == CSheetId::Unknown)
{
nlwarning("Can't get sheet");
return;
}
getEditor().setCurrentTool(NULL); // remove current to avoid to have ghost removed by that tool if it was a "CToolCreateEntity" too.
uint ghostSlot = 1; // TMP TMP
CEntityCL * entity = NULL;
if (!(entity=CEditor::createEntity(ghostSlot, sheetId, CVector::Null, 0.f)))
{
return;
}
//-------------------------random init npc visual properties
if(dynamic_cast<CPlayerR2CL *>(entity))
{
// push equipment id
getEditor().getLua().push(getString(paletteNode, "Equipment"));
// push race
std::string race;
switch(entity->people())
{
case EGSPD::CPeople::Fyros:
race = "Fyros";
break;
case EGSPD::CPeople::Matis:
race = "Matis";
break;
case EGSPD::CPeople::Tryker:
race = "Tryker";
break;
case EGSPD::CPeople::Zorai:
race = "Zorai";
break;
default:
nlwarning("CAHCreateEntity::execute unknown people");
}
getEditor().getLua().push(race);
if (getEditor().getEnv().callMethodByNameNoThrow("randomNPCProperties", 2, 1))
{
CLuaObject result(getEditor().getLua());
std::map< std::string, double > visualProps;
ENUM_LUA_TABLE(result, it)
{
visualProps[it.nextKey().toString()] = it.nextValue().toNumber();
}
// visual property A depends on the type of the entity
SPropVisualA vA;
SPropVisualB vB;
SPropVisualC vC;
sint64 *prop = 0;
//vA.PropertySubData.Sex = (uint) visualProps["Sex"];
const CEntitySheet *entitySheet = SheetMngr.get((CSheetId)sheetId.asInt());
if(entitySheet)
{
const CCharacterSheet *chSheet = dynamic_cast<const CCharacterSheet *>(entitySheet);
if(chSheet)
{
vA.PropertySubData.Sex = (chSheet->Gender == GSGENDER::female);
}
}
vC.PropertySubData.CharacterHeight = (uint) visualProps["GabaritHeight"];
vC.PropertySubData.ArmsWidth = (uint) visualProps["GabaritArmsWidth"];
vC.PropertySubData.TorsoWidth = (uint) visualProps["GabaritTorsoWidth"];
vC.PropertySubData.LegsWidth = (uint) visualProps["GabaritLegsWidth"];
vC.PropertySubData.BreastSize = (uint) visualProps["GabaritBreastSize"];
int itemNb = (int) visualProps["HairType"];
std::string itemFileName;
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.HatModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::HEAD_SLOT);
}
else
{
vA.PropertySubData.HatModel = 0;
}
vA.PropertySubData.HatColor = (uint) visualProps["HairColor"];
vC.PropertySubData.Tattoo = (uint) visualProps["Tattoo"];
vC.PropertySubData.EyesColor = (uint) visualProps["EyesColor"];
vC.PropertySubData.MorphTarget1 = (uint) visualProps["MorphTarget1"];
vC.PropertySubData.MorphTarget2 = (uint) visualProps["MorphTarget2"];
vC.PropertySubData.MorphTarget3 = (uint) visualProps["MorphTarget3"];
vC.PropertySubData.MorphTarget4 = (uint) visualProps["MorphTarget4"];
vC.PropertySubData.MorphTarget5 = (uint) visualProps["MorphTarget5"];
vC.PropertySubData.MorphTarget6 = (uint) visualProps["MorphTarget6"];
vC.PropertySubData.MorphTarget7 = (uint) visualProps["MorphTarget7"];
vC.PropertySubData.MorphTarget8 = (uint) visualProps["MorphTarget8"];
itemNb = (int) visualProps["JacketModel"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.JacketModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::CHEST_SLOT);
}
else
{
vA.PropertySubData.JacketModel = 0;
}
itemNb = (int) visualProps["TrouserModel"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.TrouserModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::LEGS_SLOT);
}
else
{
vA.PropertySubData.TrouserModel = 0;
}
itemNb = (int) visualProps["FeetModel"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vB.PropertySubData.FeetModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::FEET_SLOT);
}
else
{
vB.PropertySubData.FeetModel = 0;
}
itemNb = (int) visualProps["HandsModel"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vB.PropertySubData.HandsModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::HANDS_SLOT);
}
else
{
vB.PropertySubData.HandsModel = 0;
}
itemNb = (int) visualProps["ArmModel"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.ArmModel = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::ARMS_SLOT);
}
else
{
vA.PropertySubData.ArmModel = 0;
}
vA.PropertySubData.JacketColor = (uint) visualProps["JacketColor"];
vA.PropertySubData.TrouserColor = (uint) visualProps["TrouserColor"];
vB.PropertySubData.FeetColor = (uint) visualProps["FeetColor"];
vB.PropertySubData.HandsColor = (uint) visualProps["HandsColor"];
vA.PropertySubData.ArmColor = (uint) visualProps["ArmColor"];
itemNb = (int) visualProps["WeaponRightHand"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.WeaponRightHand = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::RIGHT_HAND_SLOT);
}
else
{
vA.PropertySubData.WeaponRightHand = 0;
}
itemNb = (int) visualProps["WeaponLeftHand"];
if(itemNb>0)
{
itemFileName = CSheetId(itemNb).toString();
vA.PropertySubData.WeaponLeftHand = (uint) SheetMngr.getVSIndex(itemFileName, SLOTTYPE::LEFT_HAND_SLOT);
}
else
{
vA.PropertySubData.WeaponLeftHand = 0;
}
prop = (sint64 *)&vA;
im->getDbProp("SERVER:Entities:E"+toString("%d", entity->slot())+":P"+toString("%d", CLFECOMMON::PROPERTY_VPA))->setValue64(*prop);
prop = (sint64 *)&vB;
im->getDbProp("SERVER:Entities:E"+toString("%d", entity->slot())+":P"+toString("%d", CLFECOMMON::PROPERTY_VPB))->setValue64(*prop);
prop = (sint64 *)&vC;
im->getDbProp("SERVER:Entities:E"+toString("%d", entity->slot())+":P"+toString("%d", CLFECOMMON::PROPERTY_VPC))->setValue64(*prop);
EntitiesMngr.updateVisualProperty(0, entity->slot(), CLFECOMMON::PROPERTY_VPA);
EntitiesMngr.updateVisualProperty(0, entity->slot(), CLFECOMMON::PROPERTY_VPB);
EntitiesMngr.updateVisualProperty(0, entity->slot(), CLFECOMMON::PROPERTY_VPC);
}
}
getEditor().setCurrentTool(new CToolCreateEntity(ghostSlot, paletteId, im->getDbProp("UI:TEMP:R2_DRAW_ARRAY")->getValueBool()));
}
};
REGISTER_ACTION_HANDLER(CAHCreateEntity, "r2ed_create_entity");
// *********************************************************************************************************
sint CEditor::classToIndex(const std::string &className) const
{
CHashMap<std::string, uint>::const_iterator it = _ClassNameToIndex.find(className);
if (it == _ClassNameToIndex.end()) return -1;
return it->second;
}
// *********************************************************************************************************
bool CEditor::isKindOf(sint testedClassIndex, sint kindClassIndex) const
{
if (testedClassIndex < 0 || kindClassIndex < 0) return false;
return _KindOfTable(testedClassIndex, kindClassIndex) != 0;
}
// *********************************************************************************************************
void CEditor::initClassInheritanceTable()
{
std::vector<std::string> classes;
std::map<std::string, std::string> baseClasses;
ENUM_LUA_TABLE(getClasses(), it)
{
CLuaObject name = it.nextValue()["Name"];
CLuaObject base = it.nextValue()["BaseClass"];
std::string baseName;
if (base.isString())
{
baseName = base.toString();
}
if (name.isString())
{
_ClassNameToIndex[name.toString()] = (uint)classes.size();
classes.push_back(name.toString());
baseClasses[name.toString()] = baseName;
}
}
_KindOfTable.init((uint)classes.size(), (uint)classes.size(), 0);
_BaseClassIndices.resize(classes.size());
for (uint k = 0; k < classes.size(); ++k)
{
//nlwarning("Class %d = %s", (int) k, classes[k].c_str());
_BaseClassIndices[k] = classToIndex(baseClasses[classes[k]]);
for (uint l = 0; l < classes.size(); ++l)
{
std::string currClass = classes[k];
while(!currClass.empty())
{
if (currClass == classes[l])
{
_KindOfTable(k, l) = 1;
break;
}
currClass = baseClasses[currClass];
}
}
}
_InstancesByDispName.clear();
_InstancesByDispName.resize(classes.size());
}
// *********************************************************************************************************
sint CEditor::getBaseClass(sint derivedClass) const
{
if (derivedClass < 0 || derivedClass >= (sint) _BaseClassIndices.size()) return -1;
return _BaseClassIndices[derivedClass];
}
// *********************************************************************************************************
void CEditor::setMaxVisibleEntityExceededFlag(bool on)
{
if (on == _MaxVisibleEntityExceededFlag) return;
_MaxVisibleEntityExceededFlag = on;
// lua ui update
CLuaStackChecker lsc(&getLua(), 0);
getLua().push(on);
callEnvMethod("setMaxVisibleEntityExceededFlag", 1, 0);
}
// *********************************************************************************************************
class CAHGoTest : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
CHECK_EDITOR
ConnectionWanted = true;
}
};
REGISTER_ACTION_HANDLER(CAHGoTest, "r2ed_go_test");
// *********************************************************************************************************
class CAHStopTest : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
CHECK_EDITOR
if (getEditor().getAccessMode() != CEditor::AccessEditor) return;
ConnectionWanted = true;
}
};
REGISTER_ACTION_HANDLER(CAHStopTest, "r2ed_stop_test");
// *********************************************************************************************************
class CAHOpenScenarioControl : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &sParams)
{
CHECK_EDITOR
bool openUI = true;
bool showHide = (getParam(sParams, "showHide")=="1");
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CInterfaceGroup* wnd = NULL;
if(!R2::getEditor().isInitialized())
wnd = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId("ui:interface:ring_scenario_loading_window"));
else
wnd = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId("ui:interface:r2ed_scenario_control"));
if(wnd)
{
if(showHide)
openUI = !wnd->getActive();
wnd->setActive(openUI);
}
//}
}
};
REGISTER_ACTION_HANDLER(CAHOpenScenarioControl, "open_scenario_control");
// *********************************************************************************************************
class CAHR2StopLive : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &sParams)
{
CHECK_EDITOR
bool confirmStopLive = getParam(sParams, "confirmStopLive")=="1";
if(!confirmStopLive)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiR2EDconfirmStopLive"), "r2_stop_live", "confirmStopLive=1", "", "", "ui:interface");
}
else
{
CSessionBrowserImpl &sb = CSessionBrowserImpl::getInstance();
sb.closeSession(sb.getCharId(), R2::getEditor().getDMC().getEditionModule().getCurrentAdventureId());
if(sb.waitOneMessage(sb.getMessageName("on_invokeResult")))
{
if(R2::getEditor().getDMC().getEditionModule().getEditSessionLink()!=0)
{
// Now we expect to receive an impulsion FAR_TP to mainland, triggered
// by the DSS. We'll disobey it by FarTPing to the Edition session instead!
nldebug( "Will return to editing session %u", R2::getEditor().getDMC().getEditionModule().getEditSessionLink() );
FarTP.hookNextFarTPForEditor();
}
// otherwise, let accomplish the FAR_TP to mainland (returnToPreviousSession)
// triggered by the DSS.
}
else
{
nlwarning("closeSession callback return false");
}
}
}
};
REGISTER_ACTION_HANDLER(CAHR2StopLive, "r2_stop_live");
// *********************************************************************************************************
class CAHInviteCharacter : public IActionHandler
{
virtual void execute(CCtrlBase *pCaller, const std::string &/* sParams */)
{
CHECK_EDITOR
CInterfaceManager *pIM = CInterfaceManager::getInstance();
pIM->runActionHandler("leave_modal", pCaller, "");
if(pCaller)
{
CInterfaceGroup *fatherGC = pCaller->getParent();
if (fatherGC)
{
// Look for the root parent
for(;;)
{
CInterfaceGroup *parent = fatherGC->getParent();
if (!parent || (parent->getId()=="ui:interface"))
break;
fatherGC = parent;
}
// Get the modal edit box
CGroupEditBox *geb = dynamic_cast<CGroupEditBox *>(fatherGC->getGroup("add_contact_eb:eb"));
if (geb && !geb->getInputString().empty())
{
string charName = geb->getInputString().toString();
CSessionBrowserImpl & sessionBrowser = CSessionBrowserImpl::getInstance();
sessionBrowser.inviteCharacterByName(sessionBrowser.getCharId(), charName);
if(!sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_invokeResult")))
{
nlwarning("inviteCharacterByName callback return false");
}
if(sessionBrowser._LastInvokeResult == 14)
{
CViewText* pVT = dynamic_cast<CViewText*>(pIM->getElementFromId("ui:interface:warning_free_trial:text"));
if (pVT != NULL)
pVT->setText(CI18N::get("uiRingWarningInviteFreeTrial"));
pIM->runActionHandler("enter_modal", pCaller, "group=ui:interface:warning_free_trial");
}
else if(sessionBrowser._LastInvokeResult == 12)
{
pIM->runActionHandler("enter_modal", pCaller, "group=ui:interface:warning_newcomer");
}
geb->setInputString(ucstring(""));
}
}
}
}
};
REGISTER_ACTION_HANDLER(CAHInviteCharacter, "r2ed_invite_character");
// *********************************************************************************************************
class CAHTryGoTest : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
CHECK_EDITOR
getEditor().callEnvMethod("tryGoTest", 0, 0);
}
};
REGISTER_ACTION_HANDLER(CAHTryGoTest, "r2ed_try_go_test");
// *********************************************************************************************************
class CAHCancelTool : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
if (!ClientCfg.R2EDEnabled || !getEditor().isInitialized()) return;
CHECK_EDITOR
getEditor().setCurrentTool(NULL);
}
};
REGISTER_ACTION_HANDLER(CAHCancelTool, "r2ed_cancel_tool");
//////////////////////////////////////////
// SWITCH DM / TESTER AT ANIMATION TIME //
//////////////////////////////////////////
// *********************************************************************************************************
class CAHAnimTestMode : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
CHECK_EDITOR
if (getEditor().getAccessMode() == CEditor::AccessDM) return;
getEditor().setMode(CEditor::TestMode);
}
};
REGISTER_ACTION_HANDLER(CAHAnimTestMode, "r2ed_anim_test_mode");
// *********************************************************************************************************
class CAHAnimDMMode : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
CHECK_EDITOR
getEditor().setMode(CEditor::DMMode);
}
};
REGISTER_ACTION_HANDLER(CAHAnimDMMode, "r2ed_anim_dm_mode");
// *********************************************************************************************************
class CAHR2ContextCommand : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &sParams)
{
CHECK_EDITOR
// forward the call to lua
// first param is the id of the command
std::string commandId = getParam(sParams, "commandId");
// if there's a current active tool, then see if it wants to handle it first
if (commandId == "delete")
{
if (getEditor().getCurrentTool() && getEditor().getCurrentTool()->onDeleteCmd())
return;
}
getEditor().getLua().push(commandId);
getEditor().callEnvMethod("execContextCommand", 1, 0);
}
};
REGISTER_ACTION_HANDLER(CAHR2ContextCommand, "r2ed_context_command");
// *********************************************************************************************************
class CAHR2Teleport : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
if (!ClientCfg.R2EDEnabled) return;
if (R2::getEditor().getMode() != CEditor::EditionMode &&
R2::getEditor().getMode() != CEditor::DMMode &&
R2::getEditor().getMode() != CEditor::AnimationModeDm) return;
CHECK_EDITOR
// just forward to lua
getEditor().callEnvMethod("activeTeleportTool", 0, 0);
}
};
REGISTER_ACTION_HANDLER(CAHR2Teleport, "r2ed_teleport");
// *********************************************************************************************************
class CAHR2Undo : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
// if an edit box currently has focus, then try undo on it first
CGroupEditBox *eb = dynamic_cast<CGroupEditBox *>(getEditor().getUI().getCaptureKeyboard());
if (eb && eb->undo())
{
return;
}
CActionHistoric &historic = getEditor().getDMC().getActionHistoric();
if (historic.canUndo())
{
getEditor().setCurrentTool(NULL);
const ucstring *actionName = historic.getPreviousActionName();
nlassert(actionName);
CLuaIHM::push(getEditor().getLua(), *actionName);
historic.undo();
getEditor().callEnvMethod("onUndo", 1, 0);
}
else
{
getEditor().callEnvMethod("onCantUndo", 0, 0);
}
}
};
REGISTER_ACTION_HANDLER(CAHR2Undo, "r2ed_undo");
// *********************************************************************************************************
class CAHR2Redo : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
// if an edit box currently has focus, then try redo on it first
CGroupEditBox *eb = dynamic_cast<CGroupEditBox *>(getEditor().getUI().getCaptureKeyboard());
if (eb && eb->redo())
{
return;
}
CActionHistoric &historic = getEditor().getDMC().getActionHistoric();
if (historic.canRedo())
{
getEditor().setCurrentTool(NULL);
const ucstring *actionName = historic.getNextActionName();
nlassert(actionName);
CLuaIHM::push(getEditor().getLua(), *actionName);
historic.redo();
getEditor().callEnvMethod("onRedo", 1, 0);
}
else
{
getEditor().callEnvMethod("onCantRedo", 0, 0);
}
}
};
REGISTER_ACTION_HANDLER(CAHR2Redo, "r2ed_redo");
// *********************************************************************************************************
// signal the server that a dm gift has begun, so that the server can take note of the target entity (the current target)
class CAHR2DMGiftBegin : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream("DM_GIFT:BEGIN", out))
{
NetMngr.push(out);
}
else
nlwarning("<CHandlerInvalidateExchange::execute> unknown message name 'DM_GIFT:BEGIN");
}
};
REGISTER_ACTION_HANDLER(CAHR2DMGiftBegin, "r2ed_dm_gift_begin");
// *********************************************************************************************************
// signal the server that a dm gift has begun, so that the server can take note of the target entity (the current target)
class CAHR2DMGiftValidate : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
CInterfaceManager *im = CInterfaceManager::getInstance();
CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream("DM_GIFT:VALIDATE", out))
{
for(uint k = 0; k < 8; ++k)
{
uint32 sheetId = 0;
uint8 quantity = 0;
CCDBNodeLeaf *sheetLeaf = im->getDbProp(toString("LOCAL:R2:DM_GIFT:%d:SHEET", (int) k));
if (sheetLeaf) sheetId = (uint32) sheetLeaf->getValue32();
CCDBNodeLeaf *quantityLeaf = im->getDbProp(toString("LOCAL:R2:DM_GIFT:%d:QUANTITY", (int) k));
if (quantityLeaf) quantity = (uint8) quantityLeaf->getValue8();
out.serial(sheetId);
out.serial(quantity);
}
NetMngr.push(out);
}
else
nlwarning("<CHandlerInvalidateExchange::execute> unknown message name 'DM_GIFT:VALIDATE");
}
};
REGISTER_ACTION_HANDLER(CAHR2DMGiftValidate, "r2ed_dm_gift_validate");
// *********************************************************************************************************
// freeze / unfreeze bot objects
class CAHR2FreezeUnfreezeBotObjects : public IActionHandler
{
virtual void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
{
CInterfaceManager *im = CInterfaceManager::getInstance();
im->executeLuaScript("r2:freezeUnfreezeBotObjects()");
}
};
REGISTER_ACTION_HANDLER(CAHR2FreezeUnfreezeBotObjects, "r2ed_freeze_unfreeze_botobjects");
} // R2
// *********************************************************************************************************
// COMMAND TO REINITIALIZE THE EDITOR : useful to check scripts error
NLMISC_COMMAND(resetEditor, "reset R2 editor, reload all scripts (except ui xmls)", "")
{
if (!args.empty()) return false;
R2::ResetWanted = true;
R2::ReloadUIFlag = false;
return true;
}
// *********************************************************************************************************
// COMMAND TO REINITIALIZE THE EDITOR : useful to check scripts error
NLMISC_COMMAND(resetEditorAndReloadUI, "reset R2 editor, reload all scripts & xml (possibly preserving scenario)", "")
{
if (!args.empty()) return false;
R2::ResetWanted = true;
R2::ReloadUIFlag = true;
return true;
}
// *********************************************************************************************************
// write scenario rtdata to a file for debugging or stress testing by simulator_service
NLMISC_COMMAND(saveScenarioRtData, "save scenario RtData to file", "<filename>")
{
const R2::CObject *scenario = R2::getEditor().getDMC().getHighLevel();
if( !scenario )
{
nlinfo("No current scenario -- can't save rtdata");
return false;
}
std::string fileName = "outpout";
if( args.empty() )
{
// try to name file from title, then area+instance
R2::CObject *description = scenario->findAttr("Description");
if( description )
{
R2::CObject *name = description->findAttr("Name");
R2::CObject *title = 0;
if (name)
{
title = name;
}
else
{
title = description->findAttr("Title"); //obsolete
}
R2::CObject *locationId = description->findAttr("LocationId");
R2::CObject *instanceId = description->findAttr("InstanceId");
if( title )
{
string sTitle = title->toString();
if( !sTitle.empty() )
fileName = sTitle;
}
else if( locationId && instanceId )
fileName = "area" + locationId->toString() + "_" + instanceId->toString();
}
}
else // filename given
{
fileName = args[0];
}
nlinfo("translating current scenario");
R2::CObject *pHighLevel = scenario->clone();
nlassert( pHighLevel );
R2::CObject *pRtData = R2::getEditor().getDMC().translateScenario( pHighLevel );
delete pHighLevel;
if( !pRtData )
{
nlwarning("Failed to translate high-level scenario into rtdata");
return false;
}
// binary
string fullFileName = fileName;
fullFileName += ".rt.bin";
nlinfo("writing rtdata to %s", fullFileName.c_str());
COFile output;
output.open(fullFileName);
R2::CObjectSerializerClient serializer( pRtData );
serializer.serial(output);
output.flush();
output.close();
if( true ) // debug
{
// text
fullFileName = fileName;
fullFileName += ".rt.txt";
COFile output;
//std::stringstream ss;
std::string ss;
output.open(fullFileName);
pRtData->serialize(ss);
//std::string str = ss.str();
output.serial(ss);
output.flush();
output.close();
}
return true;
}
NLMISC_COMMAND(dumpValidPositions, "dump valid position to create objects from the current camera viewpoint", "<filename>")
{
if (args.size() != 1) return false;
try
{
COFile output(args[0]);
CBitmap result;
Driver->getBuffer(result);
if (result.getWidth() == 0 || result.getHeight() == 0) return false;
CMatrix camMatrix = MainCam.getMatrix();
NL3D::CFrustum fru = MainCam.getFrustum();
R2::CTool::CWorldViewRay wvr;
wvr.Right = camMatrix.getI().normed();
wvr.Up = camMatrix.getK().normed();
wvr.OnMiniMap = false;
wvr.Origin = camMatrix.getPos();
wvr.Valid = true;
for (uint x = 0; x < result.getWidth(); ++x)
{
for (uint y = 0; y < result.getHeight(); ++y)
{
CVector ray(fru.Left + (fru.Right - fru.Left) * (x / (float) result.getWidth()), fru.Near,
fru.Top + (fru.Bottom - fru.Top) * (y / (float) result.getHeight()));
ray.normalize();
ray = camMatrix.mulVector(ray);
CVector inter;
wvr.Dir = ray;
R2::CTool::TRayIntersectionType rit = R2::CTool::computeLandscapeRayIntersection(wvr, inter);
CRGBA resultCol;
switch(rit)
{
case R2::CTool::NoIntersection: resultCol = CRGBA(0, 0, 0, 0); break;
case R2::CTool::ValidPacsPos: resultCol = CRGBA(0, 0, 255, 100); break;
default: resultCol = CRGBA(255, 0, 0, 100); break;
}
CRGBA *dest = ((CRGBA *) &result.getPixels(0)[0]) + x + y * result.getWidth();
dest->blendFromui(*dest, resultCol, resultCol.A);
}
}
result.writeTGA(output, 32, false);
}
catch(...)
{
}
return true;
}
/*
// *********************************************************************************************************
NLMISC_COMMAND(resetScenario, "reset R2 editor, reload all scripts & xml", "")
{
if (!args.empty()) return false;
R2::ResetScenarioWanted = true;
return true;
}
// *********************************************************************************************************
NLMISC_COMMAND(reloadScenario, "reset R2 editor, reload all scripts & xml (possibly preserving scenario)", "")
{
if (!args.empty()) return false;
//
R2::ReloadScenarioWanted = true;
return true;
}
*/
bool IsInRingMode()
{
return R2::getEditor().getMode() != R2::CEditor::NotInitialized;
}
Reference in a new issue View git blame Copy permalink