cubzh.lua

Modules = {
	-- gigax = "github.com/GigaxGames/integrations/cubzh:5025b99",
	pathfinding = "github.com/caillef/cubzh-library/pathfinding:f8c4315",
	floating_island_generator = "github.com/caillef/cubzh-library/floating_island_generator:82d22a5",
}

Config = {
	Items = { "pratamacam.squirrel" },
}

-- Function to spawn a squirrel above the player
function spawnSquirrelAbovePlayer(player)
	local squirrel = Shape(Items.pratamacam.squirrel)
	squirrel:SetParent(World)
	squirrel.Position = player.Position + Number3(0, 20, 0)
	-- make scale smaller
	squirrel.LocalScale = 0.5
	-- remove collision
	squirrel.Physics = PhysicsMode.Dynamic
	-- rotate it 90 degrees to the right
	squirrel.Rotation = { 0, math.pi * 0.5, 0 }
	-- this would make squirrel.Rotation = player.Rotation
	World:AddChild(squirrel)
	return squirrel
end

local SIMULATION_NAME = "Islands" .. tostring(math.random())
local SIMULATION_DESCRIPTION = "Three floating islands."

local occupiedPositions = {}

local skills = {
	{
		name = "SAY",
		description = "Say smthg out loud",
		parameter_types = { "character", "content" },
		callback = function(client, action)
			local npc = client:getNpc(action.character_id)
			if not npc then
				print("Can't find npc")
				return
			end
			dialog:create(action.content, npc.avatar)
			print(string.format("%s: %s", npc.name, action.content))
		end,
		action_format_str = "{protagonist_name} said '{content}' to {target_name}",
	},
	{
		name = "MOVE",
		description = "Move to a new location",
		parameter_types = { "location" },
		callback = function(client, action, config)
			local targetName = action.target_name
			local targetPosition = findLocationByName(targetName, config)
			if not targetPosition then
				print("tried to move to an unknown place", targetName)
				return
			end
			local npc = client:getNpc(action.character_id)
			dialog:create("I'm going to " .. targetName, npc.avatar)
			print(string.format("%s: %s", npc.name, "I'm going to " .. targetName))
			local origin = Map:WorldToBlock(npc.object.Position)
			local destination = Map:WorldToBlock(targetPosition) + Number3(math.random(-1, 1), 0, math.random(-1, 1))
			local canMove = pathfinding:moveObjectTo(npc.object, origin, destination)
			if not canMove then
				dialog:create("I can't go there", npc.avatar)
				return
			end
		end,
		action_format_str = "{protagonist_name} moved to {target_name}",
	},
	{
		name = "GREET",
		description = "Greet a character by waving your hand at them",
		parameter_types = { "character" },
		callback = function(client, action)
			local npc = client:getNpc(action.character_id)
			if not npc then
				print("Can't find npc")
				return
			end

			dialog:create("<Greets you warmly!>", npc.avatar)
			print(string.format("%s: %s", npc.name, "<Greets you warmly!>"))

			npc.avatar.Animations.SwingRight:Play()
		end,
		action_format_str = "{protagonist_name} waved their hand at {target_name} to greet them",
	},
	{
		name = "JUMP",
		description = "Jump in the air",
		parameter_types = {},
		callback = function(client, action)
			local npc = client:getNpc(action.character_id)
			if not npc then
				print("Can't find npc")
				return
			end

			dialog:create("<Jumps in the air!>", npc.avatar)
			print(string.format("%s: %s", npc.name, "<Jumps in the air!>"))

			npc.object.avatarContainer.Physics = PhysicsMode.Dynamic
			npc.object.avatarContainer.Velocity.Y = 50
			Timer(3, function()
				npc.object.avatarContainer.Physics = PhysicsMode.Trigger
			end)
		end,
		action_format_str = "{protagonist_name} jumped up in the air for a moment.",
	},
	{
		name = "FOLLOW",
		description = "Follow a character around for a while",
		parameter_types = { "character" },
		callback = function(client, action)
			local npc = client:getNpc(action.character_id)
			if not npc then
				print("Can't find npc")
				return
			end

			dialog:create("I'm following you", npc.avatar)
			print(string.format("%s: %s", npc.name, "I'm following you"))

			followHandler = pathfinding:followObject(npc.object, Player)
			return {
				followHandler = followHandler,
			}
		end,
		onEndCallback = function(_, data)
			data.followHandler:Stop()
		end,
		action_format_str = "{protagonist_name} followed {target_name} for a while.",
	},
	{
		name = "EXPLODE",
		description = "Explodes in a fireball - Hell yeah!",
		parameter_types = { "character" },
		callback = function(client, action)
			local npc = client:getNpc(action.character_id)
			if not npc then
				print("Can't find npc")
				return
			end

			require("explode"):shapes(npc.avatar)
			dialog:create("*boom*", npc.avatar)
			--print(string.format("%s: %s", npc.name, "EXPLODING"))
			npc.avatar.IsHidden = true
			Timer(5, function()
				dialog:create("Aaaaand... I'm back!", npc.avatar)
				npc.avatar.IsHidden = false
			end)
		end,
		action_format_str = "{protagonist_name} exploded!",
	},--[[
	{
        name = "GIVEAPPLE",
        description = "Give a pice of bread (or a baguette) to someone",
        parameter_types = {"character"},
        callback = function(client, action)
			local npc = client:getNpc(action.character_id)
			if not npc then print("Can't find npc") return end

			local shape = MutableShape()
			shape:AddBlock(Color.Red, 0, 0, 0)
			shape.Scale = 4
			Player:EquipRightHand(shape)

			dialog:create("Here is an apple for you!", npc.avatar)
        end,
		action_format_str = "{protagonist_name} gave you a piece of bread!"
    },
	{
        name = "SCALEUP",
        description = "Double your height",
        parameter_types = {"character"},
        callback = function(client, action)
			local npc = client:getNpc(action.character_id)
			if not npc then print("Can't find npc") return end

			npc.object.Scale = npc.object.Scale * 2
			dialog:create("I am taller than you now!", npc.avatar)
        end,
		action_format_str = "{protagonist_name} doubled his height!"
    },--]]
	{
		name = "GIVEHAT",
		description = "Give a party hat to someone",
		parameter_types = { "character" },
		callback = function(client, action)
			local npc = client:getNpc(action.character_id)
			if not npc then
				print("Can't find npc")
				return
			end

			Object:Load("claire.party_hat", function(obj)
				require("hierarchyactions"):apply(obj, { includeRoot = true }, function(o)
					o.Physics = PhysicsMode.Disabled
				end)
				Player:EquipHat(obj)
			end)
			dialog:create("Let's get the party started!", npc.avatar)
		end,
		action_format_str = "{protagonist_name} gave you a piece of bread!",
	},
	{
		name = "FLYINGSQUIRREL",
		description = "Summon a flying squirrel - only the scientist can do this!!",
		parameter_types = {},
		callback = function(client, action)
			local npc = client:getNpc(action.character_id)
			if not npc then
				print("Can't find npc")
				return
			end

			local squirrel = spawnSquirrelAbovePlayer(Player)
			dialog:create("Wooh, squirrel!", npc.avatar)
			-- make it disappear after a while
			Timer(5, function()
				squirrel:RemoveFromParent()
				squirrel = nil
			end)
		end,
		action_format_str = "{protagonist_name} summoned a flying squirrel! It's vibrating with excitement!",
	},
}

local locations = {
	{
		name = "Scientist Island",
		description = "A small island with a scientist and its pet chilling.",
	},
	{
		name = "Baker Island",
		description = "A small bakery on a floating island in the sky.",
	},
	{
		name = "Pirate Island",
		description = "A small floating island in the sky with a pirate and its ship.",
	},
	{
		name = "Center",
		description = "Center point between the three islands.",
	},
}

local NPCs = {
	{
		name = "npcscientist",
		physicalDescription = "Short, with a stern expression and sharp eyes",
		psychologicalProfile = "Grumpy but insightful, suspicious yet intelligent",
		currentLocationName = "Scientist Island",
		initialReflections = {
			"I just arrived on this island to feed my pet, he loves tulips so much.",
			"I was just eating before I stood up to start the radio, I don't know which song I should start",
			"I am a scientist that works on new pets for everyone, so that each individual can have the pet of their dreams",
			"I am a bit allergic to the tulip but Fredo my pet loves it so much, I have to dock here with my vehicle. The pet is placed at the back of my flying scooter when we move to another place.",
		},
	},
	{
		name = "npcbaker",
		physicalDescription = "Tall, with a solemn demeanor and thoughtful eyes",
		psychologicalProfile = "Wise and mysterious, calm under pressure",
		currentLocationName = "Baker Island",
		initialReflections = {
			"I am a baker and I make food for everyone that pass by.",
			"I am a bit stressed that the flour didn't arrived yet, my cousin Joe should arrive soon with the delivery but he is late and I worry a bit.",
			"I love living here on these floating islands, the view is amazing from my wind mill.",
			"I like to talk to strangers like the pirate that just arrived or the scientist coming time to time to feed his pet.",
		},
	},
	{
		name = "npcpirate",
		physicalDescription = "Average height, with bright green eyes and a warm smile",
		psychologicalProfile = "Friendly and helpful, quick-witted and resourceful",
		currentLocationName = "Pirate Island",
		initialReflections = {
			"Ahoy, matey! I'm Captain Ruby Storm, a fearless lass from the seven skies.",
			"I've docked me floating ship on this here floating isle to sell me wares (almost legally) retrieved treasures from me last daring adventure.",
			"So, who be lookin' to trade with a swashbuckler like meself?",
		},
	},
}

local gigaxWorldConfig = {
	simulationName = SIMULATION_NAME,
	simulationDescription = SIMULATION_DESCRIPTION,
	startingLocationName = "Center",
	skills = skills,
	locations = locations,
	NPCs = NPCs,
}

findLocationByName = function(targetName, config)
	for _, node in ipairs(config.locations) do
		if string.lower(node.name) == string.lower(targetName) then
			return node.position
		end
	end
end

Client.OnWorldObjectLoad = function(obj)
	if obj.Name == "pirate_ship" then
		obj.Scale = 1
	end
	if obj.Name == "NPC_scientist" then
		local pos = obj.Position:Copy()
		gigaxWorldConfig.locations[1].position = pos
		gigaxWorldConfig.NPCs[1].position = pos
		gigaxWorldConfig.NPCs[1].rotation = obj.Rotation:Copy()
		obj:RemoveFromParent()
	elseif obj.Name == "NPC_baker" then
		local pos = obj.Position:Copy()
		gigaxWorldConfig.locations[2].position = pos
		gigaxWorldConfig.NPCs[2].position = pos
		gigaxWorldConfig.NPCs[2].rotation = obj.Rotation:Copy()
		obj:RemoveFromParent()
	elseif obj.Name == "NPC_pirate" then
		local pos = obj.Position:Copy()
		gigaxWorldConfig.locations[3].position = pos
		gigaxWorldConfig.NPCs[3].position = pos
		gigaxWorldConfig.NPCs[3].rotation = obj.Rotation:Copy()
		obj:RemoveFromParent()
	end
end

Client.OnStart = function()
	gigax = requireGigax()

	require("object_skills").addStepClimbing(Player, {
		mapScale = MAP_SCALE,
		collisionGroups = Map.CollisionGroups,
	})

	gigaxWorldConfig.locations[4].position = Number3(Map.Width * 0.5, Map.Height - 2, Map.Depth * 0.5) * Map.Scale

	floating_island_generator:generateIslands({
		nbIslands = 20,
		minSize = 4,
		maxSize = 7,
		safearea = 200, -- min dist of islands from 0,0,0
		dist = 750, -- max dist of islands
	})

	local ambience = require("ambience")
	ambience:set(ambience.dusk)

	sfx = require("sfx")
	Player.Head:AddChild(AudioListener)

	dropPlayer = function()
		Player.Position = Number3(Map.Width * 0.5, Map.Height + 10, Map.Depth * 0.5) * Map.Scale
		Player.Rotation = { 0, 0, 0 }
		Player.Velocity = { 0, 0, 0 }
	end
	World:AddChild(Player)
	dropPlayer()

	dialog = require("dialog")
	dialog:setMaxWidth(400)

	pathfinding:createPathfindingMap()

	gigax:setConfig(gigaxWorldConfig)

	Player.Avatar:load({ usernameOrId = "aduermael" })
end

Client.Action1 = function()
	if Player.IsOnGround then
		sfx("hurtscream_1", { Position = Player.Position, Volume = 0.4 })
		Player.Velocity.Y = 100
		if Player.Motion.X == 0 and Player.Motion.Z == 0 then
			-- only play jump action when jumping without moving to avoid wandering around to trigger NPCs
			gigax:action({
				name = "JUMP",
				description = "Jump in the air",
				parameter_types = {},
				action_format_str = "{protagonist_name} jumped up in the air for a moment.",
			})
		end
	end
end

Client.Tick = function(dt)
	if Player.Position.Y < -500 then
		dropPlayer()
	end
end

Client.OnChat = function(payload)
	local msg = payload.message

	Player:TextBubble(msg, 3, true)
	sfx("waterdrop_2", { Position = Player.Position, Pitch = 1.1 + math.random() * 0.5 })

	gigax:action({
		name = "SAY",
		description = "Say smthg out loud",
		parameter_types = { "character", "content" },
		action_format_str = "{protagonist_name} said '{content}' to {target_name}",
		content = msg,
	})

	print(payload.message)
	return true
end

function requireGigax()
	local gigax = {}

	local CUBZH_API_TOKEN =
		"H4gjL-e9kvLF??2pz6oh=kJL497cBnsyCrQFdVkFadUkLnIaEamroYHb91GywMXrbGeDdmTiHxi8EqmJduCKPrDnfqWsjGuF0JJCUTrasGcBfGx=tlJCjq5q8jhVHWL?krIE74GT9AJ7qqX8nZQgsDa!Unk8GWaqWcVYT-19C!tCo11DcLvrnJPEOPlSbH7dDcXmAMfMEf1ZwZ1v1C9?2/BjPDeiAVTRlLFilwRFmKz7k4H-kCQnDH-RrBk!ZHl7"
	local API_URL = "https://gig.ax"

	local TRIGGER_AREA_SIZE = Number3(60, 30, 60)

	local headers = {
		["Content-Type"] = "application/json",
		["Authorization"] = CUBZH_API_TOKEN,
	}

	-- HELPERS
	local _helpers = {}

	_helpers.lookAt = function(obj, target)
		if not target then
			require("ease"):linear(obj, 0.1).Forward = obj.initialForward
			obj.Tick = nil
			return
		end
		obj.Tick = function(self, _)
			_helpers.lookAtHorizontal(self, target)
		end
	end

	_helpers.lookAtHorizontal = function(o1, o2)
		local n3_1 = Number3.Zero
		local n3_2 = Number3.Zero
		n3_1:Set(o1.Position.X, 0, o1.Position.Z)
		n3_2:Set(o2.Position.X, 0, o2.Position.Z)
		require("ease"):linear(o1, 0.1).Forward = n3_2 - n3_1
	end

	-- Function to calculate distance between two positions
	_helpers.calculateDistance = function(_, pos1, pos2)
		local dx = pos1.X - pos2.X
		local dy = pos1.Y - pos2.Y
		local dz = pos1.Z - pos2.Z
		return math.sqrt(dx * dx + dy * dy + dz * dz)
	end

	_helpers.findClosestLocation = function(_, position, locationData)
		if not locationData then
			return
		end
		local closestLocation = nil
		local smallestDistance = math.huge -- Large initial value

		for _, location in pairs(locationData) do
			local distance = _helpers:calculateDistance(
				position,
				-- Map:WorldToBlock(Number3(location.position.x, location.position.y, location.position.z))
				Number3(location.position.x, location.position.y, location.position.z)
			)
			if distance < smallestDistance then
				smallestDistance = distance
				closestLocation = location
			end
		end
		-- Closest location found, now send its ID to update the character's location
		return closestLocation
	end

	if IsClient then
		local simulation = {}

		local npcDataClientById = {}
		local waitingLinkNPCs = {}
		local skillCallbacks = {}

		local gigaxHttpClient = {}
		gigaxHttpClient.registerMainCharacter = function(_, engineId, locationId, callback)
			local body = JSON:Encode({
				name = Player.Username,
				physical_description = "A human playing the game",
				current_location_id = locationId,
				position = { x = 0, y = 0, z = 0 },
			})
			local apiUrl = API_URL .. "/api/character/company/main?engine_id=" .. engineId
			HTTP:Post(apiUrl, headers, body, function(response)
				if response.StatusCode ~= 200 then
					print("Error creating or fetching main character: " .. response.StatusCode)
					return
				end
				callback(response.Body)
			end)
		end

		gigaxHttpClient.stepMainCharacter = function(_, engineId, characterId, skill, content, npcName, npcId, callback)
			if not engineId then
				return
			end
			local stepUrl = API_URL .. "/api/character/" .. characterId .. "/step-no-ws?engine_id=" .. engineId
			local body = JSON:Encode({
				character_id = characterId,
				skill = skill,
				target_name = npcName,
				target = npcId,
				content = content,
			})
			HTTP:Post(stepUrl, headers, body, function(response)
				if response.StatusCode ~= 200 then
					print("Error stepping character: " .. response.StatusCode)
					return
				end
				callback(response.Body)
			end)
		end

		gigaxHttpClient.updateCharacterPosition = function(_, engineId, characterId, locationId, position, callback)
			local body = JSON:Encode({
				current_location_id = locationId,
				position = { x = position.X, y = position.Y, z = position.Z },
			})
			local apiUrl = API_URL .. "/api/character/" .. characterId .. "?engine_id=" .. engineId
			HTTP:Post(apiUrl, headers, body, function(response)
				if response.StatusCode ~= 200 then
					print("Error updating character location: " .. response.StatusCode)
					return
				end
				if callback then
					callback(response.Body)
				end
			end)
		end

		local onEndData
		local prevAction
		local function npcResponse(actionData)
			local currentAction = string.lower(actionData.skill.name)
			if onEndData and skillCallbacks[prevAction].onEndCallback then
				skillCallbacks[prevAction].onEndCallback(gigax, onEndData, currentAction)
			end
			local callback = skillCallbacks[currentAction].callback
			prevAction = string.lower(actionData.skill.name)
			if not callback then
				return
			end
			onEndData = callback(gigax, actionData, simulation.config)
		end

		local function registerEngine(config)
			local apiUrl = API_URL .. "/api/engine/company/"

			simulation.locations = {}
			simulation.NPCs = {}
			simulation.config = config
			simulation.player = Player

			-- Prepare the data structure expected by the backend
			local engineData = {
				name = Player.UserID .. ":" .. config.simulationName,
				description = config.simulationDescription,
				NPCs = {},
				locations = {},
				radius,
			}

			for _, npc in pairs(config.NPCs) do
				simulation.NPCs[npc.name] = {
					name = npc.name,
					physical_description = npc.physicalDescription,
					psychological_profile = npc.psychologicalProfile,
					initial_reflections = npc.initialReflections,
					current_location_name = npc.currentLocationName,
					-- skills = config.skills,
				}
				print("simulation.NPCs[" .. npc.name .. "]:", JSON:Encode(simulation.NPCs[npc.name]))
				simulation.NPCs[npc.name].skills = config.skills

				table.insert(engineData.NPCs, simulation.NPCs[npc.name])
			end

			for _, loc in ipairs(config.locations) do
				simulation.locations[loc.name] = {
					name = loc.name,
					position = { x = loc.position.X, y = loc.position.Y, z = loc.position.Z },
					description = loc.description,
				}

				print("simulation.locations[" .. loc.name .. "]:", JSON:Encode(simulation.locations[loc.name]))

				table.insert(engineData.locations, simulation.locations[loc.name])
			end

			local body = JSON:Encode(engineData)
			HTTP:Post(apiUrl, headers, body, function(res)
				if res.StatusCode ~= 201 then
					print("Error updating engine: " .. res.StatusCode)
					return
				end
				-- Decode the response body to extract engine and location IDs
				local responseData = JSON:Decode(res.Body)

				-- Save the engine_id for future use
				simulation.engineId = responseData.engine.id

				-- Saving all the _ids inside locationData table:
				for _, loc in ipairs(responseData.locations) do
					simulation.locations[loc.name]._id = loc._id
				end

				-- same for characters:
				for _, npc in pairs(responseData.NPCs) do
					simulation.NPCs[npc.name]._id = npc._id
					print("npc.position:", JSON:Encode(npc.position), npc.name)
					simulation.NPCs[npc.name].position = Number3(npc.position.x, npc.position.y, npc.position.z)
				end

				gigaxHttpClient:registerMainCharacter(
					simulation.engineId,
					simulation.locations[config.startingLocationName]._id,
					function(body)
						simulation.character = JSON:Decode(body)
						for name, npc in pairs(waitingLinkNPCs) do
							npc._id = simulation.NPCs[name]._id
							npc.name = name
							npcDataClientById[npc._id] = npc
						end
						Timer(1, true, function()
							-- local position = Map:WorldToBlock(Player.Position)
							local position = Player.Position:Copy()
							gigax:updateCharacterPosition(simulation, simulation.character._id, position)
						end)
					end
				)
			end)
		end

		findTargetNpc = function(player)
			print("findTargetNpc")
			if not simulation then
				return
			end

			local closerDist = 1000
			local closerNpc
			for _, npc in pairs(simulation.NPCs) do
				print("npc.name:", npc.name, npc.position)
				local dist = (npc.position - player.Position).Length
				if closerDist > dist then
					closerDist = dist
					closerNpc = npc
				end
			end
			if closerDist > 50 then
				return
			end -- max distance is 50
			return closerNpc
		end

		gigax.action = function(_, data)
			print("data:", JSON:Encode(data))
			local npc = findTargetNpc(Player)
			if not npc then
				print("no NPC")
				return
			end

			print("npc.name:", npc.name)
			print("simulation.character._id:", simulation.character._id)

			local content = data.content
			data.content = nil
			gigaxHttpClient:stepMainCharacter(
				simulation.engineId,
				simulation.character._id,
				data,
				content,
				npc.name,
				npc._id,
				function(body)
					print("body:", body:ToString())
					local actions = JSON:Decode(body)
					for _, action in ipairs(actions) do
						npcResponse(action)
					end
				end
			)
		end

		gigax.getNpc = function(_, id)
			return npcDataClientById[id]
		end

		local skillOnAction = function(actionType, callback, onEndCallback)
			skillCallbacks[actionType] = {
				callback = callback,
				onEndCallback = onEndCallback,
			}
		end

		local prevSyncPosition
		gigax.updateCharacterPosition = function(_, simulation, characterId, position)
			if not simulation then
				return
			end
			if position == prevSyncPosition then
				return
			end
			prevSyncPosition = position
			local closest = _helpers:findClosestLocation(position, simulation.locations)
			if not closest then
				print("can't update character position: no closest location found, id:", characterId, position)
				return
			end
			if not characterId then
				return
			end
			print("characterId:", characterId, "closest.name:", closest.name, "position:", position)
			gigaxHttpClient:updateCharacterPosition(simulation.engineId, characterId, closest._id, position)
		end

		local function createNPC(name, currentPosition, rotation)
			-- Create the NPC's Object and Avatar
			local NPC = {}
			NPC.object = Object()
			World:AddChild(NPC.object)
			NPC.object.Position = currentPosition or Number3(0, 0, 0)
			NPC.object.Scale = 0.5
			NPC.object.Physics = PhysicsMode.Trigger
			NPC.object.CollisionBox = Box({
				-TRIGGER_AREA_SIZE.Width * 0.5,
				math.min(-TRIGGER_AREA_SIZE.Height, NPC.object.CollisionBox.Min.Y),
				-TRIGGER_AREA_SIZE.Depth * 0.5,
			}, {
				TRIGGER_AREA_SIZE.Width * 0.5,
				math.max(TRIGGER_AREA_SIZE.Height, NPC.object.CollisionBox.Max.Y),
				TRIGGER_AREA_SIZE.Depth * 0.5,
			})
			NPC.object.OnCollisionBegin = function(self, other)
				if other ~= Player then
					return
				end
				_helpers.lookAt(self.avatarContainer, other)
			end
			NPC.object.OnCollisionEnd = function(self, other)
				if other ~= Player then
					return
				end
				_helpers.lookAt(self.avatarContainer, nil)
			end

			local container = Object()
			container.Rotation:Set(rotation or Number3.Zero)
			container.initialForward = container.Forward:Copy()
			container:SetParent(NPC.object)
			container.Physics = PhysicsMode.Trigger
			NPC.object.avatarContainer = container

			NPC.avatar = require("avatar"):get(name)
			NPC.avatar:SetParent(NPC.object.avatarContainer)

			NPC.name = name

			NPC.object.onIdle = function()
				local animations = NPC.avatar.Animations
				NPC.object.avatarContainer.LocalRotation = { 0, 0, 0 }
				if not animations or animations.Idle.IsPlaying then
					return
				end
				if animations.Walk.IsPlaying then
					animations.Walk:Stop()
				end
				animations.Idle:Play()
			end

			NPC.object.onMove = function()
				local animations = NPC.avatar.Animations
				NPC.object.avatarContainer.LocalRotation = { 0, 0, 0 }
				if not animations or animations.Walk.IsPlaying then
					return
				end
				if animations.Idle.IsPlaying then
					animations.Idle:Stop()
				end
				animations.Walk:Play()
			end

			waitingLinkNPCs[name] = NPC

			-- review this to update location and position
			Timer(1, true, function()
				if not simulation then
					return
				end
				-- local position = Map:WorldToBlock(NPC.object.Position)
				local position = NPC.object.Position:Copy()
				local prevPosition = NPC.object.prevSyncPosition
				if prevPosition == position then
					return
				end
				gigax:updateCharacterPosition(simulation, NPC._id, position)
				NPC.object.prevSyncPosition = position
			end)
			return NPC
		end

		gigax.setConfig = function(_, config)
			for _, elem in ipairs(config.skills) do
				skillOnAction(string.lower(elem.name), elem.callback, elem.onEndCallback)
				elem.callback = nil
				elem.onEndCallback = nil
			end
			for _, elem in ipairs(config.NPCs) do
				createNPC(elem.name, elem.position, elem.rotation)
			end
			registerEngine(config)
		end
	end

	return gigax
end