Collective development of a server for variants

Jon_Ko · June 24, 2022, 5:43pm

Users of this forum came up with some interesting Go variants which currently can’t be played on any server. Would anyone be interested in helping to change that?

We could enhance a server that already exists or build something new. I’d be open to both approaches.

[Edit] Our current repository: Go Variants on GitHub

Existing servers:

Variant Go Server (thread, source)
DipGo (love letter thread)
MPGO (thread, source)
Parallel Go (thread, source)
Fractional Go Server (source)
and probably more…

Variants lacking a server:

benjito · June 24, 2022, 6:22pm

Yeah I’d be interested

Seems like VGS is the obvious choice if looking to extend an existing project. But @seequ recently mentioned part of it is not in a buildable state so that poses an issue

Jon_Ko · June 24, 2022, 6:25pm

I’ve made a wiki out of my first post to gather some information about variants and servers. Feel free to extend or change it.

seequ · June 24, 2022, 6:49pm

One thing to note with VGS is that the server is actually very easy to interface with. There’s even some prior work with integrating katago (ask @sanderl). This means that even if no one wants to salvage the existing client, a determined developer could write a completely new one and make it support whatever subset of variants you want to see.

martin3141 · June 24, 2022, 7:27pm

Almost a year ago a friend of mine and I started a webassembly project for playing fractional multicolour go online. It lacks important features such as user management and a database and is far from finished. But it is open-source and the code can maybe be re-used, too.

for the interested

https://github.com/merowin/Fractional-Go-Server

We had also plans to integrate generalised pyramid scoring

Anyway I am interested in contributing to a community project for go variants

yebellz · June 24, 2022, 7:28pm

I would like to point out that the DipGo server uses sequential moves (for now). The variant that we proposed and played here on these forums had simultaneous moves.

Jon_Ko · June 25, 2022, 2:17pm

Great that there’s some interest.

One thing to think of is what possibilities to add variants should be provided.

I think some stuff could be changed via config files or something similar. For example an easy method to define the move sequence would help with a lot of variants.

Standard: 1,2,1,2,…
Pair go: 1,2,3,4,1,2,3,4,…
Thue-Morse: 1,2,2,1,2,1,1,2,…
Sequential multiplayer: 1,…,n,1,…,n,…
Parallel multiplayer: (1,…,n),(1,…,n),…
But that could also be: (1,3,5),(2,4,6),(1,3,5),(2,4,6),…

Now defining those sequences by generating them and providing them as input would be one way to go and would be sufficient in a lot of cases. Providing functions (to create the sequences) as input would be more flexible, but also more complicated to implement.

Now I think I’ve seen the concept of a move sequence in Variant Go Server and Fractional Go Server, but I didn’t check how those are implemented.

benjito · June 25, 2022, 3:47pm

AFAICT, they both support cycling through a list of players, like in your “Standard” and “Sequential Multiplayer”, but not the parallel or T-M ones.

github.com

JaniM/variant-go-server/blob/8f17e6fd5b82cec56c9ac3f61209f3e283ef7055/shared/src/states/play.rs#L494-L505


      
          fn next_turn(&mut self, shared: &mut SharedState, new_turn: bool) {
              if !new_turn {
                  loop {
                      shared.turn += 1;
                      if shared.turn >= shared.seats.len() {
                          shared.turn = 0;
                      }
                      if !shared.get_active_seat().resigned {
                          break;
                      }
                  }
              }

github.com

merowin/Fractional-Go-Server/blob/82410769eecf7ee5a195ac64e254e94ad9706b06/FractionalGoServer/Shared/Data/GameParameters.cs#L41-L57


      
          public void AdvanceMoveCycle()
          {
              int moveCycleLength = MoveCycle.Count;
              int moveNumber = Moves.Count;
              ActiveMoveIndex = (ActiveMoveIndex + 1) % moveCycleLength;
              int count = 1;
              while (ActivePlayerSlot.InactiveSinceMove <= moveNumber + 1 && count < moveCycleLength)
              {
                  ActiveMoveIndex = (ActiveMoveIndex + 1) % moveCycleLength;
                  count++;
              }
              if (count == moveCycleLength)
              {
                  GamePhase = GamePhase.Finished;
                  Console.WriteLine("No Players Left");
              }
          }

Jon_Ko · June 25, 2022, 4:06pm

I’ve just thought of something else to consider: Sometimes during the game the move sequence may change, like when a player gets eliminated in battle royale.

martin3141 · June 25, 2022, 4:07pm

Do we want to support non-rectangular board patterns?

In that case I would suggest a data structure along the lines of
“a board has a list of intersections”
“an intersection has a list of intersections (neighbours)”
… then we could for example use a bunch of code from the Fractional Go Server to generate boards of (what we called) “polygonal” pattern (don’t ask why) of different sizes.

An advantage is that you can create various kinds of patterns. A disadvantage is that from this structure alone, it is not clear how to display the board (we solved this by storing a bunch of data inside each intersection, like a coordinate vector etc.)

benjito · June 25, 2022, 4:11pm

Yes please! Those polygonal boards sound awesome!

Also 3-D/4-D variants would be cool (although maybe UI is too hard)

Jon_Ko · June 25, 2022, 5:55pm

I’d want that, yes.
And the question what we want is an important one in general. I think it would be good to at least consider stuff that someone wants, even if others are not interested, to build something that is flexible.

teapoweredrobot · June 25, 2022, 7:53pm

You mean like this one?
https://www.britgo.org/clubs/mk/mkboard.html

antonTobi · June 25, 2022, 9:01pm

benjito · June 25, 2022, 9:42pm

There are pretty mature graph drawing libraries out there…

Here’s a 9x9 board as drawn by GraphViz, not exactly a go board, but playable

I’m not saying we should visualize stuff this way, just that we have something to fall back on if the board state is represented as a graph.

On the other hand... Toroidal Go

Hexagonal Go looks pretty darn good

martin3141 · June 25, 2022, 9:57pm

Yeah I suspect that non-planar graphs will be tricky to visualise.

For planar graphs it’s not a big problem, I think. For example we can compute coordinates for intersections (different from the usual goban coordinates) for the purpose of positioning them nicely.

yebellz · June 25, 2022, 10:59pm

How about supporting multiple classes of stones (i.e., different types of stones with varying capabilities)? Or radically different winning objectives, like the capture of a special type of stone?

benjito · June 25, 2022, 11:23pm

I legit think implementing chess would be a good test of the extensibility of the project haha

benjito · June 25, 2022, 11:38pm

Okay I think the big question for me is how do we start?

Like are we doing “green field” or extending an existing project?
If green field, what tech stack? One theme I saw in the existing projects was that there needs to be a way to share code between client and server bc of all the rulesets and whatnot. That could be a good reason to do a node.js server, but compiling to webasm works too.
If existing, would it be a fork? I think it’d be nice for everyone who’s contributing to have push-to-main priviledges (at least at first)

Jon_Ko · June 26, 2022, 8:36am

I don’t know yet. Maybe we should take a look at Variant Go Server and sketch out how certain features could be implemented? And maybe how we’d implement them if we were doing it from scratch?