mirror of
https://github.com/glest/glest-source.git
synced 2025-02-24 11:42:31 +01:00
7252 lines
259 KiB
C++
7252 lines
259 KiB
C++
// ==============================================================
|
|
// This file is part of Glest (www.glest.org)
|
|
//
|
|
// Copyright (C) 2001-2005 Martio Figueroa
|
|
//
|
|
// You can redistribute this code and/or modify it under
|
|
// the terms of the GNU General Public License as published
|
|
// by the Free Software Foundation; either version 2 of the
|
|
// License, or (at your option) any later version
|
|
// ==============================================================
|
|
|
|
#include "script_manager.h"
|
|
|
|
#include "world.h"
|
|
#include "lang.h"
|
|
#include "game_camera.h"
|
|
#include "game.h"
|
|
#include "config.h"
|
|
|
|
#include "leak_dumper.h"
|
|
|
|
using namespace
|
|
Shared::Platform;
|
|
using namespace
|
|
Shared::Lua;
|
|
using namespace
|
|
Shared::Util;
|
|
|
|
namespace
|
|
Glest
|
|
{
|
|
namespace
|
|
Game
|
|
{
|
|
|
|
ScriptManagerMessage::ScriptManagerMessage ():
|
|
text (""),
|
|
header ("")
|
|
{
|
|
this->factionIndex = -1;
|
|
this->
|
|
teamIndex = -1;
|
|
this->
|
|
messageNotTranslated = true;
|
|
}
|
|
|
|
ScriptManagerMessage::ScriptManagerMessage (const string & textIn,
|
|
const string & headerIn,
|
|
int factionIndex,
|
|
int teamIndex,
|
|
bool messageNotTranslated):
|
|
text (textIn),
|
|
header (headerIn)
|
|
{
|
|
this->factionIndex = factionIndex;
|
|
this->
|
|
teamIndex = teamIndex;
|
|
this->
|
|
messageNotTranslated = messageNotTranslated;
|
|
}
|
|
|
|
void
|
|
ScriptManagerMessage::saveGame (XmlNode * rootNode)
|
|
{
|
|
std::map < string, string > mapTagReplacements;
|
|
XmlNode *
|
|
scriptManagerMessageNode =
|
|
rootNode->addChild ("ScriptManagerMessage");
|
|
|
|
//string text;
|
|
scriptManagerMessageNode->addAttribute ("text", text,
|
|
mapTagReplacements);
|
|
//string header;
|
|
scriptManagerMessageNode->addAttribute ("header", header,
|
|
mapTagReplacements);
|
|
scriptManagerMessageNode->addAttribute ("factionIndex",
|
|
intToStr (factionIndex),
|
|
mapTagReplacements);
|
|
scriptManagerMessageNode->addAttribute ("teamIndex",
|
|
intToStr (teamIndex),
|
|
mapTagReplacements);
|
|
scriptManagerMessageNode->addAttribute ("messageNotTranslated",
|
|
intToStr (messageNotTranslated),
|
|
mapTagReplacements);
|
|
}
|
|
|
|
void
|
|
ScriptManagerMessage::loadGame (const XmlNode * rootNode)
|
|
{
|
|
const XmlNode *
|
|
scriptManagerMessageNode = rootNode;
|
|
|
|
text = scriptManagerMessageNode->getAttribute ("text")->getValue ();
|
|
header = scriptManagerMessageNode->getAttribute ("header")->getValue ();
|
|
factionIndex =
|
|
scriptManagerMessageNode->getAttribute ("factionIndex")->
|
|
getIntValue ();
|
|
teamIndex =
|
|
scriptManagerMessageNode->getAttribute ("teamIndex")->getIntValue ();
|
|
|
|
messageNotTranslated = true;
|
|
if (scriptManagerMessageNode->hasAttribute ("messageNotTranslated") ==
|
|
true)
|
|
{
|
|
messageNotTranslated =
|
|
(scriptManagerMessageNode->getAttribute ("messageNotTranslated")->
|
|
getIntValue () != 0);
|
|
}
|
|
}
|
|
|
|
// =====================================================
|
|
// class PlayerModifiers
|
|
// =====================================================
|
|
|
|
PlayerModifiers::PlayerModifiers ()
|
|
{
|
|
winner = false;
|
|
aiEnabled = true;
|
|
consumeEnabled = true;
|
|
}
|
|
|
|
void
|
|
PlayerModifiers::saveGame (XmlNode * rootNode)
|
|
{
|
|
std::map < string, string > mapTagReplacements;
|
|
XmlNode *
|
|
playerModifiersNode = rootNode->addChild ("PlayerModifiers");
|
|
|
|
//bool winner;
|
|
playerModifiersNode->addAttribute ("winner", intToStr (winner),
|
|
mapTagReplacements);
|
|
//bool aiEnabled;
|
|
playerModifiersNode->addAttribute ("aiEnabled", intToStr (aiEnabled),
|
|
mapTagReplacements);
|
|
//bool consumeEnabled;
|
|
playerModifiersNode->addAttribute ("consumeEnabled",
|
|
intToStr (consumeEnabled),
|
|
mapTagReplacements);
|
|
}
|
|
|
|
void
|
|
PlayerModifiers::loadGame (const XmlNode * rootNode)
|
|
{
|
|
const XmlNode *
|
|
playerModifiersNode = rootNode;
|
|
|
|
winner =
|
|
playerModifiersNode->getAttribute ("winner")->getIntValue () != 0;
|
|
aiEnabled =
|
|
playerModifiersNode->getAttribute ("aiEnabled")->getIntValue () != 0;
|
|
consumeEnabled =
|
|
playerModifiersNode->getAttribute ("consumeEnabled")->
|
|
getIntValue () != 0;
|
|
}
|
|
|
|
CellTriggerEvent::CellTriggerEvent ()
|
|
{
|
|
type = ctet_Unit;
|
|
sourceId = 0;
|
|
destId = 0;
|
|
//Vec2i destPos;
|
|
|
|
triggerCount = 0;
|
|
}
|
|
|
|
void
|
|
CellTriggerEvent::saveGame (XmlNode * rootNode)
|
|
{
|
|
std::map < string, string > mapTagReplacements;
|
|
XmlNode *
|
|
cellTriggerEventNode = rootNode->addChild ("CellTriggerEvent");
|
|
|
|
// CellTriggerEventType type;
|
|
cellTriggerEventNode->addAttribute ("type", intToStr (type),
|
|
mapTagReplacements);
|
|
// int sourceId;
|
|
cellTriggerEventNode->addAttribute ("sourceId", intToStr (sourceId),
|
|
mapTagReplacements);
|
|
// int destId;
|
|
cellTriggerEventNode->addAttribute ("destId", intToStr (destId),
|
|
mapTagReplacements);
|
|
// Vec2i destPos;
|
|
cellTriggerEventNode->addAttribute ("destPos", destPos.getString (),
|
|
mapTagReplacements);
|
|
// int triggerCount;
|
|
cellTriggerEventNode->addAttribute ("triggerCount",
|
|
intToStr (triggerCount),
|
|
mapTagReplacements);
|
|
|
|
// Vec2i destPosEnd;
|
|
cellTriggerEventNode->addAttribute ("destPosEnd",
|
|
destPosEnd.getString (),
|
|
mapTagReplacements);
|
|
}
|
|
|
|
void
|
|
CellTriggerEvent::loadGame (const XmlNode * rootNode)
|
|
{
|
|
const XmlNode *
|
|
cellTriggerEventNode = rootNode->getChild ("CellTriggerEvent");
|
|
|
|
type =
|
|
static_cast < CellTriggerEventType >
|
|
(cellTriggerEventNode->getAttribute ("type")->getIntValue ());
|
|
sourceId =
|
|
cellTriggerEventNode->getAttribute ("sourceId")->getIntValue ();
|
|
destId = cellTriggerEventNode->getAttribute ("destId")->getIntValue ();
|
|
destPos =
|
|
Vec2i::strToVec2 (cellTriggerEventNode->getAttribute ("destPos")->
|
|
getValue ());
|
|
triggerCount =
|
|
cellTriggerEventNode->getAttribute ("triggerCount")->getIntValue ();
|
|
|
|
if (cellTriggerEventNode->hasAttribute ("destPosEnd") == true)
|
|
{
|
|
destPosEnd =
|
|
Vec2i::strToVec2 (cellTriggerEventNode->
|
|
getAttribute ("destPosEnd")->getValue ());
|
|
}
|
|
}
|
|
|
|
TimerTriggerEvent::TimerTriggerEvent ()
|
|
{
|
|
running = false;
|
|
startFrame = 0;
|
|
endFrame = 0;
|
|
triggerSecondsElapsed = 0;
|
|
}
|
|
|
|
void
|
|
TimerTriggerEvent::saveGame (XmlNode * rootNode)
|
|
{
|
|
std::map < string, string > mapTagReplacements;
|
|
XmlNode *
|
|
timerTriggerEventNode = rootNode->addChild ("TimerTriggerEvent");
|
|
|
|
// bool running;
|
|
timerTriggerEventNode->addAttribute ("running", intToStr (running),
|
|
mapTagReplacements);
|
|
// //time_t startTime;
|
|
// //time_t endTime;
|
|
// int startFrame;
|
|
timerTriggerEventNode->addAttribute ("startFrame",
|
|
intToStr (startFrame),
|
|
mapTagReplacements);
|
|
// int endFrame;
|
|
timerTriggerEventNode->addAttribute ("endFrame", intToStr (endFrame),
|
|
mapTagReplacements);
|
|
|
|
if (triggerSecondsElapsed > 0)
|
|
{
|
|
timerTriggerEventNode->addAttribute ("triggerSecondsElapsed",
|
|
intToStr
|
|
(triggerSecondsElapsed),
|
|
mapTagReplacements);
|
|
}
|
|
}
|
|
|
|
void
|
|
TimerTriggerEvent::loadGame (const XmlNode * rootNode)
|
|
{
|
|
const XmlNode *
|
|
timerTriggerEventNode = rootNode->getChild ("TimerTriggerEvent");
|
|
|
|
running =
|
|
timerTriggerEventNode->getAttribute ("running")->getIntValue () != 0;
|
|
startFrame =
|
|
timerTriggerEventNode->getAttribute ("startFrame")->getIntValue ();
|
|
endFrame =
|
|
timerTriggerEventNode->getAttribute ("endFrame")->getIntValue ();
|
|
if (timerTriggerEventNode->hasAttribute ("triggerSecondsElapsed") ==
|
|
true)
|
|
{
|
|
triggerSecondsElapsed =
|
|
timerTriggerEventNode->getAttribute ("triggerSecondsElapsed")->
|
|
getIntValue ();
|
|
}
|
|
}
|
|
|
|
// =====================================================
|
|
// class ScriptManager
|
|
// =====================================================
|
|
ScriptManager *
|
|
ScriptManager::thisScriptManager = NULL;
|
|
const int
|
|
ScriptManager::messageWrapCount = 35;
|
|
const int
|
|
ScriptManager::displayTextWrapCount = 64;
|
|
|
|
ScriptManager::ScriptManager ()
|
|
{
|
|
world = NULL;
|
|
gameCamera = NULL;
|
|
lastCreatedUnitId = -1;
|
|
lastDeadUnitId = 0;
|
|
lastDeadUnitCauseOfDeath = 0;
|
|
lastDeadUnitKillerId = 0;
|
|
lastAttackedUnitId = 0;
|
|
lastAttackingUnitId = 0;
|
|
gameOver = false;
|
|
gameWon = false;
|
|
currentTimerTriggeredEventId = 0;
|
|
currentCellTriggeredEventId = 0;
|
|
currentCellTriggeredEventUnitId = 0;
|
|
currentEventId = 0;
|
|
inCellTriggerEvent = false;
|
|
rootNode = NULL;
|
|
currentCellTriggeredEventAreaEntryUnitId = 0;
|
|
currentCellTriggeredEventAreaExitUnitId = 0;
|
|
lastDayNightTriggerStatus = 0;
|
|
registeredDayNightEvent = false;
|
|
errorCount = 0;
|
|
|
|
lastUnitTriggerEventUnitId = -1;
|
|
lastUnitTriggerEventType = utet_None;
|
|
}
|
|
|
|
ScriptManager::~ScriptManager ()
|
|
{
|
|
|
|
}
|
|
|
|
void
|
|
ScriptManager::init (World * world, GameCamera * gameCamera,
|
|
const XmlNode * rootNode)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
//printf("In [%s::%s Line: %d] rootNode [%p][%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,rootNode,(rootNode != NULL ? rootNode->getName().c_str() : "none"));
|
|
this->rootNode = rootNode;
|
|
const Scenario *
|
|
scenario = world->getScenario ();
|
|
|
|
this->world = world;
|
|
this->gameCamera = gameCamera;
|
|
|
|
//set static instance
|
|
thisScriptManager = this;
|
|
|
|
//printf("In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
|
|
currentEventId = 1;
|
|
CellTriggerEventList.clear ();
|
|
TimerTriggerEventList.clear ();
|
|
|
|
//printf("In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
|
|
|
|
//register functions
|
|
luaScript.registerFunction (networkShowMessageForFaction,
|
|
"networkShowMessageForFaction");
|
|
luaScript.registerFunction (networkShowMessageForTeam,
|
|
"networkShowMessageForTeam");
|
|
|
|
luaScript.registerFunction (networkSetCameraPositionForFaction,
|
|
"networkSetCameraPositionForFaction");
|
|
luaScript.registerFunction (networkSetCameraPositionForTeam,
|
|
"networkSetCameraPositionForTeam");
|
|
|
|
luaScript.registerFunction (showMessage, "showMessage");
|
|
luaScript.registerFunction (setDisplayText, "setDisplayText");
|
|
luaScript.registerFunction (addConsoleText, "addConsoleText");
|
|
luaScript.registerFunction (addConsoleLangText, "addConsoleLangText");
|
|
luaScript.registerFunction (DisplayFormattedText,
|
|
"DisplayFormattedText");
|
|
luaScript.registerFunction (DisplayFormattedText,
|
|
"displayFormattedText");
|
|
luaScript.registerFunction (DisplayFormattedLangText,
|
|
"DisplayFormattedLangText");
|
|
luaScript.registerFunction (DisplayFormattedLangText,
|
|
"displayFormattedLangText");
|
|
luaScript.registerFunction (clearDisplayText, "clearDisplayText");
|
|
luaScript.registerFunction (setCameraPosition, "setCameraPosition");
|
|
luaScript.registerFunction (shakeCamera, "shakeCamera");
|
|
luaScript.registerFunction (shakeCameraOnUnit, "shakeCameraOnUnit");
|
|
luaScript.registerFunction (createUnit, "createUnit");
|
|
luaScript.registerFunction (createUnitNoSpacing, "createUnitNoSpacing");
|
|
luaScript.registerFunction (setLockedUnitForFaction,
|
|
"setLockedUnitForFaction");
|
|
luaScript.registerFunction (destroyUnit, "destroyUnit");
|
|
luaScript.registerFunction (giveKills, "giveKills");
|
|
luaScript.registerFunction (morphToUnit, "morphToUnit");
|
|
luaScript.registerFunction (moveToUnit, "moveToUnit");
|
|
|
|
luaScript.registerFunction (playStaticSound, "playStaticSound");
|
|
luaScript.registerFunction (playStreamingSound, "playStreamingSound");
|
|
luaScript.registerFunction (stopStreamingSound, "stopStreamingSound");
|
|
luaScript.registerFunction (stopAllSound, "stopAllSound");
|
|
luaScript.registerFunction (togglePauseGame, "togglePauseGame");
|
|
|
|
luaScript.registerFunction (playStaticVideo, "playStaticVideo");
|
|
//luaScript.registerFunction(playStreamingVideo, "playStreamingVideo");
|
|
//luaScript.registerFunction(stopStreamingVideo, "stopStreamingVideo");
|
|
luaScript.registerFunction (stopAllVideo, "stopAllVideo");
|
|
|
|
luaScript.registerFunction (giveResource, "giveResource");
|
|
luaScript.registerFunction (givePositionCommand, "givePositionCommand");
|
|
luaScript.registerFunction (giveProductionCommand,
|
|
"giveProductionCommand");
|
|
luaScript.registerFunction (giveAttackCommand, "giveAttackCommand");
|
|
luaScript.registerFunction (giveUpgradeCommand, "giveUpgradeCommand");
|
|
luaScript.registerFunction (giveAttackStoppedCommand,
|
|
"giveAttackStoppedCommand");
|
|
luaScript.registerFunction (disableAi, "disableAi");
|
|
luaScript.registerFunction (enableAi, "enableAi");
|
|
luaScript.registerFunction (getAiEnabled, "getAiEnabled");
|
|
luaScript.registerFunction (disableConsume, "disableConsume");
|
|
luaScript.registerFunction (enableConsume, "enableConsume");
|
|
luaScript.registerFunction (getConsumeEnabled, "getConsumeEnabled");
|
|
luaScript.registerFunction (setPlayerAsWinner, "setPlayerAsWinner");
|
|
luaScript.registerFunction (endGame, "endGame");
|
|
|
|
luaScript.registerFunction (startPerformanceTimer,
|
|
"startPerformanceTimer");
|
|
luaScript.registerFunction (endPerformanceTimer, "endPerformanceTimer");
|
|
luaScript.registerFunction (getPerformanceTimerResults,
|
|
"getPerformanceTimerResults");
|
|
|
|
luaScript.registerFunction (registerCellTriggerEventForUnitToUnit,
|
|
"registerCellTriggerEventForUnitToUnit");
|
|
luaScript.registerFunction (registerCellTriggerEventForUnitToLocation,
|
|
"registerCellTriggerEventForUnitToLocation");
|
|
luaScript.registerFunction (registerCellTriggerEventForFactionToUnit,
|
|
"registerCellTriggerEventForFactionToUnit");
|
|
luaScript.
|
|
registerFunction (registerCellTriggerEventForFactionToLocation,
|
|
"registerCellTriggerEventForFactionToLocation");
|
|
|
|
luaScript.
|
|
registerFunction (registerCellAreaTriggerEventForUnitToLocation,
|
|
"registerCellAreaTriggerEventForUnitToLocation");
|
|
luaScript.
|
|
registerFunction (registerCellAreaTriggerEventForFactionToLocation,
|
|
"registerCellAreaTriggerEventForFactionToLocation");
|
|
luaScript.registerFunction (registerCellAreaTriggerEvent,
|
|
"registerCellAreaTriggerEvent");
|
|
|
|
luaScript.registerFunction (getCellTriggerEventCount,
|
|
"getCellTriggerEventCount");
|
|
luaScript.registerFunction (unregisterCellTriggerEvent,
|
|
"unregisterCellTriggerEvent");
|
|
luaScript.registerFunction (startTimerEvent, "startTimerEvent");
|
|
luaScript.registerFunction (startEfficientTimerEvent,
|
|
"startEfficientTimerEvent");
|
|
luaScript.registerFunction (resetTimerEvent, "resetTimerEvent");
|
|
luaScript.registerFunction (stopTimerEvent, "stopTimerEvent");
|
|
luaScript.registerFunction (getTimerEventSecondsElapsed,
|
|
"timerEventSecondsElapsed");
|
|
luaScript.registerFunction (getCellTriggeredEventId,
|
|
"triggeredCellEventId");
|
|
luaScript.registerFunction (getTimerTriggeredEventId,
|
|
"triggeredTimerEventId");
|
|
|
|
luaScript.registerFunction (getCellTriggeredEventAreaEntryUnitId,
|
|
"triggeredEventAreaEntryUnitId");
|
|
luaScript.registerFunction (getCellTriggeredEventAreaExitUnitId,
|
|
"triggeredEventAreaExitUnitId");
|
|
|
|
luaScript.registerFunction (getCellTriggeredEventUnitId,
|
|
"triggeredCellEventUnitId");
|
|
|
|
luaScript.registerFunction (setRandomGenInit, "setRandomGenInit");
|
|
luaScript.registerFunction (getRandomGen, "getRandomGen");
|
|
luaScript.registerFunction (getWorldFrameCount, "getWorldFrameCount");
|
|
|
|
luaScript.registerFunction (getStartLocation, "startLocation");
|
|
luaScript.registerFunction (getIsUnitAlive, "isUnitAlive");
|
|
luaScript.registerFunction (getUnitPosition, "unitPosition");
|
|
luaScript.registerFunction (setUnitPosition, "setUnitPosition");
|
|
|
|
luaScript.registerFunction (addCellMarker, "addCellMarker");
|
|
luaScript.registerFunction (removeCellMarker, "removeCellMarker");
|
|
luaScript.registerFunction (showMarker, "showMarker");
|
|
|
|
luaScript.registerFunction (getUnitFaction, "unitFaction");
|
|
luaScript.registerFunction (getUnitName, "unitName");
|
|
luaScript.registerFunction (getResourceAmount, "resourceAmount");
|
|
|
|
luaScript.registerFunction (getLastCreatedUnitName,
|
|
"lastCreatedUnitName");
|
|
luaScript.registerFunction (getLastCreatedUnitId, "lastCreatedUnit");
|
|
|
|
luaScript.registerFunction (getLastDeadUnitName, "lastDeadUnitName");
|
|
luaScript.registerFunction (getLastDeadUnitId, "lastDeadUnit");
|
|
luaScript.registerFunction (getLastDeadUnitCauseOfDeath,
|
|
"lastDeadUnitCauseOfDeath");
|
|
luaScript.registerFunction (getLastDeadUnitKillerName,
|
|
"lastDeadUnitKillerName");
|
|
luaScript.registerFunction (getLastDeadUnitKillerId,
|
|
"lastDeadUnitKiller");
|
|
|
|
luaScript.registerFunction (getLastAttackedUnitName,
|
|
"lastAttackedUnitName");
|
|
luaScript.registerFunction (getLastAttackedUnitId, "lastAttackedUnit");
|
|
|
|
luaScript.registerFunction (getLastAttackingUnitName,
|
|
"lastAttackingUnitName");
|
|
luaScript.registerFunction (getLastAttackingUnitId,
|
|
"lastAttackingUnit");
|
|
|
|
luaScript.registerFunction (getUnitCount, "unitCount");
|
|
luaScript.registerFunction (getUnitCountOfType, "unitCountOfType");
|
|
|
|
luaScript.registerFunction (getIsGameOver, "isGameOver");
|
|
luaScript.registerFunction (getGameWon, "gameWon");
|
|
|
|
luaScript.registerFunction (getSystemMacroValue, "getSystemMacroValue");
|
|
luaScript.registerFunction (scenarioDir, "scenarioDir");
|
|
luaScript.registerFunction (getPlayerName, "getPlayerName");
|
|
luaScript.registerFunction (getPlayerName, "playerName");
|
|
|
|
luaScript.registerFunction (loadScenario, "loadScenario");
|
|
|
|
luaScript.registerFunction (getUnitsForFaction, "getUnitsForFaction");
|
|
luaScript.registerFunction (getUnitCurrentField, "getUnitCurrentField");
|
|
|
|
luaScript.registerFunction (isFreeCellsOrHasUnit,
|
|
"isFreeCellsOrHasUnit");
|
|
luaScript.registerFunction (isFreeCells, "isFreeCells");
|
|
|
|
luaScript.registerFunction (getHumanFactionId, "humanFaction");
|
|
|
|
luaScript.registerFunction (highlightUnit, "highlightUnit");
|
|
luaScript.registerFunction (unhighlightUnit, "unhighlightUnit");
|
|
|
|
luaScript.registerFunction (giveStopCommand, "giveStopCommand");
|
|
luaScript.registerFunction (selectUnit, "selectUnit");
|
|
luaScript.registerFunction (unselectUnit, "unselectUnit");
|
|
luaScript.registerFunction (addUnitToGroupSelection,
|
|
"addUnitToGroupSelection");
|
|
luaScript.registerFunction (recallGroupSelection,
|
|
"recallGroupSelection");
|
|
luaScript.registerFunction (removeUnitFromGroupSelection,
|
|
"removeUnitFromGroupSelection");
|
|
luaScript.registerFunction (setAttackWarningsEnabled,
|
|
"setAttackWarningsEnabled");
|
|
luaScript.registerFunction (getAttackWarningsEnabled,
|
|
"getAttackWarningsEnabled");
|
|
|
|
luaScript.registerFunction (getIsDayTime, "getIsDayTime");
|
|
luaScript.registerFunction (getIsNightTime, "getIsNightTime");
|
|
luaScript.registerFunction (getTimeOfDay, "getTimeOfDay");
|
|
luaScript.registerFunction (registerDayNightEvent,
|
|
"registerDayNightEvent");
|
|
luaScript.registerFunction (unregisterDayNightEvent,
|
|
"unregisterDayNightEvent");
|
|
|
|
luaScript.registerFunction (registerUnitTriggerEvent,
|
|
"registerUnitTriggerEvent");
|
|
luaScript.registerFunction (unregisterUnitTriggerEvent,
|
|
"unregisterUnitTriggerEvent");
|
|
luaScript.registerFunction (getLastUnitTriggerEventUnitId,
|
|
"lastUnitTriggerEventUnit");
|
|
luaScript.registerFunction (getLastUnitTriggerEventType,
|
|
"lastUnitTriggerEventType");
|
|
luaScript.registerFunction (getUnitProperty, "getUnitProperty");
|
|
luaScript.registerFunction (getUnitPropertyName, "getUnitPropertyName");
|
|
luaScript.registerFunction (disableSpeedChange, "disableSpeedChange");
|
|
luaScript.registerFunction (enableSpeedChange, "enableSpeedChange");
|
|
luaScript.registerFunction (getSpeedChangeEnabled,
|
|
"getSpeedChangeEnabled");
|
|
|
|
luaScript.registerFunction (storeSaveGameData, "storeSaveGameData");
|
|
luaScript.registerFunction (loadSaveGameData, "loadSaveGameData");
|
|
|
|
luaScript.registerFunction (getFactionPlayerType,
|
|
"getFactionPlayerType");
|
|
|
|
//load code
|
|
for (int i = 0; i < scenario->getScriptCount (); ++i)
|
|
{
|
|
const Script *
|
|
script = scenario->getScript (i);
|
|
luaScript.loadCode ("function " + script->getName () + "()" +
|
|
script->getCode () + "end\n",
|
|
script->getName ());
|
|
}
|
|
|
|
|
|
//!!!
|
|
// string data_path= getGameReadWritePath(GameConstants::path_data_CacheLookupKey);
|
|
// if(data_path != ""){
|
|
// endPathWithSlash(data_path);
|
|
// }
|
|
// string sandboxScriptFilename = data_path + "data/core/scripts/sandbox.lua";
|
|
// string sandboxLuaCode = getFileTextContents(sandboxScriptFilename);
|
|
//
|
|
// //luaScript.loadCode(sandboxLuaCode + "\n", "megaglest_lua_sandbox");
|
|
// luaScript.setSandboxWrapperFunctionName("runsandboxed");
|
|
// luaScript.setSandboxCode(sandboxLuaCode);
|
|
// luaScript.runCode(sandboxLuaCode);
|
|
|
|
// // Setup the lua security sandbox here
|
|
// luaScript.beginCall("megaglest_lua_sandbox");
|
|
// luaScript.endCall();
|
|
|
|
//setup message box
|
|
messageBox.init (Lang::getInstance ().getString ("Ok"));
|
|
messageBox.setEnabled (false);
|
|
//messageBox.setAutoWordWrap(false);
|
|
|
|
//last created unit
|
|
lastCreatedUnitId = -1;
|
|
lastDeadUnitName = "";
|
|
lastDeadUnitId = -1;
|
|
lastDeadUnitCauseOfDeath = ucodNone;
|
|
lastDeadUnitKillerName = "";
|
|
lastDeadUnitKillerId = -1;
|
|
|
|
lastAttackedUnitName = "";
|
|
lastAttackedUnitId = -1;
|
|
lastAttackingUnitName = "";
|
|
lastAttackingUnitId = -1;
|
|
|
|
gameOver = false;
|
|
gameWon = false;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
try
|
|
{
|
|
// Setup global functions and vars here
|
|
luaScript.beginCall ("global");
|
|
luaScript.endCall ();
|
|
|
|
//call startup function
|
|
if (this->rootNode == NULL)
|
|
{
|
|
luaScript.beginCall ("startup");
|
|
luaScript.endCall ();
|
|
}
|
|
else
|
|
{
|
|
loadGame (this->rootNode);
|
|
this->rootNode = NULL;
|
|
|
|
if (LuaScript::getDebugModeEnabled () == true)
|
|
printf ("Calling onLoad luaSavedGameData.size() = %d\n",
|
|
(int) luaSavedGameData.size ());
|
|
|
|
luaScript.beginCall ("onLoad");
|
|
luaScript.endCall ();
|
|
}
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
//string sErrBuf = "";
|
|
//if(ex.wantStackTrace() == true) {
|
|
char
|
|
szErrBuf[8096] = "";
|
|
//snprintf(szErrBuf,8096,"In [%s::%s %d]",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
|
|
string
|
|
sErrBuf =
|
|
string (szErrBuf) +
|
|
string ("The game may no longer be stable!\n\n\t [") +
|
|
string (ex.what ()) + string ("]\n");
|
|
//}
|
|
SystemFlags::OutputDebug (SystemFlags::debugError, sErrBuf.c_str ());
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugSystem).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugSystem,
|
|
sErrBuf.c_str ());
|
|
|
|
thisScriptManager->
|
|
addMessageToQueue (ScriptManagerMessage
|
|
(sErrBuf.c_str (), "error", -1, -1, true));
|
|
thisScriptManager->onMessageBoxOk (false);
|
|
}
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
// ========================== events ===============================================
|
|
|
|
void
|
|
ScriptManager::onMessageBoxOk (bool popFront)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
Lang & lang = Lang::getInstance ();
|
|
|
|
for (int index = 0; messageQueue.empty () == false; ++index)
|
|
{
|
|
//printf("i = %d messageQueue.size() = %d popFront = %d\n",i,messageQueue.size(),popFront);
|
|
if (popFront == true)
|
|
{
|
|
messageQueue.pop_front ();
|
|
}
|
|
if (messageQueue.empty () == false)
|
|
{
|
|
// printf("onMessageBoxOk [%s] factionIndex = %d [%d] teamIndex = %d [%d][%d]\n",
|
|
// wrapString(lang.getScenarioString(messageQueue.front().getText()), messageWrapCount).c_str(),
|
|
// messageQueue.front().getFactionIndex(), this->world->getThisFactionIndex(),
|
|
// messageQueue.front().getTeamIndex(),this->world->getThisTeamIndex(),this->world->getThisFaction()->getTeam());
|
|
|
|
if ((messageQueue.front ().getFactionIndex () < 0
|
|
&& messageQueue.front ().getTeamIndex () < 0)
|
|
|| messageQueue.front ().getFactionIndex () ==
|
|
this->world->getThisFactionIndex ()
|
|
|| messageQueue.front ().getTeamIndex () ==
|
|
this->world->getThisTeamIndex ())
|
|
{
|
|
|
|
messageBox.setEnabled (true);
|
|
|
|
string
|
|
msgText = messageQueue.front ().getText ();
|
|
string
|
|
msgHeader = messageQueue.front ().getHeader ();
|
|
if (messageQueue.front ().getMessageNotTranslated () ==
|
|
false)
|
|
{
|
|
|
|
msgText =
|
|
lang.getScenarioString (messageQueue.front ().
|
|
getText ());
|
|
msgHeader =
|
|
lang.getScenarioString (messageQueue.front ().
|
|
getHeader ());
|
|
}
|
|
messageBox.setText (msgText);
|
|
messageBox.setHeader (msgHeader);
|
|
break;
|
|
}
|
|
popFront = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::onResourceHarvested ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (this->rootNode == NULL)
|
|
{
|
|
luaScript.beginCall ("resourceHarvested");
|
|
luaScript.endCall ();
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::onUnitCreated (const Unit * unit)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (this->rootNode == NULL)
|
|
{
|
|
lastCreatedUnitName = unit->getType ()->getName (false);
|
|
lastCreatedUnitId = unit->getId ();
|
|
luaScript.beginCall ("unitCreated");
|
|
luaScript.endCall ();
|
|
luaScript.beginCall ("unitCreatedOfType_" +
|
|
unit->getType ()->getName ());
|
|
luaScript.endCall ();
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::onUnitDied (const Unit * unit)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (this->rootNode == NULL)
|
|
{
|
|
if (unit->getLastAttackerUnitId () >= 0)
|
|
{
|
|
Unit *
|
|
killer = world->findUnitById (unit->getLastAttackerUnitId ());
|
|
|
|
if (killer != NULL)
|
|
{
|
|
lastAttackingUnitName = killer->getType ()->getName (false);
|
|
lastAttackingUnitId = killer->getId ();
|
|
|
|
lastDeadUnitKillerName =
|
|
killer->getType ()->getName (false);
|
|
lastDeadUnitKillerId = killer->getId ();
|
|
}
|
|
else
|
|
{
|
|
lastDeadUnitKillerName = "";
|
|
lastDeadUnitKillerId = -1;
|
|
}
|
|
}
|
|
|
|
lastAttackedUnitName = unit->getType ()->getName (false);
|
|
lastAttackedUnitId = unit->getId ();
|
|
|
|
lastDeadUnitName = unit->getType ()->getName (false);
|
|
lastDeadUnitId = unit->getId ();
|
|
lastDeadUnitCauseOfDeath = unit->getCauseOfDeath ();
|
|
|
|
luaScript.beginCall ("unitDied");
|
|
luaScript.endCall ();
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::onUnitAttacked (const Unit * unit)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (this->rootNode == NULL)
|
|
{
|
|
lastAttackedUnitName = unit->getType ()->getName (false);
|
|
lastAttackedUnitId = unit->getId ();
|
|
luaScript.beginCall ("unitAttacked");
|
|
luaScript.endCall ();
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::onUnitAttacking (const Unit * unit)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (this->rootNode == NULL)
|
|
{
|
|
lastAttackingUnitName = unit->getType ()->getName (false);
|
|
lastAttackingUnitId = unit->getId ();
|
|
luaScript.beginCall ("unitAttacking");
|
|
luaScript.endCall ();
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::onGameOver (bool won)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
gameWon = won;
|
|
luaScript.beginCall ("gameOver");
|
|
luaScript.endCall ();
|
|
}
|
|
|
|
void
|
|
ScriptManager::onTimerTriggerEvent ()
|
|
{
|
|
if (TimerTriggerEventList.empty () == true)
|
|
{
|
|
return;
|
|
}
|
|
if (this->rootNode != NULL)
|
|
{
|
|
return;
|
|
}
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] TimerTriggerEventList.size() = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
TimerTriggerEventList.size ());
|
|
|
|
for (std::map < int, TimerTriggerEvent >::iterator iterMap =
|
|
TimerTriggerEventList.begin ();
|
|
iterMap != TimerTriggerEventList.end (); ++iterMap)
|
|
{
|
|
|
|
TimerTriggerEvent & event = iterMap->second;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] event.running = %d, event.startTime = %lld, event.endTime = %lld, diff = %f\n",
|
|
__FILE__, __FUNCTION__, __LINE__,
|
|
event.running,
|
|
(long long int) event.startFrame,
|
|
(long long int) event.endFrame,
|
|
(event.endFrame - event.startFrame));
|
|
|
|
if (event.running == true)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath
|
|
(__FILE__).c_str (), __FUNCTION__,
|
|
__LINE__);
|
|
|
|
// If using an efficient timer, check if its time to trigger
|
|
// on the elapsed check
|
|
if (event.triggerSecondsElapsed > 0)
|
|
{
|
|
int
|
|
elapsed =
|
|
(world->getFrameCount () -
|
|
event.startFrame) / GameConstants::updateFps;
|
|
if (elapsed < event.triggerSecondsElapsed)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
currentTimerTriggeredEventId = iterMap->first;
|
|
luaScript.beginCall ("timerTriggerEvent");
|
|
luaScript.endCall ();
|
|
|
|
if (event.triggerSecondsElapsed > 0)
|
|
{
|
|
int
|
|
timerId = iterMap->first;
|
|
stopTimerEvent (timerId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::onCellTriggerEvent (Unit * movingUnit)
|
|
{
|
|
if (CellTriggerEventList.empty () == true)
|
|
{
|
|
return;
|
|
}
|
|
if (this->rootNode != NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] movingUnit = %p, CellTriggerEventList.size() = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
movingUnit, CellTriggerEventList.size ());
|
|
|
|
// remove any delayed removals
|
|
unregisterCellTriggerEvent (-1);
|
|
|
|
inCellTriggerEvent = true;
|
|
if (movingUnit != NULL)
|
|
{
|
|
//ScenarioInfo scenarioInfoStart = world->getScenario()->getInfo();
|
|
|
|
for (std::map < int, CellTriggerEvent >::iterator iterMap =
|
|
CellTriggerEventList.begin ();
|
|
iterMap != CellTriggerEventList.end (); ++iterMap)
|
|
{
|
|
CellTriggerEvent & event = iterMap->second;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] movingUnit = %d, event.type = %d, movingUnit->getPos() = %s, event.sourceId = %d, event.destId = %d, event.destPos = %s\n",
|
|
__FILE__, __FUNCTION__, __LINE__,
|
|
movingUnit->getId (), event.type,
|
|
movingUnit->getPos ().getString ().
|
|
c_str (), event.sourceId,
|
|
event.destId,
|
|
event.destPos.getString ().
|
|
c_str ());
|
|
|
|
bool
|
|
triggerEvent = false;
|
|
currentCellTriggeredEventAreaEntryUnitId = 0;
|
|
currentCellTriggeredEventAreaExitUnitId = 0;
|
|
currentCellTriggeredEventUnitId = 0;
|
|
|
|
switch (event.type)
|
|
{
|
|
case ctet_Unit:
|
|
{
|
|
Unit *
|
|
destUnit = world->findUnitById (event.destId);
|
|
if (destUnit != NULL)
|
|
{
|
|
if (movingUnit->getId () == event.sourceId)
|
|
{
|
|
bool
|
|
srcInDst =
|
|
world->getMap ()->isInUnitTypeCells (destUnit->
|
|
getType (),
|
|
destUnit->
|
|
getPos (),
|
|
movingUnit->
|
|
getPos ());
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] movingUnit = %d, event.type = %d, movingUnit->getPos() = %s, event.sourceId = %d, event.destId = %d, event.destPos = %s, destUnit->getPos() = %s, srcInDst = %d\n",
|
|
__FILE__,
|
|
__FUNCTION__,
|
|
__LINE__,
|
|
movingUnit->getId (),
|
|
event.type,
|
|
movingUnit->getPos ().
|
|
getString ().c_str (),
|
|
event.sourceId,
|
|
event.destId,
|
|
event.destPos.
|
|
getString ().c_str (),
|
|
destUnit->getPos ().
|
|
getString ().c_str (),
|
|
srcInDst);
|
|
|
|
if (srcInDst == true)
|
|
{
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::
|
|
debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::
|
|
debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath
|
|
(__FILE__).
|
|
c_str (),
|
|
__FUNCTION__,
|
|
__LINE__);
|
|
}
|
|
else
|
|
{
|
|
srcInDst =
|
|
world->getMap ()->
|
|
isNextToUnitTypeCells (destUnit->getType (),
|
|
destUnit->getPos (),
|
|
movingUnit->
|
|
getPos ());
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::
|
|
debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::
|
|
debugLUA,
|
|
"In [%s::%s Line: %d] movingUnit = %d, event.type = %d, movingUnit->getPos() = %s, event.sourceId = %d, event.destId = %d, event.destPos = %s, destUnit->getPos() = %s, srcInDst = %d\n",
|
|
__FILE__,
|
|
__FUNCTION__,
|
|
__LINE__,
|
|
movingUnit->
|
|
getId (),
|
|
event.type,
|
|
movingUnit->
|
|
getPos ().
|
|
getString ().
|
|
c_str (),
|
|
event.sourceId,
|
|
event.destId,
|
|
event.destPos.
|
|
getString ().
|
|
c_str (),
|
|
destUnit->
|
|
getPos ().
|
|
getString ().
|
|
c_str (),
|
|
srcInDst);
|
|
}
|
|
triggerEvent = srcInDst;
|
|
if (triggerEvent == true)
|
|
{
|
|
currentCellTriggeredEventUnitId =
|
|
movingUnit->getId ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case ctet_UnitPos:
|
|
{
|
|
if (movingUnit->getId () == event.sourceId)
|
|
{
|
|
bool
|
|
srcInDst =
|
|
world->getMap ()->isInUnitTypeCells (movingUnit->
|
|
getType (),
|
|
event.destPos,
|
|
movingUnit->
|
|
getPos ());
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] movingUnit = %d, event.type = %d, movingUnit->getPos() = %s, event.sourceId = %d, event.destId = %d, event.destPos = %s, srcInDst = %d\n",
|
|
__FILE__, __FUNCTION__,
|
|
__LINE__,
|
|
movingUnit->getId (),
|
|
event.type,
|
|
movingUnit->getPos ().
|
|
getString ().c_str (),
|
|
event.sourceId,
|
|
event.destId,
|
|
event.destPos.
|
|
getString ().c_str (),
|
|
srcInDst);
|
|
|
|
if (srcInDst == true)
|
|
{
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath
|
|
(__FILE__).c_str (),
|
|
__FUNCTION__,
|
|
__LINE__);
|
|
}
|
|
triggerEvent = srcInDst;
|
|
|
|
if (triggerEvent == true)
|
|
{
|
|
currentCellTriggeredEventUnitId =
|
|
movingUnit->getId ();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ctet_UnitAreaPos:
|
|
{
|
|
if (movingUnit->getId () == event.sourceId)
|
|
{
|
|
bool
|
|
srcInDst = false;
|
|
|
|
// Cache area lookup so for each unitsize and pos its done only once
|
|
bool
|
|
foundInCache = false;
|
|
std::map < int,
|
|
std::map <
|
|
Vec2i,
|
|
bool > >::iterator
|
|
iterFind1 =
|
|
event.eventLookupCache.find (movingUnit->
|
|
getType ()->
|
|
getSize ());
|
|
if (iterFind1 != event.eventLookupCache.end ())
|
|
{
|
|
std::map < Vec2i, bool >::iterator iterFind2 =
|
|
iterFind1->second.find (movingUnit->getPos ());
|
|
if (iterFind2 != iterFind1->second.end ())
|
|
{
|
|
foundInCache = true;
|
|
srcInDst = iterFind2->second;
|
|
}
|
|
}
|
|
|
|
if (foundInCache == false)
|
|
{
|
|
for (int x = event.destPos.x;
|
|
srcInDst == false && x <= event.destPosEnd.x;
|
|
++x)
|
|
{
|
|
for (int y = event.destPos.y;
|
|
srcInDst == false
|
|
&& y <= event.destPosEnd.y; ++y)
|
|
{
|
|
srcInDst =
|
|
world->getMap ()->
|
|
isInUnitTypeCells (movingUnit->
|
|
getType (), Vec2i (x,
|
|
y),
|
|
movingUnit->
|
|
getPos ());
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::
|
|
debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::
|
|
debugLUA,
|
|
"In [%s::%s Line: %d] movingUnit = %d, event.type = %d, movingUnit->getPos() = %s, event.sourceId = %d, event.destId = %d, event.destPos = %s, srcInDst = %d\n",
|
|
__FILE__,
|
|
__FUNCTION__,
|
|
__LINE__,
|
|
movingUnit->
|
|
getId (),
|
|
event.type,
|
|
movingUnit->
|
|
getPos ().
|
|
getString ().
|
|
c_str (),
|
|
event.
|
|
sourceId,
|
|
event.destId,
|
|
Vec2i (x,
|
|
y).
|
|
getString ().
|
|
c_str (),
|
|
srcInDst);
|
|
}
|
|
}
|
|
|
|
event.eventLookupCache[movingUnit->getType ()->
|
|
getSize ()][movingUnit->
|
|
getPos ()] =
|
|
srcInDst;
|
|
}
|
|
|
|
if (srcInDst == true)
|
|
{
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath
|
|
(__FILE__).c_str (),
|
|
__FUNCTION__,
|
|
__LINE__);
|
|
}
|
|
triggerEvent = srcInDst;
|
|
if (triggerEvent == true)
|
|
{
|
|
currentCellTriggeredEventUnitId =
|
|
movingUnit->getId ();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ctet_Faction:
|
|
{
|
|
Unit *
|
|
destUnit = world->findUnitById (event.destId);
|
|
if (destUnit != NULL &&
|
|
movingUnit->getFactionIndex () == event.sourceId)
|
|
{
|
|
bool
|
|
srcInDst =
|
|
world->getMap ()->isInUnitTypeCells (destUnit->
|
|
getType (),
|
|
destUnit->
|
|
getPos (),
|
|
movingUnit->
|
|
getPos ());
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] movingUnit = %d, event.type = %d, movingUnit->getPos() = %s, event.sourceId = %d, event.destId = %d, event.destPos = %s, srcInDst = %d\n",
|
|
__FILE__, __FUNCTION__,
|
|
__LINE__,
|
|
movingUnit->getId (),
|
|
event.type,
|
|
movingUnit->getPos ().
|
|
getString ().c_str (),
|
|
event.sourceId,
|
|
event.destId,
|
|
event.destPos.
|
|
getString ().c_str (),
|
|
srcInDst);
|
|
|
|
if (srcInDst == true)
|
|
{
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath
|
|
(__FILE__).c_str (),
|
|
__FUNCTION__,
|
|
__LINE__);
|
|
}
|
|
else
|
|
{
|
|
srcInDst =
|
|
world->getMap ()->
|
|
isNextToUnitTypeCells (destUnit->getType (),
|
|
destUnit->getPos (),
|
|
movingUnit->getPos ());
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] movingUnit = %d, event.type = %d, movingUnit->getPos() = %s, event.sourceId = %d, event.destId = %d, event.destPos = %s, destUnit->getPos() = %s, srcInDst = %d\n",
|
|
__FILE__,
|
|
__FUNCTION__,
|
|
__LINE__,
|
|
movingUnit->getId (),
|
|
event.type,
|
|
movingUnit->getPos ().
|
|
getString ().c_str (),
|
|
event.sourceId,
|
|
event.destId,
|
|
event.destPos.
|
|
getString ().c_str (),
|
|
destUnit->getPos ().
|
|
getString ().c_str (),
|
|
srcInDst);
|
|
}
|
|
triggerEvent = srcInDst;
|
|
if (triggerEvent == true)
|
|
{
|
|
currentCellTriggeredEventUnitId =
|
|
movingUnit->getId ();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ctet_FactionPos:
|
|
{
|
|
if (movingUnit->getFactionIndex () == event.sourceId)
|
|
{
|
|
//printf("ctet_FactionPos event.destPos = [%s], movingUnit->getPos() [%s]\n",event.destPos.getString().c_str(),movingUnit->getPos().getString().c_str());
|
|
|
|
bool
|
|
srcInDst =
|
|
world->getMap ()->isInUnitTypeCells (movingUnit->
|
|
getType (),
|
|
event.destPos,
|
|
movingUnit->
|
|
getPos ());
|
|
if (srcInDst == true)
|
|
{
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath
|
|
(__FILE__).c_str (),
|
|
__FUNCTION__,
|
|
__LINE__);
|
|
}
|
|
triggerEvent = srcInDst;
|
|
if (triggerEvent == true)
|
|
{
|
|
currentCellTriggeredEventUnitId =
|
|
movingUnit->getId ();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ctet_FactionAreaPos:
|
|
{
|
|
if (movingUnit->getFactionIndex () == event.sourceId)
|
|
{
|
|
//if(event.sourceId == 1) printf("ctet_FactionPos event.destPos = [%s], movingUnit->getPos() [%s] Unit id = %d\n",event.destPos.getString().c_str(),movingUnit->getPos().getString().c_str(),movingUnit->getId());
|
|
|
|
bool
|
|
srcInDst = false;
|
|
|
|
// Cache area lookup so for each unitsize and pos its done only once
|
|
bool
|
|
foundInCache = false;
|
|
std::map < int,
|
|
std::map <
|
|
Vec2i,
|
|
bool > >::iterator
|
|
iterFind1 =
|
|
event.eventLookupCache.find (movingUnit->
|
|
getType ()->
|
|
getSize ());
|
|
if (iterFind1 != event.eventLookupCache.end ())
|
|
{
|
|
std::map < Vec2i, bool >::iterator iterFind2 =
|
|
iterFind1->second.find (movingUnit->getPos ());
|
|
if (iterFind2 != iterFind1->second.end ())
|
|
{
|
|
foundInCache = true;
|
|
srcInDst = iterFind2->second;
|
|
}
|
|
}
|
|
|
|
if (foundInCache == false)
|
|
{
|
|
for (int x = event.destPos.x;
|
|
srcInDst == false && x <= event.destPosEnd.x;
|
|
++x)
|
|
{
|
|
for (int y = event.destPos.y;
|
|
srcInDst == false
|
|
&& y <= event.destPosEnd.y; ++y)
|
|
{
|
|
|
|
srcInDst =
|
|
world->getMap ()->
|
|
isInUnitTypeCells (movingUnit->
|
|
getType (), Vec2i (x,
|
|
y),
|
|
movingUnit->
|
|
getPos ());
|
|
if (srcInDst == true)
|
|
{
|
|
if (SystemFlags::
|
|
getSystemSettingType
|
|
(SystemFlags::debugLUA).enabled)
|
|
SystemFlags::
|
|
OutputDebug (SystemFlags::
|
|
debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath
|
|
(__FILE__).c_str (),
|
|
__FUNCTION__,
|
|
__LINE__);
|
|
}
|
|
}
|
|
}
|
|
|
|
event.eventLookupCache[movingUnit->getType ()->
|
|
getSize ()][movingUnit->
|
|
getPos ()] =
|
|
srcInDst;
|
|
}
|
|
|
|
triggerEvent = srcInDst;
|
|
if (triggerEvent == true)
|
|
{
|
|
//printf("!!!UNIT IN AREA!!! Faction area pos, moving unit faction= %d, trigger faction = %d, unit id = %d\n",movingUnit->getFactionIndex(),event.sourceId,movingUnit->getId());
|
|
currentCellTriggeredEventUnitId =
|
|
movingUnit->getId ();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ctet_AreaPos:
|
|
{
|
|
// Is the unit already in the cell range? If no check if they are entering it
|
|
if (event.eventStateInfo.find (movingUnit->getId ()) ==
|
|
event.eventStateInfo.end ())
|
|
{
|
|
//printf("ctet_FactionPos event.destPos = [%s], movingUnit->getPos() [%s]\n",event.destPos.getString().c_str(),movingUnit->getPos().getString().c_str());
|
|
|
|
bool
|
|
srcInDst = false;
|
|
for (int x = event.destPos.x;
|
|
srcInDst == false && x <= event.destPosEnd.x;
|
|
++x)
|
|
{
|
|
for (int y = event.destPos.y;
|
|
srcInDst == false && y <= event.destPosEnd.y;
|
|
++y)
|
|
{
|
|
|
|
srcInDst =
|
|
world->getMap ()->
|
|
isInUnitTypeCells (movingUnit->getType (),
|
|
Vec2i (x, y),
|
|
movingUnit->getPos ());
|
|
if (srcInDst == true)
|
|
{
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::
|
|
debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::
|
|
debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath
|
|
(__FILE__).
|
|
c_str (),
|
|
__FUNCTION__,
|
|
__LINE__);
|
|
|
|
currentCellTriggeredEventAreaEntryUnitId =
|
|
movingUnit->getId ();
|
|
event.eventStateInfo[movingUnit->
|
|
getId ()] =
|
|
Vec2i (x, y).getString ();
|
|
}
|
|
}
|
|
}
|
|
triggerEvent = srcInDst;
|
|
if (triggerEvent == true)
|
|
{
|
|
currentCellTriggeredEventUnitId =
|
|
movingUnit->getId ();
|
|
}
|
|
}
|
|
// If unit is already in cell range check if they are leaving?
|
|
else
|
|
{
|
|
bool
|
|
srcInDst = false;
|
|
for (int x = event.destPos.x;
|
|
srcInDst == false && x <= event.destPosEnd.x;
|
|
++x)
|
|
{
|
|
for (int y = event.destPos.y;
|
|
srcInDst == false && y <= event.destPosEnd.y;
|
|
++y)
|
|
{
|
|
|
|
srcInDst =
|
|
world->getMap ()->
|
|
isInUnitTypeCells (movingUnit->getType (),
|
|
Vec2i (x, y),
|
|
movingUnit->getPos ());
|
|
if (srcInDst == true)
|
|
{
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::
|
|
debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::
|
|
debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath
|
|
(__FILE__).
|
|
c_str (),
|
|
__FUNCTION__,
|
|
__LINE__);
|
|
|
|
//event.eventStateInfo[movingUnit->getId()] = Vec2i(x,y);
|
|
}
|
|
}
|
|
}
|
|
triggerEvent = (srcInDst == false);
|
|
if (triggerEvent == true)
|
|
{
|
|
currentCellTriggeredEventUnitId =
|
|
movingUnit->getId ();
|
|
}
|
|
|
|
if (triggerEvent == true)
|
|
{
|
|
currentCellTriggeredEventAreaExitUnitId =
|
|
movingUnit->getId ();
|
|
|
|
event.eventStateInfo.erase (movingUnit->getId ());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if (triggerEvent == true)
|
|
{
|
|
if (SystemFlags::
|
|
getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath
|
|
(__FILE__).c_str (),
|
|
__FUNCTION__, __LINE__);
|
|
|
|
currentCellTriggeredEventId = iterMap->first;
|
|
event.triggerCount++;
|
|
|
|
luaScript.beginCall ("cellTriggerEvent");
|
|
luaScript.endCall ();
|
|
}
|
|
|
|
// ScenarioInfo scenarioInfoEnd = world->getScenario()->getInfo();
|
|
// if(scenarioInfoStart.file != scenarioInfoEnd.file) {
|
|
// break;
|
|
// }
|
|
}
|
|
}
|
|
|
|
inCellTriggerEvent = false;
|
|
}
|
|
|
|
// ========================== lua wrappers ===============================================
|
|
|
|
string
|
|
ScriptManager::wrapString (const string & str, int wrapCount)
|
|
{
|
|
string
|
|
returnString;
|
|
|
|
int
|
|
letterCount = 0;
|
|
for (int i = 0; i < (int) str.size (); ++i)
|
|
{
|
|
if (letterCount > wrapCount && str[i] == ' ')
|
|
{
|
|
returnString += '\n';
|
|
letterCount = 0;
|
|
}
|
|
else
|
|
{
|
|
returnString += str[i];
|
|
}
|
|
++letterCount;
|
|
}
|
|
|
|
return returnString;
|
|
}
|
|
|
|
void
|
|
ScriptManager::networkShowMessageForFaction (const string & text,
|
|
const string & header,
|
|
int factionIndex)
|
|
{
|
|
messageQueue.
|
|
push_back (ScriptManagerMessage (text, header, factionIndex));
|
|
thisScriptManager->onMessageBoxOk (false);
|
|
}
|
|
void
|
|
ScriptManager::networkShowMessageForTeam (const string & text,
|
|
const string & header,
|
|
int teamIndex)
|
|
{
|
|
// Team indexes are 0 based internally (but 1 based in the lua script) so convert
|
|
teamIndex--;
|
|
messageQueue.
|
|
push_back (ScriptManagerMessage (text, header, -1, teamIndex));
|
|
thisScriptManager->onMessageBoxOk (false);
|
|
}
|
|
|
|
void
|
|
ScriptManager::networkSetCameraPositionForFaction (int factionIndex,
|
|
const Vec2i & pos)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (factionIndex == this->world->getThisFactionIndex ())
|
|
{
|
|
gameCamera->centerXZ (pos.x, pos.y);
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::networkSetCameraPositionForTeam (int teamIndex,
|
|
const Vec2i & pos)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (teamIndex == this->world->getThisTeamIndex ())
|
|
{
|
|
gameCamera->centerXZ (pos.x, pos.y);
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::showMessage (const string & text, const string & header)
|
|
{
|
|
messageQueue.push_back (ScriptManagerMessage (text, header));
|
|
thisScriptManager->onMessageBoxOk (false);
|
|
}
|
|
|
|
void
|
|
ScriptManager::clearDisplayText ()
|
|
{
|
|
displayText = "";
|
|
}
|
|
|
|
void
|
|
ScriptManager::setDisplayText (const string & text)
|
|
{
|
|
displayText =
|
|
wrapString (Lang::getInstance ().getScenarioString (text),
|
|
displayTextWrapCount);
|
|
}
|
|
|
|
void
|
|
ScriptManager::addConsoleText (const string & text)
|
|
{
|
|
world->addConsoleText (text);
|
|
}
|
|
void
|
|
ScriptManager::addConsoleLangText (const char *fmt, ...)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
va_list
|
|
argList;
|
|
va_start (argList, fmt);
|
|
|
|
const int
|
|
max_debug_buffer_size = 8096;
|
|
char
|
|
szBuf[max_debug_buffer_size] = "";
|
|
vsnprintf (szBuf, max_debug_buffer_size - 1, fmt, argList);
|
|
|
|
world->addConsoleTextWoLang (szBuf);
|
|
va_end (argList);
|
|
|
|
}
|
|
|
|
void
|
|
ScriptManager::DisplayFormattedText (const char *fmt, ...)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
va_list
|
|
argList;
|
|
va_start (argList, fmt);
|
|
|
|
const int
|
|
max_debug_buffer_size = 8096;
|
|
char
|
|
szBuf[max_debug_buffer_size] = "";
|
|
vsnprintf (szBuf, max_debug_buffer_size - 1, fmt, argList);
|
|
|
|
displayText = szBuf;
|
|
|
|
va_end (argList);
|
|
}
|
|
void
|
|
ScriptManager::DisplayFormattedLangText (const char *fmt, ...)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
va_list
|
|
argList;
|
|
va_start (argList, fmt);
|
|
|
|
const int
|
|
max_debug_buffer_size = 8096;
|
|
char
|
|
szBuf[max_debug_buffer_size] = "";
|
|
vsnprintf (szBuf, max_debug_buffer_size - 1, fmt, argList);
|
|
|
|
displayText = szBuf;
|
|
|
|
va_end (argList);
|
|
}
|
|
void
|
|
ScriptManager::setCameraPosition (const Vec2i & pos)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
gameCamera->centerXZ (pos.x, pos.y);
|
|
}
|
|
|
|
void
|
|
ScriptManager::shakeCamera (int shakeIntensity, int shakeDuration,
|
|
bool cameraDistanceAffected, int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (cameraDistanceAffected)
|
|
{
|
|
Unit *
|
|
unit = world->findUnitById (unitId);
|
|
if (unit)
|
|
{
|
|
gameCamera->shake (shakeDuration, shakeIntensity,
|
|
cameraDistanceAffected,
|
|
unit->getCurrMidHeightVector ());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gameCamera->shake (shakeDuration, shakeIntensity,
|
|
cameraDistanceAffected, Vec3f (0.f, 0.f, 0.f));
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::createUnit (const string & unitName, int factionIndex,
|
|
Vec2i pos)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%s] factionIndex = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
unitName.c_str (), factionIndex);
|
|
world->createUnit (unitName, factionIndex, pos);
|
|
}
|
|
|
|
void
|
|
ScriptManager::createUnitNoSpacing (const string & unitName,
|
|
int factionIndex, Vec2i pos)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%s] factionIndex = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
unitName.c_str (), factionIndex);
|
|
world->createUnit (unitName, factionIndex, pos, false);
|
|
}
|
|
|
|
void
|
|
ScriptManager::setLockedUnitForFaction (const string & unitName,
|
|
int factionIndex, bool lock)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%s] factionIndex = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
unitName.c_str (), factionIndex);
|
|
if (world->getFactionCount () > factionIndex)
|
|
{
|
|
const UnitType *
|
|
ut =
|
|
world->getFaction (factionIndex)->getType ()->
|
|
getUnitType (unitName);
|
|
world->getFaction (factionIndex)->setLockedUnitForFaction (ut,
|
|
lock);
|
|
}
|
|
else
|
|
{
|
|
throw
|
|
megaglest_runtime_error
|
|
("Invalid faction index in setLockedUnitForFaction: " +
|
|
intToStr (factionIndex), true);
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::destroyUnit (int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__, unitId);
|
|
Unit *
|
|
unit = world->findUnitById (unitId);
|
|
if (unit != NULL)
|
|
{
|
|
// Make sure they die
|
|
bool
|
|
unit_dead = unit->decHp (unit->getHp () * unit->getHp ());
|
|
if (unit_dead == false)
|
|
{
|
|
throw
|
|
megaglest_runtime_error ("unit_dead == false", true);
|
|
}
|
|
unit->kill ();
|
|
// If called from an existing die event we get a stack overflow
|
|
//onUnitDied(unit);
|
|
}
|
|
}
|
|
void
|
|
ScriptManager::giveKills (int unitId, int amount)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__, unitId);
|
|
Unit *
|
|
unit = world->findUnitById (unitId);
|
|
if (unit != NULL)
|
|
{
|
|
for (int index = 1; index <= amount; ++index)
|
|
{
|
|
unit->incKills (-1);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::playStaticSound (const string & playSound)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] playSound [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
playSound.c_str ());
|
|
world->playStaticSound (playSound);
|
|
}
|
|
void
|
|
ScriptManager::playStreamingSound (const string & playSound)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] playSound [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
playSound.c_str ());
|
|
world->playStreamingSound (playSound);
|
|
}
|
|
|
|
void
|
|
ScriptManager::stopStreamingSound (const string & playSound)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] playSound [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
playSound.c_str ());
|
|
world->stopStreamingSound (playSound);
|
|
}
|
|
|
|
void
|
|
ScriptManager::stopAllSound ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
world->stopAllSound ();
|
|
}
|
|
|
|
void
|
|
ScriptManager::playStaticVideo (const string & playVideo)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] playVideo [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
playVideo.c_str ());
|
|
world->playStaticVideo (playVideo);
|
|
}
|
|
void
|
|
ScriptManager::playStreamingVideo (const string & playVideo)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] playVideo [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
playVideo.c_str ());
|
|
world->playStreamingVideo (playVideo);
|
|
}
|
|
|
|
void
|
|
ScriptManager::stopStreamingVideo (const string & playVideo)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] playVideo [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
playVideo.c_str ());
|
|
world->stopStreamingVideo (playVideo);
|
|
}
|
|
|
|
void
|
|
ScriptManager::stopAllVideo ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
world->stopAllVideo ();
|
|
}
|
|
|
|
void
|
|
ScriptManager::togglePauseGame (int pauseStatus)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] pauseStatus = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
pauseStatus);
|
|
world->togglePauseGame ((pauseStatus != 0), true);
|
|
}
|
|
|
|
void
|
|
ScriptManager::morphToUnit (int unitId, const string & morphName,
|
|
int ignoreRequirements)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%d] morphName [%s] forceUpgradesIfRequired = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__, unitId,
|
|
morphName.c_str (), ignoreRequirements);
|
|
|
|
world->morphToUnit (unitId, morphName, (ignoreRequirements == 1));
|
|
}
|
|
|
|
void
|
|
ScriptManager::moveToUnit (int unitId, int destUnitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%d] destUnitId [%d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__, unitId,
|
|
destUnitId);
|
|
|
|
world->moveToUnit (unitId, destUnitId);
|
|
}
|
|
|
|
void
|
|
ScriptManager::giveResource (const string & resourceName,
|
|
int factionIndex, int amount)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->giveResource (resourceName, factionIndex, amount);
|
|
}
|
|
|
|
void
|
|
ScriptManager::givePositionCommand (int unitId,
|
|
const string & commandName,
|
|
const Vec2i & pos)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->givePositionCommand (unitId, commandName, pos);
|
|
}
|
|
|
|
void
|
|
ScriptManager::giveAttackCommand (int unitId, int unitToAttackId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->giveAttackCommand (unitId, unitToAttackId);
|
|
}
|
|
|
|
void
|
|
ScriptManager::giveProductionCommand (int unitId,
|
|
const string & producedName)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->giveProductionCommand (unitId, producedName);
|
|
}
|
|
|
|
void
|
|
ScriptManager::giveUpgradeCommand (int unitId,
|
|
const string & producedName)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->giveUpgradeCommand (unitId, producedName);
|
|
}
|
|
|
|
void
|
|
ScriptManager::giveAttackStoppedCommand (int unitId,
|
|
const string & itemName,
|
|
int ignoreRequirements)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->giveAttackStoppedCommand (unitId, itemName,
|
|
(ignoreRequirements == 1));
|
|
}
|
|
|
|
void
|
|
ScriptManager::disableAi (int factionIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (factionIndex >= 0 && factionIndex < GameConstants::maxPlayers)
|
|
{
|
|
playerModifiers[factionIndex].disableAi ();
|
|
disableConsume (factionIndex); // by this we stay somehow compatible with old behaviour
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::enableAi (int factionIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (factionIndex >= 0 && factionIndex < GameConstants::maxPlayers)
|
|
{
|
|
playerModifiers[factionIndex].enableAi ();
|
|
}
|
|
}
|
|
|
|
bool
|
|
ScriptManager::getAiEnabled (int factionIndex)
|
|
{
|
|
|
|
if (factionIndex >= 0 && factionIndex < GameConstants::maxPlayers)
|
|
{
|
|
return playerModifiers[factionIndex].getAiEnabled ();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
ScriptManager::disableConsume (int factionIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (factionIndex >= 0 && factionIndex < GameConstants::maxPlayers)
|
|
{
|
|
playerModifiers[factionIndex].disableConsume ();
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::enableConsume (int factionIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
if (factionIndex >= 0 && factionIndex < GameConstants::maxPlayers)
|
|
{
|
|
playerModifiers[factionIndex].enableConsume ();
|
|
}
|
|
}
|
|
|
|
bool
|
|
ScriptManager::getConsumeEnabled (int factionIndex)
|
|
{
|
|
|
|
if (factionIndex >= 0 && factionIndex < GameConstants::maxPlayers)
|
|
{
|
|
return playerModifiers[factionIndex].getConsumeEnabled ();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int
|
|
ScriptManager::registerCellTriggerEventForUnitToUnit (int sourceUnitId,
|
|
int destUnitId)
|
|
{
|
|
CellTriggerEvent
|
|
trigger;
|
|
trigger.type = ctet_Unit;
|
|
trigger.sourceId = sourceUnitId;
|
|
trigger.destId = destUnitId;
|
|
|
|
int
|
|
eventId = currentEventId++;
|
|
CellTriggerEventList[eventId] = trigger;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] Unit: %d will trigger cell event when reaching unit: %d, eventId = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
sourceUnitId, destUnitId, eventId);
|
|
|
|
return eventId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::
|
|
registerCellTriggerEventForUnitToLocation (int sourceUnitId,
|
|
const Vec2i & pos)
|
|
{
|
|
CellTriggerEvent
|
|
trigger;
|
|
trigger.type = ctet_UnitPos;
|
|
trigger.sourceId = sourceUnitId;
|
|
trigger.destPos = pos;
|
|
|
|
int
|
|
eventId = currentEventId++;
|
|
CellTriggerEventList[eventId] = trigger;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] Unit: %d will trigger cell event when reaching pos: %s, eventId = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
sourceUnitId, pos.getString ().c_str (),
|
|
eventId);
|
|
|
|
return eventId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::
|
|
registerCellAreaTriggerEventForUnitToLocation (int sourceUnitId,
|
|
const Vec4i & pos)
|
|
{
|
|
CellTriggerEvent
|
|
trigger;
|
|
trigger.type = ctet_UnitAreaPos;
|
|
trigger.sourceId = sourceUnitId;
|
|
trigger.destPos.x = pos.x;
|
|
trigger.destPos.y = pos.y;
|
|
trigger.destPosEnd.x = pos.z;
|
|
trigger.destPosEnd.y = pos.w;
|
|
|
|
int
|
|
eventId = currentEventId++;
|
|
CellTriggerEventList[eventId] = trigger;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] Unit: %d will trigger cell event when reaching pos: %s, eventId = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
sourceUnitId, pos.getString ().c_str (),
|
|
eventId);
|
|
|
|
return eventId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::
|
|
registerCellTriggerEventForFactionToUnit (int sourceFactionId,
|
|
int destUnitId)
|
|
{
|
|
CellTriggerEvent
|
|
trigger;
|
|
trigger.type = ctet_Faction;
|
|
trigger.sourceId = sourceFactionId;
|
|
trigger.destId = destUnitId;
|
|
|
|
int
|
|
eventId = currentEventId++;
|
|
CellTriggerEventList[eventId] = trigger;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] Faction: %d will trigger cell event when reaching unit: %d, eventId = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
sourceFactionId, destUnitId, eventId);
|
|
|
|
return eventId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::
|
|
registerCellTriggerEventForFactionToLocation (int sourceFactionId,
|
|
const Vec2i & pos)
|
|
{
|
|
CellTriggerEvent
|
|
trigger;
|
|
trigger.type = ctet_FactionPos;
|
|
trigger.sourceId = sourceFactionId;
|
|
trigger.destPos = pos;
|
|
|
|
int
|
|
eventId = currentEventId++;
|
|
CellTriggerEventList[eventId] = trigger;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]Faction: %d will trigger cell event when reaching pos: %s, eventId = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
sourceFactionId, pos.getString ().c_str (),
|
|
eventId);
|
|
|
|
return eventId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::
|
|
registerCellAreaTriggerEventForFactionToLocation (int sourceFactionId,
|
|
const Vec4i & pos)
|
|
{
|
|
CellTriggerEvent
|
|
trigger;
|
|
trigger.type = ctet_FactionAreaPos;
|
|
trigger.sourceId = sourceFactionId;
|
|
trigger.destPos.x = pos.x;
|
|
trigger.destPos.y = pos.y;
|
|
trigger.destPosEnd.x = pos.z;
|
|
trigger.destPosEnd.y = pos.w;
|
|
|
|
int
|
|
eventId = currentEventId++;
|
|
CellTriggerEventList[eventId] = trigger;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]Faction: %d will trigger cell event when reaching pos: %s, eventId = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
sourceFactionId, pos.getString ().c_str (),
|
|
eventId);
|
|
|
|
return eventId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::registerCellAreaTriggerEvent (const Vec4i & pos)
|
|
{
|
|
CellTriggerEvent
|
|
trigger;
|
|
trigger.type = ctet_AreaPos;
|
|
trigger.sourceId = -1;
|
|
trigger.destPos.x = pos.x;
|
|
trigger.destPos.y = pos.y;
|
|
trigger.destPosEnd.x = pos.z;
|
|
trigger.destPosEnd.y = pos.w;
|
|
|
|
int
|
|
eventId = currentEventId++;
|
|
CellTriggerEventList[eventId] = trigger;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] trigger cell event when reaching pos: %s, eventId = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
pos.getString ().c_str (), eventId);
|
|
|
|
return eventId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getCellTriggerEventCount (int eventId)
|
|
{
|
|
int
|
|
result = 0;
|
|
if (CellTriggerEventList.find (eventId) != CellTriggerEventList.end ())
|
|
{
|
|
result = CellTriggerEventList[eventId].triggerCount;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
ScriptManager::unregisterCellTriggerEvent (int eventId)
|
|
{
|
|
if (CellTriggerEventList.find (eventId) != CellTriggerEventList.end ())
|
|
{
|
|
if (inCellTriggerEvent == false)
|
|
{
|
|
CellTriggerEventList.erase (eventId);
|
|
}
|
|
else
|
|
{
|
|
unRegisterCellTriggerEventList.push_back (eventId);
|
|
}
|
|
}
|
|
|
|
if (inCellTriggerEvent == false)
|
|
{
|
|
if (unRegisterCellTriggerEventList.empty () == false)
|
|
{
|
|
for (int i = 0;
|
|
i < (int) unRegisterCellTriggerEventList.size (); ++i)
|
|
{
|
|
int
|
|
delayedEventId = unRegisterCellTriggerEventList[i];
|
|
CellTriggerEventList.erase (delayedEventId);
|
|
}
|
|
unRegisterCellTriggerEventList.clear ();
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
ScriptManager::startTimerEvent ()
|
|
{
|
|
TimerTriggerEvent
|
|
trigger;
|
|
trigger.running = true;
|
|
//trigger.startTime = time(NULL);
|
|
trigger.startFrame = world->getFrameCount ();
|
|
//trigger.endTime = 0;
|
|
trigger.endFrame = 0;
|
|
|
|
int
|
|
eventId = currentEventId++;
|
|
TimerTriggerEventList[eventId] = trigger;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] TimerTriggerEventList.size() = %d, eventId = %d, trigger.startTime = %lld, trigger.endTime = %lld\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
TimerTriggerEventList.size (), eventId,
|
|
(long long int) trigger.startFrame,
|
|
(long long int) trigger.endFrame);
|
|
|
|
return eventId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::startEfficientTimerEvent (int triggerSecondsElapsed)
|
|
{
|
|
TimerTriggerEvent
|
|
trigger;
|
|
trigger.running = true;
|
|
//trigger.startTime = time(NULL);
|
|
trigger.startFrame = world->getFrameCount ();
|
|
//trigger.endTime = 0;
|
|
trigger.endFrame = 0;
|
|
trigger.triggerSecondsElapsed = triggerSecondsElapsed;
|
|
|
|
int
|
|
eventId = currentEventId++;
|
|
TimerTriggerEventList[eventId] = trigger;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] TimerTriggerEventList.size() = %d, eventId = %d, trigger.startTime = %lld, trigger.endTime = %lld\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
TimerTriggerEventList.size (), eventId,
|
|
(long long int) trigger.startFrame,
|
|
(long long int) trigger.endFrame);
|
|
|
|
return eventId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::resetTimerEvent (int eventId)
|
|
{
|
|
int
|
|
result = 0;
|
|
if (TimerTriggerEventList.find (eventId) !=
|
|
TimerTriggerEventList.end ())
|
|
{
|
|
TimerTriggerEvent & trigger = TimerTriggerEventList[eventId];
|
|
result = getTimerEventSecondsElapsed (eventId);
|
|
|
|
//trigger.startTime = time(NULL);
|
|
trigger.startFrame = world->getFrameCount ();
|
|
//trigger.endTime = 0;
|
|
trigger.endFrame = 0;
|
|
trigger.running = true;
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] TimerTriggerEventList.size() = %d, eventId = %d, trigger.startTime = %lld, trigger.endTime = %lld, result = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
TimerTriggerEventList.size (), eventId,
|
|
(long long int) trigger.startFrame,
|
|
(long long int) trigger.endFrame,
|
|
result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int
|
|
ScriptManager::stopTimerEvent (int eventId)
|
|
{
|
|
int
|
|
result = 0;
|
|
if (TimerTriggerEventList.find (eventId) !=
|
|
TimerTriggerEventList.end ())
|
|
{
|
|
TimerTriggerEvent & trigger = TimerTriggerEventList[eventId];
|
|
//trigger.endTime = time(NULL);
|
|
trigger.endFrame = world->getFrameCount ();
|
|
trigger.running = false;
|
|
result = getTimerEventSecondsElapsed (eventId);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] TimerTriggerEventList.size() = %d, eventId = %d, trigger.startTime = %lld, trigger.endTime = %lld, result = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
TimerTriggerEventList.size (), eventId,
|
|
(long long int) trigger.startFrame,
|
|
(long long int) trigger.endFrame,
|
|
result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getTimerEventSecondsElapsed (int eventId)
|
|
{
|
|
int
|
|
result = 0;
|
|
if (TimerTriggerEventList.find (eventId) !=
|
|
TimerTriggerEventList.end ())
|
|
{
|
|
TimerTriggerEvent & trigger = TimerTriggerEventList[eventId];
|
|
if (trigger.running)
|
|
{
|
|
//result = (int)difftime(time(NULL),trigger.startTime);
|
|
result =
|
|
(world->getFrameCount () -
|
|
trigger.startFrame) / GameConstants::updateFps;
|
|
}
|
|
else
|
|
{
|
|
//result = (int)difftime(trigger.endTime,trigger.startTime);
|
|
result =
|
|
(trigger.endFrame -
|
|
trigger.startFrame) / GameConstants::updateFps;
|
|
}
|
|
|
|
//printf("Timer event id = %d seconmds elapsed = %d\n",eventId,result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
ScriptManager::setPlayerAsWinner (int factionIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
|
|
if (factionIndex >= 0 && factionIndex < GameConstants::maxPlayers)
|
|
{
|
|
playerModifiers[factionIndex].setAsWinner ();
|
|
}
|
|
}
|
|
|
|
void
|
|
ScriptManager::endGame ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
gameOver = true;
|
|
}
|
|
|
|
void
|
|
ScriptManager::startPerformanceTimer ()
|
|
{
|
|
|
|
if (world->getGame () == NULL)
|
|
{
|
|
throw
|
|
megaglest_runtime_error ("#1 world->getGame() == NULL", true);
|
|
}
|
|
world->getGame ()->startPerformanceTimer ();
|
|
|
|
}
|
|
|
|
void
|
|
ScriptManager::endPerformanceTimer ()
|
|
{
|
|
|
|
if (world->getGame () == NULL)
|
|
{
|
|
throw
|
|
megaglest_runtime_error ("#2 world->getGame() == NULL", true);
|
|
}
|
|
world->getGame ()->endPerformanceTimer ();
|
|
|
|
}
|
|
|
|
Vec2i
|
|
ScriptManager::getPerformanceTimerResults ()
|
|
{
|
|
|
|
if (world->getGame () == NULL)
|
|
{
|
|
throw
|
|
megaglest_runtime_error ("#3 world->getGame() == NULL", true);
|
|
}
|
|
return world->getGame ()->getPerformanceTimerResults ();
|
|
}
|
|
|
|
Vec2i
|
|
ScriptManager::getStartLocation (int factionIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->getStartLocation (factionIndex);
|
|
}
|
|
|
|
|
|
Vec2i
|
|
ScriptManager::getUnitPosition (int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
Vec2i
|
|
result = world->getUnitPosition (unitId);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s] unitId = %d, pos [%s]\n",
|
|
__FUNCTION__, unitId,
|
|
result.getString ().c_str ());
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
ScriptManager::setUnitPosition (int unitId, Vec2i pos)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->setUnitPosition (unitId, pos);
|
|
}
|
|
|
|
void
|
|
ScriptManager::addCellMarker (Vec2i pos, int factionIndex,
|
|
const string & note,
|
|
const string & textureFile)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->addCellMarker (pos, factionIndex, note, textureFile);
|
|
}
|
|
|
|
void
|
|
ScriptManager::removeCellMarker (Vec2i pos, int factionIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->removeCellMarker (pos, factionIndex);
|
|
}
|
|
|
|
void
|
|
ScriptManager::showMarker (Vec2i pos, int factionIndex,
|
|
const string & note,
|
|
const string & textureFile, int flashCount)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->showMarker (pos, factionIndex, note, textureFile, flashCount);
|
|
}
|
|
|
|
int
|
|
ScriptManager::getIsUnitAlive (int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->getIsUnitAlive (unitId);
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitFaction (int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->getUnitFactionIndex (unitId);
|
|
}
|
|
const string
|
|
ScriptManager::getUnitName (int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
string
|
|
result = "";
|
|
Unit *
|
|
unit = world->findUnitById (unitId);
|
|
if (unit)
|
|
{
|
|
result = world->findUnitById (unitId)->getType ()->getName (false);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const string
|
|
ScriptManager::getUnitDisplayName (int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->getUnitName (unitId);
|
|
}
|
|
|
|
int
|
|
ScriptManager::getResourceAmount (const string & resourceName,
|
|
int factionIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->getResourceAmount (resourceName, factionIndex);
|
|
}
|
|
|
|
const
|
|
string &
|
|
ScriptManager::getLastCreatedUnitName ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return lastCreatedUnitName;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getCellTriggeredEventId ()
|
|
{
|
|
|
|
return currentCellTriggeredEventId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getTimerTriggeredEventId ()
|
|
{
|
|
|
|
return currentTimerTriggeredEventId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getCellTriggeredEventAreaEntryUnitId ()
|
|
{
|
|
|
|
return currentCellTriggeredEventAreaEntryUnitId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getCellTriggeredEventAreaExitUnitId ()
|
|
{
|
|
|
|
return currentCellTriggeredEventAreaExitUnitId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getCellTriggeredEventUnitId ()
|
|
{
|
|
|
|
return currentCellTriggeredEventUnitId;
|
|
}
|
|
|
|
void
|
|
ScriptManager::setRandomGenInit (int seed)
|
|
{
|
|
|
|
random.init (seed);
|
|
}
|
|
|
|
int
|
|
ScriptManager::getRandomGen (int minVal, int maxVal)
|
|
{
|
|
|
|
return random.randRange (minVal, maxVal);
|
|
}
|
|
|
|
int
|
|
ScriptManager::getWorldFrameCount ()
|
|
{
|
|
|
|
return world->getFrameCount ();
|
|
}
|
|
|
|
bool
|
|
ScriptManager::getGameWon () const
|
|
{
|
|
|
|
return
|
|
gameWon;
|
|
}
|
|
|
|
bool
|
|
ScriptManager::getIsGameOver () const
|
|
{
|
|
|
|
return
|
|
gameOver;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastCreatedUnitId ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return lastCreatedUnitId;
|
|
}
|
|
|
|
const
|
|
string &
|
|
ScriptManager::getLastDeadUnitName ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return lastDeadUnitName;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastDeadUnitId ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return lastDeadUnitId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastDeadUnitCauseOfDeath ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return lastDeadUnitCauseOfDeath;
|
|
}
|
|
|
|
const
|
|
string &
|
|
ScriptManager::getLastDeadUnitKillerName ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return lastDeadUnitKillerName;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastDeadUnitKillerId ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return lastDeadUnitKillerId;
|
|
}
|
|
|
|
const
|
|
string &
|
|
ScriptManager::getLastAttackedUnitName ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return lastAttackedUnitName;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastAttackedUnitId ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return lastAttackedUnitId;
|
|
}
|
|
|
|
const
|
|
string &
|
|
ScriptManager::getLastAttackingUnitName ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return lastAttackingUnitName;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastAttackingUnitId ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return lastAttackingUnitId;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitCount (int factionIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->getUnitCount (factionIndex);
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitCountOfType (int factionIndex,
|
|
const string & typeName)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->getUnitCountOfType (factionIndex, typeName);
|
|
}
|
|
|
|
const string
|
|
ScriptManager::getSystemMacroValue (const string & key)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->getSystemMacroValue (key);
|
|
}
|
|
|
|
const string
|
|
ScriptManager::getPlayerName (int factionIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->getPlayerName (factionIndex);
|
|
}
|
|
|
|
void
|
|
ScriptManager::loadScenario (const string & name, bool keepFactions)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
|
|
world->setQueuedScenario (name, keepFactions);
|
|
}
|
|
|
|
vector < int >
|
|
ScriptManager::getUnitsForFaction (int factionIndex,
|
|
const string & commandTypeName,
|
|
int field)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
|
|
return world->getUnitsForFaction (factionIndex, commandTypeName, field);
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitCurrentField (int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
|
|
return world->getUnitCurrentField (unitId);
|
|
}
|
|
|
|
int
|
|
ScriptManager::isFreeCellsOrHasUnit (int field, int unitId, Vec2i pos)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
|
|
Unit *
|
|
unit = world->findUnitById (unitId);
|
|
if (unit == NULL)
|
|
{
|
|
throw
|
|
megaglest_runtime_error ("unit == NULL", true);
|
|
}
|
|
int
|
|
result =
|
|
world->getMap ()->isFreeCellsOrHasUnit (pos,
|
|
unit->getType ()->getSize (),
|
|
static_cast < Field > (field),
|
|
unit);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s] unitId = %d, [%s] pos [%s] field = %d result = %d\n",
|
|
__FUNCTION__, unitId,
|
|
unit->getType ()->getName (false).c_str (),
|
|
pos.getString ().c_str (), field, result);
|
|
|
|
return result;
|
|
}
|
|
|
|
int
|
|
ScriptManager::isFreeCells (int unitSize, int field, Vec2i pos)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
int
|
|
result =
|
|
world->getMap ()->isFreeCellsOrHasUnit (pos, unitSize,
|
|
static_cast < Field > (field),
|
|
NULL);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s] unitSize = %d, pos [%s] field = %d result = %d\n",
|
|
__FUNCTION__, unitSize,
|
|
pos.getString ().c_str (), field, result);
|
|
|
|
return result;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getHumanFactionId ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return this->world->getThisFactionIndex ();
|
|
}
|
|
|
|
void
|
|
ScriptManager::highlightUnit (int unitId, float radius, float thickness,
|
|
Vec4f color)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
|
|
world->highlightUnit (unitId, radius, thickness, color);
|
|
}
|
|
|
|
void
|
|
ScriptManager::unhighlightUnit (int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
|
|
world->unhighlightUnit (unitId);
|
|
}
|
|
|
|
void
|
|
ScriptManager::giveStopCommand (int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->giveStopCommand (unitId);
|
|
}
|
|
|
|
bool
|
|
ScriptManager::selectUnit (int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->selectUnit (unitId);
|
|
}
|
|
|
|
void
|
|
ScriptManager::unselectUnit (int unitId)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->unselectUnit (unitId);
|
|
}
|
|
|
|
void
|
|
ScriptManager::addUnitToGroupSelection (int unitId, int groupIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->addUnitToGroupSelection (unitId, groupIndex);
|
|
}
|
|
void
|
|
ScriptManager::recallGroupSelection (int groupIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->recallGroupSelection (groupIndex);
|
|
}
|
|
void
|
|
ScriptManager::removeUnitFromGroupSelection (int unitId, int groupIndex)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->removeUnitFromGroupSelection (unitId, groupIndex);
|
|
}
|
|
|
|
void
|
|
ScriptManager::setAttackWarningsEnabled (bool enabled)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
world->setAttackWarningsEnabled (enabled);
|
|
}
|
|
|
|
bool
|
|
ScriptManager::getAttackWarningsEnabled ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
return world->getAttackWarningsEnabled ();
|
|
}
|
|
|
|
void
|
|
ScriptManager::registerUnitTriggerEvent (int unitId)
|
|
{
|
|
UnitTriggerEventList[unitId] = utet_None;
|
|
}
|
|
|
|
void
|
|
ScriptManager::unregisterUnitTriggerEvent (int unitId)
|
|
{
|
|
UnitTriggerEventList.erase (unitId);
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastUnitTriggerEventUnitId ()
|
|
{
|
|
return lastUnitTriggerEventUnitId;
|
|
}
|
|
UnitTriggerEventType
|
|
ScriptManager::getLastUnitTriggerEventType ()
|
|
{
|
|
return lastUnitTriggerEventType;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitProperty (int unitId, UnitTriggerEventType type)
|
|
{
|
|
int
|
|
result = -1;
|
|
|
|
//printf("File: %s line: %d type: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__,type);
|
|
|
|
Unit *
|
|
unit = world->findUnitById (unitId);
|
|
if (unit != NULL)
|
|
{
|
|
switch (type)
|
|
{
|
|
case utet_None:
|
|
result = -2;
|
|
break;
|
|
case utet_HPChanged:
|
|
result = unit->getHp ();
|
|
break;
|
|
case utet_EPChanged:
|
|
result = unit->getEp ();
|
|
break;
|
|
case utet_LevelChanged:
|
|
result = -3;
|
|
if (unit->getLevel () != NULL)
|
|
{
|
|
result = unit->getLevel ()->getKills ();
|
|
}
|
|
break;
|
|
case utet_FieldChanged:
|
|
result = unit->getCurrField ();
|
|
break;
|
|
case utet_SkillChanged:
|
|
result = -4;
|
|
if (unit->getCurrSkill () != NULL)
|
|
{
|
|
result = unit->getCurrSkill ()->getClass ();
|
|
}
|
|
break;
|
|
default:
|
|
result = -1000;
|
|
break;
|
|
}
|
|
}
|
|
//printf("File: %s line: %d result: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__,result);
|
|
return result;
|
|
}
|
|
const string
|
|
ScriptManager::getUnitPropertyName (int unitId, UnitTriggerEventType type)
|
|
{
|
|
string
|
|
result = "";
|
|
Unit *
|
|
unit = world->findUnitById (unitId);
|
|
if (unit != NULL)
|
|
{
|
|
switch (type)
|
|
{
|
|
case utet_None:
|
|
result = "";
|
|
break;
|
|
case utet_HPChanged:
|
|
result = "";
|
|
break;
|
|
case utet_EPChanged:
|
|
result = "";
|
|
break;
|
|
case utet_LevelChanged:
|
|
result = "";
|
|
if (unit->getLevel () != NULL)
|
|
{
|
|
result = unit->getLevel ()->getName (false);
|
|
}
|
|
break;
|
|
case utet_FieldChanged:
|
|
result = "";
|
|
break;
|
|
case utet_SkillChanged:
|
|
result = "";
|
|
if (unit->getCurrSkill () != NULL)
|
|
{
|
|
result = unit->getCurrSkill ()->getName ();
|
|
}
|
|
break;
|
|
default:
|
|
result = "???";
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void
|
|
ScriptManager::onUnitTriggerEvent (const Unit * unit,
|
|
UnitTriggerEventType event)
|
|
{
|
|
//static bool inEvent = false;
|
|
//if(inEvent == true) {
|
|
// printf("\n\n!!!!!!!!!!!!!!! File: %s line: %d unit [%d - %s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__,unit->getId(),unit->getType()->getName().c_str());
|
|
// return;
|
|
//}
|
|
//inEvent = true;
|
|
//printf("File: %s line: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__);
|
|
if (UnitTriggerEventList.empty () == false)
|
|
{
|
|
//printf("File: %s line: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__);
|
|
std::map < int,
|
|
UnitTriggerEventType >::iterator
|
|
iterFind = UnitTriggerEventList.find (unit->getId ());
|
|
if (iterFind != UnitTriggerEventList.end ())
|
|
{
|
|
//printf("File: %s line: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__);
|
|
|
|
lastUnitTriggerEventUnitId = unit->getId ();
|
|
lastUnitTriggerEventType = event;
|
|
|
|
//printf("File: %s line: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__);
|
|
|
|
luaScript.beginCall ("unitTriggerEvent");
|
|
luaScript.endCall ();
|
|
|
|
//printf("File: %s line: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__);
|
|
}
|
|
}
|
|
//inEvent = false;
|
|
//printf("File: %s line: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__);
|
|
}
|
|
|
|
void
|
|
ScriptManager::registerDayNightEvent ()
|
|
{
|
|
registeredDayNightEvent = true;
|
|
}
|
|
|
|
void
|
|
ScriptManager::unregisterDayNightEvent ()
|
|
{
|
|
registeredDayNightEvent = false;
|
|
}
|
|
|
|
void
|
|
ScriptManager::onDayNightTriggerEvent ()
|
|
{
|
|
if (registeredDayNightEvent == true)
|
|
{
|
|
bool
|
|
isDay = (this->getIsDayTime () == 1);
|
|
if ((lastDayNightTriggerStatus != 1 && isDay == true) ||
|
|
(lastDayNightTriggerStatus != 2 && isDay == false))
|
|
{
|
|
if (isDay == true)
|
|
{
|
|
lastDayNightTriggerStatus = 1;
|
|
}
|
|
else
|
|
{
|
|
lastDayNightTriggerStatus = 2;
|
|
}
|
|
|
|
printf ("Triggering daynight event isDay: %d [%f]\n", isDay,
|
|
getTimeOfDay ());
|
|
|
|
luaScript.beginCall ("dayNightTriggerEvent");
|
|
luaScript.endCall ();
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
ScriptManager::getIsDayTime ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
|
|
const TimeFlow *
|
|
tf = world->getTimeFlow ();
|
|
if (tf == NULL)
|
|
{
|
|
throw
|
|
megaglest_runtime_error ("#1 tf == NULL", true);
|
|
}
|
|
return tf->isDay ();
|
|
}
|
|
int
|
|
ScriptManager::getIsNightTime ()
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
|
|
const TimeFlow *
|
|
tf = world->getTimeFlow ();
|
|
if (tf == NULL)
|
|
{
|
|
throw
|
|
megaglest_runtime_error ("#2 tf == NULL", true);
|
|
}
|
|
return tf->isNight ();
|
|
}
|
|
float
|
|
ScriptManager::getTimeOfDay ()
|
|
{
|
|
//printf("File: %s line: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
|
|
const TimeFlow *
|
|
tf = world->getTimeFlow ();
|
|
if (tf == NULL)
|
|
{
|
|
throw
|
|
megaglest_runtime_error ("#3 tf == NULL", true);
|
|
}
|
|
//printf("File: %s line: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__);
|
|
return tf->getTime ();
|
|
}
|
|
|
|
void
|
|
ScriptManager::disableSpeedChange ()
|
|
{
|
|
if (world->getGame () == NULL)
|
|
{
|
|
throw
|
|
megaglest_runtime_error ("#4 world->getGame() == NULL");
|
|
}
|
|
world->getGame ()->setDisableSpeedChange (true);
|
|
}
|
|
void
|
|
ScriptManager::enableSpeedChange ()
|
|
{
|
|
if (world->getGame () == NULL)
|
|
{
|
|
throw
|
|
megaglest_runtime_error ("#5 world->getGame() == NULL");
|
|
}
|
|
world->getGame ()->setDisableSpeedChange (false);
|
|
}
|
|
|
|
bool
|
|
ScriptManager::getSpeedChangeEnabled ()
|
|
{
|
|
if (world->getGame () == NULL)
|
|
{
|
|
throw
|
|
megaglest_runtime_error ("#6 world->getGame() == NULL");
|
|
}
|
|
return world->getGame ()->getDisableSpeedChange ();
|
|
}
|
|
|
|
void
|
|
ScriptManager::addMessageToQueue (ScriptManagerMessage msg)
|
|
{
|
|
messageQueue.push_back (msg);
|
|
}
|
|
|
|
void
|
|
ScriptManager::storeSaveGameData (string name, string value)
|
|
{
|
|
|
|
if (LuaScript::getDebugModeEnabled () == true)
|
|
printf ("storeSaveGameData name [%s] value [%s]\n", name.c_str (),
|
|
value.c_str ());
|
|
|
|
luaSavedGameData[name] = value;
|
|
}
|
|
|
|
string
|
|
ScriptManager::loadSaveGameData (string name)
|
|
{
|
|
string
|
|
value = luaSavedGameData[name];
|
|
|
|
if (LuaScript::getDebugModeEnabled () == true)
|
|
printf ("loadSaveGameData result name [%s] value [%s]\n",
|
|
name.c_str (), value.c_str ());
|
|
|
|
return value;
|
|
}
|
|
|
|
ControlType
|
|
ScriptManager::getFactionPlayerType (int factionIndex)
|
|
{
|
|
Faction *
|
|
faction = world->getFaction (factionIndex);
|
|
if (faction != NULL)
|
|
{
|
|
return faction->getControlType ();
|
|
}
|
|
return ctClosed;
|
|
}
|
|
// ========================== lua callbacks ===============================================
|
|
|
|
int
|
|
ScriptManager::showMessage (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
thisScriptManager->showMessage (luaArguments.getString (-2),
|
|
luaArguments.getString (-1));
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::networkShowMessageForFaction (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->networkShowMessageForFaction (luaArguments.
|
|
getString (-3),
|
|
luaArguments.
|
|
getString (-2),
|
|
luaArguments.
|
|
getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::networkShowMessageForTeam (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->networkShowMessageForTeam (luaArguments.
|
|
getString (-3),
|
|
luaArguments.
|
|
getString (-2),
|
|
luaArguments.
|
|
getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::networkSetCameraPositionForFaction (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->networkSetCameraPositionForFaction (luaArguments.
|
|
getInt (-2),
|
|
luaArguments.
|
|
getVec2i (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::networkSetCameraPositionForTeam (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->networkSetCameraPositionForTeam (luaArguments.
|
|
getInt (-2),
|
|
luaArguments.
|
|
getVec2i (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
|
|
int
|
|
ScriptManager::setDisplayText (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->setDisplayText (luaArguments.getString (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::addConsoleText (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->addConsoleText (luaArguments.getString (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::clearDisplayText (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->clearDisplayText ();
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::setCameraPosition (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->
|
|
setCameraPosition (Vec2i (luaArguments.getVec2i (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::shakeCamera (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->shakeCamera (luaArguments.getInt (-2),
|
|
luaArguments.getInt (-1), false, 0);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::shakeCameraOnUnit (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->shakeCamera (luaArguments.getInt (-3),
|
|
luaArguments.getInt (-2), true,
|
|
luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::createUnit (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%s] factionIndex = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getString (-3).c_str (),
|
|
luaArguments.getInt (-2));
|
|
|
|
try
|
|
{
|
|
thisScriptManager->createUnit (luaArguments.getString (-3),
|
|
luaArguments.getInt (-2),
|
|
luaArguments.getVec2i (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
void
|
|
ScriptManager::error (LuaHandle * luaHandle,
|
|
const megaglest_runtime_error * mgErr,
|
|
const char *file, const char *function, int line)
|
|
{
|
|
char
|
|
szErrBuf[8096] = "";
|
|
char
|
|
szErrBuf2[8096] = "";
|
|
|
|
int
|
|
luaLine = -1;
|
|
const char *
|
|
luaSource = "";
|
|
|
|
if (luaHandle != NULL)
|
|
{
|
|
lua_Debug
|
|
ar;
|
|
lua_getstack (luaHandle, 1, &ar);
|
|
lua_getinfo (luaHandle, "nSl", &ar);
|
|
|
|
luaLine = ar.currentline;
|
|
luaSource = ar.source;
|
|
|
|
}
|
|
snprintf (szErrBuf, 8096, "in %s::%s %d ",
|
|
extractFileFromDirectoryPath (file).c_str (), function, line);
|
|
snprintf (szErrBuf2, 8096, "Lua: tag=<%s> line=%d ", luaSource,
|
|
luaLine - 1);
|
|
string
|
|
sErrBuf = string ("Error! The game may no longer be stable!\n\n")
|
|
+ string (szErrBuf) + "\n" + string (szErrBuf2) + "\n\n"
|
|
+ string (mgErr->what ());
|
|
|
|
SystemFlags::OutputDebug (SystemFlags::debugError, sErrBuf.c_str ());
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugSystem).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugSystem, sErrBuf.c_str ());
|
|
|
|
thisScriptManager->
|
|
addMessageToQueue (ScriptManagerMessage
|
|
(sErrBuf.c_str (),
|
|
"error " +
|
|
intToStr (thisScriptManager->errorCount), -1, -1,
|
|
true));
|
|
thisScriptManager->errorCount++;
|
|
thisScriptManager->onMessageBoxOk (false);
|
|
}
|
|
|
|
int
|
|
ScriptManager::createUnitNoSpacing (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%s] factionIndex = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getString (-3).c_str (),
|
|
luaArguments.getInt (-2));
|
|
|
|
try
|
|
{
|
|
thisScriptManager->createUnitNoSpacing (luaArguments.getString (-3),
|
|
luaArguments.getInt (-2),
|
|
luaArguments.getVec2i (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::destroyUnit (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getInt (-1));
|
|
|
|
try
|
|
{
|
|
thisScriptManager->destroyUnit (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::setLockedUnitForFaction (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%s] factionIndex = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getString (-3).c_str (),
|
|
luaArguments.getInt (-2));
|
|
|
|
try
|
|
{
|
|
thisScriptManager->setLockedUnitForFaction (luaArguments.
|
|
getString (-3),
|
|
luaArguments.getInt (-2),
|
|
(luaArguments.
|
|
getInt (-1) ==
|
|
0 ? false : true));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::giveKills (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getInt (-1));
|
|
|
|
try
|
|
{
|
|
thisScriptManager->giveKills (luaArguments.getInt (-2),
|
|
luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::morphToUnit (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%d] morphName [%s] forceUpgrade = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getInt (-3),
|
|
luaArguments.getString (-2).c_str (),
|
|
luaArguments.getInt (-1));
|
|
|
|
try
|
|
{
|
|
thisScriptManager->morphToUnit (luaArguments.getInt (-3),
|
|
luaArguments.getString (-2),
|
|
luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::moveToUnit (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] unit [%d] dest unit [%d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getInt (-2),
|
|
luaArguments.getInt (-1));
|
|
|
|
try
|
|
{
|
|
thisScriptManager->moveToUnit (luaArguments.getInt (-2),
|
|
luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::playStaticSound (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] sound [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getString (-1).c_str ());
|
|
|
|
try
|
|
{
|
|
thisScriptManager->playStaticSound (luaArguments.getString (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::playStreamingSound (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] sound [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getString (-1).c_str ());
|
|
|
|
try
|
|
{
|
|
thisScriptManager->playStreamingSound (luaArguments.getString (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::stopStreamingSound (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] sound [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getString (-1).c_str ());
|
|
|
|
try
|
|
{
|
|
thisScriptManager->stopStreamingSound (luaArguments.getString (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::stopAllSound (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->stopAllSound ();
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::playStaticVideo (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] sound [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getString (-1).c_str ());
|
|
|
|
try
|
|
{
|
|
thisScriptManager->playStaticVideo (luaArguments.getString (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::playStreamingVideo (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] sound [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getString (-1).c_str ());
|
|
|
|
try
|
|
{
|
|
thisScriptManager->playStreamingVideo (luaArguments.getString (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::stopStreamingVideo (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] sound [%s]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getString (-1).c_str ());
|
|
|
|
try
|
|
{
|
|
thisScriptManager->stopStreamingVideo (luaArguments.getString (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::stopAllVideo (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
try
|
|
{
|
|
thisScriptManager->stopAllVideo ();
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::togglePauseGame (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d] value = %d\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__,
|
|
luaArguments.getInt (-1));
|
|
|
|
try
|
|
{
|
|
thisScriptManager->togglePauseGame (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
int
|
|
ScriptManager::giveResource (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->giveResource (luaArguments.getString (-3),
|
|
luaArguments.getInt (-2),
|
|
luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::givePositionCommand (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->givePositionCommand (luaArguments.getInt (-3),
|
|
luaArguments.getString (-2),
|
|
luaArguments.getVec2i (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::giveAttackCommand (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->giveAttackCommand (luaArguments.getInt (-2),
|
|
luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::giveProductionCommand (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->giveProductionCommand (luaArguments.getInt (-2),
|
|
luaArguments.
|
|
getString (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::giveUpgradeCommand (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->giveUpgradeCommand (luaArguments.getInt (-2),
|
|
luaArguments.getString (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::giveAttackStoppedCommand (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->giveAttackStoppedCommand (luaArguments.getInt (-3),
|
|
luaArguments.
|
|
getString (-2),
|
|
luaArguments.
|
|
getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::disableAi (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->disableAi (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::enableAi (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->enableAi (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getAiEnabled (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
bool
|
|
result = thisScriptManager->getAiEnabled (luaArguments.getInt (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::disableConsume (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->disableConsume (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::enableConsume (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->enableConsume (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getConsumeEnabled (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
bool
|
|
result =
|
|
thisScriptManager->getConsumeEnabled (luaArguments.getInt (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::registerCellTriggerEventForUnitToUnit (LuaHandle *
|
|
luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->
|
|
registerCellTriggerEventForUnitToUnit (luaArguments.getInt (-2),
|
|
luaArguments.getInt (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::registerCellTriggerEventForUnitToLocation (LuaHandle *
|
|
luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->
|
|
registerCellTriggerEventForUnitToLocation (luaArguments.getInt (-2),
|
|
luaArguments.
|
|
getVec2i (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::registerCellAreaTriggerEventForUnitToLocation (LuaHandle *
|
|
luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->
|
|
registerCellAreaTriggerEventForUnitToLocation (luaArguments.
|
|
getInt (-2),
|
|
luaArguments.
|
|
getVec4i (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::registerCellTriggerEventForFactionToUnit (LuaHandle *
|
|
luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->
|
|
registerCellTriggerEventForFactionToUnit (luaArguments.getInt (-2),
|
|
luaArguments.getInt (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::registerCellTriggerEventForFactionToLocation (LuaHandle *
|
|
luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->
|
|
registerCellTriggerEventForFactionToLocation (luaArguments.
|
|
getInt (-2),
|
|
luaArguments.
|
|
getVec2i (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::
|
|
registerCellAreaTriggerEventForFactionToLocation (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->
|
|
registerCellAreaTriggerEventForFactionToLocation (luaArguments.
|
|
getInt (-2),
|
|
luaArguments.
|
|
getVec4i (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::registerCellAreaTriggerEvent (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->registerCellAreaTriggerEvent (luaArguments.
|
|
getVec4i (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getCellTriggerEventCount (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->getCellTriggerEventCount (luaArguments.
|
|
getInt (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::unregisterCellTriggerEvent (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->unregisterCellTriggerEvent (luaArguments.
|
|
getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::startTimerEvent (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result = thisScriptManager->startTimerEvent ();
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::startEfficientTimerEvent (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->startEfficientTimerEvent (luaArguments.
|
|
getInt (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::stopTimerEvent (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->stopTimerEvent (luaArguments.getInt (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::resetTimerEvent (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->resetTimerEvent (luaArguments.getInt (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getTimerEventSecondsElapsed (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->getTimerEventSecondsElapsed (luaArguments.
|
|
getInt (-1));
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::setPlayerAsWinner (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->setPlayerAsWinner (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::endGame (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->endGame ();
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::startPerformanceTimer (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->startPerformanceTimer ();
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::endPerformanceTimer (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->endPerformanceTimer ();
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getPerformanceTimerResults (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
Vec2i
|
|
results = thisScriptManager->getPerformanceTimerResults ();
|
|
luaArguments.returnVec2i (results);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getStartLocation (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
Vec2i
|
|
pos =
|
|
thisScriptManager->getStartLocation (luaArguments.getInt (-1));
|
|
luaArguments.returnVec2i (pos);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitPosition (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
Vec2i
|
|
pos = thisScriptManager->getUnitPosition (luaArguments.getInt (-1));
|
|
luaArguments.returnVec2i (pos);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::setUnitPosition (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->setUnitPosition (luaArguments.getInt (-2),
|
|
luaArguments.getVec2i (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::addCellMarker (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
//printf("LUA addCellMarker --> START\n");
|
|
|
|
int
|
|
factionIndex = luaArguments.getInt (-4);
|
|
|
|
//printf("LUA addCellMarker --> START 1\n");
|
|
|
|
Vec2i
|
|
pos = luaArguments.getVec2i (-1);
|
|
|
|
//printf("LUA addCellMarker --> START 2\n");
|
|
|
|
string
|
|
note = luaArguments.getString (-3);
|
|
|
|
//printf("LUA addCellMarker --> START 3\n");
|
|
|
|
string
|
|
texture = luaArguments.getString (-2);
|
|
|
|
//printf("LUA addCellMarker --> faction [%d] pos [%s] note [%s] texture [%s]\n",factionIndex,pos.getString().c_str(),note.c_str(),texture.c_str());
|
|
|
|
thisScriptManager->addCellMarker (pos, factionIndex, note, texture);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::removeCellMarker (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
int
|
|
factionIndex = luaArguments.getInt (-2);
|
|
Vec2i
|
|
pos = luaArguments.getVec2i (-1);
|
|
|
|
thisScriptManager->removeCellMarker (pos, factionIndex);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::showMarker (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
int
|
|
flashCount = luaArguments.getInt (-5);
|
|
//printf("LUA addCellMarker --> START\n");
|
|
|
|
int
|
|
factionIndex = luaArguments.getInt (-4);
|
|
|
|
//printf("LUA addCellMarker --> START 1\n");
|
|
|
|
Vec2i
|
|
pos = luaArguments.getVec2i (-1);
|
|
|
|
//printf("LUA addCellMarker --> START 2\n");
|
|
|
|
string
|
|
note = luaArguments.getString (-3);
|
|
|
|
//printf("LUA addCellMarker --> START 3\n");
|
|
|
|
string
|
|
texture = luaArguments.getString (-2);
|
|
|
|
//printf("LUA addCellMarker --> faction [%d] pos [%s] note [%s] texture [%s]\n",factionIndex,pos.getString().c_str(),note.c_str(),texture.c_str());
|
|
|
|
thisScriptManager->showMarker (pos, factionIndex, note, texture,
|
|
flashCount);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitFaction (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
factionIndex =
|
|
thisScriptManager->getUnitFaction (luaArguments.getInt (-1));
|
|
luaArguments.returnInt (factionIndex);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitName (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
const string
|
|
unitname =
|
|
thisScriptManager->getUnitName (luaArguments.getInt (-1));
|
|
luaArguments.returnString (unitname);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitDisplayName (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
const string
|
|
unitname =
|
|
thisScriptManager->getUnitDisplayName (luaArguments.getInt (-1));
|
|
luaArguments.returnString (unitname);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
|
|
int
|
|
ScriptManager::getResourceAmount (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getResourceAmount (luaArguments.
|
|
getString (-2),
|
|
luaArguments.getInt (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastCreatedUnitName (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnString (thisScriptManager->
|
|
getLastCreatedUnitName ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastCreatedUnitId (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->getLastCreatedUnitId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getCellTriggeredEventId (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getCellTriggeredEventId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getTimerTriggeredEventId (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getTimerTriggeredEventId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getCellTriggeredEventAreaEntryUnitId (LuaHandle *
|
|
luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getCellTriggeredEventAreaEntryUnitId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getCellTriggeredEventAreaExitUnitId (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getCellTriggeredEventAreaExitUnitId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getCellTriggeredEventUnitId (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getCellTriggeredEventUnitId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::setRandomGenInit (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->setRandomGenInit (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getRandomGen (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getRandomGen (luaArguments.getInt (-2),
|
|
luaArguments.getInt (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getWorldFrameCount (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->getWorldFrameCount ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastDeadUnitName (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnString (thisScriptManager->getLastDeadUnitName ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastDeadUnitId (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->getLastDeadUnitId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastDeadUnitCauseOfDeath (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getLastDeadUnitCauseOfDeath ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastDeadUnitKillerName (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnString (thisScriptManager->
|
|
getLastDeadUnitKillerName ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastDeadUnitKillerId (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getLastDeadUnitKillerId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastAttackedUnitName (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnString (thisScriptManager->
|
|
getLastAttackedUnitName ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastAttackedUnitId (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->getLastAttackedUnitId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastAttackingUnitName (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnString (thisScriptManager->
|
|
getLastAttackingUnitName ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getLastAttackingUnitId (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->getLastAttackingUnitId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getSystemMacroValue (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnString (thisScriptManager->
|
|
getSystemMacroValue (luaArguments.
|
|
getString (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::scenarioDir (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnString (thisScriptManager->
|
|
getSystemMacroValue ("$SCENARIO_PATH"));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getPlayerName (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnString (thisScriptManager->
|
|
getPlayerName (luaArguments.getInt (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitCount (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getUnitCount (luaArguments.getInt (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitCountOfType (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getUnitCountOfType (luaArguments.getInt (-2),
|
|
luaArguments.
|
|
getString (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::DisplayFormattedText (LuaHandle * luaHandle)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
try
|
|
{
|
|
//const char *ret;
|
|
//lua_lock(luaHandle);
|
|
//luaC_checkGC(luaHandle);
|
|
|
|
int
|
|
args = lua_gettop (luaHandle);
|
|
if (lua_checkstack (luaHandle, args + 1))
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
string
|
|
fmt = luaArguments.getString (-args);
|
|
//va_list argList;
|
|
//va_start(argList, fmt.c_str() );
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"DisplayFormattedText args = %d!\n",
|
|
args);
|
|
|
|
const int
|
|
max_args_allowed = 8;
|
|
if (args == 1)
|
|
{
|
|
thisScriptManager->DisplayFormattedText (fmt.c_str ());
|
|
}
|
|
else if (args == 2)
|
|
{
|
|
thisScriptManager->DisplayFormattedText (fmt.c_str (),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+
|
|
1));
|
|
}
|
|
else if (args == 3)
|
|
{
|
|
thisScriptManager->DisplayFormattedText (fmt.c_str (),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 1),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+
|
|
2));
|
|
}
|
|
else if (args == 4)
|
|
{
|
|
thisScriptManager->DisplayFormattedText (fmt.c_str (),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 1),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 2),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+
|
|
3));
|
|
}
|
|
else if (args == 5)
|
|
{
|
|
thisScriptManager->DisplayFormattedText (fmt.c_str (),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 1),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 2),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 3),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+
|
|
4));
|
|
}
|
|
else if (args == 6)
|
|
{
|
|
thisScriptManager->DisplayFormattedText (fmt.c_str (),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 1),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 2),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 3),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 4),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+
|
|
5));
|
|
}
|
|
else if (args == 7)
|
|
{
|
|
thisScriptManager->DisplayFormattedText (fmt.c_str (),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 1),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 2),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 3),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 4),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 5),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+
|
|
6));
|
|
}
|
|
else if (args == max_args_allowed)
|
|
{
|
|
thisScriptManager->DisplayFormattedText (fmt.c_str (),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 1),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 2),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 3),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 4),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 5),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+ 6),
|
|
luaArguments.
|
|
getGenericData (-args
|
|
+
|
|
7));
|
|
}
|
|
else
|
|
{
|
|
char
|
|
szBuf[8096] = "";
|
|
snprintf (szBuf, 8096,
|
|
"Invalid parameter count in method [%s] args = %d [argument count must be between 1 and %d]",
|
|
__FUNCTION__, args, max_args_allowed);
|
|
throw
|
|
megaglest_runtime_error (szBuf);
|
|
}
|
|
|
|
//va_end(argList);
|
|
}
|
|
//lua_unlock(luaHandle);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return 1;
|
|
|
|
/*
|
|
int args=lua_gettop(luaHandle);
|
|
if(lua_checkstack(luaHandle, args+1))
|
|
{
|
|
va_list argList;
|
|
int i;
|
|
//lua_getfield(luaHandle, LUA_GLOBALSINDEX, "print");
|
|
for(i = 1;i <= args; i++) {
|
|
lua_pushvalue(luaHandle, i);
|
|
}
|
|
lua_call(luaHandle, args, 0);
|
|
}
|
|
else
|
|
{
|
|
return luaL_error(luaHandle, "cannot grow stack");
|
|
}
|
|
*/
|
|
|
|
/*
|
|
luax_getfunction(L, mod, fn);
|
|
for (int i = 0; i < n; i++) {
|
|
lua_pushvalue(L, idxs[i]); // The arguments.
|
|
}
|
|
lua_call(L, n, 1); // Call the function, n args, one return value.
|
|
lua_replace(L, idxs[0]); // Replace the initial argument with the new object.
|
|
return 0;
|
|
*/
|
|
}
|
|
|
|
int
|
|
ScriptManager::addConsoleLangText (LuaHandle * luaHandle)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
try
|
|
{
|
|
//const char *ret;
|
|
//lua_lock(luaHandle);
|
|
//luaC_checkGC(luaHandle);
|
|
|
|
int
|
|
args = lua_gettop (luaHandle);
|
|
if (lua_checkstack (luaHandle, args + 1))
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
string
|
|
fmt = luaArguments.getString (-args);
|
|
//va_list argList;
|
|
//va_start(argList, fmt.c_str() );
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"DisplayFormattedText args = %d!\n",
|
|
args);
|
|
|
|
const int
|
|
max_args_allowed = 8;
|
|
if (args == 1)
|
|
{
|
|
thisScriptManager->addConsoleLangText (Lang::getInstance ().
|
|
getScenarioString
|
|
(fmt).c_str ());
|
|
}
|
|
else if (args == 2)
|
|
{
|
|
thisScriptManager->addConsoleLangText (Lang::getInstance ().
|
|
getScenarioString
|
|
(fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
1));
|
|
}
|
|
else if (args == 3)
|
|
{
|
|
thisScriptManager->addConsoleLangText (Lang::getInstance ().
|
|
getScenarioString
|
|
(fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
1),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
2));
|
|
}
|
|
else if (args == 4)
|
|
{
|
|
thisScriptManager->addConsoleLangText (Lang::getInstance ().
|
|
getScenarioString
|
|
(fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
1),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
2),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
3));
|
|
}
|
|
else if (args == 5)
|
|
{
|
|
thisScriptManager->addConsoleLangText (Lang::getInstance ().
|
|
getScenarioString
|
|
(fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
1),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
2),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
3),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
4));
|
|
}
|
|
else if (args == 6)
|
|
{
|
|
thisScriptManager->addConsoleLangText (Lang::getInstance ().
|
|
getScenarioString
|
|
(fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
1),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
2),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
3),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
4),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
5));
|
|
}
|
|
else if (args == 7)
|
|
{
|
|
thisScriptManager->addConsoleLangText (Lang::getInstance ().
|
|
getScenarioString
|
|
(fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
1),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
2),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
3),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
4),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
5),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
6));
|
|
}
|
|
else if (args == max_args_allowed)
|
|
{
|
|
thisScriptManager->addConsoleLangText (Lang::getInstance ().
|
|
getScenarioString
|
|
(fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
1),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
2),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
3),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
4),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
5),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
6),
|
|
luaArguments.
|
|
getGenericData (-args +
|
|
7));
|
|
}
|
|
else
|
|
{
|
|
char
|
|
szBuf[8096] = "";
|
|
snprintf (szBuf, 8096,
|
|
"Invalid parameter count in method [%s] args = %d [argument count must be between 1 and %d]",
|
|
__FUNCTION__, args, max_args_allowed);
|
|
throw
|
|
megaglest_runtime_error (szBuf);
|
|
}
|
|
|
|
//va_end(argList);
|
|
}
|
|
//lua_unlock(luaHandle);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
ScriptManager::DisplayFormattedLangText (LuaHandle * luaHandle)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
|
|
try
|
|
{
|
|
//const char *ret;
|
|
//lua_lock(luaHandle);
|
|
//luaC_checkGC(luaHandle);
|
|
|
|
int
|
|
args = lua_gettop (luaHandle);
|
|
if (lua_checkstack (luaHandle, args + 1))
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
string
|
|
fmt = luaArguments.getString (-args);
|
|
//va_list argList;
|
|
//va_start(argList, fmt.c_str() );
|
|
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).
|
|
enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"DisplayFormattedText args = %d!\n",
|
|
args);
|
|
|
|
const int
|
|
max_args_allowed = 8;
|
|
if (args == 1)
|
|
{
|
|
thisScriptManager->
|
|
DisplayFormattedLangText (Lang::getInstance ().
|
|
getScenarioString (fmt).c_str ());
|
|
}
|
|
else if (args == 2)
|
|
{
|
|
thisScriptManager->
|
|
DisplayFormattedLangText (Lang::getInstance ().
|
|
getScenarioString (fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args + 1));
|
|
}
|
|
else if (args == 3)
|
|
{
|
|
thisScriptManager->
|
|
DisplayFormattedLangText (Lang::getInstance ().
|
|
getScenarioString (fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args + 1),
|
|
luaArguments.
|
|
getGenericData (-args + 2));
|
|
}
|
|
else if (args == 4)
|
|
{
|
|
thisScriptManager->
|
|
DisplayFormattedLangText (Lang::getInstance ().
|
|
getScenarioString (fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args + 1),
|
|
luaArguments.
|
|
getGenericData (-args + 2),
|
|
luaArguments.
|
|
getGenericData (-args + 3));
|
|
}
|
|
else if (args == 5)
|
|
{
|
|
thisScriptManager->
|
|
DisplayFormattedLangText (Lang::getInstance ().
|
|
getScenarioString (fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args + 1),
|
|
luaArguments.
|
|
getGenericData (-args + 2),
|
|
luaArguments.
|
|
getGenericData (-args + 3),
|
|
luaArguments.
|
|
getGenericData (-args + 4));
|
|
}
|
|
else if (args == 6)
|
|
{
|
|
thisScriptManager->
|
|
DisplayFormattedLangText (Lang::getInstance ().
|
|
getScenarioString (fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args + 1),
|
|
luaArguments.
|
|
getGenericData (-args + 2),
|
|
luaArguments.
|
|
getGenericData (-args + 3),
|
|
luaArguments.
|
|
getGenericData (-args + 4),
|
|
luaArguments.
|
|
getGenericData (-args + 5));
|
|
}
|
|
else if (args == 7)
|
|
{
|
|
thisScriptManager->
|
|
DisplayFormattedLangText (Lang::getInstance ().
|
|
getScenarioString (fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args + 1),
|
|
luaArguments.
|
|
getGenericData (-args + 2),
|
|
luaArguments.
|
|
getGenericData (-args + 3),
|
|
luaArguments.
|
|
getGenericData (-args + 4),
|
|
luaArguments.
|
|
getGenericData (-args + 5),
|
|
luaArguments.
|
|
getGenericData (-args + 6));
|
|
}
|
|
else if (args == max_args_allowed)
|
|
{
|
|
thisScriptManager->
|
|
DisplayFormattedLangText (Lang::getInstance ().
|
|
getScenarioString (fmt).c_str (),
|
|
luaArguments.
|
|
getGenericData (-args + 1),
|
|
luaArguments.
|
|
getGenericData (-args + 2),
|
|
luaArguments.
|
|
getGenericData (-args + 3),
|
|
luaArguments.
|
|
getGenericData (-args + 4),
|
|
luaArguments.
|
|
getGenericData (-args + 5),
|
|
luaArguments.
|
|
getGenericData (-args + 6),
|
|
luaArguments.
|
|
getGenericData (-args + 7));
|
|
}
|
|
else
|
|
{
|
|
char
|
|
szBuf[8096] = "";
|
|
snprintf (szBuf, 8096,
|
|
"Invalid parameter count in method [%s] args = %d [argument count must be between 1 and %d]",
|
|
__FUNCTION__, args, max_args_allowed);
|
|
throw
|
|
megaglest_runtime_error (szBuf);
|
|
}
|
|
|
|
//va_end(argList);
|
|
}
|
|
//lua_unlock(luaHandle);
|
|
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
ScriptManager::getGameWon (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->getGameWon ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getIsGameOver (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->getIsGameOver ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::loadScenario (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->loadScenario (luaArguments.getString (-2),
|
|
luaArguments.getInt (-1) != 0);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitsForFaction (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
vector < int >
|
|
units =
|
|
thisScriptManager->getUnitsForFaction (luaArguments.getInt (-3),
|
|
luaArguments.getString (-2),
|
|
luaArguments.getInt (-1));
|
|
luaArguments.returnVectorInt (units);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitCurrentField (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getUnitCurrentField (luaArguments.
|
|
getInt (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getIsUnitAlive (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getIsUnitAlive (luaArguments.getInt (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::isFreeCellsOrHasUnit (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
int
|
|
result =
|
|
thisScriptManager->isFreeCellsOrHasUnit (luaArguments.getInt (-3),
|
|
luaArguments.getInt (-2),
|
|
luaArguments.
|
|
getVec2i (-1));
|
|
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::isFreeCells (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
|
|
try
|
|
{
|
|
int
|
|
result = thisScriptManager->isFreeCells (luaArguments.getInt (-3),
|
|
luaArguments.getInt (-2),
|
|
luaArguments.
|
|
getVec2i (-1));
|
|
|
|
luaArguments.returnInt (result);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getHumanFactionId (LuaHandle * luaHandle)
|
|
{
|
|
if (SystemFlags::getSystemSettingType (SystemFlags::debugLUA).enabled)
|
|
SystemFlags::OutputDebug (SystemFlags::debugLUA,
|
|
"In [%s::%s Line: %d]\n",
|
|
extractFileFromDirectoryPath (__FILE__).
|
|
c_str (), __FUNCTION__, __LINE__);
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->getHumanFactionId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::highlightUnit (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->highlightUnit (luaArguments.getInt (-4),
|
|
luaArguments.getFloat (-3),
|
|
luaArguments.getFloat (-2),
|
|
luaArguments.getVec4f (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::unhighlightUnit (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->unhighlightUnit (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::giveStopCommand (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->giveStopCommand (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::selectUnit (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
selectUnit (luaArguments.getInt (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::unselectUnit (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->unselectUnit (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::addUnitToGroupSelection (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->addUnitToGroupSelection (luaArguments.getInt (-2),
|
|
luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::recallGroupSelection (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->recallGroupSelection (luaArguments.getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::removeUnitFromGroupSelection (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->removeUnitFromGroupSelection (luaArguments.
|
|
getInt (-2),
|
|
luaArguments.
|
|
getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::setAttackWarningsEnabled (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->
|
|
setAttackWarningsEnabled ((luaArguments.getInt (-1) ==
|
|
0 ? false : true));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
int
|
|
ScriptManager::getAttackWarningsEnabled (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getAttackWarningsEnabled ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getIsDayTime (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->getIsDayTime ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
int
|
|
ScriptManager::getIsNightTime (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->getIsNightTime ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
int
|
|
ScriptManager::getTimeOfDay (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnFloat (thisScriptManager->getTimeOfDay ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::registerDayNightEvent (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->registerDayNightEvent ();
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
int
|
|
ScriptManager::unregisterDayNightEvent (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->unregisterDayNightEvent ();
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::registerUnitTriggerEvent (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->registerUnitTriggerEvent (luaArguments.
|
|
getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
int
|
|
ScriptManager::unregisterUnitTriggerEvent (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->unregisterUnitTriggerEvent (luaArguments.
|
|
getInt (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
int
|
|
ScriptManager::getLastUnitTriggerEventUnitId (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getLastUnitTriggerEventUnitId ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
int
|
|
ScriptManager::getLastUnitTriggerEventType (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (static_cast <
|
|
int >(thisScriptManager->
|
|
getLastUnitTriggerEventType ()));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getUnitProperty (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
int
|
|
value =
|
|
thisScriptManager->getUnitProperty (luaArguments.getInt (-2),
|
|
static_cast <
|
|
UnitTriggerEventType >
|
|
(luaArguments.getInt (-1)));
|
|
luaArguments.returnInt (value);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
int
|
|
ScriptManager::getUnitPropertyName (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
const string
|
|
unitname =
|
|
thisScriptManager->getUnitPropertyName (luaArguments.getInt (-2),
|
|
static_cast <
|
|
UnitTriggerEventType >
|
|
(luaArguments.getInt (-1)));
|
|
luaArguments.returnString (unitname);
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::disableSpeedChange (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->disableSpeedChange ();
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
int
|
|
ScriptManager::enableSpeedChange (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->enableSpeedChange ();
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
int
|
|
ScriptManager::getSpeedChangeEnabled (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->getSpeedChangeEnabled ());
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::storeSaveGameData (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
thisScriptManager->storeSaveGameData (luaArguments.getString (-2),
|
|
luaArguments.getString (-1));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::loadSaveGameData (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnString (thisScriptManager->
|
|
loadSaveGameData (luaArguments.
|
|
getString (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
}
|
|
|
|
int
|
|
ScriptManager::getFactionPlayerType (LuaHandle * luaHandle)
|
|
{
|
|
LuaArguments
|
|
luaArguments (luaHandle);
|
|
try
|
|
{
|
|
luaArguments.returnInt (thisScriptManager->
|
|
getFactionPlayerType (luaArguments.
|
|
getInt (-1)));
|
|
}
|
|
catch (const megaglest_runtime_error & ex)
|
|
{
|
|
error (luaHandle, &ex, __FILE__, __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
return luaArguments.getReturnCount ();
|
|
|
|
}
|
|
|
|
void
|
|
ScriptManager::saveGame (XmlNode * rootNode)
|
|
{
|
|
std::map < string, string > mapTagReplacements;
|
|
XmlNode *
|
|
scriptManagerNode = rootNode->addChild ("ScriptManager");
|
|
|
|
//lua
|
|
// string code;
|
|
scriptManagerNode->addAttribute ("code", code, mapTagReplacements);
|
|
// LuaScript luaScript;
|
|
|
|
luaScript.beginCall ("onSave");
|
|
luaScript.endCall ();
|
|
|
|
if (LuaScript::getDebugModeEnabled () == true)
|
|
printf ("After onSave luaSavedGameData.size() = %d\n",
|
|
(int) luaSavedGameData.size ());
|
|
for (std::map < string, string >::iterator iterMap =
|
|
luaSavedGameData.begin (); iterMap != luaSavedGameData.end ();
|
|
++iterMap)
|
|
{
|
|
|
|
XmlNode *
|
|
savedGameDataItemNode =
|
|
scriptManagerNode->addChild ("SavedGameDataItem");
|
|
|
|
savedGameDataItemNode->addAttribute ("key", iterMap->first,
|
|
mapTagReplacements);
|
|
savedGameDataItemNode->addAttribute ("value", iterMap->second,
|
|
mapTagReplacements);
|
|
}
|
|
|
|
// //world
|
|
// World *world;
|
|
// GameCamera *gameCamera;
|
|
//
|
|
// //misc
|
|
// MessageQueue messageQueue;
|
|
for (std::list < ScriptManagerMessage >::iterator it =
|
|
messageQueue.begin (); it != messageQueue.end (); ++it)
|
|
{
|
|
(*it).saveGame (scriptManagerNode);
|
|
}
|
|
|
|
//printf("==== ScriptManager Savegame messageBox [%d][%s][%s] displayText [%s]\n",messageBox.getEnabled(),messageBox.getText().c_str(),messageBox.getHeader().c_str(),displayText.c_str());
|
|
|
|
// GraphicMessageBox messageBox;
|
|
scriptManagerNode->addAttribute ("messageBox_enabled",
|
|
intToStr (messageBox.getEnabled ()),
|
|
mapTagReplacements);
|
|
scriptManagerNode->addAttribute ("messageBox_text",
|
|
messageBox.getText (),
|
|
mapTagReplacements);
|
|
scriptManagerNode->addAttribute ("messageBox_header",
|
|
messageBox.getHeader (),
|
|
mapTagReplacements);
|
|
|
|
// string displayText;
|
|
scriptManagerNode->addAttribute ("displayText", displayText,
|
|
mapTagReplacements);
|
|
//
|
|
// //last created unit
|
|
// string lastCreatedUnitName;
|
|
scriptManagerNode->addAttribute ("lastCreatedUnitName",
|
|
lastCreatedUnitName,
|
|
mapTagReplacements);
|
|
// int lastCreatedUnitId;
|
|
scriptManagerNode->addAttribute ("lastCreatedUnitId",
|
|
intToStr (lastCreatedUnitId),
|
|
mapTagReplacements);
|
|
//
|
|
// //last dead unit
|
|
// string lastDeadUnitName;
|
|
scriptManagerNode->addAttribute ("lastDeadUnitName", lastDeadUnitName,
|
|
mapTagReplacements);
|
|
// int lastDeadUnitId;
|
|
scriptManagerNode->addAttribute ("lastDeadUnitId",
|
|
intToStr (lastDeadUnitId),
|
|
mapTagReplacements);
|
|
// int lastDeadUnitCauseOfDeath;
|
|
scriptManagerNode->addAttribute ("lastDeadUnitCauseOfDeath",
|
|
intToStr (lastDeadUnitCauseOfDeath),
|
|
mapTagReplacements);
|
|
//
|
|
// //last dead unit's killer
|
|
// string lastDeadUnitKillerName;
|
|
scriptManagerNode->addAttribute ("lastDeadUnitKillerName",
|
|
lastDeadUnitKillerName,
|
|
mapTagReplacements);
|
|
// int lastDeadUnitKillerId;
|
|
scriptManagerNode->addAttribute ("lastDeadUnitKillerId",
|
|
intToStr (lastDeadUnitKillerId),
|
|
mapTagReplacements);
|
|
//
|
|
// //last attacked unit
|
|
// string lastAttackedUnitName;
|
|
scriptManagerNode->addAttribute ("lastAttackedUnitName",
|
|
lastAttackedUnitName,
|
|
mapTagReplacements);
|
|
// int lastAttackedUnitId;
|
|
scriptManagerNode->addAttribute ("lastAttackedUnitId",
|
|
intToStr (lastAttackedUnitId),
|
|
mapTagReplacements);
|
|
//
|
|
// //last attacking unit
|
|
// string lastAttackingUnitName;
|
|
scriptManagerNode->addAttribute ("lastAttackingUnitName",
|
|
lastAttackingUnitName,
|
|
mapTagReplacements);
|
|
// int lastAttackingUnitId;
|
|
scriptManagerNode->addAttribute ("lastAttackingUnitId",
|
|
intToStr (lastAttackingUnitId),
|
|
mapTagReplacements);
|
|
//
|
|
// // end game state
|
|
// bool gameOver;
|
|
scriptManagerNode->addAttribute ("gameOver", intToStr (gameOver),
|
|
mapTagReplacements);
|
|
// bool gameWon;
|
|
scriptManagerNode->addAttribute ("gameWon", intToStr (gameWon),
|
|
mapTagReplacements);
|
|
// PlayerModifiers playerModifiers[GameConstants::maxPlayers];
|
|
for (unsigned int i = 0; i < (unsigned int) GameConstants::maxPlayers;
|
|
++i)
|
|
{
|
|
PlayerModifiers & player = playerModifiers[i];
|
|
player.saveGame (scriptManagerNode);
|
|
}
|
|
// int currentTimerTriggeredEventId;
|
|
scriptManagerNode->addAttribute ("currentTimerTriggeredEventId",
|
|
intToStr
|
|
(currentTimerTriggeredEventId),
|
|
mapTagReplacements);
|
|
// int currentCellTriggeredEventId;
|
|
scriptManagerNode->addAttribute ("currentCellTriggeredEventId",
|
|
intToStr (currentCellTriggeredEventId),
|
|
mapTagReplacements);
|
|
// int currentEventId;
|
|
scriptManagerNode->addAttribute ("currentEventId",
|
|
intToStr (currentEventId),
|
|
mapTagReplacements);
|
|
// std::map<int,CellTriggerEvent> CellTriggerEventList;
|
|
for (std::map < int, CellTriggerEvent >::iterator iterMap =
|
|
CellTriggerEventList.begin ();
|
|
iterMap != CellTriggerEventList.end (); ++iterMap)
|
|
{
|
|
XmlNode *
|
|
cellTriggerEventListNode =
|
|
scriptManagerNode->addChild ("CellTriggerEventList");
|
|
|
|
cellTriggerEventListNode->addAttribute ("key",
|
|
intToStr (iterMap->first),
|
|
mapTagReplacements);
|
|
iterMap->second.saveGame (cellTriggerEventListNode);
|
|
}
|
|
// std::map<int,TimerTriggerEvent> TimerTriggerEventList;
|
|
for (std::map < int, TimerTriggerEvent >::iterator iterMap =
|
|
TimerTriggerEventList.begin ();
|
|
iterMap != TimerTriggerEventList.end (); ++iterMap)
|
|
{
|
|
XmlNode *
|
|
timerTriggerEventListNode =
|
|
scriptManagerNode->addChild ("TimerTriggerEventList");
|
|
|
|
timerTriggerEventListNode->addAttribute ("key",
|
|
intToStr (iterMap->first),
|
|
mapTagReplacements);
|
|
iterMap->second.saveGame (timerTriggerEventListNode);
|
|
}
|
|
|
|
// bool inCellTriggerEvent;
|
|
scriptManagerNode->addAttribute ("inCellTriggerEvent",
|
|
intToStr (inCellTriggerEvent),
|
|
mapTagReplacements);
|
|
// std::vector<int> unRegisterCellTriggerEventList;
|
|
for (unsigned int i = 0; i < unRegisterCellTriggerEventList.size ();
|
|
++i)
|
|
{
|
|
XmlNode *
|
|
unRegisterCellTriggerEventListNode =
|
|
scriptManagerNode->addChild ("unRegisterCellTriggerEventList");
|
|
unRegisterCellTriggerEventListNode->addAttribute ("eventId",
|
|
intToStr
|
|
(unRegisterCellTriggerEventList
|
|
[i]),
|
|
mapTagReplacements);
|
|
}
|
|
|
|
scriptManagerNode->addAttribute ("registeredDayNightEvent",
|
|
intToStr (registeredDayNightEvent),
|
|
mapTagReplacements);
|
|
scriptManagerNode->addAttribute ("lastDayNightTriggerStatus",
|
|
intToStr (lastDayNightTriggerStatus),
|
|
mapTagReplacements);
|
|
|
|
for (std::map < int, UnitTriggerEventType >::iterator iterMap =
|
|
UnitTriggerEventList.begin ();
|
|
iterMap != UnitTriggerEventList.end (); ++iterMap)
|
|
{
|
|
XmlNode *
|
|
unitTriggerEventListNode =
|
|
scriptManagerNode->addChild ("UnitTriggerEventList");
|
|
|
|
unitTriggerEventListNode->addAttribute ("unitId",
|
|
intToStr (iterMap->first),
|
|
mapTagReplacements);
|
|
unitTriggerEventListNode->addAttribute ("eventType",
|
|
intToStr (iterMap->second),
|
|
mapTagReplacements);
|
|
}
|
|
scriptManagerNode->addAttribute ("lastUnitTriggerEventUnitId",
|
|
intToStr (lastUnitTriggerEventUnitId),
|
|
mapTagReplacements);
|
|
scriptManagerNode->addAttribute ("lastUnitTriggerEventType",
|
|
intToStr (lastUnitTriggerEventType),
|
|
mapTagReplacements);
|
|
|
|
luaScript.saveGame (scriptManagerNode);
|
|
}
|
|
|
|
void
|
|
ScriptManager::loadGame (const XmlNode * rootNode)
|
|
{
|
|
const XmlNode *
|
|
scriptManagerNode = rootNode->getChild ("ScriptManager");
|
|
|
|
// string code;
|
|
code = scriptManagerNode->getAttribute ("code")->getValue ();
|
|
// LuaScript luaScript;
|
|
|
|
vector < XmlNode * >savedGameDataItemNodeList =
|
|
scriptManagerNode->getChildList ("SavedGameDataItem");
|
|
|
|
if (LuaScript::getDebugModeEnabled () == true)
|
|
printf ("In loadGame savedGameDataItemNodeList.size() = %d\n",
|
|
(int) savedGameDataItemNodeList.size ());
|
|
|
|
for (unsigned int i = 0; i < savedGameDataItemNodeList.size (); ++i)
|
|
{
|
|
XmlNode *
|
|
node = savedGameDataItemNodeList[i];
|
|
string
|
|
key = node->getAttribute ("key")->getValue ();
|
|
string
|
|
value = node->getAttribute ("value")->getValue ();
|
|
|
|
luaSavedGameData[key] = value;
|
|
}
|
|
|
|
// //world
|
|
// World *world;
|
|
// GameCamera *gameCamera;
|
|
//
|
|
// //misc
|
|
// MessageQueue messageQueue;
|
|
messageQueue.clear ();
|
|
vector < XmlNode * >messageQueueNodeList =
|
|
scriptManagerNode->getChildList ("ScriptManagerMessage");
|
|
for (unsigned int i = 0; i < messageQueueNodeList.size (); ++i)
|
|
{
|
|
XmlNode *
|
|
node = messageQueueNodeList[i];
|
|
ScriptManagerMessage
|
|
msg;
|
|
msg.loadGame (node);
|
|
messageQueue.push_back (msg);
|
|
}
|
|
|
|
// GraphicMessageBox messageBox;
|
|
messageBox.setEnabled (scriptManagerNode->
|
|
getAttribute ("messageBox_enabled")->
|
|
getIntValue () != 0);
|
|
messageBox.setText (scriptManagerNode->
|
|
getAttribute ("messageBox_text")->getValue ());
|
|
messageBox.setHeader (scriptManagerNode->
|
|
getAttribute ("messageBox_header")->getValue ());
|
|
|
|
// string displayText;
|
|
displayText =
|
|
scriptManagerNode->getAttribute ("displayText")->getValue ();
|
|
//
|
|
// //last created unit
|
|
// string lastCreatedUnitName;
|
|
lastCreatedUnitName =
|
|
scriptManagerNode->getAttribute ("lastCreatedUnitName")->getValue ();
|
|
// int lastCreatedUnitId;
|
|
lastCreatedUnitId =
|
|
scriptManagerNode->getAttribute ("lastCreatedUnitId")->getIntValue ();
|
|
//
|
|
// //last dead unit
|
|
// string lastDeadUnitName;
|
|
lastDeadUnitName =
|
|
scriptManagerNode->getAttribute ("lastDeadUnitName")->getValue ();
|
|
// int lastDeadUnitId;
|
|
lastDeadUnitId =
|
|
scriptManagerNode->getAttribute ("lastDeadUnitId")->getIntValue ();
|
|
// int lastDeadUnitCauseOfDeath;
|
|
lastDeadUnitCauseOfDeath =
|
|
scriptManagerNode->getAttribute ("lastDeadUnitCauseOfDeath")->
|
|
getIntValue ();
|
|
//
|
|
// //last dead unit's killer
|
|
// string lastDeadUnitKillerName;
|
|
lastDeadUnitKillerName =
|
|
scriptManagerNode->getAttribute ("lastDeadUnitKillerName")->
|
|
getValue ();
|
|
// int lastDeadUnitKillerId;
|
|
lastDeadUnitKillerId =
|
|
scriptManagerNode->getAttribute ("lastDeadUnitKillerId")->
|
|
getIntValue ();
|
|
//
|
|
// //last attacked unit
|
|
// string lastAttackedUnitName;
|
|
lastAttackedUnitName =
|
|
scriptManagerNode->getAttribute ("lastAttackedUnitName")->getValue ();
|
|
// int lastAttackedUnitId;
|
|
lastAttackedUnitId =
|
|
scriptManagerNode->getAttribute ("lastAttackedUnitId")->
|
|
getIntValue ();
|
|
//
|
|
// //last attacking unit
|
|
// string lastAttackingUnitName;
|
|
lastAttackingUnitName =
|
|
scriptManagerNode->getAttribute ("lastAttackingUnitName")->
|
|
getValue ();
|
|
// int lastAttackingUnitId;
|
|
lastAttackingUnitId =
|
|
scriptManagerNode->getAttribute ("lastAttackingUnitId")->
|
|
getIntValue ();
|
|
//
|
|
// // end game state
|
|
// bool gameOver;
|
|
gameOver =
|
|
scriptManagerNode->getAttribute ("gameOver")->getIntValue () != 0;
|
|
// bool gameWon;
|
|
gameWon =
|
|
scriptManagerNode->getAttribute ("gameWon")->getIntValue () != 0;
|
|
// PlayerModifiers playerModifiers[GameConstants::maxPlayers];
|
|
vector < XmlNode * >playerModifiersNodeList =
|
|
scriptManagerNode->getChildList ("PlayerModifiers");
|
|
for (unsigned int i = 0; i < playerModifiersNodeList.size (); ++i)
|
|
{
|
|
XmlNode *
|
|
node = playerModifiersNodeList[i];
|
|
playerModifiers[i].loadGame (node);
|
|
}
|
|
// int currentTimerTriggeredEventId;
|
|
currentTimerTriggeredEventId =
|
|
scriptManagerNode->getAttribute ("currentTimerTriggeredEventId")->
|
|
getIntValue ();
|
|
// int currentCellTriggeredEventId;
|
|
currentCellTriggeredEventId =
|
|
scriptManagerNode->getAttribute ("currentCellTriggeredEventId")->
|
|
getIntValue ();
|
|
// int currentEventId;
|
|
currentEventId =
|
|
scriptManagerNode->getAttribute ("currentEventId")->getIntValue ();
|
|
// std::map<int,CellTriggerEvent> CellTriggerEventList;
|
|
vector < XmlNode * >cellTriggerEventListNodeList =
|
|
scriptManagerNode->getChildList ("CellTriggerEventList");
|
|
for (unsigned int i = 0; i < cellTriggerEventListNodeList.size (); ++i)
|
|
{
|
|
XmlNode *
|
|
node = cellTriggerEventListNodeList[i];
|
|
CellTriggerEvent
|
|
event;
|
|
event.loadGame (node);
|
|
CellTriggerEventList[node->getAttribute ("key")->getIntValue ()] =
|
|
event;
|
|
}
|
|
|
|
// std::map<int,TimerTriggerEvent> TimerTriggerEventList;
|
|
vector < XmlNode * >timerTriggerEventListNodeList =
|
|
scriptManagerNode->getChildList ("TimerTriggerEventList");
|
|
for (unsigned int i = 0; i < timerTriggerEventListNodeList.size (); ++i)
|
|
{
|
|
XmlNode *
|
|
node = timerTriggerEventListNodeList[i];
|
|
|
|
TimerTriggerEvent
|
|
event;
|
|
event.loadGame (node);
|
|
TimerTriggerEventList[node->getAttribute ("key")->getIntValue ()] =
|
|
event;
|
|
}
|
|
|
|
// bool inCellTriggerEvent;
|
|
inCellTriggerEvent =
|
|
scriptManagerNode->getAttribute ("inCellTriggerEvent")->
|
|
getIntValue () != 0;
|
|
// std::vector<int> unRegisterCellTriggerEventList;
|
|
vector < XmlNode * >unRegisterCellTriggerEventListNodeList =
|
|
scriptManagerNode->getChildList ("unRegisterCellTriggerEventList");
|
|
for (unsigned int i = 0;
|
|
i < unRegisterCellTriggerEventListNodeList.size (); ++i)
|
|
{
|
|
XmlNode *
|
|
node = unRegisterCellTriggerEventListNodeList[i];
|
|
unRegisterCellTriggerEventList.push_back (node->
|
|
getAttribute ("eventId")->
|
|
getIntValue ());
|
|
}
|
|
|
|
if (scriptManagerNode->hasAttribute ("registeredDayNightEvent") == true)
|
|
{
|
|
registeredDayNightEvent =
|
|
scriptManagerNode->getAttribute ("registeredDayNightEvent")->
|
|
getIntValue () != 0;
|
|
}
|
|
if (scriptManagerNode->hasAttribute ("lastDayNightTriggerStatus") ==
|
|
true)
|
|
{
|
|
lastDayNightTriggerStatus =
|
|
scriptManagerNode->getAttribute ("lastDayNightTriggerStatus")->
|
|
getIntValue ();
|
|
}
|
|
|
|
vector < XmlNode * >unitTriggerEventListNodeList =
|
|
scriptManagerNode->getChildList ("UnitTriggerEventList");
|
|
for (unsigned int i = 0; i < unitTriggerEventListNodeList.size (); ++i)
|
|
{
|
|
XmlNode *
|
|
node = unitTriggerEventListNodeList[i];
|
|
|
|
UnitTriggerEventType
|
|
eventType = utet_None;
|
|
int
|
|
unitId = node->getAttribute ("unitId")->getIntValue ();
|
|
if (node->hasAttribute ("eventType") == true)
|
|
{
|
|
eventType =
|
|
static_cast < UnitTriggerEventType >
|
|
(node->getAttribute ("eventType")->getIntValue ());
|
|
}
|
|
else if (node->hasAttribute ("evenType") == true)
|
|
{
|
|
eventType =
|
|
static_cast < UnitTriggerEventType >
|
|
(node->getAttribute ("evenType")->getIntValue ());
|
|
}
|
|
UnitTriggerEventList[unitId] = eventType;
|
|
}
|
|
if (scriptManagerNode->hasAttribute ("lastUnitTriggerEventUnitId") ==
|
|
true)
|
|
{
|
|
lastUnitTriggerEventUnitId =
|
|
scriptManagerNode->getAttribute ("lastUnitTriggerEventUnitId")->
|
|
getIntValue ();
|
|
}
|
|
if (scriptManagerNode->hasAttribute ("lastUnitTriggerEventType") ==
|
|
true)
|
|
{
|
|
lastUnitTriggerEventType =
|
|
static_cast < UnitTriggerEventType >
|
|
(scriptManagerNode->getAttribute ("lastUnitTriggerEventType")->
|
|
getIntValue ());
|
|
}
|
|
|
|
luaScript.loadGame (scriptManagerNode);
|
|
}
|
|
|
|
|
|
}
|
|
} //end namespace
|