def __init__(self, networkname, server_config, bot_config, joinlist,
modules_config):
self.alive = True
self.connected = False
self.hostname = server_config['hostname']
self.port = int(server_config.get('port', "6667"))
self.nick = bot_config['nick']
self.altnick = bot_config.get('altnick', self.nick + "_")
self.username = bot_config['username']
self.realname = bot_config['realname']
self.owner = bot_config['owner']
self.networkname = networkname
self.joinlist = joinlist
self._reader_thread = None
self._parser = MessageParser()
self._init_callback_table()
self._socket = None
self._channel_list = []
self._modules_config = modules_config
self.dynamic_modules = [
DynamicModule(self, m, c) for m, c in modules_config.items()
]
self._last_ping = time.time()
def __init__(self, message):
self.message_parser = MessageParser(message)
# hole, [['2c', '2d'],...] for 6 players
self.hole = self.message_parser.hole
# board ['2c', '2d', '2h', ...] for at most 5 board cards
self.board = self.message_parser.board
self.viewing_player = self.message_parser.get_position()
self.betting_string = self.message_parser.get_betting_string(rd=None)
self.board_string = self.message_parser.get_board_string(rd=None)
# a two-dimension list, dim-1 is round, dim-2 is i-th action of a round
self.betting_action = self.get_betting_action()
# a one-dimension list, store each {action string} as an element
self.action_list = []
# store each {action object} of all round actions in a one-dimension list
for each_round_action in self.betting_action:
for action in each_round_action:
self.action_list.append(Action(action))
# set up basic data structure
self.spent = [50, 100, 0, 0, 0, 0]
self.active = [True] * 6
self.fold = [False] * 6
self.allin = [False] * 6
self.pot = 150
self.max_bet = 100
self.current_player = 2 # player at seat 2 is first player to act in PREFLOP round
self.finished = False
self.round = Round.PREFLOP
self.boards = None # first round have no board cards
self.holes = None # hole array for 6 players
self.min_no_limit_raise_to = 2 * 100
self.max_no_limit_raise_to = 20000
self.next_round_flag = False
self.call_number = 0
# update [hole] and [board]
self.holes = self.message_parser.get_hole_card(position=None)
self.boards = self.message_parser.get_board_card(rd=None)
# after setting up basic data structure, start to do each action and update data structure
cnt = 0
for action in self.action_list:
cnt += 1
self.do_action(action)
def __init__(self, sock):
self.__socket = sock
self.__message_parser = MessageParser()
self.__lobby_model = LobbyModel()
# name of the game
self.__game = None
# player number (1 or 2)
self.__player = None
# player id lol
self.__id = self.__get_own_player_id()
# add client as player
self.__lobby_model.add_player(self.__id)
# register callbacks
self.__lobby_model.register_callback(LobbyEvent.on_update,
self.on_update_lobby)
self.__lobby_model.register_callback(LobbyEvent.on_chat, self.on_chat)
def __init__(self, roverID, blockInfo):
self.roverID = roverID
self.blockInfo = blockInfo
self.posY = 0
self.nextY = 0
if roverID == 0:
self.posX = 0
self.nextX = 0
else:
self.posX = -1
self.nextX = -1
# Declare test client and parser
self.clientConnection = TestClient()
self.parser = MessageParser(roverID)
# Connect signals and slots
self.clientConnection.messageFromServer.connect(self.parser.parse)
self.parser.parsedMessageSignal.connect(self.messageFromServer)
self.parser.constructedMessageSignal.connect(
self.clientConnection.sendMessageToServer)
def cleanup():
print('cleanup')
server.closeServer()
# Make Qt happy
app = QApplication(sys.argv)
# Declare server
server = team13Server('192.168.42.1', 2000)
# Declare server GUI
serverGui = MainWindow()
# Declare parser for rover 0
rover0Parser = MessageParser(0)
# Declare parser for rover 1
rover1Parser = MessageParser(1)
# Central class holding positions of both rovers
roverPositions = RoverPositions()
# Declare controller for rover 0
rover0Controller = Rover0Control(roverPositions)
# Declare controller for rover 1
rover1Controller = Rover1Control(roverPositions)
# Connect server signals
server.client0Message.connect(rover0Parser.parse)
server.client1Message.connect(rover1Parser.parse)
server.serverClosed.connect(rover0Parser.closeLog)
server.startSelf.connect(server.runServer)
# Connect GUI signals
# Please install the slackclient module either globally or into ./lib before running this bot
# Additionally, you should fill in the config.json with all of the appropriate keys, tokens, and IDs
import json, sys, socket, time
sys.path.insert(0, 'lib')
sys.dont_write_bytecode = True
from rtmctl import SlackBotController
from messageparser import MessageParser
with open('config.json', 'r') as cfg:
config = json.load(cfg)
slackbot = SlackBotController(config=config, parser=MessageParser(config))
# Runs the bot and handles/retries on connection errors,
# implements an exponential backoff up to 256 seconds.
def retryLoop(func, sec):
try:
func()
except Exception, e:
sec = sec + 1 if sec < 8 else 1
print 'Connection error, retrying in ' + str(2**sec) + ' seconds...'
time.sleep(2**sec)
retryLoop(func, sec)
retryLoop(slackbot.run, 0)
from messageparser import MessageParser
mp = MessageParser()
try:
prefix, command, params = mp.parseMessage('USER oskar oskar 127.0.0.1 :realname\r\n')
except ValueError as e:
print(e)
print("prefix: ", prefix)
print("command:", command)
print("parameters:", params)
# try:
# mp.parseMessage(':prefix 001 middle :this is a trailing parameter \r\n')
# except ValueError as e:
# print(e)
# print("prefix: ", mp.prefix)
# print("command:", mp.command)
# print("parameters:", mp.parameters)
import json, sys, socket, time
sys.path.insert(0, './lib')
from irccontroller import SlackIRCController
from messageparser import MessageParser
with open('config.json', 'r') as cfg:
config = json.load(cfg)
slackbot = SlackIRCController(server=config['irc']['host'],
port=config['irc']['port'],
channel=config['irc']['channel'],
master=config['master'],
parser=MessageParser(config=config),
username=config['irc']['username'],
password=config['irc']['password'])
# Runs the bot and handles/retries on connection errors,
# implementing an exponential backoff up to 256 seconds.
def retryLoop(func, sec):
try:
func()
except socket.error:
sec = sec + 1 if sec < 8 else 1
print 'Connection error, retrying in ' + str(2**sec) + ' seconds...'
time.sleep(2**sec)
retryLoop(func, sec)
retryLoop(slackbot.run, 0)
