def privmsg(self, user, channel, msg):
"""This will get called when the bot receives a message."""
user = user.split('!', 1)[0]
#self.mode("#wrentest2", True, "c");
if msg == "modes?":
def modesCallback(prefix, command, params):
if prefix == "RPL_CHANNELMODEIS":
self.msg(channel, params[2])
return True
elif prefix == "RPL_UMODEIS":
self.msg(channel, params[1])
return True
return False
#self.msg(channel, "The mode for %s is %s" % (rplChannel,rplModes))
#return True
self.addCallback(modesCallback)
self.sendLine("MODE %s" % channel)
# Check to see if they're sending me a private message
# TODO: This should be cleaned up to be less confusing in terms of channel vs user
if channel == self.nickname:
channel = user
CommandHandler.handleCommand(self, user, channel, msg)
#print "Handlers:", self.handlers
for handler in self.handlers:
#print handler, dir(handler)
if "privmsg" in dir(self.handlers[handler]):
self.handlers[handler].privmsg(self, user, channel, msg)
def on_touch_up(touch):
CommandHandler.execute(Command("Mouse release","Release the mouse button","leftrelease " + str(touch.x) + " " + str(touch.y)));
# touch is over, display informations, and check if it matches some
# known gesture.
g = simplegesture(
'',
zip(touch.ud['line'].points[::2], touch.ud['line'].points[1::2])
)
# print the gesture representation, you can use that to add
# gestures to my_gestures.py
#print "gesture representation:", gdb.gesture_to_str(g)
gesture = OwnGesture.Gesture("name", False, gdb.gesture_to_str(g))
if len(EventLoop.touches) < 2:
global V2SWIPE_REF
global H2SWIPE_REF
global ROTATE_REF
global PINCH_REF
#Clear multi-touch reference points
V2SWIPE_REF = []
H2SWIPE_REF = []
ROTATE_REF = []
PINCH_REF = []
return gesture #TODO Return actual gesture object
def privmsg(self, user, channel, msg):
"""This will get called when the bot receives a message."""
user = user.split('!', 1)[0]
#self.mode("#wrentest2", True, "c");
if msg == "modes?":
def modesCallback(prefix, command, params):
if prefix == "RPL_CHANNELMODEIS":
self.msg(channel, params[2])
return True
elif prefix == "RPL_UMODEIS":
self.msg(channel, params[1])
return True
return False
#self.msg(channel, "The mode for %s is %s" % (rplChannel,rplModes))
#return True
self.addCallback(modesCallback)
self.sendLine("MODE %s" % channel)
# Check to see if they're sending me a private message
# TODO: This should be cleaned up to be less confusing in terms of channel vs user
if channel == self.nickname:
channel = user
CommandHandler.handleCommand(self, user, channel, msg)
#print "Handlers:", self.handlers
for handler in self.handlers:
#print handler, dir(handler)
if "privmsg" in dir(self.handlers[handler]):
self.handlers[handler].privmsg(self, user, channel, msg)
def on_touch_move(touch):
# store points of the touch movement
CommandHandler.execute(Command("Mouse drag","Move the mouse cursor","positionmouse " + str(touch.x) + " " + str(touch.y)));
try:
touch.ud['line'].points += [touch.x, touch.y]
except (KeyError), e:
pass
def handle_incoming_messages():
data = request.json
try:
sender = data['entry'][0]['messaging'][0]['sender']['id']
message = data['entry'][0]['messaging'][0]['message']['text']
except:
pass
if 'message' in locals():
CommandHandler.process(sender, message)
return "ok"
def main():
global slack_client
READ_WEBSOCKET_DELAY = 1 # 1 second delay between reading from firehose
Competitors.load_competitors()
if slack_client.rtm_connect():
print("Smashbot connected and running!")
CommandHandler.init()
if sys.argv[-1] == "tfile":
tfile = open("entry.txt", 'r+')
stuff = tfile.read().split("\n")
channel = stuff[4]
user = "******" # jackson lol
print(stuff)
CommandHandler.player1 = stuff[0]
CommandHandler.player2 = stuff[1]
CommandHandler.score1 = int(stuff[2])
CommandHandler.score2 = int(stuff[3])
CommandHandler.pending = True
command = "match-confirm no-print"
tfile.truncate()
tfile.close()
print("about to run")
handle_command(command, channel, user)
elif sys.argv[-1] == "addfile":
tfile = open("entry.txt", 'r+')
stuff = tfile.read().split("\n")
channel = stuff[2]
user = "******" # also jackson.
print(stuff)
command = "add-competitor " + stuff[0] + " " + stuff[
1] + " no-print"
tfile.truncate()
tfile.close()
handle_command(command, channel, user)
elif sys.argv[-1] == "cancelfile":
tfile = open("entry.txt", 'r+')
stuff = tfile.read().split("\n")
channel = stuff[0]
user = "******"
command = "match-cancel no-print"
print(stuff)
tfile.truncate()
tfile.close()
handle_command(command, channel, user)
while True:
command, channel, user = parse_slack_output(
slack_client.rtm_read())
if command and channel:
handle_command(command, channel, user)
time.sleep(READ_WEBSOCKET_DELAY)
else:
print("Connection failed. Invalid Slack token or bot ID?")
def run(self):
self.csock.connect(("localhost",25566))
p = self.recivePack()
print("recived: ",p, CommandHandler.validDict(CommandHandler.getAsDict(p)))
time.sleep(1)
while True:
p = self.recivePack()
if (p is b''):
break
print("recived: ",p, CommandHandler.validDict(CommandHandler.getAsDict(p)))
print("done")
def saveCroppedImage(self):
Logger.info("Saving cropped image")
currentImage = self.imageHandler.readImage(self.rawImagePath)
if CommandHandler.areBoundsSet():
bounds = CommandHandler.getBounds()
croppedImage = self.imageHandler.cropAndRotateRectangleInImage(
currentImage, bounds)
else:
bounds = self.getBoundingRectForTable(currentImage)
croppedImage = self.imageHandler.cropImageByBoundingRect(
currentImage, bounds)
cv.imwrite(self.croppedImagePath, croppedImage)
def c_handler(self, *arg, **karg):
def _c_handler(bot, update, args=None):
message = ''
if (args != None):
message = ' '.join(args)
reply = self.handler(message=message)
if reply is None:
return
if isinstance(reply, (str, unicode)):
update.effective_message.reply_text(reply)
else:
try:
reply_markup = _generateMenu(reply[sadDec._MENU_INDEX_])
update.effective_message.reply_text(
reply[sadDec._MESSAGE_INDEX_],
reply_markup=reply_markup)
except IndexError:
logging.error("Bad menu formatting")
_newCommandHandler = CommandHandler._Command(
_c_handler,
funcName=self.handler.funcName,
passArgs=True,
description=self.handler.description)
return _newCommandHandler
def run(self):
self.running = True
while self.running:
print("do random dict")
t = [random.randint(128,255),random.randint(0,255),random.randint(0,255)]
self.parent.dict = CommandHandler.getAsDict(t)
time.sleep(2)
def handle_incoming_messages():
data = request.json
try:
sender = data['entry'][0]['messaging'][0]['sender']['id']
message = data['entry'][0]['messaging'][0]['message']['text'].decode('UTF-8')
except:
pass
try:
postback = data['entry'][0]['messaging'][0]['postback']['payload']
except:
pass
if 'message' in locals():
CommandHandler.message(sender, message)
if 'postback' in locals():
CommandHandler.postback(sender, postback)
return "ok"
def setup_bot(self):
"""
Setup routine for new bot. Does the following things:
1. Select virtual server specified by self.sid
2. Set bot nickname to the Name specified by self.bot_name
3. Move the bot to the channel specified by self.default_channel
4. Register command and event handlers
:return:
"""
try:
self.ts3conn.use(sid=self.sid)
except ts3.TS3Connection.TS3QueryException:
self.logger.exception("Error on use SID")
exit()
try:
self.channel = self.get_channel_id(self.default_channel)
self.ts3conn.clientupdate(["client_nickname=" + self.bot_name])
self.ts3conn.clientmove(self.channel,
int(self.ts3conn.whoami()["client_id"]))
except ts3.TS3Connection.TS3QueryException:
self.logger.exception("Error on setting up client")
self.ts3conn.quit()
return
self.command_handler = CommandHandler.CommandHandler(self.ts3conn)
self.event_handler = EventHandler.EventHandler(
ts3conn=self.ts3conn, command_handler=self.command_handler)
try:
self.ts3conn.register_for_server_events(
self.event_handler.on_event)
self.ts3conn.register_for_private_messages(
self.event_handler.on_event)
except ts3.TS3Connection.TS3QueryException:
self.logger.exception("Error on registering for events.")
exit()
def printCommand(self):
tdict = self.dict
if tdict is not self.oldDict:
print("----------------------")
for k in tdict:
print(k, tdict[k])
print(CommandHandler.getAsByteArray(tdict))
self.oldDict = tdict
def privmsg(self, client, user, channel, msg):
comm = ch.parseCommand(client.nickname, msg)
if comm:
if comm["command"] == "herp":
client.msg(channel, "derp")
elif (re.search("what day is it\?", msg)):
client.msg(channel, whatDay())
def areImagesEqual(self, imageA, imageB):
self.equalityThreshold = CommandHandler.getSensitivity()
grayA = self.getGrayscale(imageA)
grayB = self.getGrayscale(imageB)
score = self.calculateEqualityScore(grayA, grayB)
ScoreKeeper.score = score
return score > (1 - self.equalityThreshold)
def sendCommand(self,dir,speed):
dict = CommandHandler.blankDict()
if (dir <= 0):
dict["steering_direction"] = 0
dict["steering_position"] = -dir
else:
dict["steering_direction"] = 1
dict["steering_position"] = dir
if (speed <= 0):
dict["motor_direction"] = 0
dict["motor_speed"] = -speed
else:
dict["motor_direction"] = 1
dict["motor_speed"] = speed
dict["time"] = int(time.time())
commandArray = CommandHandler.getAsByteArray(dict)
print("sending command")
print("----------------------")
for k in dict:
print(k, dict[k])
print(commandArray)
self.sock.sendPack(commandArray)
def on_touch_down(touch):
#start collecting points in touch.ud
CommandHandler.execute(Command("Mouse left click","Click the left mouse button","leftpress " + str(touch.x) + " " + str(touch.y)));
userdata = touch.ud
userdata['line'] = Line(points=(touch.x, touch.y))
#The moment you have two touch points: use their locations as references.
if len(EventLoop.touches) == 2:
global V2SWIPE_REF
global H2SWIPE_REF
global ROTATE_REF
global PINCH_REF
global GTHRESHOLD
global GTHRESHOLD2
t = EventLoop.touches
V2SWIPE_REF = [(t[0].x,t[0].y),(t[1].x,t[1].y)]
H2SWIPE_REF = [(t[0].x,t[0].y),(t[1].x,t[1].y)]
ROTATE_REF = [(t[0].x,t[0].y),(t[1].x,t[1].y)]
PINCH_REF = [(t[0].x,t[0].y),(t[1].x,t[1].y)]
return None #TODO Return actual gesture object
def setup_bot(self):
"""
Setup routine for new bot. Does the following things:
1. Select virtual server specified by self.sid
2. Set bot nickname to the Name specified by self.bot_name
3. Move the bot to the channel specified by self.default_channel
4. Register command and event handlers
:return:
"""
try:
self.ts3conn.use(sid=self.sid)
except ts3.TS3Connection.TS3QueryException:
self.logger.exception("Error on use SID")
exit()
try:
try:
self.ts3conn.clientupdate(["client_nickname=" + self.bot_name])
except TS3QueryException as e:
if e.type == TS3QueryExceptionType.CLIENT_NICKNAME_INUSE:
self.logger.info(
"The choosen bot nickname is already in use, keeping the default nickname"
)
else:
raise e
try:
self.channel = self.get_channel_id(self.default_channel)
self.ts3conn.clientmove(
self.channel, int(self.ts3conn.whoami()["client_id"]))
except TS3QueryException as e:
if e.type == TS3QueryExceptionType.CHANNEL_ALREADY_IN:
self.logger.info(
"The bot is already in the configured default channel")
else:
raise e
except TS3QueryException:
self.logger.exception("Error on setting up client")
self.ts3conn.quit()
return
self.command_handler = CommandHandler.CommandHandler(self.ts3conn)
self.event_handler = EventHandler.EventHandler(
ts3conn=self.ts3conn, command_handler=self.command_handler)
try:
self.ts3conn.register_for_server_events(
self.event_handler.on_event)
self.ts3conn.register_for_channel_events(
0, self.event_handler.on_event)
self.ts3conn.register_for_private_messages(
self.event_handler.on_event)
except ts3.TS3Connection.TS3QueryException:
self.logger.exception("Error on registering for events.")
exit()
def isTableFree(self, imagePathA, imagePathB):
imageA = self.imageHandler.readImage(imagePathA)
imageB = self.imageHandler.readImage(imagePathB)
if CommandHandler.areBoundsSet():
bounds = CommandHandler.getBounds()
croppedA = self.imageHandler.cropAndRotateRectangleInImage(
imageA, bounds)
croppedB = self.imageHandler.cropAndRotateRectangleInImage(
imageB, bounds)
else:
tableABounds = self.tableFinder.getBoundingRectForTable(imageA)
tableBBounds = self.tableFinder.getBoundingRectForTable(imageB)
largestBounds = self.imageHandler.getLargestBoundingRect(
tableABounds, tableBBounds)
croppedA = self.imageHandler.cropImageByBoundingRect(
imageA, largestBounds)
croppedB = self.imageHandler.cropImageByBoundingRect(
imageB, largestBounds)
return self.imageComparator.areImagesEqual(croppedA, croppedB)
def main():
s = socket.socket()
s.connect((Config.HOST, Config.PORT))
s.send("PASS {}\r\n".format(Config.PASS).encode("utf-8"))
s.send("NICK {}\r\n".format(Config.NICK).encode("utf-8"))
s.send("JOIN #{}\r\n".format(Config.CHAN).encode("utf-8"))
chat_message = re.compile(r"^:\w+!\w+@\w+\.tmi\.twitch\.tv PRIVMSG #\w+ :")
Utilities.chat(s, "SpotBot has started running!")
thread.start_new_thread(OpOperations.thread_fill_op_list, ())
while True:
response = s.recv(1024).decode("utf-8")
if response == "PING :tmi.twitch.tv\r\n":
s.send("PONG :tmi.twitch.tv\r\n".encode("utf-8"))
else:
user = re.search(r"\w+", response).group(0)
message = chat_message.sub("", response)
message = message.strip()
CommandHandler.handle_command(user, message, s)
print(response)
sleep(1)
def __init__(self, data, bots, config, section):
(self.host, self.port, self.name, self.pswd) = data
self._handle_data_reset()
# Open the database for this bot.
self.db = shelve.open("{0}@{1}.db".format(
self.name, self.host).replace(".", "-").replace("/", "-"),
writeback=True)
# Store the list of bots.
self._bots = bots
self.config = config
self.section = section
# Initialize various classes.
self.ch = CommandHandler(self)
self.pi = PlayerInfo(self)
self.kl = KillsLog(self)
self.cmds = Commands(self)
BaseSocket.__init__(self)
self.commands_load()
ts = time.time()
self.who_stamp = ts + self.config.getint("General", "who_delay")
def handle_command(command, channel, user):
"""
Receives commands directed at the bot and determines if they
are valid commands. If so, then acts on the commands. If not,
returns back what it needs for clarification.
"""
new_command = command
if command[0] == ":":
new_command = command[1:]
response, ochannel = CommandHandler.execute_command(
new_command, channel, user)
slack_client.api_call("chat.postMessage",
channel=ochannel,
text=response,
as_user=True)
def __init__(self):
threading.Thread.__init__(self)
##first thing to run##
self.socket = CarSocket.CarSocket(parent = self)
self.socket.connect("localhost",25566) #host ip
#self.socket.hostServerSocket(hostname="192.168.0.117", port=25565) #change host ip
self.setDaemon(False)
self.socket.setDaemon(False)
io.setmode(io.BCM)
self.dict = self.oldDict= CommandHandler.blankDict()
#self.motor = MotorClass.DCMotorClass(17,18,500,100,io) #for dc, not used on new car.
self.motor = MotorClass.StepperMotor(17,18,20,21,1,io)
self.motor.setDaemon(False)
self.motor.start()
self.servo = ServoClasses.ServoClass(27,100,io)
def __init__(self, data, bots, config, section):
(self.host, self.port, self.name, self.pswd) = data
self._handle_data_reset()
# Open the database for this bot.
self.db = shelve.open("{0}@{1}.db".format(self.name, self.host).replace(".", "-").replace("/", "-"), writeback = True)
# Store the list of bots.
self._bots = bots
self.config = config
self.section = section
# Initialize various classes.
self.ch = CommandHandler(self)
self.pi = PlayerInfo(self)
self.kl = KillsLog(self)
self.cmds = Commands(self)
BaseSocket.__init__(self)
self.commands_load()
ts = time.time()
self.who_stamp = ts + self.config.getint("General", "who_delay")
def getMaskForTable(self, poolImage):
self.th_green_low = numpy.array(CommandHandler.getThGreenLow())
self.th_green_high = numpy.array(CommandHandler.getThGreenHigh())
hsvImage = cv.cvtColor(poolImage, cv.COLOR_BGR2HSV)
return self.getMask(hsvImage)
class Bot(BaseSocket):
## Initializes the game bot.
## @param data Tuple containing the bot's server, port, name and password.
## @param bots List of bots.
## @param config ConfigParser instance.
## @param section Section in the config with the settings for this bot.
def __init__(self, data, bots, config, section):
(self.host, self.port, self.name, self.pswd) = data
self._handle_data_reset()
# Open the database for this bot.
self.db = shelve.open("{0}@{1}.db".format(self.name, self.host).replace(".", "-").replace("/", "-"), writeback = True)
# Store the list of bots.
self._bots = bots
self.config = config
self.section = section
# Initialize various classes.
self.ch = CommandHandler(self)
self.pi = PlayerInfo(self)
self.kl = KillsLog(self)
self.cmds = Commands(self)
BaseSocket.__init__(self)
self.commands_load()
ts = time.time()
self.who_stamp = ts + self.config.getint("General", "who_delay")
## Load the possible commands.
def commands_load(self):
self.config.read(['config.cfg'])
# List of recognized commands.
self.commands = [
("^what does(?: (?:the )?acronym)? (\w+) (?:stand for|mean)(?:\?)?$", self.cmds.player_command_acronym),
("^(?:wtf|what) is (\w+)(?:\?)?$", self.cmds.player_command_acronym),
("^when was ([a-zA-Z0-9_-]+) last (?:on|online|logged in|here|seen)(?:\?)?$", self.cmds.player_command_seen),
("^seen ([a-zA-Z0-9_-]+)(?:\?)?$", self.cmds.player_command_seen),
("^(?:when (?:have (?:you|u) last seen|did (?:you|u) last see)|(?:last )?seen|have (?:you|u) seen|did (?:you|u) see) ([a-zA-Z0-9_-]+)(?:\?)?$", self.cmds.player_command_seen),
("^(?:what|which) (\w+) is ([a-zA-Z0-9_-]+)(?:\?)?$", self.cmds.player_command_info),
("^wh(?:o|ich player(s)?) (?:(?:has |have )?died|got killed)(?: the)? most(?: often)?( in(?: the)? arena)?(?:\?)?$", self.cmds.player_command_died),
("^wh(?:ich|at) (?:mo(?:b|nster)|beast|thing|creature)(s)? (?:is|are|r)(?: (?:the )?most)? (?:lethal|dangerous)(?:\?)?$", self.cmds.player_command_lethal),
("^wh(?:o|ich player(s)?) (?:has|have) killed(?: (?:the )?most)(?: players)? in(?: the)? arena(?:\?)?$", self.cmds.player_command_arena),
("^how (?:many times|much) (?:has|did) ([a-zA-Z0-9_-]+) die(?:d)?( in(?: the)? arena)?(?:\?)?$", self.cmds.player_command_died_player),
("^how (?:many times|much) (?:has|did) (.+) kill(?:ed)?( in(?: the)? arena)?(?:\?)?$", self.cmds.player_command_killed_count),
("^how (?:many times|much) (?:has|did) (.+) kill(?:ed)? ([a-zA-Z0-9_-]+)( in(?: the)? arena)?(?:\?)?$", self.cmds.player_command_killed_player),
("^reload commands(?:\.)?$", self.cmds.player_commands_reload),
("^chat (.+)$", self.cmds.player_command_chat),
("^(?:how much is )?(\d+) (\w+)(?: coin(?:s)?)? in (\w+)(?: coin(?:s)?)?(?:\?)?$", self.cmds.player_command_currency),
("^shut(?: )?down$", self.cmds.player_command_quit),
]
# Is there a commands section?
if not self.config.has_section("Commands"):
return
for (name, value) in self.config.items("Commands"):
(regex, s) = re.match("\"(.+)\" (.+)", value).groups()
self.commands.append((regex, s))
## Closes the bot.
def close(self):
self.db.close()
self.disconnect()
self._bots.remove(self)
## Sends connect data to the game server.
def _post_connect(self):
self.send(b"version 1055 1055 Atrinikbot")
self.send(b"setup bot 1")
## Handles queue command sending.
def _command_queue_handler(self, cmd):
self.send_command(cmd)
## Send data to the server.
## @param s The data to send.
def send(self, s):
if type(s) != type(bytes()):
s = s.encode()
l = len(s)
s = struct.pack("BB", (l >> 8 & 0xFF), l & 0xFF) + s
l += 2
sent = 0
while sent < l:
sent += self.socket.send(s[sent:])
## Send game command to the server.
## @param s The command to send.
def send_command(self, s):
self.send("cm {0}".format(s))
## Reset internal data used when reading data from socket.
def _handle_data_reset(self):
self._readbuf = b""
self._readbuf_len = 0
self._header_len = 0
self._cmd_len = -1
## Handle reading data from socket.
def handle_data(self):
starttime = time.time()
while True:
if time.time() - starttime > 0.5:
break
# Less than 2 bytes read (possibly 0 so far), choose how much to read.
if self._readbuf_len < 2:
# If we read something already, check for bit marker and read more
# if applicable, as this is as 3-byte header.
if self._readbuf_len > 0 and struct.unpack("B", self._readbuf[:1])[0] & 0x80:
toread = 3 - self._readbuf_len
# Standard 2-byte header.
else:
toread = 2 - self._readbuf_len
# Exactly 2 bytes read; if the bit marker is set, read 1 more, as this
# a 3-byte header instead of the standard 2-byte one.
elif self._readbuf_len == 2 and struct.unpack("B", self._readbuf[:1])[0] & 0x80:
toread = 1
else:
# We got the header data, try to parse it.
if self._readbuf_len <= 3:
# Figure out the header length.
self._header_len = 3 if struct.unpack("B", self._readbuf[:1])[0] & 0x80 else 2
self._cmd_len = 0
# Unpack the header.
unpacked = struct.unpack("{0}B".format(self._header_len), self._readbuf[:self._header_len])
i = 0
# 3-byte header.
if self._header_len == 3:
self._cmd_len += (unpacked[i] & 0x7f) << 16
i += 1
# 2-byte header or continuation of the above 3-byte one.
self._cmd_len += unpacked[i] << 8
i += 1
self._cmd_len += unpacked[i]
# Now we know exactly how much data to read to complete the
# command.
toread = self._cmd_len + self._header_len - self._readbuf_len
try:
# Try to read the data.
data = self.socket.recv(toread)
except socket.error:
return
# Failed; reset connection.
if not data:
self._handle_data_reset()
self._mark_reconnect()
return
# Store the data and update the data's total length.
self._readbuf += data
self._readbuf_len += len(data)
# Have we completed reading the data for the command yet?
if self._readbuf_len == self._cmd_len + self._header_len:
# Strip off the header bytes.
self._readbuf = self._readbuf[self._header_len:]
# Get the command ID.
(cmd_id,) = struct.unpack("B", self._readbuf[:1])
# Command #0 marks compressed data.
if cmd_id == 0:
# Figure out the uncompressed length.
ucomp_len = struct.unpack("I", self._readbuf[1:5][::-1])
# Uncompress the data.
self._readbuf = zlib.decompress(self._readbuf[5:])
# Get the actual command ID now.
(cmd_id,) = struct.unpack("B", self._readbuf[:1])
# Handle the command.
self.ch.handle_command(cmd_id, self._readbuf[1:])
# Reset the internal pointers.
self._handle_data_reset()
## Handle anything extra.
def handle_extra(self):
ts = time.time()
# Check if it's time to send a /who command yet.
if ts >= self.who_stamp:
self.who_stamp = ts + self.config.getint("General", "who_delay")
self.send_command("/who")
# Handle command queue.
self._command_queue_handle()
## Handle chat.
## @param name Player that activated the chat.
## @param msg The message player said.
## @param chat Chat type used (tell, shout, say, etc).
def handle_chat(self, name, msg, chat):
# Default message if we can't match any regex.
ret = "I cannot answer that query."
# Remove extraneous spaces between words.
msg = " ".join(msg.split())
# Try to parse the commands.
for (regex, cmd) in self.commands:
match = re.match(regex, msg, re.I)
if match:
if type(cmd) == type(str()):
ret = cmd.format(name)
else:
ret = cmd(name, match.groups())
break
if chat == "tell":
self.send_command("/tell {0} {1}".format(name, ret))
elif chat == "say":
self.send_command("/say {0}".format(ret))
import sys
import os
import CommandHandler
if __name__ == "__main__":
CommandHandler.CommandHandler()
exit(1)
class Bot(BaseSocket):
## Initializes the game bot.
## @param data Tuple containing the bot's server, port, name and password.
## @param bots List of bots.
## @param config ConfigParser instance.
## @param section Section in the config with the settings for this bot.
def __init__(self, data, bots, config, section):
(self.host, self.port, self.name, self.pswd) = data
self._handle_data_reset()
# Open the database for this bot.
self.db = shelve.open("{0}@{1}.db".format(
self.name, self.host).replace(".", "-").replace("/", "-"),
writeback=True)
# Store the list of bots.
self._bots = bots
self.config = config
self.section = section
# Initialize various classes.
self.ch = CommandHandler(self)
self.pi = PlayerInfo(self)
self.kl = KillsLog(self)
self.cmds = Commands(self)
BaseSocket.__init__(self)
self.commands_load()
ts = time.time()
self.who_stamp = ts + self.config.getint("General", "who_delay")
## Load the possible commands.
def commands_load(self):
self.config.read(['config.cfg'])
# List of recognized commands.
self.commands = [
("^what does(?: (?:the )?acronym)? (\w+) (?:stand for|mean)(?:\?)?$",
self.cmds.player_command_acronym),
("^(?:wtf|what) is (\w+)(?:\?)?$",
self.cmds.player_command_acronym),
("^when was ([a-zA-Z0-9_-]+) last (?:on|online|logged in|here|seen)(?:\?)?$",
self.cmds.player_command_seen),
("^seen ([a-zA-Z0-9_-]+)(?:\?)?$", self.cmds.player_command_seen),
("^(?:when (?:have (?:you|u) last seen|did (?:you|u) last see)|(?:last )?seen|have (?:you|u) seen|did (?:you|u) see) ([a-zA-Z0-9_-]+)(?:\?)?$",
self.cmds.player_command_seen),
("^(?:what|which) (\w+) is ([a-zA-Z0-9_-]+)(?:\?)?$",
self.cmds.player_command_info),
("^wh(?:o|ich player(s)?) (?:(?:has |have )?died|got killed)(?: the)? most(?: often)?( in(?: the)? arena)?(?:\?)?$",
self.cmds.player_command_died),
("^wh(?:ich|at) (?:mo(?:b|nster)|beast|thing|creature)(s)? (?:is|are|r)(?: (?:the )?most)? (?:lethal|dangerous)(?:\?)?$",
self.cmds.player_command_lethal),
("^wh(?:o|ich player(s)?) (?:has|have) killed(?: (?:the )?most)(?: players)? in(?: the)? arena(?:\?)?$",
self.cmds.player_command_arena),
("^how (?:many times|much) (?:has|did) ([a-zA-Z0-9_-]+) die(?:d)?( in(?: the)? arena)?(?:\?)?$",
self.cmds.player_command_died_player),
("^how (?:many times|much) (?:has|did) (.+) kill(?:ed)?( in(?: the)? arena)?(?:\?)?$",
self.cmds.player_command_killed_count),
("^how (?:many times|much) (?:has|did) (.+) kill(?:ed)? ([a-zA-Z0-9_-]+)( in(?: the)? arena)?(?:\?)?$",
self.cmds.player_command_killed_player),
("^reload commands(?:\.)?$", self.cmds.player_commands_reload),
("^chat (.+)$", self.cmds.player_command_chat),
("^(?:how much is )?(\d+) (\w+)(?: coin(?:s)?)? in (\w+)(?: coin(?:s)?)?(?:\?)?$",
self.cmds.player_command_currency),
("^shut(?: )?down$", self.cmds.player_command_quit),
]
# Is there a commands section?
if not self.config.has_section("Commands"):
return
for (name, value) in self.config.items("Commands"):
(regex, s) = re.match("\"(.+)\" (.+)", value).groups()
self.commands.append((regex, s))
## Closes the bot.
def close(self):
self.db.close()
self.disconnect()
self._bots.remove(self)
## Sends connect data to the game server.
def _post_connect(self):
self.send(b"version 1055 1055 Atrinikbot")
self.send(b"setup bot 1")
## Handles queue command sending.
def _command_queue_handler(self, cmd):
self.send_command(cmd)
## Send data to the server.
## @param s The data to send.
def send(self, s):
if type(s) != type(bytes()):
s = s.encode()
l = len(s)
s = struct.pack("BB", (l >> 8 & 0xFF), l & 0xFF) + s
l += 2
sent = 0
while sent < l:
sent += self.socket.send(s[sent:])
## Send game command to the server.
## @param s The command to send.
def send_command(self, s):
self.send("cm {0}".format(s))
## Reset internal data used when reading data from socket.
def _handle_data_reset(self):
self._readbuf = b""
self._readbuf_len = 0
self._header_len = 0
self._cmd_len = -1
## Handle reading data from socket.
def handle_data(self):
starttime = time.time()
while True:
if time.time() - starttime > 0.5:
break
# Less than 2 bytes read (possibly 0 so far), choose how much to read.
if self._readbuf_len < 2:
# If we read something already, check for bit marker and read more
# if applicable, as this is as 3-byte header.
if self._readbuf_len > 0 and struct.unpack(
"B", self._readbuf[:1])[0] & 0x80:
toread = 3 - self._readbuf_len
# Standard 2-byte header.
else:
toread = 2 - self._readbuf_len
# Exactly 2 bytes read; if the bit marker is set, read 1 more, as this
# a 3-byte header instead of the standard 2-byte one.
elif self._readbuf_len == 2 and struct.unpack(
"B", self._readbuf[:1])[0] & 0x80:
toread = 1
else:
# We got the header data, try to parse it.
if self._readbuf_len <= 3:
# Figure out the header length.
self._header_len = 3 if struct.unpack(
"B", self._readbuf[:1])[0] & 0x80 else 2
self._cmd_len = 0
# Unpack the header.
unpacked = struct.unpack("{0}B".format(self._header_len),
self._readbuf[:self._header_len])
i = 0
# 3-byte header.
if self._header_len == 3:
self._cmd_len += (unpacked[i] & 0x7f) << 16
i += 1
# 2-byte header or continuation of the above 3-byte one.
self._cmd_len += unpacked[i] << 8
i += 1
self._cmd_len += unpacked[i]
# Now we know exactly how much data to read to complete the
# command.
toread = self._cmd_len + self._header_len - self._readbuf_len
try:
# Try to read the data.
data = self.socket.recv(toread)
except socket.error:
return
# Failed; reset connection.
if not data:
self._handle_data_reset()
self._mark_reconnect()
return
# Store the data and update the data's total length.
self._readbuf += data
self._readbuf_len += len(data)
# Have we completed reading the data for the command yet?
if self._readbuf_len == self._cmd_len + self._header_len:
# Strip off the header bytes.
self._readbuf = self._readbuf[self._header_len:]
# Get the command ID.
(cmd_id, ) = struct.unpack("B", self._readbuf[:1])
# Command #0 marks compressed data.
if cmd_id == 0:
# Figure out the uncompressed length.
ucomp_len = struct.unpack("I", self._readbuf[1:5][::-1])
# Uncompress the data.
self._readbuf = zlib.decompress(self._readbuf[5:])
# Get the actual command ID now.
(cmd_id, ) = struct.unpack("B", self._readbuf[:1])
# Handle the command.
self.ch.handle_command(cmd_id, self._readbuf[1:])
# Reset the internal pointers.
self._handle_data_reset()
## Handle anything extra.
def handle_extra(self):
ts = time.time()
# Check if it's time to send a /who command yet.
if ts >= self.who_stamp:
self.who_stamp = ts + self.config.getint("General", "who_delay")
self.send_command("/who")
# Handle command queue.
self._command_queue_handle()
## Handle chat.
## @param name Player that activated the chat.
## @param msg The message player said.
## @param chat Chat type used (tell, shout, say, etc).
def handle_chat(self, name, msg, chat):
# Default message if we can't match any regex.
ret = "I cannot answer that query."
# Remove extraneous spaces between words.
msg = " ".join(msg.split())
# Try to parse the commands.
for (regex, cmd) in self.commands:
match = re.match(regex, msg, re.I)
if match:
if type(cmd) == type(str()):
ret = cmd.format(name)
else:
ret = cmd(name, match.groups())
break
if chat == "tell":
self.send_command("/tell {0} {1}".format(name, ret))
elif chat == "say":
self.send_command("/say {0}".format(ret))
def signalCommand(g):
if not g:
pass
else:
c = ProfileManager.getCommand(g)
CommandHandler.execute(c)
#First check if user account exists
fileFound = FileHandler.DoesAccountExist()
if (not fileFound):
#Create user account since it doesn't exist
try:
CreateAccount()
console.out(17) #Success, account created
except Exception:
console.out(18) #Failure
raise
#Now get the user to log in to their account
credentialPass = False
validationKey = Encryptor.GenerateSALT()
while (not credentialPass):
verification = VerifyUser()
if (not verification[0]):
if (verification[1] == "Invalid"):
#console.cls()
console.out(24, 0.03)
else:
#Success, user has logged in
securityKey = Encryptor.GenerateSecurityKey()
FileHandler.CreateSecurityFile(
Encryptor.OneWayEncryptor(securityKey, validationKey), username)
Command = CMD.CommandHandler(username, verification[1])
credentialPass = verification
PasswordLocker()
Logger.info("Comparing images")
if oldImage.is_file():
try:
isAvailable = pooltableChecker.isTableFree(currentImagePath,
oldImagePath)
except Exception as e:
isAvailable = None
Logger.exception(e)
if isAvailable != wasAvailable:
Logger.info('Posting availability: ' + str(isAvailable))
mattermost_client.updateMattermostAvailable(isAvailable)
wasAvailable = isAvailable
copyfile(currentImagePath, ConfigHandler.getRawImagePath())
currentImage.rename(oldImagePath)
mattermost_client.postToCommandChannel("Pool-ping is up and running")
while CommandHandler.getRunMain():
try:
time.sleep(CommandHandler.getInterval())
camera.takePicture()
checkAvailability()
CommandHandler.reactToCommands()
except Exception as e:
Logger.exception(e)
mattermost_client.postToCommandChannel("Pool-ping is shutdown")
from MailBox import *
from MailHandlerInterface import *
# Mailbox handlers:
from CommandHandler import *
logger.info('creating MailBox')
mb = MailBox('email_settings.ini', "C:/Users/user/Desktop/automation")
#
# register handlers to treat unread messages
#
mb.add_mailbox_handler(CommandHandler(mb, 'CommandHandlerConfigs.json'))
#mb.add_mailbox_handler(___here___)
# main loop
seed(1)
while True:
logger.debug('checking mailbox')
mb.process_unread_messages()
wait_seconds = int(random()*100)%50 + 15
logger.debug('waiting {} seconds'.format(wait_seconds))
separator = ""
for s in range(80):
separator = separator + " ="
def run():
while True:
user_input = input("Enter a command: ")
split_user_input = user_input.split()
#validate
command = split_user_input[0]
options = split_user_input[1:]
option_dictionary = {}
for option in options:
split_option = option.split(":")
if len(split_option) == 1:
option_dictionary[split_option[0]] = ""
else:
option_dictionary[split_option[0]] = split_option[1]
packet_bytes = ""
if command == "help":
CommandHandler.handle_help("")
elif command == "exit":
break
elif command == "device-get-service":
packet_bytes = CommandHandler.handle_device_get_service(
option_dictionary)
elif command == "device-get-host-info":
packet_bytes = CommandHandler.handle_device_get_host_info(
option_dictionary)
elif command == "device-get-host-firmware":
packet_bytes = CommandHandler.handle_device_get_host_firmware(
option_dictionary)
elif command == "device-get-wifi-info":
packet_bytes = CommandHandler.handle_device_get_wifi_info(
option_dictionary)
elif command == "device-get-wifi-firmware":
packet_bytes = CommandHandler.handle_device_get_wifi_firmware(
option_dictionary)
elif command == "device-get-power":
packet_bytes = CommandHandler.handle_device_get_power(
option_dictionary)
elif command == "device-set-power":
packet_bytes = CommandHandler.handle_device_set_power(
option_dictionary)
elif command == "device-get-label":
packet_bytes = CommandHandler.handle_device_get_label(
option_dictionary)
elif command == "device-set-label":
packet_bytes = CommandHandler.handle_device_set_label(
option_dictionary)
elif command == "device-get-version":
packet_bytes = CommandHandler.handle_device_get_version(
option_dictionary)
elif command == "device-get-info":
packet_bytes = CommandHandler.handle_device_get_info(
option_dictionary)
elif command == "device-get-location":
packet_bytes = CommandHandler.handle_device_get_location(
option_dictionary)
elif command == "device-set-location":
packet_bytes = CommandHandler.handle_device_set_location(
option_dictionary)
elif command == "device-get-group":
packet_bytes = CommandHandler.handle_device_get_group(
option_dictionary)
elif command == "device-set-group":
packet_bytes = CommandHandler.handle_device_set_group(
option_dictionary)
elif command == "device-echo-request":
packet_bytes = CommandHandler.handle_device_echo_request(
option_dictionary)
elif command == "light-get-state":
packet_bytes = CommandHandler.handle_light_get_state(
option_dictionary)
elif command == "light-set-color":
packet_bytes = CommandHandler.handle_light_set_color(
option_dictionary)
elif command == "light-set-waveform":
packet_bytes = CommandHandler.handle_light_set_waveform(
option_dictionary)
elif command == "light-get-power":
packet_bytes = CommandHandler.handle_light_get_power(
option_dictionary)
elif command == "light-set-power":
packet_bytes = CommandHandler.handle_light_set_power(
option_dictionary)
elif command == "light-set-waveform-optional":
packet_bytes = CommandHandler.handle_light_set_waveform_optional(
option_dictionary)
elif command == "light-get-infrared":
packet_bytes = CommandHandler.handle_light_get_infrared(
option_dictionary)
elif command == "light-set-infrared":
packet_bytes = CommandHandler.handle_light_set_infrared(
option_dictionary)
else:
print("invalid command. type help for availble commands")
print()
if packet_bytes == "":
continue
else:
PacketBroadcaster.broadcast_packet("172.16.10.255", 56700,
packet_bytes)
def main():
print("\n\n{:^80}\n".format(printBold("***** AADC Voice Control Client *****")))
print("\n{:^80}\n".format(printBold("((( o )))")))
# print('\nConnect to:\t[a] ' + bcolors.UNDERLINE + 'Car 26' + bcolors.ENDC + '\t[b] ' + bcolors.UNDERLINE + 'Car 27' + bcolors.ENDC +'\t[l] ' + bcolors.UNDERLINE + 'localhost' + bcolors.ENDC +'\n')
command_handler = CommandHandler(car_ips, control_server_port, SQS_POLL_TIMEOUT)
try:
while True:
# STEP 1: connect to the car servers
s1 = ">>> Stage 1/3: Connect to Cars <<<" + bcolors.ENDC
print(bcolors.OKGREEN + "\n________________________________________________________________________________\n")
print("\n{:^80}\n".format(s1))
connected = command_handler.connectToCars()
if not connected:
print(bcolors.WARNING + "no connected server found!" + bcolors.ENDC)
continue
else:
print("\nConnected.")
command_handler.printConnectionStats()
command_handler.printCarStats()
# STEP 2: connect to AWS
s2 = ">>> Stage 2/3: Connect to AWS <<<" + bcolors.ENDC
print(bcolors.OKGREEN + "\n________________________________________________________________________________\n")
print("\n{:^80}\n".format(s2))
command_handler.connectToAWS()
# STEP 3: start the VoiceControl service
s2 = ">>> Stage 3/3: Connect to AWS <<<" + bcolors.ENDC
print(bcolors.OKGREEN + "\n________________________________________________________________________________\n")
print("\n{:^80}\n".format(s2))
command_handler.startHandler()
except KeyboardInterrupt:
print('\nexiting.')
exit()
