Yes, more collective worklog reading

(Continued from this ridiculously huge thread as per Skidracer's wise suggestion).

*Gasp* Mark is posting even more worklog entries!
This is unusual... perhaps he is actually not Mark, but a robot posing as him?

This reflection stuff sounds like it will help me a lot, so good luck :)
The "Metadata" stuff sounds awesome as well. I can't decide where I would use it, but it's just too cool not to use, so I must find a way. It seems ideal for an easy way to create pleasant game data saving, where you can control what gets saved / restored by a simple keyword. If I'm on the right track, that's excellent!

I hope this comes with a docs update...


I notice that the window title in the IDE screenshot says "Quark 1.0", which is not the document being edited. Is that the doing of the new projects stuff? (And is there a fantastic version management thing in there which saves a change history and backup of each version number... or is that just the project's name?)

By the way, if Mark is reading this... I like having these smaller, less enormous adjustments to the language. I'd love to see this sort of stuff more often, since their effects can be felt by all! (And much more quickly than with a big, adventurous task such as a 3D module).

Along with IDE, I really hope the help document have also improvement, sometimes it's hard to get used to a simple command, have to tyr many times and know what heck it is...

Very cool that Mark is sharing more. He was quite a bit more active years ago but he also had to deal with some rough things these last couple of years :( Anyway, I think the name of the company says it all ... Blitz Research. We'll see a product when Mark's good and ready. I think if he can produce a high level editing system which includes a 'hatch' to access the guts of the system then the world will be a very nice place indeed.

I love reading what Mark is up to ;) more more!

Reflections?

Delegates?

Might as well write his worklogs in Chinese....

I haven't got a clue as to what Mark is doing with these fancy new things he's making, but I really enjoy reading his worklog.

I just wanted express my thanks to Mark for updating the worklog more often..
Good work, Mark.. I hope you find the time to continue to post some short logs every now and then.. :)

Runtime reflection lets you access fields of types you don't yet know of.

i.e. you create a saving function that compresses a type and saves it to disk, the problem being you currently can only save types you are aware of which requires you to make a special save for each type. This would instead allow you to do something like:

[pseudocode]

For Local a:TField = eachFieldIn myObj
	if (a.serializable) then saveData(a)
Next

[/pseudocode]

As regards Delegates, this is probably better than be trying to explain it: http://en.wikipedia.org/wiki/Delegation_(programming)

@Mark
Thumbs up for the worklog updates!

Finally adding reflection will make a whole lot of of a difference. These are great, great news.

Well, there's stuff I would rather have, but assuming I have got my head around it (and I'm not sure of that yet), it's just what I was after when I was tinkering with a GUI system for Max2D. This wouldn't have come about for use in Mark's gxLib by any chance? [Edit: no... for his game maker according to the log]

For anyone that missed it, there are two worklogs added since the recent one on the direction of Max3D... I almost missed the first one.

I was just p[osting about serialisation yesterday on Indiegamer! Very useful for mid-level save games.

These are good news!
It seems Mark has found a 'new inspiring muse'...3 worklog update in less than 2 weeks, it's a record!
I like to see what are the WIP!
Thanks

@Grey Alien, i've done something along the lines of mid-saving games and was saving animations etc and reloading exactly how they left off, was tricky work in blitz3d but did work good ie save while a character was in mid jump and while another was running etc and it all restored perfectly, same frames, continuing animation where it left etc.

ps im not a fan of saving the state and reloading exactly where it left off ie halflife, more of a savepoint person where you can save but continue at the last save point.
I think it gives the designer more control over the game and how it is played.

Really cool and handy stuff. I wrote a serialization lib for Max once and it was a pita. This makes it soo easy and cool. Almost as cool as having coroutines and continuation :)

Finally reflection.

Think of delegates as typesafe callbacks. If you don't know what that means, you won't need it.

Looking good all around.

Thank you Mark for keeping us informed about your progress :)

Cool OOP stuff by the way !

Sergio.

(tu) sinu: Yeah, quicksaves can be useful for the "busy person" who doesn't have time to replay since the last save point but they can also speed up a game and almost be used as cheating.

Thank you Mark for the worklogs. I truly appreaciate them.

Yup, great news, and it really is good to see the steady updates. Even just once a month would do, but 3 in 2 weeks is good going...

As part of these changes to the OO side of 'max, I'd love to see "Private" extended to work within types. So that I can define which fields and methods are publicly visible.

excellent stuff, thanks for keeping us posted mark :)

Cool, all we need now is ImageBuffer support and Max is finished! =]

That would be good, also the ability to either specify read/write functions for each field (my preference) OR to have generic read and write functions (like PHP) i.e.

Type myType
	Field X:Int Get getX Set setX
	Field Y:Int Get getY Set setY
	
	Method getX()
		Return X+viewPortOffset
	End Method
	
	Method setX(val:Int)
		If val >= 0 And val < GraphicsWidth() X = val
	End Method
End Type

OR

Type myType
	Field X:Int
	Field Y:Int
	
	Method __get(fieldName)
		Return self.fields[fieldName]
	End Method
	
	Method __set(fieldName:String, val:Int)
		If fieldName <> "X" Then Return 'only allow write to X
		If val >= 0 And val < GraphicsWidth() Then self.fields[fieldName] = val
	End Method
End Type

Hmmm, something like the latter sounds feasible, presumably you'd "just" be over-riding 'max's internal fieldset and fieldget for the type...

OVERLOADING. *hint*.

Me too! I always thought this was an odd omission.

Me three.


Oh, and OVERLOADING. *hint*.

Thanks for the worklog Mark, please keep it up ;)

I'd rather have access modifiers, properties and overloading ( operator and function/method ) as they would actually allow me to do things I can't do. Reflection would just make some things easier for me, although I do appreciate it makes some things possible, just not things I would do.

Yes Yes Yes, and Oh god yes.

Wait... this is the Blitz forum? Oh crap!