TDF Send
So on a recommendation from shmoo on Libera, I decided to get myself a Pro duck.ai account for just whatever bullshit I feel like doing. It’s actually so much better than Google’s Gemini subscription shit. Way better. Infinitely better.
Anyways, I vibecoded a zoitechat script that allows you to send “The Draw Font” ascii spam to whatever channel. It works pretty well I guess. I fuckin dig it. I dunno how well it works in edge cases, so if anyone has any updates please do pass along.
Anyway, without further ado:
# tdf_send.py — TheDraw .TDF sender for ZoiteChat
import os
import re
import shlex
import struct
import zoitechat
__module_name__ = "TDF Send"
__module_version__ = "1.11"
__module_description__ = "Render and send wrapped TheDraw .TDF fonts"
TDF_MARKER = b"\x55\xaa\x00\xff"
FIRST_FONT_OFFSET = 20
FONT_HEADER_SIZE = 213
UNDEFINED_OFFSET = 0xFFFF
MAX_IRC_BYTES = 350
DOS_TO_IRC = [1, 2, 3, 10, 4, 6, 7, 15, 14, 12, 9, 11, 4, 13, 8, 0]
OUTLINE_MAP = {
"A": 0xCD,
"B": 0xC4,
"C": 0xB3,
"D": 0xBA,
"E": 0xD5,
"F": 0xBB,
"G": 0xD6,
"H": 0xBF,
"I": 0xC8,
"J": 0xBE,
"K": 0xC0,
"L": 0xBD,
"M": 0xB5,
"N": 0xC7,
}
PC_DISPLAY_GLYPHS = {
1: "☺",
2: "☻",
3: "♥",
4: "♦",
5: "♣",
6: "♠",
7: "•",
8: "◘",
9: "○",
10: "◙",
11: "♂",
12: "♀",
14: "♫",
15: "☼",
16: "►",
17: "◄",
18: "↕",
19: "‼",
20: "¶",
21: "§",
22: "▬",
23: "↨",
24: "↑",
25: "↓",
26: "→",
27: "←",
28: "∟",
29: "↔",
30: "▲",
31: "▼",
127: "⌂",
}
# Use full-width Unicode block characters where possible. In particular,
# CP437's ■ often renders as a small centered square in modern clients.
TDF_BLOCK_GLYPHS = {
0xB0: "░",
0xB1: "▒",
0xB2: "▓",
0xDB: "█",
0xDC: "▄",
0xDD: "▌",
0xDE: "▐",
0xDF: "▀",
0xFE: "█",
}
IRC_COLOR_RE = re.compile(r"\x03\d{2},\d{2}")
FONT_DIR_PREF = "tdf_font_directory"
LAST_FONT_PREF = "tdf_last_font_file"
DEFAULT_FONT_DIR = os.path.expanduser("~/fonts")
loaded_fonts = {}
loaded_file = None
font_directory = None
def cp437_to_utf8(value):
if value in TDF_BLOCK_GLYPHS:
return TDF_BLOCK_GLYPHS[value]
return PC_DISPLAY_GLYPHS.get(
value,
bytes([value]).decode("cp437", errors="replace"),
)
def font_key(name):
return name.replace("\x00", "").replace("\u00a0", " ").strip().casefold()
def display_width(text):
return len(IRC_COLOR_RE.sub("", text).replace("\x0f", ""))
def compact_irc_colors(line):
result = []
last_color = None
pos = 0
while pos < len(line):
match = IRC_COLOR_RE.match(line, pos)
if match:
color = match.group(0)
if color != last_color:
result.append(color)
last_color = color
pos = match.end()
continue
if line[pos] == "\x0f":
last_color = None
result.append(line[pos])
pos += 1
return "".join(result)
def get_font_directory():
global font_directory
if font_directory is None:
saved = zoitechat.get_pluginpref(FONT_DIR_PREF)
font_directory = os.path.expanduser(saved or DEFAULT_FONT_DIR)
return font_directory
def set_font_directory(path):
global font_directory
font_directory = os.path.abspath(os.path.expanduser(path))
zoitechat.set_pluginpref(FONT_DIR_PREF, font_directory)
def resolve_tdf_path(value):
value = os.path.expanduser(value)
if os.path.isabs(value) or "/" in value:
candidates = [value]
else:
candidates = [os.path.join(get_font_directory(), value)]
for candidate in candidates:
if os.path.isfile(candidate):
return os.path.abspath(candidate)
if not candidate.lower().endswith(".tdf"):
with_extension = candidate + ".tdf"
if os.path.isfile(with_extension):
return os.path.abspath(with_extension)
raise ValueError('Could not find "{}" in {}'.format(value, get_font_directory()))
class TDFFont:
def __init__(self, name, font_type, spacing, data, offsets):
self.name = name
self.font_type = font_type
self.spacing = max(0, spacing - 1)
self.data = data
self.offsets = offsets
def character(self, char):
if char == " ":
return [" "]
code = ord(char)
if code < 33 or code > 126:
return [char]
offset = self.offsets[code - 33]
if offset == UNDEFINED_OFFSET or offset + 2 > len(self.data):
return [char]
width = self.data[offset]
height = self.data[offset + 1]
pos = offset + 2
rows = []
row = ""
row_columns = 0
if width == 0:
return [" "]
while pos < len(self.data):
value = self.data[pos]
pos += 1
if value == 0:
if row or not rows:
rows.append(row + (" " * max(0, width - row_columns)))
break
if value == 13:
rows.append(row + (" " * max(0, width - row_columns)))
row = ""
row_columns = 0
continue
color_value = None
if self.font_type == 2:
if pos >= len(self.data):
break
color_value = self.data[pos]
pos += 1
if self.font_type == 0:
reference = chr(value)
if reference == "@":
glyph = " "
elif reference == "O":
glyph = "\u00a0"
elif reference == "&":
continue
elif reference in OUTLINE_MAP:
glyph = cp437_to_utf8(OUTLINE_MAP[reference])
else:
glyph = cp437_to_utf8(value)
else:
glyph = cp437_to_utf8(value)
if color_value is not None:
foreground = DOS_TO_IRC[color_value & 0x0F]
background = DOS_TO_IRC[(color_value >> 4) & 0x07]
row += "\x03{:02d},{:02d}{}".format(
foreground,
background,
glyph,
)
else:
row += glyph
row_columns += 1
while len(rows) < height:
rows.append(" " * width)
return rows or [" " * width]
def render(self, text):
rendered = []
for source_line in text.splitlines() or [""]:
glyphs = [self.character(char) for char in source_line]
widths = [
max((display_width(row) for row in glyph), default=1)
for glyph in glyphs
]
height = max((len(glyph) for glyph in glyphs), default=1)
output = [""] * height
for index, glyph in enumerate(glyphs):
for row_index in range(height):
if row_index < len(glyph):
output[row_index] += glyph[row_index]
else:
output[row_index] += " " * widths[index]
if index != len(glyphs) - 1:
for row_index in range(height):
output[row_index] += " " * self.spacing
rendered.extend(row + "\x0f" for row in output)
return rendered
def rendered_lines_fit(self, text, byte_limit):
return all(
len(compact_irc_colors(line).encode("utf-8")) <= byte_limit
for line in self.render(text)
)
def render_wrapped(self, text, byte_limit=MAX_IRC_BYTES):
all_lines = []
for paragraph in text.split("\n"):
if not paragraph:
all_lines.extend(self.render(""))
continue
words = paragraph.split()
current = ""
for word in words:
candidate = word if not current else current + " " + word
if self.rendered_lines_fit(candidate, byte_limit):
current = candidate
continue
if current:
all_lines.extend(self.render(current))
current = ""
if self.rendered_lines_fit(word, byte_limit):
current = word
continue
partial = ""
for char in word:
candidate = partial + char
if self.rendered_lines_fit(candidate, byte_limit):
partial = candidate
else:
if not partial:
raise ValueError(
"One rendered character is wider than IRC allows."
)
all_lines.extend(self.render(partial))
partial = char
current = partial
if current:
all_lines.extend(self.render(current))
return all_lines
def load_tdf(path):
global loaded_fonts
global loaded_file
with open(path, "rb") as source:
blob = source.read()
if not blob.startswith(b"\x13TheDraw FONTS file\x1a"):
raise ValueError("Not a valid TheDraw .TDF file.")
fonts = {}
pos = FIRST_FONT_OFFSET
while pos + FONT_HEADER_SIZE <= len(blob):
if blob[pos : pos + 4] != TDF_MARKER:
break
name_length = min(blob[pos + 4], 12)
name = (
blob[pos + 5 : pos + 5 + name_length]
.decode("cp437", errors="replace")
.split("\x00", 1)[0]
.strip()
)
font_type = blob[pos + 21]
spacing = blob[pos + 22]
block_size = struct.unpack_from("<H", blob, pos + 23)[0]
offsets = list(struct.unpack_from("<94H", blob, pos + 25))
data_start = pos + FONT_HEADER_SIZE
data_end = min(data_start + block_size, len(blob))
if name:
fonts[font_key(name)] = TDFFont(
name,
font_type,
spacing,
blob[data_start:data_end],
offsets,
)
pos = data_start + block_size
if not fonts:
raise ValueError("No readable fonts were found in this file.")
loaded_fonts = fonts
loaded_file = os.path.abspath(path)
def get_font(name):
font = loaded_fonts.get(font_key(name))
if font is None:
raise ValueError(
'Font "{}" was not found. Use /TDFFONTS to list fonts.'.format(name)
)
return font
def send_lines(context, lines):
for line in lines:
line = compact_irc_colors(line.replace("\r", "").replace("\n", ""))
if len(line.encode("utf-8")) > MAX_IRC_BYTES:
raise ValueError("A rendered line is too wide for IRC.")
context.command("SAY " + line)
def tdfload_cb(word, word_eol, userdata):
try:
if len(word) < 2:
raise ValueError("Usage: /TDFLOAD <filename-or-path>")
path = resolve_tdf_path(word_eol[1])
load_tdf(path)
zoitechat.set_pluginpref(LAST_FONT_PREF, path)
zoitechat.prnt(
"Loaded {} font(s) from {}".format(len(loaded_fonts), loaded_file)
)
except Exception as error:
zoitechat.prnt("TDF error: {}".format(error))
return zoitechat.EAT_ALL
def tdfdir_cb(word, word_eol, userdata):
try:
if len(word) < 2:
zoitechat.prnt("TDF directory: " + get_font_directory())
return zoitechat.EAT_ALL
path = os.path.expanduser(word_eol[1])
if not os.path.isdir(path):
raise ValueError("Directory does not exist: " + path)
set_font_directory(path)
zoitechat.prnt("TDF directory set to: " + get_font_directory())
except Exception as error:
zoitechat.prnt("TDF error: {}".format(error))
return zoitechat.EAT_ALL
def tdffonts_cb(word, word_eol, userdata):
if not loaded_fonts:
zoitechat.prnt("No TDF file loaded. Use /TDFLOAD <file>.")
else:
zoitechat.prnt(
"Loaded fonts: "
+ ", ".join(sorted(font.name for font in loaded_fonts.values()))
)
return zoitechat.EAT_ALL
def tdf_cb(word, word_eol, userdata):
try:
args = shlex.split(word_eol[1])
if len(args) < 2:
raise ValueError('Usage: /TDF "Font Name" text')
font = get_font(args[0])
send_lines(zoitechat.get_context(), font.render_wrapped(" ".join(args[1:])))
except Exception as error:
zoitechat.prnt("TDF error: {}".format(error))
return zoitechat.EAT_ALL
def tdfto_cb(word, word_eol, userdata):
try:
args = shlex.split(word_eol[1])
if len(args) < 3:
raise ValueError('Usage: /TDFTO <#channel-or-nick> "Font Name" text')
context = zoitechat.find_context(channel=args[0])
if context is None:
raise ValueError('No open channel or query named "{}".'.format(args[0]))
font = get_font(args[1])
send_lines(context, font.render_wrapped(" ".join(args[2:])))
except Exception as error:
zoitechat.prnt("TDF error: {}".format(error))
return zoitechat.EAT_ALL
zoitechat.hook_command(
"TDFLOAD",
tdfload_cb,
help="/TDFLOAD <filename-or-path> Load a TDF file",
)
zoitechat.hook_command(
"TDFDIR",
tdfdir_cb,
help="/TDFDIR [directory] Show or set the TDF font directory",
)
zoitechat.hook_command(
"TDFFONTS",
tdffonts_cb,
help="/TDFFONTS List fonts in the loaded TDF file",
)
zoitechat.hook_command(
"TDF",
tdf_cb,
help='/TDF "Font Name" <text> Send to the current channel or query',
)
zoitechat.hook_command(
"TDFTO",
tdfto_cb,
help='/TDFTO <#channel-or-nick> "Font Name" <text>',
)
zoitechat.prnt("TDF Send 1.11 loaded")
saved_font = zoitechat.get_pluginpref(LAST_FONT_PREF)
if saved_font and os.path.isfile(saved_font):
try:
load_tdf(saved_font)
zoitechat.prnt("TDF Send restored {}".format(saved_font))
except Exception as error:
zoitechat.prnt("TDF auto-load error: {}".format(error))
else:
zoitechat.prnt("TDF Send font directory: {}".format(get_font_directory()))
REVISIONS:
- Updated to wrap at 350 utf-8 bytes, for better or worse.
- Configurable font folder location, persistent last font loaded
- Fixed weird ass alignment issue