253 lines
8.8 KiB
Python
253 lines
8.8 KiB
Python
#!/usr/bin/env python3
|
|
|
|
"""
|
|
.. module::ASCII
|
|
:synopsis: Spam chat with awesome ascii texts
|
|
"""
|
|
|
|
from pyircbot.modulebase import ModuleBase, command
|
|
from threading import Thread
|
|
from glob import iglob
|
|
from collections import defaultdict
|
|
from time import sleep
|
|
import re
|
|
import os
|
|
import json
|
|
from textwrap import wrap
|
|
from pyircbot.modules.ModInfo import info
|
|
|
|
|
|
RE_ASCII_FNAME = re.compile(r'^[a-zA-Z0-9\-_]+$')
|
|
IRC_COLOR = "\x03"
|
|
|
|
|
|
def is_numeric(char):
|
|
i = ord(char)
|
|
return i >= 48 and i <= 57
|
|
|
|
|
|
class ASCII(ModuleBase):
|
|
def __init__(self, bot, moduleName):
|
|
ModuleBase.__init__(self, bot, moduleName)
|
|
self.running_asciis = defaultdict(lambda: None)
|
|
self.killed_channels = defaultdict(lambda: False)
|
|
|
|
@info("listascii", "list available asciis", cmds=["listascii"])
|
|
@command("listascii")
|
|
def cmd_listascii(self, msg, cmd):
|
|
"""
|
|
List available asciis
|
|
"""
|
|
fnames = [os.path.basename(f).split(".", 2)[0] for f in iglob(os.path.join(self.getFilePath(), "*.txt"))]
|
|
fnames.sort()
|
|
|
|
message = "Avalable asciis: {}".format(", ".join(fnames[0:self.config.get("list_max")]))
|
|
self.bot.act_PRIVMSG(msg.args[0], message)
|
|
|
|
if len(fnames) > self.config.get("list_max"):
|
|
self.bot.act_PRIVMSG(msg.args[0], "...and {} more".format(len(fnames) - self.config.get("list_max")))
|
|
return
|
|
|
|
@info("ascii <name>", "print an ascii", cmds=["ascii"])
|
|
@command("ascii", require_args=True)
|
|
def cmd_ascii(self, msg, cmd):
|
|
if self.channel_busy(msg.args[0]):
|
|
return
|
|
|
|
# Prevent parallel spamming in different channels
|
|
if not self.config.get("allow_parallel") and any(self.running_asciis.values()):
|
|
return
|
|
|
|
ascii_name = cmd.args.pop(0)
|
|
if not RE_ASCII_FNAME.match(ascii_name):
|
|
return
|
|
|
|
hilight = cmd.args[0] + ": " if self.config.get("allow_hilight", False) and len(cmd.args) >= 1 else False
|
|
try:
|
|
self.send_to_channel(msg.args[0], self.load_ascii(ascii_name), prefix=hilight)
|
|
except FileNotFoundError:
|
|
return
|
|
|
|
@info("stopascii", "stop the currently scrolling ascii", cmds=["stopascii"])
|
|
@command("stopascii")
|
|
def cmd_stopascii(self, msg, cmd):
|
|
"""
|
|
Command to stop the running ascii in a given channel
|
|
"""
|
|
if self.running_asciis[msg.args[0]]:
|
|
self.killed_channels[msg.args[0]] = True
|
|
|
|
def channel_busy(self, channel_name):
|
|
"""
|
|
Prevent parallel spamming in same channel
|
|
"""
|
|
if self.running_asciis[channel_name]:
|
|
return True
|
|
return False
|
|
|
|
def send_to_channel(self, channel, lines, **kwargs):
|
|
self.running_asciis[channel] = Thread(target=self.print_lines, daemon=True,
|
|
args=[channel, lines], kwargs=kwargs)
|
|
self.running_asciis[channel].start()
|
|
|
|
def load_ascii(self, ascii_name):
|
|
"""
|
|
Loads contents of ascii from disk by name
|
|
:return: list of string lines
|
|
"""
|
|
with open(self.getFilePath(ascii_name + ".txt"), "rb") as f:
|
|
return [i.rstrip() for i in f.read().decode("UTF-8", errors="ignore").split("\n")]
|
|
|
|
def print_lines(self, channel, lines, prefix=None):
|
|
"""
|
|
Print the contents of ascii_path to channel
|
|
:param ascii_path: file path to the ascii art file to read and print
|
|
:param channel: channel name to print to
|
|
"""
|
|
delay = self.config.get("line_delay")
|
|
|
|
for line in lines:
|
|
if self.killed_channels[channel]:
|
|
break
|
|
if not line:
|
|
line = " "
|
|
if prefix:
|
|
line = "{}{}".format(prefix, line)
|
|
self.bot.act_PRIVMSG(channel, line)
|
|
if delay:
|
|
sleep(delay)
|
|
del self.running_asciis[channel]
|
|
del self.killed_channels[channel]
|
|
|
|
@info("asciiedit <args>", "customize an ascii with input", cmds=["asciiedit"])
|
|
@command("asciiedit", require_args=True)
|
|
def cmd_asciiedit(self, msg, cmd):
|
|
ascii_name = cmd.args.pop(0)
|
|
try:
|
|
with open(self.getFilePath(ascii_name + ".json")) as f:
|
|
ascii_infos = json.load(f)
|
|
ascii_lines = self.load_ascii(ascii_name)
|
|
except FileNotFoundError:
|
|
return
|
|
|
|
template_data = " ".join(cmd.args).split("|")
|
|
|
|
for i in range(0, min(len(ascii_infos["areas"]), len(template_data))):
|
|
ascii_infos["areas"][i]["string"] = template_data[i]
|
|
|
|
lines = self.edit_ascii(ascii_lines, ascii_infos)
|
|
self.send_to_channel(msg.args[0], lines)
|
|
|
|
def edit_ascii(self, lines, info_dict):
|
|
asci = AsciiEdit(lines)
|
|
# Per region in the metadata
|
|
for area in info_dict["areas"]:
|
|
message = area.get("format", "{}").format(area["string"])
|
|
x = area["x"]
|
|
y = area["y"]
|
|
# Format the text to the area's width
|
|
boxed_lines = wrap(message, area["width"])
|
|
# Write each line
|
|
for line in boxed_lines:
|
|
line_x = x
|
|
props = area.get("props", [])
|
|
# move the X over for centered text
|
|
if "centered" in props:
|
|
padding = (area["width"] - len(line)) / 2
|
|
line_x += padding
|
|
if "upper" in props:
|
|
line = line.upper()
|
|
if "lower" in props:
|
|
line = line.lower()
|
|
if "blacktext" in props:
|
|
asci.set_charcolor(1)
|
|
# Ensure anything in the template will be covered
|
|
# line = line + " " * (area["width"] - len(line))
|
|
# Write the formatted line
|
|
asci.goto(line_x, y)
|
|
asci.write(line)
|
|
# Check if height limit is passed
|
|
y += 1
|
|
if y >= area["y"] + area["height"]:
|
|
break
|
|
return asci.getlines()
|
|
|
|
|
|
class AsciiEdit(object):
|
|
"""
|
|
Semi-smart ascii editing library
|
|
"""
|
|
def __init__(self, lines):
|
|
self.lines = [list(line) for line in lines]
|
|
self.x = 0
|
|
self.virtual_x = 0
|
|
self.y = 0
|
|
self.charcolor = None
|
|
|
|
def goto(self, x, y):
|
|
"""
|
|
This method moves the internal pointer to the passed X and Y coordinate. The origin is the top left corner.
|
|
The literal coordinates (self.x and self.y) point to where in the data the pointer is. Y is simple, self.y is
|
|
always the data and rendered Y coordinate. X has invisible-when-rendered formatting data, so the self.virtual_x
|
|
attribute tracks where the cursor is in the rendered output; self.x tracks the location in the actual data.
|
|
:param x: x coordinate
|
|
:type x: int
|
|
:param y: y coordinate
|
|
:type y: int
|
|
"""
|
|
# Immediately set the x and y pointers
|
|
self.virtual_x = x
|
|
self.y = y
|
|
# Calculate the x position in-data by increasing self.x to the right until real_x == target x
|
|
self.x = 0
|
|
real_x = 0
|
|
while real_x <= x:
|
|
# Scan throw any repeated color codes
|
|
while self.lines[self.y][self.x] == IRC_COLOR:
|
|
# Scan forward until color code is crossed
|
|
self.x += 1 # the escape char
|
|
if is_numeric(self._getchar()):
|
|
self.x += 1 # color code 1st digit
|
|
if is_numeric(self._getchar()):
|
|
self.x += 1 # color code 2nd digit
|
|
# Check for background color code after comma
|
|
if self._getchar() == "," and is_numeric(self._getchar(self.x + 1)):
|
|
self.x += 2 # comma and background code digit 1
|
|
if is_numeric(self._getchar()):
|
|
self.x += 1 # color code digit 2
|
|
real_x += 1
|
|
if real_x <= x:
|
|
self.x += 1
|
|
|
|
def set_charcolor(self, color):
|
|
self.charcolor = color
|
|
|
|
def write(self, text):
|
|
"""
|
|
Write a single line of text to the ascii
|
|
"""
|
|
for char in text:
|
|
self._putchar(self.x, self.y, char)
|
|
self.goto(self.virtual_x + 1, self.y)
|
|
|
|
def getlines(self):
|
|
"""
|
|
Return the rendered ascii, formatted as a list of string lines
|
|
"""
|
|
return [''.join(line) for line in self.lines]
|
|
|
|
def _getchar(self, x=None, y=None):
|
|
if x is None:
|
|
x = self.x
|
|
if y is None:
|
|
y = self.y
|
|
return self.lines[y][x]
|
|
|
|
def _putchar(self, x, y, char):
|
|
if self.charcolor is not None and char != " ":
|
|
self.lines[y].pop(x)
|
|
for char in list((IRC_COLOR + str(self.charcolor) + char)[::-1]):
|
|
self.lines[y].insert(x, char)
|
|
else:
|
|
self.lines[y][x] = char
|