// 假设 buffer 是接收到的 ArrayBuffer
let offset = 0;
const view = new DataView(buffer);
 
// 1. 读取 Action Count
const actionCount = view.getUint32(offset, true); // true for Little-Endian
offset += 4;
 
// 2. 读取 Delay
const delay = view.getFloat32(offset, true);
offset += 4;
 
// 3. 读取 Palette
const paletteSize = view.getUint8(offset);
offset += 1;
 
const palette = [];
for (let i = 0; i < paletteSize; i++) {
  const r = view.getUint8(offset++);
  const g = view.getUint8(offset++);
  const b = view.getUint8(offset++);
  palette.push({ r, g, b });
}
 
// 4. 读取 Points Count
const pointsCount = view.getUint32(offset, true);
offset += 4;
 
// 5. 读取 Points
const points = [];
for (let i = 0; i < pointsCount; i++) {
  const x = view.getUint16(offset, true);
  offset += 2;
  const y = view.getUint16(offset, true);
  offset += 2;
  const r = view.getUint8(offset++);
  const g = view.getUint8(offset++);
  const b = view.getUint8(offset++);
  points.push({ x, y, color: { r, g, b } });
}

def on_draw_response(result):
    print(f"Draw response received: {result}")
    
    code = result.get('code')
    points_left = result.get('pointsLeft')
    last_update = result.get('lastUpdate')
    message = result.get('message', "Unknown Error")
 
payload = {
    "data": {
        "x": x,
        "y": y,
        "c": color,
        "w": 1,
        "h": 1
    }
}
 
self.sio.emit("draw", payload, callback=on_draw_response)

import socket
 
old_getaddrinfo = socket.getaddrinfo
 
def getaddrinfo_ipv4_only(host, port, *args, **kwargs):
    # 只保留返回 AF_INET（IPv4）的解析结果
    results = old_getaddrinfo(host, port, *args, **kwargs)
    return [res for res in results if res[0] == socket.AF_INET]
 
socket.getaddrinfo = getaddrinfo_ipv4_only

[project]
name = "paint-bot"
version = "0.1.0"
description = "paint2025 bot"
readme = "README.md"
requires-python = ">=3.12"
dependencies = [
    "pillow>=12.0.0",
    "python-socketio>=5.15.1",
    "requests>=2.32.5",
    "websocket-client>=1.9.0",
]

import argparse
import time
import requests
from PIL import Image
import socketio
import threading
 
def rgb_to_hex(r, g, b):
    return f"#{r:02x}{g:02x}{b:02x}"
 
def get_canvas_points():
    resp = requests.get("https://paint2025.geekpie.club/api/place")
    resp.raise_for_status()
    data = resp.json()
    points = {}
    for p in data.get("data", {}).get("points", []):
        points[(int(p["x"]), int(p["y"]))] = p["c"].lower()
    return points
 
# =========================
# 单 token Socket.IO 客户端
# =========================
class TokenClient:
    def __init__(self, token: str):
        self.token = token
        self.sio = socketio.Client(
            logger=False,
            engineio_logger=False
        )
        self.connected = False
 
        @self.sio.event
        def connect():
            self.connected = True
            print(f"[socketio] token {self.token[:6]} connected")
 
        @self.sio.event
        def disconnect():
            self.connected = False
            print(f"[socketio] token {self.token[:6]} disconnected")
 
    def connect(self):
        self.sio.connect(
            "https://paint2025.geekpie.club",
            transports=["websocket"],
            wait=True,
            wait_timeout=30,
            auth={
                "token": self.token
            }
        )
 
    def draw(self, x, y, color):
        if not self.connected:
            return False
        self.sio.emit(
            "draw",
            {
                "data": {"w": 1, "h": 1, "x": x, "y": y, "c": color},
            },
        )
        return True
 
    def close(self):
        if self.connected:
            self.sio.disconnect()
 
# =========================
# 主绘制逻辑
# =========================
def draw_image_until_complete(img_path, width, height, start_x, start_y, tokens_str):
    tokens = [t.strip() for t in tokens_str.split(",") if t.strip()]
    if not tokens:
        raise ValueError("No valid tokens")
 
    print(f"Starting with {len(tokens)} tokens")
 
    # 创建 token 客户端
    clients = [TokenClient(t) for t in tokens]
 
    # 并行连接
    threads = []
    for c in clients:
        t = threading.Thread(target=c.connect, daemon=True)
        t.start()
        threads.append(t)
 
    for t in threads:
        t.join()
 
    img = Image.open(img_path).convert("RGB")
    img = img.resize((width, height), Image.LANCZOS)
    pixels = img.load()
 
    client_index = 0
    sleep_time = 0.25
 
    try:
        while True:
            canvas = get_canvas_points()
            all_done = True
 
            for dy in range(height):
                for dx in range(width):
                    x = start_x + dx
                    y = start_y + dy
                    r, g, b = pixels[dx, dy]
                    color = rgb_to_hex(r, g, b).lower()
 
                    if canvas.get((x, y)) != color:
                        all_done = False
 
                        client = clients[client_index]
                        client_index = (client_index + 1) % len(clients)
 
                        if client.draw(x, y, color):
                            print(
                                f"[draw] x={x}, y={y}, color={color}, token={client.token[:6]}"
                            )
                        else:
                            print(
                                f"[draw] skipped (not connected) token={client.token[:6]}"
                            )
 
                        time.sleep(sleep_time)
 
            if all_done:
                print("All pixels match the target image!")
                break
            else:
                print("Not finished, checking again")
                time.sleep(5)
    finally:
        for c in clients:
            c.close()
 
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--image", required=True)
    parser.add_argument("--width", type=int, required=True)
    parser.add_argument("--height", type=int, required=True)
    parser.add_argument("--start-x", type=int, required=True)
    parser.add_argument("--start-y", type=int, required=True)
    parser.add_argument("--tokens", required=True)
    args = parser.parse_args()
 
    draw_image_until_complete(
        args.image,
        args.width,
        args.height,
        args.start_x,
        args.start_y,
        args.tokens,
    )
 
if __name__ == "__main__":
    main()