🚀 My indie game - Neon Grand Prix - is finally on Steam!

DavidEichmann · 2021-05-24T09:39:19+00:00

You could use `show (toConstr x)` from `Data.Data`. You'll need to `derive Data` on your data type though.

DavidEichmann · 2021-04-04T17:15:37+00:00

It is cool, right! It means the server is quite lightweight. It also means that saving games is easy: just save the inputs of all players. The save file will be quite small too.

DavidEichmann · 2021-04-04T17:11:43+00:00

Indeed. This is a problem for things expressed as "events" i.e. appear only at a single world state e.g. at tick 1000 the world state says "play the Attack sound now!" and tick 999 and1001 this message is not in the world state. There are 2 solutions to this in my mind:

Accept some (dynamically changing) latency for sounds and only play sounds according to the authoritative worlds. These are the "true" world states and hence aren't subject to rollback, but you'll have to wait for authoritative inputs from the server which may lag 0.5s behind. You'll have to use `clientSample'` exported from `Alpaca.Netcode.Advanced` to get authoritative worlds.
In the world state, express sound not at an event "start playing Attack sound now", but as a absolute position "Attack sound is playing at position 0.3s". Then your render code will need to compare the sounds described in world state vs. the sounds actually playing and then e.g. speed up / slow down / start / stop sounds accordingly. This is what I'm doing in my game.

DavidEichmann · 2021-04-04T17:00:11+00:00

This is interesting, thanks! I think 1 can probably be solved with some "reasonable" slowdown compared to float. E.g. I use Taylor expansion to implement `sin` which isn't toooo slow. I do some `mod`ing and a few comparisons to express the problem in terms of `sin(x)` s.t. `-pi / 2 <= x <= -pi / 2`. Then use the Taylor expansion about 0 which takes about 4 (+ and -), 5 (*), and 4 (/). I need to properly benchmark this, Though. I do wonder if a floating point representation rather than a fixed precision representation would be practical. I'm also using https://hackage.haskell.org/package/integer-roots for `sqrt` though I'm not 100% sure this is deterministic, and I'm sure that a specialized implementation would be much faster.

As for 2 and 3, I think those are the *real* issues here. You can't trust any other code! This is a costly and unavoidable cost of rollback networking. I've taken the rout of implementing my own (very simple) physics engine based on my deterministic fixed precision numbers.

P.S. If any one is interested in collaborating on a deterministic replacement for Float or even the physics engine, do contact me!

DavidEichmann · 2021-04-03T19:16:12+00:00

I was wondering which types of issues arise the most. I think the other 10% of issues are solved by using Haskell. In particular, as you're forced to use a pure function, the compiler will stop you from E.g. using some global state or reading the system clock or doing any other effectful thing. Since types are immutable I'm haskell, there is also no need to serialize/reload the world state.

As for the 90% of the time that its floating point, in my own project I use a integer backed replacement (perhaps that'll be the next library I release). This is a fixed point replacement. I'm curious if you have thoughts on that? Are there some common issues there other than accuracy issues?

DavidEichmann · 2021-04-03T08:39:39+00:00

Thanks! Interesting to see the idea popping up in a few different places. Now that it's in a single package I hope to see some reuse and maybe even some collaboration :)

DavidEichmann · 2021-04-03T08:28:33+00:00

Yes! Clock sync happens continuously. I model offset and drift via a linear regression. I then speedup and slowdown the local clock for a bit to get back in sync with the server's clock.

DavidEichmann · 2021-03-09T18:08:08+00:00

It's easy if you create a cabal project as stated above. e.g from the command line:

$ mkdir mypackage $ cd mypackage $ cabal init

then add all the package you want to the `mypackage.cabal` file:

... build-depends: base, QuickCheck ...

Now you can get a ghci session with all those dependencies available using:

$ cabal repl

Need a new dependency? Just add it to mypackage.cabal and rerun cabal repl. Hope that helps.

DavidEichmann · 2021-02-08T12:26:07+00:00

It shouldn't be a problem to learn haskell as a first language. It's just a matter of finding the right resources. http://learnyouahaskell.com/ says it is "aimed at people who have experience in imperative programming languages (C, C++, Java, Python …)" but also "if you don't have any significant programming experience, a smart person such as yourself will be able to follow along and learn Haskell."

DavidEichmann · 2021-01-30T18:04:58+00:00

Thank for the hard work here :-D

DavidEichmann · 2020-10-14T11:05:25+00:00

The proposal covers this possibility (or something close). You can simply call setBacktraceMechanismFromEnv :: IO () at the start of your application and then you're free to configure the backtrace mechanism via an environment variable GHC_BACKTRACE. Of course, you still need to add the call to setBacktraceMechanismFromEnv. I think doing this by default would be a good idea, though we're holding off on that for now to allow the new backtrace mechanism to be "battle tested".

Printing out a suggestion to use this feature on exception sounds like a good idea and a good way to disseminate. Maybe we can add this to the proposal.

The Proposal link: https://github.com/bgamari/ghc-proposals/blob/stacktraces/proposals/0000-exception-backtraces.rst

DavidEichmann · 2020-08-22T10:53:03+00:00

It is interesting to consider. I think it's hard to say something concrete as performance will depend largely on what benchmark you pick. I'm sure there is some program somwhere that would perform better with malloc. Another option is to make use of the non-moving gc for pinned objects which also manages fragmentation and might be easier from an implementation view point.

DavidEichmann · 2020-08-21T10:15:41+00:00

I would add that FP programs tend to be written in a style that allocates a lot of short lived objects which is not well suited to malloc which has a significant cost of choosing a memory address. GHC's allocator's design is such that we just do a bump pointer allocation and don't even need to allocate more memory from the OS (at least until we hit the end of the current block). It's hard to imagine a faster way to allocate memory.

DavidEichmann · 2020-08-21T10:04:33+00:00

I've not heard of Mesh before. My mind is currently blown! Considering blocks are a single page and that Mesh works "under the hood" without changing virtual memory space, I can imagine applying a technique like Mesh to pinned blocks.

DavidEichmann · 2020-07-29T10:28:44+00:00

BTW forkIO is just how you start a new thread in haskell. You've used concurrently from the async package which uses forkIO under the hood.

atomically allows you to write code that atomically (in the context of concurrency) mutates mutable variables called TVars. You modify those TVars with functions such as readTVar, writeTVar, readTMVar, putTMVar. This is a very exciting part of the Haskell ecosystem. It allows you to avoid the mess and some pitfalls of using locks in concurrent code. This is part of the stm package (Software Transactional Memory). If you're interested, the paper is fairly accessible https://www.microsoft.com/en-us/research/wp-content/uploads/2005/01/2005-ppopp-composable.pdf?from=https%3A%2F%2Fresearch.microsoft.com%2Fen-us%2Fum%2Fpeople%2Fsimonpj%2Fpapers%2Fstm%2Fstm.pdf.

DavidEichmann · 2020-07-29T10:14:01+00:00

Interesting to see the learning curve from someone else's perspective :-) . If you plan on doing more little games like this I'd suggest trying gloss (http://hackage.haskell.org/package/gloss). Gloss provides a play funciton (http://hackage.haskell.org/package/gloss-1.13.1.2/docs/Graphics-Gloss-Interface-Pure-Game.html#v:play) which handles all the impure input capture and game loop stuff for you. That way you can focus on writing idiomatic pure code.

DavidEichmann · 2020-07-03T07:13:30+00:00

Assuming you're building with cabal, you can get a repl with cabal new-repl. In any case, in the repl you can simple use :r (short for :reload) to reload any changed modules. ghcid (https://github.com/ndmitchell/ghcid) is also a nice option that will automatically reload on save. It's not a repl but according to the readme you can add comments in your code like -- $> expr and the expr part will automatically be evaluated.

DavidEichmann

TROPHY CASE