[ANN] gzochi project development release 0.12

[Julian Graham]

Hello,

I'm pleased to announce the release of version 0.12 of the gzochi game
development framework.

gzochi (/zoʊ-tʃiː/) is a programming framework for developing online
games in GNU Guile, and a distributed middleware container that hosts
your games for thousands of connected players. gzochi takes care of
the hard parts of online game development - concurrency, data
persistence, and network communications - so you can focus on the
stuff that matters!

This is a large release that adds distributed task management to the
capabilities of the gzochi meta server, allowing it to track task
assignments, completions, and cancellations for a game running across
multiple application server nodes, and ensuring that tasks assigned to
failed nodes are re-assigned elsewhere to finish. With this release,
games can run on a single application server or across a cluster of
servers connected to a meta server without modification, making them
fault-tolerant and enabling them to scale horizontally and take
advantage of new hardware as it is added.

In addition, this release includes the following notable changes:

* Faster and more object-efficient implementations of the scalable
vector and hash table collection types in the Scheme API

* Support for large transactional changesets when running in distributed mode

* ...and more! As usual, see the NEWS files in the distribution for details

This is a development release, but there's extensive server and client
documentation, and the distribution includes three example games with
heavily-annotated source code. For more information, visit the web
site at http://www.nongnu.org/gzochi/


Regards,
Julian

[Arne Babenhauserheide]

gzochi (/zoʊ-tʃiː/) is a programming framework for developing online
games in GNU Guile, and a distributed middleware container that hosts
your games for thousands of connected players. gzochi takes care of
the hard parts of online game development - concurrency, data
persistence, and network communications - so you can focus on the
stuff that matters!

That sounds great and got me intrigued!

I looked into the documentation and didn’t find an example how such a
game would look, but the example in the docs was too minimal to
understand what I can do with gzochi. And I did not understand how users
would launch the game (essentially: What shell command to run to start
the game).

Do you have a somewhat larger example online, along with deployment info?

This is a development release, but there's extensive server and client
documentation, and the distribution includes three example games with
heavily-annotated source code. For more information, visit the web
site at http://www.nongnu.org/gzochi/

Can I find these examples without installing so that I can have a quick
look how the game code reads?

Best wishes,
Arne
--
Unpolitisch sein
heißt politisch sein
ohne es zu merken

[Julian Graham]

Hi Arne!

I looked into the documentation and didn’t find an example how such a
game would look, but the example in the docs was too minimal to
understand what I can do with gzochi. And I did not understand how users
would launch the game (essentially: What shell command to run to start
the game).
Do you have a somewhat larger example online, along with deployment info?

Yes! The source distribution ships with client- and server-side code
for two example games: AberMUD and MazeWar. The easiest way to get
started would be to build the server container, deploy one of the
server-side game implementations, then build and run its associated
client. For example:

$ cd gzochi-0.12/gzochi-server
$ ./configure && make

...then, to deploy and launch the AberMUD example server:

$ cd meta/deploy
$ ln -s ../../../examples/abermud/server abermud
$ cd ..
$ ./gzochid

Then, to build and run the AberMUD example client:

$ cd gzochi-0.12/examples/abermud/client
$ ./configure && make
...
$ cd src
$ ./abermud localhost 8001

Can I find these examples without installing so that I can have a quick
look how the game code reads?

Yes! The server-side implementations probably have the strongest
dependency on the framework. See:

- https://gitlab.com/joolean/gzochi/tree/master/examples/abermud/server
- E.g., https://gitlab.com/joolean/gzochi/blob/master/examples/abermud/server/gzochi/example/abermud.scm
- https://gitlab.com/joolean/gzochi/tree/master/examples/mazewar/server
- E.g., https://gitlab.com/joolean/gzochi/blob/master/examples/mazewar/server/gzochi/example/mazewar.scm


Regards,
Julian

[Zelphir Kaltstahl]

Sounds really good! I did not know about gzochi.

I am interested in the networking part. Do you have some document
somewhere describing how gzochi handles distributed servers and what the
approach is to keep stuff synchronized over multiple servers? Or how it
deals with disconnects from servers? As I have not done much network
programming, these things seem complex and I don't know much about them
yet. It would be great to have a learning resource that describes these
things and how they are implemented using Guile.

----------------------------------------------------------------------
Message: 1
Date: Mon, 2 Jul 2018 15:13:47 -0400
Subject: [ANN] gzochi project development release 0.12
Content-Type: text/plain; charset="UTF-8"
Hello,
I'm pleased to announce the release of version 0.12 of the gzochi game
development framework.
gzochi (/zo?-t?i?/) is a programming framework for developing online
games in GNU Guile, and a distributed middleware container that hosts
your games for thousands of connected players. gzochi takes care of
the hard parts of online game development - concurrency, data
persistence, and network communications - so you can focus on the
stuff that matters!
This is a large release that adds distributed task management to the
capabilities of the gzochi meta server, allowing it to track task
assignments, completions, and cancellations for a game running across
multiple application server nodes, and ensuring that tasks assigned to
failed nodes are re-assigned elsewhere to finish. With this release,
games can run on a single application server or across a cluster of
servers connected to a meta server without modification, making them
fault-tolerant and enabling them to scale horizontally and take
advantage of new hardware as it is added.
* Faster and more object-efficient implementations of the scalable
vector and hash table collection types in the Scheme API
* Support for large transactional changesets when running in distributed mode
* ...and more! As usual, see the NEWS files in the distribution for details
This is a development release, but there's extensive server and client
documentation, and the distribution includes three example games with
heavily-annotated source code. For more information, visit the web
site at http://www.nongnu.org/gzochi/
Regards,
Julian

[Julian Graham]

Hi Zelphir!

I'm afraid I'm going to disappoint you: Most of gzochi is written in
C, including the networking and message-delivery code. The C code
links with libguile to host Guile applications and inject them with
services like messaging and data storage. So there isn't much Guile
networking code to study.

You're right that keeping state synchronized across multiple servers
is difficult. It's handled in different ways in different parts of the
system, but at a high level, the architecture works like this: There
are application container servers, which clients log into and which
actually run Guile application code; and, when running in distributed
mode, there is a meta server, which the application container servers
log into and which takes care of maintaining shared state like lock
tables, task assignments, message routing, etc.


On Tue, Jul 3, 2018 at 6:36 PM Zelphir Kaltstahl

Post by Zelphir Kaltstahl
Sounds really good! I did not know about gzochi.
I am interested in the networking part. Do you have some document
somewhere describing how gzochi handles distributed servers and what the
approach is to keep stuff synchronized over multiple servers? Or how it
deals with disconnects from servers? As I have not done much network
programming, these things seem complex and I don't know much about them
yet. It would be great to have a learning resource that describes these
things and how they are implemented using Guile.