khanat-opennel-code/code/ryzom/common/data_common/r2/r2_logic.lua

--
--

Logic = {}

Logic.Activities = {"Follow Route", "Patrol", "Repeat Road", "Deploy", "Wander", "Rest In Zone", "Feed In Zone", "Hunt In Zone", "Guard Zone", "Stand Still", "Stand On Start Point", "Go To Start Point"}
Logic.TimeLimits = {"No Limit", "Until", "Few Sec", "Few Min", "Chat", "Season", "Day", "Month"}
Logic.Seasons = {"Spring", "Summer", "Autumn", "Winter"}
Logic.Days = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
Logic.Months = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}
Logic.ScriptActions ={"Sit Down", "Stand Up", "Go To Step", "Set Activity", "Stop Actions", "Start Mission"}

Logic.EventModes ={"Once Only", "Repeating"}
Logic.EventTypes ={"Time", "Place", "Entity or Group", "State Machine", "Counter"}
Logic.ConditionTypes ={
							{},
							{"Any player in zone", "All players in zone", "No players in zone", "Some players in zone"},
							{"At Destination", "Enters State", "Leaves State", "Activity Is", "Die", "Is Attacked"},
							{},
							{"v0_changed", "v3_changed", "Equals", "Lesser", "Greater", ""},
						}

Logic.ChatTypes = {"None", "Repeating", "Non Repeating", "Continue"}
Logic.InteractionTypes = {"Give", "Say"}

Logic.Name = "Activity"
Logic.Description = "A feature for describing activities sequences"




Logic.Components = {}




	-- ACTION -------------------
Logic.Components.LogicEntityAction = 
	{
		BaseClass ="BaseClass",
		Name = "LogicEntityAction",
		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "logicEntityActionPropertySheetDisplayer",
		Prop =
		{
			{Name ="Name", Type ="String"}, 
			{Name ="Event", Type ="EventType"}, 
			{Name ="Actions", Type ="Table"}, -- "ActionStep" list
			{Name ="Conditions", Type ="Table"}, -- "ConditionStep" list
		},

		getName = function(this)

			local logicEntity = this.Parent.Parent.Parent
			assert(logicEntity)

			if logicEntity:isGrouped() then
				logicEntity = logicEntity.ParentInstance
			end

			local coloredName = (logicEntity.InstanceId == r2.events.filteredLogicEntityId)

			local eventType = r2.events.keyWordsColor .. i18n.get("uiR2EdEventTxtPreEvent"):toUtf8() .. " "

			if coloredName then		
				eventType = eventType .. r2.events.filterWordColor 
			else
				eventType = eventType .. r2.events.entityWordColor 
			end
			local name = "No name"
			if logicEntity.getName then
				name = logicEntity:getName()
			elseif logicEntity.Name then
				name = logicEntity.Name
			end
			eventType = eventType .. name .. " " 
			eventType = eventType .. r2.events.communWordsColor 

			eventType = eventType ..r2.getLogicAttribute(logicEntity.Class, "Events", this.Event.Type).text
			
			if this.Event.Value~="" then
				local instance = r2:getInstanceFromId(this.Event.Value)
				assert(instance)

				eventType = eventType .. " " .. instance:getShortName()
			end

			
			if this.Event.ValueString and this.Event.ValueString ~= "" then
				if string.gfind(eventType, "%%1")() then
					eventType = string.gsub(eventType, "%%1", "'"..tostring(this.Event.ValueString).."'")
				else
					eventType = eventType .. " '" .. tostring(this.Event.ValueString).. "'"
				end
			end

			eventType = eventType .. ", "

			
			-- conditions
			local conditionsList = ""
			for i=0, this.Conditions.Size-1 do
				local conditionInst = this.Conditions[i]
				
				if conditionInst.Entity~="" and conditionInst.Condition.Type~="" then

					conditionsList = conditionsList .. "\n" .. r2.events.keyWordsColor 
						..string.upper(i18n.get("uiR2EdEventTxtPreCondition"):toUtf8()).." " 
						.. r2.events.communWordsColor 

					local conditionLogicEntity = r2:getInstanceFromId(tostring(conditionInst.Entity))
					assert(conditionLogicEntity)

					coloredName = (conditionLogicEntity.InstanceId == r2.events.filteredLogicEntityId)
					if coloredName then 
						conditionsList = conditionsList .. r2.events.filterWordColor 
					else
						conditionsList = conditionsList .. r2.events.entityWordColor
					end
					conditionsList = conditionsList .. conditionLogicEntity.Name .. " " 
					conditionsList = conditionsList .. r2.events.communWordsColor 
			
					conditionsList = conditionsList ..r2.getLogicAttribute(conditionLogicEntity.Class, "Conditions", conditionInst.Condition.Type).text

					if conditionInst.Condition.Value~="" then
						local instance = r2:getInstanceFromId(conditionInst.Condition.Value)
						assert(instance)
						conditionsList = conditionsList .. " '" .. instance:getShortName() .."'"
					end

					conditionsList = conditionsList .. ", "
				end
			end

			-- actions
			local actionsList = ""
			for i=0, this.Actions.Size-1 do
				local actionInst = this.Actions[i]
				
				if actionInst.Entity~="" and actionInst.Action.Type~="" then
					
					actionsList = actionsList .. "\n" .. r2.events.keyWordsColor 
						..string.upper(i18n.get("uiR2EdEventTxtPreActions"):toUtf8()).." "
						.. r2.events.communWordsColor 

					local actionLogicEntity = r2:getInstanceFromId(tostring(actionInst.Entity))
					assert(actionLogicEntity)
					
					coloredName = (actionLogicEntity.InstanceId == r2.events.filteredLogicEntityId)
					if coloredName then 
						actionsList = actionsList .. r2.events.filterWordColor 
					else
						actionsList = actionsList .. r2.events.entityWordColor 
					end
					local name = "No name"
					if actionLogicEntity.getName then
						name = actionLogicEntity:getName()
					elseif actionLogicEntity.Name then
						name = actionLogicEntity.Name
					end
					actionsList = actionsList .. name .. " " 
					actionsList = actionsList .. r2.events.communWordsColor 
					
					actionsList = actionsList ..r2.getLogicAttribute(actionLogicEntity.Class, "ApplicableActions", actionInst.Action.Type).text
					if actionInst.Action.Value~="" then
						local instance = r2:getInstanceFromId(actionInst.Action.Value)
						assert(instance)
						actionsList = actionsList .. " '" .. instance:getShortName() .. "'"
					end

					if actionInst.Action.ValueString and actionInst.Action.ValueString ~= "" then

						if string.gfind(actionsList, "%%1")() then
							actionsList = string.gsub(actionsList, "%%1", "'"..tostring(actionInst.Action.ValueString).."'")
						else
							actionsList = actionsList .. " '" .. tostring(actionInst.Action.ValueString).. "'"
						end
					end

					if i~=this.Actions.Size-1 then
						actionsList = actionsList .. ","
					else
						actionsList = actionsList .. "."
					end
				end
			end

			if actionsList=="" then
				actionsList = "\n..."
			end
		
			return eventType .. conditionsList .. actionsList --.. "\n"
		end,

		getLogicEntityParent = function(this)

			local logicEntity = this.Parent.Parent.Parent
			if logicEntity:isGrouped() then logicEntity = logicEntity.Parent.Parent end

			return logicEntity
		end,

		-- The act of the event
		getLogicAct = function(this)
			
			local currentAct = r2:getCurrentAct()
			local baseAct =  r2.Scenario:getBaseAct()
			local isBaseAct = false
			local presentActs = {}
			local isCurrentAct = false
			local counter = 0
			

			local entity = this:getLogicEntityParent()
			if entity and entity.getParentAct then
				local act = entity:getParentAct()
				if act then
					if act==currentAct then 
						isCurrentAct=true 
					elseif act==baseAct then
						isBaseAct = true
					else
						presentActs[act.InstanceId] = act.InstanceId
						counter = counter+1
					end
				end
			end


			local function verifyAct ( container)
				
				local key, value = next(container, nil)
				while key do
					if value.Action and value.Action.Type == "Start Act" then
					else
						local entityId = value.Entity
						local entity= r2:getInstanceFromId(entityId)
						if entity and entity.getParentAct then
							local act = entity:getParentAct()
							if act then
								if act==currentAct then 
									isCurrentAct=true 
								elseif act==baseAct then
									isBaseAct = true
								else
									presentActs[act.InstanceId] = act.InstanceId
									counter = counter+1
								end
							end
						end
					end
					key, value = next(container, key)
				end
			end

			verifyAct(this.Actions)
			verifyAct(this.Conditions)

			if counter>=2 or (counter==1 and isCurrentAct) then
				return nil
			elseif counter==1 and not isCurrentAct and isBaseAct then
				local act = nil
				for k, actId in pairs(presentActs) do
					act = r2:getInstanceFromId(actId)
					break
				end
				--inspect(act)
				return act
			else
				--inspect(currentAct)
				return currentAct
			end
		end,
		



		----------
		-- called upon translation
		getLogicActForTranslate = function(this)
			local currentAct = this:getLogicEntityParent():getParentAct()
			local baseAct =  r2.Scenario:getBaseAct()

			local entity = this.Event.Entity
			if entity and entity.getParentAct then
				local act = entity:getParentAct()
				if currentAct == nil then
					currentAct = act
				elseif act ~= currentAct then
					if currentAct == baseAct then
						currentAct = act
					elseif act == baseAct then
						-- do nothing
					else 
						return nil
					end
				end
			end


			
			local function verifyAct ( container)
				local key, value = next(container, nil)
				while key do
					if value.Action and value.Action.Type == "Start Act" then
					else
						local entityId = value.Entity
						local entity= r2:getInstanceFromId(entityId)
						if entity and entity.getParentAct then
							local act = entity:getParentAct()
							if act then
								if currentAct == nil then
									currentAct = act
								elseif act ~= currentAct then
									if currentAct == baseAct then
										currentAct = act
									elseif act == baseAct then
										-- do nothing
									else 																				return false
									end
								end
							end
						end
					end
					key, value = next(container, key)
				end
				return true
			end


			if not verifyAct(this.Actions) then return false end
			if not verifyAct(this.Conditions) then return false end
			return currentAct		
		end,
		--
		getLogicActInstanceId = function(this)
			--local ok, act = pcall(Logic.Components.LogicEntityAction.getLogicAct, this)
			local ok, act = pcall(Logic.Components.LogicEntityAction.getLogicActForTranslate, this)
			if not ok or not act then
				return r2.RefId("")
			end
			
			return act.InstanceId
		end,
	}

Logic.Components.EventType = 
	{
		BaseClass ="BaseClass",
		Name = "EventType",
		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "eventTypePropertySheetDisplayer",
		Prop =
		{
			{Name ="Type", Type ="String"}, 
			{Name ="Value", Type ="RefId"}, -- if type is end of activity/chat step/sequence, instance id
			{Name ="ValueString", Type ="String", DefaultValue="", DefaultInBase=1}, -- if type is emit user event, sub timer...

		}
	}

local classActionStepVersion = 2
Logic.Components.ActionStep = {
		BaseClass ="BaseClass",
		Name = "ActionStep",
		Version = classActionStepVersion,
		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "actionStepPropertySheetDisplayer",
		Prop =
		{
			{Name ="Entity", Type ="RefId"}, -- entity target id
			{Name ="Action", Type ="ActionType"} -- sequence id
		},

		updateVersion = function(this, scenarioValue, currentValue )
			
			local patchValue = scenarioValue
			if patchValue < 1 then
				local invalidActions = {}
				invalidActions["desactivate"] = "deactivate"
				invalidActions["Desactivate"] = "deactivate"
				r2.updateLogicActions(this, invalidActions, "BanditCamp")
				patchValue = 1
			end

			if patchValue < 2 then

				local action = this.Action
				if action.Type == "Add 10 Seconds" then
					r2.requestSetNode(action.InstanceId, "Type", "add seconds")
					r2.requestInsertNode(action.InstanceId, "", -1, "ValueString", "10")
				end

				if action.Type == "Sub 10 seconds" then
					r2.requestSetNode(action.InstanceId, "Type", "sub seconds")
					r2.requestInsertNode(action.InstanceId, "", -1, "ValueString", "10")
				end
				if action.Type == "Add 1 minute" then
					r2.requestSetNode(action.InstanceId, "Type", "add seconds")
					r2.requestInsertNode(action.InstanceId, "", -1, "ValueString", "60")
				end

				if action.Type == "Sub 1 minute" then
					r2.requestSetNode(action.InstanceId, "Type", "sub seconds")
					r2.requestInsertNode(action.InstanceId, "", -1, "ValueString", "60")
				end

				patchValue = 2
			end
			
			if patchValue == currentValue then return true end
			return false
		end,	
	}


Logic.Components.ActionType = 
	{
		BaseClass ="BaseClass",
		Name = "ActionType",
		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "actionTypePropertySheetDisplayer",
		Prop =
		{
			{Name ="Type", Type ="String"}, 
			{Name ="Value", Type ="RefId"}, -- if type is begin of activity/chat sequence, instance id
			{Name ="ValueString", Type ="String", DefaultValue="", DefaultInBase=1}, -- if type is emit user event, sub timer...

		
		}
	}

Logic.Components.ConditionStep =
	{
		BaseClass ="BaseClass",
		Name = "ConditionStep",
		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "conditionStepPropertySheetDisplayer",
		Prop =
		{
			{Name ="Entity", Type ="RefId"}, -- entity id
			{Name ="Condition", Type ="ConditionType"}
			
		}
	}

Logic.Components.ConditionType = 
	{
		BaseClass ="BaseClass",
		Name = "ConditionType",
		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "conditionTypePropertySheetDisplayer",
		Prop =
		{
			{Name ="Type", Type ="String"}, 
			{Name ="Value", Type ="RefId"}, -- if type is being in activity/chat step/sequence, instance id

		
		}
	}

	-- REACTION -----------------

Logic.Components.LogicEntityReaction = 
	{
		BaseClass ="BaseClass",
		Name = "LogicEntityReaction",
		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "logicEntityReactionPropertySheetDisplayer",
		Prop =
		{
			{Name ="Name", Type ="String"}, 
			{Name ="LogicEntityAction", Type ="String"}, -- id of associated LogicEntityAction
			{Name ="ActionStep", Type ="String"},		  -- id of associated ActionStep
		}
	}

Logic.Components.ChatAction=
	{
		BaseClass ="BaseClass",
		Name ="ChatAction",
		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "chatActionPropertySheetDisplayer",
		Prop =
		{
			{Name ="Who", Type ="RefId"},
			{Name ="WhoNoEntity", Type ="String"},
			{Name ="Says", Type ="String"},
			{Name ="Emote", Type ="String"},
			{Name ="Facing", Type ="RefId"},
--			{Name ="FacingNoEntity", Type ="String"},
		}
	}

Logic.Components.ChatStep = {
		BaseClass ="BaseClass",
		Name = "ChatStep",
		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "chatStepPropertySheetDisplayer",
		Prop =
		{
			{Name ="Actions", Type ="Table"},
			{Name ="Time", Type ="Number" },
			{Name ="Name", Type ="String" }
		},

		getName = function(this)

			-- after time
			local minNb, secNb = r2.dialogs:calculMinSec(this.Time)
			local time = ""
			if minNb ~= 0 then
				time = tostring(minNb)..i18n.get("uiR2EdShortMinutes"):toUtf8()
			end
			time = time.." " ..tostring(secNb)..i18n.get("uiR2EdShortSeconds"):toUtf8()
			local afterTime = "(" ..i18n.get("uiR2EdAfter"):toUtf8().." ".. time..") "

			-- says
			local whoToWho = ""
			local action = this.Actions[0]
			local who = action.Who
			if who=="" then who=action.WhoNoEntity end
			if who and who ~= "" then
	
				if r2:getInstanceFromId(who) then
					who=r2:getInstanceFromId(who).Name	
				else
					who = r2.dialogs.whoToWhoTranslation[who]
				end

				whoToWho = who .. " " 

				local facing = action.Facing
				if facing~="" then
					whoToWho = whoToWho ..i18n.get("uiR2EdSaysTo"):toUtf8().. " " .. r2:getInstanceFromId(facing).Name .. " "	
				end

				local emote = action.Emote
				if emote~="" and r2.dialogs.fromEmoteIdToName[emote] ~= nil then
					whoToWho = whoToWho .."(" .. r2.dialogs.fromEmoteIdToName[emote] .. ") :"
				end
			end

			return afterTime..whoToWho

		end,

		getShortName = function(this)

			-- says
			local saysWhat = ""
			local action = this.Actions[0]
			local who = action.Who
			if who ~= "" or WhoNoEntity~="" then
				who = r2:getInstanceFromId(who)
				if who then
					saysWhat = who.Name
				elseif action.WhoNoEntity=="_System" then
					saysWhat = i18n.get("uiR2EdSystem"):toUtf8()
				elseif action.WhoNoEntity=="_DM" then
					saysWhat = i18n.get("uiR2EdDonjonMaster"):toUtf8()
				end
			
				saysWhat = saysWhat .. " " ..i18n.get("uiR2EdSays"):toUtf8().. " " 

				local says = action.Says
				if says ~= "" then
					local inst=r2:getInstanceFromId(says)
					if inst then
						says = inst.Text 
						local uc_says = ucstring()
						uc_says:fromUtf8(says)
						uc_says = uc_says:substr(0, 4)
						says = uc_says:toUtf8()					
					end

				end

				saysWhat = saysWhat .. says .. "..."
			end

			return saysWhat

		end,

		--------------------------------------------------------------------------------------------
		-- from 'BaseClass'
		getParentTreeNode = function(this)				
		end,
	}


local classChatSequenceVersion = 1
Logic.Components.ChatSequence = {
		PropertySheetHeader = r2.getDisplayButtonHeader("r2.dialogs:openEditor()", "uiR2EdEditDialogButton"),
		BaseClass = "LogicEntity",
		Name = "ChatSequence",
		InEventUI = true,
		Menu="ui:interface:r2ed_feature_menu",
		Version = classChatSequenceVersion,

		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "chatSequencePropertySheetDisplayer",

		DisplayerUI = "R2::CDisplayerLua",
		DisplayerUIParams = "defaultUIDisplayer",
		DisplayerVisual = "R2::CDisplayerVisualEntity",

		Parameters = {},
		ApplicableActions = {
								"activate", "deactivate", "starts dialog", "stops dialog", "starts chat"  , "continues dialog"
							},
		Events =			{
								"start of dialog", "end of dialog" ,
								"start of chat", "end of chat",
								"activation", "deactivation"
							},
		Conditions =		{
								"is not in dialog", "is in dialog", "is in chat"
							},
		TextContexts =		{},
		TextParameters =	{},
		LiveParameters =	{},

		
		Prop =
		{	
			{Name = "Type", Type="String",DefaultValue = "None", Visible=false},
			{Name ="Repeating", Type="Number" ,DefaultValue = "0", Visible=false},
			{Name="Components",Type="Table"},
			{Name="SubComponents", Type="Table"},
			{Name="Name", Type="String", MaxNumChar="32"},
			{Name="AutoStart", Type="Number", WidgetStyle="Boolean", DefaultValue="1", Visible=function(this) return this:mustDisplayAutostart() end},
			{Name="Active", Type="Number", WidgetStyle="Boolean", DefaultValue = "1"},
		},
	
		
		mustDisplayAutostart = function(this)
			if this.Class == "ProximityDialog" then
				return false
			end
			return true
		end,

		-- it's a feature
		getParentTreeNode = function(this)
			return this:getFeatureParentTreeNode()
		end,

		onPostCreate = function(this)
			--this:createGhostComponents()
			if this.User.DisplayProp and this.User.DisplayProp == 1 then
				r2:setSelectedInstanceId(this.InstanceId)				
				r2:showProperties(this)		
				this.User.DisplayProp = nil
			end

		end,

		create = function()
			
			--if r2:getLeftQuota() <= 0 then -- ??	
			--	r2:makeRoomMsg()
			--	return
			--end
	
			local function posOk(x, y, z)
				if r2.mustDisplayInfo("ChatSequence") == 1 then 
					r2.displayFeatureHelp("ChatSequence")
				end
				debugInfo(string.format("Validate creation of 'Dialog' at pos (%d, %d, %d)", x, y, z))
				r2.dialogs:newSequenceInst(x, y, z)
			end
			local function posCancel()
				debugInfo("Cancel choice 'Dialog' position")
			end	
			
			local creature = r2.Translator.getDebugCreature("object_component_dialog.creature")
			r2:choosePos(creature, posOk, posCancel, "createDialog")
		end,

		---- get Name ------
		getName = function(this)

			local name = this.Name
			if name == "" then

				local index = r2.logicComponents:searchElementIndex(this)
				if index >= 0 then
					name = i18n.get("uiR2EDDialog"):toUtf8() .. index
				end
			end
			
			return name 
		end,

		---- get Name ------
		getShortName = function(this)

			return this:getName() 
		end,

		---------------------------------------------------------------------------------------------------------

		editDialogs = function(this)
			r2.dialogs:openEditor()
		end,

		getAvailableCommands = function(this, dest)
			r2.Classes.LogicEntity.getAvailableCommands(this, dest)
			table.insert(dest, this:buildCommand(this.editDialogs, "edit_dialogs", "uiR2EDEditDialogs", "r2ed_edit_dialog.tga", true))				
			this:getAvailableDisplayModeCommands(dest)
		end,

		initEventValuesMenu = function(this, menu, categoryEvent)
			for ev=0,menu:getNumLine()-1 do

				local eventType = tostring(menu:getLineId(ev))

				if r2.events.eventTypeWithValue[eventType] == "Number" then
					menu:addSubMenu(ev)
					local subMenu = menu:getSubMenu(ev)
					local func = ""
					for i=0, 9 do
						local uc_name = ucstring()
						uc_name:fromUtf8( tostring(i) )
						func = "r2.events:setEventValue('','" .. categoryEvent .."','".. tostring(i).."')"
						subMenu:addLine(uc_name, "lua", func, tostring(i))
					end

				elseif r2.events.eventTypeWithValue[eventType]=="ChatStep" then

					menu:addSubMenu(ev)
					local subMenu = menu:getSubMenu(ev)

					for c=0, this.Components.Size-1 do
						local chat = this.Components[c]
						local uc_name = ucstring()
						uc_name:fromUtf8(chat:getShortName())
						subMenu:addLine(uc_name, "lua", 
							"r2.events:setEventValue('".. chat.InstanceId .."','" .. categoryEvent .. "')", chat.InstanceId)
					end

					if this.Components.Size==0 then
						subMenu:addLine(i18n.get("uiR2EdNoSelelection"), "", "", "")
					end
				end
			end
		end,
		
		getLogicAction = function(this, context, action)
			return r2.Translator.getDialogLogicAction(this, context, action)
		end,
		getLogicEvent = function(this, context, event)
			return r2.Translator.getDialogLogicEvent(this, context, event)
		end,
		getLogicCondition = function(this, context, condition)
			return r2.Translator.getDialogLogicCondition(this, context, condition)
		end,

		pretranslate = function(this, context)
			r2.Translator.createAiGroup(this, context)
		end,

		translate = function(this, context)
			r2.Translator.translateFeatureActivation(this, context)
			r2.Translator.translateDialog( this, context)
		end,

		updateVersion = function(this, scenarioValue, currentValue )
			local patchValue = scenarioValue
			if patchValue < 1 then
				local subComponents = {}
				r2.requestInsertNode(this.InstanceId, "", -1, "SubComponents", subComponents)
				r2.requestInsertNode(this.InstanceId, "", -1, "AutoStart", this.Active)
				r2.requestSetNode(this.InstanceId, "Active", 1)
				r2.requestSetNode(this.InstanceId, "Base", r2.Translator.getDebugBase("palette.entities.botobjects.dialog"))
				patchValue = 1
			end
			
			if patchValue == currentValue then return true end
			return false
		end,

		initLogicEntitiesInstancesMenu = function(this, subMenu, calledFunction)
			
			local entitiesTable = r2.Scenario:getAllInstancesByType(this.Name)
			for key, entity in entitiesTable do
				local uc_name = ucstring()
				uc_name:fromUtf8(entity.Name)
				subMenu:addLine(uc_name, "lua", calledFunction.."('".. entity.InstanceId .."')", entity.InstanceId)
			end

			if table.getn(entitiesTable)==0 then
				subMenu:addLine(i18n.get("uiR2EdNoSelelection"), "", "", "")
			end
		end
		
	}


local ActivityStepVersion = 1
Logic.Components.ActivityStep = {
		BaseClass ="BaseClass",
		Name ="ActivityStep",
		Version = ActivityStepVersion,
		BuildPropertySheet = true,
		Menu ="ui:interface:r2ed_feature_menu",
		
		BuildPropertySheet = false,
		DisplayerVisualParams = 
		{
			Look = r2.PrimRender.GroupLook,		
			ArrayName = "Components"
		},
		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "activityStepPropertySheetDisplayer",	
		
		Prop =
		{
			{Name="Activity", Type="String"},
			{Name="ActivityZoneId",Type="RefId",Category="ActivityStep"},
			{Name="TimeLimit",Type="String",Category="ActivityStep"},
			{Name="TimeLimitValue", Type="String",Category="ActivityStep",Category="ActivityStep"},
			{Name="RoadCountLimit", Type="String",Category="ActivityStep",Category="ActivityStep", DefaultInBase = 1, DefaultValue = "0"},
			{Name="Chat",Type="RefId"},
			{Name = "Type", Type="String",DefaultValue = "None"},  --TEMP TEMP TEMP
			{Name="EventsIds",Type="Table"},
			{Name="Name", Type="String", MaxNumChar="32"}
		},
		-- get sequencable parent for this activity step
		getSequencableParent = function(this)
			local currParent = this.Parent
			while currParent do
				if currParent.InstanceId and currParent:isSequencable() then
					return currParent
				end
				currParent = currParent.Parent
			end
			return nil
		end,
		getVerbLookupString = function(this)
			local seqParent = this:getSequencableParent()			
			if seqParent then
				return seqParent:getActivityVerbLookupName(this.Activity)
			else
				return this.Activity
			end			
		end,
		-- do lookup from the verb lookup string used to know the display name, and button texture
		doLookupFromVerb = function(this, lookupTable)			
			local lookupString = this:getVerbLookupString()			
			-- activity type
			local value = lookupTable[lookupString]
			if  not value then
				debugInfo(colorTag(255,0,0).."The activity '".. lookupString .."' is not properly registred")				
				return nil				
			end
			return value
		end,
		-- get texture for the button displayed in the mini activity view
		getMiniButtonTexture = function(this)						
			local result = this:doLookupFromVerb(r2.miniActivities.activityTextures)
			if result then return result end
			return "brick_default.tga"
		end,
		-- get the verb for this activity (rest, feed, patrol etc...)
		getVerb = function(this)									
			local result = this:doLookupFromVerb(r2.activities.activityTypeTranslation)
			if result then result = result.trans end
			if result then return result end
			return ucstring("Activity not registered : " .. lookupString)
		end,
		-- element name
		getName = function(this)			
			local activityType = this:getVerb() .. " "
			if this.ActivityZoneId~= "" then
				local place = r2:getInstanceFromId(tostring(this.ActivityZoneId))
				if place~=nil then
					activityType = activityType.. place.Name .." "
				end	
			end

			-- activity time
			local activityTime = ""
			if this.TimeLimit == "Few Sec" then
			
				local hourNb, minNb, secNb = r2.logicComponents:calculHourMinSec(tonumber(this.TimeLimitValue))

				local timeLimitText = i18n.get("uiR2EdFor"):toUtf8() .. " "
				if hourNb ~= 0 then timeLimitText = timeLimitText .. hourNb .. i18n.get("uiR2EdShortHours"):toUtf8() .. " " end
				if minNb ~= 0 then timeLimitText = timeLimitText .. minNb .. i18n.get("uiR2EdShortMinutes"):toUtf8() .. " " end
				timeLimitText = timeLimitText .. secNb .. i18n.get("uiR2EdShortSeconds"):toUtf8() 
				
				activityTime = timeLimitText

			elseif r2.activities.timeLimitsTranslation[this.TimeLimit] ~= nil then
				activityTime = string.lower(r2.activities.timeLimitsTranslation[this.TimeLimit])
			end

			return activityType..activityTime
		end,

		-- element name
		getShortName = function(this)

			-- activity type			
			local activityType = this:getVerb()
			if this.ActivityZoneId~= "" then
				local place = r2:getInstanceFromId(tostring(this.ActivityZoneId))
				if place~=nil then
					activityType = activityType.. " " .. place.Name 
				end	
			end

			return activityType
		end,

		updateVersion = function(this, scenarioValue, currentValue )
			local patchValue = scenarioValue

			if patchValue < 1 then
				local activity = this.Activity
				if (activity and activity == "Inactive") then
					r2.requestSetNode(this.InstanceId, "Activity", "Stand Still")
				end
				local name = this.Name
				
				patchValue = 1
			end
			if patchValue == currentValue then return true end
			return false
		end
	}



Logic.Components.ActivitySequence = {
		BaseClass="BaseClass",
		Name="ActivitySequence",
		BuildPropertySheet = true,
		Menu ="ui:interface:r2ed_feature_menu",

		--DisplayerUI = "R2::CDisplayerLua",
		--DisplayerUIParams = "defaultUIDisplayer",
		BuildPropertySheet = false,
		DisplayerVisual = "R2::CDisplayerVisualActivitySequence",
		DisplayerProperties = "R2::CDisplayerLua",
		DisplayerPropertiesParams = "activitySequencePropertySheetDisplayer",	
		
		Prop =
		{
			--{Name ="InstanceId", Type ="String"},
			{Name ="Repeating", Type ="Number" , DefaultValue = "1"},
			{Name ="Components", Type ="Table"},
			{Name ="Name", Type ="String"}
		},

		---- get Name ------
		getName = function(this)

			local name = this.Name
			if name == "" then

				local index = r2.logicComponents:searchElementIndex(this)

				if index >= 0 then
					name = i18n.get("uiR2EdSeq"):toUtf8() .. index
				end
			end
			
			return name 
		end,

		---- get Name ------
		getShortName = function(this)

			return this:getName() 
		end,

		-- get ActiveLogicEntity parent
		getActiveLogicEntityParent = function(this)

			-- ActiveLogicEntity.Behavior.Activities
			local activeLogicEntity = this.Parent.Parent.Parent

			-- NpcGrpFeature.Components
			--if activeLogicEntity:isGrouped() then activeLogicEntity = activeLogicEntity.Parent.Parent end

			return activeLogicEntity
		end,
	}



--this function must be called when we delete a ChatAction,
--to unregister the text
onDeleteChatAction = function(chatAction)
	if chatAction.User.DeleteInProgress == true then return end
	chatAction.User.DeleteInProgress = true
	if chatAction.Says ~= nil and chatAction.Says ~= ""
	then

		debugInfo("onDeleteChatAction")
		r2.unregisterTextFromId(chatAction.Says)
	end
end

--counts the states created, to ensure states names uniqueness

--timer used to time the sequences steps
Logic.activityStepTimer = "t0"
Logic.activityStepTimerId = 0
--timer used to time the chat steps
Logic.chatTimer = "t1"
Logic.chatTimerId = 1
--timer used inside activities
Logic.activityInternalTimer = "t2"
Logic.activityInternalTimerId = 2

--variable used to know which action of the current chat sequence
--must be played
Logic.chatStepVar = "v1"
--variable used to know which chat sequence is currently played
Logic.chatSequenceVar = "v0"
--variable used to know which activity sequence is currently played
Logic.activityStepVar = "v2"
--variable used to know which interrupt action must be executed
Logic.triggerEventVar = "v3"

Logic.EndOfActivitySequenceEvent = 9
Logic.EndOfChatSequenceEvent = 8

--switch_action which hold all chat sequences
Logic.DialogAction = nil
--switch action holding chat sequences transitions
Logic.DialogAction2 = nil

--switch_action which hold all sequence steps
Logic.SequenceAction = nil
Logic.ActionStepCounter =0
Logic.ChatSequenceCounter = 0
--used to know the names of all the states generated
--to translate this activity
Logic.StatesByName = ""

--timer_triggered event, triggered 
--each time we must enter a new chat step
Logic.DialogEvent = nil

Logic.DialogEvent2 = nil

--timer_triggered event, triggered
--each time we must enter a new sequence step
Logic.SequenceEvent = nil

--hold the states used in the current activity.
--all the states are created at the start of the translation,
--before translating the events and actions.
Logic.States = {}

--hold the states used in all the activities
--of the group
Logic.ActivitiesStates ={}

--the activity which is currently being translated.
Logic.CurrentActivity = nil

----------------------------------------------------
--to be called once for each sequence of each group
--complete the AiActivity field of the first state of this sequence
--and create the actions to go to the first step
Logic.initGroupActivitiesTranslation = function(context, hlComponent, sequence, first, activityIndex, aiActivity, rtGrp)
	assert(context and hlComponent and sequence and activityIndex and aiActivity and rtGrp)
	--get the states of this activity
	
	local activityStates = Logic.ActivitiesStates[ tostring(sequence.InstanceId) ]	
	assert(sequence.Class == "ActivitySequence")
	if not activityStates then
		
		if hlComponent then
			printWarning("Error while translating '" .. hlComponent.Name .. "' activities in sequence " .. sequence.Name)			
			-- pretranslate sequence.InstanceId errors instanceId not added in currentAct.ActivitiesId ?
			return nil
		end		
	end
	--get the initial state of this activity
	local aiState = activityStates[sequence.InstanceId][1]
	Logic.StatesByName = ""
	for k, v in pairs(activityStates)
	do
		if v.Class ~= "RtAiState"
		then
			local  k1, v1 = next( v, nil)
			while k1 do
				Logic.StatesByName = r2.Utils.concat(Logic.StatesByName, v1.Name)
				k1, v1 = next(v, k1)
			end
		else
			Logic.StatesByName = r2.Utils.concat(Logic.StatesByName, v.Name)
		end
	end
	aiState.AiActivity = aiActivity
	assert(aiState.AiActivity)
	local event = r2.Translator.createEvent("start_of_state", aiState.Name, rtGrp.Name)
	-- local event = r2.Translator.createEvent("group_spawned", aiState.Name, rtGrp.Name)
	table.insert(context.RtAct.Events, event)
	if first == true
	then
		table.insert(aiState.Children, rtGrp.Id)
	end

	local speed = ""

	if hlComponent.Speed and hlComponent.Speed == "run" then speed = "()addProfileParameter(\"running\");\n" end
	
	local code = "currentActivitySequenceVar = " .. tostring(activityIndex -1 ) ..";\n"			
		.. "oldActivitySequenceVar = currentActivitySequenceVar;\n"
		.. "RoadCountLimit=0;\n"
		.. "oldActivityStepVar = -1;\n" 
		.. "oldActivityStepVar2 = 0;\n" 
		.. Logic.activityStepVar .." = 0;\n" 
		.. speed
		.."alive = 0;\n"
		.."(alive)isAlived();\n"
		.. "if (alive == 1)\n{\n"
		.. "\t()setTimer(30, " .. Logic.activityStepTimerId .. ");\n"
		.. "\tinit = 1;\n"
		.. "}\n"


	-- Fauna activities


	local action = r2.Translator.createAction("code", code)
	action.Name = "startActivitySequence"

	table.insert(context.RtAct.Actions, action)
	table.insert(event.ActionsId, action.Id)



	do
		local event = r2.Translator.createEvent("group_spawned", aiState.Name, rtGrp.Name)
		local action = r2.Translator.createAction("code", "if (init != 1)\n{\n\t()setTimer(30, " .. Logic.activityStepTimerId .. ");\n}\n")
		table.insert(context.RtAct.Events, event)
		table.insert(context.RtAct.Actions, action)
		table.insert(event.ActionsId, action.Id)
	end


	local leader = hlComponent

	if hlComponent:isKindOf("NpcGrpFeature") then
		if hlComponent.Components.Size ~= 0 then
			leader = hlComponent.Components[0]
		else
			leader = nil
		end
	end
end

--insert an activity step at the specified position
Logic.insertActivityStep = function(sequence, step, pos)
	local n = table.getn(sequence.Components)
	if n < pos
	then
		table.insert(sequence.Components, step)
	else
		table.insert(sequence.Components, pos, step)
	end
end

--insert a chat step at the specified position
Logic.insertChatStep = function(chatSequence, chatStep, pos)
	local n = table.getn(chatSequence.Components)
	if n < pos
	then
		table.insert(chatSequence.Components, chatStep)
	else
		table.insert(chatSequence.Components, pos)
	end
end


Logic.createInteraction = function(action, parameter)
	local index = Logic.find(Logic.InteractionTypes, action)
	local interaction
	
	if index == nil or parameter == nil
	then
--			debugInfo(colorTag(255,0,0).."unknown interaction : " .. action .." !")
		return nil
	end

	interaction = r2.newComponent("Interaction")
	interaction.Type = action
	interaction.Parameter = parameter
	return interaction
end

Logic.createActivityStep = function(activity, timeLimit, zoneId, time)
	local activityStep = nil
	
	if activity == nil or timeLimit == nil
	then
		return nil
	end

--checking activity type and time limit type
	if Logic.find(Logic.Activities, activity)~= nil and Logic.find(Logic.TimeLimits, timeLimit)~= nil
	then
		--checking activity parameter
		if ( (activity ~= "Stand Still") and (activity ~= "Inactive") and (zoneId == nil) )
		then
			--this activity need a zone, and no zone id is given
--				debugInfo(colorTag(255,0,0).."activity <" .. activity .."> need a zone id!")
			return nil
		end
		
	--checking time parameter
		--if time parameter needed, check its presence
		if timeLimit~="No Limit" and timeLimit~="Chat" and time == nil
		then
			--this activity needs a time limit and no limit is given
--				debugInfo(colorTag(255,0,0).."Time limit <" .. timeLimit .."> need a time limit parameter!")
			return nil
		end

		--check season validity
		if (timeLimit == "Season") and (Logic.find(Logic.Seasons, time) == nil)
		then
--				debugInfo(colorTag(255,0,0).."Unknown season: " .. time)
			return nil
		end
		
		--check day validity
		if (timeLimit == "Day") and (Logic.find(Logic.Days, time) == nil)
		then
			debugInfo(colorTag(255,0,0).."Uknown week day: " .. time)
			return nil
		end
		
		if (timeLimit == "Month") and (Logic.find(Logic.Months, time)== nil)
		then
--				debugInfo(colorTag(255,0,0,0).."Uknown month: " .. time)
			return nil
		end

		activityStep = r2.newComponent("ActivityStep")
		activityStep.Activity = activity
		activityStep.TimeLimit = timeLimit
		activityStep.ActivityZoneId = zoneId
		activityStep.TimeLimitValue = time
	else
--			debugInfo(colorTag(255,0,0).."Unknown activity !")
	end
	return activityStep
end

Logic.createState = function()
	local aiState = r2.newComponent("RtAiState")
	aiState.Name = aiState.Id
	Logic.StatesByName = Logic.StatesByName .."\n" .. aiState.Name
	return aiState
end

--create the AiStates necessay to translate this step
Logic.createStepStates = function(step, context)
	local states = {}
	local state = Logic.createState()
	table.insert(states, state)
	table.insert(context.RtAct.AiStates, state)
	if step.Activity == "Patrol"
	then
		local state = Logic.createState()
		table.insert(states, state)
		table.insert(context.RtAct.AiStates, state)
	end
	return states
end

--assign a zone or a road to an AiState
--if invert is true, invert the road
Logic.assignZone = function(rtAiState, zone, invert)
	assert( zone and type(zone) == "userdata")
	local points = zone.Points
	assert( points ~= nil)

	local size = points.Size + 1
	rtAiState.Pts = {}
	local i =0
	local j

	local k, v = next(points, nil)
	while k ~= nil
	do
		assert(v ~= nil)
		i = i +1
		if invert == true
		then
			j = size - i
		else
			j = i
		end
		rtAiState.Pts[j]={}
		rtAiState.Pts[j].x = r2.getWorldPos(v).x
		rtAiState.Pts[j].y = r2.getWorldPos(v).y
		rtAiState.Pts[j].z = r2.getWorldPos(v).z
		k, v = next(points, k)
	end
end

--create all the states used in this activity Sequence
Logic.createActivityStates = function(context, sequence)
	assert( sequence ~= nil)

	local activityStates ={}
	--activity's initial stat, aiStopStatee
	
	-- init state
	local aiStartState = r2.newComponent("RtAiState")
	aiStartState.Name = aiStartState.Id
	Logic.StatesByName = aiStartState.Name
	aiStartState.AiMovement = "idle" -- "stand_on_start_point"
	table.insert(context.RtAct.AiStates, aiStartState)
	

	-- end state
	local aiStopState = r2.newComponent("RtAiState")
	aiStopState.Name = aiStopState.Id
	--Logic.StatesByName = aiStopState.Name
	aiStopState.AiMovement = "idle" -- "stand_on_start_point"
	table.insert(context.RtAct.AiStates, aiStopState)

	activityStates[sequence.InstanceId]= { aiStartState, aiStopState}


	if (sequence.Components == nil) then assert(nil) end
	--creation of the states of the step
	local k, v = next(sequence.Components, nil)
	while k do
		local states = Logic.createStepStates(v, context)
		activityStates[v.InstanceId]= states
		 k, v = next(sequence.Components, k)
	end
	Logic.ActivitiesStates[sequence.InstanceId] = activityStates
end

Logic.translateActivitySequence = function(context, hlComponent, activitySequence, sequenceId, rtNpcGrp)
	assert(rtNpcGrp ~= nil)
	if context.Real == false
	then
		return
	end
	Logic.ActionStepCounter = 0
	Logic.ChatSequenceCounter = 0
	--Logic.States = {}
	Logic.CurrentActivity = activitySequence
	local ok = false

	local nbSteps = activitySequence.Components.Size
	local aiState
	local action
	local event
	local sequence = activitySequence


	if sequence.Components.Size ==0
	then	
		return
	end


	Logic.initSequence(context, rtNpcGrp)
	if  Logic.ActivitiesStates[sequence.InstanceId] then
		Logic.States = Logic.ActivitiesStates[sequence.InstanceId]
	else
		Logic.States = ""
	end
	
	

	local i =1
	local k, activityStep = next(sequence.Components, nil)
	while k do
		--translate step
		Logic.translateActivityStep(context,  hlComponent, activitySequence, activityStep, i, rtNpcGrp)
		i = i + 1
		k, activityStep = next(sequence.Components, k)

	end

	--create actions to repeat the sequence
	if sequence.Repeating == 1
	then

		local code =
			"//sequence will repeat"..
			"oldChatSequenceVar = " .. Logic.chatSequenceVar .. ";\n" ..
			"RoadCountLimit=0;\n" ..
			"oldActivityStepVar = " .. Logic.activityStepVar .. ";\n" ..
			"oldActivityStepVar2 = " .. Logic.activityStepVar .. " + 1" .. ";\n" ..
			"v2=0;\n" ..
			"()setTimer(1, " ..Logic.activityStepTimerId .. ");\n"
--			.. "()setEvent(" .. Logic.EndOfActivitySequenceEvent ..");\n"
		
		local action = r2.Translator.createAction("code", code)
		action.Name = "repeat_sequence"
		table.insert(Logic.SequenceAction.Children, action)
		
	else
	
		local backupState =
			"//sequence will not repeat"..
			"oldChatSequenceVar = " .. Logic.chatSequenceVar .. ";\n" ..
			"RoadCountLimit=0;\n"..
			"oldActivityStepVar = " .. Logic.activityStepVar .. ";\n" ..
			"oldActivityStepVar2 = " .. Logic.activityStepVar ..  " + 1" .. ";\n"
		
		local stateName = Logic.ActivitiesStates[sequence.InstanceId][sequence.InstanceId][2].Id

		local setNextActivityState = "()postNextState(\"" .. r2.getNamespace() .. stateName .."\");\n"
		
		local action = r2.Translator.createAction("code", backupState 
			-- .."()setEvent(" .. Logic.EndOfActivitySequenceEvent ..");\n"
			..setNextActivityState)
		
		
		action.Name = "end_of_activity_sequence"
		table.insert(Logic.SequenceAction.Children, action)
	end

	Logic.SequenceEvent.StatesByName = Logic.StatesByName
	Logic.DialogEvent = nil
	Logic.SequenceEvent = nil
end



Logic._obsolete_TranslateScriptAction = function(context, step, nextTime)
	local actionType = Logic.getAction(step)
	assert(actionType~= nil)
--		debugInfo(colorTag(0,255,0).. actionType)
	
	if actionType == "stop_actions"
	then
		local action = r2.Translator.createAction("set_timer_" ..Logic.chatTimer, "0")
		return action
	end
	
	if actionType == "start_mission"
	then
		local counterMission = context.Components[step.Parameter]
		local action = r2.Translator.createAction("trigger_event_1", context.RtCounters[counterMission.InstanceId].RtGroup.Name)
--			debugInfo("action created!!")
		return action
	end

	if 0==1 and actionType == "go_to_step"
	then
		--TODO
		local param = tonumber(step.Parameter)
		debugInfo("param = " .. param)
		if (param < 1) or (Logic.CurrentActivity.Components[param]== nil)
		then
--				debugInfo(colorTag(255,0,0).."Impossible to go to step " .. param .." !")
			return nil
		end
		debugInfo(context.Feature.Class)
		return Logic.selectActivityStep(param)
	end

	if actionType == "set_activity"
	then
		local group = nil
		local param
		local rtGroup
		if step.Who ~= "" and step.Who ~= nil
		then
			group = step.Who
			rtGroup = r2.Translator.getRtGroup(context, group)
		end
		
		param = tonumber(step.Parameter)

--			debugInfo("param = " .. param)

		local action
		if group ~= nil
		then
			action = r2.Translator.createAction("begin_state", Logic.getActivityInitialStateName(group, param, context))
			assert(action ~= nil)
			local index = Logic.addTriggeredAction(context, context.RtGroups[group].Name, action)
			action = r2.Translator.createAction("modify_variable", rtGroup.Name ..":" ..Logic.triggerEventVar .." = " .. index)
			action.Name ="set_activity"
		else
			action = r2.Translator.createAction("begin_state", Logic.getActivityInitialStateName(context.Group.Name, param, context))
			assert(action ~= nil)
		end
		return action
	end

	local action = r2.Translator.createAction(actionType)
	assert(action ~= nil)
	return action
end


	

Logic.translateChatAction = function(context, chatSequenceNumber, chatStepNumber, chatSequence, chatStep, chatAction, rtMAction)
	local getRtId = r2.Features["TextManager"].getRtId
	if chatAction.Class == "ChatAction"
	then	
		local who =  r2.Utils.getNpcParam( tostring( chatAction.Who), context)
		-- create say action
		if not who then

			local whoInstance = r2:getInstanceFromId( tostring(chatAction.Who) )
			local chatSequenceInstance = r2:getInstanceFromId(chatSequence.InstanceId)
			
			local whoName = ""
			if whoInstance then  whoName = "(" .. whoInstance.Name ..")" end

			if false then
				printWarning( "Error in ChatStep '" .. chatStep:getName()
				..	"' of the ChatSequence '" .. chatSequence:getName() .. "'"
				.. 	" the field Who '" ..  chatAction.Who .."' is invalid " )
			end

			return nil
				
		end

		if  chatAction.Says ~= "" and chatAction.Says ~= nil
		then
			local param = getRtId(context, tostring(chatAction.Says))
			if param then
				action = r2.Translator.createAction("npc_say", param,   who); 

			--	action = r2.newComponent("RtNpcEventHandlerAction")
			--	action.Action = "npc_say"
			
			--	action.Parameters = who .."\n" .. param
				table.insert(rtMAction.Children, action)
			else
				debugInfo(colorTag(255,255,0).."WRN: Text " .. chatAction.Says .. " error")
			end
	
		end

			-- create emot action
		if tostring(chatAction.Emote) ~= "" and chatAction.Emote ~= nil
		then
			action = r2.newComponent("RtNpcEventHandlerAction")
			action.Action = "emot"
			action.Parameters = tostring(chatAction.Emote).."\n" .. who
			table.insert(rtMAction.Children, action)
		end

		-- create facing action
		if tostring(chatAction.Facing) ~= "" and chatAction.Facing ~= nil
		then
			local facing = r2.Utils.getNpcParam(tostring(chatAction.Facing), context)
			if facing then
				action = r2.newComponent("RtNpcEventHandlerAction")
				action.Action = "facing"
				action.Parameters = facing .."\n" .. who
				table.insert(rtMAction.Children, action)
			else
				printWarning("Can not find npc")
			end
		end
	else
		printWarning( chatAction.Class .. " not implemented yet")
	end
end

Logic.translateChatStep = function(context, chatSequenceNumber, chatSequence, chatStepNumber, chatStep, rtActionSwitchChatStep)
	
	assert(chatStep)
	assert(chatStep.Class == "ChatStep")
	
	if  chatStep.Actions.Size > 0  then

		local rtMAction = r2.Translator.createAction("multi_actions")		
		table.insert(rtActionSwitchChatStep.Children, rtMAction)
		
		local k, chatAction = next(chatStep.Actions, nil)
		while k do
			Logic.translateChatAction(context, chatSequenceNumber, chatStepNumber, chatSequence, chatStep, chatAction, rtMAction)

			local oldChatAction = chatAction
			-- next wait
			do
				
				if (chatStepNumber < chatSequence.Components.Size and chatSequence.Components[chatStepNumber ]) then
				
					local action = r2.Translator.createAction("code", 
						"oldChatStepVar = " .. tostring(chatStepNumber)..";\n"  ..
						Logic.chatStepVar .." = " .. tostring(chatStepNumber+1)..";\n" ..
						"()setTimer(" .. tostring(1+chatSequence.Components[chatStepNumber].Time*10) .. ", " .. Logic.chatTimerId .. ");\n");
					action.Name = "next"
					table.insert(rtMAction.Children, action)
				
				else
					local action = r2.Translator.createAction("code", 
						"oldChatStepVar = " .. tostring(chatStepNumber)..";\n"  ..
						Logic.chatStepVar .." = " .. tostring(chatStepNumber+1)..";\n" ..
						"()setEvent(" ..Logic.EndOfChatSequenceEvent ..");\n" ..
						"if (repeatSequence == 1)\n{\n  " .. Logic.chatSequenceVar .."=" ..Logic.chatSequenceVar ..";\n" ..
						"}\n")

					action.Name = "end_of_chat_sequence"
					table.insert(rtMAction.Children, action)

				end
	
	

			end

			
			k, chatAction = next(chatStep.Actions, k)

		end

		
	else
		local action = r2.Translator.createAction("null_action")
		action.Name = "empty_chat_step_" .. chatStepNumber
		table.insert(rtActionSwitchChatStep.Children, action)
	end

end

Logic.translateChatSequence = function (context, chatSequenceNumber, chatSequence, rtSwitchChatSequence)
	assert(chatSequence)
	assert(chatSequence.Class == "ChatSequence")
	if  chatSequence.Components.Size  > 0  then
		
		local rtActionSwitchChatStep = r2.Translator.createAction("switch_actions", Logic.chatStepVar)
		rtActionSwitchChatStep.Name = "switch_chat_step" 
		table.insert(rtSwitchChatSequence.Children, rtActionSwitchChatStep)
		
		local chatStepNumber = 0
	
		-- initial wait
		do
			local action = r2.Translator.createAction("code", "oldChatStepVar = 0;\n" 
				.. Logic.chatStepVar .." = 1;\n()setTimer(" .. tostring( tonumber(chatSequence.Components[0].Time)*10 + 1) .. ", " .. Logic.chatTimerId ..");\n");
			action.Name = "initial_wait"
			table.insert(rtActionSwitchChatStep.Children, action)
		end

	
		local k, chatStep = next(chatSequence.Components, nil)
		while k do
			chatStepNumber = chatStepNumber + 1
			Logic.translateChatStep(context, chatSequenceNumber, chatSequence, chatStepNumber, chatStep, rtActionSwitchChatStep)
			k, chatStep = next(chatSequence.Components, k)
		end
	else
		local action = r2.Translator.createAction("null_action")
		action.Name = "empty_chat_sequence_" .. chatSequenceNumber
		table.insert(rtSwitchChatSequence.Children, action)
	end
end

Logic.translateChatSequences = function (context, hlComponent, behavior, rtNpcGrp)
	assert(behavior.ChatSequences)
	if behavior.ChatSequences.Size > 0 then
		assert(rtNpcGrp)

		do
			local	event = r2.Translator.createEvent("variable_" ..Logic.chatSequenceVar .."_changed", "", rtNpcGrp.Name)
			event.Name = "activity_sequence_changed"
			table.insert(context.RtAct.Events, event)
			
			local rtInitChatStep = r2.Translator.createAction("code", "oldChatStepVar = -1;\n" .. Logic.chatStepVar .." = 0;\n()setTimer(1, " ..Logic.chatTimerId .. ")\;\n")
			rtInitChatStep.Name = "init_chat_step"
			table.insert(context.RtAct.Actions, rtInitChatStep)
			table.insert(event.ActionsId, rtInitChatStep.Id)
		end
		

		local	event = r2.Translator.createEvent("timer_" ..Logic.chatTimer .."_triggered", "", rtNpcGrp.Name)
		event.Name = "dialog_event"
		table.insert(context.RtAct.Events, event)
			
		local rtSwitchChatSequence = r2.Translator.createAction("switch_actions", Logic.chatSequenceVar)
		rtSwitchChatSequence.Name = "switch_chat_sequence"
		table.insert(context.RtAct.Actions, rtSwitchChatSequence)
		table.insert(event.ActionsId, rtSwitchChatSequence.Id)
		
		local chatSequenceNumber = 0
		local k, chatSequence = next(behavior.ChatSequences, nil)
		while k do
			context.Feature = nil
			chatSequenceNumber = chatSequenceNumber + 1
			Logic.translateChatSequence(context, chatSequenceNumber, chatSequence, rtSwitchChatSequence)	
			k, chatSequence = next(behavior.ChatSequences, k)
		end
	end
end



function Logic.isWanderActivity(activity)
	return activity == "Wander" or activity == "Go To Zone" or activity == "Rest In Zone" or activity == "Feed In Zone"
		or activity == "Hunt In Zone" or activity == "Guard Zone"
end


-------------------------------------------------
--create a transition to go to step number stepNb
--set a timer to go to next step
--select the step
--goto the step's state
Logic.createTransition = function(context,  hlComponent, activitySequence, activityStep, activityStepIndex, stepAction)
	local findChatSequenceIdByInstanceId = function (chat)

		local parent = chat.ParentInstance.ChatSequences
		assert(parent)

		
		local nbSequence = 0
		local k, sequence = next(parent, nil)
		while k do
			if tostring(sequence.InstanceId) == tostring(chat.InstanceId) then return nbSequence end			
 			nbSequence = nbSequence + 1
			k, sequence = next(parent, k)
		end
		return -1
	end

	assert(activityStep)

	local chat = nil


	if activityStep.Chat ~= "" then
		chat = r2:getInstanceFromId( tostring(activityStep.Chat) )
	end

	local code = ""


	local backupState = ""
	local setChatSequence = ""
	local setNextActivity = ""
	local setNextActivityTimer = ""
	local setNextActivityState = ""

	
	backupState =
		"oldChatSequenceVar = " .. Logic.chatSequenceVar .. ";\n" ..
		"RoadCountLimit=0;\n"..
		"oldActivityStepVar = " .. Logic.activityStepVar .. ";\n" ..
		"oldActivityStepVar2 = " .. Logic.activityStepVar.. " + 1;\n"
	
		
	if chat~= nil then		
		local id = findChatSequenceIdByInstanceId( chat )
		assert(id ~= -1 )
		setChatSequence =  Logic.chatSequenceVar .. " = " .. tostring( id ) .. ";\n"		
		if (activityStep.Type == "Repeating") then 
			setChatSequence = setChatSequence .. "repeatSequence = 1;\n" 
		else
			setChatSequence = setChatSequence .. "repeatSequence = 0;\n" 
		end
	end
	
	-- next activity
	setNextActivity =  Logic.activityStepVar .. " = " .. activityStepIndex ..";\n"	

	-- next activity timer
	local param = Logic.getTimeLimit(activityStep)
	if param ~= nil  then
		if Logic.isWanderActivity(activityStep.Activity) then
			-- The time limite is use by the activity
		else
			setNextActivityTimer  = "()setTimer(" .. param ..", " ..Logic.activityStepTimerId .. ");\n"
		end
	end

	local states = Logic.States[activityStep.InstanceId]
	local stateName = states[1].Name

	-- next activity state
	
	setNextActivityState = "()postNextState(\"" .. r2.getNamespace() .. stateName .."\");\n"
	local action = r2.Translator.createAction("code", backupState .. setChatSequence .. setNextActivity .. setNextActivityTimer .. setNextActivityState)


	action.Name = "process_activity_step" .. activityStepIndex
	
	if stepAction then
		local tmpAction = r2.Translator.createAction("multi_actions")
		table.insert(tmpAction.Children, action)
		table.insert(tmpAction.Children, stepAction)		
		action = tmpAction
	end
	
	action.Name = "process_activity_step" .. activityStepIndex
	return action
	
end


------------------------------------------
--cr<63>e une action qui permet de 
--s<>lectionner une s<>quence de chat
Logic.selectDialog = function(dialogNb, rtNpcGrp)
	local action
	local prefix = ""
	if (rtNpcGrp ~= nil) then
		prefix = r2.getNamespace() .. rtNpcGrp .. "." 
	end
		
	action = r2.Translator.createAction("code",
		prefix .."oldChatSequenceVar =" .. prefix..Logic.chatSequenceVar ..";\n" ..
		prefix .. Logic.chatSequenceVar .." = " ..(dialogNb-1)..";\n")
	action.Name = "select_dialog"
	return action
end

--create the actions and events necessary to choose
--the dialog while running sequence
Logic.initDialog = function(context)
	local event = r2.Translator.createEvent("variable_" ..Logic.chatSequenceVar .."_changed", "all_sequence_states", context.Group.Name)
	event.Name = "change_dialog_event"
	Logic.DialogEvent2 = event
	local action
	local mAction = r2.Translator.createAction("multi_actions")
	action = r2.Translator.createAction("code", "oldChatStepVar = " .. Logic.chatStepVar ..";\n" .. Logic.chatStepVar .." = 0;\n")
	action.Name = "reset_dialog"
	table.insert(mAction.Children, action)
	action = r2.Translator.createAction("switch_actions", Logic.chatSequenceVar)
	action.Name = "init_dialog_timer"
	table.insert(mAction.Children, action)
	Logic.DialogAction2 = action
	table.insert(context.RtAct.Events, event)
	table.insert(context.RtAct.Actions, mAction)
	table.insert(event.ActionsId, mAction.Id)


	event = r2.Translator.createEvent("timer_" ..Logic.chatTimer .."_triggered", "all_sequence_states", context.Group.Name)
	event.Name = "dialog_event"
	Logic.DialogEvent = event
	table.insert(context.RtAct.Events, event)

	Logic.DialogAction = r2.Translator.createAction("switch_actions", Logic.chatSequenceVar)
	table.insert(context.RtAct.Actions, Logic.DialogAction)
	table.insert(event.ActionsId, Logic.DialogAction.Id)
end

Logic.initSequence = function(context, rtNpcGrp)
	assert(context)
	assert(rtNpcGrp)

	event = r2.Translator.createEvent("timer_" ..Logic.activityStepTimer .."_triggered", "all_sequence_states", rtNpcGrp.Name)
	event.Name = "sequence_event"
	Logic.SequenceEvent = event
	table.insert(context.RtAct.Events, event)

	Logic.SequenceAction = r2.Translator.createAction("switch_actions", Logic.activityStepVar)
	table.insert(context.RtAct.Actions, Logic.SequenceAction)
	table.insert(event.ActionsId, Logic.SequenceAction.Id)
end

-- ust to implement translateEvents used to implement event created for implementing 
Logic.translateEvent = function( context,  hlComponent, activitySequence, activityStep,  activityStepIndex, event, rtNpcGrp, statesByName)
	local chat = nil
-- context, groups, states, actionToAdd)
	local eventType, eventParam = Logic.getEvent(event)
	local eventHandler = nil

	if context.Events[event.InstanceId] == nil
	then
		eventHandler = r2.Translator.createEvent(eventType, states, groups)
		assert(eventHandler ~= nil)
			
		local stepAction = Logic.translateChatStep(context, event.Action, nil)
			
		if actionToAdd ~= nil
		then
			table.insert(stepAction.Children, actionToAdd)
		end

		assert(stepAction ~= nil)

		table.insert(context.RtAct.Actions, stepAction)
		table.insert(eventHandler.ActionsId, stepAction.Id)
		context.Events[event.InstanceId] = eventHandler
	else
		eventHandler = context.Events[event.InstanceId]
			
		if string.find(eventHandler.StatesByName, states) == nil
		then
			eventHandler.StatesByName = eventHandler.StatesByName .. "\n" .. states
		end

		if string.find(eventHandler.GroupsByName, groups) == nil
		then
			eventHandler.GroupsByName = eventHandler.GroupsByName .. "\n" .. groups
		end
				
	end

	return eventHandler
end

-- translateEvents
Logic.translateEvents = function(context,  hlComponent, activitySequence, activityStep,  activityStepIndex, rtNpcGrp, statesByName)
	
	local activityStep

	local last = nil

	if activityStepIndex == activitySequence.Components.Size then 
		last = true
	end


	local  k, eventId  = next(step.EventsIds, nil)
	do
		local eventHandler = r2:getInstanceFromId(eventId)
		assert(eventHandler ~= nil)
		local action = nil
		
		if  eventHandler.Condition.Type == "At Destination"	then
			if step.Activity == "Follow Route" and last ~= true then
				action = Logic.selectActivityStep(activityStepIndex + 1)
			end
		end

		--the event returned here is a RtNpcEventHandler
		event = translateEvent(context, groups, states, action)
		assert(event ~= nil)
		
		table.insert(context.RtAct.Events, event)
		k, eventId  = next(step.EventsIds, k)
	end
end

--translate an activity step
Logic.translateActivityStep = function(context,  hlComponent, activitySequence, activityStep,  activityStepIndex, rtNpcGrp)

	--translate this activity activityStep's events
	assert(rtNpcGrp)
	local aiState
	local aiState2
	local statesByName
	local groupsByName = rtNpcGrp.Name
	local zone = nil
	local chat = nil
	local aiScriptDebug = false

	local activityStep = activityStep

	if activityStep.Chat ~= "" then
		chat = r2:getInstanceFromId(activityStep.Chat)
		if not chat then
			printErr("translation error: in the activitySequence " .. activitySequence.Name .. " in component " .. hlComponent.Name .. ": " .. " the chat sequence associated to this activity sequence can not be found")
			return nil
		end
	end
		
	local states = Logic.States[activityStep.InstanceId]
	--states creation
	aiState = states[1] -- 1 is first ( a lua object not a instance )

	--setting state AiMovement
	aiState.AiMovement = Logic.getAiMovement(activityStep.Activity)
	assert(aiState.AiMovement ~= "")
	--setting state zone or road


	local positionalActivity= {["Patrol"]		= "road", 
							["Wander"]			= "zone",
							["Repeat Road"]		= "road",		
							["Follow Route"]	= "road",		
							["Rest In Zone"]	= "zone",
							["Feed In Zone"]	= "zone",	
							["Hunt In Zone"]	= "zone",	
							["Guard Zone"]		= "zone",		
							["Go To Zone"]		= "zone",	
							 }
	if positionalActivity[activityStep.Activity] then
		local zone = r2:getInstanceFromId(activityStep.ActivityZoneId)
		if zone == nil then
			aiState = states[1]
			aiState.AiMovement = "idle"
			return aiState
		else
			if positionalActivity[activityStep.Activity] == "zone" then
				if table.getn(zone.Points) < 3 then
					aiState = states[1]
					aiState.AiMovement = "idle"
					return aiState
				end
			else
				if table.getn(zone.Points) < 2 then
					aiState = states[1]
					aiState.AiMovement = "idle"
					return aiState
				end
			end	
		end
	end

	


	if activityStep.Activity == "Patrol" then
		local zone = r2:getInstanceFromId(activityStep.ActivityZoneId)
		if (zone == nil)
		then
			printErr("translation error: in the activitySequence " .. activitySequence.Name .. " in component " .. hlComponent.Name .. ": " .. " the zone associated to the action can not be found")
			return nil
		end

		--un etat aller, un etat retour 
		aiState2 = states[2]
		aiState2.AiMovement = "follow_route"
		Logic.assignZone(aiState, zone, false)
		Logic.assignZone(aiState2, zone, true)

		statesByName = aiState.Name .."\n" .. aiState2.Name
	elseif activityStep.Activity == "Repeat Road" or  activityStep.Activity == "Follow Route" or  activityStep.Activity == "Wander" 
		or activityStep.Activity == "Rest In Zone" or activityStep.Activity == "Feed In Zone" or activityStep.Activity ==  "Hunt In Zone"
		or activityStep.Activity == "Guard Zone" or activityStep.Activity == "Go To Zone" then
		local zone = r2:getInstanceFromId(activityStep.ActivityZoneId)
		if (zone == nil) then
			printErr("translation error: in the activitySequence " .. activitySequence.Name .. " in component " .. hlComponent.Name .. ": " .. " the zone associated to the action can not be found")
			return nil
		end
		Logic.assignZone(aiState, zone, false)
		statesByName = aiState.Name
	else
		statesByName = aiState.Name
	end


	if activityStep.Activity == "Repeat Road" then
		local action
		local event
		--when at end of the road, ...
		event = r2.Translator.createEvent("destination_reached_all", statesByName, groupsByName)
		table.insert(context.RtAct.Events, event)
		--return to the start of the road
		local repeatCount = activityStep.RoadCountLimit
		if not repeatCount then repeatCount = 2 end

		action = r2.Translator.createAction("next_road", groupsByName, aiState.Name, activityStepIndex ,  repeatCount)
		table.insert(context.RtAct.Actions, action)
		table.insert(event.ActionsId, action.Id)

	elseif activityStep.Activity == "Patrol" then
		local action
		local event
		local repeatCount = activityStep.RoadCountLimit
		if not repeatCount then repeatCount = 2 end
		event = r2.Translator.createEvent("destination_reached_all", aiState.Name, groupsByName)
		table.insert(context.RtAct.Events, event)
		action = r2.Translator.createAction("next_road", groupsByName, aiState2.Name, activityStepIndex,  repeatCount)
		action.Name = "return"
		table.insert(context.RtAct.Actions, action)
		table.insert(event.ActionsId, action.Id)

		event = r2.Translator.createEvent("destination_reached_all", aiState2.Name, groupsByName)
		table.insert(context.RtAct.Events, event)
		action = r2.Translator.createAction("next_road", groupsByName, aiState.Name, activityStepIndex ,  repeatCount)
		action.Name = "go"
		table.insert(context.RtAct.Actions, action)
		table.insert(event.ActionsId, action.Id)

	elseif activityStep.Activity == "Follow Route" or activityStep.Activity == "Go To Start Point" or activityStep.Activity == "Go To Zone" then
		local action
		local event
		event = r2.Translator.createEvent("destination_reached_all", aiState.Name, groupsByName)
		table.insert(context.RtAct.Events, event)
		action =  Logic.selectActivityStep(activityStepIndex + 1)
		table.insert(context.RtAct.Actions, action)
		table.insert(event.ActionsId, action.Id)
	elseif activityStep.Activity == "Rest In Zone" then
		local wanderTime = 100
		local restTime = 300
		r2.Translator.createActivityInZone(context, aiState.Name, groupsByName, "Rest", Logic.activityInternalTimerId, wanderTime, restTime, aiScriptDebug)
	elseif activityStep.Activity == "Feed In Zone" then
		local wanderTime = 50
		local feedTime = 150
		r2.Translator.createActivityInZone(context, aiState.Name, groupsByName, "Eat", Logic.activityInternalTimerId, wanderTime, feedTime, aiScriptDebug)
	elseif activityStep.Activity == "Hunt In Zone" then
		local wanderTime = 100
		local alertTime = 25
		local eatTime = 80
		r2.Translator.createHuntActivityInZone(context, aiState.Name, groupsByName, Logic.activityInternalTimerId, wanderTime, alertTime, eatTime, aiScriptDebug)
	elseif activityStep.Activity == "Guard Zone" then
		r2.Translator.createSimpleActivityInZone(context, aiState.Name, groupsByName, "Alert", false, aiScriptDebug)
	end


	if Logic.isWanderActivity(activityStep.Activity) and activityStep.TimeLimit == "Few Sec" then
		local event = r2.Translator.createEvent("destination_reached_all", aiState.Name, groupsByName)
		table.insert(context.RtAct.Events, event)
		local action =  r2.Translator.createAction("wander_destination_reached",  groupsByName, aiState.Name,activityStepIndex , tonumber(activityStep.TimeLimitValue))
		table.insert(context.RtAct.Actions, action)
		table.insert(event.ActionsId, action.Id)
	end

	local stepAction = nil	
	if activityStep.Activity == "Stand Up" then
		stepAction = r2.Translator.createAction("stand_up", rtNpcGrp.Id )		
	elseif activityStep.Activity == "Sit Down" then
		stepAction = r2.Translator.createAction("sit_down", rtNpcGrp.Id )		
	end
	

	-- translate event create by activitySequence (eg patrol)
	if activityStep.EventsIds.Size ~= 0
	then
		Logic.translateEvents(context,  hlComponent, activitySequence, activityStep,  activityStepIndex, rtNpcGrp, statesByName)
	end


	
	--go to next activityStep
	local action = Logic.createTransition(context,  hlComponent, activitySequence, activityStep, activityStepIndex, stepAction)
	table.insert(Logic.SequenceAction.Children, action)


	-- if ActivityStep.TimeLimit == "Chat" creates a eventhandler to go to next state
	
	if activityStep.TimeLimit == "Chat" then
		local action
		local condition
		local event

		local number = Logic.findChatSequenceIdByInstanceId(hlComponent, chat.InstanceId)	
		if (number == nil or number == -1) then
			printWarning("Error in translation:  in component '" .. hlComponent.Name .. " the chat sequence selected as time limit of Activity Step " .. activityStepIndex .. " does not exist.")

		end
	
		

		event = r2.Translator.createEvent("user_event_8", aiState.Name,  rtNpcGrp.Id)
		table.insert(context.RtAct.Events, event)

	
		
		condition =  r2.Translator.createAction("condition_if", "v0  == "..tostring(number-1))
		table.insert(context.RtAct.Actions, condition)

		
		action =  Logic.selectActivityStep(activityStepIndex + 1)
		table.insert(condition.Children, action)
		table.insert(event.ActionsId, condition.Id)


	end

	assert(State ~= "")
	return aiState
end

---------------------------------------------------------------------------------------
--helpers functions--
---------------------------------------------------------------------------------------


Logic.getAiMovement = function(activity)
	assert(activity and type(activity) == "string")
	if (activity == "Follow Route") or (activity == "Patrol") or (activity == "Repeat Road") then
		return "follow_route"
	elseif activity == "Deploy" then
		return "stand_on_vertices"
	elseif activity == "Wander" or activity == "Go To Zone" or activity == "Rest In Zone" or activity == "Feed In Zone"
		or activity == "Hunt In Zone" or activity == "Guard Zone" then
		return "wander"
	elseif activity == "Stand Still" or activity == "Inactive" or activity == "Stand Up" or activity == "Sit Down" then
		return "idle"
	elseif activity == "Stand On Start Point" or activity == "Go To Start Point" then
		return "stand_on_start_point"
	end
	
	printWarning("Undef activity '"..activity.."'")
	assert(nil)
	return ""
end

Logic.getAction = function(action)
local action_type = action.Action

	if action_type == "Sit Down"
	then
		return "sit_down"
	end
	if action_type == "Stand Up"
	then
		return "stand_up"
	end
	if action_type == "Go To Step"
	then
		if action.Parameter == nil or action.Parameter == ""
		then
			return nil
		end
		return "go_to_step"
	end
	if action_type == "Set Activity"
	then
		if action.Parameter == nil or action.Parameter == ""
		then
			return nil
		end
		return "set_activity"
	end

	if action_type == "Stop Actions"
	then
		return "stop_actions"
	end

	if action_type == "Start Mission"
	then	
		return "start_mission"
	end

	return nil
end

Logic.getEvent = function(Event)
	local i = Logic.find(Logic.EventTypes, Event.Condition.SourceType)
	--Time event type
	if i == 0
	then
	end
	
	--place event type
	if i == 1
	then
	end

	--entity event type
	if i == 2
	then
		if Event.Condition.Type == "At Destination"
		then
			return "destination_reached_all"
		end
		
		if Event.Condition.Type == "Is Attacked"
		then
			return "group_under_attack"
		end

		if Event.Condition.Type == "Enters State"
		then
			return "start_of_state"
		end

		if Event.Condition.Type == "Leaves State"
		then
			return "end_of_state"
		end
		if Event.Condition.Type == "Activity Is"
		then				
		end
	end

	--State Machine event type
	if i == 3
	then
	end

	--Counter event type
	if i == 4
	then
		local counterName = Event.Parameter
		local param
		
		if counterName == nil
		then
			
		end

		if string.find(Event.Condition.Type, "v%d_changed") ~= nil
		then
			return "variable_" ..Event.Condition.Type
		end

		if Event.Condition.Type == "Equals"
		then
			param = " = "
		else
			if Event.Condition.Type == "Lesser"
			then
				param = " < "
			else
				if Event.Condition.Type == "Greater"
				then
					param = " > "
				else
					param = nil
				end
			end
		end
		if param == nil
		then
			return nil
		end
		param = param ..Event.Condition.ConditionParameter

		return "variable_changed", param
	end
end

Logic.checkEvent = function(eventMode, sourceType, sourceId, conditionType, parameter)
	local eventTypeInd = Logic.find(Logic.EventTypes, sourceType)
	local conditionTypeInd
	if eventTypeInd == nil
	then
		return false
	end

	--{"Time", "Place", "Entity or Group", "State Machine", "Counter"}

	conditionTypeInd = Logic.find(Logic.ConditionTypes[eventTypeInd], conditionType)
	if eventTypeInd == nil
	then
		return false
	end

	--Time event type
	if eventTypeInd == 0
	then
	end

	--Place event type
	if eventTypeInd == 1
	then
	end

	--Entity or Group event type
	if eventTypeInd == 2
	then
		if parameter == nil or parameter == ""
		then
			if conditionType == "At Destination" or conditionType == "Is Attacked"
			then
				return true
			else
				return false
			end
		else
			if conditionType == "Enters State" or conditionType == "Leaves State"
			then
				return true
			else
				return false
			end
		end
	end

	--State Machine event type
	if eventTypeInd == 3
	then
	end

	--Counter event type
	if eventTypeInd == 4
	then
		if string.find(conditionType, "v%d_changed") ~= nil
		then
			return true
		end
		if conditionType == "Lesser" or conditionType == "Greater" or conditionType == "Equals"
		then
			return true
		end
	end

	return false

end

Logic.fillCondition = function(condition, sourceType, sourceId, conditionType, conditionParameter)
	condition.SourceType = sourceType
	condition.SourceId = sourceId
	condition.Type = conditionType
	condition.ConditionParameter = conditionParameter
end

Logic.fillEvent = function(event, eventMode, sourceType, sourceId, conditionType, conditionParameter)
	if Logic.checkEvent(eventMode, sourceType, sourceId, conditionType, conditionParameter) == false
	then
		assert(0)
		return false
	end

	Logic.fillCondition(event.Condition, sourceType, sourceId, conditionType, conditionParameter)
	event.EventMode = eventMode
	return true
end
-----------------------------------------
--genere le parametre de l'action set_timer
Logic.getTimeLimit = function(step)
	local param = ""

	if step.TimeLimit == "Few Sec" then
		local limit = tonumber(step.TimeLimitValue)
		limit = 1 + limit * 10
		param = tostring( limit )
		return param
	end
	return nil
end
	
Logic.getActivityInitialStateName = function(groupId, activityNb, context)
	local group = context.Components[groupId]
	local activity = group.Components[1].Behavior.Activities[activityNb]
	
	if activity == nil
	then
		return nil
	end

	local activityStates = Logic.ActivitiesStates[activity.InstanceId]
	return activityStates[activity.InstanceId][0].Name
end

--return the states used to represent this step activity
Logic.getActivityStepStates = function(activity, stepNb)
	local activityStates = Logic.ActivitiesStates[activity.InstanceId]
	local states = activityStates[activity.Components[stepNb].InstanceId]
	return states
end

Logic.find = function(array, elem)
	local i = 0
	for k, v in pairs(array)
	do
		if k ~="Keys"
		then
			if elem == v
			then
				return i
			end
			i = i + 1
		end
	end
	return nil
end



Logic.findChatSequenceIdByInstanceIdImpl = function(instance, instanceId)
	local behvior = instance:getBehavior()
	local k, sequence = next(behvior.ChatSequences, nil)
	local nbSequence = 0
	while k do
		nbSequence = nbSequence + 1
		if tostring(sequence.InstanceId) == instanceId then return nbSequence end
		 k, sequence = next(behvior.ChatSequences, k)
	end
	return -1
end

Logic.findChatSequenceIdByInstanceId = function(target, instanceId)
	local instance =target
	return Logic.findChatSequenceIdByInstanceIdImpl(instance, instanceId)

end

-- target -> hlNpc or hlNpcGrp
Logic.findChatStepIdByInstanceId = function(target, instanceId)
	assert( type(target) == "userdata")
	local nbSequence = 0
	local nbStep = 0

	local instance = target
	assert(instance ~= nil)
	local behavior = instance:getBehavior()
	assert(behavior ~= nil)
	local k2, sequence = next(behavior.ChatSequences, nil)
	while k2 do

		nbSequence = nbSequence + 1
		nbStep =  0
		local k, step = next(sequence.Components, nil)
		while k do
			nbStep = nbStep  +1
			if tostring(step.InstanceId) == instanceId then return {nbStep, nbSequence} end
			k, step = next(sequence.Components, k)
		end
		 k2, sequence = next(behavior.ChatSequences, k2)
	end
	assert(0)
	return {-1, -1}
end

-- target is a NpcGrp or a Npc or a CustomNpc
Logic.findActivitySequenceIdByInstanceId = function(target, instanceId)
	assert( type(target) == "userdata")
	
	local nbSequence = 0
	local behavior = nil

	behavior = target:getBehavior()

	if behavior == nil then
		debugInfo("Error: try to find activity Sequence on an unknown entity of type " .. target.Class )
		assert(nil)
	end

	local npc = behavior.ParentInstance
	local grp = behavior.ParentInstance.ParentInstance
	if not npc:isGrouped() then grp = nil end
	

	local k, sequence  = next(behavior.Activities, nil)
	while (k ~= nil) do

		nbSequence = nbSequence + 1
		if sequence.InstanceId == instanceId then
			if grp then return {nbSequence, grp} end
			if npc then return {nbSequence, npc} end
			assert(nil)
		end
		k, sequence  = next(behavior.Activities, k)
	end
	return {-1, nil}
end

Logic.findActivityStepIdByInstanceId = function(target, instanceId)
	assert( type(target) == "userdata")
	local nbSequence = 0
	local nbStep = 0
	local comp = target
	local behavior = comp:getBehavior()
	
	local k, sequence = next(behavior.Activities, nil)
	while k do

		if tostring(sequence.InstanceId) == instanceId then
			assert(nil) -- use findActivityStep instead of findactivitySequence
		end

		nbSequence = nbSequence + 1
		nbStep =  0
		local k2, step = next(sequence.Components, nil)
		while (k2) do
			nbStep = nbStep  +1
			if tostring(step.InstanceId) == instanceId then return {nbStep, nbSequence} end
			k2, step = next(sequence.Components, k2)
		end
		k, sequence = next(behavior.Activities, k)
	end
	return {-1, -1}
end





Logic.selectActivityStep = function(stepNb)
	local action 
	stepNb = stepNb - 1

	action  = r2.Translator.createAction("code", 
		Logic.activityStepVar .. " = " .. stepNb ..";\n"
		.. "()setTimer(1, " ..Logic.activityStepTimerId .. ");\n")
	action.Name = "select_activity_step " .. stepNb

	return action
end



----------------------------------------------------------------------------
-- add a line to the event menu

local component = Logic.Components.ChatSequence


----------------------------------------------------------------------------
-- add a line to the event menu
function component:getLogicTranslations()

	local logicTranslations = {
		["ApplicableActions"] = {
			["starts dialog"]			= { menu=i18n.get( "uiR2AA0ChatSeqStart"		):toUtf8(), 
											text=i18n.get( "uiR2AA1ChatSeqStart"		):toUtf8()},
			["stops dialog"]			= { menu=i18n.get( "uiR2AA0ChatSeqStop"			):toUtf8(), 
											text=i18n.get( "uiR2AA1ChatSeqStop"			):toUtf8()},
			["starts chat"]				= { menu=i18n.get( "uiR2AA0ChatStepStart"		):toUtf8(), 
											text=i18n.get( "uiR2AA1ChatStepStart"		):toUtf8()},
			["continues dialog"]				= { menu=i18n.get( "uiR2AA0ChatStepContinue"		):toUtf8(), 
											text=i18n.get( "uiR2AA1ChatStepContinue"		):toUtf8()},
		},
		["Events"] = {	
			["start of dialog"]			= { menu=i18n.get( "uiR2Event0ChatSeqStart"		):toUtf8(), 
											text=i18n.get( "uiR2Event1ChatSeqStart"		):toUtf8()},
			["end of dialog"]			= { menu=i18n.get( "uiR2Event0ChatSeqEnd"		):toUtf8(), 
											text=i18n.get( "uiR2Event1ChatSeqEnd"		):toUtf8()},
			["start of chat"]			= { menu=i18n.get( "uiR2Event0ChatStepStart"	):toUtf8(), 
											text=i18n.get( "uiR2Event1ChatStepStart"	):toUtf8()},
			["end of chat"]				= { menu=i18n.get( "uiR2Event0ChatStepEnd"		):toUtf8(), 
											text=i18n.get( "uiR2Event1ChatStepEnd"		):toUtf8()},
		},
		["Conditions"] = {	
			["is in dialog"]			= { menu=i18n.get( "uiR2Test0ChatSeq"			):toUtf8(), 
											text=i18n.get( "uiR2Test1ChatSeq"			):toUtf8()},
			["is not in dialog"]		= { menu=i18n.get( "uiR2Test0ChatNotSeq"		):toUtf8(), 
											text=i18n.get( "uiR2Test1ChatNotSeq"		):toUtf8()},
			["is in chat"]				= { menu=i18n.get( "uiR2Test0ChatStep"			):toUtf8(), 
											text=i18n.get( "uiR2Test1ChatStep"			):toUtf8()},
		}
	}
	return logicTranslations
end


r2.Features["ActivitySequence"] = Logic