Monkey 2

Forum Replies Created

Viewing 15 posts - 226 through 240 (of 342 total)

← 1 … 15 16 17 … 23 →

Author

Posts

March 13, 2017 at 9:24 am in reply to: List Extensions > A clever way to filter lists. #7480

cocon

Participant

After of revisiting this idea, I noticed that this actually leads to functional programming concept such as LINQ etc. From what I guess Monkey 2 will feature LINQ in the future, so I won’t plan to do a re-implementation of that. However only as an evolution of the first example, this is more of a prototype for exploring the concept further. This time I took it a step further to use Extension methods to the List class rather than writing “service classes”, this way the API becomes fluent and natural. Perhaps in the future if I get any further ideas with this it will justify the creation of a library.

The most possible future plan in mind, is to port some little game examples (perhaps some bananas) to this style of programming and see in real terms what are the benefits.

' listextensions.monkey2

Namespace std.collections

#Import "<std>"
Using std.collections

Class List<T> Extension

	' Foreach Extention Methods
	' --------------------------------------------------
	
	Method ForEach(callbackFunction:Void(element:T))
		For Local item := Eachin Self
			callbackFunction(item)
		End
	End
	
	Method ForEachIf(callbackFunction:Void(element:T), booleanFunction:Bool(element:T))
		For Local item := Eachin Self
			If booleanFunction(item) Then callbackFunction(item)
		End
	End
	
	' --------------------------------------------------
	
	
	' Filter Extention Methods
	' --------------------------------------------------
	
	Method Filter:List<T>(booleanFunction:Bool(element:T))
		Local items := New List<T>
		For Local item := Eachin Self
			If booleanFunction(item)
				items.Add(item)
			End
		End
		Return items
	End
	
	' --------------------------------------------------
	
	
	' Find Extention Methods
	' --------------------------------------------------
	
	Method Find:T(booleanFunction:Bool(element:T))
		For Local item := Eachin Self
			If booleanFunction(item) Then Return item
		End
		Return Null
	End
		
	' --------------------------------------------------
	
	
	' Generate Extention Methods
	' --------------------------------------------------
	
	Method Generate:List<T>(element:T, times:Int)
		Local items := New List<T>
		For Local count := 0 Until times
			items.Add(element)
		End
		Return items
	End
	
	Method Generate:List<T>(callbackFunction:T(), times:Int)
		Local items := New List<T>
		For Local count := 0 Until times
			items.Add(callbackFunction())
		End
		Return items
	End
	
	' --------------------------------------------------
	
	
	' Conversion Extention Methods
	' --------------------------------------------------
	
	Method Convert<U>:List<U>()
		Local items := New List<U>
		For Local item := Eachin Self
			Local converted := Cast<U>(item)
			If converted <> Null Then items.Add(converted)
		Next
		Return items
	End
	
	Method Convert<U>:List<U>(conversionFunction:U(element:T))
		Local items := New List<U>
		For Local item := Eachin Self
			Local converted := conversionFunction(item)
			If converted <> Null Then items.Add(converted)
		Next
		Return items
	End
	
	' --------------------------------------------------
	
	
	' Apply Extention Methods
	' --------------------------------------------------
		
	Method Apply:List<T>(element:T)
		Local iterator := Self.All()
		While Not iterator.AtEnd
			iterator.Current = element
			iterator.Bump()
		Wend
		Return Self
	End
	
	Method Apply:List<T>(callbackFunction:T())
		Local iterator := Self.All()
		While Not iterator.AtEnd
			iterator.Current = callbackFunction()
			iterator.Bump()
		Wend
		Return Self
	End
	
	Method Apply:List<T>(callbackFunction:T(element:T))
		Local iterator := Self.All()
		While Not iterator.AtEnd
			iterator.Current = callbackFunction(iterator.Current)
			iterator.Bump()
		Wend
		Return Self
	End
	' --------------------------------------------------
	
	
	' Copy Extention Methods
	' --------------------------------------------------
	
	Method Copy:List<T>()
		Local items := New List<T>
		
		For Local item := Eachin Self
			items.Add(item)
		End
		
		Return items
	End
	
End

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

' listextensions.monkey2

Namespace std.collections

#Import "<std>"

Using std.collections

Class List<T> Extension

' Foreach Extention Methods

' --------------------------------------------------

Method ForEach(callbackFunction:Void(element:T))

For Local item := Eachin Self

callbackFunction(item)

End

Method ForEachIf(callbackFunction:Void(element:T), booleanFunction:Bool(element:T))

For Local item := Eachin Self

If booleanFunction(item) Then callbackFunction(item)

End

' --------------------------------------------------

' Filter Extention Methods

' --------------------------------------------------

Method Filter:List<T>(booleanFunction:Bool(element:T))

Local items := New List<T>

For Local item := Eachin Self

If booleanFunction(item)

items.Add(item)

End

Return items

End

' --------------------------------------------------

' Find Extention Methods

' --------------------------------------------------

Method Find:T(booleanFunction:Bool(element:T))

For Local item := Eachin Self

If booleanFunction(item) Then Return item

End

Return Null

End

' --------------------------------------------------

' Generate Extention Methods

' --------------------------------------------------

Method Generate:List<T>(element:T, times:Int)

Local items := New List<T>

For Local count := 0 Until times

items.Add(element)

End

Return items

End

Method Generate:List<T>(callbackFunction:T(), times:Int)

Local items := New List<T>

For Local count := 0 Until times

items.Add(callbackFunction())

End

Return items

End

' --------------------------------------------------

' Conversion Extention Methods

' --------------------------------------------------

Method Convert:List()

Local items := New List

For Local item := Eachin Self

Local converted := Cast(item)

If converted <> Null Then items.Add(converted)

Return items

End

Method Convert:List(conversionFunction:U(element:T))

Local items := New List

For Local item := Eachin Self

Local converted := conversionFunction(item)

If converted <> Null Then items.Add(converted)

Return items

End

' --------------------------------------------------

' Apply Extention Methods

' --------------------------------------------------

Method Apply:List<T>(element:T)

Local iterator := Self.All()

While Not iterator.AtEnd

iterator.Current = element

iterator.Bump()

Wend

Return Self

End

Method Apply:List<T>(callbackFunction:T())

Local iterator := Self.All()

While Not iterator.AtEnd

iterator.Current = callbackFunction()

iterator.Bump()

Wend

Return Self

End

Method Apply:List<T>(callbackFunction:T(element:T))

Local iterator := Self.All()

While Not iterator.AtEnd

iterator.Current = callbackFunction(iterator.Current)

iterator.Bump()

Wend

Return Self

End

' --------------------------------------------------

' Copy Extention Methods

' --------------------------------------------------

Method Copy:List<T>()

Local items := New List<T>

For Local item := Eachin Self

items.Add(item)

End

Return items

End

' listextensionstests.monkey2

#Import "<std>"
#Import "listextensions.monkey2"

Using std..

Function Main()
'	TestExtension_Generate()
'	TestExtension_Foreach()
'	TestExtension_Filter()
'	TestExtension_Apply()
'	TestExtension_Copy()
'	TestExtension_Convert()
End

' FUNCTIONS TO TEST LIST EXTENSION METHODS

Function TestExtension_Generate()
	Print("Generate Extension Methods")

	Local data := New List<Int>().Generate(FunctionRandomInt, 10)
	Print("Created " + data.Count() + " numbers.")
	data.ForEach(FunctionPrint)
	
	Print("")
End

Function TestExtension_Foreach()
	Print("Foreach Extension Methods")

	Local data := New List<Int>().Generate(FunctionRandomInt, 10)
	
	' apply function for each element of the list
	Print("print original numbers")
	data.ForEach(FunctionPrint)
	Print("")
	
	' apply function for only specific elements of the list
	' depending on the boolean result of the function
	Print("print numbers that are less than 50")
	data.ForEachIf(FunctionPrint, FunctionLessFifty)
	
	Print("")
End

Function TestExtension_Filter()
	Print("Filter Extension Methods")
	
	Local data := New List<Int>().Generate(FunctionRandomInt, 10)
	
	Print("print original numbers")
	data.ForEach(FunctionPrint)
	Print("")
	
	' apply a function filter the elements of the list, after that
	' do a chain call to apply the print function to each element
	Print("print even numbers")
	data.Filter(FunctionEven).ForEach(FunctionPrint)
	
	Print("")
End

Function TestExtension_Copy()
	Print("Copy Extension Methods")
	
	' create the first random list
	Local data1 := New List<Int>().Generate(FunctionRandomInt, 10)
	
	' make a copy of the first list
	Local data2 := data1.Copy()
	'doing a simple assignment like this -> Local data2 := data1
	' will result to having two lists pointing at the same object references
	
	' both will have the same data
	' data2 list will be mutated
	data2.Apply(FunctionRandomInt)
	
	' now print the results
	Print("values from list 1")
	data1.ForEach(FunctionPrint)
	Print("")
	
	Print("values from list 2")
	data2.ForEach(FunctionPrint)
	Print("")
	
	Print("")
End

Function TestExtension_Convert()
	Print("Convert Extension Methods")

	Local data := New List<Int>().Generate(FunctionRandomInt, 10)
	
	Print("print original numbers")
	data.ForEach(FunctionPrint)
	Print("")
	
	' convert the list to a list of another type
	' this will use the default behaviour of the Cast<T> command
	Print("convert to float automatically")
	data.Convert<Float>().ForEach(FunctionPrintGeneric<Float>)
	
	' convert the list values based on a custom function
	Print("convert to float with a function")
	data.Convert<Float>(FunctionIntToFloatRandom).ForEach(FunctionPrintGeneric<Float>)
	
	Print("")
End

Function TestExtension_Apply()
	Print("Apply Extension Methods")
	
	Local data := New List<Int>().Generate(FunctionRandomInt, 10)
	
	Print("print original numbers")
	data.ForEach(FunctionPrint)
	Print("")
	
	Print("apply a new value to each element of the list")
	data.Apply(Rnd(10))
	data.ForEach(FunctionPrint)
	Print("")
	
	' apply a new value to each element based on the output of a function
	Print("apply a random value by replacement")
	data.Apply(FunctionRandomInt)
	data.ForEach(FunctionPrint)
	Print("")
	
	' apply a new value to each element by mutating the existing value
	Print("add 100 to the existing numbers")
	data.Apply(FunctionAdd100)
	data.ForEach(FunctionPrint)
	Print("")
	
	Print("repeat test once again with only one chained call")
	data.Apply(FunctionRandomInt).Apply(FunctionAdd100).ForEach(FunctionPrint)
	
	Print("")
End

' OTHER HELPER FUNCTIONS

Function FunctionPrint(number:Int)
	Print("~t" + number)
End

Function FunctionPrintGeneric<T>(value:T)
	Print("~t"+value)
End

Function FunctionPrintString(string_:String)
	Print("~t" + string_)
End

Function FunctionRandomInt:Int()
	Return Cast<Int>(Rnd(1, 100))
End

Function FunctionIntToFloatRandom:Float(x:Int)
	Return x + Cast<Float>(Rnd(0.001, 0.1))
End

Function FunctionLessFifty:Bool(number:Int)
	Return number < 50
End

Function FunctionEven:Bool(number:Int)
	Return (number Mod 2) = 0
End

Function FunctionAdd100:Int(number:Int)
	Return number + 100
End

Function FunctionConvertIntToString:String(number:Int)
	Return "String: " + number
End

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

' listextensionstests.monkey2

#Import "<std>"

#Import "listextensions.monkey2"

Using std..

Function Main()

' TestExtension_Generate()

' TestExtension_Foreach()

' TestExtension_Filter()

' TestExtension_Apply()

' TestExtension_Copy()

' TestExtension_Convert()

End

' FUNCTIONS TO TEST LIST EXTENSION METHODS

Function TestExtension_Generate()

Print("Generate Extension Methods")

Local data := New List<Int>().Generate(FunctionRandomInt, 10)

Print("Created " + data.Count() + " numbers.")

data.ForEach(FunctionPrint)

Print("")

End

Function TestExtension_Foreach()

Print("Foreach Extension Methods")

Local data := New List<Int>().Generate(FunctionRandomInt, 10)

' apply function for each element of the list

Print("print original numbers")

data.ForEach(FunctionPrint)

Print("")

' apply function for only specific elements of the list

' depending on the boolean result of the function

Print("print numbers that are less than 50")

data.ForEachIf(FunctionPrint, FunctionLessFifty)

Print("")

End

Function TestExtension_Filter()

Print("Filter Extension Methods")

Local data := New List<Int>().Generate(FunctionRandomInt, 10)

Print("print original numbers")

data.ForEach(FunctionPrint)

Print("")

' apply a function filter the elements of the list, after that

' do a chain call to apply the print function to each element

Print("print even numbers")

data.Filter(FunctionEven).ForEach(FunctionPrint)

Print("")

End

Function TestExtension_Copy()

Print("Copy Extension Methods")

' create the first random list

Local data1 := New List<Int>().Generate(FunctionRandomInt, 10)

' make a copy of the first list

Local data2 := data1.Copy()

'doing a simple assignment like this -> Local data2 := data1

' will result to having two lists pointing at the same object references

' both will have the same data

' data2 list will be mutated

data2.Apply(FunctionRandomInt)

' now print the results

Print("values from list 1")

data1.ForEach(FunctionPrint)

Print("")

Print("values from list 2")

data2.ForEach(FunctionPrint)

Print("")

End

Function TestExtension_Convert()

Print("Convert Extension Methods")

Local data := New List<Int>().Generate(FunctionRandomInt, 10)

Print("print original numbers")

data.ForEach(FunctionPrint)

Print("")

' convert the list to a list of another type

' this will use the default behaviour of the Cast<T> command

Print("convert to float automatically")

data.Convert<Float>().ForEach(FunctionPrintGeneric<Float>)

' convert the list values based on a custom function

Print("convert to float with a function")

data.Convert<Float>(FunctionIntToFloatRandom).ForEach(FunctionPrintGeneric<Float>)

Print("")

End

Function TestExtension_Apply()

Print("Apply Extension Methods")

Local data := New List<Int>().Generate(FunctionRandomInt, 10)

Print("print original numbers")

data.ForEach(FunctionPrint)

Print("")

Print("apply a new value to each element of the list")

data.Apply(Rnd(10))

data.ForEach(FunctionPrint)

Print("")

' apply a new value to each element based on the output of a function

Print("apply a random value by replacement")

data.Apply(FunctionRandomInt)

data.ForEach(FunctionPrint)

Print("")

' apply a new value to each element by mutating the existing value

Print("add 100 to the existing numbers")

data.Apply(FunctionAdd100)

data.ForEach(FunctionPrint)

Print("")

Print("repeat test once again with only one chained call")

data.Apply(FunctionRandomInt).Apply(FunctionAdd100).ForEach(FunctionPrint)

Print("")

End

' OTHER HELPER FUNCTIONS

Function FunctionPrint(number:Int)

Print("~t" + number)

End

Function FunctionPrintGeneric<T>(value:T)

Print("~t"+value)

End

Function FunctionPrintString(string_:String)

Print("~t" + string_)

End

Function FunctionRandomInt:Int()

Return Cast<Int>(Rnd(1, 100))

End

Function FunctionIntToFloatRandom:Float(x:Int)

Return x + Cast<Float>(Rnd(0.001, 0.1))

End

Function FunctionLessFifty:Bool(number:Int)

Return number < 50

End

Function FunctionEven:Bool(number:Int)

Return (number Mod 2) = 0

End

Function FunctionAdd100:Int(number:Int)

Return number + 100

End

Function FunctionConvertIntToString:String(number:Int)

Return "String: " + number

End

March 11, 2017 at 9:23 pm in reply to: Fixed Shooter #7474

cocon

Participant

Nicely done!

March 3, 2017 at 1:44 pm in reply to: Pocket Invaders anybody? #7366

cocon

Participant

Great!

February 16, 2017 at 5:22 am in reply to: i_editor #7171

cocon

Participant

I want to write an interpreter too for educational purposes.

I have put on some study in it a few weeks now (first time ever) and I have completed the required knowledge about the tokenizer and the semantic model. The most tricky part is how to convert the token list to the semantic model… All of the implementations available use recursive function calls, which I dislike. Otherwise I will fall back to the most classic approach, peeking and checking…

February 13, 2017 at 1:01 am in reply to: gles3.0 vs gles2.0 for mx23d #7122

cocon

Participant

A renderer API wrapper has to be made in this case, so the implementation is more flexible. This approach was done in Microsoft XNA because at that moment in time, they wanted to support both XBOX and Windows DX9.

I have also studied a little about the source code of BGFX, it follows the same approach of API virtualization, meaning that you can create vertex buffers and stuff, and getting the low level feeling. But you don’t care whether actually the implementation behind the scenes is OpenGL or DirectX, rather than only you care about the deployment platform.

February 7, 2017 at 2:10 pm in reply to: i_editor #6980

cocon

Participant

Looks like an interesting concept, have you written an interpreter for this?

February 6, 2017 at 7:02 am in reply to: sort of vague auto-ish shader idea #6966

cocon

Participant

So this basically tells that if you write a special parser that understands specific source patterns, or comment tags, you would generate custom vertex attributes dynamically.

February 4, 2017 at 1:29 am in reply to: Mojox textview, selecting with shift behaviour #6942

cocon

Participant

Yes, the reason is that the boolean condition that would allow the fix happen, is valid only for repeat events. Specifically is the way that modifier keys are processed.

textview.monkey2 - line 1201
	Method OnContentMouseEvent( event:MouseEvent ) Override
		Select event.Type
		Case EventType.MouseDown
			Select event.Clicks
			Case 1
				_cursor=CharAtPoint( event.Location )
				' This one...
				If Not (event.Modifiers & Modifier.Shift) _anchor=_cursor

textview.monkey2 - line 1201

Method OnContentMouseEvent( event:MouseEvent ) Override

Select event.Type

Case EventType.MouseDown

Select event.Clicks

Case 1

_cursor=CharAtPoint( event.Location )

' This one...

If Not (event.Modifiers & Modifier.Shift) _anchor=_cursor

After examining these *.monkey2 files in order to understand the inner workings: view, window, app, textview. The best fix for this problem, is this one.

				' Previous Implementation
				' If Not (event.Modifiers & Modifier.Shift) _anchor=_cursor
				
				' New One
				If Keyboard.KeyDown(Key.LeftShift) Or Keyboard.KeyDown(Key.RightShift)
					' nothing
				Else
					_anchor=_cursor
				End

' Previous Implementation

' If Not (event.Modifiers & Modifier.Shift) _anchor=_cursor

' New One

If Keyboard.KeyDown(Key.LeftShift) Or Keyboard.KeyDown(Key.RightShift)

' nothing

Else

_anchor=_cursor

End

Unfortunately I have to bypass the event mechanism and do a dirty hack (ignore the event checks) and rely on the Keyboard class. I am not proud of the solution, but it will work for now, until I find something else better better.

P.S. Some notes on this subject _________________________________________________

Regarding the proper “textview solution” would be fixed like this: app.monkey2 line 720

If kevent->repeat_
	SendKeyEvent( EventType.KeyRepeat )
Else
	SendKeyEvent( EventType.KeyDown )
Endif

If kevent->repeat_

SendKeyEvent( EventType.KeyRepeat )

Else

SendKeyEvent( EventType.KeyDown )

Endif

Either by creating a new important event KeyPress (which captures both states of Down and Repeat) or the significance of Key.Repeat would be changed (changing it’s bitwise value) if it makes any sense to do so:

If kevent->repeat_ SendKeyEvent( EventType.Down & EventType.KeyRepeat )

1	If kevent->repeat_ SendKeyEvent( EventType.Down & EventType.KeyRepeat )

I don’t know if these proposals are good or not but I though it a good opportunity to throw the ideas, and see what happens.

January 28, 2017 at 5:44 am in reply to: Using large XML data – 3Mbyte file #6851

cocon

Participant

I would definitely be sure that 3MB is a reasonable size and that the TinyXML is solid.

Just out of curiosity if you parse the XML file with another programming language what will happen?
https://www.tutorialspoint.com/python/python_xml_processing.htm

P.S. I don’t know also if there is an encoding issue as well, is the file UTF8?

January 28, 2017 at 5:31 am in reply to: Instancing entities with components #6850

cocon

Participant

' ---------------------------------------------- '
' IMPLEMENTATION
' ---------------------------------------------- '
Interface IComponent

 Property Name:String
 Property Owner:GameObject()

 Method OnLoad()
 Method OnUpdate()
 Method OnStop()
End

Class GameObject
 Field List<String> Tags;
 
 Field List<IComponent> Components;
 Method FindComponent:IComponent(name:String)
 ' foreach component return if name matches
 End

 Method Start()
 End
 Method Update()
 End
 Method End()
 End

End
' ---------------------------------------------- '


' ---------------------------------------------- '
' CUSTOM COMPONENTS
' ---------------------------------------------- '
Class CharacterController Implements IComponent
 '...'
End

Class EnemyAI Implements IComponent
 '...'
End
' ---------------------------------------------- '



' ---------------------------------------------- '
' EXAMPLE
' ---------------------------------------------- '

' both game objects have the same class
Local player := New GameObject
Local enemy := New GameObject

' each game object however has different behaviour
player.Components.AddLast(New CharacterController)
enemy.Components.AddLast(New EnemyAI)

' ---------------------------------------------- '

' OTHER NOTES

' Creating an object pool is important because
' you might need to fetch them at any time.
Class GameObjectPool Abstract
 Global GameObjects:List<GameObject>
 Function Add(g:GameObject)
 '...
 End
End

' and then at the game object constructor
Class GameObject
 '...'
 Method New()
 GameObjectPool.Add(Self)
 End
 '...'
End

' Later on...

' You can use global search functions.

Function FindGameObjectByTag:GameObject(tag:string)
 '...
End

Function FindGameObjectsByTag:List<GameObject>(tag:string)
 '...
End

' Another alternative is to put them in a registry class
' no need for searching the most important objects constantly.
Class GameObjectRegistry Abstract
 Global Player:GameObject
 Global Enemies:List<GameObject>
End

' ---------------------------------------------- '

' IMPLEMENTATION

' ---------------------------------------------- '

Interface IComponent

Property Name:String

Property Owner:GameObject()

Method OnLoad()

Method OnUpdate()

Method OnStop()

End

Class GameObject

Field List<String> Tags;

Field List<IComponent> Components;

Method FindComponent:IComponent(name:String)

' foreach component return if name matches

End

Method Start()

End

Method Update()

End

Method End()

End

' ---------------------------------------------- '

' CUSTOM COMPONENTS

' ---------------------------------------------- '

Class CharacterController Implements IComponent

'...'

End

Class EnemyAI Implements IComponent

'...'

End

' ---------------------------------------------- '

' EXAMPLE

' ---------------------------------------------- '

' both game objects have the same class

Local player := New GameObject

Local enemy := New GameObject

' each game object however has different behaviour

player.Components.AddLast(New CharacterController)

enemy.Components.AddLast(New EnemyAI)

' ---------------------------------------------- '

' OTHER NOTES

' Creating an object pool is important because

' you might need to fetch them at any time.

Class GameObjectPool Abstract

Global GameObjects:List<GameObject>

Function Add(g:GameObject)

'...

End

' and then at the game object constructor

Class GameObject

'...'

Method New()

GameObjectPool.Add(Self)

End

'...'

End

' Later on...

' You can use global search functions.

Function FindGameObjectByTag:GameObject(tag:string)

'...

End

Function FindGameObjectsByTag:List<GameObject>(tag:string)

'...

End

' Another alternative is to put them in a registry class

' no need for searching the most important objects constantly.

Class GameObjectRegistry Abstract

Global Player:GameObject

Global Enemies:List<GameObject>

End

Code is from muscle memory, unfortunately is not a perfect design, as design flaws occur they will have to be solved on the spot.

For example, just now I added “Name” + “Owner” on the IComponent.
The reason is that for example acquiring a nitro boost component, will increase the speed of movement component. This means that the “nitro compo” will send message to the “movement compo”.

Class NitroComponent Implements IComponent
	
	Field Move:MoveComponent

	Method OnLoad()
		Self.Move = Owner.FindComponent("Move")
		' Perhaps reflection also might be a good idea.
	End
End

Class NitroComponent Implements IComponent

Field Move:MoveComponent

Method OnLoad()

Self.Move = Owner.FindComponent("Move")

' Perhaps reflection also might be a good idea.

End

January 27, 2017 at 11:05 pm in reply to: today I have been doing 3d physics (dynamics) #6844

cocon

Participant

Very nice! Not to mention that I am a huge fan of ODE.

January 23, 2017 at 6:31 pm in reply to: today i haz bin perlin #6757

cocon

Participant

Nice one.

January 23, 2017 at 6:26 pm in reply to: Miscellaneous Procedural Generation Code #6756

cocon

Participant

This looks good.

January 16, 2017 at 1:56 am in reply to: Try, Catch Errors #6544

cocon

Participant

Good one.

January 15, 2017 at 1:06 am in reply to: Is there any way to do ternary expression? #6517

cocon

Participant

From what I see it’s called an “If Expression”

Author

Posts

Viewing 15 posts - 226 through 240 (of 342 total)

← 1 … 15 16 17 … 23 →

cocon

Forum Replies Created

Archives

Recent Replies

What is this?