next »

[RalenHlaalo]

For one of my previous games, I implemented the ability to record the player's inputs and play them back later to re-simulate the play session. It was pretty cool, and I wanted it in my current project, so I turned it into a reusable library. Got it integrated into the new one now, and it worked perfectly first try. I'm automatically saving all play sessions to disk in a way that won't be disrupted by a crash, with the idea that this would be an amazing feature to have for debugging... If I find a bug or a crash, I'll always have a replay that can reproduce the problem. Very pleased with it!

The benefits of determinism! Does this mean you're limiting the frame rate somehow, as opposed to moving things by variable deltas? That's what I'm doing, by sleeping the thread - which works more reliably on some platforms (Linux) than on others (Windows).

Another advantage is the ability to play in-game cut-scenes as just a sequence of actions, requiring very little memory. For example, a character could run and jump onto a moving platform, blast a bad guy, all while dodging pieces of falling debris, and you can guarantee that it will run the same every time.

[zacaj]

Another advantage is the ability to play in-game cut-scenes as just a sequence of actions, requiring very little memory. For example, a character could run and jump onto a moving platform, blast a bad guy, all while dodging pieces of falling debris, and you can guarantee that it will run the same every time.

If you can encode your cutscenes using regular input, you might want to reconsider them being cutscenes...

[RalenHlaalo]

Another advantage is the ability to play in-game cut-scenes as just a sequence of actions, requiring very little memory. For example, a character could run and jump onto a moving platform, blast a bad guy, all while dodging pieces of falling debris, and you can guarantee that it will run the same every time.

If you can encode your cutscenes using regular input, you might want to reconsider them being cutscenes...

Perhaps I didn't mean 'cutscenes'. What word would you use? I'm sure you knew what I meant.

[ThemsAllTook]

The benefits of determinism! Does this mean you're limiting the frame rate somehow, as opposed to moving things by variable deltas? That's what I'm doing, by sleeping the thread - which works more reliably on some platforms (Linux) than on others (Windows).

Yep, fixed delta for everything related to game logic. If sleeping your thread isn't reliable, you might be able to get better results by enabling vsync and doing something like this.

Release it!

Working on it! I'll post here once it has a home. It's technically available now (with minimal documentation, and a bunch of dependencies on other things in my game framework) if you want to dig through my svn repository: http://sacredsoftware.net/svn/misc/StemLibProjects/inputcontroller/trunk/

[RalenHlaalo]

The benefits of determinism! Does this mean you're limiting the frame rate somehow, as opposed to moving things by variable deltas? That's what I'm doing, by sleeping the thread - which works more reliably on some platforms (Linux) than on others (Windows).

Yep, fixed delta for everything related to game logic. If sleeping your thread isn't reliable, you might be able to get better results by enabling vsync and doing something like this.

The problem is, my renderer runs in a separate thread. If I were to use the method described in that article, it would essentially amount to 'busy waiting', which I'm trying to avoid. I'm proud of the fact that when my engine is running, the CPU usage is very low (for a simple game). You can minimise the game and do other things without the fan speeding up or your laptop getting hot.

[ThemsAllTook]

Waiting on vsync should use basically no CPU. That said, there are other benefits of multithreading, like being able to take advantage of multiple CPU cores... It should still be possible to use a fixed timestep with your method, just by having the logic thread try to sleep for an appropriate amount of time, and the render thread block on vsync and use the latest results it can get from the logic thread to draw stuff.

[RalenHlaalo]

Waiting on vsync should use basically no CPU. That said, there are other benefits of multithreading, like being able to take advantage of multiple CPU cores... It should still be possible to use a fixed timestep with your method, just by having the logic thread try to sleep for an appropriate amount of time, and the render thread block on vsync and use the latest results it can get from the logic thread to draw stuff.

Yeah, that is what I'm doing. It's just that sleeping isn't quite as reliable under Windows as it is under Linux, but it's not a big deal.

[ThemsAllTook]

Yeah, that is what I'm doing. It's just that sleeping isn't quite as reliable under Windows as it is under Linux, but it's not a big deal.

Maybe you could use a semaphore to wake the logic thread when the render thread finishes a buffer swap? I don't do a lot of real-time multithreading, so I'm not sure if this is a good idea, but off the top of my head it seems like it might work...though maybe Windows's semaphores have timing just as imprecise as its sleep functions.

[RalenHlaalo]

Yeah, that is what I'm doing. It's just that sleeping isn't quite as reliable under Windows as it is under Linux, but it's not a big deal.

Maybe you could use a semaphore to wake the logic thread when the render thread finishes a buffer swap? I don't do a lot of real-time multithreading, so I'm not sure if this is a good idea, but off the top of my head it seems like it might work...though maybe Windows's semaphores have timing just as imprecise as its sleep functions.

I imagine the thread would still have a tendency to occasionally oversleep. Moreover, the reason I decoupled the renderer from the main thread in the first place was to allow the game logic to run at a decent speed on occasions when rendering is slow - such as on low-spec hardware - thus maintaining the speed and responsiveness of the underlying simulation. Tying the main thread to the renderer in the way you suggest would defeat the purpose of this multi-threaded design.

[ThemsAllTook]

Happy moment yesterday: I had a need for some small snippets of code scattered around various modules to run at startup. I didn't really want to have to update main() to call each one explicitly, but I didn't know of another way to do it. After discussing with other programmers for a while, and briefly considering parsing my executable for to load symbols matching a specific pattern and execute them, I stumbled upon __attribute__((constructor))...exactly what I needed! gcc function attributes can do all kinds of cool shit: http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html

[Rusk]

Happy moment yesterday: I had a need for some small snippets of code scattered around various modules to run at startup. I didn't really want to have to update main() to call each one explicitly, but I didn't know of another way to do it. After discussing with other programmers for a while, and briefly considering parsing my executable for to load symbols matching a specific pattern and execute them, I stumbled upon __attribute__((constructor))...exactly what I needed! gcc function attributes can do all kinds of cool shit: http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html

That is cool... but I can imagine how tricky it would be to hunt down a bug in those functions if you didn't know (or forgot) about that.

[ThemsAllTook]

That is cool... but I can imagine how tricky it would be to hunt down a bug in those functions if you didn't know (or forgot) about that.

For sure! Definitely a thing to use as sparingly as possible. The situation I have is perfect for it though.

[Slader16]

I made my first program in Java. It prints out the multiples of whatever number a user inputs. 

[OniWorld]

Finally got support in for quadratic bezier curves, now I can make amazing environments with very little effort and processing power!

[TheLastBanana]

That looks super cool, OniWorld!

[oahda]

Finally got support in for quadratic bezier curves, now I can make amazing environments with very little effort and processing power!

ÆæÆÆÆææææÆæææä that looks soo good.

[Noogai03]

1) dat bezier curve


2) it's so weird when you find really cool frameworks that have barely been used by anyone, especially when they're really advanced (like with their own setup program, etc)

[Fallsburg]

Just made an Answer Set Programming model that can create metroidvania style maps with lock and key mechanisms. It can burn out 1000 different maps in 1.5 seconds.  Pretty psyched.

[Garthy]

Happy moment yesterday: I had a need for some small snippets of code scattered around various modules to run at startup. I didn't really want to have to update main() to call each one explicitly, but I didn't know of another way to do it.

If you're using C++ and are after a compiler-portable way to do it, you can always use the constructor in a class that is used for a global object, eg:

Code:

static void CodeToCallOnInit()
{
  // Do stuff here.
}

class Foo
{
  public:
    Foo() {CodeToCallOnInit();}
};

static Foo foo;

Early C++ compilers had some trouble with this (I saw similar code have problems with gcc circa 1997 but the actual gcc may have been older) but it's been a safe construct for a while now. It'll be called before main() begins, at least in every environment I've seen.

[riksteri]

Preparing to publish my first open source project. It is really just for giggles and learning the ropes of the hosting services out there (this one is in Bitbucket). Hopefully it also gets employers to tick off another box for me when I apply for jobs. Not a too serious development effort, but still plenty of reason to make me happy for the moment. Still a couple things to do before hitting the button. (It is not a game, by the way).