#GAMESTATE_DRAW_GUI_KEEPER=1

Strict

Import mojo


#If GAMESTATE_DRAW_GUI_KEEPER=1 
Import lss.ax.swapper.guiswapper
#End


Class GameState
	
	'summary: The current GameState that is active. Note that you shouldn't change this! Use the Functions 'MakeActive' and 'CloseActive' instead! 
	Global active:GameState
	
	'summary: The stack of GameStates that was active.
	Global stack:List<GameState> = New List<GameState>
	
	#If GAMESTATE_DRAW_GUI_KEEPER=1 
	Global doGuiHover:Bool = True
	#End
	
	#Rem
		summary: MakeActive activates a New Gamestate And place the Current active gamestate on the stack.
		
		The New created gamestate will get the 'OnActivation' method fired.	
		
		[i]parameters:[/i]
		toActivate:GameState - your gamestate extend that you want To activate.
		whipeOld:Bool        - True, If you want To close the old one (you dont need a levelmenu on the stack, Right?  )
	#End
	Function MakeActive:Int(toActivate:GameState, whipeOld:Bool = False)
		If (active <> Null) Then
			If (stack.Contains(active)) Then
				stack.Remove(active)
			EndIf
			
			If whipeOld = False Then stack.AddLast(active)
			
			If whipeOld = False Then active.OnPause()
			
			
		EndIf
		
		Local tmp:GameState = active
		
		active = toActivate
		
		active.OnActivation(tmp)
		
		If whipeOld Then tmp.OnClose()
		
		
		Return True;
	
	End
	
	#Rem
		summary: Closes that Current active gamestate. 
		
		The gamestack that was closed will get the 'OnClose' method fired.
		It also pop's the last gamestate of the stack and fire the 'OnResume' method for it.
		
		Returns True, If it was possible To close the Current active gamestate, False otherwise (no more gamestates Left!)
	#End
	Function CloseActive:Int()
		Local ret:Int = 0
		
		If (active <> Null) Then
			active.OnClose()
			active = Null
			ret = True
		EndIf
		
		If (stack.Count() > 0)
			active = stack.RemoveLast()
			
			active.OnResume()
		
		EndIf
		
		Return ret
	End
	
	#Rem
		summary: Render() should get called in the App's onRender method. It overtake the rendering!
		
		Returns False, If it was Not possible To call an active gamestate.
	#End
	Function Render:Int(doCls:Int = True)
		If (active <> Null)
		
			If (doCls > 0) Then Cls
			
			PushMatrix()
			active.OnRender()
			PopMatrix()
			
			#If GAMESTATE_DRAW_GUI_KEEPER=1 
			PushMatrix()
		'	debugAlpha = True
		'	Print("Rendere GuiKeeper")
			GuiKeeper.Draw(doGuiHover)
		'	Print("---------------")
		'	debugAlpha = False
			PopMatrix()
			#End
			
			PushMatrix()
			active.OnGuiRender()
			PopMatrix()
		Else
			Return 0;
			
		EndIf
		Return 1;
	End
	#Rem
		summary: Minib3dRender() should get called in the App's onRender method. It overtake the rendering! Note: Its a slightly different version of render, designed to work with Minib3d propebly (Minib3d hates PopMatrix() !)
		
		Returns False, If it was Not possible To call an active gamestate.
	#End
	Function Minib3dRender:Int()
		If (active <> Null)
		
			
			active.OnRender()
		
			#If GAMESTATE_DRAW_GUI_KEEPER=1 
		
				GuiKeeper.Draw(doGuiHover)
			
			#End
			
			active.OnGuiRender()
			
		Else
			Return 0;
			
		EndIf
		Return 1;
	End
	
	#Rem
		summary: Update() should get called in the App's onUpdate method.
		
		Returns False, If it was Not possible To call an active gamestate.
	#End
	Function Update:Int()
		If (active <> Null)
			
			active.OnUpdate()
		Else
			Return 0;
			
		EndIf
		Return 1;
	End
	
	#Rem
		summary: Provides a simple shortcut To call "active.OnFoucsLost" If app.OnSuspend() is called.
		So, simply Call this in your entry app And process some logics in the active gamestates!
	#End
	Function FocusLost:Int()
		If active Then active.OnFocusLost()
		Return 1
	End
	#Rem
		summary: Provides a simple shortcut To call "active.OnFoucsGain" If app.OnResume() is called.
		So, simply Call this in your entry app And process some logics in the active gamestates!
	#End
	Function FocusGain:Int()
		If active Then active.OnFocusGain()
		Return 1
	End
	#Rem
		summary: Provides a simple shortcut To call "OnBack" For every gamestate, If app.OnBack() is callde.
		So, simply Call this in your entry app And process some logics in the gamestates!
	#End
	Function Back:Int()
		For Local g:GameState = EachIn GameState.stack
			g.OnBack(active)
		Next
		Return 1
	End
	
	
	Function Loading:Int()
		If active Then active.OnLoading()
		
		Return 1
	End
	'summary: The default new() method calls OnCreate.
	Method New()
	'Print "BASE NEW CALLED!"
		Self.OnCreate();  		
	End
	
	'summary: OnCreate is called if you make an instance of a gamestate (-extend). Use this to load some Ressources or fill the field.
	Method OnCreate:Int()
		Return True
	End
	
	'summary: OnLoading is called when the App is "OnLoading"
	Method OnLoading:Int()
		
		Return True
	End
	
	'summary: OnActivation is called if you use the GameState.MakeActive() method.
	Method OnActivation:Int(oldGamestate:GameState)
		Return True
	End
	
	'summary: OnClose is called if you use the GameState.CloseActive() method. Use this to unload ressources.
	Method OnClose:Int()
		Return True
	End
	
	'summary: OnRender is called before the OnGuiRender method. General drawings should be done here (player, map...)
	Method OnRender:Int()
		Return True
	End
	
	'summary: OnGuirender is called after the OnRender method. Draw stuff like the gui here, it will overlay the normal rendered stuff. 
	Method OnGuiRender:Int()
		Return True
	End
	
	'summary: OnUpdate is called out of the GameState.Update() method. Its called before the Render methods. Place general gamelogic in here.
	Method OnUpdate:Int()
		Return True
	End
	
	'summary: It will get called on a focus change. 
	Method OnFocusGain:Int()
		Return True
	End
	
	'summary: It will get called on a focus change.
	Method OnFocusLost:Int()
		Return True
	End
	
	'summary: OnPause is called, if a current active gamestate is pushed on the stack. It will "pause" its working, until it its popped out again.
	Method OnPause:Int()
		Return True
	End
	
	'summary: OnResume is called, if a gamestate is popped out of the stack. It will be the new active gamestate.
	Method OnResume:Int()
		Return True
	End
	
	#Rem
		summary: OnBack is called For EVERY gamestate (Not only the active one!) when the App.OnBack() Method is fired.
		The "active" parameter lets you check with "if active = self", If its called For the active gamestate.
	#End
	Method OnBack:Int(active:GameState)
		Return True
	End
	
	
End