khanat-client-data-NeL/data/ryz/ryz_ring/r2_ui_event_handlers.lua

1394 lines
46 KiB
Lua
Raw Normal View History

2016-05-06 10:56:20 +00:00
--------------
--------------
-- GROUPING --
--------------
--------------
-- TODO nico : find a better file organisation for ui & logic handling
-- TODO nico : most of these global function should be made class members
-- TODO nico : some other part are API to the C++ : these would better fit in a separate, dedicated file.
r2.MaxGroupRadius = 20
function r2.checkGroupDistance(instanceId, targetId)
assert(instanceId)
if not targetId then targetId = instanceId end
assert(targetId)
local target = r2:getInstanceFromId(targetId)
local npc = r2:getInstanceFromId(instanceId)
local group = target.ParentInstance
assert(group)
-- The two npc are not grouped
if not group:isKindOf("NpcGrpFeature") then
local leader = target
local npcPosX = npc.Position.x
local npcPosY = npc.Position.y
local leaderPosX = leader.Position.x
local leaderPosY = leader.Position.y
local x = (npcPosX - leaderPosX)^2 --* (npcPosX - leaderPosX)
local y = (npcPosY - leaderPosY)^2 --* (npcPosY - leaderPosY)
local dist = math.sqrt(x + y)
if dist > r2.MaxGroupRadius then return false end
return true
end
local size = table.getn(group.Components)
local i = 0
for i = 0, size-1 do
local leader = group.Components[i]
if npc and leader and npc.Position and leader.Position then
local npcPosX = npc.Position.x
local npcPosY = npc.Position.y
local leaderPosX = leader.Position.x
local leaderPosY = leader.Position.y
local x = (npcPosX - leaderPosX)^2 --* (npcPosX - leaderPosX)
local y = (npcPosY - leaderPosY)^2 --* (npcPosY - leaderPosY)
local dist = math.sqrt(x + y)
if dist > r2.MaxGroupRadius then return false end
end
end
return true
end
function r2.checkLeaderDistAndUngroup(instanceId)
local ok = r2.checkGroupDistance(instanceId)
if not ok then r2:ungroup(movedNpc) end
end
------------------------------------------------------------------------------------
-- test if an object can be grouped with 'target'
-- 'src' must be a an entity
-- 'target' may be another entity or a group
function r2:testCanGroup(src, target)
if target:isSameObjectThan(src) then return false end -- can't group itself
if src:getCategory() ~= target:getCategory() or
src:getSubCategory() ~= target:getSubCategory()
then
return false
end
if target:isKindOf("Npc") then
if target:isBotObject() or target:isPlant() then return false end -- can't group bot objects together
-- if instance is in a group, then can't goup with an instance of the same group
if not src:isInDefaultFeature() then
return target.ParentInstance ~= src.ParentInstance
end
if r2.checkGroupDistance(src.InstanceId, target.InstanceId) == false then return false end
return true
elseif target:isKindOf("NpcGrpFeature") then
-- can group if src is not already in the same group
if not src:isInDefaultFeature() then
return target ~= src.ParentInstance
end
local leader = r2:getInstanceFromId(target.Components[0].InstanceId)
assert(leader)
if r2.checkGroupDistance(src.InstanceId, leader.InstanceId) == false then return false end
return true
end
end
function r2:testCanGroupSelectedInstance(targetInstanceId)
return r2:testCanGroup(r2:getSelectedInstance(), r2:getInstanceFromId(targetInstanceId))
end
------------------------------------------------------------------------------------
-- group an entity with another entity or group
-- 'src' must be a an entity
-- 'target' may be another entity or a group
function r2:group(src, target)
r2.requestNewAction(i18n.get("uiR2EDGroupAction"))
if target:getParentAct() ~= src:getParentAct() then
src:togglePermanentCurrentAct(false)
end
--debugInfo(colorTag(0, 255, 255) .. "Grouping instance " .. src.InstanceId .. " with instance or group " .. target.InstanceId)
-- remove previous behavior (when grouped, only the group has a behavior, not his members)
-- if target has no group then create a new group
local targetGroup
if target:isKindOf("NpcGrpFeature") then
targetGroup = target
-- recompute relative position
src:requestMakePosRelativeTo(targetGroup)
elseif target:isInDefaultFeature() then
assert(target:isKindOf("Npc"))
--r2.requestSetNode(target.Behavior.InstanceId, "Type", "")
-- create a new group
-- debugInfo(colorTag(255, 255, 0) .. "Creating new group")
local newGroup = r2.newComponent("NpcGrpFeature")
local uc_groupName = ucstring()
uc_groupName:fromUtf8(r2.PaletteIdToGroupTranslation[src.Base].. " " .. i18n.get("uiR2EDNameGroup"):toUtf8())
local groupName = r2:genInstanceName(uc_groupName):toUtf8()
newGroup.Name = groupName
--r2.requestSetNode(target.Behavior.InstanceId, "Type", "")
--newGroup.Behavior.Type = src.Behavior.Type
--newGroup.Behavior.ZoneId = src.Behavior.ZoneId
__tmpNewGroup = newGroup
--runCommand("luaObject", "__tmpNewGroup", maxDepth)
__tmpNewGroup = nil
-- create new group
--r2.requestInsertNode(src:getParentAct().InstanceId, "Features", -1, "", newGroup)
r2.requestInsertNode(target:getParentAct().InstanceId, "Features", -1, "", newGroup)
-- move the target instance into that group
r2.requestMoveNode(target.InstanceId, "", -1, newGroup.InstanceId, "Components", -1)
targetGroup = newGroup
else
--debugInfo(colorTag(255, 0, 255) .. "Group already created")
targetGroup = target.ParentInstance
-- recompute relative position
src:requestMakePosRelativeTo(targetGroup)
end
-- is src is in a group then ungroup before doing the move
if not src:isInDefaultFeature() then
r2:ungroup(src)
end
-- nico patch : locaaly mark the entity so that it can't be grouped again before net msg is received
src.User.Grouped = true
-- force update of the available options
if src == r2:getSelectedInstance() then
r2.ContextualCommands:update()
end
-- move the selected instance into the target group
r2.requestMoveNode(src.InstanceId, "", -1, targetGroup.InstanceId, "Components", -1)
--r2.requestSetNode(src.Behavior.InstanceId, "Type", "")
end
------------------------------------------------------------------------------------
-- group the selected instance with the given instance
function r2:groupSelectedInstance(instanceId)
r2:group(r2:getSelectedInstance(), r2:getInstanceFromId(instanceId))
end
------------------------------------------------------------------------------------
-- ungroup a npc
function r2:ungroup(instance)
r2.requestNewAction(i18n.get("uiR2EDUngroupAction"))
if instance == nil then
debugInfo(colorTag(255, 255, 0) .. "No selected instance")
return
end
local target = instance:getParentAct():getDefaultFeature()
--debugInfo(colorTag(255, 255, 0) .. "Parent group size is " .. tostring(instance.Parent.Size))
if instance.Parent.Size <= 2 then
-- debugInfo(colorTag(255, 255, 0) .. "Empty group left, removing it")
-- this was the last object of the group, so remove the group
local groupId = instance.ParentInstance.InstanceId
local parentTable = instance.Parent -- must keep pointer on parent because parent will be changed
-- a son is moved
for i = parentTable.Size - 1, 0, -1 do
parentTable[i]:requestMakePosRelativeTo(target)
r2.requestMoveNode(parentTable[i].InstanceId, "", -1, instance:getParentAct():getDefaultFeature().InstanceId, "Components", -1)
end
--debugInfo(colorTag(255, 255, 0) .. "request erase node")
r2.requestEraseNode(groupId, "", -1)
else
-- make pos relative to the new target
instance:requestMakePosRelativeTo(target)
r2.requestMoveNode(instance.InstanceId, "", -1, target.InstanceId, "Components", -1)
--give a new Behavior to the degrouped member
--r2.requestSetNode(instance.InstanceId,"Behavior",r2.newComponent("Behavior"))
end
end
------------------------------------------------------------------------------------
-- set instance as the new leader of its group
function r2:setAsGroupLeader(instance)
r2.requestNewAction(i18n.get("uiR2EDSetAsLeaderAction"))
if instance:isInDefaultFeature() then
debugInfo("Instance is not in a group, can't set as leader")
return
end
--local oldLeader = instance.ParentInstance.Components[0]
--if (oldLeader:isSameObjectThan(instance)) then return end
-- copy behaviour from the entity (becomes the group behavior)
--r2:setActivityType(instance.Behavior, oldLeader.Behavior.Type, oldLeader.Behavior.ZoneId)
--r2:setActivityType(oldLeader.Behavior, "", "")
-- put leader in first position of the group
r2.requestMoveNode(instance.InstanceId, "", -1, instance.ParentInstance.InstanceId, "Components", 0)
end
-------------------
-------------------
-- NPC BEHAVIOR --
-------------------
-------------------
------------------------------------------------------------------------------------
function r2:testCanPickZoneForNPC(instanceId)
local targetInstance = r2:getInstanceFromId(instanceId)
--if targetInstance:isKindOf("WayPoint") or targetInstance:isKindOf("RegionVertex") or
-- targetInstance:isKindOf("Region") or targetInstance:isKindOf("Road")
if targetInstance:isKindOf("RegionVertex") or targetInstance:isKindOf("Region") then
return true
end
return false
end
------------------------------------------------------------------------------------
function r2:testCanPickRoadForNPC(instanceId)
local targetInstance = r2:getInstanceFromId(instanceId)
if targetInstance:isKindOf("WayPoint") or targetInstance:isKindOf("Road")
then
return true
end
return false
end
------------------------------------------------------------------------------------
--if instance is a grouped npc, return the leader's behavior
--else, return the npc's behavior
function r2:getBehavior(instance)
return r2:getLeader(instance).Behavior
end
------------------------------------------------------------------------------------
function r2:getLeader (instance)
--local grouped = not instance:isInDefaultFeature()
local grouped = instance:isGrouped()
if grouped == true then
local group = instance.ParentInstance
assert(group ~=nil)
instance = group.Components[0]
elseif instance:isKindOf("NpcGrpFeature") then
instance = instance.Components[0]
end
return instance
end
------------------------------------------------------------------------------------
--the arguments must be verified before calling this function
--function r2:setActivityType(behaviorObject, activity, zoneInstanceId)
-- r2.requestSetNode(behaviorObject.InstanceId, "Type", activity)
-- r2.requestSetNode(behaviorObject.InstanceId, "ZoneId", zoneInstanceId)
--end
------------------------------------------------------------------------------------
--function r2:affectZoneToNPC(npcInstanceId, zoneInstanceId)
-- local npcInstance = r2:getInstanceFromId(npcInstanceId)
-- if npcInstance == nil then
-- debugInfo("No target npc")
-- return
-- end
-- local behavior = r2:getBehavior(npcInstance)
-- local activity
-- local targetInstance = r2:getInstanceFromId(zoneInstanceId)
-- if targetInstance:isKindOf("WayPoint") or targetInstance:isKindOf("RegionVertex") then
-- debugInfo(colorTag(255, 255, 0) .. "Selecting parent from WayPoint of RegionVertex")
-- targetInstance = targetInstance.ParentInstance
-- end
-- r2:blink(targetInstance)
-- if targetInstance:isKindOf("Road") then
-- activity = "follow_route"
-- else
-- activity = "wander"
-- end
-- local act = npcInstance:getParentAct()
-- if act~= nil
-- then
--debugInfo(colorTag(255,0,0).."act class: "..act.Class)
-- else
-- debugInfo(colorTag(255,0,0).."act niiil!! ")
-- end
-- r2:setActivityType(behavior,activity,targetInstance.InstanceId)
--end
function r2:affectZoneToSelectedNPC(zoneInstanceId)
local npcInstanceId = r2:getLeader(r2:getSelectedInstance()).InstanceId
--r2:affectZoneToNPC(npcInstanceId, zoneInstanceId)
r2:setBehaviorToNPC(npcInstanceId, zoneInstanceId, "Wander")
end
function r2:affectRestZoneToSelectedNPC(zoneInstanceId)
local npcInstanceId = r2:getLeader(r2:getSelectedInstance()).InstanceId
--r2:affectZoneToNPC(npcInstanceId, zoneInstanceId)
r2:setBehaviorToNPC(npcInstanceId, zoneInstanceId, "Rest In Zone")
end
function r2:affectFeedZoneToSelectedNPC(zoneInstanceId)
local npcInstanceId = r2:getLeader(r2:getSelectedInstance()).InstanceId
--r2:affectZoneToNPC(npcInstanceId, zoneInstanceId)
r2:setBehaviorToNPC(npcInstanceId, zoneInstanceId, "Feed In Zone")
end
function r2:affectHuntZoneToSelectedNPC(zoneInstanceId)
local npcInstanceId = r2:getLeader(r2:getSelectedInstance()).InstanceId
--r2:affectZoneToNPC(npcInstanceId, zoneInstanceId)
r2:setBehaviorToNPC(npcInstanceId, zoneInstanceId, "Hunt In Zone")
end
function r2:affectGuardZoneToSelectedNPC(zoneInstanceId)
local npcInstanceId = r2:getLeader(r2:getSelectedInstance()).InstanceId
--r2:affectZoneToNPC(npcInstanceId, zoneInstanceId)
r2:setBehaviorToNPC(npcInstanceId, zoneInstanceId, "Guard Zone")
end
------------------------------------------------------------------------------------
function r2:createZoneAndAffectBehaviorToNPC(startX, startY, startZ, primLook, primInvalidLook, primCanCloseLook, affectFunction, activity)
if affectFunction == nil then
dumpCallStack(1)
assert(false)
end
r2.requestNewPendingMultiAction(i18n.get("uiR2EDAddActivityAction"), 3)
-- TODO nico : use co-routine here instead of the callback stuff...
local npcInstanceId = r2:getSelectedInstance().InstanceId
local selectInstance = false
local params =
{
Look = primLook,
InvalidLook = primInvalidLook,
CanCloseLook = primCanCloseLook,
Vertices = { { x = startX, y = startY, z = startZ } }, -- start with single vertex where the user clicked
CookieKey = "CreateFunc", -- special function called by the road/region displayer when it is created
CookieValue = function(primitive)
-- this is a pending action with 3 steps here
affectFunction(r2, npcInstanceId, primitive.InstanceId, activity)
end,
SelectInstance = selectInstance, -- when road or place is created to associate new activity to a NPC,
-- it must not be selected
OnCancel = function()
r2.requestCancelAction()
end
}
if params.CanCloseLook and params.CanCloseLook.Shape == r2.PrimRender.Shape.ClosedPolyLine then
params.Type = "Region"
else
params.Type = "Route"
end
r2:setCurrentTool("R2::CToolDrawPrim", params)
--debugInfo("createZoneAndAffectBehaviorToNPC END")
end
------------------------------------------------------------------------------------
function r2:createZoneAndAffectZoneToNPC(startX, startY, startZ)
r2:createZoneAndAffectBehaviorToNPC(startX, startY, startZ, r2.PrimRender.RegionCreateLook, r2.PrimRender.RegionCreateInvalidLook, r2.PrimRender.RegionCreateCanCloseLook, r2.setBehaviorToNPC, "Wander")
end
function r2:createRestZoneAndAffectZoneToNPC(startX, startY, startZ)
r2:createZoneAndAffectBehaviorToNPC(startX, startY, startZ, r2.PrimRender.RegionCreateLook, r2.PrimRender.RegionCreateInvalidLook, r2.PrimRender.RegionCreateCanCloseLook, r2.setBehaviorToNPC, "Rest In Zone")
end
function r2:createFeedZoneAndAffectZoneToNPC(startX, startY, startZ)
r2:createZoneAndAffectBehaviorToNPC(startX, startY, startZ, r2.PrimRender.RegionCreateLook, r2.PrimRender.RegionCreateInvalidLook, r2.PrimRender.RegionCreateCanCloseLook, r2.setBehaviorToNPC, "Feed In Zone")
end
function r2:createHuntZoneAndAffectZoneToNPC(startX, startY, startZ)
r2:createZoneAndAffectBehaviorToNPC(startX, startY, startZ, r2.PrimRender.RegionCreateLook, r2.PrimRender.RegionCreateInvalidLook, r2.PrimRender.RegionCreateCanCloseLook, r2.setBehaviorToNPC, "Hunt In Zone")
end
function r2:createGuardZoneAndAffectZoneToNPC(startX, startY, startZ)
r2:createZoneAndAffectBehaviorToNPC(startX, startY, startZ, r2.PrimRender.RegionCreateLook, r2.PrimRender.RegionCreateInvalidLook, r2.PrimRender.RegionCreateCanCloseLook, r2.setBehaviorToNPC, "Guard Zone")
end
------------------------------------------------------------------------------------
function r2:setBehaviorToNPC(npcInstanceId, zoneInstanceId, activity)
local npcInstance = r2:getInstanceFromId(npcInstanceId)
if npcInstance == nil then return end
local behavior = r2:getBehavior(npcInstance)
local targetInstance = r2:getInstanceFromId(zoneInstanceId)
if targetInstance:isKindOf("WayPoint") or targetInstance:isKindOf("RegionVertex") then
zoneInstanceId = targetInstance.ParentInstance.InstanceId
end
local act = npcInstance:getParentAct()
if act~= nil
then
--debugInfo(colorTag(255,0,0).."act class: "..act.Class)
else
debugInfo(colorTag(255,0,0).."act niiil!! ")
end
r2.activities:initEditorAfterFirstCall()
local tableInit = {}
tableInit.Activity = activity
tableInit.ActivityZoneId = zoneInstanceId
if activity=="Follow Route" or activity=="Repeat Road" or activity=="Patrol" then
tableInit.TimeLimit = "No Limit"
tableInit.TimeLimitValue = "0"
else
tableInit.TimeLimit = "Few Sec"
tableInit.TimeLimitValue = "20"
end
if activity=="Repeat Road" or activity=="Patrol" then
tableInit.RoadCountLimit = "2"
end
-- if current display mode for prim is 'hide all', then force to 'contextual' at
if r2.PrimDisplayVisible == false then
r2:primDisplayShowContextual()
displaySystemInfo(i18n.get("uiR2EDPrimDisplayModeChangedToContextual"), 'BC')
end
if not r2.activities:newElementInst(tableInit) then return end
end
function r2:setBehaviorToSelectedNPC(zoneInstanceId, activity)
local npcInstanceId = r2:getLeader(r2:getSelectedInstance()).InstanceId
r2:setBehaviorToNPC(npcInstanceId, zoneInstanceId, activity)
end
------------------------------------------------------------------------------------
function r2:setBehaviorFollowRouteToNPC(roadInstanceId)
r2:setBehaviorToSelectedNPC(roadInstanceId, "Follow Route")
end
function r2:createRouteAndSetBehaviorFollowRouteToNPC(startX, startY, startZ)
r2:createZoneAndAffectBehaviorToNPC(startX, startY, startZ, r2.PrimRender.RoadCreateLook, r2.PrimRender.RoadCreateInvalidLook, nil, self.setBehaviorToNPC, "Follow Route")
end
------------------------------------------------------------------------------------
function r2:setBehaviorPatrolRouteToNPC(roadInstanceId)
r2:setBehaviorToSelectedNPC(roadInstanceId, "Patrol")
end
function r2:createRouteAndSetBehaviorPatrolRouteToNPC(startX, startY, startZ)
r2:createZoneAndAffectBehaviorToNPC(startX, startY, startZ, r2.PrimRender.RoadCreateLook, r2.PrimRender.RoadCreateInvalidLook, nil, self.setBehaviorToNPC, "Patrol")
end
------------------------------------------------------------------------------------
function r2:setBehaviorRepeatRoadToNPC(roadInstanceId)
r2:setBehaviorToSelectedNPC(roadInstanceId, "Repeat Road")
end
function r2:createRoadAndSetBehaviorRepeatRoadToNPC(startX, startY, startZ)
r2:createZoneAndAffectBehaviorToNPC(startX, startY, startZ, r2.PrimRender.RoadCreateLook, r2.PrimRender.RoadCreateInvalidLook, nil, self.setBehaviorToNPC, "Repeat Road")
end
------------------------------------------------------------------------------------
function r2:setNPCStandInPlace(instance)
r2.activities:initEditorAfterFirstCall()
local tableInit = {}
tableInit.Activity = "Stand Still"
tableInit.ActivityZoneId = ""
tableInit.TimeLimit = "Few Sec"
tableInit.TimeLimitValue = "20"
if not r2.activities:newElementInst(tableInit) then return end
end
----------------
----------------
-- MENU SETUP --
----------------
----------------
------------------------------------------------------------------------------------
function r2:selectParent(index)
local parent = r2:getSelectedInstance()
for i = 1,index do
parent = parent.ParentInstance
if parent == nil then return end
end
r2:setSelectedInstanceId(parent.InstanceId)
end
-------------------
-------------------
-- COPY AND PASTE --
-------------------
-------------------
------------------------------------------------------------------------------------
-- called by C++ when copy has been pressed (key or ui button)
function r2:copy()
local selection = r2:getSelectedInstance()
if selection == nil then
displaySystemInfo(i18n.get("uiR2EDCantCopyEmptySelection"), "BC")
return
end
if not selection:isCopyable() then
displaySystemInfo(i18n.get("uiR2EDSelectionDoNotSupportCopy"), "BC")
return
end
r2.ClipBoard = selection:copy()
r2.ClipBoardSrcInstanceId = selection.InstanceId
r2.ClipBoardDisplayName = selection:getDisplayName()
displaySystemInfo(concatUCString(selection:getDisplayName(), i18n.get("uiR2EDSelectionCopied")), "BC")
end
------------------------------------------------------------------------------------
-- called by C++ when copy has been pressed (key or ui button)
function r2:paste()
r2.requestNewAction(concatUCString(i18n.get("uiR2EDPasteAction"), r2.ClipBoardDisplayName))
if r2.ClipBoard == nil then
displaySystemInfo(i18n.get("uiR2EDEmptyClipBoard"), "BC")
return
end
-- call the paste function (not a method here)
local newCopy = r2.Classes[r2.ClipBoard.Class].newCopy(r2.ClipBoard)
r2.requestNewAction(concatUCString(i18n.get("uiR2EDPasteAction"), r2.ClipBoardDisplayName))
r2.Classes[r2.ClipBoard.Class].paste(newCopy, true, r2.ClipBoardSrcInstanceId)
r2.requestEndAction()
end
-- tmp tmp for debug
function doublePaste()
debugInfo("1 " .. tostring(r2.UIMainLoop.LeftQuotaModified))
r2:paste()
debugInfo("2 " .. tostring(r2.UIMainLoop.LeftQuotaModified))
r2:paste()
debugInfo("3 " .. tostring(r2.UIMainLoop.LeftQuotaModified))
end
-- tmp tmp for debug
function testPaste()
for k = 1, 99 do
r2:paste()
end
end
--r2.CuttedSelectionId = "" -- instance id for the selection to be cutted
--
------------------------------------------------------------------------------------
--function r2:getCuttedSelection()
-- return r2:getInstanceFromId(self.CuttedSelectionId)
-- end
--------------------------------------------------------------------------------------
--function r2:cut(instance)
-- local oldSelection = r2:getCuttedSelection()
-- if oldSelection and oldSelection.DisplayerUI then
-- oldSelection.DisplayerUI:onCut(oldSelection, false) -- not cut anymore
-- end
-- if instance then
-- r2.CuttedSelectionId = instance.InstanceId
-- else
-- r2.CuttedSelectionId = ""
-- end
-- local newSelection = r2:getCuttedSelection()
-- if newSelection and newSelection.DisplayerUI then
-- newSelection.DisplayerUI:onCut(newSelection, true) -- new instance being cut
-- end
--end
--
--------------------------------------------------------------------------------------
--function r2:paste()
-- local target = r2:getSelectedInstance()
-- local src = r2:getCuttedSelection()
-- assert(target)
-- assert(src)
-- r2:cut(nil)
-- -- check that target accept the paste
-- assert(target.accept)
-- local destArray = target:accept(src)
-- -- do the move
-- if target.insert ~= nil then
-- -- if an 'insert' then use it to do the insertion
-- target:insert(src)
-- else
-- -- else just move the node at the end of the array
-- assert(type(destArray) == "string")
-- r2.requestMoveNode(src.InstanceId, "", -1, target.InstanceId, destArray, -1)
-- end
--end
------------------------
------------------------
-- INSTANCE SELECTION --
------------------------
------------------------
------------------------------------------------------------------------------------
-- called by the framework when an instance is selected
function r2:onSelectInstance(instance)
--local st = nltime.getPreciseLocalTime()
if instance then
instance:onSelect()
-- reset slect bar type
r2.SelectBar.InstancesType = instance:getSelectBarType()
end
if r2.isPropertyWindowVisible() then
r2:showProperties(instance)
end
r2.CustomBBox:updateUI()
r2.ContextualCommands:setupToolbar(instance)
r2.MiniToolbar:setupToolbar(instance)
if not instance then
r2.ContextualCommands:setupMenu(nil)
end
r2.SelectBar:touch()
r2.SelectBar:getBar().active = (instance ~= nil and not instance.Ghost)-- ensure that 'active' is properly set for the select bar
-- (do not wait per frame update)
getUI("ui:interface:r2ed_select_bar"):updateCoords()
getUI("ui:interface:r2ed_contextual_toolbar_new"):updateCoords()
getUI("ui:interface:r2ed_mini_activity_view"):updateCoords()
--local et = nltime.getPreciseLocalTime()
--debugInfo("select instance : " .. tostring(1000 * (et - st)) .." ms")
end
------------------------------------------------------------------------------------
--function r2:showEditOrTestButton(isEdition)
-- if isEdition == nil then
-- debugInfo(debug.traceback())
-- end
-- local editButton = getUI("ui:interface:r2ed_toolbar_admin:r2ed_tool_go_edition")
-- if editButton then editButton.active = not isEdition end
-- local testButton = getUI("ui:interface:r2ed_toolbar_admin:r2ed_tool_go_test")
-- if testButton then testButton.active = isEdition end
--end
------------------------------------------------------------------------------------
--function r2:setEditorMode(isEdition)
-- -- tmp hack here to know what is the current mode
-- if isEdition then
-- r2:setupUIForEdition()
-- else
-- r2:setupUIForTest()
-- end
-- --r2:showEditOrTestButton(isEdition)
-- r2.IsEdition = isEdition
--end
---------------
---------------
-- MAIN MENU --
---------------
---------------
------------------------------------------------------------------------------------
function r2:popMainMenu()
r2:setCurrentTool('')
local menuName = select(r2.Mode == "Edit", "ui:interface:r2ed_main_menu", "ui:interface:r2ed_main_menu_animation")
--runAH(nil, "active_menu", "menu=" .. menuName)
launchContextMenuInGame(menuName)
local menu = getUI(menuName)
assert(menu)
local function buildKeyName(action, params)
local keyName = ucstring(runExpr(string.format("getKey('%s', '%s')", action, params)))
assert(isUCString(keyName))
if keyName == i18n.get("uiNotAssigned") then
-- no associated key...
return keyName
else
local result = concatUCString(ucstring("(") , keyName, ucstring(")"))
--debugInfo(result:toUtf8())
return result
end
end
-- fill menu entries common to edition & test
menu:find("preferences_key").t.uc_hardtext = buildKeyName("show_hide", "game_config")
menu:find("keys_key").t.uc_hardtext = buildKeyName("show_hide", "keys")
--menu:find("debug_console_key").t.uc_hardtext = buildKeyName("show_hide", "debug_info")
menu:find("chat_window_key").t.uc_hardtext = buildKeyName("show_hide", "main_chat")
menu:find("quit_key").t.uc_hardtext = buildKeyName("quit_ryzom_now", "")
menu:find("mail_box_key").t.uc_hardtext = buildKeyName("show_hide", "mailbox")
menu:find("guild_forum_key").t.uc_hardtext = buildKeyName("show_hide", "guild_forum")
-- fill name of key for each menu entry
if r2.Mode == "Edit" then
menu:find("go_test_key").t.uc_hardtext = buildKeyName("r2ed_try_go_test", "")
menu:find("palette_key").t.uc_hardtext = buildKeyName("show_hide", "r2ed_palette")
menu:find("scenario_key").t.uc_hardtext = buildKeyName("show_hide", "r2ed_scenario")
menu:find("cust_bbox").active = (config.R2EDExtendedDebug == 1)
else
menu:find("stop_test_key").t.uc_hardtext = buildKeyName("r2ed_stop_test", "")
menu:find("stop_test").active = (r2.AccessMode == "Editor")
end
if r2.Mode ~= "Edit" then
menu:find("live").active = not (r2.AccessMode == "Editor")
menu:find("stop_live").active = not (r2.AccessMode == "Editor")
menu:find("player_admin").active = not (r2.AccessMode == "Editor")
end
menu:find("map_key").t.uc_hardtext = buildKeyName("show_hide", "map")
menu:find("debug_console").active = (config.R2EDExtendedDebug == 1)
menu:find("fixed_lighting_bm").bm.texture = select(r2:getFixedLighting(), "r2_icon_light_on_small.tga", "r2_icon_light_off_small.tga")
menu:find("toggle_fixed_lighting").hardtext = select(r2:getFixedLighting(), "uiR2EDTurnLightOff", "uiR2EDTurnLightOn")
-- setup position
local scrW, scrH = getWindowSize()
menu:updateCoords()
menu.x = scrW - menu.w_real
menu.y = 28
menu:updateCoords()
end
-- called by main menu in edition mode to go to test mode
function r2:tryGoTest()
-- remove any keyboard focus so that any editbox properties will be updated correctly
resetCaptureKeyboard()
r2.acts.deleteOldScenario = true
r2:defaultUIDisplayer():storeClosedTreeNodes()
if r2:getLeftQuota() < 0 then
messageBox(i18n.get("uiR2EDCantGoTest"))
return
end
-- freeze go test in menu & button
local goTestButton = getUI("ui:interface:r2ed_toolbar"):find("r2ed_tool_start").unselected.button
local goTestMenu = getUI("ui:interface:r2ed_main_menu"):find("go_test")
if not goTestButton.frozen or goTest.grayed then
goTestButton.frozen = true
goTestMenu.grayed = true
runAH(nil, "r2ed_go_test", "")
end
end
------------------------------
------------------------------
-- NO MORE ROOM IN SCENARIO --
------------------------------
------------------------------
-- called by C++ (or lua) to signal that there's no more room to create new entities
function r2:makeRoomMsg()
displaySystemInfo(i18n.get("uiR2EDMakeRoom"), "BC")
end
local instanceTrees = nil -- private to r2:getInstanceFromUIUnderMouse
-- test if mouse is currently over a widget in the ui that represents an entity in the scenario (used by the pick tool)
-- TODO nico : put this in the cpp API !!!
function r2:getInstanceIdFromUIUnderMouse()
-- implemented for the scenario tree only for now ...
-- build pointers on all tree if not already done
if instanceTrees == nil then
instanceTrees = {}
table.insert(instanceTrees, getUI("ui:interface:r2ed_scenario"):find("content_tree_list"))
local maxNumActs = getDefine('r2ed_max_num_additionnal_acts')
for i = 0, r2:getMaxNumberOfAdditionnalActs() - 1 do
table.insert(instanceTrees, getUI("ui:interface:r2ed_scenario"):find("act_tree_" .. tostring(i)))
table.insert(instanceTrees, getUI("ui:interface:r2ed_scenario"):find("macro_act_tree_" .. tostring(i)))
end
end
-- look in all scenario trees ....
for k, v in pairs(instanceTrees) do
if v and v.active then
local node = v:getNodeUnderMouse()
if node then
return node.Id
end
end
end
return nil
end
----------
----------
-- ACTS --
----------
----------
-- called by C++ when a new act has been selected
function r2:onActChanged(previousAct, currentAct)
-- update the scenario window
r2.ScenarioWindow:updateUIFromCurrentAct()
-- update the select bar
r2.SelectBar:touch()
if r2:isScenarioUpdating() == 1 then
return
end
-- tp if change location
local baseAct = r2.Scenario:getBaseAct()
-- change position
if previousAct and currentAct and baseAct then
local previousActInstanceId = tostring(r2.Scenario.User.SelectedActInstanceId);
local previousLocationInstanceId = tostring(r2.Scenario.User.SelectedLocationInstanceId)
local currentActInstanceId = tostring(currentAct.InstanceId)
local currentActLocationInstanceId = tostring(currentAct.LocationId)
if currentAct.InstanceId ~= tostring(baseAct.InstanceId) then
r2.Scenario.User.SelectedActInstanceId = tostring(currentAct.InstanceId)
r2.Scenario.User.SelectedLocationInstanceId = tostring(currentAct.LocationId)
debugInfo("Location id: " ..tostring(currentAct.LocationId))
if ( r2.Scenario.User.SelectedLocationInstanceId ~= previousLocationInstanceId) then
local actIndex = 0
local k,v = next(r2.Scenario.Acts)
while k do
if tostring(v.InstanceId) == tostring(currentAct.InstanceId) then
debugInfo("::BEFORE TP::Location id: " ..tostring(currentAct.LocationId))
r2.requestSetStartingAct(actIndex)
r2.requestTpToEntryPoint(actIndex)
end
actIndex = actIndex + 1
k,v = next(r2.Scenario.Acts, k)
end
end
end
end
end
------------------
------------------
-- EDITOR MODES --
------------------
------------------
-- called by C ++ : cleanup tasks when the editor is released
function r2:onFinalRelease()
r2.DMGift:cancel() -- if a dm gift was current, cancel it
end
-- called by C ++ when current mode of the editor is about to change
function r2:onPreModeChanged()
r2.DMGift:cancel() -- if a dm gift was current, cancel it
end
-- Called by the C++ framework when there's a mode change between editing, dm etc
-- the r2.Mode variable is changed to one of the following:
-- 'Edit' for editing mode
-- 'Test' for test mode
-- 'DM' for DM mode
-- 'GoingToDM' when switching from editing to dm mode (when the transition screen is displayed)
-- 'BackToEditing' when switching from dm/test mode to editing (when the transition screen is displayed)
function r2:onModeChanged()
-- if a form was displayed, just cancel it
if r2.CurrentForm and r2.CurrentForm.active then
r2:cancelForm(r2.CurrentForm)
end
-- if we're back in edition and there's an error message left, display it now
if r2.Mode == "Edit" and r2.LastTranslationErrorMsg ~= nil then
local str = r2.LastTranslationErrorMsg
assert(type(str) == "string")
local ucStringMsg = ucstring("Translation Error")
--ucStringMsg:fromUtf8(r2.LastTranslationErrorMsg)
displaySystemInfo(ucStringMsg, "BC")
messageBox(str)
r2.LastTranslationErrorMsg = nil
end
-- reset the list af acts and triggers until they are received
if mode == "Edit" then
r2.AnimGlobals:reset()
end
end
---------------------------------------------------------------------------------------------
-------------
-------------
-- WEATHER --
-------------
-------------
-- pop the weather edition dialog in test mode
function r2:changeWeatherDialog()
local function onOk(form)
setWeatherValue(true) -- back to auto weather
-- send request message to dss
local newWeatherValue = select(form.ManualWeather == 1, form.WeatherValue + 1, 0)
if newWeatherValue ~= getDbProp("SERVER:WEATHER:VALUE") then
r2.requestSetWeather(newWeatherValue) -- predicted weather
end
--if form.Season ~= getDbProp("SERVER:SEASON:VALUE") then
-- r2.requestSetSeason(form.Season)
--end
end
local function onCancel(form)
setWeatherValue(true) -- back to auto weather
end
local params =
{
WeatherValue = getWeatherValue() * 1022,
ManualWeather = select(getDbProp("SERVER:WEATHER:VALUE") ~= 0, 1, 0),
--Season = getServerSeason()
}
r2:doForm("ChangeWeatherForm", params, onOk, onCancel)
end
-- teleport
-- tpPosition when player click on the minimap
-- Whe can not use the /a Position command because we need admin power to do it
function r2:activeTeleportTool()
local function posOk(x, y, z)
if config.Local == 1 then
runCommand("pos", x, y, z);
else
r2.requestTpPosition(x, y, z)
end
end
local function posCancel()
debugInfo("Cancel teleport pos")
end
r2:choosePos("", posOk, posCancel, "teleport", "r2ed_tool_can_pick.tga", "r2ed_tool_pick.tga")
end
-- teleport
-- tpPosition when player click on the minimap
-- Whe can not use the /a Position command because we need admin power to do it
function r2:teleportToTarget()
local target = r2:getSelectedInstance()
if not target then return end
local pos = r2.getWorldPos(target)
local x = pos.x
local y = pos.y
local z = pos.z
local x2, y2, z2 = r2:getUserEntityPosition()
local dx = (x - x2)^2 --* (npcPosX - leaderPosX)
local dy = (y - y2)^2 --* (npcPosY - leaderPosY)
local dist = math.sqrt(dy + dx)
if dist > 300 then return end
if config.Local == 1 then
runCommand("pos", x, y, z);
else
r2.requestTpPosition(x, y, z)
end
end
---------------------------------------------------------------------------------------------
------------------------
------------------------
-- TOOLS CONTEXT HELP --
------------------------
------------------------
-- call by C++ to change the context help that is displayed for the current tool
function r2:setToolContextHelp(ucHelp)
--debugInfo(tostring(ucHelp))
local helpGroup = getUI("ui:interface:r2ed_tool_context_help")
helpGroup.t.uc_hardtext = ucHelp
helpGroup.t:updateCoords()
helpGroup.w = helpGroup.t.w
helpGroup:invalidateCoords()
end
-- call by C++ to display a message saying that the max number of points has been reached
-- while drawing a primitive
function r2:noMoreRoomLeftInPrimitveMsg()
local keyName = ucstring(runExpr("getKey('r2ed_context_command', 'commandId=delete')"))
local msg = concatUCString(i18n.get("uiR2EDNoMoreRoomInPrimStart"),
keyName,
i18n.get("uiR2EDNoMoreRoomInPrimEnd"))
displaySystemInfo(msg, "TAGBC")
end
---------------------------------------------------------------------------------------------
--------------------
--------------------
-- ANIMATION TIME --
--------------------
--------------------
function r2:updateAnimBarActions(...)
-- forward to the real anim bar
r2.ui.AnimBar:updateActions(arg)
end
---------------------------------------------------------------------------------------------
------------------------
------------------------
-- UNDO / REDO EVENTS --
------------------------
------------------------
-- called by C++ when an action has been undone
function r2:onUndo(actionUCName)
debugInfo("*undo*")
displaySystemInfo(concatUCString(i18n.get("uiR2EDUndoing"), actionUCName), "BC")
r2.ToolUI:updateUndoRedo()
end
-- called by C++ when an action has been redone
function r2:onRedo(actionUCName)
debugInfo("*redo*")
displaySystemInfo(concatUCString(i18n.get("uiR2EDRedoing"), actionUCName), "BC")
r2.ToolUI:updateUndoRedo()
end
-- called by C++ when a new action has been added in the action historic
function r2:onNewActionAddedInHistoric()
debugInfo("*new action*")
r2.ToolUI:updateUndoRedo()
end
-- called by C++ when an action new pending action has begun
function r2:onCancelActionInHistoric()
r2.ToolUI:updateUndoRedo()
end
-- called by C++ when a new pending action has begun
function r2:onPendingActionBegin()
r2.ToolUI:updateUndoRedo()
end
-- called by C++ when an undo was attempted but failed because there were no actions left in the historic
function r2:onCantUndo(actionUCName)
displaySystemInfo(i18n.get("uiR2EDCantUndo"), "BC")
end
-- called by C++ when a redo was attempted but failed because there are no more actions at the end of the historic
function r2:onCantRedo(actionUCName)
displaySystemInfo(i18n.get("uiR2EDCantRedo"), "BC")
end
-- called by C++ when the action historic has been cleared
-- this may happen after scenario version update
function r2:onClearActionHistoric()
r2.ToolUI:updateUndoRedo()
end
---------------------------------------------------------------------------------------------
------------------------
------------------------
-- DISPLAY MODE MENU --
------------------------
------------------------
-- call by the toolabr button to pop the 'display mode' menu
function r2:popDisplayModeMenu()
local menuName = "ui:interface:r2ed_primitive_display"
local menu = getUI(menuName)
launchContextMenuInGame(menuName)
-- setup position
local parentIcon = getUI("ui:interface:r2ed_toolbar:r2ed_tool_display_mode")
local scrW, scrH = getWindowSize()
--
menu:find("freeze_all").grayed = not r2.PrimDisplayVisible
menu:find("freeze_all").checked = r2.PrimDisplayFrozen
menu:find("unfreeze_all").grayed = not r2.PrimDisplayVisible
menu:find("unfreeze_all").checked = not r2.PrimDisplayFrozen
menu:find("hide_all").checked = not r2.PrimDisplayVisible
menu:find("show_contextual").checked = (r2.PrimDisplayVisible and r2.PrimDisplayContextualVisibility)
menu:find("show_all").checked = (r2.PrimDisplayVisible and not r2.PrimDisplayContextualVisibility)
--
menu:setPosRef("TL TL")
menu:updateCoords()
menu.x = parentIcon.x_real
menu.y = parentIcon.y_real - scrH
menu:updateCoords()
end
local scratchDisplayModeTableSrc = {} -- 'reserve' for list of objects we want to change display mode
local scratchDisplayModeTableDest = {}
-- reset the display mode to 'Visibl' for all objects in all acts
function r2:resetDisplayModeForAllObjects()
local objList = scratchDisplayModeTableSrc -- alias
table.clear(objList)
r2.Scenario:getSons(objList)
r2.requestNewAction(i18n.get("uiR2EDChangeDisplayAction"))
for k, v in pairs(objList) do
if v:isKindOf("WorldObject") then
v.DisplayerVisual.DisplayMode = 0
end
end
end
----------------------------------------------------------------
-- primitive display mode menu handlers
-- current display mode for primitive
-- NB : these flags may be accessed by C++ when a new route or zone is drawn, to switch 'to display all' mode
-- which isdone by calling 'r2:primDisplayShowAll'
r2.PrimDisplayMode = 0 -- Visible
-- is contextual selection on for primitives ?
r2.PrimDisplayFrozen = false
r2.PrimDisplayVisible = true
r2.PrimDisplayContextualVisibility = false
-- 0, Visible
-- 1, Hidden
-- 2, Frozen
-- 3, Locked
function r2:getPrimDisplayMode()
if not r2.PrimDisplayVisible then
return 1
else
if r2.PrimDisplayFrozen then
return 2
else
return 0
end
end
end
function r2:updatePrimDisplayMode()
r2:setDisplayMode("places", r2:getPrimDisplayMode(), r2.PrimDisplayContextualVisibility)
end
function r2:primDisplayFreezeAll()
r2.PrimDisplayFrozen = true
r2:updatePrimDisplayMode()
end
--
function r2:primDisplayUnfreezeAll()
r2.PrimDisplayFrozen = false
r2:updatePrimDisplayMode()
end
--
function r2:primDisplayHideAll()
r2.PrimDisplayVisible = false
r2.PrimDisplayContextualVisibility = false
r2:updatePrimDisplayMode()
end
--
function r2:primDisplayShowContextual()
r2.PrimDisplayVisible = true
r2.PrimDisplayContextualVisibility = true
r2:updatePrimDisplayMode()
end
--
function r2:primDisplayShowAll()
r2.PrimDisplayVisible = true
r2.PrimDisplayContextualVisibility = false
r2:updatePrimDisplayMode()
end
--
function r2:notifyPrimDisplayShowAll()
displaySystemInfo(i18n.get("uiR2EDPrimDisplayModeChangedToShowAll"), 'BC')
r2:primDisplayShowAll()
end
-- change display mode for all objects of the given category
-- filter may be :
-- 'all'
-- 'places' : roads and regions
-- "bot_objects' : pieces of furniture, buildings ...
function r2:setDisplayMode(filter, displayMode, contextualVisibility)
local objList = scratchDisplayModeTableSrc -- alias
local finalObjList = scratchDisplayModeTableDest -- alias
table.clear(objList)
table.clear(finalObjList)
-- operate in all acts
for k, v in specPairs(r2.Scenario.Acts) do
v:getSons(objList)
end
for k,v in pairs(objList) do
if v:isKindOf("WorldObject") then
if filter == "all" then
if v:canChangeDisplayMode() then
table.insert(finalObjList, v)
end
elseif filter == "places" then
if v:isKindOf("Region") or v:isKindOf("Road") then
table.insert(finalObjList, v)
end
elseif filter == "bot_objects" then
if v:isKindOf("Npc") and v:isBotObject() then
table.insert(finalObjList, v)
end
end
end
end
if table.getn(finalObjList) == 0 then
--displaySystemInfo(i18n.get("uiR2EDNoTargetForDisplayModeChange"), "BC")
return
end
-- change display mode only for object that need it
--r2.requestNewAction(i18n.get("uiR2EDChangeDisplayAction"))
for k, v in pairs(finalObjList) do
v.DisplayerVisual.DisplayMode = displayMode
if v:isKindOf("BasePrimitive") then
v.DisplayerVisual.ContextualVisibilityActive = contextualVisibility
end
--if v.DisplayMode == srcDisplayMode or (srcDisplayMode == nil and v.DisplayMode ~= displayModeValue) then
--debugInfo("Changing display mode for " .. v:getDisplayName():toUtf8())
--r2.requestSetNode(v.InstanceId, "DisplayMode", displayModeValue)
-- now a local property
--end
end
end
r2.BotObjectsFrozen = false
function r2:setupFreezeBotObjectButton()
getUI("ui:interface:r2ed_toolbar"):find("r2ed_freeze_bot_objects").active = not r2.BotObjectsFrozen
getUI("ui:interface:r2ed_toolbar"):find("r2ed_unfreeze_bot_objects").active = r2.BotObjectsFrozen
end
function r2:freezeUnfreezeBotObjects()
if r2.BotObjectsFrozen then
r2:unfreezeBotObjects()
else
r2:freezeBotObjects()
end
end
function r2:freezeBotObjects()
r2.BotObjectsFrozen = true
r2:setDisplayMode("bot_objects", 2, false)
r2:setupFreezeBotObjectButton()
end
function r2:unfreezeBotObjects()
r2.BotObjectsFrozen = false
r2:setDisplayMode("bot_objects", 0, false)
r2:setupFreezeBotObjectButton()
end
function r2:setUndoRedoInstances(instanceId)
if instanceId then
r2.logicComponents.undoRedoInstances[tostring(instanceId)] = true
end
end
---
--Called by C++ when upload message are send
--
local lastMessage = {MessageName="", Size=0, Received=0 }
function r2:onMessageSendingStart(messageName, nbPacket, size)
debugInfo("--- Start "..messageName.. " " .. tostring(nbPacket).. " " ..tostring(size))
lastMessage.MessageName = messageName
lastMessage.Size = size
lastMessage.Received =0
local msg = nil
if lastMessage.MessageName == "SSUA" then
msg = i18n.get("uiR2EDUploadScenario"):toUtf8()
elseif lastMessage.MessageName == "RSS2" then
msg = i18n.get("uimR2EDGoToDMMode"):toUtf8()
else
return
end
local ui = getUI("ui:interface:r2ed_uploading_bar")
if not ui then
return
end
local bar = ui:find("uploading_bar")
if not bar then
return
end
bar.hardtext = msg .. " 0%"
ui.active = true
end
function r2:onMessageSendingUpdate(packetId, packetSize)
debugInfo("--- Update " .. tostring(packetId) .. " " .. tostring(packetSize) )
lastMessage.Received = lastMessage.Received + packetSize
if lastMessage.Size and lastMessage.Size ~= 0 then
debugInfo("--- " .. tostring( math.floor( (100*lastMessage.Received) / lastMessage.Size) ) )
if lastMessage.MessageName == "SSUA" then
msg = i18n.get("uiR2EDUploadScenario"):toUtf8()
elseif lastMessage.MessageName == "RSS2" then
msg = i18n.get("uimR2EDGoToDMMode"):toUtf8()
else
return
end
local ui = getUI("ui:interface:r2ed_uploading_bar")
if not ui then
return
end
local bar = ui:find("uploading_bar")
if not bar then
return
end
bar.hardtext = msg .. " ".. tostring( math.floor( (100*lastMessage.Received) / lastMessage.Size ) ) .."%"
ui.active = true
end
end
function r2:onMessageSendingFinish()
debugInfo("--- Finish ")
debugInfo(lastMessage.MessageName)
local ui = getUI("ui:interface:r2ed_uploading_bar")
if not ui then
return
end
local bar = ui:find("uploading_bar")
if not bar then
return
end
bar.hardtext = ""
ui.active = true
end
-- called by C++ to signal that there are too many entity displayed simultaneously
function r2:setMaxVisibleEntityExceededFlag(tooMany)
local msgGroup = getUI("ui:interface:r2ed_max_visible_entity_count_exceeded")
msgGroup.active = tooMany
if tooMany then
msgGroup.t:updateCoords()
msgGroup.w = msgGroup.t.w
msgGroup:invalidateCoords()
end
end