Sorry your browser is not supported!

You are using an outdated browser that does not support modern web technologies, in order to use this site please update to a new browser.

Browsers supported include Chrome, FireFox, Safari, Opera, Internet Explorer 10+ or Microsoft Edge.

Work in Progress / Sports Fiction ®

Author
Message
MrValentine
AGK Backer
7
Years of Service
User Offline
Joined: 5th Dec 2010
Playing: Playing
Posted: 13th Jul 2014 23:17
Quote: "I will post the next update tomorrow."


Looking forward to it!

In my world a year is 365 seconds!

/Back on topic

Rudolpho
12
Years of Service
User Offline
Joined: 28th Dec 2005
Location: Sweden
Posted: 13th Jul 2014 23:29
Thanks for the summarizing, that clears quite a lot of things up

Quote: "Stop using vague words such as this and the"

To be honest your posts can be quite vague, or rather abstract too at times; perhaps that is only to be expected with an abstraction-based product though
(Now I'll admit to not having read through each and every post, much less remembering everything from the ones I have in fact read so it can of course be explained by lack of context from previous posts).


I see about the frame rate then. Just as a suggestion I would probably recommend trying to find and alleviate the reason as soon as possible rather than it getting obfuscated by future contributing factors as time goes on if something seems to kill the framerate completely; it can be very annoying trying to find causes and solution to a complex system as a post-process. 30 FPS is quite an OK rate, I just thought it seemed odd if it you only got 8 FPS out of rendering a seemingly low-poly checkerboard-textured terrain, which could maybe then be explained by the GUI components being rendered by the same process as you say. But I see you're sleeping the process; still that doesn't quite make a drop to below 10 come off as reasonable. But I'm sure you have your reasons.

Quote: "... but if I maxed out the FPS; DBPro would consume too much of my resources I need for my development software running in the background."

Not saying that you're not right but that sounds quite odd to me (or were you the guy who preferred to develop on low-end machines to see how your programs would behave with low resource availability? I know I read that somewhere the other day but might've been on stack overflow...)
Otherwise DBPro executables are 32-bit, single-threaded programs which limits them to using at most 2Gb RAM and one CPU core. Most machines made in the last 8+ years should exceed that. Although I suppose your other programs may use all processors or collectively use up tonnes of memory, I'm just curious


Quote: "Just for any curiousity, the engine sleep process uses the Matrix1 Nice Sleep command; and this can be overriden in the configuration file for both products. Compared to the native sleep command, this Matrix1 alternative is CPU friendly."

Oh haha, right that ludicruous Sleep function, it is actually implemented like so:

I mean, come on... I suppose it will technically allow for more precise timing than calling the Sleep function from kernel32.dll but I don't really see that as being the prime use for the function. Ok if wait does that but sleep should really do what you expect from it ("sleep" the process).


Now from how you're describing your project it sounds like a very exciting take on a game engine / editor package. Sounds like a behemoth of a project to attempt by yourself / two people though, so I wish you the best of luck with it (it seems you've got very far already)!

However, one thing in your last post got me a bit worried, namely this line:
Quote: "The ZeroOne runtime engine (that is the thing which SF and X-Prod are made out of) is a .NET based engine which can link up with windows based libraries such as DarkBASIC."


TGC does seem to have adopted a different attitude towards linking to their libraries from other applications since DarkGDK 2; as a matter of fact I had to cancel this wrapper project of mine from last year after getting the reply that they weren't too keen on the idea when I enquired as to whether it was allowed. However this was (I believe) largely attributed to the fact that my approach could be used to circumvent the protection on most commercial third party plugins; perhaps you can work something out with them about this as Mistrel must have done.


Finally, you say that you can develop for "any" language you have a compiler for (or the ones you will eventually support I guess) by providing a compiler of your own. Does this mean that any code / scripts authored in your editor will be translated into native code for that particular language and then compiled using its compiler? So that the whole thing is essentially an abstraction layer for converting code / your engine will be written in such a way that it can be translated into using various languages and libraries? That is indeed an intriguing and quite innovative idea in that case.
I'm pretty sure you have said it does, but this does allow the authoring of native code besides the whole visual editor thing right? Or will it be more like scripts interpreted by your own engine?


"Why do programmers get Halloween and Christmas mixed up?"
Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 14th Jul 2014 21:44 Edited at: 14th Jul 2014 22:17
Quote: "To be honest your posts can be quite vague, or rather abstract too at times; perhaps that is only to be expected with an abstraction-based product though"


Good, that will convince people to ask questions

Quote: "Just as a suggestion I would probably recommend trying to find and alleviate the reason as soon as possible rather than it getting obfuscated by future contributing factors"


I already think I know what it is (most likely I had logging switched on) besides the sleep call. And my clock system is the thing which will tell me where the slow downs occur; I just haven't switched it on yet. I have attempted to create this engine about 5 times. On my 6th attempt, I am confident that I will produce a high framerate in the end and will find most bottlenecks with little effort.

What scares me is when these benchmark bars are all equal, in which case all processes take as long as each other and drop the FPS below 30 on an old machine; this is when I would need to break it down further with more clocks.

Quote: "it can be very annoying trying to find causes"


Yep!

Quote: "Not saying that you're not right but that sounds quite odd to me (or were you the guy who preferred to develop on low-end machines to see how your programs would behave with low resource availability?"


Yep! I build on low end machines to A, make sure it will be playable on low end machines; B to save money . However I do have a more up-to-date faster system now as I move into animation and game action.

However I often test things on a slower machine which only has 2GB of RAM so that FPS drops are more obvious to see.

Quote: " Sounds like a behemoth of a project to attempt by yourself / two people though, so I wish you the best of luck with it (it seems you've got very far already)!"


I have a rule, try to work your strengths. This all ties in with target audience, market type; the pros and cons.

I cannot work on small projects, I am terrible at making them. It is my archtype if you will; I only know how to make something big. My ideas only link up with something big enough to match them.

I could not entertain millions of people with a few pixels and one button. Something other talented developers can do, such as with some of the AppGameKit developers.

The other thing is I only play large games (lots of players and content) and use complex industry standard software at work; this makes me a bit more at home with the culture and terminologies in these markets; I understand people like me, so I am building stuff for them.

I do not fear the size of the project because I think people will want the product and will pay for it; which means they will pay others to work on it if is want they actually want. If people do not want it, I will still use it to build something else they do want; so in the end, that brings us back to putting the money into something which gives them what they want; win-win.

I have also achieved what I could not do in the past.

About 3 years ago I did not understand HLSL shaders. 4 years ago I could not use Blender (although my best modelling work has yet to be shown). 6 years ago I could not program; I did not know what a boolean was or nothing about null!

2 years ago XProducer did not exist, and I did not know how to create windows user interfaces. I did not want to make a level editor because I thought it would be too hard and time consuming; but my instincts told me it would be the only level editor I'd need to make in my lifespan, so there is no excuse.

Turns out I have it 25% done in 6 months before employing anyone; apart from last month Dejan who is a programming wizard.

Quote: "The ZeroOne runtime engine (that is the thing which SF and X-Prod are made out of) is a .NET based engine which can link up with windows based libraries such as DarkBASIC.""


Quote: "TGC does seem to have adopted a different attitude towards linking to their libraries from other applications since DarkGDK 2"


It links to DarkBASIC for my own use to make SF and XProd; in other words you could not call a DarkBASIC function from my DLLs.

This is because my SF/XProd functionality reside in DLLs. The engine is the DLL and the DarkBASIC program is the wrapper. I do not call DarkBASIC functions from XProd/SF, DarkBASIC it calls XProd/SF functions from DarkBASIC. (At least in most cases, in somecases I have wrap a DBP application to perform some tool operations, and I use a WPF application to package everything for convience)

The part of my engine which links with DarkBASIC is not a product, that part is just a part of SF / XProd. The only thing you can do with that part is modify Sports Fiction and the X-Producer for yourself or your friends or customers. But that will be limited to what I am permitted to allow you to modify; something to be arranged much later. Modding is a topic for later, and that is something I do need to discuss with TGC.

The other part my engine, "my part" has nothing to do with DarkBASIC which you can use freely; it only links to .NET, nothing else. This also includes some of my assets and functionality, which leads me to your next point:

Quote: "Does this mean that any code / scripts authored in your editor will be translated into native code for that particular language and then compiled using its compiler?"


Yes that is the goal, be it DarkBASIC, AppGameKit, HTML5, Silverlight, C#, VB.NET or C++; I want you to be able to load X-Producer content into your application; and content includes functionality; and to reiterate this is functionality based on abstration from templates, templates are something you can define.

For example, with your DX11 plugin, you could create an XProd template to allow generate a DBP project which loads the XElements using your commands instead of the standard ones. You instruct XProd how to compile a DX11 program the way you want it to compile it; loading all of the XElements including actions, sounds, events and triggers into your program. It uses code generation and pre-compilation instructions; and will be able to make you an install package too (using a scriptable install package maker).


Quote: "I'm pretty sure you have said it does, but this does allow the authoring of native code besides the whole visual editor thing right? Or will it be more like scripts interpreted by your own engine?"


I am not 100% sure what you mean, but if you are refering to how it makes things work in other languages? Then yeah, it makes code for you to run "outside" of my engine; exposing all of the details, nothing hidden. This will have limits since obviously, a mobile web browser is not going to understand absolutely every command or event available for Windows 8.1.

In the case of Modding, then there is not much compiling to do, just a small wrapper for SF or XProd. Again, modding is subject to limitations on use, but the benefits of these is that you get to use my game assets and some of the X-Producer's functionality in your applications. A bit like hosting Microsoft Word documents in your application using COM Dlls. This is not confirmed but desirable.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 14th Jul 2014 21:54 Edited at: 15th Jul 2014 00:39

Foundation Plugin - 30/06/14 - 22:00 - Enumeration Library


Today work has gone underway developing a crucial function library for Windows programming tools to handle elements with flexibility. The foundation plugin is available for DarkBASIC in order to access the ZeroOne element infrastructure and to import some of the X-Producers complex datatypes and assets.

From this point onward we will discuss the terminology and functions of these plugins using diagrams. Our first group of diagrams introduce the ZeroOne foundation's enumeration class library.



So that is what enumeration does, so what else can it do?



NOTE: When it is said that the enumerators can collect data about types or functions; we are refering to the types and functions in ZeroOne, the elements you define in the X-Producer and the .NET classes and functions; not the functions and types in third parties, scripting languages or in DarkBASIC; these are outside of ZeroOne's scope.






So today we have seen that enumeration is used to collect unrelated or un-related elements, whether they are objects, classes, functions or types; and puts them in a sortable or countable list.



In DarkBASIC; the MAKE ENUMERATOR command will create an element used to contain a collection based on criteria, you can keep this enumerator for reuse, or remove it with DELETE ENUMERATOR in DarkBASIC (or Enumerator.Delete() in .NET). In some cases, one enumerator will be all you will ever need in the lifetime of your program or game simulation; however in a large game or application you should use specific enumerators for specific purposes; selecting them with the SELECT ENUMERATOR DarkBASIC command or (Enumerator.Select in .NET); something to be discussed in a future update.

Rudolpho
12
Years of Service
User Offline
Joined: 28th Dec 2005
Location: Sweden
Posted: 15th Jul 2014 23:44
Quote: "I cannot work on small projects, I am terrible at making them. It is my archtype if you will; I only know how to make something big. My ideas only link up with something big enough to match them.

I could not entertain millions of people with a few pixels and one button. Something other talented developers can do, such as with some of the AppGameKit developers.

The other thing is I only play large games (lots of players and content) and use complex industry standard software at work; this makes me a bit more at home with the culture and terminologies in these markets; I understand people like me, so I am building stuff for them."

I can relate to that. Unfortunately most people get scared off of such projects, be it as active contributors, investors or otherwise. But yeah, I'm the guy who tried to make a MORPG (yes, one M is enough) for my final project for my game development education so (And no, it didn't go all that bad, like everyone was oh-so-keen on pointing out at every opportunity they got; "you'll never make it", "nobody can do that without dozens of people and years of time", "just make something that you can actually complete", etc., etc.; we actually got a playable, albeit very buggy, build for the demonstration day and straight A:s. And lots of knowledge we definately didn't acquire through the normal courses and activities taught by the university alone).


Quote: "The part of my engine which links with DarkBASIC is not a product, that part is just a part of SF / XProd."

Quote: "The other part my engine, "my part" has nothing to do with DarkBASIC which you can use freely; it only links to .NET, nothing else."

Ah, I see, you should be safe then

Quote: "Yes that is the goal, be it DarkBASIC, AppGameKit, HTML5, Silverlight, C#, VB.NET or C++; I want you to be able to load X-Producer content into your application; and content includes functionality; and to reiterate this is functionality based on abstration from templates, templates are something you can define."

That sounds quite awesome! I can see the allure of essentially wrapping the engine in a dynamic library then, allowing it to be linked up to most any language easier. However, it sounds like that may not be your plan still; if you intend for it to be supported by HTML5 for example, you would basically have to rewrite your engine for that platform. Again lots of work, not undoable though and I'm sure it'll most definately be worth it in the end.

Quote: "I am not 100% sure what you mean, but if you are refering to how it makes things work in other languages? Then yeah, it makes code for you to run "outside" of my engine; exposing all of the details, nothing hidden."

Cool, that's definately preferrable to the scripting approach in my opinion.
And yes, that's what I meant.


"Why do programmers get Halloween and Christmas mixed up?"
Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 16th Jul 2014 01:02 Edited at: 16th Jul 2014 01:03
Quote: "But yeah, I'm the guy who tried to make a MORPG (yes, one M is enough) for my final project for my game development education so (And no, it didn't go all that bad, like everyone was oh-so-keen on pointing out at every opportunity they got; "you'll never make it", "nobody can do that without dozens of people and years of time", "just make something that you can actually complete", etc., etc.; we actually got a playable, albeit very buggy, build for the demonstration day and straight A:s. And lots of knowledge we definately didn't acquire through the normal courses and activities taught by the university alone)."


Really? Wow, do you have any links to this project; I'd like to see what you came up with. What an achievement.

Am I correct in guessing that those people who say such things probably did not score a C.
Quote: "
That sounds quite awesome! I can see the allure of essentially wrapping the engine in a dynamic library then, allowing it to be linked up to most any language easier. However, it sounds like that may not be your plan still; if you intend for it to be supported by HTML5 for example, you would basically have to rewrite your engine for that platform. Again lots of work, not undoable though and I'm sure it'll most definately be worth it in the end."


My strategy is to not have to rewrite; but to override. The engine will be modular, so all the parts which cannot be ported to your target platform, must be overriden with something that can.

As a basic example; If a circle needs to be drawn in green on the screen, but there is no circle command in the language; you must create the circle command and make it draw the circle in green given the XProds specifications.

If the language already has its own circle command, your port template needs to tell X-Prod how to use it. Then it will produce the project files for you to compile and upload.

Hard work, but the whole point because hopefully in the future I could produce a template to port apps for games consoles.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 16th Jul 2014 01:50

Foundation Plugin - 30/06/14 - 22:00 - Enumeration Process


Most of today has been spent working on the plugin task. We have been reviewing the enumeration process; following on from yesterday's introduction to the enumeration library; the commands in this library are used to collect a selection of related or un-related elements or classes, and place them into a list. The practical uses have already been highlighted in the previous update where we also looked at how enumerators a created.

After finalizing the new commands, I will be uploading examples of the code required to access the enumerators functionality.

Rudolpho
12
Years of Service
User Offline
Joined: 28th Dec 2005
Location: Sweden
Posted: 16th Jul 2014 22:49 Edited at: 16th Jul 2014 22:51
Quote: "Really? Wow, do you have any links to this project; I'd like to see what you came up with. What an achievement."

Well, it certainly got further than was expected within the frame of the course but it still was full of flaws and definately not polished the slightest bit so I usually don't brag about it, I just brought it up as a hint that I too am fond of ("overly") large projects

I could fire up the server and send you the client if you like, the only video I can find was the official last video demonstration from the course which were recorded by my work buddy (who made all of the graphics by the way) a few days before the final presentation. Since we of course made lots of last-minute tweaks in the following days there are lots of annoying, clearly visible bugs and flaws in that video that weren't in the final version (albeit that too was of course far from perfect). For example the irradic movement of the moose when they are aggroed, the almost invisible space with in the chat and the fact that you can still move around when dead. Also Hassan (who recorded the video) apparently didn't figure out that you could zoom the camera out by scrolling the mouse wheel, so the point of view is very bad.
Here's the video anyway:
http://youtu.be/w3DyXsgp13A
Oh and never mind all of my dyslexic buddy's spelling mistakes. But yes, the game was actually called Ageing Wrath, which kind of stuck with everyone who heard it because they liked to point out how wrong that was in favor of the spelling "aging", however it seems ageing is indeed the correct brittish english spelling.

As you can see it definately isn't graphically impressive; the part I'm most proud of as the sole programmer behind it was the readily extensible network layout - we had a master data server, a transfer server and different shard servers for each area within the game. These could all be run on the same computer or moved to separate ones, which worked well. I also take some pride in the culling system that ran on a separate thread, and the terrain engine which, apart from some visible seams due to texture atlas lookup issues, worked quite well with almost unnoticeable LOD transitions.
This was written using DarkGDK 2 by the way. Unfortunately its author went missing and it became abandonware a few months into our project. I also spent a lot of time in the beginning trying to get a proper lighting system set up, but this ultimately proved a fruitless labour that essentially wasted away our first two months and could much better have been spent on other engine functionality. I managed to work around a lot of issues with DGDK2, adding dll wrapper functions by hand, recompiling the DBPro source and so on, but some things just weren't mendable. For example it turned out impossible to interface DarkDynamix with it, it didn't support cube maps no matter what and lots of other inconveniences I can't remember off the top of my head.
This, along with the fact that we got lots of complaints when handing out the client to class mates and friends for testing about them having to download DX9 onto their Windows 7/8 machines actually is the reason I started on my own DX11 engine. So the project isn't directly dead, it's just getting a more capable (and tweakable!) engine. While that is in development the game itself is of course on a hold.

Quote: "Am I correct in guessing that those people who say such things probably did not score a C."

Haha, actually it wasn't just classmates who said that, even two lecturers and a supervisor expressed those views, especially in the beginning (they did admit we did deliver later on though). They were also quite adamant that we should switch to the end-all game making solution Unity like 95% of the others were. Of course their games looked better but they really didn't do much themselves (except for the media then, although lots of people actually just went to the asset store) and I suppose they scored thereafter.


Quote: "My strategy is to not have to rewrite; but to override. The engine will be modular, so all the parts which cannot be ported to your target platform, must be overriden with something that can. "

I see the idea here, but what I meant is that this will probably be true for almost all different applications; you need to know what the function for drawing a circle is and how its argument list looks and so on. I suppose that's what those language templates are for though?


"Why do programmers get Halloween and Christmas mixed up?"
Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 16th Jul 2014 23:47 Edited at: 23rd Jul 2014 02:09

Foundation Plugin - 16/07/14 - 22:00 - Enumeration Process


Welcome once again to another BM project update. Todays topic relates to my programming assistant's work on the enumeration class, I have been working on the node class, but we will talk about that in later update.

Dejan's DotNet programming language of choice is C#, as opposed to mine which is VB.NET; but that does not stop us working on the same DLL, thanks to Microsoft's Common Language runtime which can interpret instructions from both languages as well as from C++. He is working on a number of DLLs to make the enumeration feature work for DarkBASIC; so I can access my elements easily than at present with my temporary windows messages and LUA scripts. - Oh yeah, and let us not forget that you will be able to use these functions in your DarkBASIC programs.

So far he is working on the following functions:


MAKE ENUMERATOR
SELECT ENUMERATOR enumeratorIndex | SELECT ENUMERATOR enumeratorName
GET NEXT
CURRENT STRING$
CURRENT INTEGER
CURRENT FLOAT#
NEXT STRING$
NEXT INTEGER
NEXT FLOAT#
GET INDEX
GET COUNT (Yet to be initiated)


There are many more functions required for this class such as NEXT DOUBLE INTEGER, NEXT ID and a function for checking the classification of the elements; we will discuss those when we get started on them.

The most basic form of enumeration iteration using a while, repeat or for loop will work as demonstrated:

--> Outputs each string item

--> Outputs each string item until the index exceeds the number of items in the enumeration

--> Outputs each string from index 0 to the count

--> Outputs a row of 3 values in an abstract collection twice

From this standpoint it looks like a mere list of commands for iterating ZeroOne strings; but the point of consideration is where these strings actually exist; pretty much anywhere you can define; and the real power of this class comes from the fact that what is being iterated can be almost anything; not just an array or list.

How the enumerator retrieves the next entry is abstract; therefore different enumerators have different methods of supplying the current and next item in the sequence. This is why the enumerator exists; it has the responsibility of numbering the items, getting their values and storing them for access.


Notice that the SELECT ENUMERATOR command has two overloads; that is two versions. One which retrieves the enumerator by its index, the other by its name. Most if not all ZeroOne objects can be accessed by name or numeric index.

There are also a third and forth method for looking up ZeroOne elements; something we may discuss at a later date which includes looking up a custom numeric ID and looking up something by its relation to something else; for example picking an element which is linked with another.

In the next enumeration development log, we will go into further detail discussing enumeration procedures.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 17th Jul 2014 16:32
Quote: "I see the idea here, but what I meant is that this will probably be true for almost all different applications; you need to know what the function for drawing a circle is and how its argument list looks and so on. I suppose that's what those language templates are for though?"


Yeah; and I think it will be quite difficult at first to make it work; but after a few years I am sure the community will have quite a number of templates created.

So far I am using the templates to get the nodes to output code. So far so good. The flaw with templates is that they must be simple; anything complicated will need to be coded manually.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 18th Jul 2014 00:38 Edited at: 18th Jul 2014 00:41

Node Editor - 17/07/14 - 21:00 - New Node System Implemented


Today I got of to a start implementing the engine's new node system. The old node system used to parse XML nodes from within the DarkBASIC part of the engine and run through the instructions defined. This proved to difficult to tweak, monitor and update. This time the node XML is handled by the dotNet part of the engine, and the instructions are sent to DarkBASIC in the same fashion as X-Properties, which are attributes with events, sharing capabilities and triggers. Now the engine does not need to be compiled every time a change is made to the format of the XML; and by using the property system this makes the nodes more flexible for improving, updating and sharing across a live network.

I also added he node editor component from the X-Producer to the node database so that I can start completing the user interface features right where the nodes are defined.



The next step is to create the buttons and tools for node usage, and to test some nodes in live action.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 19th Jul 2014 00:48

Node Editor - 18/07/14 - 21:00 - New Node Connectors


Nodes send states or values to other nodes, and can control the flow of actions. They send and control the simulation using node connectors. Each node connector is connected from an attribute port leading out or coming into a node.

After the first month of daily updates since they began on the 18th of June, today was a day for creating the new connectors which are designed to appear more easy to follow than the previous ones, based on research. These new connectors indicate the flow of data by brightening in tone as they reach there target port. As shown in the node development tool's test node diagram; each port can recieve or send via multiple connectors.



Nodes will have a number of layout modes; this layout mode is the flowchart mode.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 20th Jul 2014 01:52 Edited at: 20th Jul 2014 01:54

Zero One - 19/07/14 - 23:00 - Equipment Upgrade Complete


Today's update has been posted to confirm that I have fully upgraded my development equipment for the purpose of building the bulk of the games, complex tools and more intensive videos. A few moments ago was the engine's first attempt at running on a 64bit version of windows which so happens to be version Windows 8.1. It seems the user interface is all intact although incomplete by plan; but not all went as planned...



I noticed that when I made the move, Visual Studio reflected some peculiar debugging behaviour; the X-Producer crashed silently and could I could not use the debugger to trace what happened. I then went into step-through-mode and noticed I could no longer edit the code as it runs. I assumed it had to do with where the program crashed in code, which so happens to be its file icon and image thumbnail process bound to a separate thread; but in reality the problem is more related to my applications build mode. It had to do with the fact that my project was set to build on the default platform, which so happens to be 64bit. This mode will not permit me to access required functionality at this moment in time, so I had to explicitly force the tool to build the frontend in x86 mode (32bit).

At some point or another, in hope, we will figure out how to get the front-end to run in 64bit mode as an option. The split process engine can supply 4 GB of ram to each process anyway, enabling the software to use up to 16 GB using the 32bit processes if ever required to do so. More than enough to carry out its purpose.

Another problem I have encountered is MikeNet (DarkNet) not working; and it seems it might be related to the operating system's bit depth. I will attempt to recompile the engine with the 64bit version of MikeNet to see what happens.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 21st Jul 2014 02:26 Edited at: 22nd Jul 2014 02:06

Zero One - 20/07/14 - 23:50 - Midnight work


Sunday was a busy day out for me, but I managed to get a little work done after midnight. The following problems occurred but have been solved:

* MikeNet (DarkNet) error
* Failure to compile some of the DLLs in x86
* Problem installing some of the third party DBP plugins

For the rest of tonight until the wee hours of the morning, I will be creating some interactive classes for interpreting the new editing and world creation user operations and for creating the nodes to compute all of the operation logic for DBP. Tomorrow it seems additional work needs to be done with XData; a class which arranges information into fields and tables.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 22nd Jul 2014 01:56 Edited at: 22nd Jul 2014 02:09

XProducer - Query Module - 20/07/14 - 23:30 - Queries


A query is a form of questioning posed to obtain qualified results in the form of logical conclusions, database tables and general check-lists. Queries are often performed by the engine to build a list of elements which meet certain criteria. Currently the query system is being composed of query functions for accessing such functionality from node or event editors; and XQL which is a simple query language designed for defining the queries in code.

The query system is broken down into categorized query elements. Today I was working on the LimbQuery element. I needed detect the limbs under the mouse for some drag and drop functionality.

When an action requires a series of limbs from various objects or a single object, a limb query can lookup the limbs running in the simulation. If there are criteria for selecting the limbs, this criteria must be set using triggers; a topic for another day.

When looking at a query in the X-Producer; in most cases the user interface element will resemble a list. The queries share similarities with lists because they are both enumerable. The difference is that queries obtain their items dynamically on request. A list does not have the ability to populate itself, list items must be added explicitly.

Requests can be made to populate the query result immediately or only when something in the list is used. When a query is set to only populate when something inside of the query result is used, this is known as a deferred query.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 23rd Jul 2014 02:28

ZeroOne Foundation Plugin - 22/07/14 - 23:30 - Enumeration


In continuation of the progress logs focused on the work on the ZeroOne foundation plugin's enumeration library, we will look at how the functions will be used in DarkBASIC. The same is also true when referencing the dotNET build of the plugin for use in C#/VB/C++.

Earlier on we looked at the functions for creating an enumerator, which can be used to iterate a series of related or unrelated elements; performing what needs to be performed on each one after the other. One of the most important functions in the enumerator class is the ENUMERATE function. The enumerate function is required to convert information supplied by a source into something that can be iterated; that is to loop through the series of elements in a collection, which may not have been a collection by nature.

Calling the enumerate function is a way of telling the enumerator where it must obtain its items. This can be from a list, dictionary, string, members of a given class or an additional call to ZeroOne function. The source of the information can vary in accord with the abstraction principle behind the engine, making the function available for general use.

There are a number of prerequisites of enumeration when calling the ENUMERATE function; for this reason additional functions have created as syntactic sugar; reducing the amount of code you need to write to reach your goals. Follow along with the reoccurring updates on enumeration this week.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 24th Jul 2014 02:00 Edited at: 24th Jul 2014 02:04

Zero One Foundation Plugin - 17/07/14 - 23:00 - Enumeration library update


Today I got the latest update emailed to me. What has been done relates to directing a specified enumerator to a selection of sources containing or referencing items.

The first source comes from lists. Lists are similar to DarkBASIC arrays; the difference between our lists and the arrays is that our lists inherit dotNet functionality providing functions such as aggregates and sums. These utility functions will be introduced much later because the present need is to get the basics working.

The second source of enumerable items come dictionaries. The dictionaries list each item attached with a key; in ZeroOne's case a string representing the name of the item (although keys are not limited to strings). Keys are used to lookup the item using a hash table. Dictionaries differ to lists and so whilst also attached with some of the list's utility functions, not all of them will work on normal dictionaries. Other types of dictionaries and lists will be a topic for another day.

The third source of enumerable items come from a function. The function is expected to return the items from somewhere you define or as is defined in the engine.

The forth source of enumerable items come from the class of the selected source. The class's attributes and functions are then converted to a collection by the enumerator. This is how DarkBASIC will interact with some of the complex class instances and static classes variable by variable where there is no easier way to return a class's composition into something DarkBASIc can interpret.

The firth source of enumeration, is another enumerator. These are treated as a collections and are thus valid sources for each other. One enumerator could be made dependant on another in circumstances such as sending information over the network; where the first local enumerator gets items from the second, and the second enumerator obtains items from the remote user.

The final source of enumeration so far is what is called the global element list. This is the list of all of ZeroOne's elements registered to be accessible by via plugin in the running program.

With a selection of methods and ways to skin the same cat, confidence can be established when using the general functions in the library without worrying about where your items will come from.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 25th Jul 2014 02:05

Zero One Engine - 17/07/14 - 23:00 - Triggers


Attributes, properties and events in the engine correspond to end-user actions, such as moving the mouse or driving a vehicle passed a finish line. The representation of end-user actions in property values, attribute values and event parameters is used for making changes to the experience of the game, or to make the alterations requested by the user.

Over the passed few days my personal task relates to creating drag and drop functionality in a 3D environment; and triggers are used throughout the program to make things work along side node functions.

In the engine, there are three types of triggers; the ZeroOne triggers, PhysX triggers and the Micrsoft dotNet triggers. This discussion relates to the ZeroOne triggers; the dotNet triggers have a similar purpose but are defined and handled differently. PhysX triggers are managed by the NVidia physics drivers which are implemented by Dark Dynamix; a DarkBASIC professional plugin.

ZeroOne triggers are either constant or dynamic. A constant trigger is hard coded into the engine, as shown in this code snippet from the ZeroOne World DBP procress:

Trigger( iDetectorFunction , iDetector, iObject )

A dynamic trigger has a UDT instance which uses the trigger functions using the supplied parameters.

Trigger( Triggers(id).Ptr , Triggers(id).Reference, Triggers(id).Int )

The first line features a function pointer which can only be specified by the engine; and the second looks up trigger parameters that can be altered by the MOD creator and the X-Producer; even the function being called by the trigger where permitted.

So that demonstrates how triggers are called by the engine; next we will look at how they work.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 26th Jul 2014 00:38

Zero One Engine - 25/07/14 - 22:00 - Trigger Calls


A call to a trigger is made when the engine requests that something not always defined at design time needs to occur, or if the engine requires a user defined change to something, or an event has been raised and the trigger as a handler of the event.

ZeroOne triggers are a unique feature of the engine from an internal standpoint because they are the smallest most simple class member. The main trigger call functions are so simple, only a few lines are required to define them in DarkBASIC:



As you can see, these functions do not perform much alone. All of the action takes place in the user defined or pre-defined trigger function. A call to the function is handled by the Matrix1 plugin by Ian, a member of TGC. This section of the class is for the most part what ZeroOne triggers are; although another part not revealed handles constructing and de-constructing the triggers.

If you happen to be a programmer, you are likely to notice that there are 3 functions with different parameters and return types. This is because triggers have the ability to alter passing values of various types. If a trigger is unavailable or undefined; the current value in the channel of triggers is maintained. If no trigger is available in the channel, the original value is maintained. We will conclude this introduction with a diagram illustrating what happens when a value reaches a point where a trigger is unavailable.



As shown, a number of triggers may be available and will alter the passing value if required; otherwise, the original value is passed back to the engine. This information reveals how some of the ZeroOne events and X-Properties work; a trigger or a series of triggers are expected to alter a passing value along a channel of triggers until no triggers are left, then the final value is returned to the engine.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 27th Jul 2014 01:48 Edited at: 27th Jul 2014 01:49

Zero One Engine - 26/07/14 - 22:00 - Nodes - Trigger Relationships


So we have seen the definition of nodes and the definition of triggers; now how do these two classes relate. The answer is that each node has a number of connections between them, passing values along channels from one node to other the nodes. The node performs its intrinsic action once all required parameter have been collected. Triggers are value passing mechanisms with the ability to modify the passing values, and relate to nodes in that they are often required to alter the values that come in or go out of nodes.

In programming, this can be demonstrated by the following hard coded node with a function of listing the limbs underneath the mouse on screen.



Here a node is created and set to use the LIMBS_QUERIES_LISTANYLIMB_INTEGER_NODE_FUNC_ID function index. It requires a trigger called TIsAnyObjectUnderMouse to check if any object is under the mouse, and uses the trigger TIsSceneObject as a filter to accept objects which are scene based. These triggers return 1 if they succeed otherwise 0 is returned and the attached function will cancel by nature when such boolean triggers return false. Most of the nodes parameters are trigger based, even the two getter parameters in the last two lines.

The example above is by no means a show of how nodes and triggers are to be created by the end-user; the X-Producer is responsible to generating code like this using the user interface as the instrument of node and trigger creation.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 28th Jul 2014 00:20
Greetings ladies and gents. I have been away from my desk and will not be posting the usual daily update on the project. Tomorrow we will commence with plugin and logic programming we have been focusing on; plus some other cool stuff...

until then, have a pleasant evening.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 28th Jul 2014 23:45

ZeroOne Foundation Plugin - 28/07/14 - 20:00 - Enumeration


Today I recieved the latest version of the foundation plugin which is thus far focused on the enumeration (As discussed in detail in a prior update earlier in this month, the enumerators will provide a means for DarkBASIC to load and iterate ZeroOne and X-Producer content, in addition to enhancing the work-flow with list utility functions).

The latest build features a static singleton instantiation property suggested by Dejan. This gives the DLL a global lazy initialized enumerator to begin with, to prepare the programmer with something straight off the bat rather than having to always create a new enumerator for each program. At least this is what I can gather from his idea; it will be a matter of time before I can test the plugin in DarkBASIC and let you know what I think.


Node Module - 28/07/14 - 21:30 - Custom Nodes


I have started to create a function which attempts to convert a class instance into a node; thus enabling all sorts of programming objects to receive structure and initialization from a node in the node editor. The term 'custom node' is being used to emphasize the fact that such nodes need not be defined by us the creators of the engine, but you also for your needs.

I will be using this function to interpret your class instance into a node, supplying it with tweaking tools based on my interpretation of your objects. Like most X-Producer content, nodes process new XML objects on the fly, and thus will need to convert your class instance into XML as it is supplied.

An additional benefit of this feature is providing the X-Producer with a means to save and load your data to XML files without you having to create your own parser; and this is just one of the many ways data can be organized by the editor.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 30th Jul 2014 02:39 Edited at: 30th Jul 2014 02:39

Node Module - 29/07/14 - 23:30 - Node Flow Diagram Upgrade


As I developed my node based programming system, I made frequent tests of the interface to get a feel of how the real work flow will be later on when designing logical elements such as materials, physics entities and sports. I have been planning for a multiview node interface; whereby each user of the X-Producer can have their own way of manipulating and viewing their nodes the way they want to. Ranging from list views to flow chart views, each view arranges the nodes accordingly. It just so happens that the first view I chose to develop is the flow chart view; a view recommended for outlining the high level aspects of your digital logic.

All organs are important

I found some undesirable features when I tested the view; the nodes looked too similar to each other making it harder to read; and the labels where a tad bit small. All of the nodes form as an organisation of synegistic interdependant cogs in ones creation; like organs they all play a vital role and thus need to stand out more.

What I decided to do was to add icons to the flow chart nodes so that they can illustrate the purpose of the nodes and I am implementing a font configuration feature.

Although this screenshot is a prototype of what is to be introduced, and it features code names for ports; it seems that so far things are starting to look more pleasent to the eye.


The next step is to create an algorithm which attempts to pick the right sort of icon for the node; given that nodes may be defined by the end-user, and there are far too many of them to hand pick their icons manually.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 31st Jul 2014 00:04

Node Module - 30/07/14 - 21:00 - Node Icons


Now it is time to gather the icons for the nodes. There are no limits to what kind of nodes can be defined, thus the collection of icons will not have a limit imposed.

There will be two ways to decorate a flow chart view or list view node with an icon. The first is to allow my software to guess what icon would be most suitable for your node using its icon picker algorithm; and the second is to choose your own icon for your node by selecting one of the icons I created or your very own imported bitmap image of choice.



Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 31st Jul 2014 23:14

Node Module - 31/07/14 - 21:00 - Node Icons




In the life of a programmer there will be ups and downs; but whether a day is good or bad it is another step in a journey and a significant part of a process. Today my assistant had Windows 8.1 related problems with returning dotNET strings into DarkBASIC without crashing the executable, and spent a great deal of time trying to get the problem sorted, and has succeeded. After a bit of a break, I think we will get back on track with the plug-in.

I spent a few moments in the day adding in major aspects of the icon selection class; and will need more time before I can get it to work and decorate our nodes with fancy icons according to node descriptions.

Until the next update, have a good evening.

Rudolpho
12
Years of Service
User Offline
Joined: 28th Dec 2005
Location: Sweden
Posted: 1st Aug 2014 02:42
Quote: "Today my assistant had Windows 8.1 related problems with returning dotNET strings into DarkBASIC without crashing the executable, and spent a great deal of time trying to get the problem sorted, and has succeeded."

Take care with that, remember that you have to let the DBPro engine free and allocate string memory (using the CreateDeleteString function referred by the globstruct) to ensure proper memory manegement. While it is usually possible to create and return your own c-strings which will be usable in DBPro, this will cause memory leaks and may result in crashes if the DBPro engine later attempts to free your string pointer (which it cannot if it isn't responsible for its allocation). So for returning a string you'll basically have to copy it into memory provided by DBPro itself.


"Why do programmers get Halloween and Christmas mixed up?"
Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 1st Aug 2014 20:32 Edited at: 1st Aug 2014 20:37
Thanks for the information; I will mention it to him.

I remember discussing CreateDeleteString before we began the work, however he said the problem was more to do with dotNet. (I do not understand the reason; the C aspect of the plugin is not in my department so to speak)

I am also not sure why this exit crash occured on Windows 8.1 and not the other operating systems.

If there is any more advice you have about anything, please do not hesitate to let me know Rudolpho.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 1st Aug 2014 23:36 Edited at: 1st Aug 2014 23:37

X-Producer - 01/08/14 - 21:00 - Image Collections


Now in order to supply the nodes with icons we needed something to organize specific icons for specific needs. As I often try to knock 2 birds with a single stone, I saw the opportunity to create something which organizes images in general; combining them into groups which I will call image collections.

With my birthday fast approaching on August 8th, I am striving to complete this phase of the development because I do not know what kind of condition I am going to be in on or after the day (probably, nothing terrible will happen to me). So today I made an extra effort by creating a user interface for creating and browsing image collections.

It will not be completed until months later when the editor's design and workflow is further established, but I will be developing the key features of the image collections required for the icons and level development.



I also added the exported version of the control to the Graphic and Brush module of the X-Producer in the images tab at the bottom. I think I will put one in the layout and material modules too; these modules all require images for one purpose or another and this control is exclusively supplied for image selection compared to the global palette tab which is for all purpose asset selection which so happens to include images.



Rudolpho
12
Years of Service
User Offline
Joined: 28th Dec 2005
Location: Sweden
Posted: 2nd Aug 2014 01:25 Edited at: 2nd Aug 2014 01:26
Quote: "I remember discussing CreateDeleteString before we began the work, however he said the problem was more to do with dotNet."

I believe the chars used by c# (and presumably .NET alltogether) are 16-bit unicode, while a c-string (as used by DBPro for one) is 8-bit ASCII. Converting isn't that big of a problem since the ASCII characters map directly to the first 256 unicode characters. However you will have to create a byte array instead of a char array and copy the data over by masking away the most significant bit from the unicode strings. Also remember that you need to have a null-termination character at the end of a c-string (basically the last byte should be set to 0) if you wish to send data to a function expecting a c-string.


"Why do programmers get Halloween and Christmas mixed up?"
Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 3rd Aug 2014 01:47
Thanks. I will mention it.

X-Producer - 01/08/14 - 23:00 - Minor update


Today I only had one hour for project work due to unavailability. Not much could be prepared and discussed in this update other than the icons for the node diagram and the image collection class are pending; perhaps by Monday or Tuesday we should have flow chart nodes with custom icons. We will see how it goes.

Goodbye.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 15th Aug 2014 23:38 Edited at: 20th Aug 2014 00:31

Binary Modular Project - 15/08/14 - 21:00 - Return to work


After a last minute 14 day vacation for my Birthday I have finally returned to work on the project. It is now time to get back into action, the level of required details of programming to art at the mind's forefront takes days to restore.

It will be interesting to see what we can get started this weekend. I hope that all of the young ones had a good start to their summer holidays; and to the older ones I hope you did not do anything I would not do!

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 20th Aug 2014 00:05 Edited at: 20th Aug 2014 00:30

Binary Modular Project - 19/08/14 - 20:00 - Start of new phase


Many collective project tasks can be tracked more easily in an ordinal arrangement of intermediate goals which are milestones. With the relaxing social break over and a new thread page there is no better time to commence towards the next milestone of testing our first plugins and nodes live in the developing engine for X-Producer and Sports Fiction.

In addition to tests; a one-to-one correlation between the user and the frontend needs to be maintained by design. The frontend in this context is either X-Producer's or Sports Fictions' user interface which requires smart applications of mouse, keyboard and controller commands bringing forth maximal levels of comfortable control and solutional customizability; a requirement which is to be the providential focus of this phase to ensure the user gets from point A to point B with little delay and great certainty.




Zero One Foundation Plugin - 19/08/14 - 21:00 - Selections for Enumeration


An inmost Selection class has been designed for the modder or creator to select elements, or the properties of the elements, for elementary expressions, iteration and modification. DarkBASIC will have a use for selectors as its means for unrestrained interaction with our dotNet defined elements; along side the more controlled and pre-managed plugin functions supplied as syntactic sugar or functional shortcuts.

The selection and selection manager classes have been promptly supplied in C# ready for review and additional work. Some of the selection functions have been briefly introduced below with more detailed summarization to follow in a future relevant update.

REGISTER ELEMENT - Adds a class instance, or member of a class, to a registered list of arbitrary elements of variant types

SELECT ELEMENT - Selects a registered element

GET STRING - Obtains the element as a string, or one of its members as a string, even if numeric in nature

GET FLOAT - Obtains the element in numerical form and returns it converted to a 32bit floating point value

GET INTEGER - Obtains the element in numerical form and returns it converted to a signed 32bit integer value

IS XELEMENT - Returns true, or 1 in DBP, if the selected element derives from a Zero One X-Element. X-Elements are instances with XML parsing capabilities and amongst other features they contain X-Properties (that is, network ready element properties which are also XML ready, automatically performing their assigned function when their values change - see the material editor shader property videos)

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 20th Aug 2014 23:52 Edited at: 21st Aug 2014 22:53

Zero One - 20/08/14 - 21:00 - Icon Picker


The Icon Picker is ready. ZeroOne can conveniently select an icon for any XElement such as a node or action button, without you the developers, needing to hand pick icons for every foreseen element that can come about by design or those unanticipated through runtime user input. Quite frankly the primary use for this class is to pick icons for thousands of action buttons and nodes; but nothing in ZeroOne is limited purposefully for any sole use thus promoting innovation and creativity unrestrained by rigid convention or initial design.

The Icon Picker is not the highest level element in the engine which would be observable to most users in the program's interface. The Icon Picker will take action on a consistent basis while the software is used; but for some users it can be used in production as part of their creation, not just a part of the tool for creation.

Like most high level elements in the engine, the Icon Picker is loaded from an XML file, with the following tag, supplied with a name attribute, as the root of the document:

<IconPicker Name="My Icon Picker Name">

Nelow is an example of an icon picker document containing the intrinsic elements. The schema for this XML is identical to the schema of the Icon Picker's derived lower level class, the Text Match Picker, which inturn uses the Picker class as the lowest level source of origin. The Icon Picker is classified as a Text Match Picker because it checks the names and descriptions of elements which need automated icon selection.

Quote: "
<IconPicker Name="Icon Picker">
<PickedItem>C:\bM\Source\SFFiles\UIData\XProducerUI\images\XProducerSmallIcons_97.png</PickedItem>
<Matchers>
<TextMatcher Name="Node" MatchedItem="C:\bM\Source\SFFiles\UIData\XProducerUI\images\XProducerIcons_19.png">
<Scores>
<TextMatchScore Text="Node" ScoreRatio="1.9" />
<TextMatchScore Text="Class" ScoreRatio="1" />
</Scores>
</TextMatcher>
<TextMatcher Name="Image" MatchedItem="C:\bM\Source\SFFiles\UIData\XProducerUI\images\XProducerSmallIcons_97.png">
<Scores>
<TextMatchScore Text="Image" ScoreRatio="1.6" />
<TextMatchScore Text="UI" ScoreRatio="1" />
</Scores>
</TextMatcher>
<TextMatcher Name="Text Matcher 2">
<Scores></Scores>
</TextMatcher>
</Matchers>
</IconPicker>
"


Each Text Matcher in the text match based Icon Picker is assigned an icon and a collection of scored strings. The more matches found in names and descriptions, and the higher the score of the text match, the more likely the engine will select the assigned icon.

Quote: "<TextMatcher Name="Node" MatchedItem="C:\bM\Source\SFFiles\UIData\XProducerUI\images\XProducerIcons_19.png">
<Scores>
<TextMatchScore Text="Node" ScoreRatio="1.9" />
<TextMatchScore Text="Class" ScoreRatio="1" />
</Scores>
</TextMatcher>"


When put to use, the picker has selected different icons for the nodes shown in the attached screenshot of the prototype interface. When no scored entry will suffice, a default icon is supplied which is taken from the <PickedItem> XML tag.



In the next update I will have discussed the solutions for getting this all to work.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 21st Aug 2014 23:32 Edited at: 21st Aug 2014 23:33

Zero One - 21/08/14 - 22:00 - Text Matching for Icon Selection Automation


Today will be the first time node editing will be shown on video; but first let us pick up where we left off yesterday in order to show how Icon Pickers work.

As was discussed in the previous update, our Icon Picker is required to select the best icon it can find for what is likely to be 10s of thousands of buttons, items and nodes for X-Producer and Sports Fiction. Unless an icon has already been attached by design, the Icon Picker will select the best scoring icon, otherwise a default icon is attached.

Assuming you already know that the Icon Picker uses the functionality of the Text Match Picker class; we can take a look at how these work.

* Firstly, the base class of the Icon Picker, simply called the Picker class, is activated when a client element is requesting something; in this context something that requires an icon makes a request for one.

* Second, The Picker class uses its distant descendant the Icon Picker to supply the functionality for selection, whilst sending the Icon Picker the name of the client element.

* In the third procedure, the Icon Picker's Text Match picking functions are assigned and used to score each icon according to the supplied text; the supplied text is the name sent by the base Picker class. (The Text Match Picker is an immediate descendant of the Picker class, and the Icon Picker is the immediate descendant of the Text Match Picker class)

* In the forth procedure, the Text Match Picker scores and obtains the best score based on its default customizable setting of the highest scoring entry. The best entry contains an icon which is sent back to the client element; but if no score available, a default icon is sent back instead.


In the following video I have briefly demonstrated how the text is scored. The video also illustrates that each text entry is given a unique score, to add more weight to terms which suit the given icon. A score has been calculated next the test text field for demonstration.





XProducer - Node Editor (Prototype) - 21/08/14 - 21:00 - Icon Picker for Nodes


In the video below, the action nodes have been demonstrated for the first time. The icons in all of the nodes where selected in realtime by the software; the SetupWindow node was given a default icon due to its icon not being added to the database, thus no score can be obtained; remember that our Icon Picker is assigned a default icon for when no score is available.

In the final product, nodes such as these will have their icons set permanently so that the CPU is not used to find icons for each and every node added to your algorithm minute by minute, hour by hour. The Icon Picker will only take action when no icon has been set, most likely when a node was generated in real-time.

It is important to note that icons and names of nodes are a part of the customizable user interface.




The next phase in the Node module job is to create the other views for different methods of node editing; plus I need to load the nodes into X-Producer and Sports Fiction.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 23rd Aug 2014 00:45 Edited at: 23rd Aug 2014 00:47

Zero One - 22/08/14 - 22:00 - Period forecast


A period forecast of development:

A number of revealed X-Producer modules will be brought into focus, some interesting aspects of the node system will be tested in the X-Producer and a series of tasks related to logic, event management and queries will be undertaken, among other things.

Earlier today I spent time using the Direct X 11 plugin created by Rudolpho. I have uploaded my first snippet of a series of DBPRO snippets using the plugin which is likely to be a good investment for my software in the future. Watch this space for experiments with the plugin.

One other interesting activity today was to design a special ZeroOne component called the Problem Solver; a homogeneous logical system which is to be put into place for Sports Fictions strategical artificial intelligence, and for internal project management needs. This component is also to become an integral part of a logic and game-mechanics X-Producer module shortly to be introduced.

Rudolpho
12
Years of Service
User Offline
Joined: 28th Dec 2005
Location: Sweden
Posted: 24th Aug 2014 01:19
Thanks for the honourable mentions
I'm looking forward to seeing what you'll come up with, and what errors you will uncover in your experiments with my plugin.

Also it is nice to see some videos of your work in action, however if possible, may I suggest trying to record those in higher resolution? It is perhaps not directly relevant to the demonstration but not being able to make out text present in a video annoys me greatly.


"Why do programmers get Halloween and Christmas mixed up?"
Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 24th Aug 2014 01:37 Edited at: 24th Aug 2014 01:59

XProducer - 23/08/14 - 23:00 - Module Tab Previews


In consideration for learners of the XProducer software, a feature was created today for displaying previews of the XProducer modules when the mouse is placed over their tab buttons. If you are not quite sure what the tab icons represent, you now have a name and picture of the module to to guide you to the one you are looking for.

The picture of the module is generated in realtime; what you see is an approximation of the current visual state of your module, including any open documents inside of the module user interface.



@Rudolpho: I will record at higher resolutions in future; it seems what is legible on my screen may not be clear on others, and the video compression makes it worse.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 25th Aug 2014 02:01 Edited at: 28th Aug 2014 17:27

Zero One World - 24/08/14 - 23:00 - Logic of the Game World


When players load their Sports Fiction game and enter into it with their digital selves; they enter into what is called the ZeroOne 'world'. Technically there can be more than one world object in a ZeroOne application; but for the time being it seems most likely that Sports Fiction will feature one world class with multiple instances of the world running on various computers off-line or on-line.

The game world is composed of two types of X-Element; the logical (usually invisible) and the physical (simulations). The logical elements are there to form conclusions, and these conclusions are used to determine actions for the physical elements which represent what you can see, hear and feel by means of hardware at-hand.

Most of the physical elements will be introduced as we introduce the sports and environmental X-Producer tools; but to begin with we'll look at the elements which are either logical or hybrid (a bit of both) formed to define and control what you see, hear and feel (where force-feedback is availabe). Knowledge of the following elements is required to understand how the game's logic system works.

These are part of a heterogeneous logical system to be used to process the sports or to design your logical creations.



X-Queries are inquiries into happenings in the world; and produce a result which can be a list of results or a new element representing the result.

I introduced you to the query element in an earlier post, and we will look further into these elements and their uses in the next few updates.

To reiterate, these elements consist of a criterion or criteria; and the result of the query is a single element or list of elements matching the criterion or criteria.



The reason module of the X-Producer is used to create X-Reasons; an X-Element not previously mentioned or introduced. These are reasoning devices for the game's AI, and some of the X-Producer's suggestion features. The brief explanation to follow may seem complicated; when seen in action this explanation will make more sense.

The X-Reason elements consist of 3 major aspects of ZeroOne's digital logical reasoning

The 3 Ps. Problem Solving, Path Finding and Proposition (or premises).

The problem solving aspect is based on my homogeneous problem solving design; where the elements of pragmatic reasoning have the same structure; they are either a problem or solution, and stem from problems, or respectively, solutions. The best solutions solve most of the worst problems; and supply the X-Reason with a strategy for decision making.

The path finding aspect is then used to determine the shortest physical or logical route to the solution; from location to destination, from current activity to target activity, from commencement to goal, or from current technology to target technology; given the context of the reasoning. Based on the strategy specified by the problem solving system, the quickest solution-for-solutions is usually most favourable where it solves many problems for the owner (likely the CPU opponents or team members.)

Finally, the proposition aspect of the X-Reason is the productive output of the element, supplying its owner with a suggested action (likely from a query of actions using X-Queries given the solution as critera); because the problem solver indicates what strategy is best, and the path finder selects the fastest route for that strategy and the proposition leads to a concluding action.

The reasoning capability of game AI is to be reduced by the level of difficulty, thus dumbed-down AI will have less solutions available and cannot pick the shortest paths all of the time.



The X-Union class constructs elements composed of elements which are not inherently related. Unlike groups, you can package any X-Element or non X-Element into a union; for example a number of 3D objects, images, queries, sounds and players could be used to form a union.

Why do we use unions? We need a way to define a complex classification of elements at runtime, during the simulation. These united elements can then behave as one composition, one X-Element; an X-Union, which can be acted upon with generalized interactivity. A good example of an X-Union is a sport in SF, which contain many components which may not be defined in hard-code and may not be designed before release, but after release by the players interested in sports customization.

When a union is formed, all of its elements are initialized (if uninitialized). When a union is removed, its elements are removed (unless indestructible). The united elements include the logical and the physical; anything defined in the X-Producer or not.

Unions can be foremd from X-Queries; the union would exists because a number of elements exist which meet certain criteria.

Unions can be formed from X-Reasons; the union would exist because the reasoner 'thinks' that the union should exist for its own benefit or detriment given the context.



Nodes are the actions of the proposed solution of X-Reasons; or the actions which produce singular or united elements.

These are symbols representing other elements that can be designed, formed in relationships and controlled using node based tools. It is fair to say that most X-Elements ZeroOne can be created or controlled by nodes. In many X-Producer editing tools you will soon see, you may not realize that what you actually see are nodes made to look like what they represent in certain view modes. - The way we usually look at nodes are in flow chart view as shown in previous posts; but the flow chart view is just one of numerous views; and not all views are interactive.



Summary

Nodes, queries, reasons and unions; these are the elements which take data and turn it into a dynamic experience. The visual and emotional essense of this is to become an integral reality demonstrated in up and coming video footage and tutorials; keen developers will soon recognize the presence of these invisible processes due to foreknowledge and will do well to grasp and make use of them in future.

The components of these elements reveal how they work; and will be the next focus in an up and coming update on the logical system.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 26th Aug 2014 13:40 Edited at: 28th Aug 2014 17:28
This is the project update for the 25th August which I was unable to upload.


Query Module - 25/08/14 - X Query Language


X-Queries are exclusively used by the X-Producer, Sports Fiction and your ZeroOne applications to obtain results from an inquiry. X-Queries are an X-Element which you may also compile in your own ZeroOne applications deployed by the X-Producer or may be a part of a DBPRO application you use with my ZeroOne foundation plugin.

Note that as was not long ago discussed; ZeroOne applications compiled from my editor will not include any of my SportsFiction or XProducer DarkBASIC programs including their viewports and physics executables; you must construct your own DarkBASIC programs (or what ever Windows compatible development tool you wish to integrate ZeroOne with); which should not take long with the X-Producers code generation features. In other words, compiling your DBPRO application is performed in DarkBASIC, and its ZeroOne features are to be compiled in the X-Producer and loaded by your copy of the ZeroOne foundation plugin for DarkBASIC.

To confuse you even more, your copy of the X-Producer can compile your DBP project... it runs the DarkBASIC compiler for you... but all of this is what takes place after effortlessly clicking a conveniently simple compile button, so all of the complicated work is done for you behind the scenes.

I emphasize these points to make clear why X-Queries are not just for x-production and sportsfictioning.

With that out of the way, we can all now look at the X-Query Language in trust that whether you are to become a Sports Architect, ZeroOne application developer, X-Producer module developer or X-Producer presentation developer, you can make use of these query features in your own works.

XQL

The features of X-Queries and the X-Query Language (XQL).

This is a comparison of the current state of XQL and the commonly used Structured Query Language (rarely refereed to as Server Query Language which is my personal preferred name).

* Structured Query Language (SQL) is used to access or manipulate information in databases. Databases store information arranged in tables used for access and manipulation. We use databases because they handle the complexities of validations, data-corruptibility, discrepancies, data-transactions, isolated storage and shared access without us having know about it.

* X Query Language is associated with ZeroOne and the X-Producer and is used to access or manipulate X; or anything that can be accessed or manipulated by ZeroOne and the X-Producer, which includes XML, images, databases and the windows operating system. XQL is processed in the ZeroOne application on the local computer; SQL is generally processed on a remote dedicated database server.

Although I do not know of any query language that is not structured; replacing the prefix with an X aligns the technology with the X-Producer and clears confusion between the two. Differentiating SQL and XQL is important because both have a role in ZeroOne and may be used and discussed vigorously, and sometimes, side-by-side in future updates.

* By principle SQL is a standard raised by the ANSI (American National Standards Institute) which "constituents to strengthen the U.S. marketplace position in the global economy while helping to assure the safety and health of consumers and the protection of the environment". It is established, trusted, safe and omnipresent. (http://www.ansi.org/)

* By principle XQL is derived and must derive from SQL to adhere to such industry standards; however, it must be tailored to work closely with ZeroOne applications and to incorporate ZeroOne-integral XML in its syntax. Where SQL is consistently keyword orientated XQL can contain keywords and XML, and thus introduces XML standards inforced by the World Wide Web Consortium (W3C).

With all of the institutionalized requirements out of the way, let us take a look at the language itself.

Obtaining information

SELECT * FROM xmlDocument

SELECT * FROM <xmlDocument><FirstElement /><SecondElement /></xmlDocument>

These two examples above contain query language statements with a similar outcome; they gather all XML elements from within a certain xmlDocument element. The SELECT keyword tells the computer to pick something, and the next keyword indicates what it is. In this case, *, anything, FROM within something. In this case, from an XML document.

The former example uses a variable to obtain the XML and the latter example literally declares what xmlDocument is, as the query is declared. As far as I know, only XQL can perform both statements as they have been written.

These examples are not the most practical use for the querying feature. More practical examples will be introduced when this discussion progresses from basic to advanced. We do not want to leave not even one person behind.

Another interesting thing about the XQL statements is the fact that both deliver XML content by reference. The XML can be manipulated elsewhere for its lifetime, which is until nothing refers to the XML in memory.

Why XML
Quite simply because most of what ZeroOne is composed of, and what X-Producer can create, is defined by it. When you create XML, you can create X-Elements, which inturn creates the entities of your ZeroOne world.


Inserting information

INSERT xmlParagraph INTO xmlDocument

INSERT <paragraph>My Text<paragraph/> INTO xmlDocument.<FirstElement>

INSERT <paragraph>My Text<paragraph/> INTO xmlDocument.Element("FirstElement")

INSERT xmlParagraph INTO ( <xmlDocument><FirstElement /><SecondElement /><xmlDocument> ).<FirstElement>

In all of the four above examples, a paragraph XML element which contains the text 'My Text' are added to the FirstElement node inside of the xmlDocument node. The first and last examples add a previously declared XML element. The second and third examples insert an XML element declared immediately inside of the XQL statement.

Inserting information at a specified location in a list
The following three statements adds a box to the start of a list, which must not be a readonly list.

INSERT box IN listOfBoxes AT INDEX 0

INSERT AT 0, box INTO listOfBoxes

PUSH box INTO listOfBoxes

listOfBoxes.Insert(0,box)

The following three statements adds a box to the at the end of a list, which must not be a readonly list.

INSERT box INTO listOfBoxes

ADD box TO listOfBoxes

listOfBoxes.Add(box)

The following three statements adds a box as the third item in the list, which must not be a readonly list. Zero based indexes are used in X-Queries, zero is the first, one is the second and two is the third, and so on.

INSERT box IN listOfBoxes AT 2

INSERT box AT INDEX 2 IN listOfBoxes

INSERT AT 2, box INTO listOfBoxes

listOfBoxes.Insert(2, box)

Note that the INDEX keyword is optional for readability.

The last examples of the previous two sets of examples feature function syntax; they use programming syntax instead of query syntax. It is fine to use function syntax in XQL statements, as is the case in some SQL, but the use of query-styled syntax over functional syntax is more easy for most readers of English to interpret. Note that in theory, function syntax is marginally faster when X-Queries are declared at runtime, but this is not a good reason to use such syntax prior to seeing evidence.

Named queries
The following three statements are named by assignment to variables. Each example will return the same number of results, but with a slight difference in behaviour.

XQuery = SELECT * FROM list

XQuery = SELECT FROM list

XQuery = list

In the previous examples; the XQuery variable will contain the content of the list. In the second example, the SQL styled asterisk (*) symbol usage was removed because in XQL the symbol is optional. In the third example the XQuery variable and list become the same thing; when the XQuery variable is manipulated, the list is manipulated; this is not true of the first two examples where they become a read only list of results.

All three XQuery variables have deferred results, with content of the first two XQuery variables empty, or unprocessed, until something makes the inquiry, and each time something makes the inquiry. The third variable being a reference to the list, does no filtering (unless the list in-question happens to be an enumeration of something else).

The FROM keyword is optional, and is often more easier to read than when it is omitted.

Counting the results
In the following examples, if there are 10 players and XQuery = SELECT FROM players, then all of the examples will display how many players there are. The print statement is a utility keyword used to output text to the XQuery console. The exceptions are that the first example runs a deferred query assumed to be declared as a variable in a previous statement, the second example declares and runs the query at the same time, and the last example gets the count directly.

Print XQuery.Count

Print (SELECT FROM players).Count

Print (SELECT players).Count

Print players.Count

All four examples return the number of players. They are all processed because the Count property will run the inquiry immediately.

Forecast

In a near future X-Query update; we will have introduced more XQL statements, more detailed queries and videos demonstrating X-Queries in action. Further along in time, my first simple ZeroOne application compiled by the X-Producer will be used to demonstrate X-Queries in deployed software. We will also demonstrate the connection between X-Reasons, X-Queries and X-Unions in ZeroOne's processing of game logic.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 27th Aug 2014 01:47 Edited at: 28th Aug 2014 17:28

Unions Module - 26/08/14 - 20:00 Comparison to Groups, Lists and Entities


The Union X-Element is a composition of ZeroOne elements; and can be primarily understood as a group, and is somewhat comparable to lists. Before being able to use the Union editor in the X-Producer or defining them in XQL or XML, it is easiest to understand this element with a comparison to groups, entities, categories and lists.

Groups, X-Entities and lists have certain functionality in ZeroOne which is shared by X-Unions.

Purposes
While each of these components have been created to handle a primary purpose; not all creative solutions stem from the primary purposes of such components; therefore it is best to view this information as a guide, taking in these following statements with a grain of salt.

Lists, groups, X-Unions and X-Entities are containers of X-Elements, X-Elements can be added to or removed from them.

* Lists are used to refer to a number of elements, variables or constants arranged in as a sequence for storage, sorting, iteration and comparisons.

* Groups are primarily used to identify a number of elements, variables or constants.

* X-Entities are primarily used to represent something interactive that is a significant physical prop in a scene, or an interactive resource in an application. These are composed of elements, variables and constants.

* X-Unions are primarily used to classify a number of X-Elements, variables or constants as a single X-Element based on another X-Element class, inheriting its functionality. These are interactively used as a significant physical prop in a scene, a section or structure in a scene, or as a resource in an application; and use inherited functionality to perform its purpose.


What they can store

* Lists, groups and X-Unions can contain any type of data. X-Entities can only contain X-Properties, X-Items, X-Unions and child X-Entities.

* A piece of data can only be assigned to one group; but can be assigned to unlimited lists and X-Entities.

* The number of X-Unions which can contain an item depends on what kind of X-Union has been defined.


What classifications are available

* Groups are unclassified.

* X-Entities are unclassified, they all share the same underlying structure, although what they contain determines their capabilities.

* Lists are either classified to store data of a specific type, or to store variable classifications of items

* X-Unions are classified from any existing class of X-Element or complex datatype. A series of elements united as an X-Entity would form X-Union which behaves as an X-Entity, and a series of elements united as a list would form X-Union which behaves like a list.

What are the overheads

* There is little or no overhead when computing lists or groups

* Entity loading times depend on the content of the given entity, but is faster than loading a Union

* Union instances will take slightly longer to load than entities; union class definitions will take somewhat longer. Class defintion is best performed in transitional situations.


What actions can they perform

* Groups cannot perform any actions; you must perform the actions of group members on an individual basis.

* Lists can add, remove, sort and run calculations based on their content. You must perform the actions of group members on an individual basis.

* X-Entities can perform game actions, can spawn or destroy other entities, can collect X-Items and can manipulate the environment through X-Properties.

* X-Unions inherit their actions from their derived class; member actions are performed on an individual basis.


What happens when an they are loaded

* Groups immediately refer to any loaded element, variable or constant in memory that is assigned to the group.

* Lists contain references and thus behave similar to groups when loaded.

* X-Entities load their assets and child entities

* X-Unions load what ever they are classified to load.


What happens when an they are unloaded

* Lists and groups perform no action on the members when unloaded

* X-Entities and X-Unions will unload their members; except when such members do not permit be unloaded by the parent


Summary

X-Unions are classified as to how they work, and are composed of a list of members including elements, variables and constants. Instances and classes of X-Unions can be constructed in design-time or run-time. These should not be construct merely for grouping or listing content.

Unless the intention is to define an advanced component which governs a group of entities and elements inside of a scene or world and is to recieve special functionality to be performed on itself and its members; lists of entities should be used instead of unions of entities.


Sports Fiction - 26/08/14 - 23:30 Sports Architect Preperations


Today was spent preparing components, documents, videos and demonstrations of Sports Architecture. The architecture of sport is a milestone that precedes the fun-tests and storyline phase. The Sports Architect is an X-Producer development kit for SF (exclusive for people who own a copy of SF). It is to be used by sports architects to customize existing sports or create new sports. It uses X-Producer and 3D content to define sports arenas, environments, tracks, fields, courses, mazes and equipment based on the structure, flow and rules of a given sport.

Each sport is based on a set number of objectives. They have specified a number of participants, teams and levels. They are layered with stages of gameplay rewarding resources and points for the types of actions and achievements made by the players. Resources and experience points advances the players to higher levels of more prestigious sporting activity. The prestigiousness of the sport being created is constrained by the skill and rating of the sport's architect; or group of architects.

There are more than 100 components and principles of sports currently being defined and tested for use.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 27th Aug 2014 23:32 Edited at: 27th Aug 2014 23:44

Sports Architecture - 27/08/14 - 21:00 Sports Outline


Today the outline for the sports was updated, which is a guide for my current work on the sports; and to prepare interested sports architects.

This information is development log, it is not part of the game manual and is not suitable for those soley interested in casual gameplay; where there will be plenty dedicated for you having some fun, on this particaly day the topic of discussion is about creating the actual sports or for progression to play professionally.

The sports fall under a number of branches; and within these branches, classifications; were each sport is categorized by features. The Sports Outline is subject to change during development.

Parts of the outline have been shown below; the other parts are what you will have to eventually find out for yourself, when they are revealed.



SF Sports Outline - v0.48



Requirement for Sports

* Must derive from a predefined sport, which also adheres to the following

* Must contain a competitive quality associated with the casual and professional game modes

* Must not rely on luck

* Must have a clearly defined description of what the players must do

* Must award associated skill levels and abilities for characters participating, managing and manipulating

* Must feature all levels of difficulty (AI and assists)

* Must provide CPU processed opponents (AI)

* Must present at least three of the tiers of user activity (sportsfictioning), including the first (observation) for online spectators



Branches of Sport

* Combat Sport

* Coordination Sport

* Equestrian Sport

* Management Sport

* Mechanical Sport

* Mind Sport

* Navigation Sport

* Racing Sport

* Strength Sport

> and Multi-Sport, A combination of a number of branches in one sport




Tiers of Activity (or tiers of sportsfictioning)

All sports contain optional activities. Each subsequent tier of activity features higher levels of game control, from controlling nothing to controlling the structure of a league. One cannot enter into Sports Fiction without performing at least one of the following:

Tier 0 - Observation

Tier 1 - Participation

Tier 3 - Management (of team)

Tier 4 - Manipulation (of opponent / environment )

Tier 5 - Organization (of team / tournament / league )

It will be possible to undertake more than one of the tiers of activities when in the game. All sports must support tier 0; it must be possible for users to enter into the sport and watch the action online using 3D cameras (viewports). All other activities are optional because the CPU and the artificial intelligence can perform them; in the special case of sports manipulation, such activities are exclusive to sports which feature manipulative actions on opponents or the environment.



Tiers of teams

* Squad - A number of joint players taking part in a specific sport. One player can be a part of numerous squads; thus being able to play the sports they want
----- MODs: Sports Fiction and Sports Fiction Pro

* Group - A number of squads united under an umbrella group who organizes games and leagues while competing in various sports; scoring on a per sport basis against other groups
----- MOD: Sports Fiction

* Nation - A special group who's members originate from a single province, country or continent.
----- MOD: Sports Fiction Pro only

Physical Features
* To be revealed *

Environmental Features
* To be revealed *

Equipment
* To be revealed *

All designs and customizations of sports from the development team and the users must adhere to this outline; which is to be displayed within the game and the SDK; and is subject to change.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 29th Aug 2014 00:47 Edited at: 29th Aug 2014 00:52

Zero One Foundation - 28/08/14 - 21:00 Engine Variables


I want to wilfully provide DBPro with access to the ZeroOne core variables using the foundation plugin. These variables are used to obtain information about what the user interface and the base elements of the engine. This is a handy way of making data transactions between DBP and the XData. Today was spent writing the engine variable sharing functions in dotNet, and a test project in DarkBASIC. So far the test project looks like this:



Each of the engine variables are accessed using a hash table; and can have their values retrieved by ID. There are many more functions in this part of the engine; but for now hopefully my assitant will produce the links to these functions in the plugin at some point this week or next week.


Sports Fiction - Assets - 28/08/14 - 21:00 Texture Asset Plan


Today was also spent reviewing the assets of the Sports Fiction game. Most of 2014 has been focused on infrastructure and UI programming. It has been a long time since I got my hands dirty in visual and sound asset creation; but this is about to change because I need to make the footage look presentable enough for early showcasing and testing.

A number of visual techniques have been practised on the odd occasion throughout the year, and now fast approaching is the time to put these techniques into action. Today I recalled my research relating to procedurally generated rock, brick and concrete. This is one of a number of techniques under the procedural generation aspect of the X-Materials in XProd.

Procedural texturing is one half of the job which is being used to add randomality to the hyperrealistic textures; and to create tiles.

The main principle under argument is the use of noise to reflect the rugged nature of stone and concrete as digital materials. As is demonstrated below, the level of noise used on the base textures are high, and the outcome is a rough looking surface.





Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 30th Aug 2014 00:14 Edited at: 30th Aug 2014 00:20

Materials Module - 26/07/14 - 22:00 - Pixel Movement


Normal Mapping, Height Mapping, Light Mapping, Custom Mapping? - Yes, the latter mentioned technique is not quite you were expecting; but allow me to explain; custom mapping is simply an the act of mapping pixels onto your objects in your own way; using the colours and tones for your own calculations.

A number of shaders being developed for Sports Fiction feature such customized mapping requirements for textures; where normal maps often use the lower and higher ranges of Red and Green to represent the direction of surface normals (or the angle of surface); your own mapping technique would use the colours for something you specify.

One thing we can do with colour values, is animate pixels.

Moving pixels in a shader
There are a number of ways to apply motion to not just vertices, but pixels. For today we will look at how I am using the timer to move pixels around; the timer being omnipresent in and outside of HLSL can sometimes be overlooked.


Special texture maps
To demonstrate, we have a base image which represents the texture of an entity in a scene; which in this instance is a group of vertical lines


And below we have a gradient map used as a coefficient grid for the final effect.



Result
When the brightness, or in this instance a single component of each pixel, of the gradient map is used to affect the UV lookup of the base texture, based upon the given engine time,; we get pixels that appear to move.



Here the base image moves up and down because its vertical component of its UV coordinates is being multiplied by a coefficient.

The coefficient is the level of red in the gradient map; the level of blue, green and transparency has not been included. White is represented by 1.0 in each of the channels of colour; and black is represented by 0.0 in the channels of colour. We could combine all of the channels to detect the true brightness; however since this is a custom texture mapping procedure, we can choose what component we want to use for the task, reducing the complexity of the calculation to one component, safeguarding the system from shader complexity issues.

The pixels appear to move because the ever-changing timer, used as the parameter of the sin function, is used to multiply the coefficient; but in reality the pixels do not move; their texture sampling coordinates change, and the texture sample features an image detailed enough make this change look animated.

The simplicity of this feature is what makes it widely used so far.

Test Shader


Ortu
DBPro Master
10
Years of Service
Recently Online
Joined: 21st Nov 2007
Location: Austin, TX
Posted: 30th Aug 2014 00:26
Very cool, the potential of shaders has always fascinated me, but sad to say i have only just begun to dig into HLSL. Your shader work has always been one of the big highlights of this thread.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 30th Aug 2014 20:56
Play around with shaders already created; it is a fun way to learn.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 1st Sep 2014 12:01 Edited at: 14th Sep 2014 18:12

Sports Fiction - 01/09/14 - 9:30 - Control System


Traditions




With its own exclusive wikipedia entry, a self titled keyboard product line and an entry in the Urban Dictionary, WASD is the most common gaming configuration representing the arrow keys on a keyboard; and little has changed since the competitive days of Quake, and without doubt, if we ever get a future PC version release of Bungie's up and coming epic title, Destiny, players will be manoeuvring around level platforms with the same tradition almost two decades ago.

The WASD movement binding is popular in first person shooters, role playing and driving games. Players expect to be able to control the character or given vehicle without reading the manual. Having the WASD bound to player movement, in addition to the arrow keys, reduces the complexity and learning curve of the game; having the gameplay commence without delay. Player's who are already used to certain game control configuration or standard, can bring that knowledge into action in a different game.

Such standards are by no means limited to controlling the central character; there are other gaming traditions which players expect to have implemented; some more common than others. But some expectations are quite individualized, I have my requirements, and you have yours. By providing a means of modification, the individual's product can be modified to satisfy the wishes of the individual.

Sports Fiction's control system task has been continued over the past few days, and is being developed with a template based on the most common traditions in various game genres; and each sport will have their control systems taken from such traditions.

For customization, all permitted player actions have the ability to be bound to input from customizable keys, gamepad buttons, mouse buttons and movement. Each scalable action permitted can also have its rate of fire and scale adjusted by the user to best suit their playing style and needs. The action class has implemented such attributes and can be configured in the option screen.


Scenes Module - 01/09/14 - 10:00 - Scene Cameras


Some of today's work will be based on creating the required functions for capturing scenes and following the player character. The scenes module consists of functions for loading, structuring and capturing environments. The scene camera uses the DirectX camera as a basis and expands it with logic and event triggers.

Two simplified functions have been posted below to demonstrate where it all starts.

The first function causes the current camera to follow a certain object; as



The second causes the camera to watch an object, or its root limb from a given distance and specified angle.



There is usually only 1 camera which receives such control; however in some situations you will soon see, numerous cameras need to follow and watch various objects from various points in scenes.

I will now be getting on with today's work.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 14th Sep 2014 18:21 Edited at: 14th Sep 2014 18:23
Appologies for the delayed updates; unfortunately I have been ill and will be focusing on my health, with visits to the doctor and the gym.

I also have more than the usual responsiblities at work at the moment, since a manager and team leader has left; it is just me running the show in a busy retail warehouse. Until a new manager is taken on board, I will have reduced time for the project.

Adaptation not submission
With all unexpected problems I always try to find a way to adapt, taking up any opportunities; refusing to submit to stagnance or inactivity, something highly recommended for all to avoid.

In this disappointing month of limits; I will make one or two posts when I can. So far, I have spent most of my project time learning new tricks. It will be interesting for you to see what these tricks are when I return...

Rudolpho
12
Years of Service
User Offline
Joined: 28th Dec 2005
Location: Sweden
Posted: 20th Sep 2014 19:36
Sorry to hear about your health issues, hope you will get better soon.


"Why do programmers get Halloween and Christmas mixed up?"
Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 23rd Sep 2014 20:46 Edited at: 23rd Sep 2014 20:47
Thanks Rudolpho

I am going to the doctors tomorrow to get to the bottom of this. A number of symtoms related to fatigue and low recovery will be addressed, and hopefully after some screening and tests we will find the cause of the problem so things can get back to normal.

I look forward to continuing soon.

Chris Tate
DBPro Master
10
Years of Service
User Offline
Joined: 29th Aug 2008
Location: London, England
Posted: 24th Sep 2014 23:54 Edited at: 24th Sep 2014 23:56

Zero One Foundation - 24/09/14 - 15:00 Engine Variables


After a three week period of inactivity, today was spent getting back into action. Here commences our next batch of updates.

Today I had a brief exchange of messages with Dejan regarding the engine variable functions he is implementing into the foundation plugin. As discussed previously, this is for providing low level control over the elements which make high level components of the system work, according to the specifications and preferences of the end-user and their system.

Benefits of low level control seen at present
If something does not work as expected, the developers can adjust the experience without the presence of dedicated tools
Temporary measures by variable manipulation can prudentially turn into beneficial long-term features
The variables can be altered for debugging purposes, helping you track down the potential causes of faults

Security measures for low level control
Not all users are permitted to alter all of the security-tiered engine variables
Security is an ongoing requirement planned, implemented and tested daily for our needs and yours
A certain degree of logging has been set in place for tracking manipulation of engine variables





Sports Fiction - 24/09/14 - 18:00 Entity Modelling


I have had to spend most of the year programming the editor and interface, but now I have continued with modelling and texturing for the game. There were never any plans to create a modelling program because Blender fits the role perfectly; although some aspects of modelling are possible in the X-Producer, these modelling tools are purposed for turning 3D models into interactive X-Items and X-Entities. A number of interesting Blender modelling topics came to mind as I continued where I left off a year ago.

Navigating large objects in Blender
Today I spent some time working on a certain large scaled scene featuring various technological components; which reminded me of a certain setting put into place by the Blender development team for navigating around large objects nice and easily. In addition to using Blender's the fly-through-mode (CTRL+F), you can mouse-scroll into a certain point along the surface of an object using the 'Zoom to Mouse Position' option situated in the Interface tab of the user preferences window. Moving from one point in a scene to another only takes a mouse scroll.

Whilst in edit mode you may also focus the camera and pivot around a vertex or group of vertices. This is performed by selecting the sub-geometry of interest and pressing the number pad dot (.) key. Now when rotating the camera using the number-pad; you are rotating around the geometry of interest, so to put it.

Extruding geometry, without altering the source mesh in Blender
Today I had to extrude parts of a certain complicated object to be showcased in future. There were a number of requirements I had in mind which could not be fulfilled with regular extrusion, by my understanding.

I need to alter the depth of the extrusion as and when I see fit in the future
I need extrude similar parts of the mesh without using a mirror modifier or array modifier for duplication
I wanted to preview how the extrusion looks, make some minor alterations with the extrusion un-applied, then have the extrusion restored

So how would you perform such a task?

Well some of you already know, but for those who do not, I will explain in tomorrow's update.

Login to post a reply

Server time is: 2018-10-15 17:42:43
Your offset time is: 2018-10-15 17:42:43