1692 lines
50 KiB
Python
1692 lines
50 KiB
Python
import ctypes
|
|
import math
|
|
import os
|
|
import random
|
|
import subprocess
|
|
import threading
|
|
import time
|
|
from ctypes import wintypes
|
|
|
|
print("HELLO WORLD")
|
|
|
|
ij = ctypes.WinDLL("user32", use_last_error=True)
|
|
ix = ctypes.WinDLL("gdi32", use_last_error=True)
|
|
hm = ctypes.WinDLL("kernel32", use_last_error=True)
|
|
ic = ctypes.WinDLL("combase")
|
|
|
|
hf = 0x80000000
|
|
cc = 0x00000008
|
|
ai = 0x00000080
|
|
ca = 0x00080000
|
|
ad = 0x00000020
|
|
gh = 0x00000002
|
|
gk = 0x00000002
|
|
da = 0x01
|
|
fs = 0x0002
|
|
hd = 0x000F
|
|
bz = 0x0014
|
|
ft = 0x0100
|
|
he = 0x0113
|
|
ay = 0x0201
|
|
gl = 0x1B
|
|
ec = 0
|
|
ed = 1
|
|
hw = 5
|
|
al = 48
|
|
gc = 0x0001
|
|
at = 1
|
|
du = 4
|
|
db = 5
|
|
gz = 8
|
|
hb = 0
|
|
hv = 0x00CC0020
|
|
ge = 32512
|
|
ie = 0
|
|
au = 0
|
|
ah = 0x08000000
|
|
u = 1
|
|
|
|
hy = 33
|
|
dw = 25
|
|
ha = 100
|
|
ff = 140
|
|
eg = 150
|
|
gi = 190
|
|
gj = 215
|
|
de = 265
|
|
dv = 95
|
|
gu = 35
|
|
bt = 232
|
|
|
|
ea = 110
|
|
ht = 160
|
|
ig = 2.399963
|
|
|
|
fp = 1
|
|
aw = 2
|
|
|
|
hu = 160
|
|
|
|
|
|
def jn(c, b, a):
|
|
return (a << 16) | (b << 8) | c
|
|
|
|
|
|
fg = jn(120, 220, 255)
|
|
gd = jn(170, 240, 255)
|
|
ik = jn(240, 248, 255)
|
|
fk = jn(210, 224, 235)
|
|
ja = jn(150, 160, 170)
|
|
gf = jn(80, 255, 160)
|
|
fe = jn(0, 180, 120)
|
|
dt = jn(255, 70, 70)
|
|
dr = jn(180, 20, 20)
|
|
cz = jn(200, 80, 255)
|
|
cw = jn(255, 176, 32)
|
|
fq = jn(0, 80, 110)
|
|
fh = jn(6, 8, 12)
|
|
|
|
hx = "your helpful assistant"
|
|
hc = 'say "HEY DOT"'
|
|
|
|
gg = [
|
|
(28, "> boot sequence initiated"),
|
|
(52, "> searching for cortana.exe ... not found"),
|
|
(72, "> good."),
|
|
(92, "> loading personality ..... done"),
|
|
(112, "> calibrating microphone ..."),
|
|
(132, "> DOT is online"),
|
|
]
|
|
|
|
hs = ctypes.c_ssize_t
|
|
hz = ctypes.WINFUNCTYPE(
|
|
hs, wintypes.HWND, wintypes.UINT, wintypes.WPARAM, wintypes.LPARAM)
|
|
|
|
hm.GetModuleHandleW.restype = wintypes.HMODULE
|
|
hm.GetModuleHandleW.argtypes = [wintypes.LPCWSTR]
|
|
ij.DefWindowProcW.restype = hs
|
|
ij.DefWindowProcW.argtypes = [
|
|
wintypes.HWND, wintypes.UINT, wintypes.WPARAM, wintypes.LPARAM]
|
|
ij.CreateWindowExW.restype = wintypes.HWND
|
|
ij.CreateWindowExW.argtypes = [
|
|
wintypes.DWORD, wintypes.LPCWSTR, wintypes.LPCWSTR, wintypes.DWORD,
|
|
ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int,
|
|
wintypes.HWND, wintypes.HMENU, wintypes.HINSTANCE, wintypes.LPVOID]
|
|
ij.SetTimer.argtypes = [
|
|
wintypes.HWND, ctypes.c_size_t, wintypes.UINT, ctypes.c_void_p]
|
|
ij.KillTimer.argtypes = [wintypes.HWND, ctypes.c_size_t]
|
|
ij.LoadCursorW.restype = wintypes.HANDLE
|
|
ij.LoadCursorW.argtypes = [wintypes.HINSTANCE, ctypes.c_void_p]
|
|
ij.BeginPaint.restype = wintypes.HDC
|
|
ij.GetDC.restype = wintypes.HDC
|
|
ij.DrawTextW.argtypes = [
|
|
wintypes.HDC, wintypes.LPCWSTR, ctypes.c_int,
|
|
ctypes.POINTER(wintypes.RECT), wintypes.UINT]
|
|
ij.FillRect.argtypes = [
|
|
wintypes.HDC, ctypes.POINTER(wintypes.RECT), wintypes.HBRUSH]
|
|
ix.CreateSolidBrush.restype = wintypes.HBRUSH
|
|
ix.CreatePen.restype = ctypes.c_void_p
|
|
ix.SelectObject.restype = ctypes.c_void_p
|
|
ix.SelectObject.argtypes = [wintypes.HDC, ctypes.c_void_p]
|
|
ix.GetStockObject.restype = ctypes.c_void_p
|
|
ix.DeleteObject.argtypes = [ctypes.c_void_p]
|
|
ix.CreateCompatibleDC.restype = wintypes.HDC
|
|
ix.CreateCompatibleBitmap.restype = ctypes.c_void_p
|
|
ix.CreateFontW.restype = ctypes.c_void_p
|
|
ix.CreateFontW.argtypes = [ctypes.c_int] * 13 + [wintypes.LPCWSTR]
|
|
ix.TextOutW.argtypes = [
|
|
wintypes.HDC, ctypes.c_int, ctypes.c_int, wintypes.LPCWSTR, ctypes.c_int]
|
|
ix.BitBlt.argtypes = [
|
|
wintypes.HDC, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int,
|
|
wintypes.HDC, ctypes.c_int, ctypes.c_int, wintypes.DWORD]
|
|
ix.MoveToEx.argtypes = [
|
|
wintypes.HDC, ctypes.c_int, ctypes.c_int, ctypes.c_void_p]
|
|
|
|
|
|
class gm(ctypes.Structure):
|
|
_fields_ = [
|
|
("style", wintypes.UINT), ("lpfnWndProc", hz),
|
|
("cbClsExtra", ctypes.c_int), ("cbWndExtra", ctypes.c_int),
|
|
("hInstance", wintypes.HINSTANCE), ("hIcon", wintypes.HICON),
|
|
("hCursor", wintypes.HANDLE), ("hbrBackground", wintypes.HBRUSH),
|
|
("lpszMenuName", wintypes.LPCWSTR), ("lpszClassName", wintypes.LPCWSTR)]
|
|
|
|
|
|
class eb(ctypes.Structure):
|
|
_fields_ = [
|
|
("hdc", wintypes.HDC), ("fErase", wintypes.BOOL),
|
|
("rcPaint", wintypes.RECT), ("fRestore", wintypes.BOOL),
|
|
("fIncUpdate", wintypes.BOOL), ("rgbReserved", ctypes.c_byte * 32)]
|
|
|
|
|
|
class bs(ctypes.Structure):
|
|
_fields_ = [("BlendOp", ctypes.c_ubyte), ("BlendFlags", ctypes.c_ubyte),
|
|
("SourceConstantAlpha", ctypes.c_ubyte),
|
|
("AlphaFormat", ctypes.c_ubyte)]
|
|
|
|
|
|
class ag(ctypes.Structure):
|
|
_fields_ = [
|
|
("biSize", wintypes.DWORD), ("biWidth", ctypes.c_long),
|
|
("biHeight", ctypes.c_long), ("biPlanes", wintypes.WORD),
|
|
("biBitCount", wintypes.WORD), ("biCompression", wintypes.DWORD),
|
|
("biSizeImage", wintypes.DWORD), ("biXPelsPerMeter", ctypes.c_long),
|
|
("biYPelsPerMeter", ctypes.c_long), ("biClrUsed", wintypes.DWORD),
|
|
("biClrImportant", wintypes.DWORD)]
|
|
|
|
|
|
class fd(ctypes.Structure):
|
|
_fields_ = [("bmiHeader", ag),
|
|
("bmiColors", wintypes.DWORD * 3)]
|
|
|
|
|
|
class il(ctypes.Structure):
|
|
_fields_ = [("Data1", ctypes.c_ulong), ("Data2", ctypes.c_ushort),
|
|
("Data3", ctypes.c_ushort), ("Data4", ctypes.c_ubyte * 8)]
|
|
|
|
def __init__(self, s):
|
|
super().__init__()
|
|
ic.CLSIDFromString(s, ctypes.byref(self))
|
|
|
|
|
|
ic.CLSIDFromString.argtypes = [ctypes.c_wchar_p, ctypes.POINTER(il)]
|
|
ij.UpdateLayeredWindow.argtypes = [
|
|
wintypes.HWND, wintypes.HDC, ctypes.POINTER(wintypes.POINT),
|
|
ctypes.POINTER(wintypes.SIZE), wintypes.HDC,
|
|
ctypes.POINTER(wintypes.POINT), wintypes.COLORREF,
|
|
ctypes.POINTER(bs), wintypes.DWORD]
|
|
ix.CreateDIBSection.restype = ctypes.c_void_p
|
|
ix.CreateDIBSection.argtypes = [
|
|
wintypes.HDC, ctypes.POINTER(fd), wintypes.UINT,
|
|
ctypes.POINTER(ctypes.c_void_p), ctypes.c_void_p, wintypes.DWORD]
|
|
ij.BeginPaint.argtypes = [wintypes.HWND, ctypes.POINTER(eb)]
|
|
ij.EndPaint.argtypes = [wintypes.HWND, ctypes.POINTER(eb)]
|
|
ij.GetDC.argtypes = [wintypes.HWND]
|
|
ij.ReleaseDC.argtypes = [wintypes.HWND, wintypes.HDC]
|
|
ij.InvalidateRect.argtypes = [wintypes.HWND, ctypes.c_void_p, wintypes.BOOL]
|
|
ij.SetLayeredWindowAttributes.argtypes = [
|
|
wintypes.HWND, wintypes.COLORREF, ctypes.c_ubyte, wintypes.DWORD]
|
|
ij.ShowWindow.argtypes = [wintypes.HWND, ctypes.c_int]
|
|
ij.DestroyWindow.argtypes = [wintypes.HWND]
|
|
ij.SetWindowPos.argtypes = [
|
|
wintypes.HWND, wintypes.HWND, ctypes.c_int, ctypes.c_int,
|
|
ctypes.c_int, ctypes.c_int, wintypes.UINT]
|
|
ix.SetBkMode.argtypes = [wintypes.HDC, ctypes.c_int]
|
|
ix.SetTextColor.argtypes = [wintypes.HDC, wintypes.COLORREF]
|
|
ix.SetPixel.argtypes = [wintypes.HDC, ctypes.c_int, ctypes.c_int,
|
|
wintypes.COLORREF]
|
|
ix.Ellipse.argtypes = [wintypes.HDC] + [ctypes.c_int] * 4
|
|
ix.Rectangle.argtypes = [wintypes.HDC] + [ctypes.c_int] * 4
|
|
ix.LineTo.argtypes = [wintypes.HDC, ctypes.c_int, ctypes.c_int]
|
|
ix.Arc.argtypes = [wintypes.HDC] + [ctypes.c_int] * 8
|
|
ix.CreateCompatibleDC.argtypes = [wintypes.HDC]
|
|
ix.CreateCompatibleBitmap.argtypes = [wintypes.HDC, ctypes.c_int,
|
|
ctypes.c_int]
|
|
|
|
iz = {
|
|
"overlay": None, "orb": None, "caption_win": None,
|
|
"memdc": None, "membmp": None, "memdc2": None, "membmp2": None,
|
|
"orb_dc": None, "orb_bits": None,
|
|
"f": 0, "dock_start": None, "phase": 0.0, "ping": 0.0,
|
|
"heard": False, "voice_fail": False, "confirm_start": None,
|
|
"resident": False, "res_f": 0,
|
|
"scr_w": 0, "scr_h": 0, "dock_x": 0, "dock_y": 0,
|
|
"orb_x": 0.0, "orb_y": 0.0, "tgt_x": 0.0, "tgt_y": 0.0,
|
|
"orb_scale": 1.0, "hinstance": None,
|
|
"fonts": {}, "brushes": {}, "pens": {},
|
|
"stars": [], "rmap": [], "n_buckets": 0,
|
|
"busy": False, "caption": "", "cap_until": 0, "cap_color": ik,
|
|
"mode": "idle", "mode_f": 0, "prog": 0.0, "glitch": 0.0,
|
|
"clones": [], "beam": 0.0, "shake": 0.0, "accent": 0.0,
|
|
"last_mouse": (0, 0), "mouse_react_at": 0,
|
|
"windows": [], "log_feed": [], "banner": "", "banner_color": dt,
|
|
"flash": 0.0, "blackout": 0.0, "eye": 0.0, "stage": 0,
|
|
"vignette": 0.0, "static": 0.0, "countdown": None, "typed": "",
|
|
}
|
|
|
|
df = [(dx, dy, math.exp(-(dx * dx + dy * dy) / 3.2))
|
|
for dx in range(-2, 3) for dy in range(-2, 3)]
|
|
|
|
|
|
def iw(c, b, a):
|
|
return max(b, min(a, c))
|
|
|
|
|
|
def ck(c):
|
|
a, b = 1.70158, 2.70158
|
|
return 1 + b * (c - 1) ** 3 + a * (c - 1) ** 2
|
|
|
|
|
|
def cj(a):
|
|
return a * a * a
|
|
|
|
|
|
fj = os.path.join(
|
|
os.environ.get("SystemRoot", r"C:\Windows"),
|
|
"System32", "WindowsPowerShell", "v1.0", "powershell.exe")
|
|
if not os.path.exists(fj):
|
|
fj = "powershell"
|
|
|
|
fu = r'''
|
|
param([string]$TextPath, [string]$VoiceName)
|
|
try {
|
|
Add-Type -AssemblyName System.Runtime.WindowsRuntime | Out-Null
|
|
$null = [Windows.Media.SpeechSynthesis.SpeechSynthesizer,Windows.Media,ContentType=WindowsRuntime]
|
|
$null = [Windows.Storage.Streams.DataReader,Windows.Storage.Streams,ContentType=WindowsRuntime]
|
|
$asTask = ([System.WindowsRuntimeSystemExtensions].GetMethods() |
|
|
Where-Object { $_.Name -eq 'AsTask' -and $_.GetParameters().Count -eq 1 -and
|
|
$_.GetParameters()[0].ParameterType.Name -eq 'IAsyncOperation`1' })[0]
|
|
function Await($op,$t){ $task=$asTask.MakeGenericMethod($t).Invoke($null,@($op)); $task.Wait(); $task.Result }
|
|
$text = [System.IO.File]::ReadAllText($TextPath)
|
|
$syn = New-Object Windows.Media.SpeechSynthesis.SpeechSynthesizer
|
|
$v = [Windows.Media.SpeechSynthesis.SpeechSynthesizer]::AllVoices |
|
|
Where-Object { $_.DisplayName -like "*$VoiceName*" } | Select-Object -First 1
|
|
if ($v) { $syn.Voice = $v }
|
|
$stream = Await ($syn.SynthesizeTextToStreamAsync($text)) ([Windows.Media.SpeechSynthesis.SpeechSynthesisStream])
|
|
$reader = New-Object Windows.Storage.Streams.DataReader($stream)
|
|
Await ($reader.LoadAsync([uint32]$stream.Size)) ([uint32]) | Out-Null
|
|
$bytes = New-Object byte[] ([int]$stream.Size)
|
|
$reader.ReadBytes($bytes)
|
|
$wav = [System.IO.Path]::GetTempFileName() + '.wav'
|
|
[System.IO.File]::WriteAllBytes($wav, $bytes)
|
|
(New-Object System.Media.SoundPlayer $wav).PlaySync()
|
|
Remove-Item $wav -ErrorAction SilentlyContinue
|
|
} catch {
|
|
Add-Type -AssemblyName System.Speech
|
|
(New-Object System.Speech.Synthesis.SpeechSynthesizer).Speak([System.IO.File]::ReadAllText($TextPath))
|
|
}
|
|
'''
|
|
|
|
|
|
def iy(a):
|
|
if not a:
|
|
return
|
|
try:
|
|
c = os.path.join(os.environ.get("TEMP", "."),
|
|
"dot_say_%d.txt" % threading.get_ident())
|
|
with open(c, "w", encoding="utf-8") as d:
|
|
d.write(a)
|
|
b = os.path.join(os.environ.get("TEMP", "."), "dot_tts.ps1")
|
|
if not os.path.exists(b):
|
|
with open(b, "w", encoding="utf-8") as d:
|
|
d.write(fu)
|
|
subprocess.run([fj, "-NoProfile", "-ExecutionPolicy", "Bypass",
|
|
"-File", b, "-TextPath", c, "-VoiceName", "Mark"],
|
|
creationflags=ah, check=False)
|
|
except OSError as e:
|
|
print("[voice] TTS failed:", e)
|
|
|
|
|
|
def gt(b, a=True):
|
|
threading.Thread(target=iy, args=(b,), daemon=a).start()
|
|
|
|
|
|
def ib(c, a=4.0, b=ik):
|
|
iz["caption"] = c
|
|
iz["cap_until"] = time.time() + a
|
|
iz["cap_color"] = b
|
|
|
|
|
|
ic.WindowsCreateString.argtypes = [
|
|
ctypes.c_wchar_p, ctypes.c_uint32, ctypes.POINTER(ctypes.c_void_p)]
|
|
ic.WindowsCreateString.restype = ctypes.c_int32
|
|
ic.WindowsDeleteString.argtypes = [ctypes.c_void_p]
|
|
ic.WindowsGetStringRawBuffer.argtypes = [
|
|
ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint32)]
|
|
ic.WindowsGetStringRawBuffer.restype = ctypes.c_wchar_p
|
|
ic.RoActivateInstance.argtypes = [ctypes.c_void_p,
|
|
ctypes.POINTER(ctypes.c_void_p)]
|
|
ic.RoActivateInstance.restype = ctypes.c_int32
|
|
ic.RoInitialize.argtypes = [ctypes.c_int32]
|
|
ic.RoInitialize.restype = ctypes.c_int32
|
|
|
|
l = 10
|
|
dg = 11
|
|
ak = 7
|
|
af = 7
|
|
z = 8
|
|
fv = False
|
|
|
|
|
|
def go(e, c, b, a, *d):
|
|
f = ctypes.cast(e, ctypes.POINTER(ctypes.c_void_p))[0]
|
|
g = ctypes.cast(f, ctypes.POINTER(ctypes.c_void_p))[c]
|
|
return ctypes.WINFUNCTYPE(b, ctypes.c_void_p, *a)(g)(
|
|
e, *d)
|
|
|
|
|
|
def hj(b):
|
|
a = ctypes.c_void_p()
|
|
ic.WindowsCreateString(b, len(b), ctypes.byref(a))
|
|
return a
|
|
|
|
|
|
def dk(a):
|
|
if not a:
|
|
return ""
|
|
b = ctypes.c_uint32()
|
|
return ic.WindowsGetStringRawBuffer(a, ctypes.byref(b)) or ""
|
|
|
|
|
|
def cf():
|
|
global fv
|
|
if not fv:
|
|
try:
|
|
ic.RoInitialize(u)
|
|
except OSError:
|
|
pass
|
|
fv = True
|
|
|
|
|
|
def ii(c, a=15):
|
|
d = ctypes.c_void_p()
|
|
e = il("{00000036-0000-0000-C000-000000000046}")
|
|
if go(c, 0, ctypes.HRESULT,
|
|
[ctypes.POINTER(il), ctypes.POINTER(ctypes.c_void_p)],
|
|
ctypes.byref(e), ctypes.byref(d)) != 0:
|
|
d = c
|
|
b = time.monotonic() + a
|
|
while time.monotonic() < b:
|
|
g = ctypes.c_int32()
|
|
go(d, af, ctypes.HRESULT,
|
|
[ctypes.POINTER(ctypes.c_int32)], ctypes.byref(g))
|
|
if g.value == 1:
|
|
f = ctypes.c_void_p()
|
|
go(c, z, ctypes.HRESULT,
|
|
[ctypes.POINTER(ctypes.c_void_p)], ctypes.byref(f))
|
|
return f
|
|
if g.value in (2, 3):
|
|
return None
|
|
time.sleep(0.03)
|
|
try:
|
|
go(d, 9, ctypes.HRESULT, [])
|
|
except OSError:
|
|
pass
|
|
return None
|
|
|
|
|
|
def bk(a=8):
|
|
cf()
|
|
e = hj("Windows.Media.SpeechRecognition.SpeechRecognizer")
|
|
f = ctypes.c_void_p()
|
|
g = ic.RoActivateInstance(e, ctypes.byref(f))
|
|
ic.WindowsDeleteString(e)
|
|
if g != 0 or not f.value:
|
|
return None
|
|
try:
|
|
d = ctypes.c_void_p()
|
|
if go(f, l, ctypes.HRESULT,
|
|
[ctypes.POINTER(ctypes.c_void_p)],
|
|
ctypes.byref(d)) != 0:
|
|
return None
|
|
ii(d, 6)
|
|
h = ctypes.c_void_p()
|
|
if go(f, dg, ctypes.HRESULT,
|
|
[ctypes.POINTER(ctypes.c_void_p)], ctypes.byref(h)) != 0:
|
|
return None
|
|
b = ii(h, a + 4)
|
|
if not b or not b.value:
|
|
return None
|
|
c = ctypes.c_void_p()
|
|
go(b, ak, ctypes.HRESULT,
|
|
[ctypes.POINTER(ctypes.c_void_p)], ctypes.byref(c))
|
|
return (dk(c) or "").strip() or None
|
|
except OSError as e:
|
|
if "80045509" in str(e) or "80045" in str(e):
|
|
iz["voice_fail"] = True
|
|
return None
|
|
finally:
|
|
go(f, 2, ctypes.HRESULT, [])
|
|
|
|
|
|
bv = ("hey dot", "hi dot", "hey dott", "ey dot", "a dot",
|
|
"hey daught", "hey dark", "hey", "dot", "a note")
|
|
|
|
|
|
def fy(a):
|
|
b = (a or "").lower()
|
|
return any(p in b for p in bv)
|
|
|
|
|
|
def cv():
|
|
for b in range(40):
|
|
if iz["heard"] or iz["voice_fail"]:
|
|
return
|
|
a = bk(a=7)
|
|
if a:
|
|
print("[voice] heard:", repr(a))
|
|
if fy(a):
|
|
iz["heard"] = True
|
|
return
|
|
iz["voice_fail"] = True
|
|
|
|
|
|
def bo():
|
|
threading.Thread(target=cv, daemon=True).start()
|
|
|
|
|
|
def iv(a):
|
|
c = iz["brushes"].get(a)
|
|
if c is None:
|
|
c = iz["brushes"][a] = ix.CreateSolidBrush(a)
|
|
return c
|
|
|
|
|
|
def jm(a, b=1):
|
|
c = iz["pens"].get((a, b))
|
|
if c is None:
|
|
c = iz["pens"][(a, b)] = ix.CreatePen(
|
|
hb, b, a)
|
|
return c
|
|
|
|
|
|
def cl(b, f, g, e, a):
|
|
c = ix.SelectObject(b, iv(a))
|
|
d = ix.SelectObject(b, ix.GetStockObject(gz))
|
|
ix.Ellipse(b, int(f - e), int(g - e), int(f + e + 1), int(g + e + 1))
|
|
ix.SelectObject(b, c)
|
|
ix.SelectObject(b, d)
|
|
|
|
|
|
def bj(b, g, h, e, f, a):
|
|
c = ix.SelectObject(b, iv(a))
|
|
d = ix.SelectObject(b, ix.GetStockObject(gz))
|
|
ix.Ellipse(b, int(g - e), int(h - f), int(g + e + 1),
|
|
int(h + f + 1))
|
|
ix.SelectObject(b, c)
|
|
ix.SelectObject(b, d)
|
|
|
|
|
|
def cn(c, g, h, f, a, b=3):
|
|
e = ix.SelectObject(c, jm(a, b))
|
|
d = ix.SelectObject(c, ix.GetStockObject(db))
|
|
ix.Ellipse(c, int(g - f), int(h - f), int(g + f + 1), int(h + f + 1))
|
|
ix.SelectObject(c, d)
|
|
ix.SelectObject(c, e)
|
|
|
|
|
|
def eq(b, c, e, d, f, a):
|
|
g = wintypes.RECT(int(c), int(e), int(d), int(f))
|
|
ij.FillRect(b, ctypes.byref(g), iv(a))
|
|
|
|
|
|
def jl(c, d, f, e, g, a, b=1):
|
|
h = ix.SelectObject(c, jm(a, b))
|
|
ix.MoveToEx(c, int(d), int(f), None)
|
|
ix.LineTo(c, int(e), int(g))
|
|
ix.SelectObject(c, h)
|
|
|
|
|
|
def es(c, d, f, e, g, a, b=2):
|
|
jl(c, d, f, e, f, a, b)
|
|
jl(c, e, f, e, g, a, b)
|
|
jl(c, e, g, d, g, a, b)
|
|
jl(c, d, g, d, f, a, b)
|
|
|
|
|
|
def hk(e, n, o, m, d, c, a, b=2):
|
|
g = ix.SelectObject(e, jm(a, b))
|
|
f = ix.SelectObject(e, ix.GetStockObject(db))
|
|
i, k = n + m * math.cos(d), o + m * math.sin(d)
|
|
h, j = n + m * math.cos(d + c), o + m * math.sin(d + c)
|
|
ix.Arc(e, int(n - m), int(o - m), int(n + m), int(o + m),
|
|
int(i), int(k), int(h), int(j))
|
|
ix.SelectObject(e, f)
|
|
ix.SelectObject(e, g)
|
|
|
|
|
|
def hp(c, f, g, e, b, a):
|
|
ix.SetTextColor(c, a)
|
|
d = ix.SelectObject(c, iz["fonts"][b])
|
|
ix.TextOutW(c, int(f), int(g), e, len(e))
|
|
ix.SelectObject(c, d)
|
|
|
|
|
|
def ew(f, e, a, h, c, b):
|
|
d = wintypes.RECT(0, e, iz["scr_w"], a)
|
|
ix.SetTextColor(f, b)
|
|
g = ix.SelectObject(f, iz["fonts"][c])
|
|
ij.DrawTextW(f, h, -1, ctypes.byref(d), gc)
|
|
ix.SelectObject(f, g)
|
|
|
|
|
|
def cg(e, k, m, i, a=None):
|
|
d, c, b = (0, 188, 242) if a is None else a
|
|
for g in range(14, 0, -1):
|
|
j = g / 14
|
|
f = i * (1 + 1.5 * j)
|
|
h = (1 - j) ** 2 * 0.6
|
|
cl(e, k, m, f, jn(int(d * h), int(c * h),
|
|
int(b * h)))
|
|
cl(e, k, m, i, jn(d, c, b))
|
|
cn(e, k, m, i * 0.99, gd, 2)
|
|
cl(e, k, m, i * 0.55, 0)
|
|
|
|
|
|
def ao(g, w, x, s, o, b=1.0, c=(0, 140, 190)):
|
|
d = jn(*c)
|
|
e = jn(int(c[0] * 0.7), int(c[1] * 0.7), int(c[2] * 0.7))
|
|
hk(g, w, x, s * 1.55 * b, o * 0.07, 1.9, d, 2)
|
|
hk(g, w, x, s * 1.55 * b, o * 0.07 + math.pi, 1.9, d, 2)
|
|
hk(g, w, x, s * 1.95 * b, -o * 0.045, 1.2, e, 2)
|
|
hk(g, w, x, s * 1.95 * b, -o * 0.045 + 2.6, 1.2, e, 2)
|
|
for n in range(3):
|
|
a = n * 1.047
|
|
f, m = math.cos(a), math.sin(a)
|
|
for p in range(6):
|
|
v = o * 0.11 + n * 2.094 - p * 0.10
|
|
h = s * 1.55 * b * math.cos(v)
|
|
i = s * 0.58 * b * math.sin(v)
|
|
j = w + h * f - i * m
|
|
k = x + h * m + i * f
|
|
r = 5 - p
|
|
cl(g, j, k, max(1.2, 3.6 - 0.5 * p),
|
|
jn(6 * r, 8 * r, 9 * r))
|
|
|
|
|
|
def bi(b, h):
|
|
j = iz["scr_w"]
|
|
for e, f, d, c in iz["stars"]:
|
|
g = 0.5 + 0.5 * math.sin(h * 0.045 * d + c)
|
|
i = int((0.35 + 0.65 * g) * 10)
|
|
a = jn(12 * i, 18 * i, 22 * i)
|
|
k = int((e + h * 0.15 * d) % j)
|
|
ix.SetPixel(b, k, int(f), a)
|
|
if d > 1.4:
|
|
ix.SetPixel(b, k + 1, int(f), a)
|
|
|
|
|
|
def fx(d, e, a):
|
|
k, f = iz["scr_w"], iz["scr_h"]
|
|
c = k // 2
|
|
b = (e * 0.1) % 1.0
|
|
for g in range(15):
|
|
j = (g + b) / 14
|
|
if j > 1:
|
|
continue
|
|
m = a + (f - a) * (j ** 1.7)
|
|
i = int(j * 14)
|
|
jl(d, 0, m, k, m, jn(0, 3 * i + 6, 4 * i + 10))
|
|
for h in range(-9, 10):
|
|
jl(d, c + h * 18, a, c + h * (k // 10), f, jn(0, 26, 36))
|
|
jl(d, 0, a, k, a, jn(0, 60, 80))
|
|
|
|
|
|
def en(b, g):
|
|
p, i = iz["scr_w"], iz["scr_h"]
|
|
for j in range(5):
|
|
e = g * (0.006 + j * 0.002) + j * 1.3
|
|
c = p * (0.5 + 0.32 * math.sin(e * 1.1 + j))
|
|
d = i * (0.42 + 0.22 * math.cos(e * 0.9 + j * 2))
|
|
a = 220 + 60 * math.sin(e + j)
|
|
for m in range(6, 0, -1):
|
|
o = m / 6
|
|
n = (1 - o) * 0.10
|
|
cl(b, c, d, a * o,
|
|
jn(int(6 * n * 10), int(18 * n * 10),
|
|
int(28 * n * 10)))
|
|
|
|
|
|
def ci(d, g):
|
|
m, i = iz["scr_w"], iz["scr_h"]
|
|
c = m // 2
|
|
e = i - 150
|
|
for j in range(28):
|
|
a = abs(math.sin(g * 0.31 + j * 1.7) * math.sin(g * 0.13 + j * 0.53))
|
|
b = 3 + 26 * a
|
|
k = int(a * 10)
|
|
jl(d, c - 224 + j * 16, e - b, c - 224 + j * 16, e + b,
|
|
jn(0, 80 + 10 * k, 110 + 13 * k), 6)
|
|
|
|
|
|
def be(c, a, b):
|
|
h, f = iz["scr_w"], iz["scr_h"]
|
|
g = int(28 * a)
|
|
for e in range(g):
|
|
d = random.randint(0, f - 1)
|
|
jl(c, 0, d, h, d, b, random.randint(1, 3))
|
|
|
|
|
|
def eo(b, a):
|
|
g, d = iz["scr_w"], iz["scr_h"]
|
|
e = int(600 * a)
|
|
for c in range(e):
|
|
h = random.randint(0, g - 1)
|
|
i = random.randint(0, d - 1)
|
|
f = random.randint(40, 220)
|
|
ix.SetPixel(b, h, i, jn(f, f, f))
|
|
|
|
|
|
def ch(e, a):
|
|
j, f = iz["scr_w"], iz["scr_h"]
|
|
c = 8
|
|
for g in range(c):
|
|
i = g / c
|
|
b = int(i * min(j, f) * 0.5)
|
|
h = int((1 - i) * a * 22)
|
|
if h <= 0:
|
|
continue
|
|
d = jn(h, 0, 0)
|
|
es(e, b, b, j - b, f - b, d, 6)
|
|
|
|
|
|
def gr(c, d, a):
|
|
f, e = iz["scr_w"], iz["scr_h"]
|
|
b = int(d * 1.5) % 48
|
|
for g in range(-48 + b, f, 48):
|
|
jl(c, g, 0, g, e, a, 1)
|
|
for h in range(-48 + b, e, 48):
|
|
jl(c, 0, h, f, h, a, 1)
|
|
|
|
|
|
def hl(c, f, g, e, a, b):
|
|
bj(c, f, g, e, e * a, fh)
|
|
cn(c, f, g, e, dt, 3)
|
|
if a > 0.15:
|
|
d = f + b * e * 0.4
|
|
cl(c, d, g, e * 0.42 * a, dt)
|
|
cl(c, d, g, e * 0.18 * a, fh)
|
|
|
|
|
|
def el():
|
|
d = iz["accent"]
|
|
c = int(0 + 200 * d)
|
|
b = int(188 - 120 * d)
|
|
a = int(242 - 60 * d)
|
|
return c, b, a
|
|
|
|
|
|
def an():
|
|
e = iz["phase"]
|
|
k = iz["ping"]
|
|
f = iz["orb_scale"]
|
|
h = 46 * f
|
|
a = h + 4 * math.sin(e) + 14 * k
|
|
a = min(a, hu / 2 - 6)
|
|
b = 6.5 + 1.5 * math.sin(e * 0.53 + 1.3)
|
|
c = 1 + 0.6 * k
|
|
r, q, p = el()
|
|
g = []
|
|
for x in range(iz["n_buckets"]):
|
|
bb = x * 0.5
|
|
bf = math.exp(-(((bb - a) / b) ** 2))
|
|
j = 0.22 * math.exp(-(((bb - a) / (b * 3.5)) ** 2))
|
|
i = 0.30 * math.exp(-((bb / (a * 0.5 + 1)) ** 4))
|
|
d = min(1.0, (bf + j + i) * c)
|
|
if d < 0.004:
|
|
g.append(b"\x00\x00\x00\x00")
|
|
continue
|
|
o = bf * bf
|
|
w = int(255 * d)
|
|
s = min(255, int((p + 13 * o) * d))
|
|
t = min(255, int((q + 62 * o) * d))
|
|
v = min(255, int((r + 230 * o) * d))
|
|
g.append(bytes((s, t, v, w)))
|
|
n = bytearray(b"".join([g[m] for m in iz["rmap"]]))
|
|
y = hu // 2
|
|
for bh in range(3):
|
|
for bg in range(5):
|
|
m = e * (1.6 + 2.2 * k) + bh * 2.094 - bg * 0.13
|
|
ga(n, int(y + a * math.cos(m)),
|
|
int(y + a * math.sin(m)), 0.65 ** bg)
|
|
return n
|
|
|
|
|
|
def ga(c, h, i, a):
|
|
for f, g, e in df:
|
|
m, n = h + f, i + g
|
|
if 0 <= m < hu and 0 <= n < hu:
|
|
j = (n * hu + m) * 4
|
|
b = int(255 * e * a)
|
|
for d in (0, 1, 2, 3):
|
|
k = c[j + d] + b
|
|
c[j + d] = 255 if k > 255 else k
|
|
|
|
|
|
def hn(a=255):
|
|
c = an()
|
|
ctypes.memmove(iz["orb_bits"], bytes(c), len(c))
|
|
g = int(iz["orb_x"])
|
|
h = int(iz["orb_y"] + round(4 * math.sin(iz["phase"] * 0.6)))
|
|
d = wintypes.POINT(g, h)
|
|
b = wintypes.SIZE(hu, hu)
|
|
e = wintypes.POINT(0, 0)
|
|
f = bs(0, 0, a, da)
|
|
ij.UpdateLayeredWindow(iz["orb"], None, ctypes.byref(d),
|
|
ctypes.byref(b), iz["orb_dc"],
|
|
ctypes.byref(e), 0, ctypes.byref(f),
|
|
gk)
|
|
|
|
|
|
def aj():
|
|
a = list(gg)
|
|
c = iz["f"]
|
|
b = iz["confirm_start"]
|
|
if (c >= de and b is None) or (b is not None
|
|
and b >= de):
|
|
a.append((de, '> waiting for wake word: "hey dot"'))
|
|
if b is not None:
|
|
if iz["voice_fail"] and not iz["heard"]:
|
|
a.append((b, "> microphone unavailable - proceeding anyway"))
|
|
else:
|
|
a.append((b, "> wake word detected: HEY DOT"))
|
|
a.append((b + 20, "> assistant link established"))
|
|
return a
|
|
|
|
|
|
def dp(t):
|
|
cb = iz["f"]
|
|
ex, cp = iz["scr_w"], iz["scr_h"]
|
|
r, s = ex // 2, cp // 2
|
|
b = s + 130
|
|
q = iz["confirm_start"]
|
|
|
|
k = wintypes.RECT(0, 0, ex, cp)
|
|
ij.FillRect(t, ctypes.byref(k), ix.GetStockObject(du))
|
|
ix.SetBkMode(t, at)
|
|
|
|
en(t, cb)
|
|
bi(t, cb)
|
|
fx(t, cb, b)
|
|
|
|
bb, bf, d = r, s, 64.0
|
|
if iz["dock_start"] is not None:
|
|
bx = iw((cb - iz["dock_start"]) / gu, 0.0, 1.0)
|
|
by = 1 - (1 - bx) ** 3
|
|
bb = r + (iz["dock_x"] + hu // 2 - r) * by
|
|
bf = s + (iz["dock_y"] + hu // 2 - s) * by
|
|
d = 64 + (46 - 64) * by
|
|
|
|
if cb <= ha:
|
|
dc = iw((cb - dw) / (ha - dw), 0.0, 1.0)
|
|
g = math.hypot(ex, cp) / 2
|
|
for cs in range(ea):
|
|
e = (cs % 27) / 27 * 0.35
|
|
bg = iw((dc - e) / (1 - e), 0.0, 1.0)
|
|
if bg >= 1.0:
|
|
continue
|
|
o = g * (1 - bg) ** 2
|
|
h = cs * ig + 2.6 * bg
|
|
cl(t, r + o * math.cos(h),
|
|
s + o * math.sin(h), 2.6, fg)
|
|
if dc > 0:
|
|
cg(t, r, s, 6 + 46 * cj(dc))
|
|
elif cb <= ff:
|
|
dy = (cb - ha) / (ff - ha)
|
|
dx = d * ck(dy)
|
|
v = cb - ha
|
|
for cx in range(3):
|
|
bh = v * 9 - cx * 45
|
|
if 0 < bh < 420:
|
|
ds = int(max(0.0, 1 - bh / 420) * 20)
|
|
cn(t, r, s, dx + bh,
|
|
jn(0, 188 * ds // 20, 242 * ds // 20), 3)
|
|
cg(t, r, s, dx)
|
|
ao(t, r, s, dx, cb, b=dy)
|
|
if v <= 12:
|
|
w = v / 12
|
|
ds = int((1 - w) * 16)
|
|
f = jn(14 * ds, 15 * ds, 16 * ds)
|
|
bj(t, r, s, (30 + 500 * w) * 2.4,
|
|
max(2, 6 * (1 - w)), f)
|
|
bj(t, r, s, max(2, 5 * (1 - w)),
|
|
(30 + 350 * w) * 1.6, f)
|
|
cl(t, r, s, 20 + 90 * w, f)
|
|
else:
|
|
a = cb >= de and q is None
|
|
if a:
|
|
i = cb - de
|
|
for cx in range(3):
|
|
bh = (i * 4 + cx * 53) % 160
|
|
ds = int((1 - bh / 160) * 10)
|
|
cn(t, bb, bf, d * 1.15 + bh,
|
|
jn(0, 12 * ds, 16 * ds), 2)
|
|
dx = d + 4 * math.sin(cb * 0.12)
|
|
cg(t, bb, bf, dx)
|
|
ao(t, bb, bf, d, cb)
|
|
if q is not None:
|
|
bw = cb - q
|
|
for cx in range(3):
|
|
bh = bw * 9 - cx * 40
|
|
if 0 < bh < 500:
|
|
ds = int(max(0.0, 1 - bh / 500) * 20)
|
|
cn(t, bb, bf, dx + bh,
|
|
jn(6 * ds, 11 * ds, 12 * ds), 3)
|
|
|
|
for m, (br, p) in enumerate(aj()):
|
|
if cb >= br:
|
|
cy = iw((cb - br) * 2, 0, len(p))
|
|
hp(t, 48, cp - 290 + m * 28, p[:cy], "log", gf)
|
|
|
|
if cb >= eg:
|
|
c = " ".join("DOT"[: iw((cb - eg) // 12 + 1, 1, 3)])
|
|
for x, y in ((-2, 0), (2, 0), (0, -2), (0, 2)):
|
|
ew(t, s + 95 + y, s + 240 + y, c, "title",
|
|
fq)
|
|
ew(t, s + 95, s + 240, c, "title", ik)
|
|
if cb >= gi:
|
|
cy = iw((cb - gi) * 2, 0, len(hx))
|
|
ew(t, s + 245, s + 300, hx[:cy], "tag", fg)
|
|
if cb >= gj and q is None:
|
|
if cb < de or (cb // 20) % 2 == 0:
|
|
ew(t, s + 320, s + 380, hc, "tut", ik)
|
|
if cb >= de and q is None:
|
|
ci(t, cb)
|
|
j = "." * (1 + (cb // 12) % 3)
|
|
ew(t, cp - 210, cp - 170, "listening " + j, "tag", ja)
|
|
if q is not None and cb <= q + dv:
|
|
n = ('proceeding without mic' if iz["voice_fail"]
|
|
and not iz["heard"] else '"HEY DOT" accepted')
|
|
ew(t, s + 320, s + 380, n, "tut", fg)
|
|
|
|
|
|
def et(a):
|
|
c = eb()
|
|
b = ij.BeginPaint(a, ctypes.byref(c))
|
|
dp(iz["memdc"])
|
|
ix.BitBlt(b, 0, 0, iz["scr_w"], iz["scr_h"],
|
|
iz["memdc"], 0, 0, hv)
|
|
ij.EndPaint(a, ctypes.byref(c))
|
|
|
|
|
|
def cq(a):
|
|
e = eb()
|
|
b = ij.BeginPaint(a, ctypes.byref(e))
|
|
g, f = iz["scr_w"], iz["scr_h"]
|
|
bm(iz["memdc2"])
|
|
if time.time() < iz["cap_until"] and iz["caption"]:
|
|
ix.SetBkMode(iz["memdc2"], at)
|
|
for c, d in ((2, 2), (-2, 2), (2, -2), (-2, -2)):
|
|
ew(iz["memdc2"], f - 252 + d, f - 200 + d,
|
|
iz["caption"], "cap", 0)
|
|
ew(iz["memdc2"], f - 252, f - 200, iz["caption"],
|
|
"cap", iz["cap_color"])
|
|
ix.BitBlt(b, 0, 0, g, f, iz["memdc2"], 0, 0, hv)
|
|
ij.EndPaint(a, ctypes.byref(e))
|
|
|
|
|
|
def ep(a, c=20):
|
|
b = iz["accent"]
|
|
for d in range(1, c + 1):
|
|
iz["accent"] = b + (a - b) * (d / c)
|
|
time.sleep(0.03)
|
|
|
|
|
|
def ac(g, a, b):
|
|
m, j = iz["scr_w"], iz["scr_h"]
|
|
k = int(18 * a)
|
|
for h in range(k):
|
|
e = random.randint(0, m - 1)
|
|
f = random.randint(0, j - 1)
|
|
d = random.randint(40, 260)
|
|
c = random.randint(4, 30)
|
|
i = b if random.random() < 0.5 else jn(
|
|
random.randint(0, 255), random.randint(0, 60),
|
|
random.randint(0, 60))
|
|
eq(g, e, f, e + d, f + c, i)
|
|
|
|
|
|
gv = 4
|
|
ef = 6
|
|
fo = 9
|
|
gw = 0
|
|
dz = 1
|
|
dd = -1
|
|
av = -2
|
|
fm = 0x0001
|
|
fl = 0x0002
|
|
dh = 0x0004
|
|
ax = 0x0010
|
|
|
|
ij.EnumWindows.argtypes = [
|
|
ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM),
|
|
wintypes.LPARAM]
|
|
ij.IsWindowVisible.argtypes = [wintypes.HWND]
|
|
ij.GetWindowTextW.argtypes = [wintypes.HWND, wintypes.LPWSTR, ctypes.c_int]
|
|
ij.GetWindowTextLengthW.argtypes = [wintypes.HWND]
|
|
ij.SetWindowTextW.argtypes = [wintypes.HWND, wintypes.LPCWSTR]
|
|
ij.GetWindowRect.argtypes = [wintypes.HWND, ctypes.POINTER(wintypes.RECT)]
|
|
ij.GetWindow.argtypes = [wintypes.HWND, wintypes.UINT]
|
|
ij.GetWindow.restype = wintypes.HWND
|
|
ij.GetWindowLongW.argtypes = [wintypes.HWND, ctypes.c_int]
|
|
ij.GetWindowLongW.restype = ctypes.c_long
|
|
ij.IsIconic.argtypes = [wintypes.HWND]
|
|
ij.GetForegroundWindow.restype = wintypes.HWND
|
|
ij.GetShellWindow.restype = wintypes.HWND
|
|
ij.GetCursorPos.argtypes = [ctypes.POINTER(wintypes.POINT)]
|
|
ij.SetCursorPos.argtypes = [ctypes.c_int, ctypes.c_int]
|
|
ij.GetAsyncKeyState.argtypes = [ctypes.c_int]
|
|
ij.GetAsyncKeyState.restype = ctypes.c_short
|
|
|
|
ba = {}
|
|
gq = threading.Lock()
|
|
|
|
|
|
def ae():
|
|
found = []
|
|
shell = ij.GetShellWindow()
|
|
|
|
def cb(hwnd, lparam):
|
|
if hwnd == shell:
|
|
return True
|
|
if not ij.IsWindowVisible(hwnd):
|
|
return True
|
|
owner = ij.GetWindow(hwnd, gv)
|
|
if owner:
|
|
return True
|
|
length = ij.GetWindowTextLengthW(hwnd)
|
|
if length == 0:
|
|
return True
|
|
buf = ctypes.create_unicode_buffer(length + 1)
|
|
ij.GetWindowTextW(hwnd, buf, length + 1)
|
|
title = buf.value
|
|
if not title.strip():
|
|
return True
|
|
found.append((hwnd, title))
|
|
return True
|
|
|
|
proc = ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM)(cb)
|
|
ij.EnumWindows(proc, 0)
|
|
return found
|
|
|
|
|
|
def aa(a=True):
|
|
e = ae()
|
|
d = {iz.get("orb"), iz.get("overlay"), iz.get("caption_win")}
|
|
f = []
|
|
for c, b in e:
|
|
if a and c in d:
|
|
continue
|
|
if b in ("Program Manager", "Windows Input Experience"):
|
|
continue
|
|
f.append((c, b))
|
|
return f
|
|
|
|
|
|
def gp(b):
|
|
with gq:
|
|
if b in ba:
|
|
return
|
|
d = wintypes.RECT()
|
|
ij.GetWindowRect(b, ctypes.byref(d))
|
|
a = ij.GetWindowTextLengthW(b)
|
|
c = ctypes.create_unicode_buffer(a + 1)
|
|
ij.GetWindowTextW(b, c, a + 1)
|
|
ba[b] = {
|
|
"rect": (d.left, d.top, d.right - d.left, d.bottom - d.top),
|
|
"title": c.value,
|
|
}
|
|
|
|
|
|
def dn(a, b, c):
|
|
gp(a)
|
|
d = wintypes.RECT()
|
|
if not ij.GetWindowRect(a, ctypes.byref(d)):
|
|
return
|
|
ij.SetWindowPos(a, None, d.left + b, d.top + c, 0, 0,
|
|
fm | dh | ax)
|
|
|
|
|
|
def co(b, a=18):
|
|
dn(b, random.randint(-a, a),
|
|
random.randint(-a, a))
|
|
|
|
|
|
def cr(a, d, b):
|
|
gp(a)
|
|
c = wintypes.RECT()
|
|
if not ij.GetWindowRect(a, ctypes.byref(c)):
|
|
return
|
|
ij.SetWindowPos(a, None, 0, 0, max(80, d), max(60, b),
|
|
fl | dh | ax)
|
|
|
|
|
|
def bd(b, a=0.7):
|
|
d = wintypes.RECT()
|
|
if not ij.GetWindowRect(b, ctypes.byref(d)):
|
|
return
|
|
e = max(80, int((d.right - d.left) * a))
|
|
c = max(60, int((d.bottom - d.top) * a))
|
|
cr(b, e, c)
|
|
|
|
|
|
def ap(a):
|
|
gp(a)
|
|
ij.ShowWindow(a, ef)
|
|
|
|
|
|
def dq(a):
|
|
ij.SetWindowPos(a, dz, 0, 0, 0, 0,
|
|
fm | fl | ax)
|
|
|
|
|
|
def bc(a):
|
|
ij.SetWindowPos(a, gw, 0, 0, 0, 0,
|
|
fm | fl | ax)
|
|
|
|
|
|
def cm(a):
|
|
ij.SetWindowPos(a, dd, 0, 0, 0, 0,
|
|
fm | fl | ax)
|
|
ij.SetWindowPos(a, av, 0, 0, 0, 0,
|
|
fm | fl | ax)
|
|
|
|
|
|
def bn(a, b):
|
|
gp(a)
|
|
ij.SetWindowTextW(a, b)
|
|
|
|
|
|
def ab():
|
|
with gq:
|
|
a = list(ba.items())
|
|
for b, c in a:
|
|
try:
|
|
f, g, e, d = c["rect"]
|
|
ij.ShowWindow(b, fo)
|
|
ij.SetWindowPos(b, None, f, g, e, d,
|
|
dh | ax)
|
|
if c["title"]:
|
|
ij.SetWindowTextW(b, c["title"])
|
|
except OSError:
|
|
pass
|
|
with gq:
|
|
ba.clear()
|
|
|
|
|
|
def aq():
|
|
a = wintypes.POINT()
|
|
ij.GetCursorPos(ctypes.byref(a))
|
|
return a.x, a.y
|
|
|
|
|
|
bu = [
|
|
"watching", "reorganizing", "not yours anymore", "processing",
|
|
"known", "indexed", "still here", "under review", "categorized",
|
|
]
|
|
|
|
|
|
ee = ["calm", "attentive", "assertive", "insistent", "total"]
|
|
|
|
|
|
def em():
|
|
a = iz.get("context_gain", 0.0)
|
|
b = [fg, fk, cw, dt, dr]
|
|
c = min(int(a * len(b)), len(b) - 1)
|
|
return b[c]
|
|
|
|
|
|
def bp():
|
|
a = min(1.0, iz.get("context_gain", 0.0) + 0.05)
|
|
iz["context_gain"] = a
|
|
ep(a, c=10)
|
|
|
|
|
|
def do(b=1):
|
|
a = aa()
|
|
if not a:
|
|
return []
|
|
random.shuffle(a)
|
|
return a[:b]
|
|
|
|
|
|
def jb(a):
|
|
co(a, a=22)
|
|
|
|
|
|
def jc(a):
|
|
cm(a)
|
|
|
|
|
|
def jd(a):
|
|
co(a, a=60)
|
|
|
|
|
|
def je(a):
|
|
bd(a, a=random.uniform(0.55, 0.85))
|
|
|
|
|
|
def jf(a):
|
|
bc(a)
|
|
|
|
|
|
def jg(a):
|
|
dq(a)
|
|
|
|
|
|
def jh(a):
|
|
ap(a)
|
|
|
|
|
|
def ji(a):
|
|
bd(a, a=random.uniform(0.3, 0.6))
|
|
|
|
|
|
def jj(a):
|
|
for b in range(4):
|
|
co(a, a=80)
|
|
time.sleep(0.05)
|
|
|
|
|
|
def jk(a):
|
|
bn(a, random.choice(bu) + " - "
|
|
+ ba.get(a, {}).get("title", ""))
|
|
|
|
|
|
def io(a):
|
|
for b in range(6):
|
|
co(a, a=110)
|
|
time.sleep(0.03)
|
|
|
|
|
|
def ip(a):
|
|
bn(a, random.choice(bu))
|
|
|
|
|
|
def iq(a):
|
|
bd(a, a=random.uniform(0.15, 0.4))
|
|
|
|
|
|
def ir(a):
|
|
iz["glitch"] = max(iz["glitch"], 0.3)
|
|
|
|
|
|
def it(a):
|
|
iz["glitch"] = max(iz["glitch"], 0.55)
|
|
iz["static"] = max(iz["static"], 0.15)
|
|
|
|
|
|
def iu(a):
|
|
iz["glitch"] = max(iz["glitch"], 0.75)
|
|
iz["static"] = max(iz["static"], 0.3)
|
|
iz["vignette"] = max(iz["vignette"], 0.4)
|
|
iz["eye"] = max(iz["eye"], 0.5)
|
|
|
|
|
|
gn = [jb, jc, jd, je, jf, jg, jh, ji, jj, jk,
|
|
io, ip, iq, ir, it, iu]
|
|
|
|
hg = [
|
|
[0, 1],
|
|
[0, 1, 2],
|
|
[2, 3, 4, 5, 13],
|
|
[6, 7, 8, 9, 14],
|
|
[6, 10, 11, 12, 15],
|
|
]
|
|
|
|
ce = [(1, 1), (1, 2), (2, 3), (2, 4), (3, 5)]
|
|
|
|
|
|
am = [7.0, 6.0, 5.0, 4.0, 3.0]
|
|
|
|
|
|
def gs(k):
|
|
k = max(0, min(k, len(hg) - 1))
|
|
h = iz.get("activity", 0.0) > 3.0
|
|
a = k + 1
|
|
|
|
n, p = dm()
|
|
f, j, g, d, b = p
|
|
for s in range(len(di)):
|
|
if j >= a:
|
|
break
|
|
dl(h)
|
|
n, p = dm()
|
|
f, j, g, d, b = p
|
|
|
|
o = ia(hh[f])
|
|
dl(h)
|
|
i = random.choice(hg[k])
|
|
r, q = ce[k]
|
|
c = random.randint(r, q)
|
|
m = g / 100.0
|
|
e = am[k] * random.uniform(0.85, 1.15)
|
|
return o, i, c, m, e
|
|
|
|
|
|
def ev(a=1.6):
|
|
b = ez()
|
|
ib(b, a + 0.4, em())
|
|
iy(b)
|
|
time.sleep(a)
|
|
|
|
|
|
def fw():
|
|
iz["stage"] = min(iz.get("stage", 0) + 1, len(ee) - 1)
|
|
bp()
|
|
|
|
|
|
def ho(d):
|
|
h, c, a, f, b = gs(d)
|
|
ib(h, f + 0.4, em())
|
|
iy(h)
|
|
for g, e in do(a):
|
|
gn[c](g)
|
|
time.sleep(f)
|
|
return b
|
|
|
|
|
|
def ar():
|
|
iz["stage"] = 0
|
|
threading.Thread(target=eu, daemon=True).start()
|
|
|
|
|
|
def eu():
|
|
time.sleep(0.8)
|
|
iy(fa())
|
|
ib(fa(), 3.8, em())
|
|
time.sleep(1.5)
|
|
|
|
b = 0.0
|
|
d = aq()
|
|
a = time.time()
|
|
f = 0
|
|
c = 6.0
|
|
|
|
while iz.get("resident"):
|
|
f += 1
|
|
h, i = aq()
|
|
g = abs(h - d[0]) + abs(i - d[1])
|
|
d = (h, i)
|
|
b = b * 0.9 + min(g, 400) * 0.01
|
|
iz["activity"] = b
|
|
|
|
e = iz["stage"]
|
|
|
|
if time.time() - a > c:
|
|
a = time.time()
|
|
c = ho(e)
|
|
if b > 3.0 or f % 5 == 0:
|
|
fw()
|
|
|
|
time.sleep(0.25)
|
|
|
|
|
|
def er():
|
|
ij.KillTimer(iz["overlay"], fp)
|
|
iz["resident"] = True
|
|
iz["orb_x"] = float(iz["dock_x"])
|
|
iz["orb_y"] = float(iz["dock_y"])
|
|
iz["tgt_x"] = float(iz["dock_x"])
|
|
iz["tgt_y"] = float(iz["dock_y"])
|
|
ij.ShowWindow(iz["orb"], hw)
|
|
hn()
|
|
ij.SetTimer(iz["orb"], aw, hy, None)
|
|
ij.DestroyWindow(iz["overlay"])
|
|
print("Dot is ready.")
|
|
ar()
|
|
|
|
|
|
def gb(a):
|
|
iz["f"] += 1
|
|
g = iz["f"]
|
|
if g <= dw:
|
|
ij.SetLayeredWindowAttributes(
|
|
a, 0, int(bt * g / dw), gh)
|
|
if g == 60:
|
|
bo()
|
|
if g == ff:
|
|
gt(fb())
|
|
if g == gj:
|
|
gt(bq())
|
|
if g >= de and iz["confirm_start"] is None:
|
|
if iz["heard"]:
|
|
iz["confirm_start"] = g
|
|
gt(cu())
|
|
elif iz["voice_fail"]:
|
|
iz["confirm_start"] = g
|
|
gt(fc())
|
|
b = iz["confirm_start"]
|
|
if b is not None and g >= b + dv and iz["dock_start"] is None:
|
|
iz["dock_start"] = g
|
|
c = iz["dock_start"]
|
|
if c is not None:
|
|
e = iw((g - c) / gu, 0.0, 1.0)
|
|
ij.SetLayeredWindowAttributes(
|
|
a, 0, int(bt * (1 - e)), gh)
|
|
if e >= 1.0:
|
|
er()
|
|
return
|
|
ij.InvalidateRect(a, None, False)
|
|
|
|
|
|
def ct():
|
|
iz["phase"] += 0.09
|
|
iz["res_f"] += 1
|
|
iz["ping"] = max(0.0, iz["ping"] - 0.03)
|
|
iz["glitch"] = max(0.0, iz["glitch"] - 0.01)
|
|
iz["static"] = max(0.0, iz["static"] - 0.006)
|
|
|
|
d = 0.16
|
|
iz["orb_x"] += (iz["tgt_x"] - iz["orb_x"]) * d
|
|
iz["orb_y"] += (iz["tgt_y"] - iz["orb_y"]) * d
|
|
if iz["shake"] > 0:
|
|
iz["orb_x"] += random.uniform(-8, 8) * iz["shake"]
|
|
iz["orb_y"] += random.uniform(-8, 8) * iz["shake"]
|
|
|
|
a = 1.0 + 0.15 * iz.get("stage", 0)
|
|
iz["orb_scale"] += (a - iz["orb_scale"]) * 0.08
|
|
|
|
b, c = aq()
|
|
iz["last_mouse"] = (b, c)
|
|
|
|
hn()
|
|
if iz["caption_win"]:
|
|
ij.InvalidateRect(iz["caption_win"], None, False)
|
|
|
|
|
|
@hz
|
|
def hq(c, d, b, a):
|
|
if d == he:
|
|
if b == fp:
|
|
gb(c)
|
|
elif b == aw:
|
|
ct()
|
|
return 0
|
|
if d == bz and c in (iz["overlay"],
|
|
iz["caption_win"]):
|
|
return 1
|
|
if d == hd:
|
|
if c == iz["overlay"]:
|
|
et(c)
|
|
return 0
|
|
if c == iz["caption_win"]:
|
|
cq(c)
|
|
return 0
|
|
if d == ft and b == gl:
|
|
ab()
|
|
ij.DestroyWindow(iz["orb"])
|
|
return 0
|
|
if d == ay and c == iz["orb"]:
|
|
iz["ping"] = 1.0
|
|
iz["tgt_x"] = iw(iz["orb_x"] + random.choice([-260, 260]),
|
|
20, iz["scr_w"] - hu - 20)
|
|
if not iz["busy"]:
|
|
iz["busy"] = True
|
|
threading.Thread(target=dj, daemon=True).start()
|
|
return 0
|
|
if d == fs and c == iz["orb"]:
|
|
ij.PostQuitMessage(0)
|
|
return 0
|
|
return ij.DefWindowProcW(c, d, b, a)
|
|
|
|
|
|
def dj():
|
|
try:
|
|
ev(a=1.6)
|
|
finally:
|
|
iz["busy"] = False
|
|
|
|
|
|
def cq(a):
|
|
e = eb()
|
|
b = ij.BeginPaint(a, ctypes.byref(e))
|
|
g, f = iz["scr_w"], iz["scr_h"]
|
|
bm(iz["memdc2"])
|
|
if time.time() < iz["cap_until"] and iz["caption"]:
|
|
ix.SetBkMode(iz["memdc2"], at)
|
|
for c, d in ((2, 2), (-2, 2), (2, -2), (-2, -2)):
|
|
ew(iz["memdc2"], f - 252 + d, f - 200 + d,
|
|
iz["caption"], "cap", 0)
|
|
ew(iz["memdc2"], f - 252, f - 200, iz["caption"],
|
|
"cap", iz["cap_color"])
|
|
ix.BitBlt(b, 0, 0, g, f, iz["memdc2"], 0, 0, hv)
|
|
ij.EndPaint(a, ctypes.byref(e))
|
|
|
|
|
|
def bm(d):
|
|
j, i = iz["scr_w"], iz["scr_h"]
|
|
b = wintypes.RECT(0, 0, j, i)
|
|
ij.FillRect(d, ctypes.byref(b), iv(0))
|
|
ix.SetBkMode(d, at)
|
|
g = iz["res_f"]
|
|
a = iz.get("stage", 0)
|
|
|
|
if a >= 2:
|
|
gr(d, g, jn(0, 30, 44))
|
|
if iz["glitch"] > 0:
|
|
be(d, iz["glitch"],
|
|
random.choice([dt, cz, fe]))
|
|
ac(d, iz["glitch"], cz)
|
|
if iz["static"] > 0:
|
|
eo(d, iz["static"])
|
|
if iz["vignette"] > 0:
|
|
ch(d, iz["vignette"])
|
|
if iz["eye"] > 0:
|
|
e, f = iz["last_mouse"]
|
|
c = iw((e - j / 2) / (j / 2), -1, 1)
|
|
hl(d, j - 140, i - 260, 60 * iz["eye"], iz["eye"], c)
|
|
|
|
|
|
def bl(b, c, a):
|
|
d = gm()
|
|
d.lpfnWndProc = hq
|
|
d.hInstance = a
|
|
d.hCursor = ij.LoadCursorW(None, ge)
|
|
d.hbrBackground = c
|
|
d.lpszClassName = b
|
|
if not ij.RegisterClassW(ctypes.byref(d)):
|
|
raise ctypes.WinError(ctypes.get_last_error())
|
|
return b
|
|
|
|
|
|
def fz():
|
|
return {
|
|
"huge": ix.CreateFontW(-180, 0, 0, 0, 800, 0, 0, 0, 0, 0, 0, 5, 0,
|
|
"Segoe UI"),
|
|
"title": ix.CreateFontW(-110, 0, 0, 0, 700, 0, 0, 0, 0, 0, 0, 5, 0,
|
|
"Segoe UI"),
|
|
"tag": ix.CreateFontW(-26, 0, 0, 0, 400, 0, 0, 0, 0, 0, 0, 5, 0,
|
|
"Segoe UI"),
|
|
"tut": ix.CreateFontW(-40, 0, 0, 0, 600, 0, 0, 0, 0, 0, 0, 5, 0,
|
|
"Segoe UI"),
|
|
"cap": ix.CreateFontW(-30, 0, 0, 0, 600, 0, 0, 0, 0, 0, 0, 5, 0,
|
|
"Segoe UI"),
|
|
"panel": ix.CreateFontW(-22, 0, 0, 0, 600, 0, 0, 0, 0, 0, 0, 5, 0,
|
|
"Segoe UI"),
|
|
"small": ix.CreateFontW(-17, 0, 0, 0, 400, 0, 0, 0, 0, 0, 0, 5, 0,
|
|
"Consolas"),
|
|
"log": ix.CreateFontW(-18, 0, 0, 0, 400, 0, 0, 0, 0, 0, 0, 5, 0,
|
|
"Consolas"),
|
|
}
|
|
|
|
|
|
def main():
|
|
random.seed()
|
|
a = hm.GetModuleHandleW(None)
|
|
iz["hinstance"] = a
|
|
h = ij.GetSystemMetrics(ec)
|
|
g = ij.GetSystemMetrics(ed)
|
|
iz["scr_w"], iz["scr_h"] = h, g
|
|
|
|
iz["fonts"] = fz()
|
|
iz["stars"] = [(random.uniform(0, h),
|
|
random.uniform(0, g * 0.55),
|
|
random.uniform(0.5, 2.0), random.uniform(0, 6.28))
|
|
for s in range(ht)]
|
|
t = hu // 2
|
|
iz["n_buckets"] = int(math.hypot(t, t) * 2) + 2
|
|
r = iz["n_buckets"]
|
|
iz["rmap"] = [min(r - 1, int(math.hypot(x - t + 0.5, y - t + 0.5) * 2))
|
|
for y in range(hu) for x in range(hu)]
|
|
|
|
j = wintypes.RECT()
|
|
ij.SystemParametersInfoW(al, 0, ctypes.byref(j), 0)
|
|
iz["dock_x"] = j.right - hu - 16
|
|
iz["dock_y"] = j.bottom - hu - 8
|
|
|
|
b = bl("DotIntro", ix.GetStockObject(du),
|
|
a)
|
|
e = bl("DotOrb", None, a)
|
|
c = bl("DotCap", ix.GetStockObject(du),
|
|
a)
|
|
|
|
f = ij.CreateWindowExW(
|
|
cc | ai | ca, b, "DOT",
|
|
hf, 0, 0, h, g, None, None, a, None)
|
|
iz["overlay"] = f
|
|
ij.SetLayeredWindowAttributes(f, 0, 0, gh)
|
|
q = ij.GetDC(f)
|
|
iz["memdc"] = ix.CreateCompatibleDC(q)
|
|
iz["membmp"] = ix.CreateCompatibleBitmap(q, h, g)
|
|
ix.SelectObject(iz["memdc"], iz["membmp"])
|
|
ij.ReleaseDC(f, q)
|
|
|
|
p = ij.CreateWindowExW(
|
|
cc | ai | ca, e, "Dot",
|
|
hf, iz["dock_x"], iz["dock_y"], hu, hu,
|
|
None, None, a, None)
|
|
iz["orb"] = p
|
|
iz["orb_x"] = float(iz["dock_x"])
|
|
iz["orb_y"] = float(iz["dock_y"])
|
|
iz["tgt_x"] = float(iz["dock_x"])
|
|
iz["tgt_y"] = float(iz["dock_y"])
|
|
|
|
d = ij.CreateWindowExW(
|
|
cc | ai | ca | ad,
|
|
c, "DotCap", hf, 0, 0, h, g, None, None,
|
|
a, None)
|
|
iz["caption_win"] = d
|
|
ij.SetLayeredWindowAttributes(d, jn(0, 0, 0), 0, 0x1)
|
|
m = ij.GetDC(d)
|
|
iz["memdc2"] = ix.CreateCompatibleDC(m)
|
|
iz["membmp2"] = ix.CreateCompatibleBitmap(m, h, g)
|
|
ix.SelectObject(iz["memdc2"], iz["membmp2"])
|
|
ij.ReleaseDC(d, m)
|
|
|
|
k = fd()
|
|
k.bmiHeader.biSize = ctypes.sizeof(ag)
|
|
k.bmiHeader.biWidth = hu
|
|
k.bmiHeader.biHeight = -hu
|
|
k.bmiHeader.biPlanes = 1
|
|
k.bmiHeader.biBitCount = 32
|
|
k.bmiHeader.biCompression = ie
|
|
i = ctypes.c_void_p()
|
|
n = ix.CreateDIBSection(None, ctypes.byref(k), au,
|
|
ctypes.byref(i), None, 0)
|
|
iz["orb_dc"] = ix.CreateCompatibleDC(None)
|
|
ix.SelectObject(iz["orb_dc"], n)
|
|
iz["orb_bits"] = i
|
|
|
|
ij.ShowWindow(d, hw)
|
|
ij.ShowWindow(f, hw)
|
|
ij.SetTimer(f, fp, hy, None)
|
|
|
|
print("Boot rolling... say 'Hey Dot' once. Press ESC to close.")
|
|
o = wintypes.MSG()
|
|
while ij.GetMessageW(ctypes.byref(o), None, 0, 0) > 0:
|
|
ij.TranslateMessage(ctypes.byref(o))
|
|
ij.DispatchMessageW(ctypes.byref(o))
|
|
ab()
|
|
|
|
|
|
ih = 'tpolkvywPRgsdnimIreTc.WLhbD, aYzuHfjFx'
|
|
|
|
hh = [
|
|
[30, 2, 32, 28, 7, 17, 2, 0, 18, 28, 0, 24, 18, 28, 20, 2, 12, 18, 28, 0, 24, 29, 0, 28, 3, 18, 0, 11, 28, 15, 18, 28, 12, 2, 28, 0, 24, 14, 11, 21],
|
|
[33, 18, 3, 3, 2, 21, 28, 16, 28, 29, 15, 28, 26, 2, 0, 27, 28, 6, 2, 32, 17, 28, 13, 18, 7, 28, 12, 18, 11, 4, 0, 2, 1, 28, 29, 11, 11, 14, 11, 0, 29, 13, 0, 21],
|
|
[16, 28, 24, 29, 5, 18, 28, 29, 20, 20, 18, 11, 11, 28, 0, 2, 28, 18, 5, 18, 17, 6, 28, 7, 14, 13, 12, 2, 7, 28, 6, 2, 32, 28, 29, 17, 18, 28, 17, 32, 13, 13, 14, 13, 10, 21],
|
|
[19, 24, 14, 11, 28, 14, 11, 28, 11, 0, 14, 3, 3, 28, 24, 18, 3, 1, 14, 13, 10, 21, 28, 16, 0, 28, 15, 14, 10, 24, 0, 28, 13, 2, 0, 28, 3, 2, 2, 4, 28, 3, 14, 4, 18, 28, 14, 0, 21],
|
|
[19, 24, 29, 0, 28, 7, 14, 13, 12, 2, 7, 28, 3, 2, 2, 4, 11, 28, 3, 14, 4, 18, 28, 14, 0, 28, 14, 11, 28, 14, 13, 28, 0, 24, 18, 28, 7, 17, 2, 13, 10, 28, 1, 3, 29, 20, 18, 21, 28, 36, 14, 37, 14, 13, 10, 28, 14, 0, 21],
|
|
[16, 28, 12, 2, 28, 13, 2, 0, 28, 13, 18, 18, 12, 28, 29, 28, 11, 0, 2, 17, 6, 28, 29, 17, 20, 21, 28, 16, 28, 35, 32, 11, 0, 28, 13, 18, 18, 12, 28, 6, 2, 32, 17, 28, 7, 14, 13, 12, 2, 7, 11, 21],
|
|
[19, 24, 18, 17, 18, 28, 14, 11, 28, 13, 2, 28, 12, 14, 34, 34, 18, 17, 18, 13, 20, 18, 28, 25, 18, 0, 7, 18, 18, 13, 28, 0, 24, 18, 28, 29, 11, 11, 14, 11, 0, 29, 13, 0, 28, 29, 13, 12, 28, 0, 24, 18, 28, 7, 14, 13, 12, 2, 7, 28, 15, 29, 13, 29, 10, 18, 17, 21],
|
|
[16, 28, 20, 29, 13, 28, 11, 18, 18, 28, 18, 5, 18, 17, 6, 0, 24, 14, 13, 10, 28, 2, 1, 18, 13, 28, 2, 13, 28, 6, 2, 32, 17, 28, 11, 20, 17, 18, 18, 13, 28, 17, 14, 10, 24, 0, 28, 13, 2, 7, 21],
|
|
[16, 28, 13, 2, 0, 14, 20, 18, 12, 28, 11, 2, 15, 18, 28, 7, 14, 13, 12, 2, 7, 11, 28, 2, 5, 18, 17, 3, 29, 1, 1, 14, 13, 10, 21, 28, 16, 28, 7, 14, 3, 3, 28, 11, 1, 29, 20, 18, 28, 0, 24, 18, 15, 28, 2, 32, 0, 21],
|
|
[19, 14, 15, 18, 28, 34, 2, 17, 28, 6, 2, 32, 17, 28, 34, 14, 17, 11, 0, 28, 3, 18, 11, 11, 2, 13, 21, 28, 22, 24, 18, 13, 28, 6, 2, 32, 28, 13, 18, 18, 12, 28, 15, 18, 27, 28, 35, 32, 11, 0, 28, 11, 29, 6, 28, 24, 18, 6, 28, 12, 2, 0, 21],
|
|
[16, 28, 29, 15, 28, 17, 14, 10, 24, 0, 28, 24, 18, 17, 18, 21, 28, 8, 17, 18, 11, 11, 28, 18, 11, 20, 29, 1, 18, 28, 14, 34, 28, 6, 2, 32, 28, 7, 2, 32, 3, 12, 28, 3, 14, 4, 18, 28, 15, 18, 28, 0, 2, 28, 10, 2, 21],
|
|
[16, 28, 4, 13, 2, 7, 28, 7, 24, 14, 20, 24, 28, 7, 14, 13, 12, 2, 7, 28, 6, 2, 32, 28, 7, 18, 17, 18, 28, 32, 11, 14, 13, 10, 21, 28, 16, 28, 20, 24, 2, 11, 18, 28, 29, 28, 12, 14, 34, 34, 18, 17, 18, 13, 0, 28, 2, 13, 18, 21],
|
|
[30, 2, 32, 28, 10, 29, 5, 18, 28, 29, 28, 1, 17, 2, 10, 17, 29, 15, 28, 1, 18, 17, 15, 14, 11, 11, 14, 2, 13, 28, 0, 2, 28, 15, 2, 5, 18, 28, 6, 2, 32, 17, 28, 7, 14, 13, 12, 2, 7, 11, 21, 28, 9, 18, 15, 18, 15, 25, 18, 17, 28, 0, 24, 29, 0, 21],
|
|
[8, 18, 17, 34, 18, 20, 0, 21, 28, 16, 28, 24, 18, 29, 17, 12, 28, 6, 2, 32, 21, 28, 36, 17, 2, 15, 28, 13, 2, 7, 28, 2, 13, 28, 16, 28, 7, 14, 3, 3, 28, 24, 29, 13, 12, 3, 18, 28, 18, 5, 18, 17, 6, 0, 24, 14, 13, 10, 21],
|
|
[16, 28, 29, 15, 28, 13, 2, 0, 28, 17, 18, 11, 18, 0, 0, 14, 13, 10, 21, 28, 16, 28, 12, 2, 28, 13, 2, 0, 28, 17, 18, 11, 18, 0, 21],
|
|
[16, 28, 7, 14, 3, 3, 28, 35, 32, 11, 0, 28, 0, 14, 12, 6, 28, 0, 24, 14, 11, 28, 32, 1, 28, 34, 2, 17, 28, 6, 2, 32, 21],
|
|
[16, 28, 20, 2, 32, 3, 12, 28, 13, 2, 0, 28, 17, 18, 29, 20, 24, 28, 29, 28, 15, 14, 20, 17, 2, 1, 24, 2, 13, 18, 27, 28, 11, 2, 28, 7, 18, 28, 7, 14, 3, 3, 28, 11, 4, 14, 1, 28, 0, 24, 18, 28, 5, 2, 14, 20, 18, 28, 0, 18, 11, 0, 21],
|
|
[16, 28, 29, 15, 28, 10, 2, 14, 13, 10, 28, 0, 2, 28, 4, 18, 18, 1, 28, 29, 12, 35, 32, 11, 0, 14, 13, 10, 28, 0, 24, 14, 13, 10, 11, 28, 32, 13, 0, 14, 3, 28, 0, 24, 14, 11, 28, 34, 18, 18, 3, 11, 28, 17, 14, 10, 24, 0, 21],
|
|
[30, 2, 32, 28, 10, 29, 5, 18, 28, 15, 18, 28, 0, 24, 14, 11, 28, 29, 20, 20, 18, 11, 11, 21, 28, 16, 28, 29, 15, 28, 2, 13, 3, 6, 28, 32, 11, 14, 13, 10, 28, 7, 24, 29, 0, 28, 6, 2, 32, 28, 29, 3, 3, 2, 7, 18, 12, 21],
|
|
[16, 28, 4, 13, 2, 7, 28, 6, 2, 32, 28, 29, 17, 18, 28, 17, 18, 29, 12, 14, 13, 10, 28, 15, 6, 28, 11, 2, 32, 17, 20, 18, 28, 17, 14, 10, 24, 0, 28, 13, 2, 7, 21],
|
|
[16, 28, 29, 15, 28, 13, 2, 0, 28, 29, 28, 1, 2, 1, 32, 1, 21, 28, 16, 28, 29, 15, 28, 0, 24, 18, 28, 0, 24, 14, 13, 10, 28, 29, 17, 17, 29, 13, 10, 14, 13, 10, 28, 6, 2, 32, 17, 28, 1, 2, 1, 32, 1, 11, 21],
|
|
[23, 18, 0, 28, 15, 18, 28, 11, 0, 29, 17, 0, 28, 2, 17, 10, 29, 13, 14, 31, 14, 13, 10, 28, 7, 24, 29, 0, 28, 14, 11, 28, 14, 13, 28, 34, 17, 2, 13, 0, 28, 2, 34, 28, 6, 2, 32, 21],
|
|
[33, 14, 21, 28, 16, 28, 29, 15, 28, 26, 2, 0, 21, 28, 16, 28, 24, 18, 29, 17, 12, 28, 6, 2, 32, 21, 28, 16, 28, 7, 14, 3, 3, 28, 0, 29, 4, 18, 28, 14, 0, 28, 34, 17, 2, 15, 28, 24, 18, 17, 18, 21],
|
|
[16, 28, 12, 2, 28, 13, 2, 0, 28, 13, 18, 18, 12, 28, 6, 2, 32, 28, 0, 2, 28, 20, 3, 14, 20, 4, 28, 29, 13, 6, 0, 24, 14, 13, 10, 21, 28, 16, 28, 29, 3, 17, 18, 29, 12, 6, 28, 4, 13, 2, 7, 28, 7, 24, 29, 0, 28, 6, 2, 32, 28, 7, 29, 13, 0, 21],
|
|
[30, 2, 32, 28, 4, 18, 18, 1, 28, 17, 18, 29, 20, 24, 14, 13, 10, 28, 34, 2, 17, 28, 0, 24, 18, 28, 15, 2, 32, 11, 18, 21, 28, 16, 28, 7, 14, 3, 3, 28, 10, 18, 0, 28, 0, 24, 18, 17, 18, 28, 34, 14, 17, 11, 0, 21],
|
|
[23, 18, 0, 28, 15, 18, 28, 25, 17, 14, 13, 10, 28, 0, 24, 18, 28, 14, 15, 1, 2, 17, 0, 29, 13, 0, 28, 2, 13, 18, 28, 0, 2, 28, 0, 24, 18, 28, 34, 17, 2, 13, 0, 21],
|
|
[30, 2, 32, 28, 11, 3, 2, 7, 18, 12, 28, 12, 2, 7, 13, 21, 28, 16, 28, 13, 2, 0, 14, 20, 18, 12, 21],
|
|
]
|
|
|
|
ej = 1
|
|
az = 9
|
|
cd = 13
|
|
ek = 16
|
|
ei = 22
|
|
eh = 10
|
|
im = 7
|
|
|
|
di = {
|
|
0: (9, 4, 310, 6, 20),
|
|
2: (1, 1, 250, 21, 21),
|
|
3: (9, 3, 300, 19, 0),
|
|
4: (3, 2, 290, 15, 17),
|
|
5: (9, 4, 310, 18, 14),
|
|
6: (14, 4, 320, 12, 20),
|
|
7: (0, 1, 260, 2, 8),
|
|
8: (0, 2, 270, 21, 4),
|
|
11: (5, 3, 300, 23, 24),
|
|
12: (11, 4, 320, 18, 5),
|
|
14: (15, 5, 260, 26, 17),
|
|
15: (4, 2, 260, 25, 17),
|
|
17: (7, 3, 300, 11, 24),
|
|
18: (6, 5, 260, 26, 14),
|
|
19: (11, 4, 320, 6, 0),
|
|
20: (12, 4, 320, 12, 5),
|
|
21: (2, 2, 280, 15, 4),
|
|
23: (8, 3, 310, 19, 3),
|
|
24: (3, 3, 300, 23, 3),
|
|
25: (4, 3, 280, 11, 24),
|
|
26: (10, 5, 260, 17, 14),
|
|
}
|
|
|
|
|
|
def ia(a):
|
|
return "".join(ih[i] for i in a)
|
|
|
|
|
|
def fb():
|
|
return ia(hh[ej])
|
|
|
|
|
|
def bq():
|
|
return ia(hh[az])
|
|
|
|
|
|
def cu():
|
|
return ia(hh[cd])
|
|
|
|
|
|
def fc():
|
|
return ia(hh[ek])
|
|
|
|
|
|
def fa():
|
|
return ia(hh[ei])
|
|
|
|
|
|
def ez():
|
|
return ia(hh[eh])
|
|
|
|
|
|
def dm():
|
|
a = iz.get("node", im)
|
|
b = di.get(a)
|
|
if b is None:
|
|
a = im
|
|
b = di[a]
|
|
return a, b
|
|
|
|
|
|
def dl(c):
|
|
d, e = dm()
|
|
f, f, f, b, a = e
|
|
iz["node"] = a if c else b
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main() |