aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-11-24 15:56:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/ryzom/common/data_common/r2/r2_components.lua
acemtp 0e7a4c27d0 Added: tables and default data for sql
2010-05-08 15:37:08 +02:00

1403 lines
44 KiB
Lua
Raw Blame History

r2.registerHighLevel = function()
local classMapDescriptionVersion = 0
local classMapDescription =
{
BaseClass="BaseClass",
Name = "MapDescription",
DisplayerUI = "",
ersion = classMapDescriptionVersion,
Prop =
{
{Name="Title", Type="String", Category="uiR2EDRollout_Scenario"},
{Name="LevelId", Type="String"},
{Name="ShortDescription", Type="String", Category="uiREDRollout_"},
{Name="OptimalNumberOfPlayer", Type="Number", Category="uiREDRollout_", Min="1", Max="10", Default="1"},
{Name="Creator", Type="String", Category="uiREDRollout_", WidgetStyle = "StaticText"},
{Name="CreatorMD5", Type="String", Category="uiREDRollout_", WidgetStyle = "StaticText"},
{Name="CreationDate", Type="String", Category="uiREDRollout_", WidgetStyle = "StaticText"},
{Name="OtherCharAccess", Type="String", Category="uiREDRollout_", WidgetStyle = "StaticText", DefaultValue="Full", DefaultInBase = 1 },
{Name="NevraxScenario", Type="String", Category="uiREDRollout_", WidgetStyle = "StaticText", DefaultValue="0", DefaultInBase = 1 },
{Name="TrialAllowed", Type="String", Category="uiREDRollout_", WidgetStyle = "StaticText", DefaultValue="0", DefaultInBase = 1 },
{Name="ScenarioTag", Type="String", Category="uiREDRollout_", WidgetStyle = "StaticText", DefaultValue="", DefaultInBase = 1 },
},
}
local classScenarioVersionName = getClientCfgVar("BuildName")
local classScenarioVersion = 4
local classScenario =
{
--BaseClass="BaseClass",
BaseClass="LogicEntity",
Name = "Scenario",
InEventUI = true,
Version = classScenarioVersion,
VersionName =classScenarioVersionName,
BuildPropertySheet = false,
Prop =
{
{Name="AccessRules", Type="String", WidgetStyle = "StaticText"},
{Name="Description", Type="MapDescription"},
{Name="Acts", Type="Table"},
{Name="Locations", Type="Table"},
{Name="Texts", Type="TextManager"},
{Name="VersionName", Type="String", DefaultValue=classScenarioVersionName, Visible=false }, -- just a string
{Name="Versions", Type="Table"},
{Name="UserComponents", Type="Table"},
{Name="PlotItems", Type="Table"},
{Name="Language", Type="String", DefaultValue="en", Visible=false},
{Name="Type", Type="String", DefaultValue="so_story_telling", Visible=false},
--{Name="TestRefId", Type="RefId", Category="uiR2EDRollout_Test"},
{Name="ScenarioScore", Type="Number", DefaultValue="0", Min="0", Visible=false},
{Name="Score", Type="Number"},
},
Parameters = {},
ApplicableActions = {
--"Start Scenario Timing", "Stop Scenario Timing", "add scenario points", "succeed scenario", "fail scenario"
},
Events = {
-- "on scenario succeeded", "on scenario failed"
},
Conditions = {
-- "is active", "is finished"
},
TextContexts = {},
TextParameters = {},
LiveParameters = {},
----------------------------------------------------------------------------------------------------
isDisplayModeOptionAvailable = function(this) return false end,
----------------------------------------------------------------------------------------------------
updateVersion = function(this, scenarioValue, currentValue)
local patchValue = scenarioValue
if patchValue < 1 then
-- Patch only for old save (not the 0.0.3)
if VersionName ~= "0.0.3" then
-- TODO use identifier instead
local oldValue = this.Description.LocationId
local newValue = oldValue
if 0 == oldValue then
newValue = 1
elseif 1 <= oldValue and oldValue <= 5 then
newValue = oldValue + 2
elseif 6 == oldValue then
newValue = 9
elseif 7 == oldValue then
newValue = 11
elseif 8 <= oldValue and oldValue <= 27 then
newValue = oldValue + 5
end
r2.requestSetNode(this.Description.InstanceId, "LocationId", newValue)
end
patchValue = 1
end
-- plot item feature
if patchValue < 2 then
r2.requestSetNode(this.InstanceId, "PlotItems", {})
r2.requestSetNode(this.InstanceId, "UserComponents", {})
patchValue = 2
end
-- update of enum for scenario type
if patchValue < 3 then
if this.Type == nil or this.Type == "" then
r2.requestSetNode(this.InstanceId, "Type", "so_story_telling")
elseif this.Type == "Roleplay" then
r2.requestSetNode(this.InstanceId, "Type", "so_story_telling")
elseif this.Type == "Combat" then
r2.requestSetNode(this.InstanceId, "Type", "so_hack_slash")
end
patchValue = 3
end
-- patch for level
if patchValue < 4 then
if this.Description.LevelId == nil or this.Description.LevelId < 0 or this.Description.LevelId > 5 then
r2.requestSetNode(this.Description.InstanceId, "LevelId", 0)
end
patchValue = 4
end
if patchValue == currentValue then return true end
return false
end,
---------------------------------------------------------------------------------------------------------
-- get name of tree icon
getContextualTreeIcon = function(this)
return this:getTreeIcon()
end,
-----------------------------------------------------------------------------
getBaseAct = function(this)
return this.Acts[0]
end,
getCurrentAct = function(this)
return r2:getCurrentAct()
end,
-----------------------------------------------------------------------------
-- from baseClass
getDisplayName = function(this)
return i18n.get("uiR2EDScenario")
end,
-----------------------------------------------------------------------------
-- from baseClass
isDeletable = function(this)
return false
end,
-----------------------------------------------------------------------------
--
getBaseActLeftBudget = function(this)
local maxValue = this:getMaxSecondaryActCost()
return this.Description.MaxEntities - this:getBaseAct():getLocalCost() - maxValue
end,
-----------------------------------------------------------------------------
-- Called by the C++ just before testing to see if the cost of this scenario is valid
-- Should return true in this case
-- If the scenario has a too high cost, then this function has the responsability to warn the player
validateForTesting = function(this)
if this:getMaxSecondaryActCost() < 0 then
messageBox(i18n.get("uiR2EDScenarioBudgetExceeded"))
return false
else
return true
end
end,
-----------------------------------------------------------------------------
--
getMaxSecondaryActCost = function(this)
local scenarioObj = r2.getScenarioObj()
local max = 0
local maxStatic = 0
local first = true
k,v = next(this.Acts,nil)
while k~=nil do
if first == true then
first = false
else
if max < v:getLocalCost() then
max = v:getLocalCost()
end
if maxStatic < v:getLocalStaticCost() then
debugInfo("setting maxStatic")
maxStatic = v:getLocalStaticCost()
end
end
k,v=next(this.Acts,k)
end
return max, maxStatic
end,
-----------------------------------------------------------------------------
-- returns a table with all objects of kind "kind" in the permanent act & current act
getAllInstancesByType = function(this, kind)
assert(type(kind) == "string")
local result = {}
--this:delegate():appendInstancesByType(result, kind)
r2.Classes.BaseClass.appendInstancesByType(this, result, kind)
this.Acts[0]:appendInstancesByType(result, kind)
local currAct = r2:getCurrentAct()
if currAct ~= nil and currAct ~= this.Acts[0] then
currAct:appendInstancesByType(result, kind)
end
return result
end,
-----------------------------------------------------------------------------
-- from baseClass
completeSelectBarMenu = function(this, rootMenu)
-- if all acts are not used, propose to create a new one
--rootMenu:addSeparator()
--r2:addMenuLine(rootMenu, this:getDisplayName(), "lua", "r2:setSelectedInstanceId('" .. this.InstanceId .."')", tostring(k), this:getSelectBarIcon(), 14)
--rootMenu:addSeparator()
--r2:addMenuLine(rootMenu, i18n.get("uiR2EDNewAct"), "lua", "r2.ScenarioWindow:newAct()", "new_act", "r2_icon_create.tga", 14)
end,
-----------------------------------------------------------------------------
-- from baseClass
displayInSelectBar = function(this)
return false -- don't display in the selection bar (only acts can be ...)
end,
--
---------------------------------------------------------------------------------------------------------
-- from base class
getFirstSelectBarSon = function(this)
return r2:getCurrentAct():getFirstSelectBarSon()
end,
---------------------------------------------------------------------------------------------------------
-- from base class
canHaveSelectBarSons = function(this)
return false;
end,
---------------------------------------------------------------------------------------------------------
-- from base class, update the item ui on first display
onPostCreate = function(this)
r2.PlotItemsPanel:reinit()
r2.PlotItemDisplayerCommon:touch()
if r2.Mode == "Edit" then
-- if some element in the scenario are hidden, then display
-- a message for the user to remember it
-- local sons = {}
-- this:getSons(sons)
-- local showWarning = false
-- for k, v in pairs(sons) do
-- if type(v) == "userdata" and v.isKindOf and v:isKindOf("WorldObject") and v.DisplayMode ~= 0 then
-- showWarning = true
-- break
-- end
-- end
-- if showWarning then
-- messageBox(i18n.get("uiR2EDDisplayModeMenuReminder"))
-- end
-- reset display modes
r2.PrimDisplayFrozen = false
r2.PrimDisplayVisible = true
r2.PrimDisplayContextualVisibility = false
r2.BotObjectsFrozen = false
r2:setupFreezeBotObjectButton()
end
end,
onAttrModified = function(this, name)
if this == r2.Scenario then
if name ~= "Acts" then
r2.ScenarioWindow:updateScenarioProperties()
end
if name=="Acts" and r2.Scenario:getCurrentAct()==r2.Scenario:getBaseAct() and r2.Scenario.Acts.Size>1 then
r2.ScenarioWindow:setAct( r2.Scenario.Acts[1] )
end
end
end,
-----------------------------------------------------------------------------
onErase = function(this)
r2.acts.deleteOldScenario = false
end,
getName = function(this)
if this.Ghost_Name then return this.Ghost_Name end
return this.Name
end,
}
----------------------------------------------------------------------------
-- add a line to the event menu
function classScenario.initLogicEntitiesMenu(this, logicEntityMenu)
local name = i18n.get("uiR2EDScenario")
logicEntityMenu:addLine(name, "lua", "", "Scenario")
end
----------------------------------------------------------------------------
-- add a line to the event sub menu
function classScenario.initLogicEntitiesInstancesMenu(this, subMenu, calledFunction)
local uc_name = ucstring()
uc_name:fromUtf8(r2.Scenario:getName())
subMenu:addLine(uc_name, "lua", calledFunction.."('".. r2.Scenario.InstanceId .."')", r2.Scenario.InstanceId)
end
----------------------------------------------------------------------------
-- add a line to the event menu
function classScenario:getLogicTranslations()
local logicTranslations = {
["ApplicableActions"] = {
--["Start Scenario Timing"] = { menu=i18n.get( "uiR2AA0ScenarioStartTiming" ):toUtf8(),
-- text=i18n.get( "uiR2AA1ScenarioStartTiming" ):toUtf8()},
--["Stop Scenario Timing"] = { menu=i18n.get( "uiR2AA0ScenarioStopTiming" ):toUtf8(),
-- text=i18n.get( "uiR2AA1ScenarioStopTiming" ):toUtf8()},
--["add scenario points"] = { menu=i18n.get( "uiR2AA0ScenarioAddPoints" ):toUtf8(),
-- text=i18n.get( "uiR2AA1ScenarioAddPoints" ):toUtf8()},
--["succeed scenario"] = { menu=i18n.get( "uiR2AA0ScenarioSucceed" ):toUtf8(),
-- text=i18n.get( "uiR2AA1ScenarioSucceed" ):toUtf8()},
--["fail scenario"] = { menu=i18n.get( "uiR2AA0ScenarioFail" ):toUtf8(),
-- text=i18n.get( "uiR2AA1ScenarioFail" ):toUtf8()},
},
["Events"] = {
--["On Scenario Started"] = { menu=i18n.get( "uiR2Event0ScenarioStart" ):toUtf8(),
-- text=i18n.get( "uiR2Event1ScenarioStart" ):toUtf8()},
--["on scenario succeeded"] = { menu=i18n.get( "uiR2Event0ScenarioSucceed" ):toUtf8(),
-- text=i18n.get( "uiR2Event1ScenarioSucceed" ):toUtf8()},
--["on scenario failed"] = { menu=i18n.get( "uiR2Event0ScenarioFailed" ):toUtf8(),
-- text=i18n.get( "uiR2Event1ScenarioFailed" ):toUtf8()},
},
["Conditions"] = {
}
}
return logicTranslations
end
function classScenario.initEventValuesMenu(this, menu, categoryEvent)
for ev=0,menu:getNumLine()-1 do
local eventType = tostring(menu:getLineId(ev))
if r2.events.eventTypeWithValue[eventType] == "Number" then
menu:addSubMenu(ev)
local subMenu = menu:getSubMenu(ev)
local func = ""
local lineNb = 0
for i=1, 100, 20 do
local lineStr = tostring(i).."/"..tostring(i+19)
subMenu:addLine(ucstring(lineStr), "", "", tostring(i))
subMenu:addSubMenu(lineNb)
local subMenu2= subMenu:getSubMenu(lineNb)
for s=0, 19 do
lineStr = tostring(i+s)
local func = "r2.events:setEventValue('','" .. categoryEvent .."','".. lineStr.."')"
subMenu2:addLine(ucstring(lineStr), "lua", func, lineStr)
end
lineNb = lineNb+1
end
end
end
end
function classScenario.pretranslate(this, context)
-- Nothing to do: Done by act[0]:pretranslate
end
function classScenario.translate(this, context)
r2.Translator.translateAiGroup(this, context)
end
function classScenario.getLogicEvent(this, context, event)
assert( event.Class == "LogicEntityAction")
local component = this -- r2:getInstanceFromId(event.Entity)
assert(component)
local rtNpcGrp = r2.Translator.getRtGroup(context, component.InstanceId)
assert(rtNpcGrp)
local eventType = tostring(event.Event.Type)
local eventHandler, firstCondition, lastCondition = nil, nil, nil
local rtNpcGrp = r2.Translator.getRtGroup(context, r2.Scenario.Acts[0].InstanceId)
assert(rtNpcGrp)
if eventType == "On Scenario Started" then
return r2.Translator.createEvent("timer_t0_triggered", "", rtNpcGrp.Id)
elseif eventType == "on scenario succeeded" then
return r2.Translator.getComponentUserEvent(rtNpcGrp, 7)
elseif eventType == "on scenario failed" then
return r2.Translator.getComponentUserEvent(rtNpcGrp, 8)
end
return eventHandler, firstCondition, lastCondition
end
function classScenario.getLogicAction(entity, context, action)
assert( action.Class == "ActionStep")
local component = r2:getInstanceFromId(action.Entity)
assert(component)
local rtNpcGrp = r2.Utils.getRtGroup(context, component.InstanceId)
assert(rtNpcGrp)
if (action.Action.Type == "Start Scenario Timing") then
local action = r2.Translator.createAction("start_scenario_timing")
return action, action
elseif (action.Action.Type == "Stop Scenario Timing") then
local action = r2.Translator.createAction("stop_scenario_timing")
return action, action
elseif (action.Action.Type == "add scenario points") then
if not action.Action.ValueString then return end
local points = tonumber(action.Action.ValueString)
local baseAct = r2.Scenario:getBaseAct()
local rtBaseActGrp = r2.Translator.getRtGroup(context, baseAct.InstanceId)
local action = r2.Translator.createAction("add_scenario_points", rtBaseActGrp.Id, points)
return action, action
elseif action.Action.Type == "succeed scenario" then
local action1 = r2.Translator.createAction("set_value", rtNpcGrp.Id, "Success", 1)
local action2 = r2.Translator.createAction("user_event_trigger", rtNpcGrp.Id, 7)
local retAction = r2.Translator.createAction("multi_actions", {action1, action2})
assert(retAction)
return retAction, retAction
elseif action.Action.Type == "fail scenario" then
local action1 = r2.Translator.createAction("set_value", rtNpcGrp.Id, "Success", 0)
local action2 = r2.Translator.createAction("user_event_trigger", rtNpcGrp.Id, 8)
local retAction = r2.Translator.createAction("multi_actions", {action1, action2})
assert(retAction)
return retAction, retAction
end
return r2.Translator.getFeatureActivationLogicAction(rtNpcGrp, action)
end
function classScenario.getLogicCondition(this, context, condition)
assert( condition.Class == "ConditionStep")
local component = r2:getInstanceFromId(condition.Entity)
assert(component)
local rtNpcGrp = r2.Utils.getRtGroup(context, component.InstanceId)
assert(rtNpcGrp)
return r2.Translator.getFeatureActivationCondition(condition, rtNpcGrp)
end
function classScenario.getActIndex(this, actInstanceId)
local index = 0
local k, v = next(this.Acts)
while k do
if tostring(v.InstanceId) == actInstanceId then
return index
end
index = index + 1
k, v = next(this.Acts, k)
end
return -1
end
-- maps each season found in the list box season to an enum to pass to setEditorSeason
r2.ListBoxSeasonToEditorSeason =
{
[0] = "Automatic",
[1] = "Spring",
[2] = "Summer",
[3] = "Autumn",
[4] = "Winter"
}
local classActVersion = 6
local classAct =
{
BaseClass="LogicEntity",
Name = "Act",
InEventUI = true,
Menu="ui:interface:r2ed_base_menu",
DisplayerUI = "R2::CDisplayerLua",
DisplayerUIParams = "createActUIDisplayer",
TreeIcon="r2ed_icon_act.tga",
Version=classActVersion,
Parameters = {},
ApplicableActions = {
"Start Act",
},
Events = {
"On Act Started",
--"On Scenario Started",
},
Conditions = {
-- "is active", "is finished"
},
TextContexts = {},
TextParameters = {},
LiveParameters = {},
Prop =
{
{Name="Version", Type="Number", Visible=false, DefaultValue=tostring(classActVersion)},
{Name="Features", Type="Table"},
{Name="Events",Type="Table"},
-- following field are tmp for property sheet building testing
-- {Name="PVP", Type="Number", WidgetStyle="Boolean", Category="uiR2EDRollout_Test" },
-- {Name="Slider1", Type="Number", WidgetStyle="Slider", Category="uiR2EDRollout_Test"},
-- {Name="Slider2", Type="Number", WidgetStyle="Slider", Category="uiR2EDRollout_Test"},
-- {Name="ComboBox1", Type="Number", WidgetStyle="EnumDropDown",
-- Enum= { "Toto", "Tata", "Titi" }
--},
-- {Name="ComboBox2", Type="Number", WidgetStyle="EnumDropDown",
-- Enum= { "A", "B", "C" }
-- },
{Name="Title", Type="String", WidgetStyle = "StaticText"},
{Name="Name", Type="String", MaxNumChar="25"},
{Name="ActivitiesIds",Type="Table"},
{Name="Counters",Type="Table"},
{Name="ManualWeather", Type="Number", WidgetStyle="Boolean", DefaultValue="0",
Visible = function(act) return not act:isBaseAct() end,
},
{Name="WeatherValue", Type="Number", WidgetStyle="Slider", Min=0, Max=1022, -- The final value in the Rt datas is 0 for autiweather and 1-1023 for weather value ([1, 1023] range <=> [0, 1022])
Visible = function(act) return act.ManualWeather == 1 and not act:isBaseAct() end,
},
{Name="Season", Type="Number", WidgetStyle="EnumDropDown", DefaultValue="0", Visible=false,
Enum= { "uiR2EDSeasonAuto", "uiR2EDSpring", "uiR2EDSummer", "uiR2EDAutumn", "uiR2EDWinter" },
},
{Name="LocationId", Type="String", Visible=false},
{Name="ShortDescription", Type="String", Visible=false},
{Name="PreActDescription", Type="String", DefaultValue="", Visible=false, DefaultInBase=1},
},
updateVersion = function(this, scenarioValue, currentValue )
local patchValue = scenarioValue
if patchValue < 1 then
r2.requestSetNode(this.InstanceId, "ManualWeather", 0)
r2.requestSetNode(this.InstanceId, "WeatherValue", 0)
patchValue = 1
end
if patchValue < 2 then
if not this.Behavior then
local behavior = r2.newComponent("LogicEntityBehavior")
r2.requestInsertNode(this.InstanceId, "", -1, "Behavior", behavior)
r2.requestSetNode(this.InstanceId, "InheritPos", 1)
-- TODO Add position (0,0,0)
end
patchValue = 2
end
if patchValue < 3 then
if not this.Name then
r2.requestSetNode(this.InstanceId, "Name", this.Title)
end
patchValue = 3
end
if patchValue < 4 then
if not this.ExportList then
-- r2.requestInsertNode(this.InstanceId, "", -1, "ExportList", {})
end
patchValue = 4
end
-- version 5 : Remove the "Cost" field -> hold locally now
if patchValue < 5 then
if this.Cost then
r2.requestEraseNode(this.InstanceId, "Cost", -1)
end
if this.StaticCost then
r2.requestEraseNode(this.InstanceId, "StaticCost", -1)
end
patchValue = 5
end
if patchValue < 6 then
if this.ExportList then
r2.requestEraseNode(this.InstanceId, "ExportList", -1)
end
patchValue = 6
end
if patchValue == currentValue then return true end
return false
end,
-----------------------------------------------------------------------------
canChangeDisplayMode = function(this)
return false
end,
-----------------------------------------------------------------------------
onActChanged = function(this)
assert(this)
if this == r2:getCurrentAct() then
r2.acts:updatePaletteFromEcosystem()
r2.ScenarioWindow:updateActProperties()
end
end,
-----------------------------------------------------------------------------
onAttrModified = function(this, name)
if name == "Features" or Name == "Events" then
-- ignore messages triggeered by sons for the update of the property window
return
end
r2.ScenarioWindow:updateActProperties()
end,
-----------------------------------------------------------------------------
onErase = function(this)
this.User.Deleted = true
if this.User.DeleteInProgress == true then return end
this.User.DeleteInProgress = true
this:setDeleteActionName()
-- assume than on delete can only be called if this act is selected
--assert(this:isSameObjectThan(r2:getCurrentAct()))
-- update name of acts in act combo box
local afterDeletedAct = false
for i=0, r2.Scenario.Acts.Size-1 do
local act = r2.Scenario.Acts[i]
if afterDeletedAct then
r2.ActUIDisplayer:updateActName(act)
elseif act==this then
afterDeletedAct = true
end
end
-- if Act[1] exists go to act1
if not r2.acts.deleteOldScenario then
if (table.getn(r2.Scenario.Acts) > 1) and (this~=r2.Scenario.Acts[1]) then
r2.ScenarioWindow:setAct( r2.Scenario.Acts[1] )
else
r2:setCurrentActFromId(r2.Scenario:getBaseAct().InstanceId)
if r2.logicComponents.undoRedoInstances[this.InstanceId] and (table.getn(r2.Scenario.Acts) <= 2) then
r2.acts:openScenarioActEditor(false, true, true)
end
end
end
if r2.logicComponents.undoRedoInstances[this.InstanceId] then
r2.logicComponents.undoRedoInstances[this.InstanceId] = nil
end
end,
-----------------------------------------------------------------------------
updateWeather = function(this)
if this==r2:getCurrentAct() and this.WeatherValue and this.ManualWeather then
setWeatherValue(this.ManualWeather == 0, this.WeatherValue / 1022)
end
end,
-----------------------------------------------------------------------------
accept = function(this, targetInstance)
if targetInstance:isKindOf("BanditCampFeature") then
return "Features"
else
return nil
end
end,
getSelectBarIcon = function(this)
return "r2ed_icon_act.tga"
end,
-----------------------------------------------------------------------------
isBaseAct = function(this)
local parentScenario = this:getParentScenario()
if not parentScenario then return false end
return this:isSameObjectThan(parentScenario:getBaseAct())
--return this == this:getParentScenario():getBaseAct()
end,
-----------------------------------------------------------------------------
-- get the tree control where object other than botobject are inserted in this act
getContentTree = function(this)
return this.User.ContentTree
end,
-----------------------------------------------------------------------------
-- get the tree control where macro components are inserted in this act
getMacroContentTree = function(this)
return this.User.MacroContentTree
end,
-----------------------------------------------------------------------------
-- get the tree control where object other than botobject are inserted in this act
getContentTreeNodes = function(this, nodeName)
local nodes = {}
if this:isBaseAct() then
local acts = this.Parent
if acts.Size>1 then
for i=1, acts.Size-1 do
if acts[i]:getContentTree() then
local node
if nodeName then
node = acts[i]:getContentTree():getRootNode():getNodeFromId(nodeName)
else
node = acts[i]:getMacroContentTree():getRootNode()
end
nodes[acts[i].InstanceId] = node
else
return nil
end
end
end
else
local node
if nodeName then
node = this:getContentTree():getRootNode():getNodeFromId(nodeName)
else
node = this:getMacroContentTree():getRootNode()
end
nodes[this.InstanceId] = node
end
return nodes
end,
-----------------------------------------------------------------------------
-- get the default feature for this act
getDefaultFeature = function(this)
assert(this.Features[0]:isKindOf("DefaultFeature"))
return this.Features[0]
end,
-----------------------------------------------------------------------------
hasScenarioCost = function(this)
return true
end,
getName = function(this)
assert(this)
local name = this.Name
local actNb = r2.logicComponents:searchElementIndex(this)-1
local firstPart = i18n.get("uiR2EDDefaultActTitle"):toUtf8().. actNb
local firstPartSpace = i18n.get("uiR2EDDefaultActTitle"):toUtf8().. " " .. actNb
if name=="" then
name = firstPartSpace
elseif string.lower(name)==string.lower(firstPart) or string.lower(name)==string.lower(firstPartSpace) then
else
name = firstPartSpace .. ":" .. name
end
return name
end,
setName = function(this, value)
assert(this)
this.Name = value
end,
-----------------------------------------------------------------------------
-- from baseClass
getDisplayName = function(this)
if this:isBaseAct() then
return i18n.get("uiR2EDBaseAct")
end
local result = ucstring()
result:fromUtf8(this:getName())
return result
end,
-----------------------------------------------------------------------------
-- from baseClass
isDeletable = function(this)
return not this:isBaseAct()
end,
---------------------------------------------------------------------------------------------------------
-- called when the instance is selected (default is no op)
onSelect = function(this, selected)
if selected and this ~= r2:getCurrentAct() then
-- act was changed from the select bar, update editor state
r2.ScenarioWindow:setAct(this)
end
end,
---------------------------------------------------------------------------------------------------------
-- from baseClass :
-- special : the scenario is not displayed in the select bar, but serves as a 'root' for enumeration so
-- we return it when acts menu is popped in the selectbar, so that acts can be enumerated
getFirstSelectBarParent = function(this)
return this.ParentInstance
end,
---------------------------------------------------------------------------------------------------------
-- from baseClass :
getSelectBarSons = function(this)
return this.Features
end,
---------------------------------------------------------------------------------------------------------
-- from BaseClass
getParentAct = function(this)
return this
end
}
function classAct.getActivitiesIds(this)
local actActivitiesIds = {}
local k, v = next(this.Features, nil)
while k do
local activitiesIds = {}
if v.getActivitiesIds then
activitiesIds = v:getActivitiesIds()
table.merge(actActivitiesIds, activitiesIds)
end
k, v = next(this.Features, k)
end
return actActivitiesIds
end
function classAct.getWorldPos(this)
return { x = 0, y = 0, z = 0 }
end
----------------------------------------------------------------------------
-- add a line to the event sub menu
function classAct.initLogicEntitiesInstancesMenu(this, subMenu, calledFunction)
local empty = true
local actsTable = r2.Scenario.Acts
for i=0, r2.Scenario.Acts.Size-1 do
local act = r2.Scenario.Acts[i]
if not act:isBaseAct() then
local uc_name = ucstring()
uc_name:fromUtf8(act.Name)
subMenu:addLine(uc_name, "lua", calledFunction.."('".. act.InstanceId .."')", act.InstanceId)
empty = false
end
end
if empty==true then
subMenu:addLine(i18n.get("uiR2EdNoSelelection"), "", "", "")
end
end
----------------------------------------------------------------------------
-- add a line to the event menu
function classAct:getLogicTranslations()
local logicTranslations = {
["ApplicableActions"] = {
["Start Act"] = { menu=i18n.get( "uiR2AA0ActStart" ):toUtf8(),
text=i18n.get( "uiR2AA1ActStart" ):toUtf8()},
},
["Events"] = {
["On Act Started"] = { menu=i18n.get( "uiR2Event0ActStart" ):toUtf8(),
text=i18n.get( "uiR2Event1ActStart" ):toUtf8()},
},
["Conditions"] = {
}
}
return logicTranslations
end
-----------------------------------------------------------------------------
-- eval the used quota for this act alone
function classAct.getUsedQuota(this)
return this:getLocalCost()
end
-----------------------------------------------------------------------------
function classAct.appendInstancesByType(this, destTable, kind)
assert(type(kind) == "string")
--this:delegate():appendInstancesByType(destTable, kind)
r2.Classes.BaseClass.appendInstancesByType(this, destTable, kind)
for key, feature in specPairs(this.Features) do
feature:appendInstancesByType(destTable, kind)
end
end
-----------------------------------------------------------------------------
function classAct.onDelete(this)
if this.User.DeleteInProgress == true then return end
-- assume than on delete can only be called if this act is selected
assert(this:isSameObjectThan(r2:getCurrentAct()))
r2.ScenarioWindow:deleteAct()
end
-----------------------------------------------------------------------------
-- return the left quota to add content into this act
function classAct.getLeftQuota(this)
if this:isBaseAct()
then
local maxValue, maxValue2 = this:getParentScenario():getMaxSecondaryActCost()
local leftQuota = r2.getMaxNpcs() - this:getLocalCost() - maxValue
local leftStaticQuota = r2.getMaxStaticObjects() - this:getLocalStaticCost() - maxValue2
return leftQuota, leftStaticQuota
else
--return this:getParentScenario().Description.MaxEntities - this:getParentScenario():getBaseAct().Cost - this.Cost
local cost = r2.getMaxNpcs() - this:getParentScenario():getBaseAct():getLocalCost() - this:getLocalCost()
local staticCost = r2.getMaxStaticObjects() - this:getParentScenario():getBaseAct():getLocalStaticCost() - this:getLocalStaticCost()
return cost, staticCost
end
end
function classAct.getActId(this)
assert(this)
local parent = this:getParentScenario()
local id = -1;
local k,v = next(parent.Acts, nil)
while k do
id = id + 1
if this:isSameObjectThan(v) then
return id
end
k,v = next(parent.Acts, k)
end
return id -- -1
end
function classAct.getLogicAction(entity, context, action)
assert( action.Class == "ActionStep")
local component = r2:getInstanceFromId(action.Entity)
assert(component)
local rtNpcGrp = r2.Translator.getRtGroup(context, component.InstanceId)
assert(rtNpcGrp)
local firstAction, lastAction = nil, nil
if action.Action.Type == "Start Act" then
firstAction, lastAction = r2.Translator.createAction("dssStartAct", entity:getActId())
assert(firstAction)
assert(lastAction)
end
return firstAction, lastAction
end
function classAct.getLogicEvent(this, context, event)
assert( event.Class == "LogicEntityAction")
local component = this -- r2:getInstanceFromId(event.Entity)
assert(component)
local rtNpcGrp = r2.Translator.getRtGroup(context, component.InstanceId)
assert(rtNpcGrp)
local eventType = tostring(event.Event.Type)
local eventHandler, lastCondition = nil, nil
if eventType == "On Act Started" then
return r2.Translator.createEvent("timer_t0_triggered", "", rtNpcGrp.Id)
end
return eventHandler, firstCondition, lastCondition
end
function classAct.getLogicCondition(this, context, condition)
return nil
end
----------------------------------------------------------------------------
-- Create a controler for the current Act
--
function classAct.pretranslate(this, context)
r2.Translator.createAiGroup(this, context)
end
function classAct.translate(this, context)
entity = this
if this:isBaseAct() then
local baseAct = this:getParentScenario():getBaseAct()
local rtNpcGrpBase = r2.Translator.getRtGroup(context, baseAct.InstanceId)
local rtAction = r2.Translator.createAction("set_scenario_points", rtNpcGrpBase.Id )
r2.Translator.translateAiGroupEvent("timer_t1_triggered", this, context, rtAction)
end
if not this:isBaseAct() then
r2.Translator.translateAiGroup(entity, context)
local rtNpcGrp = r2.Translator.getRtGroup(context, entity.InstanceId)
local baseAct = this:getParentScenario():getBaseAct()
local rtNpcGrpBase = r2.Translator.getRtGroup(context, baseAct.InstanceId)
local index = context.Scenario:getActIndex(this.InstanceId)
local rtAction = r2.Translator.createAction("act_starts", rtNpcGrp.Id, rtNpcGrpBase.Id, index)
r2.Translator.translateAiGroupInitialState(entity, context, rtAction)
end
end
local classLocationVersion = 1
local classLocation =
{
Version = classLocationVersion,
BaseClass="BaseClass",
Name = "Location",
Prop =
{
{Name="IslandName", Type="String"},
{Name="ShortDescription", Type="String"},
{Name="Time", Type="Number"},
{Name="EntryPoint", Type="String"},
{Name="Season", Type="String", DefaultValue=""},
{Name="ManualSeason", Type="Number", WidgetStyle="Boolean", DefaultValue="0" },
},
onCreate = function(this)
this:updateSeason()
end,
onAttrModified = function(this, name)
if not r2:getCurrentAct() then return end
if this.InstanceId == r2:getCurrentAct().LocationId then
if name == "Season" then
this:updateSeason()
end
end
end,
updateSeason = function(this)
-- change season in the editor
-- effect may be seen only at the next teleport message if we're joining a session
local season = this.Season
if this.ManualSeason == 0 then season="Automatic" end
--inspect(season)
r2:setEditorSeason(season)
end,
updateVersion = function(this, scenarioValue, currentValue )
local patchValue = scenarioValue
if patchValue < 1 then
local updateMap = { ["summer"] = "Summer", ["winter"] = "Winter", ["fall"] = "Autumn", ["spring"] = "Spring",
["Summer"] = "Summer", ["Winter"] = "Winter", ["Autumn"] = "Autumn", ["Spring"] = "Spring"}
if (this.ManualSeason == 1 ) then
if updateMap[ this.Season ] then
r2.requestSetNode(this.InstanceId, "Season", updateMap[this.Season])
else
debugInfo("Wrong conversion function")
assert(nil);
end
end
patchValue = 1
end
if patchValue == currentValue then return true end
return false
end,
}
local classState =
{
Name="State",
Prop=
{
{Name="InstanceId", Type="String"},
{Name="Name", Type="String" },
{Name="Behavior",Type="Behavior"}
}
}
r2.registerComponent(classMapDescription)
r2.registerComponent(classScenario)
r2.registerComponent(classAct)
r2.registerComponent(classState)
r2.registerComponent(classLocation)
end
--r2.Features.Act = {}
--
--local feature = r2.Features.Act
--
--function mergeTraduction(localLogicEntityAttributes)
-- local k, v = next(localLogicEntityAttributes, nil)
-- while k do
-- local k2, v2 = next(v, nil)
-- while k2 do
-- if not r2.logicEntityAttributes[k][k2] then
-- r2.logicEntityAttributes[k][k2] = v2
-- end
-- k2, v2 = next(v, k2)
-- end
-- k, v = next(localLogicEntityAttributes, k)
-- end
--end
--
--
--function feature:init()
-- -- register trad
-- local localLogicEntityAttributes = {
-- ["ApplicableActions"] = {
-- ["Start Act"] = i18n.get("uiR2EdStartAct"):toUtf8(),
-- },
-- ["Events"] = {
-- ["On Act Started"] = i18n.get("uiR2EdOnActStarted"):toUtf8(),
-- },
-- ["Conditions"] = {
-- }
-- }
-- mergeTraduction(localLogicEntityAttributes)
--end
--
--feature.init()
--
--r2.Features["Act"] = feature
--
-----------------------------------------------
-- Not Save to disc so not version number needed
r2.registerBasicBricks=function()
local classRtScenario =
{
Name = "RtScenario",
Prop =
{
{Name="Acts", Type="Table"},
{Name="Texts", Type="RtTextManager"},
{Name="PlotItems", Type="Table"},
{Name="Locations", Type="Table"}
}
}
r2.registerComponent(classRtScenario)
local classRtAct =
{
Name="RtAct",
Prop=
{
{Name="Id", Type="String"},
{Name="NpcGrps", Type="Table"},
{Name="FaunaGrps", Type="Table"},
{Name="AiStates", Type="Table"},
{Name="Npcs", Type="Table"},
{Name="Events",Type="Table"},
{Name="Actions", Type="Table"},
{Name="WeatherValue", Type="Number"},
{Name="Name", Type="String"},
{Name="IslandName", Type="String"},
{Name="Season", Type="Number"},
{Name="LocationId", Type="Number"},
{Name="UserTriggers", Type="Table"}
}
}
r2.registerComponent(classRtAct)
local classRtLocation =
{
Name="RtLocation",
Prop=
{
{Name="Id", Type="String"},
{Name="Island", Type="String"},
{Name="EntryPoint", Type="String"},
{Name="Season", Type="Number"},
}
}
r2.registerComponent(classRtLocation)
do
local classRt =
{
Name="RtUserTrigger",
Prop=
{
{Name="Id", Type="String"},
{Name="Name", Type="String"},
{Name="Grp", Type="String"},
{Name="TriggerId", Type="Number"},
}
}
r2.registerComponent(classRt)
end
local classRtNpcGrp =
{
Name = "RtNpcGrp",
Prop =
{
{Name="Id", Type="String"},
{Name="Name", Type="String"},
{Name="Children", Type="Table"},
{Name="AutoSpawn", Type="Number", DefaultValue="1"},
{Name="BotChat_parameters", Type="String"},
{Name="BotEquipment", Type="String"},
{Name="BotSheetClient", Type="String"},
{Name="BotVerticalPos", Type="String", DefaultValue="auto"},
{Name="Count", Type="Number"},
{Name="GrpKeywords", Type="String"},
{Name="AiProfilParams", Type="String"},
{Name="GrpParameters", Type="String"},
}
}
r2.registerComponent(classRtNpcGrp)
local classRtNpc =
{
Name = "RtNpc",
Prop =
{
{Name="Id", Type="String", DefaultValue="" },
{Name="Name", Type="String" },
{Name="Children", Type="Table" },
{Name="ChatParameters", Type="String" },
{Name="Equipment", Type="Table" },
{Name="IsStuck", Type="Number" },
{Name="Keywords", Type="String" },
{Name="Sheet", Type="String" },
{Name="SheetClient", Type="String" },
{Name="BotVerticalPos", Type="String", DefaultValue="auto" },
{Name="Angle", Type="Number" },
{Name="DmProperty", Type="Number"},
{Name="Pt", Type="RtPosition" },
}
}
r2.registerComponent(classRtNpc)
local classRtPosition =
{
Name = "RtPosition",
Prop =
{
{Name="x", Type="Number" },
{Name="y", Type="Number" },
{Name="z", Type="Number" },
}
}
r2.registerComponent(classRtPosition)
local classRtAiState =
{
Name = "RtAiState",
Prop =
{
{Name="Id", Type="String", DefaultValue="" },
{Name="Name", Type="String" },
{Name="Children", Type="Table" },
{Name="AiActivity", Type="String", DefaultValue="no_change" },
{Name="AiMovement", Type="String", DefaultValue="" },
{Name="AiProfileParams", Type="Number" },
{Name="Keywords", Type="String" },
{Name="VerticalPos", Type="String", DefaultValue="auto" },
{Name="Pts", Type="Table" },
{Name="Reactions",Type="Table"}
}
}
r2.registerComponent(classRtAiState)
local classRtNpcEventHandler =
{
Name = "RtNpcEventHandler",
Prop =
{
{Name="Id", Type="String", DefaultValue="" },
{Name="Name",Type="String"},
{Name="Event", Type="String"},
{Name="StatesByName",Type="String"},
{Name="GroupsByName",Type="String"},
{Name="ActionsId", Type="Table"}
}
}
r2.registerComponent(classRtNpcEventHandler)
local classRtNpcEventHandlerAction =
{
Name = "RtNpcEventHandlerAction",
Prop =
{
{Name="Id", Type="String", DefaultValue="" },
{Name="Action", Type="String"},
{Name="Name", Type="String"},
{Name="Parameters", Type="String"},
{Name="Children",Type="Table"},
{Name="Weight",Type="Number",DefaultValue="1"}
}
}
r2.registerComponent(classRtNpcEventHandlerAction)
local classRtFauna =
{
Name= "RtFauna",
Prop=
{
{Name="Id", Type="String", DefaultValue=""},
{Name="Name",Type="String"},
{Name="Pts", Type="Table" },
{Name="Children", Type="Table"}
}
}
r2.registerComponent(classRtFauna)
local classRtGroupFaunaEx =
{
Name="RtGroupFaunaEx",
Prop=
{
{Name="Id",Type="String",DefaultValue=""},
{Name="Name",Type="String"},
{Name="FaunaType",Type="String",DefaultValue="HERBIVORE"},
{Name="Children", Type="Table"}
}
}
r2.registerComponent(classRtGroupFaunaEx)
local classRtFaunaGenericPlace =
{
Name="RtFaunaGenericPlace",
Prop=
{
{Name="Id",Type="String",DefaultValue=""},
{Name="Name",Type="String"},
{Name="FlagFood",Type="String",DefaultValue="true"},
{Name="FlagRest",Type="String",DefaultValue="true"},
{Name="FlagSpawn",Type="String",DefaultValue="true"},
{Name="Index",Type="Number"},
{Name="IndexNext",Type="Table"},
{Name="Place",Type="Place"}
}
}
r2.registerComponent(classRtFaunaGenericPlace)
local classRtPopulation =
{
Name = "RtPopulation",
Prop=
{
{Name="Id",Type="String",DefaultValue=""},
{Name="Name",Type="String"},
{Name="Children",Type="Table"}
}
}
r2.registerComponent(classRtPopulation)
local classRtPeople =
{
Name="RtPeople",
Prop=
{
{Name="Name",Type="String"},
{Name="Count",Type="Number"},
{Name="CreatureCode",Type="String"}
}
}
r2.registerComponent(classRtPeople)
local classRtTextManager =
{
Name="RtTextManager",
Prop=
{
{Name="Id", Type="String"},
{Name="Texts", Type="Table"},
}
}
r2.registerComponent(classRtTextManager)
local classRtEntryText =
{
Name="RtEntryText",
Prop=
{
{Name="Id", Type="String"},
{Name="Text", Type="String"}
}
}
r2.registerComponent(classRtEntryText)
-- Copy struct TMissionItem
local classRtPlotItem =
{
Name = "RtPlotItem",
Prop =
{
{Name="Id", Type="String"},
{ Name="SheetId", Type="Number" },
{ Name="Name", Type="String" },
{ Name="Description", Type="String" },
{ Name="Comment", Type="String" }
}
}
r2.registerComponent(classRtPlotItem)
end
Reference in a new issue View git blame Copy permalink