Khaganat-NeL/khanat-client-data-NeL
2
0
Fork 0
Code Issues 15 Pull requests Projects Releases Packages Wiki Activity
khanat-client-data-NeL/data/ryz/ryz_ring/r2_events.lua

1812 lines
55 KiB
Lua
Raw Normal View History

premiere tentative d'organisation
2016-05-06 10:56:20 +00:00
r2.classLogicAttributes = {}
r2.events = {
uiId = "ui:interface:r2ed_events",
ownCreatedInstances = {},
openFirst = nil,
elementsIdCounter = 0,
elementOrder = false,
maxAndMin = false,
eltTemplateParams = {
selectElt="r2.events:selectElement()",
openEltEditor="",
maxMinElt="",
removeElt="r2.events:removeElementInst()",
colOver="200 150 0 100",
colPushed="200 150 0 255",
multiMaxLine=""
},
elementEditorTemplate = "template_edit_events",
elementInitialName=i18n.get("uiR2EdAction"):toUtf8(),
currentEltUIID = nil, -- initialis<69> quand l'editeur est ouvert ou ferm<72>
logicTranslations = {
["ApplicableActions"] = {},
["Events"] = {},
["Conditions"] = {}
},
selectedLogicEntity,
selectedEventType,
eventTypeWithValue = {
["end of chat"] = "ChatStep",
["start of chat"] = "ChatStep",
["starts chat"] = "ChatStep",
["is in chat"] = "ChatStep",
["begin of activity step"] = "ActivityStep",
["end of activity step"] = "ActivityStep",
["is in activity step"] = "ActivityStep",
["is in activity sequence"] = "ActivitySequence",
["end of activity sequence"] = "ActivitySequence",
["begin activity sequence"] = "ActivitySequence",
["begin of activity sequence"] = "ActivitySequence",
["emits user event"] = "Number",
["user event emitted"] = "Number",
["add seconds"] = "Number",
["sub seconds"] = "Number",
["add scenario points"] = "Number",
},
filteredLogicEntityId = nil,
dismatchWithFilter = 0,
actionOrConditionUIId = nil,
keyWordsColor = "@{FFFF}",
communWordsColor = "@{FFFB}",
filterWordColor = "@{FF0F}",
entityWordColor = "@{F90B}",
maxVisibleLine = 10,
memberManagement = false,
}
-- sequence --------------------------------------------------
function r2.events:currentSequUI()
return getUI(self.uiId):find("sequence_elts")
end
function r2.events:currentSequInstId()
return self:currentSequUI().Env.InstanceId
end
-- initialis<69> quand selection dialog dans menu
function r2.events:setSequUIInstId(sequUI, id)
sequUI.Env.InstanceId = id
end
function r2.events:currentSequInst()
return r2:getInstanceFromId(self:currentSequInstId())
end
-- element ---------------------------------------------------
function r2.events:currentEltUIId()
return self.currentEltUIID
end
function r2.events:currentEltUI()
if self.currentEltUIID then
return getUI(self.currentEltUIID)
end
return nil
end
function r2.events:setCurrentEltUIId(id)
self.currentEltUIID = id
end
function r2.events:currentEltInstId()
if self.currentEltUIID then
return self:currentEltUI().Env.InstanceId
end
return nil
end
function r2.events:currentEltInst()
if self.currentEltUIID and self:currentEltInstId() then
return r2:getInstanceFromId(self:currentEltInstId())
end
return nil
end
-- updated element and/or sequence (not necessary the same as current sequence or element)
function r2.events:updatedSequUI()
return self:currentSequUI()
end
function r2.events:setUpdatedSequUIId(sequUIId)
end
function r2.events:updatedEltUI()
return self:currentEltUI()
end
function r2.events:setUpdatedEltUIId(eltUIId)
end
------------------ INIT EVENTS EDITOR -------------------------
function r2.events:initEditor()
self:mergeLogicTranslations()
end
------------------ TRANSLATION TEXT ---------------------------
function r2.events:getTranslationText(eventCategory, eventType)
if self.logicTranslations[eventCategory][eventType] then
return self.logicTranslations[eventCategory][eventType].text
else
debugInfo(eventType .. " is not translated")
return eventType
end
end
------------------ TRANSLATION IN MENU ------------------------
function r2.events:getTranslationMenu(eventCategory, eventType)
if self.logicTranslations[eventCategory][eventType] then
return ucstring(self.logicTranslations[eventCategory][eventType].menu)
else
debugInfo(eventType .. " is not translated")
return ucstring(eventType)
end
end
-------------------------------------------------
-- Another global map containing all logic attributes per class
function r2.events:registerClassLogicAttributes(class, logicTranslations)
if r2.classLogicAttributes[class] then
r2.print("Logic attributes are already registered for class '" ..class.."'")
return
end
r2.classLogicAttributes[class] = logicTranslations
end
-------------------------------------------------
--Looks for a logic attribute for a given class. If the attribute isn't in the corresponding map, looks
-- in the class's baseclass map
function r2.getLogicAttribute(class, logicCategory, value)
if not class or class == "" then return nil end
local logicAttributes = r2.classLogicAttributes[class]
if not logicAttributes then
--look in parent map
local baseclass = r2.Classes[class].BaseClass
r2.print("Attributes not defined for class '"..class.."' looking in '"..baseclass.."' for inherited attributes")
if baseclass then
return r2.getLogicAttribute(baseclass, logicCategory, value)
end
return nil
end
local attr = logicAttributes[logicCategory][value]
if not attr then
--look in parent map
local baseclass = r2.Classes[class].BaseClass
if baseclass then
return r2.getLogicAttribute(baseclass, logicCategory, value)
end
return nil
end
return attr
end
------------------------------------------------
function r2.events:mergeLogicTranslations()
registerComponentsLogicTranslations = function(localLogicTranslations)
local k, v = next(localLogicTranslations, nil)
while k do
local k2, v2 = next(v, nil)
while k2 do
if not self.logicTranslations[k][k2] then
self.logicTranslations[k][k2] = v2
end
k2, v2 = next(v, k2)
end
k, v = next(localLogicTranslations, k)
end
end
local k, v = next(r2.Classes, nil)
while k do
if v.getLogicTranslations then
local localLogicTranslations = v:getLogicTranslations()
if localLogicTranslations then
self:registerClassLogicAttributes(k, localLogicTranslations)
--registerComponentsLogicTranslations(localLogicTranslations)
else
debugInfo(colorTag(255,0,0).."No Translation for component "..k)
end
end
k, v = next(r2.Classes, k)
end
end
------ OPEN EDITOR ------------------------------------------
function r2.events:openEditor()
local ui = getUI(self.uiId)
if not ui.active then
self:filterEvents()
-- active editor
ui.active = true
ui:updateCoords()
if self.openFirst == nil then
self.openFirst = true
ui:center()
end
else
setTopWindow(ui)
ui:blink(1)
end
end
------ CLOSE EDITOR ------------------------------------------
function r2.events:closeEditor()
local ui = getUI(self.uiId)
ui.active = false
r2.logicUI:closeEditor(r2.events)
end
------ CLEAN EDITOR ------------------------------------------
function r2.events:cleanEditor()
-- reset current dialog and current chat
self:setCurrentEltUIId(nil)
self:setUpdatedSequUIId(nil)
self:setUpdatedEltUIId(nil)
self.elementsIdCounter = 0
local sequenceUI = self:currentSequUI()
assert(sequenceUI)
local eltsList = sequenceUI:find("elements_list")
assert(eltsList)
eltsList:clear()
local dismatchFilterMenu = getUI(self.uiId):find("filterMenu"):find("dismatch_filter")
assert(dismatchFilterMenu)
dismatchFilterMenu.active = false
self.dismatchWithFilter = 0
end
--- UPDATE SEQUENCE UI-------------------------------------------
function r2.events:updateSequenceUI()
local ui = getUI(self.uiId)
assert(ui)
local filterMenuText = ui:find("filterMenu"):find("menu"):find("text")
assert(filterMenuText)
local logicEntity = r2:getInstanceFromId(self.filteredLogicEntityId)
assert(logicEntity)
filterMenuText.uc_hardtext = logicEntity:getDisplayName()
local currentSequ = self:currentSequUI()
assert(currentSequ)
local eltsList = currentSequ:find("elements_list")
assert(eltsList)
for i=0, eltsList.childrenNb-1 do
local elt = eltsList:getChild(i)
assert(elt)
--not element editor
if r2.logicUI:getEltUIInstId(elt) then
self:updateElementUI(elt)
end
end
end
function r2.events:getLogicEntityParent(event)
local logicEntity = event.Parent.Parent.Parent
if logicEntity:isGrouped() and logicEntity:isLeader() then
logicEntity = logicEntity:getParentGroup()
end
return logicEntity
end
function r2.events:filterIsLogicEntityParent(event)
return self.filteredLogicEntityId==self:getLogicEntityParent(event).InstanceId
end
function r2.events:getBehavior(logicEntity)
return logicEntity.Behavior
end
------ SELECT FILTER EVENTS --------------------------------------
function r2.events:filterEvents(logicEntityId)
if logicEntityId==nil then
logicEntityId = r2:getSelectedInstance().InstanceId
end
local logicEntity = r2:getInstanceFromId(logicEntityId)
if logicEntity then
if not self.memberManagement and logicEntity:isGrouped() then --TEMP
logicEntity = logicEntity:getParentGroup() --TEMP
logicEntityId = logicEntity.InstanceId --TEMP
end --TEMP
-- clean editor
self:cleanEditor()
local ui = getUI(self.uiId)
assert(ui)
-- update filter text
local filterMenuText = ui:find("filterMenu"):find("menu"):find("text")
assert(filterMenuText)
filterMenuText.uc_hardtext = logicEntity:getDisplayName()
self.filteredLogicEntityId = logicEntityId
-- recover all events of logic entities in current act
local allEvents = {}
local allLogicEntities = {}
for i=0, r2.Scenario.Acts.Size-1 do
local act = r2.Scenario.Acts[i]
act:appendInstancesByType(allLogicEntities, "LogicEntity")
table.insert(allLogicEntities, act)
end
table.insert(allLogicEntities, r2.Scenario)
for k0, entity in pairs(allLogicEntities) do
local behavior = self:getBehavior(entity)
if not self.memberManagement then -- TEMP
behavior = entity:getBehavior() -- TEMP
end -- TEMP
for e=0, behavior.Actions.Size-1 do
local event = behavior.Actions[e]
assert(event)
allEvents[event.InstanceId] = event
end
end
-- recover events which match with filter
local eventsType = {}
local eventsAction = {}
local eventsCondition = {}
for k, event in pairs(allEvents) do
local isSelected = false
local filterIsLogicEntityParentB = self:filterIsLogicEntityParent(event)
if not self.memberManagement then -- TEMP
filterIsLogicEntityParentB = (event:getLogicEntityParent().InstanceId == logicEntityId) -- TEMP
end -- TEMP
-- events type
if filterIsLogicEntityParentB then
table.insert(eventsType, event.InstanceId)
isSelected = true
end
-- actions
if not isSelected then
for a=0, event.Actions.Size-1 do
local action = event.Actions[a]
assert(action)
if tostring(action.Entity) == logicEntityId then
table.insert(eventsAction, event.InstanceId)
isSelected = true
break
end
end
end
-- conditions
if not isSelected then
for a=0, event.Conditions.Size-1 do
local condition = event.Conditions[a]
assert(condition)
if tostring(condition.Entity) == logicEntityId then
table.insert(eventsCondition, event.InstanceId)
break
end
end
end
end
-- create event editor
self:createElementEditor()
-- display "events type"
for k, eventId in pairs(eventsType) do
local event = r2:getInstanceFromId(eventId)
assert(event)
self:newElementUI(event)
end
-- display "events action"
for k, eventId in pairs(eventsAction) do
local event = r2:getInstanceFromId(eventId)
assert(event)
self:newElementUI(event)
end
-- display "events condition"
for k, eventId in pairs(eventsCondition) do
local event = r2:getInstanceFromId(eventId)
assert(event)
self:newElementUI(event)
end
else
debugInfo("UNKNOWN FILTER EVENTS")
for k, eventId in pairs(allEvents) do
local event = r2:getInstanceFromId(eventId)
assert(event)
self:newElementUI(event)
end
end
r2.logicComponents:selectSequence(r2.events)
end
------ REFRESH FILTER --------------------------------------------
function r2.events:refreshEvents()
self:filterEvents(self.filteredLogicEntityId)
end
------ SELECT ELEMENT --------------------------------------------
function r2.events:selectElement(selectedButtonElt)
r2.logicComponents:selectElement(r2.events, selectedButtonElt)
end
------ CREATE EDITOR -----------------------------------------------
function r2.events:createElementEditor()
r2.logicComponents:createElementEditor(r2.events)
end
------ OPEN ELEMENT EDITOR -----------------------------------------------
function r2.events:updateElementEditor()
local instanceEvent = self:currentEltInst()
if instanceEvent==nil then return end
local ui = getUI(self.uiId)
assert(ui)
local sequenceUI = self:currentSequUI()
assert(sequenceUI)
local eventEditor = sequenceUI:find("edit_element")
assert(eventEditor)
-- editor title
local editorTitleText = eventEditor:find("event_name"):find("name")
assert(editorTitleText)
local logicEntity = self:getLogicEntityParent(instanceEvent)
if not self.memberManagement then --TEMP
logicEntity = instanceEvent:getLogicEntityParent() --TEMP
end --TEMP
assert(logicEntity)
-- when menu text
local when = eventEditor:find("when")
assert(when)
when.Env.InstanceId = logicEntity.InstanceId
local whenMenuText = when:find("text")
assert(whenMenuText)
local coloredName = (logicEntity.InstanceId == self.filteredLogicEntityId)
if coloredName then
eventType = self.filterWordColor
else
eventType = self.communWordsColor
end
local name = "No name"
if logicEntity.getName then
name = logicEntity:getName()
elseif logicEntity.Name then
name = logicEntity.Name
end
eventType = eventType .. name .. " "
if coloredName then eventType = eventType .. self.communWordsColor end
local class = logicEntity.Class
assert(class)
eventType = eventType ..r2.getLogicAttribute(class, "Events", instanceEvent.Event.Type).text
if instanceEvent.Event.Value~="" then
local instance = r2:getInstanceFromId(instanceEvent.Event.Value)
assert(instance)
eventType = eventType .. " '" .. instance:getShortName() .. "'"
end
if instanceEvent.Event.ValueString and instanceEvent.Event.ValueString~="" then
eventType = eventType .. " '" .. instanceEvent.Event.ValueString .. "'"
end
local uc_when_text = ucstring()
uc_when_text:fromUtf8(eventType)
whenMenuText.uc_hardtext_single_line_format = uc_when_text
editorTitleText.uc_hardtext = whenMenuText.hardtext .. " ..."
-- actions
local actionsList = eventEditor:find("actions_list")
assert(actionsList)
actionsList:clear()
if instanceEvent.Actions.Size > 0 then
for i=0, instanceEvent.Actions.Size-1 do
local actionInst = instanceEvent.Actions[i]
local actionUI = self:newActionUI()
actionUI.Env.InstanceId = actionInst.InstanceId
local actionMenuText = actionUI:find("text")
assert(actionMenuText)
if actionInst.Entity~="" and actionInst.Action.Type~="" then
local actionLogicEntity = r2:getInstanceFromId(tostring(actionInst.Entity))
assert(actionLogicEntity)
coloredName = (actionLogicEntity.InstanceId == self.filteredLogicEntityId)
local actionType
if coloredName then
actionType = self.filterWordColor
else
actionType = self.communWordsColor
end
local name = "No name"
if actionLogicEntity.getName then
name = actionLogicEntity:getName()
elseif actionLogicEntity.Name then
name = actionLogicEntity.Name
end
actionType = actionType .. name .. " "
if coloredName then actionType = actionType .. self.communWordsColor end
local class = actionLogicEntity.Class
assert(class)
actionType = actionType ..r2.getLogicAttribute(class, "ApplicableActions", actionInst.Action.Type).text
if actionInst.Action.Value~="" then
local instance = r2:getInstanceFromId(actionInst.Action.Value)
assert(instance)
actionType = actionType .. " '" .. instance:getShortName() .. "'"
end
if actionInst.Action.ValueString and actionInst.Action.ValueString ~= "" then
if string.gfind(actionType, "%%1")() then
actionType = string.gsub(actionType, "%%1", "'"..tostring(actionInst.Action.ValueString).."'")
else
actionType = actionType .. " '" .. tostring(actionInst.Action.ValueString).. "'"
end
end
local uc_action_text = ucstring()
uc_action_text:fromUtf8(actionType)
actionMenuText.uc_hardtext_single_line_format = uc_action_text
end
end
else
self:newActionUI()
end
-- conditions
local conditionsList = eventEditor:find("conditions_list")
assert(conditionsList)
conditionsList:clear()
for i=0, instanceEvent.Conditions.Size-1 do
local conditionInst = instanceEvent.Conditions[i]
local conditionUI = self:newConditionUI()
conditionUI.Env.InstanceId = conditionInst.InstanceId
local conditionMenuText = conditionUI:find("text")
assert(conditionMenuText)
if conditionInst.Entity~="" and conditionInst.Condition.Type~="" then
local conditionLogicEntity = r2:getInstanceFromId(tostring(conditionInst.Entity))
assert(conditionLogicEntity)
coloredName = (conditionLogicEntity.InstanceId == self.filteredLogicEntityId)
local conditionType
if coloredName then
conditionType = self.filterWordColor
else
conditionType = self.communWordsColor
end
conditionType = conditionType .. conditionLogicEntity.Name .. " "
if coloredName then conditionType = conditionType .. self.communWordsColor end
local class = conditionLogicEntity.Class
assert(class)
conditionType = conditionType ..r2.getLogicAttribute(class, "Conditions", conditionInst.Condition.Type).text
if conditionInst.Condition.Value~="" then
local instance = r2:getInstanceFromId(conditionInst.Condition.Value)
assert(instance)
conditionType = conditionType .. " '" .. instance:getShortName() .."'"
end
local uc_condition_text = ucstring()
uc_condition_text:fromUtf8(conditionType)
conditionMenuText.uc_hardtext_single_line_format = uc_condition_text
end
end
self:advancedEditor(((instanceEvent.Actions.Size > 1) or (instanceEvent.Conditions.Size > 0)))
-- match filter?
local matchFilter = self:logicEntityActionMatchFilter(instanceEvent)
local dismatchFilter = eventEditor:find("dismatch_filter")
assert(dismatchFilter)
dismatchFilter.active = not matchFilter
-- valid event?
self:updateValiditySymbol(eventEditor, instanceEvent)
end
function r2.events:updateElementsUI()
local sequenceUI = self:currentSequUI()
assert(sequenceUI)
local eltsList = sequenceUI:find("elements_list")
assert(eltsList)
for i=0,eltsList.childrenNb-1 do
local elementUI = eltsList:getChild(i)
if r2.logicUI:getEltUIInstId(elementUI) then
self:updateElementUI(elementUI)
end
end
end
----- CLOSE ELEMENT EDITOR ---------------------------------------------
function r2.events:closeElementEditor()
r2.logicComponents:closeElementEditor(r2.events)
end
------ NEW ELEMENT INST ------------------------------------------
function r2.events:newElementInst()
r2.requestNewAction(i18n.get("uiR2EDNewEventAction"))
local logicEntity
if self.filteredLogicEntityId~=nil then
logicEntity = r2:getInstanceFromId(self.filteredLogicEntityId)
else
logicEntity = r2:getSelectedInstance()
end
assert(logicEntity)
local logicEvent = r2.newComponent("LogicEntityAction")
-- default event
local defaultEvent
if not self.memberManagement or not logicEntity:isGrouped() then
local class = r2.Classes[logicEntity.Class]
assert(class)
if table.getn(class.Events) > 0 then
defaultEvent = class.Events[1]
else
debugInfo("Empty events table of lua class : "..logicEntity.Class)
return
end
else
messageBox(i18n.get("uiR2EDNoEventCreation"))
return
end
local eventType = r2.newComponent("EventType")
eventType.Type = defaultEvent
logicEvent.Event = eventType
local behavior = self:getBehavior(logicEntity)
if not self.memberManagement then --TEMP
behavior = logicEntity:getBehavior() --TEMP
end --TEMP
r2.requestInsertNode(behavior.InstanceId, "Actions", -1, "", logicEvent)
self.ownCreatedInstances[logicEvent.InstanceId] = true
r2.logicComponents:newElementInst(r2.events)
end
-------- get first event in events list of a class -----------------
function r2.events:hasApplicableActions(logicEntity)
local class = r2.Classes[logicEntity.Class]
assert(class)
-- local eventsTable = {}
-- if categoryEvent=="ApplicableActions" then
-- eventsTable = logicEntity:getApplicableActions()
-- else
-- eventsTable = class[categoryEvent]
-- end
local actionsTable = logicEntity:getApplicableActions()
if table.getn(actionsTable) > 0 then
if logicEntity:isGrouped() then
local groupIndependantEvent
for k, eventType in pairs(actionsTable) do
local menuTitle = r2.getLogicAttribute(logicEntity.Class, "ApplicableActions", eventType)
if menuTitle.groupIndependant==true then
groupIndependantEvent = true
break
end
end
if groupIndependantEvent==nil then
return nil
end
end
else
debugInfo("Empty 'ApplicableActions' table of lua class : "..logicEntity.Class)
return nil
end
return true
end
------ NEW ELEMENT UI ------------------------------------------
function r2.events:newElementUI(newInst)
r2.logicUI:newElementUI(r2.events, newInst, false)
end
------ REMOVE ELEMENT INST ----------------------------------------
function r2.events:removeElementInst()
r2.requestNewAction(i18n.get("uiR2EDRemoveLogicElementAction"))
r2.logicComponents:removeElementInst(r2.events)
r2.requestEndAction()
end
------ REMOVE ELEMENT UI -------------------------------------------
function r2.events:removeElementUI(removedEltUI)
r2.logicUI:removeElementUI(r2.events, removedEltUI)
end
------ UPDATE ELEMENT TITLE -------------------------------------------
function r2.events:updateElementTitle(eventUI)
r2.logicComponents:updateElementTitle(r2.events, eventUI, false)
end
------ UPDATE ELEMENT UI -------------------------------------------
function r2.events:updateElementUI(elementUI)
r2.logicUI:updateElementUI(r2.events, elementUI)
local logicEntityAction = r2:getInstanceFromId(r2.logicUI:getEltUIInstId(elementUI))
assert(logicEntityAction)
local matchFilter = self:logicEntityActionMatchFilter(logicEntityAction)
local dismatchFilter = elementUI:find("dismatch_filter")
assert(dismatchFilter)
if dismatchFilter.active~=not matchFilter then
if matchFilter then
self.dismatchWithFilter = self.dismatchWithFilter-1
else
self.dismatchWithFilter = self.dismatchWithFilter+1
end
end
local dismatchFilterMenu = getUI(self.uiId):find("filterMenu"):find("dismatch_filter")
assert(dismatchFilterMenu)
dismatchFilterMenu.active = (self.dismatchWithFilter>0)
dismatchFilter.active = not matchFilter
-- valid event?
self:updateValiditySymbol(elementUI, logicEntityAction)
end
-------------------------------------------------------------------------------
function r2.events:updateValiditySymbol(elementUI, eventInst)
local invalidEvent = elementUI:find("invalid_event")
assert(invalidEvent)
local validEvent = elementUI:find("valid_event")
assert(validEvent)
local logicAct = eventInst:getLogicAct()
invalidEvent.active = (logicAct==nil)
validEvent.active = (logicAct~=nil and logicAct~=r2:getCurrentAct())
if validEvent.active then
local uc_other_act = ucstring()
uc_other_act:fromUtf8(i18n.get("uiR2EDEventNotInCurrentAct"):toUtf8() .. "'" .. logicAct.Name .. "'")
validEvent.tooltip = uc_other_act
end
end
function r2.events:logicEntityActionMatchFilter(logicEntityAction)
local logicEntity = self:getLogicEntityParent(logicEntityAction)
if not self.memberManagement then --TEMP
logicEntity = logicEntityAction:getLogicEntityParent() --TEMP
end
local matchFilter = (logicEntity.InstanceId==self.filteredLogicEntityId)
if matchFilter then
return true
end
for i=0, logicEntityAction.Actions.Size-1 do
local action = logicEntityAction.Actions[i]
if action.Entity==self.filteredLogicEntityId then
return true
end
end
for i=0, logicEntityAction.Conditions.Size-1 do
local condition = logicEntityAction.Conditions[i]
if condition.Entity==self.filteredLogicEntityId then
return true
end
end
return false
end
--- INIT FILTER MENU ---------------------------------------------------
function r2.events:initFilterMenu()
-- which entity menu initialization
local logicEntityMenu = getUI("ui:interface:r2ed_triggers_menu")
assert(logicEntityMenu)
local logicEntityMenu = logicEntityMenu:getRootMenu()
assert(logicEntityMenu)
logicEntityMenu:reset()
-- entity classes
for k, class in pairs(r2.Classes) do
if class.initLogicEntitiesMenu then class:initLogicEntitiesMenu(logicEntityMenu) end
end
logicEntityMenu:setMaxVisibleLine(self.maxVisibleLine)
-- for each entity classes, list of instances in current act
for c=0,logicEntityMenu:getNumLine()-1 do
logicEntityMenu:addSubMenu(c)
local subMenu = logicEntityMenu:getSubMenu(c)
local entityClass = tostring(logicEntityMenu:getLineId(c))
local class = r2.Classes[entityClass]
if class.initLogicEntitiesInstancesMenu then
class:initLogicEntitiesInstancesMenu(subMenu, "r2.events:filterEvents")
end
subMenu:setMaxVisibleLine(self.maxVisibleLine)
end
r2.logicUI:openLogicMenu(getUICaller())
end
------ INIT EVENT TYPE MENU -------------------------------------------
function r2.events:initEventMenu(categoryEvent)
-- local startTime = nltime.getPreciseLocalTime()
self.actionOrConditionUIId = getUICaller().parent.parent.id
-- which entity menu initialization
local logicEntityMenu = getUI("ui:interface:r2ed_triggers_menu")
assert(logicEntityMenu)
local logicEntityMenu = logicEntityMenu:getRootMenu()
assert(logicEntityMenu)
logicEntityMenu:reset()
-- if a logic entity has been already selected, we give a direct access to this one
local caller = getUI(self.actionOrConditionUIId)
assert(caller)
local logicEntity
local firstLine = 0
if caller.Env.InstanceId ~= nil then
if categoryEvent=="Events" then
logicEntity = r2:getInstanceFromId(caller.Env.InstanceId)
elseif categoryEvent=="ApplicableActions" or categoryEvent=="Conditions" then
local instance = r2:getInstanceFromId(caller.Env.InstanceId)
logicEntity = r2:getInstanceFromId(instance.Entity)
end
end
--local endTime = nltime.getPreciseLocalTime()
--debugInfo(string.format("time for 1 is %f", endTime - startTime))
--startTime = nltime.getPreciseLocalTime()
if logicEntity then
firstLine = 2
local uc_name = ucstring()
uc_name:fromUtf8(logicEntity.Name)
logicEntityMenu:addLine(uc_name, "lua", "r2.events:setLogicEntity('".. logicEntity.InstanceId .."')", logicEntity.InstanceId)
logicEntityMenu:addSeparator()
logicEntityMenu:addSubMenu(0)
local subMenuEventType = logicEntityMenu:getSubMenu(0)
logicEntity:initEventTypeMenu(subMenuEventType, categoryEvent)
if logicEntity.initEventValuesMenu then
logicEntity:initEventValuesMenu(subMenuEventType, categoryEvent)
end
subMenuEventType:setMaxVisibleLine(self.maxVisibleLine)
end
--local endTime = nltime.getPreciseLocalTime()
--debugInfo(string.format("time for 2 is %f", endTime - startTime))
--startTime = nltime.getPreciseLocalTime()
-- entity classes
for k, class in pairs(r2.Classes) do
if class.initLogicEntitiesMenu and table.getn(class[categoryEvent])~=0 then
class:initLogicEntitiesMenu(logicEntityMenu, (categoryEvent=="ApplicableActions"))
end
end
logicEntityMenu:setMaxVisibleLine(self.maxVisibleLine)
--local endTime = nltime.getPreciseLocalTime()
--debugInfo(string.format("time for 3 is %f", endTime - startTime))
--startTime = nltime.getPreciseLocalTime()
-- for each entity classes, list of instances in current act
for c=firstLine,logicEntityMenu:getNumLine()-1 do
logicEntityMenu:addSubMenu(c)
local subMenu = logicEntityMenu:getSubMenu(c)
local entityClass = tostring(logicEntityMenu:getLineId(c))
local class = r2.Classes[entityClass]
if class.initLogicEntitiesInstancesMenu then
class:initLogicEntitiesInstancesMenu(subMenu, "r2.events:setLogicEntity")
--local endTime = nltime.getPreciseLocalTime()
--debugInfo(string.format("time for 6 is %f", endTime - startTime))
--startTime = nltime.getPreciseLocalTime()
-- for each entity, list of its events type
for e=0,subMenu:getNumLine()-1 do
local entityId = tostring(subMenu:getLineId(e))
local entity = r2:getInstanceFromId(entityId)
if entity then
subMenu:addSubMenu(e)
local subMenuEventType = subMenu:getSubMenu(e)
entity:initEventTypeMenu(subMenuEventType, categoryEvent)
--local endTime = nltime.getPreciseLocalTime()
--debugInfo(string.format("time for 7 is %f", endTime - startTime))
--startTime = nltime.getPreciseLocalTime()
if entity.initEventValuesMenu then
entity:initEventValuesMenu(subMenuEventType, categoryEvent)
end
--local endTime = nltime.getPreciseLocalTime()
--debugInfo(string.format("time for 9 is %f", endTime - startTime))
--startTime = nltime.getPreciseLocalTime()
subMenuEventType:setMaxVisibleLine(self.maxVisibleLine)
--local endTime = nltime.getPreciseLocalTime()
--debugInfo(string.format("time for 8 is %f", endTime - startTime))
--startTime = nltime.getPreciseLocalTime()
end
end
end
subMenu:setMaxVisibleLine(self.maxVisibleLine)
end
--local endTime = nltime.getPreciseLocalTime()
--debugInfo(string.format("time for 4 is %f", endTime - startTime))
--startTime = nltime.getPreciseLocalTime()
r2.logicUI:openLogicMenu(getUICaller())
--local endTime = nltime.getPreciseLocalTime()
--debugInfo(string.format("time for 5 is %f", endTime - startTime))
--startTime = nltime.getPreciseLocalTime()
end
----- SET LOGIC ENTITY (selected in menu ) -------------------------------------------
function r2.events:setLogicEntity(entityId)
self.selectedLogicEntity = entityId
end
----- SET EVENT TYPE ------------------------------------------------
function r2.events:setEventType(eventType, endRequest, categoryEvent)
self.selectedEventType = eventType
if endRequest==tostring(true) then
if categoryEvent=="Events" then self:setEvent("")
elseif categoryEvent=="ApplicableActions" then self:setAction("")
elseif categoryEvent=="Conditions" then self:setCondition("")
end
end
end
----- SET EVENT VALUE ------------------------------------------------
function r2.events:setEventValue(instanceId, categoryEvent, optionalValueString)
if categoryEvent=="Events" then self:setEvent(instanceId, optionalValueString)
elseif categoryEvent=="ApplicableActions" then self:setAction(instanceId, optionalValueString)
elseif categoryEvent=="Conditions" then self:setCondition(instanceId, optionalValueString)
end
end
---- SET EVENT -----------------------------------------------------------------------
function r2.events:setEvent(valueInstId, optionalValueString)
r2.requestNewAction(i18n.get("uiR2EDSetEventAction"))
local eventInst = self:currentEltInst()
assert(eventInst)
local oldLogicEntity = self:getLogicEntityParent(eventInst)
if not self.memberManagement then
oldLogicEntity = eventInst:getLogicEntityParent()
end
assert(oldLogicEntity)
local newLogicEntity = r2:getInstanceFromId(self.selectedLogicEntity)
assert(newLogicEntity)
if oldLogicEntity~=newLogicEntity then
local index = r2.logicComponents:searchElementIndex(eventInst)
index = index - 1
if index >= 0 then
local oldBehavior = self:getBehavior(oldLogicEntity)
local newBehavior = self:getBehavior(newLogicEntity)
if not self.memberManagement then --TEMP
oldBehavior = oldLogicEntity:getBehavior() --TEMP
newBehavior = newLogicEntity:getBehavior() --TEMP
end
r2.requestMoveNode(oldBehavior.InstanceId, "Actions", index,
newBehavior.InstanceId, "Actions", -1)
end
end
r2.requestSetNode(eventInst.Event.InstanceId, "Type", self.selectedEventType)
r2.requestSetNode(eventInst.Event.InstanceId, "Value", r2.RefId(valueInstId))
if optionalValueString then
r2.requestSetNode(eventInst.Event.InstanceId, "ValueString", optionalValueString)
elseif eventInst.ValueString and eventInst.ValueString ~="" then
r2.requestSetNode(eventInst.Event.InstanceId, "ValueString", optionalValueString)
end
self.selectedLogicEntity = nil
self.selectedEventType = nil
end
------ SET ACTION ------------------------------------------------------
function r2.events:setAction(valueInstId, optionalValueString)
r2.requestNewAction(i18n.get("uiR2EDSetEventActionAction"))
local eventInst = self:currentEltInst()
assert(eventInst)
local actionLogicEntity = r2:getInstanceFromId(self.selectedLogicEntity)
assert(actionLogicEntity)
local caller = getUI(self.actionOrConditionUIId)
assert(caller)
local action
if caller.Env.InstanceId == nil then
action = r2.newComponent("ActionStep")
r2.requestInsertNode(eventInst.InstanceId, "Actions",-1,"", action)
caller.Env.InstanceId = action.InstanceId
else
action = r2:getInstanceFromId(caller.Env.InstanceId)
end
assert(action)
r2.requestSetNode(action.InstanceId, "Entity", r2.RefId(self.selectedLogicEntity))
r2.requestSetNode(action.Action.InstanceId, "Type", self.selectedEventType)
r2.requestSetNode(action.Action.InstanceId, "Value", r2.RefId(valueInstId))
if optionalValueString then
r2.requestSetNode(action.Action.InstanceId, "ValueString", optionalValueString)
elseif action.Action.ValueString and action.Action.ValueString ~= "" then
r2.requestSetNode(action.Action.InstanceId, "ValueString", "")
end
self.selectedLogicEntity = nil
self.selectedEventType = nil
self.actionOrConditionUIId = nil
end
------ SET CONDITION ------------------------------------------------------
function r2.events:setCondition(valueInstId)
r2.requestNewAction(i18n.get("uiR2EDSetEventConditionAction"))
local eventInst = self:currentEltInst()
assert(eventInst)
local actionLogicEntity = r2:getInstanceFromId(self.selectedLogicEntity)
assert(actionLogicEntity)
local caller = getUI(self.actionOrConditionUIId)
assert(caller)
local condition
if caller.Env.InstanceId == nil then
condition = r2.newComponent("ConditionStep")
r2.requestInsertNode(eventInst.InstanceId, "Conditions",-1,"", condition)
caller.Env.InstanceId = condition.InstanceId
else
condition = r2:getInstanceFromId(caller.Env.InstanceId)
end
assert(condition)
r2.requestSetNode(condition.InstanceId, "Entity", r2.RefId(self.selectedLogicEntity))
r2.requestSetNode(condition.Condition.InstanceId, "Type", self.selectedEventType)
r2.requestSetNode(condition.Condition.InstanceId, "Value", r2.RefId(valueInstId))
self.selectedLogicEntity = nil
self.selectedEventType = nil
self.actionOrConditionUIId = nil
end
---- EDITOR ELEMENT IN ADVANCED OR EASY MODE
function r2.events:advancedEditor(advancedMode)
local instanceEvent = self:currentEltInst()
if instanceEvent==nil then return end
local sequenceUI = self:currentSequUI()
assert(sequenceUI)
local eventEditor = sequenceUI:find("edit_element")
assert(eventEditor)
local addActionButton = eventEditor:find("what_happens"):find("add")
assert(addActionButton)
addActionButton.active = advancedMode
local conditionsGr = eventEditor:find("conditions")
assert(conditionsGr)
conditionsGr.active = advancedMode
local addConditionButton = conditionsGr:find("add")
assert(addConditionButton)
addConditionButton.active = advancedMode
local advancedButton = eventEditor:find("advanced")
advancedButton.active = not advancedMode
local conditionsList = eventEditor:find("conditions_gr")
assert(conditionsList)
conditionsList.active = (instanceEvent.Conditions.Size > 0)
end
-- NEW ACTION -------------------------------------------------
function r2.events:newActionUI()
local sequenceUI = self:currentSequUI()
assert(sequenceUI)
local eventEditor = sequenceUI:find("edit_element")
assert(eventEditor)
local actionsList = eventEditor:find("actions_list")
assert(actionsList)
local idActionUI = "action" .. actionsList.childrenNb
local params = {
id=idActionUI, x="0", y="0", sizeref="w",
posparent="", posref="TL TL", w="0", h="20",
params_l="r2.events:initEventMenu('ApplicableActions')",
remove_menu="r2.events:removeActionInst()", params_over="r2.events:activeTrashButton('true')",
}
local newActionUI = createGroupInstance("menu_trash_template", actionsList.id, params)
assert(newActionUI)
actionsList:addChild(newActionUI)
actionsList.parent:updateCoords()
newActionUI.Env.InstanceId = nil
return newActionUI
end
-- NEW CONDITION -------------------------------------------------
function r2.events:newConditionUI()
local sequenceUI = self:currentSequUI()
assert(sequenceUI)
local eventEditor = sequenceUI:find("edit_element")
assert(eventEditor)
local conditionsGr = eventEditor:find("conditions_gr")
assert(conditionsGr)
conditionsGr.active = true
local conditionsList = eventEditor:find("conditions_list")
assert(conditionsList)
local idConditionUI = "condition" .. conditionsList.childrenNb
local params = {
id=idConditionUI, x="0", y="0", sizeref="w",
posparent="", posref="TL TL", w="0", h="20",
params_l="r2.events:initEventMenu('Conditions')",
remove_menu="r2.events:removeConditionInst()", params_over="r2.events:activeTrashButton('false')",
}
local newConditionUI = createGroupInstance("menu_trash_template", conditionsList.id, params)
assert(newConditionUI)
conditionsList:addChild(newConditionUI)
conditionsList.parent:updateCoords()
newConditionUI.Env.InstanceId = nil
return newConditionUI
end
--- ACTIVE TRASH BUTTON ----------------------------------------------------------
function r2.events:activeTrashButton(actionsList)
local overMenuTrash = getUICaller().parent.parent
assert(overMenuTrash)
local trashButtonCaller = overMenuTrash:find("remove_menu")
assert(trashButtonCaller)
local menuTrashList = overMenuTrash.parent
assert(menuTrashList)
if actionsList==tostring(true) and menuTrashList.childrenNb==1 then return end
for i=0, menuTrashList.childrenNb-1 do
local menuTrash = menuTrashList:getChild(i)
assert(menuTrash)
local trashButton = menuTrash:find("remove_menu")
assert(trashButton)
if trashButton.active then
if trashButton.id == trashButtonCaller.id then return end
trashButton.active = false
break
end
end
trashButtonCaller.active = true
end
--- REMOVE CONDITION INSTANCE -----------------------------------------------------
function r2.events:removeConditionInst()
r2.requestNewAction(i18n.get("uiR2EDRemoveEventConditionAction"))
local menuTrash = getUICaller().parent.parent.parent.parent
assert(menuTrash)
local menuTrashList = menuTrash.parent
assert(menuTrashList)
if menuTrash.Env.InstanceId~=nil then
r2.requestEraseNode(menuTrash.Env.InstanceId, "", -1)
else
menuTrashList:delChild(menuTrash)
end
end
--- REMOVE ACTION INSTANCE -----------------------------------------------------
function r2.events:removeActionInst()
r2.requestNewAction(i18n.get("uiR2EDRemoveEventActionAction"))
local menuTrash = getUICaller().parent.parent.parent.parent
assert(menuTrash)
local menuTrashList = menuTrash.parent
assert(menuTrashList)
if menuTrash.Env.InstanceId~=nil then
r2.requestEraseNode(menuTrash.Env.InstanceId, "", -1)
else
menuTrashList:delChild(menuTrash)
end
end
--------------------------------------------------------------------------------------------------
-------------------------------- LOGIC ENTITY DisplayerProperties -------------------------
--------------------------------------------------------------------------------------------------
local logicEntityPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
------------------------------------------------
function logicEntityPropertySheetDisplayerTable:onPostCreate(instance)
end
------------------------------------------------
function logicEntityPropertySheetDisplayerTable:onErase(instance)
local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, instance)
if elementUI then
r2.events:removeElementUI(elementUI)
end
end
------------------------------------------------
function logicEntityPropertySheetDisplayerTable:onPreHrcMove(instance)
end
------------------------------------------------
function logicEntityPropertySheetDisplayerTable:onPostHrcMove(instance)
end
------------------------------------------------
function logicEntityPropertySheetDisplayerTable:onFocus(instance, hasFocus)
end
------------------------------------------------
function logicEntityPropertySheetDisplayerTable:onSelect(instance, isSelected)
if not isSelected then
r2.events:closeEditor()
end
end
------------------------------------------------
local oldOnAttrModified = logicEntityPropertySheetDisplayerTable.onAttrModified
function logicEntityPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
if attributeName == "Name" then
local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, instance)
if elementUI then
r2.events:updateElementUI(elementUI)
end
end
oldOnAttrModified(self, instance, attributeName)
end
------------------------------------------------
function r2:logicEntityPropertySheetDisplayer()
return logicEntityPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end
--------------------------------------------------------------------------------------------------
-------------------------------- LOGIC ENTITY ACTION DisplayerProperties -------------------------
--------------------------------------------------------------------------------------------------
local logicEntityActionPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
------------------------------------------------
function logicEntityActionPropertySheetDisplayerTable:onPostCreate(instance)
local filterIsLogicEntityParentB = r2.events:filterIsLogicEntityParent(instance)
if not r2.events.memberManagement then
filterIsLogicEntityParentB = (instance:getLogicEntityParent().InstanceId==r2.events.filteredLogicEntityId)
end
if filterIsLogicEntityParentB then
r2.events:newElementUI(instance)
end
end
------------------------------------------------
function logicEntityActionPropertySheetDisplayerTable:onErase(instance)
instance.User.Deleted = true
local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, instance)
if elementUI then
r2.events:removeElementUI(elementUI)
end
end
------------------------------------------------
function logicEntityActionPropertySheetDisplayerTable:onPreHrcMove(instance)
end
------------------------------------------------
function logicEntityActionPropertySheetDisplayerTable:onPostHrcMove(instance)
local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, instance)
local filterIsLogicEntityParentB = r2.events:filterIsLogicEntityParent(instance)
if not r2.events.memberManagement then
filterIsLogicEntityParentB = (instance:getLogicEntityParent().InstanceId==r2.events.filteredLogicEntityId)
end
if elementUI then
r2.events:updateElementUI(elementUI)
elseif filterIsLogicEntityParentB then
r2.events:newElementUI(instance)
end
end
------------------------------------------------
function logicEntityActionPropertySheetDisplayerTable:onFocus(instance, hasFocus)
end
------------------------------------------------
function logicEntityActionPropertySheetDisplayerTable:onSelect(instance, isSelected)
end
------------------------------------------------
function logicEntityActionPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, instance)
if elementUI then
r2.events:updateElementUI(elementUI)
end
end
------------------------------------------------
function r2:logicEntityActionPropertySheetDisplayer()
return logicEntityActionPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end
--------------------------------------------------------------------------------------------------
-------------------------------- EVENT TYPE DisplayerProperties -----------------------
--------------------------------------------------------------------------------------------------
local eventTypePropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
------------------------------------------------
function eventTypePropertySheetDisplayerTable:onPostCreate(instance)
end
------------------------------------------------
function eventTypePropertySheetDisplayerTable:onErase(instance)
end
------------------------------------------------
function eventTypePropertySheetDisplayerTable:onPreHrcMove(instance)
end
------------------------------------------------
function eventTypePropertySheetDisplayerTable:onPostHrcMove(instance)
end
------------------------------------------------
function eventTypePropertySheetDisplayerTable:onFocus(instance, hasFocus)
end
------------------------------------------------
function eventTypePropertySheetDisplayerTable:onSelect(instance, isSelected)
end
------------------------------------------------
function eventTypePropertySheetDisplayerTable:onAttrModified(instance, attributeName)
end
------------------------------------------------
function eventTypePropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
r2.requestEraseNode(instance.Parent.InstanceId, "", -1)
end
------------------------------------------------
function eventTypePropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
if targetAttrName == "Name" then
local eventInst = instance.Parent
assert(eventInst.Class=="LogicEntityAction")
local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, eventInst)
if elementUI then
r2.events:updateElementUI(elementUI)
end
end
end
------------------------------------------------
function r2:eventTypePropertySheetDisplayer()
return eventTypePropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end
--------------------------------------------------------------------------------------------------
-------------------------------- ACTION STEP DisplayerProperties -----------------------
--------------------------------------------------------------------------------------------------
local actionStepPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
------------------------------------------------
function actionStepPropertySheetDisplayerTable:onPostCreate(instance)
end
------------------------------------------------
function actionStepPropertySheetDisplayerTable:onErase(instance)
end
------------------------------------------------
function actionStepPropertySheetDisplayerTable:onPreHrcMove(instance)
end
------------------------------------------------
function actionStepPropertySheetDisplayerTable:onPostHrcMove(instance)
end
------------------------------------------------
function actionStepPropertySheetDisplayerTable:onFocus(instance, hasFocus)
end
------------------------------------------------
function actionStepPropertySheetDisplayerTable:onSelect(instance, isSelected)
end
------------------------------------------------
function actionStepPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
end
------------------------------------------------
function actionStepPropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
if refIdName == "Entity" then
r2.requestEraseNode(instance.InstanceId, "", -1)
end
end
------------------------------------------------
function actionStepPropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
if targetAttrName == "Name" then
local eventInst = instance.Parent.Parent
assert(eventInst.Class=="LogicEntityAction")
local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, eventInst)
if elementUI then
r2.events:updateElementUI(elementUI)
end
end
end
------------------------------------------------
function actionStepPropertySheetDisplayerTable:onTargetInstancePostHrcMove(instance, refIdName, refIdIndexInArray)
if refIdName=="Entity" then
r2.requestSetNode(instance.InstanceId, "Entity", r2.RefId(""))
r2.requestSetNode(instance.Action.InstanceId, "Type", "")
r2.requestSetNode(instance.Action.InstanceId, "Value", r2.RefId(""))
end
end
------------------------------------------------
function r2:actionStepPropertySheetDisplayer()
return actionStepPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end
--------------------------------------------------------------------------------------------------
-------------------------------- ACTION TYPE DisplayerProperties -----------------------
--------------------------------------------------------------------------------------------------
local actionTypePropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
------------------------------------------------
function actionTypePropertySheetDisplayerTable:onPostCreate(instance)
end
------------------------------------------------
function actionTypePropertySheetDisplayerTable:onErase(instance)
end
------------------------------------------------
function actionTypePropertySheetDisplayerTable:onPreHrcMove(instance)
end
------------------------------------------------
function actionTypePropertySheetDisplayerTable:onPostHrcMove(instance)
end
------------------------------------------------
function actionTypePropertySheetDisplayerTable:onFocus(instance, hasFocus)
end
------------------------------------------------
function actionTypePropertySheetDisplayerTable:onSelect(instance, isSelected)
end
------------------------------------------------
function actionTypePropertySheetDisplayerTable:onAttrModified(instance, attributeName)
end
------------------------------------------------
function actionTypePropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
r2.requestSetNode(instance.InstanceId, "Type", "")
r2.requestSetNode(instance.InstanceId, "Value", r2.RefId(""))
end
------------------------------------------------
function actionTypePropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
if targetAttrName == "Name" then
local eventInst = instance.Parent.Parent.Parent
assert(eventInst.Class=="LogicEntityAction")
local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, eventInst)
if elementUI then
r2.events:updateElementUI(elementUI)
end
end
end
------------------------------------------------
function r2:actionTypePropertySheetDisplayer()
return actionTypePropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end
--------------------------------------------------------------------------------------------------
-------------------------------- CONDITION STEP DisplayerProperties -----------------------
--------------------------------------------------------------------------------------------------
local conditionStepPropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
------------------------------------------------
function conditionStepPropertySheetDisplayerTable:onPostCreate(instance)
end
------------------------------------------------
function conditionStepPropertySheetDisplayerTable:onErase(instance)
end
------------------------------------------------
function conditionStepPropertySheetDisplayerTable:onPreHrcMove(instance)
end
------------------------------------------------
function conditionStepPropertySheetDisplayerTable:onPostHrcMove(instance)
end
------------------------------------------------
function conditionStepPropertySheetDisplayerTable:onFocus(instance, hasFocus)
end
------------------------------------------------
function conditionStepPropertySheetDisplayerTable:onSelect(instance, isSelected)
end
------------------------------------------------
function conditionStepPropertySheetDisplayerTable:onAttrModified(instance, attributeName)
end
------------------------------------------------
function conditionStepPropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
if refIdName == "Entity" then
r2.requestEraseNode(instance.InstanceId, "", -1)
end
end
------------------------------------------------
function conditionStepPropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
if targetAttrName == "Name" then
local eventInst = instance.Parent.Parent
assert(eventInst.Class=="LogicEntityAction")
local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, eventInst)
if elementUI then
r2.events:updateElementUI(elementUI)
end
end
end
------------------------------------------------
function r2:conditionStepPropertySheetDisplayer()
return conditionStepPropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end
--------------------------------------------------------------------------------------------------
-------------------------------- CONDITION TYPE DisplayerProperties -----------------------
--------------------------------------------------------------------------------------------------
local conditionTypePropertySheetDisplayerTable = clone(r2:propertySheetDisplayer())
------------------------------------------------
function conditionTypePropertySheetDisplayerTable:onPostCreate(instance)
end
------------------------------------------------
function conditionTypePropertySheetDisplayerTable:onErase(instance)
end
------------------------------------------------
function conditionTypePropertySheetDisplayerTable:onPreHrcMove(instance)
end
------------------------------------------------
function conditionTypePropertySheetDisplayerTable:onPostHrcMove(instance)
end
------------------------------------------------
function conditionTypePropertySheetDisplayerTable:onFocus(instance, hasFocus)
end
------------------------------------------------
function conditionTypePropertySheetDisplayerTable:onSelect(instance, isSelected)
end
------------------------------------------------
function conditionTypePropertySheetDisplayerTable:onAttrModified(instance, attributeName)
end
------------------------------------------------
function conditionTypePropertySheetDisplayerTable:onTargetInstanceEraseRequested(instance, refIdName, refIdIndexInArray)
r2.requestSetNode(instance.InstanceId, "Type", "")
r2.requestSetNode(instance.InstanceId, "Value", r2.RefId(""))
end
------------------------------------------------
function conditionTypePropertySheetDisplayerTable:onTargetInstanceAttrModified(instance, refIdName, refIdIndexInArray, targetAttrName, targetAttrIndexInArray)
if targetAttrName == "Name" then
local eventInst = instance.Parent.Parent.Parent
assert(eventInst.Class=="LogicEntityAction")
local elementUI = r2.logicUI:findElementUIFromInstance(r2.events, eventInst)
if elementUI then
r2.events:updateElementUI(elementUI)
end
end
end
------------------------------------------------
function r2:conditionTypePropertySheetDisplayer()
return conditionTypePropertySheetDisplayerTable -- returned shared displayer to avoid wasting memory
end
Reference in a new issue Copy permalink