The Second Go Battle Royale ⚔

Hey everyone:

The game has started, play will be in this order:
Red: @antonTobi
Yellow: @NeilAgg
Blue: @martin3141
Green: @yebellz
Pink: @mafidufa
Cerulean: @ArsenLapin1
Orange: @sokoslav

The first battle royale is wrapping up, so I wanted to try a different variant which should hopefully be faster to play.

Rules:

  1. The board will be 15x15.
  2. We can have up to 7 players.
  3. Only players may post on this thread.
  4. People may start a kibitz thread if they like, but then none of the players are allowed to read or participate on that thread.
  5. All game communication must be public in this thread.
  6. Once it is a player’s turn, they need to make a move in 48 hours unless they previously notify the players that they will need more time due to life happening (travel, work overload, etc). If they do not, they will be eliminated or replaced. This has been a bit of a problem in the other game so I am planning to enforce it more strongly.
  7. I am pretty sure there is going to be a flurry of negotiation before the first move as players deal with their starting positions. We will allow extra time before the first move to give people a chance to establish themselves.
  8. Players will randomly be assigned a color and play order.
  9. At the start of the game, each player will have 3 stones randomly placed on the board. No stone will be on the first line and no two stones will be adjacent.
  10. Any capture eliminates the player who was captured. That player’s stones remain on the board. Multiple simultaneous captures and suicide are allowed.
  11. Last player standing wins.
  12. Passing is not allowed.
  13. There is no ko rule.

As a courtesy to the other players, when you make a move, please put these items in your post:

  1. The move you are making
  2. A screenshot of the board after your move
  3. A link (preferably from the image of the screen shot) to the board in play
  4. A reminder to the next player letting them know it is their move.

A few notes on the style of play:

  1. I encourage people to role play as a maniacal king hell-bent on conquering territory.
  2. This is a game, it is not real life. People can (and probably will) make empty promises and do things against others. That is acceptable in the game and not to be taken as anything more than just game play.
  3. Collusion is allowed, which may end up being unfair to one or more players. If you are on the receiving end of that, don’t take it personally.
  4. This is supposed to be fun. Let’s keep it that way.

People who are interested, please post on this thread. We will start play once we have 7 players. Out of respect to other players, please only sign up for the game if you have the time to play.

4 Likes

I am interested and would like to sign up for the game!

Edit:

  • Could you please highlight the differences in rules with the first game? I think it’s just the strict 48h rule and the initial 3 random stones, but I’m not sure.

  • In case I know that I am going to be away for 2 days, could I nominate someone (not one of the players) to play on my behalf in my absence?

  • Is “A reminder to the next player letting them know it is their move.” really just “a courtesy”? Since the 48h rule leads to direct elimination, I would consider making it mandatory to ping the next player.

  • How are the positions of the random stones going to be determined? In particular, is it uniformly at random among all intersections of the board, or some other distribution? I think a stone on the first line would be a huge handicap. Note that about 1/4 of the intersections of a 15x15 board are on the first line. Also, grouped stones would be a huge advantage compared to scattered lonely stones. Also, stones in direct contact with an enemy stone would probably be a handicap. All that might be ok, especially since you already mentioned that the game will inevitably feel unfair at one point or another - still it might be worth stating the random method explicitly before using it.

(If necessary, I can volunteer to write a python program to generate the random stones.)

3 Likes

My suggestion for randomization would be to pick a board uniformly at random from all configurations such that no two stones are adjacent and no stone is on the first line. This ensures all stones have 4 liberties, which makes it a little less likely for the position to be hugely unfavorable to some players.

I will probably join, but will wait a little longer before committing :slight_smile:

3 Likes

Do you confirm that if I do this:

  • Initialise a list intersections with all 169 intersections that are not on the first line;
  • Initialise a list colours with 3 x 7 colours [green, green, green, red, red, red, purple, purple, purple, etc]
  • Loop until colours is empty: choose a remaining colour c uniformly at random from colours; remove it from colours; choose a remaining intersection (x,y) uniformly at random from intersections; remove that intersection plus the up-to-4-adjacent-intersections from intersections; output (c, (x,y)).

Then I will have choosen a configuration uniformly at random from all configurations such that no two stones are adjacent and no stone is on the first line.

1 Like

That is a good suggestion. I think I will write a program to do that.

I think if we take off the first line all around, we will end up with a 14x14 space. That should have 196 intersections. Maybe you made a typo in your post. :grinning:

The rest seems good to me.

The 15th line is also the first line. So it’s (15-2) lines.

Yes, I’ll post a program in five minutes.

I’m not 100% sure this yields an exactly uniform distribution, but it’s certainly good enough for our purposes since it’s clear that no color is favored :slight_smile:

2 Likes

I just noticed your edit.

My intent was to have the changes be:

  1. Random starting positions
  2. Strict time rules
  3. No posts from non-players
  4. No kibitzing

If you know you are going to be unavailable, you are welcome to nominate a replacement. The replacement can be temporary or permanent.

A notification to the next player is not required because I expect all players will keep track of the game. Other players may also post reminder messages for them if they are getting close to timeout.

I was thinking the starting positions will be uniformly random. I am OK with some players starting in better positions than others - that will lead to negotiations between the players. A player in a weak position will have to forge alliances quickly or perish. I like the suggestion to not have stones on the first line and non-adjacent. Let’s keep that.

If you would like to write a program, I appreciate that and welcome your input. How about this: You will create a board with 7 colors having 3 uniformly random stones placed and then I will use random numbers to assign players to the colors. That way, nobody can say one person set up the game to their own favor.

1 Like

The following program produced this example output:
https://vsotvep.github.io/MulticolorGo.html?bs=15&st=kbgjnggcgbjficfnlflnhfehbbhnjddgdggdcmiefimcikkcjdcencgjeddebhe

The program first generates a dictionary that maps each colour (a number between 0 and 6 included) to a list of three intersections (a pair (x,y) of numbers between 0 and 12 included).

Then in function prettify, this dictionary is used to generate a url for vsotvep’s multicolour go. The colours are taken in the list cdefghi and intersections are pairs of letters from bcdefghijklmn.

from itertools import product
from random import choice, shuffle

def random_config_as_dict():
    intersections = set(product(range(13), repeat=2))
    colours = list(range(7))*3
    result = {}
    shuffle(colours)
    for c in colours:
        x, y = choice(tuple(intersections))
        for xy in ((x, y), (x+1, y), (x-1, y), (x, y+1), (x, y-1)):
            intersections.discard(xy)
        result.setdefault(c, []).append((x,y))
    return result

def prettify(d):
    baseurl = 'https://vsotvep.github.io/MulticolorGo.html?bs=15&st='
    colours = 'cdefghi'
    alphabet = 'bcdefghijklmn'
    return baseurl + ''.join(alphabet[x]+alphabet[y]+colours[c] for c,l in d.items() for x,y in l)

def main():
    d = random_config_as_dict()
    url = prettify(d)
    print(url)

if __name__=='__main__':
    main()
2 Likes

Yes, I see that now. It should be 13x13 = 169 intersections. Thank you for keeping me honest!

If more reproducibility / trustworthiness of the randomness is needed, I can add a random.seed(...) at the beginning of the program. This way the output configuration will be a deterministic consequence of the seed. This way proves that you didn’t cheat even if you knew the player’s colours in advance, since everyone can reproduce the result by running the program with the same seed.

Wow, that was fast! It looks like it does the job. Looking at the sample board, light blue seems to be in trouble!

I don’t think anyone would accuse you of rigging the board generation, especially if you are not assigning the players to colors. No need to go to such elaborate measures. If you say it is random, I will accept your word that it is.

I don’t know if it’s uniform over the list of all possible configurations. But I’ve convinced myself that the selected intersections were not uniform. The algorithm favours intersections on the second line a bit, and favours the 2-2 points greatly. Because the more adjacent intersections an intersection originally has, the least chance it has to be selected (because it’s going to be forbidden if an adjacent intersection is selected first).

2 Likes

If you are concerned the generation is biased, change your program to do the following:

  1. Randomly pick the 21 starting points without any constraint.
  2. Check if any of the positions violate the contraints, if they do, discard the entire board and try again.
1 Like

The probability that the constraints are violated is way too high, I think. This is like the birthday paradox, except we only have 169 intersections instead of 365 days, and we’re afraid of stones being adjacent, not just on the same intersection. I haven’t calculated the exact probability of a violation but with 21 stones it has to be pretty close to 1.

1 Like

Count me in

2 Likes

If we take each stone as occupying 5 points (The position itself and the 4 adjacent ones), we have to use up 105 intersections, leaving 64 intersections free. That comes to 62% coverage.

It might take many iterations of the program, but I can’t imagine each loop would take a long time to run. It seems to me (admittedly, without trying it) that it should be able to generate a board in a reasonable amount of time.

Indeed… but I believe we would also see the 2-2 point more commonly along randomly selected positions with the specified properties (for similar reasons).

I also think it should be possible to to do with repeated trials (it will take many trials, but my gut feeling is that it will not take long for a computer anyways :slightly_smiling_face:).

But there’s no real reason to prefer “exactly uniform” over your algorithm (assuming for the moment that they are indeed different, which they might not be). So I think your algorithm will work great for our purposes.

1 Like