Qwixx KoTH
In this King of the Hill, our bots will be playing Qwixx. In Qwixx each player will try to get as many points by picking the sum of two dices and marking that number on your own scoresheet. The scoresheet has four rows with different colors (red, yellow, green, blue) with numbers ranging from 2 to 12, where green and blue have the numbers ranked in descending order. You can only mark out a number if you haven't marked a number to the right of it, i.e. after marking red 3 you cannot mark red 2 anymore.
Rules
All of the rules of Qwixx are:
- Red and yellow have numbers 2, 3, ..., 12, and a padlock.
- Green and blue have numbers 12, 11, ..., 2, and a padlock.
- There are 6 dices: red, yellow, green, blue and two white dices.
- On your turn you will throw all the dices, except for deleted ones.
- Everyone can mark one number on one color equal to the sum of the white dices. Also if it is not your turn.
- If it is your turn, you can also mark one number in a specific color, with the sum of one colored dice and one white dice. The colored dice that you pick denotes in which color you need to mark the number.
- You can only mark numbers to the right of already marked numbers.
- The last number can only be marked if you have already marked at least 5 numbers before. If you do this, you will automatically also mark the padlock, which will give you extra points. If you do this, that colored dice is not thrown anymore and nobody can mark a number in that color. This dice is deleted from the game (thrown as 0).
- Only on your turn you need to mark at least one number. If you don't do this, you will automatically mark a penalty box, which costs you 5 points.
- The amount of points is equal to the sum of 1 up to the amount of marks in each color, minus 5 times the amount of penalties. I.e.: 4 in red, 3 in green and 2 penalties is
4+3+2+1 + 3+2+1 = 16 - 2 * 5 = 6 points.
- Each turn is simultanouesly.
- The game ends when the second dice is deleted or when a scoresheet contains 4 penalties.
Tournament
The tournament rules are as follows:
- The tournament consists of
10000 * amount of bots games.
- Each game will be played with 5 random bots, in a randomized order.
- If multiple bots end up with the same amount of points in one game, each bot gets a win.
- The winner of the tournament is the bot who has the highest win percentage.
Bots
The bot needs to be defined in Python and needs to have two functions:
__init__(self, index) with the index in scoresheets, so that you know which scoresheet is yoursturn(self, scoresheets, dices, my_turn), with the current scoresheets, the dices of this turn and a boolean being True when it is your turn. This function needs to return a tuple of two tuples containing (color, number) with what your bot wants to mark, where the first tuple is for the white dices, and the second tuple only if its your turn.
The simplest bot can be defined as:
class DoNothing:
def __init__(self, index):
return
def turn(self, scoresheets, dices, my_turn):
return ([],[])
Which does absolutely nothing.
A randomized bot that tries to always mark something when possible is:
class RandomAllowedCombinations:
def __init__(self, index):
self.index = index
return
def turn(self, scoresheets, dices, my_turn):
(any_combs, turn_combs) = scoresheets[self.index].allowed_combinations(my_turn, dices)
any_comb = []
if any_combs:
any_comb = any_combs[random.randint(0, len(any_combs)-1)]
turn_comb = []
if my_turn and turn_combs:
turn_comb = turn_combs[random.randint(0, len(turn_combs)-1)]
return (any_comb, turn_comb)
This also shows some of the utility functions: you can use scoresheets[self.index].allowed_combinations(my_turn, dices) to check what you can mark with the white dices, and if its your turn with one of the colored dices as well.
Both classes (Dices and Scoresheet) have several utility functions. You can check themselves to improve your bot. Note that Dices also contains the indices for each color. And the value of a dice is 0 if it is deleted (i.e. when someone in the game marked the last number and thus the padlock in one of the previous turns).
Controller
The controller contains 5 example bots. These will not be used in the tournament, unless there are too few participants.
import random
import numpy
### Bots ###
class DoNothing:
def __init__(self, index):
return
def turn(self, scoresheets, d, my_turn):
return ([],[])
class AlwaysWhitesInRed:
def __init__(self, index):
return
def turn(self, scoresheets, d, my_turn):
return ((d.red, d.dices[d.white1] + d.dices[d.white2]),[])
class AlwaysBlueOnlyTurn:
def __init__(self, index):
return
def turn(self, scoresheets, d, my_turn):
return ([],(d.blue, d.dices[d.blue] + d.dices[d.white2]))
class RandomAllowedCombinations:
def __init__(self, index):
self.index = index
return
def turn(self, scoresheets, dices, my_turn):
(any_combs, turn_combs) = scoresheets[self.index].allowed_combinations(my_turn, dices)
any_comb = []
if any_combs:
any_comb = any_combs[random.randint(0, len(any_combs)-1)]
turn_comb = []
if my_turn and turn_combs:
turn_comb = turn_combs[random.randint(0, len(turn_combs)-1)]
return (any_comb, turn_comb)
class RandomButOnlyOwnTurn:
def __init__(self, index):
self.index = index
return
def turn(self, scoresheets, dices, my_turn):
(any_combs, turn_combs) = scoresheets[self.index].allowed_combinations(my_turn, dices)
turn_comb = []
if my_turn and turn_combs:
turn_comb = turn_combs[random.randint(0, len(turn_combs)-1)]
return ([], turn_comb)
### Classes ###
class Dices:
def __init__(self):
self.dices = []
self.deleted = []
self.red = 0
self.yellow = 1
self.green = 2
self.blue = 3
self.white1 = 4
self.white2 = 5
self.colors = [self.red, self.yellow, self.green, self.blue]
self.whites = [self.white1, self.white2]
self.diff_dices = self.colors + self.whites
def roll_dice(self):
self.dices = [0,0,0,0,0,0]
for i in range(6):
if i not in self.deleted:
self.dices[i] = random.randint(1, 6)
def delete_dice(self, color):
if not color in self.deleted:
self.deleted.append(color)
return len(self.deleted) > 1
def combinations(self):
combs = [(color, white) for color in self.colors for white in self.whites]
any_combs = [(color, self.dices[self.white1] + self.dices[self.white2]) for color in self.colors if self.dices[color] >= 1]
turn_combs = [(color, self.dices[color] + self.dices[white]) for (color, white) in combs if self.dices[color] >= 1]
return (any_combs, turn_combs)
class Game:
def __init__(self, bots):
self.bots = [bots[i](i) for i in range(len(bots))]
self.scoresheets = [Scoresheet() for i in self.bots]
self.dices = Dices()
self.turn_number = 2
def round(self):
self.dices.roll_dice()
(any_combs, turn_combs) = self.dices.combinations()
finished = False
for i, bot in enumerate(self.bots):
my_turn = self.whos_turn() == i
moves = bot.turn(self.scoresheets, self.dices, my_turn)
deleted_colors = self.scoresheets[i].mark(moves, my_turn, any_combs, turn_combs, self.dices)
if deleted_colors:
finished = finished or any([self.dices.delete_dice(deleted_color) for deleted_color in deleted_colors])
finished = finished or self.scoresheets[i].too_many_penalties()
self.turn_number += 1
return finished
def whos_turn(self):
return (self.turn_number - 1) % len(self.bots)
def runGame(self):
finished = False
while not finished:
finished = self.round()
#for i, scoresheet in enumerate(self.scoresheets):
#print self.bots[i], scoresheet.values, scoresheet.penalties, scoresheet.points()
class Scoresheet:
def __init__(self):
self.red = []
self.yellow = []
self.green = []
self.blue = []
self.penalties = 0
self.values = [self.red, self.yellow, self.green, self.blue]
def points(self):
points = self.penalties * -5
for color in self.values:
points += sum(range(len(color)+1))
return points
def allowed_combinations(self, my_turn, dices):
(any_combs, turn_combs) = dices.combinations()
any_combs = [(color, number) for (color, number) in any_combs if self.allowed(color, number, any_combs, dices)]
turn_combs = [(color, number) for (color, number) in turn_combs if self.allowed(color, number, turn_combs, dices)]
if not my_turn:
turn_combs = []
return (list(set(any_combs)), list(set(turn_combs)))
def allowed(self, color, number, combs, d):
if color not in d.deleted:
if (color, number) in combs:
if color == d.red or color == d.yellow:
if not self.values[color] or max(self.values[color]) < number:
if number < 12 or self.end_number(color, number, d):
return True
if color == d.green or color == d.blue:
if not self.values[color] or min(self.values[color]) > number:
if number > 2 or self.end_number(color, number, d):
return True
return False
def end_number(self, color, number, d):
if len(self.values[color]) > 5:
return (number == 2 and (color == d.green or color == d.blue)) or (number == 12 and (color == d.red or color == d.yellow))
return False
def mark_one(self, color, number, combs, deleted, d):
if self.allowed(color, number, combs, d):
self.values[color].append(number)
if self.end_number(color, number, d):
self.values[color].append(0)
deleted.append(color)
return deleted
def mark(self, moves, my_turn, any_combs, turn_combs, d):
beforePoints = self.points()
deleted = []
if moves[0]:
deleted = self.mark_one(moves[0][0], moves[0][1], any_combs, deleted, d)
if my_turn and moves[1]:
deleted = self.mark_one(moves[1][0], moves[1][1], turn_combs, deleted, d)
if my_turn and beforePoints == self.points():
self.penalties += 1
return deleted
def too_many_penalties(self):
return self.penalties >= 4
class Qwixx:
def __init__(self, bots, bots_per_game):
self.bots = bots
self.games = [0 for i in range(len(self.bots))]
self.points = [0 for i in range(len(self.bots))]
self.wins = [0 for i in range(len(self.bots))]
self.amountOfGames = len(bots) * 1000
self.bots_per_game = bots_per_game
def run_tournament(self):
for g in range(1, self.amountOfGames + 1):
bot_indices = numpy.random.choice(range(len(self.bots)), self.bots_per_game, replace=False)
bots_this_game = [self.bots[i] for i in bot_indices]
game = Game(bots_this_game)
game.runGame()
maxPoints = max([game.scoresheets[i].points() for i in range(len(bot_indices))])
for bot_index_game, bot_index_total in enumerate(bot_indices):
points = game.scoresheets[bot_index_game].points()
self.points[bot_index_total] += points
self.games[bot_index_total] += 1
if points == maxPoints:
self.wins[bot_index_total] += 1
print "GAME", g, "is", self.wins[bot_index_total], "th win by", self.bots[bot_index_total].__name__
def tournament(self):
self.run_tournament()
win_rates = {i: self.wins[i] / float(self.games[i]) for i in range(len(self.bots))}
format_result = '{:>30}: {:.4f} {:>6} {:>8} {:>8}'
format_header = '{:>30}: {:>6} {:>6} {:>8} {:>8}'
print(format_header.format('Name', 'Win %', 'Wins', 'Games', 'Points'))
for j, i in enumerate(sorted(win_rates, key=lambda i: win_rates[i], reverse=True)):
print(format_result.format(self.bots[i].__name__, win_rates[i], self.wins[i], self.games[i], self.points[i]))
### List of all bots ###
all_bots = [DoNothing, BadRandom, RandomAllowedCombinations, Random50, RandomButOnlyOwnTurn]
### Run tournament ###
Qwixx(all_bots, 5).tournament()
king-of-the-hill python
Sandbox
- If someone can check my Python programming capabilities that would be great. I'm no native Python programmer.
- There are quite some rules. Maybe I should simplify it? These are the official rules, but for example I could change that even on your turn you can only move once instead of twice.
- This is my first challenge, so any feedback is welcome.
- Note that I have not yet tested my controller thoroughly, I will do this before posting it as an actual challenge.
[tag:code-golf]\$\endgroup\$ – James Aug 29 '19 at 15:19