Spherical forums Community for the Sphere game engine

New? Contact Us to register an account!

I split this off from my response on the Plugins part.

Let's make Pegasus async (non-blocking). Node is, indeed, and we should follow this path. No multi-threading (for now), but one big event-loop. Yes, I say event-loop because it sounds a lot like 'game-loop'. (node uses an event-loop).
This might be harder than non blocking without an event loop, but it does solve a lot of issues regarding files and such. I am not sure how this would be designed, especially in a game, but I will look into it today.

If we follow the node.js modules+async path, I think I could implement a full-software (slow) engine by implementing Pegasus on top of Node. This could be used for prototyping. Not really for games, that is too slow. Also, 'npm install sphere-pegasus'.

If we go with Async, I suggest we use Promises. Promises is an ES6 builtin and there is Bluebird and many other libraries for ES5. You can also implement it yourself if you like, which is good fun. Use promises where-ever you can, that is.
As you might have no idea what promises are, I will explain it a bit:

A promise is a promised value. A promise can either reject (with an error) or resolve (with a value).
A quick example: loading a file. That can either fail (file did not exist, system error, whatever) or it can succeed (with the data). Now, in Node-style-async you would thus have the following function:

function loadFile(name: string, callback: (error: Error, result: any) => void): void

(Yes, this is JavaScript with typings so that is easy)
You call this:

loadFile("myFileName.y", function (error, result) {
   if (error) {
      console.log("Oh no! An error occurred! EXIT!");
      process.exit(1);
   }

    console.log("All went well, lets print and exit.", result);
    process.exit(0);
});

This ain't too bad but it is not nice either. Lets say we want to read a file and then directly write it.

loadFile("myFileName.y", function (error, result) {
   if (error) {
      console.log("Oh no! An error occurred! EXIT!");
      process.exit(1);
   }

   console.log("All went well, lets print and write.", result);

   writeFile("myOtherFileName.y", result, function (error) {
        if (error) {
            console.log("Oh No!: Could not write! EXIT!);
            process.exit(1);
        }
        console.log("ALl went well, wrote the file. Bye.");
        process.exit(0);
   });
});

This is getting worse and worse.

Also, you are processing errors over and over again.
Lets see what it all looks like using a Promise: a value that promises a result.

 function loadFile(name: string): Promise

loadFile("myFileName.y")
   .then(function (result) {
       return writeFile("myOtherFileName.y", result);
   })
   .then(function () {
      console.log("All Finished!");
   })
   .catch(function (error) {
      console.log("An error occurred:", error);
      process.exit(1);
   });

Short and nice! WIth ES6/TypeScript this is even shorter (you can compile ES6/TS to ES5):

loadFile("myFileName.y")
   .then((result) => writeFile("myOtherFileName.y", result))
   .then(() => console.log("All Finished!"))
   .catch((error) => {
      console.log("An error occurred:", error);
      process.exit(1);
   });

That is beautiful! What you read is what happens! And no deep tabs.

I hope I convinced you that this is the way to go.

(You might wonder, what does loadFile code looks like?)

function loadFile(name: string): Promise {
    return new Promise(reject: Function, resolve: Function) {
        // Do stuff
        if (an Erorr happened) {
           reject(new Error("An error"));
        } else {
            resolve("data");
        }
    }); // returns a promise right-away
}

For simple function you can also return Promise.resolve() or Promise.reject(). So a stub implementation that always resolves:

function loadFile(name: string): Promise {
    return Promise.resolve("somedata"); // STUB
}

If you have any questions of anything, respond!

Yeah sorry, I was off the sphere-grid for a while.
It happens a lot to me, that I just lose interest for a couple of months, and then I just forget about it, until I get emails!

So what will I be doing? I will not be implementing my own engine anymore, as TS also works on OSX.
All I will be doing it working on Pegasus.

So, hi, again!

Wow, that is one big screen.

I do think I will stick with my tripe screen setup I like my screens clean, and 3 fullscreen apps on display at all times does that for me.

The retina thing is why I once proposed to use floating point coords and sizes instead of integer. It does not matter for JS, and storage is the same too, but integer math might be a bit slower.
The advantage is that you can keep 1pt = 1px on non-retina, and on retina, 1pt=2px, like Apple does. also, you can then do 0.5pt = 1px on retina: making it possible to do interpolation and smaller graphics but also keeping non-retina games to work on retina displays.

I think that is what we should be aiming for.

Hello then! Welcome back!

Wow this is awesome!

Makes me reconsider my mac engine: I could just fork/pullrequest TS and write plugins... currently i only use my engine to experiment anyways. I don't see myself writing a graphics engine as well as yours!

If i find the time, ill run it on my mac tomorrow.

Feature request: V8 remote debugging (allowing it. Can use d8 to debug).

I might cease working on the engine and continue on my IDE instead and a builtin debugger is a must-have!

Keep the work up!

// Rahkiin

Let's just say this project helped me get that job.

Then I think it is time from a story by Radnen!
I love when hobby leads to work.