NUM_BALLS = 3
NUM_HOLES = 4

BallGameSettings = {
	--el acelerometro me da un valor en +-1
	--estos param son el maximo de inclinacion al que va a ser sensible el juego.
	xAmplitude = 0.7, --mayor que cero y hasta 1
	yAmplitude = 0.5, -- mayor q cero y hasta 1
	--estos valores (en el rango +-1) se mapean con una funcion exponencial
	--en valor absoluto, y este es el exponente.
	xExponent = 1, -- 3
	yExponent = 1, -- 3
	--estos valores se traducen en movimiento en los ejes vertical y horizontal del ojo de la camara multiplicando por:
	--velocidad en que se mueve la camara: 30
	camSpeed = 60.0, -- 60
	--multiplica a la anterior en cada eje
	camXSpeedMultiplier = 1.0,
	camYSpeedMultiplier = 1.0,
	--cada posicion del eyeoffset se interpola dsde el paso anterior linealmente con t = 0.15 por defecto para que no haya vibracion
	interpolator = 0.2, -- 0.3 significa 0.3 del incremento actual y 0.7 del anterior
	--valores de la fisica
	gravity = 1.0, 
	ballMass = 8.0, -- 10
	ballFriction = 0.15, -- 0.15
	ballRestitution = 0.2, -- 0.2
	ballAngularDamping = 0.9, -- 0.9
}

ball_colour = 0
g_timesCompleted = 0

hole_colours = {
{{0.755, 0.0, 0.0, 1.0},{0.098, 0.106, 0.11, 1.0}},
{{0.0, 0.824, 0.102, 1.0},{0.098, 0.106, 0.11, 1.0}},
{{0.0, 0.0, 0.82, 1.0},{0.098, 0.106, 0.11, 1.0}},
{{0.986, 0.971, 0.0, 1.0},{0.098, 0.106, 0.11, 1.0}},
}
ball_scenes = {}
ball_scenes[E_LEVEL_EASY] = "gameCaramelos/gamecaramelosbg.mesh"
ball_scenes[E_LEVEL_NORMAL] = "gameCaramelos/gamecaramelosbg2.mesh"
ball_scenes[E_LEVEL_HARD] = "gameCaramelos/gamecaramelosbg3.mesh" 

function hole(_ndx)
	if IsMenuState() then return end
		
	log("Entra la bola en el agujero " .. _ndx .. "!!!!!!!!!!!!!!!!!!!!")
	--Salgo del estado!!
	if ball_colour == _ndx then
		g_timesCompleted = g_timesCompleted + 1
		if isGame4Ended() then
			log("Correct! Game ended")
			g_currentState:setNextState(TGame4CongratulationsState:new())
		else
			log("Correct! Game NOT ended")
			g_currentState:setNextState(TGame4GreatState:new())
		end
	else
		log("Wrong!")
		g_currentState:setNextState(TGame4FailState:new())
	end
	
	FinishBallGameState()
end

function triggerHole(_ndx)
	log("creando trigger del agujero " .. _ndx .. "!!!!!!!!!!!!!!!!!!!!")
	return { name = "hole".._ndx , inScript = [[ 	Sound.PlaySound(g_Sound.fx.game4.ballInHole)
												EnqueueTimeExecuteScript('hole(]] .. _ndx .. [[)',1)]]}
end

function random_and_setup_game4()
	ball_colour = math.random(NUM_HOLES)
	scramble_colours()
	assign_colours()
end

function assign_colours()
	log("\n<<<<<<<<<<ASSIGNING COLOURS!!\n")
	for i = 1, NUM_HOLES, 1 do
		SetEffectParamColor("Ground", "hole" .. i .. "_material","g_matDiffuse", hole_colours[i][1])
	end
	--SetEffectParamColor("Ball", "ball_material","g_ambientColor", hole_colours[ball_colour])
	DeactivateActor("Ground",false)
	ActivateActor("Ground",false)
	log("asigned")
	--PauseBallGameState()
	--ResumeBallGameState()
end

function scramble_colours()
	log("INPUT LIST: (#hole_colours " .. #hole_colours .. ")")
	for i = 1, #hole_colours, 1 do
		log("hole #" .. i .. " = " .. table.tostring(hole_colours[i]))
	end

	for i = 1, #hole_colours * 2, 1 do
		local random_ndx1 = math.random( #hole_colours )
		local random_ndx2 = math.random( #hole_colours )
		log("swaping " .. random_ndx1 .. " for " .. random_ndx2)
		local value_aux = hole_colours[random_ndx1]
		hole_colours[random_ndx1] = hole_colours[random_ndx2]
		hole_colours[random_ndx2] = value_aux
	end
	
	log("OUTPUT LIST: ")
	for i = 1, #hole_colours, 1 do
		log("hole_colours #" .. i .. " = " .. table.tostring(hole_colours[i]))
	end
end

function isGame4Ended ()
	return g_timesCompleted >= NUM_BALLS
end

---------------------------------------------------
--Great, Congratulations and Fail
---------------------------------------------------
TGame4CongratulationsState = TState:new{
	m_name = "TGame4CongratulationsState",
	events = {
		onBegin = function(_self)		
				DeactivateActor("pause")
				IncrementPointsAndSave(E_LEVEL_GAME4)
				Sound.PlaySound(g_Sound.fx.game4.congratulations)
				--local auxState = _self:findParent("TRootState")
				--auxState:setNextState(TMainMenuFadeIn:new())
				return {
					actors = {
							{	actorType = "ActorGeom", 
								properties = { name = "Win", model = "efectos/congratulationcicle.mesh", touchable = false, layer = LF_PANELS+1,  camera = "game1"    },
							},
							{	actorType = "ActorGeom", 
								properties = { name = "CubePart", model = g_cubePartMeshes[4], touchable = false, layer = LF_PANELS + 2,  camera = "game1"  },
							},
						},
						setAnims = {
							{	actorName = "Win",
								properties = { anim = "efectos/congratulationcicle.anm", loop = false, }
							},
							{	actorName = "CubePart",
								properties = { anim = g_cubePartAnms[4], loop = false, }
							},
						}
				}
		end,
		onAnimEnded = {
			All = function(_self)
				--local auxState = _self:findParent("TRootState")
				_self.superState:setNextState(TGame4FadeOutState:new())
			end,
		}
	}
}

TGame4GreatState = TState:new{
	m_name = "TGame4GreatState",
	events = {
		onBegin = function(_self)
				Sound.PlaySound(g_Sound.fx.game4.great)
				DeactivateActor("pause")		
				return {	
					actors = {
						{	actorType = "ActorGeom", 
							properties = { name = "Win", model = "efectos/great.mesh", touchable = false, layer = LF_PANELS, camera = "game1" },
						},
					},
					setAnims = {
						{	actorName = "Win",
							properties = { anim = "efectos/greatCicle.anm", loop = false, }
						},
					}
				}
		end,
		
		onAnimEnded = {
			Win = function(_self)
				log("RANDOM!!!!!!!!")
				random_and_setup_game4()
				
				local auxState = _self:findParent("TGame4BallIn")
				auxState.superState:setNextState(TGame4BallIn:new())
			end,
		}		
	}
}

TGame4FailState = TState:new{
	m_name = "TGame4FailState",
	events = {
		onBegin = function(_self)
			log("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!FAIL!!!")
			Sound.PlaySound(g_Sound.fx.game4.wrong)
			DeactivateActor("pause")
			return {
					actors = {
						{	actorType = "ActorGeom", 
							properties = { name = "Fail", model = "efectos/wrong.mesh", touchable = false, layer = LF_PANELS, camera = "game1"},
						},
					},
					setAnims = {
						{	actorName = "Fail",
							properties = { anim = "efectos/wrongIn.anm", loop = false, }
						},
					}
				}
		end,
		onAnimEnded = {
			Fail = function(_self) 
					--_self.superState:setNextState(TGame4BallRespawn:new())
					_self:findParent("TRootState")
				local auxState = _self:findParent("TGame4BallIn")
				auxState.superState:setNextState(TGame4BallIn:new())
			end
		},
	}
}

--------------------------------------
-- Objeto representando a la palabra que sea...
--------------------------------------
TGame4BallRespawn = TState:new{
	m_name = "TGame4BallRespawn",
	events = 
	{
		onBegin = function(_self)
			ActivateActor("pause")
			_self:setNextState(TGame4BallIn:new())
		end,
	},
	changeAfterBeginning = true
}

TGame4BallIn = TState:new{
	m_name = "TGame4BallIn",
	events = 
	{
		onBegin = function(_self)
			ActivateActor("pause")
			ActivateGroundNodeCollision("ground")
			_self:setNextState(TGame4BallAndSceneSetup:new())
			return {
					actors = {
						{	actorType = "BallActor", 
							properties = { name = "Ball", model = "gameCaramelos/ball.mesh" },
						},					
					},
					setAnims = {},
					}
		end,
		onClick = {
			backButton = function(_self)
				pause()
			end,
		}
	},
	changeAfterBeginning = true
}

TGame4BallAndSceneSetup = TState:new{
	m_name = "TGame4BallAndSceneSetup",
	events = 
	{
		--seteffectparams....
		onBegin = function(_self)
			SetEffectParamColor("Ball", "ball_material","g_matDiffuse", hole_colours[ball_colour][1])
			SetEffectParamColor("Ball", "ball_material","g_ambientColor", hole_colours[ball_colour][2])
			assign_colours()
			_self:setNextState(TGame4LoopState:new())
		end,
	},
	changeAfterBeginning = true
}

--------------------------------------
-- Pantalla de instrucciones del juego
--------------------------------------
TGame4InstructionsOut = TState:new{
	m_name = "TGame4InstructionsOut",
	events = 
	{
		onBegin = function(_self) 
			return {
						setAnims = {
							{	actorName = "Instructions",
								properties = { anim = "gameCaramelos/tutorialOut.anm", loop = false, }
							},
						}
					}
		end,
		onAnimEnded =
		{
			Instructions = function(_self) 
				--estado del juego, en espera...
				_self.superState.superState:setNextState(TGame4BallIn:new())
			end,
		},
		onFinish = function(_self)
		end,
	}
}

TGame4InstructionsWait = TState:new{
	m_name = "TGame4InstructionsWait",
	events = 
	{
		onBegin = function(_self) 
			return {
						setAnims = {
							{	actorName = "Instructions",
								properties = { anim = "gameCaramelos/tutorialCicle.anm", loop = true, }
							},
						}
					}
			
		end,
		onClick =
		{
			button = function(_self) 
				_self.superState:setNextState(TGame4InstructionsOut:new())
			end,
		},
		onFinish = function(_self)
		end,
	}
}

TGame4InstructionsIn = TState:new{
	m_name = "TGame4InstructionsIn",
	events = 
	{
		onBegin = function(_self) 
				log("AGH creo el panel de instruciones")
			return {
						actors = {
							{	actorType = "ActorGeom", 
								properties = { name = "Instructions", model = "gameCaramelos/tutorialCaramelos.mesh", touchable = true, camera = "game3", layer = LF_PANELS },
							},
						},
						setAnims = {
							{	actorName = "Instructions",
								properties = { anim = "gameCaramelos/tutorialIn.anm", loop = false, }
							},
						}
					}		
		end,
		onAnimEnded =
		{
			Instructions = function(_self)
				_self:setNextState(TGame4InstructionsWait:new())
			end,
		},
		onFinish = function(_self)
		end,
	}
}
---------------------------------------------------

TGame4LoopState = TState:new{
	m_name = "TGame4LoopState",
	events = 
	{
		onBegin = function(_self)			
			--_self:setNextState(_self)
			log("")
			log("COMIENZO EL ESTADO DE JUEGO!")
			log("")
			local auxState = _self:findParent("TGame4BallIn")
			auxState:setNextState(auxState)
			--
			StartBallGameState()
		end,
		onClick = {
			backButton = function(_self)
				pause()
			end,
		}
				
	}
}

TGame4InitialSetup = TState:new{
	m_name = "TGame4InitialSetup",
	events = 
	{
		onBegin = function(_self)
			random_and_setup_game4()
			_self:setNextState(TGame4InstructionsIn:new())
		end
	}
}

TGame4CycleAfterFadeInState = TState:new{
	m_name = "TGame4CycleAfterFadeInState",
	events = 
	{
	
		onBegin = function(_self)
			_self:setNextState(TGame4InitialSetup:new())
			DeactivateActor("pause")
			--[[
			return {
			
				setAnims = {
						{	actorName = "Background",
								properties = { anim = "gameNumeros/numerosBgCicle.anm", loop = true, }
						},
					},	
				}
			]]
			end,
	},
	changeAfterBeginning = true
}

TGame4FadeInState = TState:new{
	m_name = "TGame4FadeInState",
	m_bLoad = false,
	events = 
	{
		onBegin = function(_self)
			Game4Started()
			ChangeCamera("game4")
			loadFxsGame4()
			Sound.PlayMusic(g_Sound.music.game4Theme)
			g_difficulty_game4 = getDifficulty(E_LEVEL_GAME4)
			if not _self.m_bLoad then 
				g_timesCompleted = 0 
			end
			g_currentGame = E_LEVEL_GAME4
			_self:setNextState(TGame4CycleAfterFadeInState:new())
			log("creando escena ".. ball_scenes[g_difficulty_game4])
			SaveGameProgress()
			if IsMrHatLite then
				return {
					actors = {
						{	actorType = "GroundActor", 
							properties = { name = "Ground", model = ball_scenes[g_difficulty_game4], groundNodes = "ground"},
						},
						{	actorType = "ActorGeom", 
							properties = { name = "Fade", model = "fadeblack.mesh", touchable = false, layer = LF_PANELS+4 },
						},
					},
					setAnims = {
						{	actorName = "Fade",
							properties = { anim = "fadeblackout.anm", loop = false, }
						},
					}
				}
			else	
			return {
					actors = {
						{	actorType = "ActorGeom", 
							properties = { name = "pause", model = "menuPause/pauseButton.mesh", touchable = true, camera = "game1", layer = LF_PANELS+3 },
						},
						{	actorType = "GroundActor", 
							properties = { name = "Ground", model = ball_scenes[g_difficulty_game4], groundNodes = "ground"},
						},
						{	actorType = "ActorGeom", 
							properties = { name = "Fade", model = "fadeblack.mesh", touchable = false, layer = LF_PANELS+4 },
						},
					},
					setAnims = {
						{	actorName = "Fade",
							properties = { anim = "fadeblackout.anm", loop = false, }
						},
					}
				}
			end
		end,
		onFinish = function()
			Sound.StopMusic(g_Sound.music.game4Theme)
			releaseFxSoundResources(g_Sound.fx.game4)
		end
	},
	changeAfterBeginning = true
}

TGame4IntroState = TState:new{
	m_name = "TGame4IntroState",
	events = {
		onBegin = function(_self)
			OpenVideoURL(g_Video.game4.intro, "g_currentState:finish()")
			_self:setNextState(_self)
		end,
		onFinish = function(_self)
			local auxState = _self:findParent("TRootState")
			auxState:setNextState(TGame4FadeInState:new())
		end
	}
}

TGame4EndingState = TState:new{
	m_name = "TGame4EndingState",
	events = {
		onBegin = function(_self)
			if(not IsMrHatLite) then
				OpenVideoURL(g_Video.game4.ending, "g_currentState:finish()")
				_self:setNextState(_self)
			end
		end,
		onFinish = function(_self)
			local auxState = _self:findParent("TRootState")
			if(not IsMrHatLite) then
				auxState:setNextState(TMainMenuFadeIn:new{ m_givePrizeOnGame = E_LEVEL_GAME4 }:new())
			else
				auxState:setNextState(TBuyFullVersionState:new())
			end
		end
	}
}

TGame4FadeOutState = TState:new{
		m_name = "TGame4FadeOutState",
		events = 
		{
			onBegin = function() 
					return {
						actors = {
							{	actorType = "ActorGeom", 
								properties = { name = "Fade2", model = "fadeblack.mesh", touchable = false, layer = LF_PANELS+4 },
							},
						},
						setAnims = {
							{	actorName = "Fade2",
								properties = { anim = "fadeblackin.anm", loop = false, }
							},
						}
					}
			end,
			onAnimEnded =
			{
				Fade2 = function(_self) 
					log("Fade ended")
					log("BIEN!, onFinish de " .. _self.m_name)	
					--_self.superState:setNextState(nil)
					FinishBallGameState()
					local aux = _self:findParent("TRootState")
					aux:setNextState(TGame4EndingState:new())
					end,
			},
		}
}