def __init__(self, server, table_name):
super(SquareOust, self).__init__(server, table_name)
self.game_display_name = "Square Oust"
self.game_name = "square_oust"
self.seats = [
Seat("Black"),
Seat("White"),
]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RSquare Oust^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Square Oust-specific stuff.
self.height = 11
self.width = 11
self.turn = None
self.black = self.seats[0]
self.black.data.seat_str = "^KBlack^~"
self.black.data.groups = []
self.black.data.made_move = False
self.white = self.seats[1]
self.white.data.seat_str = "^WWhite^~"
self.white.data.groups = []
self.white.data.made_move = False
self.resigner = None
self.layout = None
self.move_was_capture = False
# Initialize the starting layout.
self.init_layout()
def __init__(self, server, table_name):
super(Metamorphosis, self).__init__(server, table_name)
self.game_display_name = "Metamorphosis"
self.game_name = "metamorphosis"
self.seats = [Seat("Black"), Seat("White")]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RMetamorphosis^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Metamorphosis-specific stuff.
self.board = None
self.printable_board = None
self.size = 12
self.ko_fight = True
self.group_count = None
self.turn = None
self.turn_number = 0
self.seats[0].data.side = BLACK
self.seats[0].data.last_was_ko = False
self.seats[1].data.side = WHITE
self.seats[1].data.last_was_ko = False
self.last_r = None
self.last_c = None
self.resigner = None
self.adjacency_map = None
self.found_winner = False
self.init_board()
def __init__(self, server, table_name):
super(Hokm, self).__init__(server, table_name)
self.game_display_name = "Hokm"
self.game_name = "hokm"
self.state = State("need_players")
self.prefix = "(^RHokm^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Hokm-specific stuff.
self.goal = 7
self.trick = None
self.trump_suit = None
self.led_suit = None
self.turn = None
self.dealer = None
self.hakem = None
self.winner = None
# Default to four-player mode.
self.mode = 4
self.short = True
self.setup_mode()
def __init__(self, server, table_name):
super(Ataxx, self).__init__(server, table_name)
self.game_display_name = "Ataxx"
self.game_name = "ataxx"
self.seats = [
Seat("Red"),
Seat("Blue"),
]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RAtaxx^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Ataxx-specific stuff.
self.board = None
self.printable_board = None
self.sides = {}
self.size = 7
self.player_mode = 2
self.turn = None
self.last_r = None
self.last_c = None
self.init_seats()
self.init_board()
def __init__(self, server, table_name):
super(Breakthrough, self).__init__(server, table_name)
self.game_display_name = "Breakthrough"
self.game_name = "breakthrough"
self.seats = [Seat("Black"), Seat("White")]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RBreakthrough^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Breakthrough-specific stuff.
self.width = 8
self.height = 8
self.turn = None
self.black = self.seats[0]
self.white = self.seats[1]
self.resigner = None
self.layout = None
# We cheat and create a black and white piece here. Breakthrough
# doesn't differentiate between pieces, so this allows us to do
# comparisons later.
self.bp = Piece("^K", "b", "B")
self.bp.data.owner = self.black
self.wp = Piece("^W", "w", "W")
self.wp.data.owner = self.white
self.init_board()
def __init__(self, server, table_name):
super(Gonnect, self).__init__(server, table_name)
self.game_display_name = "Gonnect"
self.game_name = "gonnect"
self.seats = [
Seat("Black"),
Seat("White")
]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RGonnect^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name, self.game_display_name)
# Gonnect-specific stuff.
self.turn = None
self.seats[0].data.side = BLACK
self.seats[0].data.dir_str = "/Vertical"
self.seats[1].data.side = WHITE
self.seats[1].data.dir_str = "/Horizontal"
self.directional = False
self.resigner = None
self.turn_number = 0
self.goban = giles.games.goban.Goban()
self.adjacency_map = None
self.found_winner = False
# A traditional Gonnect board is 13x13.
self.goban.resize(13, 13)
def __init__(self, server, table_name):
super(Crossway, self).__init__(server, table_name)
self.game_display_name = "Crossway"
self.game_name = "crossway"
self.seats = [Seat("Black"), Seat("White")]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RCrossway^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Crossway-specific stuff.
self.board = None
self.printable_board = None
self.size = 19
self.turn = None
self.turn_number = 0
self.seats[0].data.side = BLACK
self.seats[1].data.side = WHITE
self.last_r = None
self.last_c = None
self.resigner = None
self.adjacency_map = None
self.found_winner = False
self.init_board()
def __init__(self, server, table_name):
super(Tanbo, self).__init__(server, table_name)
self.game_display_name = "Tanbo"
self.game_name = "tanbo"
self.seats = [
Seat("Black"),
Seat("White"),
]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RTanbo^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Tanbo-specific stuff.
self.size = 19
self.turn = None
self.black = self.seats[0]
self.black.data.seat_str = "^KBlack^~"
self.black.data.root_list = []
self.white = self.seats[1]
self.white.data.seat_str = "^WWhite^~"
self.white.data.root_list = []
self.resigner = None
self.layout = None
# Initialize the starting layout.
self.init_layout()
def __init__(self, server, table_name):
super(Expeditions, self).__init__(server, table_name)
self.game_display_name = "Expeditions"
self.game_name = "expeditions"
self.seats = [
Seat("Left"),
Seat("Right")
]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RExpeditions^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name, self.game_display_name)
# Expeditions-specific stuff.
self.suit_count = 5
self.agreement_count = 3
self.penalty = 20
self.bonus = True
self.bonus_length = 8
self.bonus_points = 20
self.hand_size = 8
self.goal = 1
self.turn = None
self.draw_pile = None
self.discards = []
self.left = self.seats[0]
self.right = self.seats[1]
self.left.data.side = LEFT
self.left.data.curr_score = 0
self.left.data.overall_score = 0
self.left.data.hand = None
self.left.data.expeditions = []
self.right.data.side = RIGHT
self.right.data.curr_score = 0
self.right.data.overall_score = 0
self.right.data.hand = None
self.right.data.expeditions = []
self.resigner = None
self.first_player = None
self.just_discarded_to = None
self.printable_layout = None
self.init_hand()
def __init__(self, server, table_name):
super(Redstone, self).__init__(server, table_name)
self.game_display_name = "Redstone"
self.game_name = "redstone"
self.seats = [
Seat("Black"),
Seat("White"),
]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RRedstone^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Redstone-specific stuff.
self.height = 19
self.width = 19
self.turn = None
self.black = self.seats[0]
self.black.data.seat_str = "^KBlack^~"
self.black.data.made_move = False
self.white = self.seats[1]
self.white.data.seat_str = "^WWhite^~"
self.white.data.made_move = False
self.resigner = None
self.layout = None
# Like most abstracts, Redstone doesn't need to differentiate between
# the pieces on the board.
self.bp = Piece("^K", "x", "X")
self.bp.data.owner = self.black
self.black.data.piece = self.bp
self.wp = Piece("^W", "o", "O")
self.wp.data.owner = self.white
self.white.data.piece = self.wp
self.rp = Piece("^R", "r", "R")
self.rp.data.owner = None
# Initialize the starting layout.
self.init_layout()
def handle(self, player):
state = player.state
substate = state.get_sub()
if substate == None:
# Just logged in. Print the helpful banner.
player.tell_cc(
"\n\n\n Welcome to ^G%s^~!\n\n" %
self.server.name)
player.tell_cc("Source URL: ^Y%s^~\n\n" % self.server.source_url)
state.set_sub("entry_prompt")
elif substate == "entry_prompt":
# Ask them for their name and set our state to waiting for an entry.
player.tell("\n\nPlease enter your name: ")
state.set_sub("name_entry")
elif substate == "name_entry":
name = player.client.get_command()
if name:
# Attempt to set their name to the one they requested.
is_valid = player.set_name(name)
if is_valid:
# Welcome them and move them to chat.
player.tell("\nWelcome, %s!\n" % player)
player.state = State("chat")
self.server.log.log("%s logged in from %s." %
(player, player.client.addrport()))
else:
state.set_sub("entry_prompt")
def __init__(self, server, table_name):
super(RockPaperScissors, self).__init__(server, table_name)
self.game_display_name = "Rock-Paper-Scissors"
self.game_name = "rps"
self.seats = [
Seat("Left"),
Seat("Right"),
]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.plays = [None, None]
self.prefix = "(^RRPS^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# RPS requires both seats, so may as well mark them active.
self.seats[0].active = True
self.seats[1].active = True
def __init__(self, server, table_name):
super(Y, self).__init__(server, table_name)
self.game_display_name = "Y"
self.game_name = "y"
self.seats = [
Seat("White"),
Seat("Black"),
]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RY^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name, self.game_display_name)
# Y-specific guff.
self.seats[0].data.color = WHITE
self.seats[0].data.color_code = "^W"
self.seats[1].data.color = BLACK
self.seats[1].data.color_code = "^K"
self.board = None
self.printable_board = None
self.size = 19
self.empty_space_count = None
self.master = False
self.turn = None
self.turn_number = 0
self.move_list = []
self.last_moves = []
self.resigner = None
self.adjacency = None
self.found_winner = False
# Y requires both seats, so may as well mark them active.
self.seats[0].active = True
self.seats[1].active = True
self.init_board()
def __init__(self, server, table_name):
super(Whist, self).__init__(server, table_name)
self.game_display_name = "Whist"
self.game_name = "whist"
self.seats = [
Seat("North"),
Seat("East"),
Seat("South"),
Seat("West"),
]
self.min_players = 4
self.max_players = 4
self.state = State("need_players")
self.prefix = "(^RWhist^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Whist-specific guff.
self.ns = Struct()
self.ns.score = 0
self.ew = Struct()
self.ew.score = 0
self.seats[0].data.who = NORTH
self.seats[1].data.who = EAST
self.seats[2].data.who = SOUTH
self.seats[3].data.who = WEST
self.goal = 5
self.trick = None
self.trump_suit = None
self.led_suit = None
self.turn = None
self.dealer = None
self.winner = None
self.layout = FourPlayerCardGameLayout()
def __init__(self, server, table_name):
super(Set, self).__init__(server, table_name)
self.game_display_name = "Set"
self.game_name = "set"
self.seats = []
self.min_players = 1
self.max_players = 32767 # We don't even use this.
self.state = State("need_players")
self.prefix = "(^RSet^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Set-specific stuff.
self.max_cards_on_table = DEFAULT_MAX_CARDS
self.deal_delay = DEFAULT_DEAL_DELAY
self.layout = None
self.printable_layout = None
self.deck = None
self.last_play_time = None
self.max_card_count = 81
self.has_borders = True
def __init__(self, server, table_name):
super(Talpa, self).__init__(server, table_name)
self.game_display_name = "Talpa"
self.game_name = "talpa"
self.seats = [
Seat("Red"),
Seat("Blue"),
]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RTalpa^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Talpa-specific stuff.
self.size = 8
self.turn = None
self.red = self.seats[0]
self.red.data.seat_str = "^RRed/Vertical^~"
self.blue = self.seats[1]
self.blue.data.seat_str = "^BBlue/Horizontal^~"
self.resigner = None
self.layout = None
# Like in most connection games, there is no difference between pieces
# of a given color, so we save time and create our singleton pieces
# here.
self.rp = Piece("^R", "x", "X")
self.rp.data.owner = self.red
self.bp = Piece("^B", "o", "O")
self.bp.data.owner = self.blue
# Initialize the starting layout.
self.init_layout()
def __init__(self, server, table_name):
super(CaptureGo, self).__init__(server, table_name)
self.game_display_name = "Capture Go"
self.game_name = "capturego"
self.seats = [Seat("Black"), Seat("White")]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RCapture Go^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name,
self.game_display_name)
# Capture Go-specific stuff.
self.turn = None
self.seats[0].data.side = BLACK
self.seats[1].data.side = WHITE
self.seats[0].data.capture_list = []
self.seats[1].data.capture_list = []
self.capture_goal = 1
self.resigner = None
self.turn_number = 0
self.goban = giles.games.goban.Goban()
def __init__(self, server, table_name):
self.server = server
self.channel = server.channel_manager.has_channel(table_name)
if not self.channel:
self.channel = self.server.channel_manager.add_channel(table_name,
gameable=True, persistent=True)
else:
self.channel.persistent = True
self.game_display_name = "Generic Game"
self.game_name = "game"
self.table_display_name = table_name
self.table_name = table_name.lower()
self.active = False
self.private = False
self.state = State("config")
self.prefix = "(^RGame^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name, self.game_display_name)
# Override this next variable in your subclasses if you're not
# done debugging them.
self.debug = False
def quit(self, player):
player.client.deactivate()
player.state = State("logout")
self.server.log.log("%s logged out." % player)
