good starting point ?

Monkey Forums/Monkey Beginners/good starting point ?

GC-Martijn

(Posted 2015) [#1]

Maybe i'm going to try the new mojo2, and want to make a good start.
Using some examples, and this deltatimer (did some tests in a other topic)
https://github.com/Regal-Internet-Brothers/deltatime/blob/master/LICENSE

My target is: desktop,ios,android

What I have is this, what do you think ?
Are there some faults already inside this setup ?

file1.monkey

Strict

Import mojo2
Import configfile

Import classes.deltatime
Import classes.game
Import classes.editor

Class MyApp Extends App Final

	Field canvas:Canvas
	Field DeltaTime:DeltaTime
	Field Capped:Bool
	
	Field game:Game
	Field editor:Editor
	
	Method OnCreate:Int()
		SetUpdateRate(0)
		SetSwapInterval(1)
		Shader.SetDefaultShader(Shader.FastShader())
		
		canvas = New Canvas()
		DeltaTime = New DeltaTime(60, 0.0, 4)
		
		game = New Game(canvas,DeltaTime)
		editor = New Editor(canvas,DeltaTime,game)
		
		Capped = True
		Return 0
	End
	
	Method OnRender:Int()
		DeltaTime.Update()
		canvas.Clear()
		
		game.Render()

		If editor Then 
			editor.Render()
		End
				
		canvas.Flush()
		Return 0
	End
	
	Method OnUpdate:Int()
		game.Update()

		If editor Then 
			editor.Update()
		End
		
		If (Not Capped) Then
			SetSwapInterval(1)
			Capped = True
		Else
			SetSwapInterval(0)
			Capped = False
		Endif
		Return 0
	End
	
	Method OnLoading:Int()
		Return 0
	End
	Method OnResize:Int()
		Return 0
	End
	Method OnSuspend:Int()
		Return 0
	End
	Method OnResume:Int()
		'dt.currentticks = Millisecs()
		'dt.lastticks = dt.currentticks
		Return 0
	End	
	Method OnClose:Int()
		Return Super.OnClose()
	End 
	Method OnBack:Int()
		Return Super.OnBack()
	End
End

Function Main:Int()
	New MyApp
	Return 0
End

classes/game.monkey

Strict
Import mojo2
Import deltatime

Class Game
	Field canvas:Canvas
	Field DeltaTime:DeltaTime
	
	Method New(_canvas:Canvas,_DeltaTime:DeltaTime)
		canvas = _canvas
		DeltaTime = _DeltaTime
	End
	
	Method Render:Void()
		canvas.SetColor(1.0, 1.0, 1.0)
		canvas.DrawText "HELLO WORLD!",DeviceWidth()/2,DeviceHeight()/2,.5,.5
		Return
	End	

	Method Update:Void()
		Local Delta:Float = DeltaTime.Delta
		' X -= (Speed * Delta)
			
		Return
	End	
	
End Class

classes/editor.monkey

Strict
Import mojo2
Import deltatime
Import game

Class Editor

	Field canvas:Canvas
	Field DeltaTime:DeltaTime
	Field game:Game
	
	Method New(_canvas:Canvas,_DeltaTime:DeltaTime,_game:Game)
		canvas = _canvas
		DeltaTime = _DeltaTime
		game=_game
	End
	
	Method Render:Void()
		Return
	End	

	Method Update:Void()
		Local Delta:Float = DeltaTime.Delta
		' X -= (Speed * Delta)
		Return
	End	
End Class

classes/deltatime.monkey

Strict
Import mojo.app

Class DeltaTime
	Global Default_FPS:Int = 60
	Global Default_DeltaLog_Size:Int = 20
	Global Default_MinimumDelta:Float = 0.0 ' 0.1
	
	' Constructor(s):
	Method New(MinimumDelta:Float=Default_MinimumDelta, DeltaLog_Size:Int=Default_DeltaLog_Size)
		Construct(MinimumDelta, DeltaLog_Size)
	End
	
	Method New(FPS:Int, MinimumDelta:Float=Default_MinimumDelta, DeltaLog_Size:Int=Default_DeltaLog_Size)
		Construct(FPS, MinimumDelta, DeltaLog_Size)
	End
	
	Method Construct:DeltaTime(MinimumDelta:Float=Default_MinimumDelta, DeltaLog_Size:Int=Default_DeltaLog_Size)
		Local FPS:= UpdateRate()
		
		If (FPS <> 0) Then
			Self.UseUpdateRate = True
		Endif
		
		' Call the main implementation.
		Return Construct(FPS, MinimumDelta, DeltaLog_Size)
	End
	
	Method Construct:DeltaTime(FPS:Int, MinimumDelta:Float=Default_MinimumDelta, DeltaLog_Size:Int=Default_DeltaLog_Size)
		If (FPS = 0) Then
			FPS = Default_FPS
		Endif
		
		' Assign the ideal frame-rate to the input.
		Self.IdealFPS = FPS
		
		' Set the previous frame's time value to the current time.
		Self.TimePreviousFrame = Millisecs()
		
		' Assign the current frame's time-value to the same as the previous frame.
		Self.TimeCurrentFrame = Self.TimePreviousFrame ' Millisecs()
		
		' Set the minimum delta-value.
		Self.MinimumDelta = MinimumDelta
		
		If (Self.DeltaLog.Length > 0) Then
			Self.DeltaLog = Self.DeltaLog.Resize(DeltaLog_Size)
		Else
			Self.DeltaLog = New Float[DeltaLog_Size]
		Endif
		
		' Return this object so it may be pooled.
		Return Self
	End
	
	' Destructor(s):
	
	' This is just a quick wrapper for 'Free'.
	Method Discard:DeltaTime()
		Return Free()
	End
	
	Method Free:DeltaTime()
		Reset()
		
		' Return this object so it may be pooled.
		Return Self
	End
	
	' Methods:
	Method Reset:Void(FPS:Int, CatchUp:Bool=False)
		' Set the ideal framerate.
		IdealFPS = FPS
		
		' Call the main implementation.
		Reset(CatchUp)
		
		Return
	End
	
	Method Reset:Void(CatchUp:Bool=False)
		' Set the previous frame's time value to the current time.
		If (Not CatchUp) Then
			TimePreviousFrame = Millisecs()
		Else
			TimePreviousFrame = TimeCurrentFrame
		Endif
		
		' Assign the current frame's time-value to the same as the previous frame.
		TimeCurrentFrame = Millisecs()
		
		' Set the 'delta' to 0.0.
		Delta = 0.0
		
		' Set the delta-node to zero.
		DeltaNode = 0
		
		' Reset the delta-log.
		ResetLog()
		
		Return
	End
	
	Method ResetLog:Void()
		ResetLog(DeltaLog)
		
		Return
	End
	
	Method ResetLog:Void(DeltaLog:Float[])
		' Set all of the delta-log's elements to 0.0.
		For Local Index:= 0 Until DeltaLog.Length
			DeltaLog[Index] = 0.0
		Next
		
		Return
	End
	
	Method Update:Void()
		' Check if we're supposed to be using the update-rate:
		If (UseUpdateRate) Then
			' Check if the update-rate is different from the ideal framerate.
			If (Self._IdealFPS <> UpdateRate()) Then ' IdealFPS
				' "Reset" using the new update-rate.
				Reset(UpdateRate(), True)
			Endif
		Endif
		
		' Capture the current time (In milliseconds):
		TimePreviousFrame = TimeCurrentFrame
		TimeCurrentFrame = Millisecs()
		
		' Update the delta-log based on the number of milliseconds since the last time we did this:
		DeltaLog[DeltaNode] = Float(TimeCurrentFrame-TimePreviousFrame) * IdealInterval
		DeltaNode = (DeltaNode+1) Mod DeltaLog.Length
		
		' Calculate the current delta:
		
		' Assign the delta to 0.0 before anything else.
		Delta = 0.0
		
		' Iterate through the delta-log, and add to the delta-value.
		For Local Index:= 0 Until DeltaLog.Length
			Delta += DeltaLog[Index]
		Next
		
		' Fix the delta value. (Calculate an average/mean)
		Delta /= DeltaLog.Length
		
		Delta = Max(Delta, MinimumDelta)
		
		' Assign the value of the inverted delta.
		InvDelta = 1.0 / Delta
		
		Return
	End
	
	' Properties:
	
	' The 'IdealFPS' property describes the ideal frame-rate/update-rate
	' that math/other using this object was built around:
	Method IdealFPS:Int() Property
		Return Self._IdealFPS
	End
	
	Method IdealFPS:Void(Input:Int) Property
		Self._IdealFPS = Input
		
		CalculateIdealInterval()
		
		Return
	End
	
	Method CalculateIdealInterval:Float()
		If (Self._IdealFPS <> 0) Then ' IdealFPS
			IdealInterval = 1.0/(1000.0/Float(Self._IdealFPS)) ' IdealFPS
		Else
			IdealInterval = 0.0
		Endif
		
		' Return the calculated interval.
		Return IdealInterval
	End
	
	' Fields (Public):
	
	' The ideal interval this application should run at.
	Field IdealInterval:Float
	
	' These variables are used to take snapshots of the up-time of this
	' application (In milliseconds); they are then used to calculate a "delta-value":
	Field TimePreviousFrame:Int
	Field TimeCurrentFrame:Int
	
	' This acts as a log of "frame-differentials", which are then
	' processed into the active "delta-value" of the current frame.
	Field DeltaLog:Float[]
	
	' The current "node" (Position) in the 'DeltaLog' array.
	Field DeltaNode:Int
	
	' The last delta-value calculated from the 'DeltaLog'.
	Field Delta:Float
	
	' The minimum value 'Delta' can be.
	Field MinimumDelta:Float
	
	' A cache containing the inverse form of 'Delta'.
	Field InvDelta:Float
	
	' Booleans / Flags:
	
	' This describes if the update-rate of the application should be used.
	Field UseUpdateRate:Bool
	
	' Fields (Private):
	Private
	
	' Ideal values:
	
	' This acts as the internal storage for the 'IdealFPS' property.
	Field _IdealFPS:Int
	
	Public
End

configfile.monkey

' GLFW configuration:
#GLFW_WINDOW_TITLE="Game1"
#GLFW_WINDOW_WIDTH=640
#GLFW_WINDOW_HEIGHT=640

#GLFW_WINDOW_SAMPLES=0
#GLFW_WINDOW_RESIZABLE=False
#GLFW_WINDOW_DECORATED=True
#GLFW_WINDOW_FLOATING=False
#GLFW_WINDOW_FULLSCREEN=False

#GLFW_SWAP_INTERVAL=1

#MOJO_AUTO_SUSPEND_ENABLED=False
#MOJO_IMAGE_FILTERING_ENABLED=False

As you can see I pass the canvas/deltatime ref into the other 2 classes.
the game is build inside the game.monkey class.
the editor is a live editor if needed.

ImmutableOctet(SKNG)

(Posted 2015) [#2]

Looks good to me. I personally like following the argument-only approach for shared/modular data, though. So, for update and render routines, I'd pass the 'DeltaTime' object per-method, and I'd pass a 'DrawList' to the render routines, as a full 'Canvas' is usually unneeded. Since you're going for a separated framework approach with 'Game', there's good reason to pass a full 'Canvas' in this case. Personally, I'd go with keeping things housed in Mojo, unless I had a reason to separate it (There are quite a few, actually). Though honestly, I'm also the guy who goes full object-oriented and builds advanced CRTP hierarchies to reuse every bit of my code, so I'm not always the best example.

GC-Martijn

(Posted 2015) [#3]

yea, I don't know if passing or storing a reference is a huge difference in speed.

Method A:Void(canvas:Canvas)
 ' do something with canvas
End Method

Field canvas:Canvas ' need to set this once
Method B:Void()
 ' do something with canvas
End Method

Both use the same reference, to only thing is that by B I store the reference inside a Field.
I think it only will cost some little bits.
Using method A, you will send the reference.
Maybe at the end there is no speed difference at all ?

I don't know what the best option is.

Inside the Game class, i'm going to use the argument-only approach sometimes for the other drawable objects and stuff.

Pharmhaus

(Posted 2015) [#4]

Putting all the information needed into the constructor seems fine to me.
If you go with an constructor approach and you try to keep the number of globals low everything should be fine.
The only thing you should think of in my opinion is the 'how hard is future change' if you can refactor everything because the code is clean enough you don't have a problem.