{"id":"gen-1782457573-3sYH8qnb2FH0HntSvBkl","choices":[{"finish_reason":"stop","index":0,"logprobs":null,"message":{"content":"# 🐍 3D Snake Game dengan Tkinter\n\nBerikut game ular dengan efek **pseudo-3D** menggunakan proyeksi isometrik, bayangan, partikel, dan pencahayaan:\n\n```python\nimport tkinter as tk\nimport random\nimport math\n\n\nclass Snake3D:\n def __init__(self):\n self.root = tk.Tk()\n self.root.title(\"🐍 3D Snake Game - MiMo\")\n self.root.configure(bg=\"#080810\")\n self.root.resizable(False, False)\n\n # ── ukuran window ──\n self.W, self.H = 920, 700\n self.canvas = tk.Canvas(\n self.root, width=self.W, height=self.H,\n bg=\"#080810\", highlightthickness=0,\n )\n self.canvas.pack(padx=5, pady=5)\n\n # ── konfigurasi grid isometrik ──\n self.COLS = 20\n self.ROWS = 20\n self.CELL = 28 # ukuran sel dalam piksel\n self.TILT = 0.50 # faktor kompresi sumbu-Y → efek perspektif\n self.OX = self.W // 2 # offset tengah layar\n self.OY = 310\n\n # ── state awal ──\n self.reset()\n\n # ── input ──\n self.root.bind(\"\", self.on_key)\n\n # ── mulai loop ──\n self.game_loop()\n self.root.mainloop()\n\n # ═══════════════════════════════════════\n # STATE\n # ═══════════════════════════════════════\n def reset(self):\n self.snake = [(10, 10), (9, 10), (8, 10)]\n self.dir = \"R\"\n self.next_dir = \"R\"\n self.food = None\n self.score = 0\n self.alive = True\n self.speed = 130 # ms per tick (semakin kecil semakin cepat)\n self.particles = []\n self.frame = 0\n self.spawn_food()\n\n # ═══════════════════════════════════════\n # KOORDINAT GRID → LAYAR (proyeksi 3D)\n # ═══════════════════════════════════════\n def g2s(self, gx, gy, z=0):\n \"\"\"Konversi koordinat grid ke koordinat layar dengan perspektif pseudo-3D.\"\"\"\n dx = (gx - self.COLS / 2) * self.CELL\n dy = (gy - self.ROWS / 2) * self.CELL\n sx = self.OX + dx\n sy = self.OY + dy * self.TILT - z\n return (sx, sy)\n\n # ═══════════════════════════════════════\n # FOOD\n # ═══════════════════════════════════════\n def spawn_food(self):\n while True:\n pos = (\n random.randint(0, self.COLS - 1),\n random.randint(0, self.ROWS - 1),\n )\n if pos not in self.snake:\n self.food = pos\n return\n\n # ═══════════════════════════════════════\n # INPUT\n # ═══════════════════════════════════════\n def on_key(self, e):\n if not self.alive:\n if e.keysym == \"space\":\n self.reset()\n return\n\n k = e.keysym\n if k == \"Up\" and self.dir != \"D\":\n self.next_dir = \"U\"\n elif k == \"Down\" and self.dir != \"U\":\n self.next_dir = \"D\"\n elif k == \"Left\" and self.dir != \"R\":\n self.next_dir = \"L\"\n elif k == \"Right\" and self.dir != \"L\":\n self.next_dir = \"R\"\n elif k == \"Escape\":\n self.root.quit()\n\n # ═══════════════════════════════════════\n # GAME LOOP\n # ═══════════════════════════════════════\n def game_loop(self):\n if self.alive:\n self.dir = self.next_dir\n self.step()\n self.render()\n self.frame += 1\n self.root.after(self.speed, self.game_loop)\n\n def step(self):\n hx, hy = self.snake[0]\n moves = {\"U\": (0, -1), \"D\": (0, 1), \"L\": (-1, 0), \"R\": (1, 0)}\n dx, dy = moves[self.dir]\n nh = (hx + dx, hy + dy)\n\n # tabrak tembok\n if not (0 <= nh[0] < self.COLS and 0 <= nh[1] < self.ROWS):\n self.alive = False\n self.spawn_burst(*self.snake[0], \"#ff2244\")\n return\n\n # tabrak badan sendiri\n if nh in self.snake:\n self.alive = False\n self.spawn_burst(*self.snake[0], \"#ff2244\")\n return\n\n self.snake.insert(0, nh)\n\n if nh == self.food:\n self.score += 10\n self.spawn_burst(*self.food, \"#ff6644\")\n self.spawn_food()\n if self.speed > 55:\n self.speed -= 2\n else:\n self.snake.pop()\n\n # ═══════════════════════════════════════\n # PARTIKEL\n # ═══════════════════════════════════════\n def spawn_burst(self, gx, gy, color):\n sx, sy = self.g2s(gx + 0.5, gy + 0.5, 20)\n for _ in range(30):\n angle = random.uniform(0, math.tau)\n vel = random.uniform(2, 9)\n self.particles.append(\n {\n \"x\": sx,\n \"y\": sy,\n \"vx\": math.cos(angle) * vel,\n \"vy\": math.sin(angle) * vel - 3,\n \"life\": random.randint(10, 30),\n \"max\": 30,\n \"sz\": random.uniform(2, 6),\n \"c\": color,\n }\n )\n\n # ═══════════════════════════════════════\n # HELPER WARNA\n # ═══════════════════════════════════════\n @staticmethod\n def lighter(hexc, n):\n h = hexc.lstrip(\"#\")\n r = min(255, int(h[0:2], 16) + n)\n g = min(255, int(h[2:4], 16) + n)\n b = min(255, int(h[4:6], 16) + n)\n return f\"#{r:02x}{g:02x}{b:02x}\"\n\n @staticmethod\n def darker(hexc, n):\n h = hexc.lstrip(\"#\")\n r = max(0, int(h[0:2], 16) - n)\n g = max(0, int(h[2:4], 16) - n)\n b = max(0, int(h[4:6], 16) - n)\n return f\"#{r:02x}{g:02x}{b:02x}\"\n\n @staticmethod\n def lerp(c1, c2, t):\n a, b = c1.lstrip(\"#\"), c2.lstrip(\"#\")\n r = int(int(a[0:2], 16) * (1 - t) + int(b[0:2], 16) * t)\n g = int(int(a[2:4], 16) * (1 - t) + int(b[2:4], 16) * t)\n bl = int(int(a[4:6], 16) * (1 - t) + int(b[4:6], 16) * t)\n return f\"#{r:02x}{g:02x}{bl:02x}\"\n\n # ═══════════════════════════════════════\n # GAMBAR KUBUS 3D\n # ═══════════════════════════════════════\n def draw_cube(self, gx, gy, color, elev=0, height=16):\n \"\"\"Gambar kubus pseudo-3D di sel grid (gx, gy).\"\"\"\n # ── titik-titik sudut ──\n # top face (elevasi + height)\n t_tl = self.g2s(gx, gy, elev + height)\n t_tr = self.g2s(gx + 1, gy, elev + height)\n t_br = self.g2s(gx + 1, gy + 1, elev + height)\n t_bl = self.g2s(gx, gy + 1, elev + height)\n\n # bottom face (elevasi)\n b_bl = self.g2s(gx, gy + 1, elev)\n b_br = self.g2s(gx + 1, gy + 1, elev)\n b_tr = self.g2s(gx + 1, gy, elev)\n\n # ── face depan (sisi selatan – paling terlihat) ──\n self.canvas.create_polygon(\n *t_bl, *t_br, *b_br, *b_bl,\n fill=self.darker(color, 45),\n outline=self.darker(color, 70),\n width=1,\n )\n\n # ── face kanan (sisi timur) ──\n self.canvas.create_polygon(\n *t_tr, *t_br, *b_br, *b_tr,\n fill=self.darker(color, 25),\n outline=self.darker(color, 55),\n width=1,\n )\n\n # ── face atas (paling terang) ──\n self.canvas.create_polygon(\n *t_tl, *t_tr, *t_br, *t_bl,\n fill=self.lighter(color, 35),\n outline=self.darker(color, 30),\n width=1,\n )\n\n # ═══════════════════════════════════════\n # GAMBAR BOLA MAKANAN (3D + GLOW)\n # ═══════════════════════════════════════\n def draw_food(self, gx, gy):\n cx, cy = gx + 0.5, gy + 0.5\n sx, sy = self.g2s(cx, cy, 18)\n\n pulse = 1 + 0.12 * math.sin(self.frame * 0.15)\n r = 13 * pulse\n base = \"#ff3366\"\n\n # glow bertingkat\n for i in range(8, 0, -1):\n gr = r + i * 5\n gc = self.lerp(base, \"#080810\", i * 0.10)\n self.canvas.create_oval(\n sx - gr, sy - gr * self.TILT,\n sx + gr, sy + gr * self.TILT,\n fill=gc, outline=\"\",\n )\n\n # bayangan di tanah\n shx, shy = self.g2s(cx, cy, 0)\n self.canvas.create_oval(\n shx - 13, shy - 6, shx + 13, shy + 6,\n fill=\"#04040a\", outline=\"\",\n )\n\n # badan bola\n self.canvas.create_oval(\n sx - r, sy - r * self.TILT,\n sx + r, sy + r * self.TILT,\n fill=base, outline=self.darker(base, 50), width=2,\n )\n\n # specular highlight\n hr = r * 0.30\n self.canvas.create_oval(\n sx - r * 0.25 - hr, sy - r * 0.35 * self.TILT - hr,\n sx - r * 0.25 + hr, sy - r * 0.35 * self.TILT + hr,\n fill=self.lighter(base, 130), outline=\"\",\n )\n\n # ═══════════════════════════════════════\n # GAMBAR MATA ULAR\n # ═══════════════════════════════════════\n def draw_eyes(self, gx, gy, elev):\n sx, sy = self.g2s(gx + 0.5, gy + 0.5, elev)\n\n off = 7\n if self.dir == \"R\":\n eyes = [(off, -5), (off, 5)]\n elif self.dir == \"L\":\n eyes = [(-off, -5), (-off, 5)]\n elif self.dir == \"U\":\n eyes = [(-5, -off), (5, -off)]\n else:\n eyes = [(-5, off), (5, off)]\n\n for ex, ey in eyes:\n er = 3.8\n self.canvas.create_oval(\n sx + ex - er, sy + ey - er,\n sx + ex + er, sy + ey + er,\n fill=\"white\", outline=\"#222\",\n )\n pr = 2.0\n self.canvas.create_oval(\n sx + ex - pr, sy + ey - pr,\n sx + ex + pr, sy + ey + pr,\n fill=\"#111\", outline=\"\",\n )\n\n # ═══════════════════════════════════════\n # GRID 3D\n # ═══════════════════════════════════════\n def draw_grid(self):\n gc = \"#161630\"\n\n for y in range(self.ROWS + 1):\n p1 = self.g2s(0, y)\n p2 = self.g2s(self.COLS, y)\n self.canvas.create_line(*p1, *p2, fill=gc)\n\n for x in range(self.COLS + 1):\n p1 = self.g2s(x, 0)\n p2 = self.g2s(x, self.ROWS)\n self.canvas.create_line(*p1, *p2, fill=gc)\n\n # border\n pts = []\n for g in [(0, 0), (self.COLS, 0), (self.COLS, self.ROWS), (0, self.ROWS)]:\n pts.extend(self.g2s(*g))\n self.canvas.create_polygon(pts, fill=\"\", outline=\"#3a3a80\", width=3)\n\n # ═══════════════════════════════════════\n # RENDER UTAMA\n # ═══════════════════════════════════════\n def render(self):\n self.canvas.delete(\"all\")\n\n # ── background gradient ──\n for i in range(0, self.H, 5):\n t = i / self.H\n r = int(8 + 14 * t)\n g = int(8 + 14 * t)\n b = int(16 + 30 * t)\n self.canvas.create_rectangle(\n 0, i, self.W, i + 5,\n fill=f\"#{r:02x}{g:02x}{b:02x}\", outline=\"\",\n )\n\n # ── grid ──\n self.draw_grid()\n\n # ── kumpulkan semua objek + depth key ──\n render_list = []\n for i, (gx, gy) in enumerate(self.snake):\n render_list.append((\"snake\", i, gx, gy, gy * 1000 + gx))\n\n if self.food:\n fx, fy = self.food\n render_list.append((\"food\", 0, fx, fy, fy * 1000 + fx))\n\n render_list.sort(key=lambda it: it[4]) # painter's algorithm\n\n # ── gambar objek ──\n for kind, idx, gx, gy, _ in render_list:\n\n # bayangan di tanah\n shx, shy = self.g2s(gx + 0.5, gy + 0.5, 0)\n ssz = 15 if kind == \"snake\" else 13\n self.canvas.create_oval(\n shx - ssz, shy - ssz * self.TILT,\n shx + ssz, shy + ssz * self.TILT,\n fill=\"#04040a\", outline=\"\",\n )\n\n if kind == \"snake\":\n if idx == 0:\n color, h = \"#00ff88\", 22\n else:\n t = idx / max(1, len(self.snake) - 1)\n color = self.lerp(\"#00dd66\", \"#003318\", t)\n h = int(20 - 8 * t)\n\n self.draw_cube(gx, gy, color, elev=2, height=h)\n\n if idx == 0:\n self.draw_eyes(gx, gy, 2 + h + 2)\n\n elif kind == \"food\":\n self.draw_food(gx, gy)\n\n # ── partikel ──\n alive = []\n for p in self.particles:\n p[\"x\"] += p[\"vx\"]\n p[\"y\"] += p[\"vy\"]\n p[\"vy\"] += 0.30\n p[\"life\"] -= 1\n if p[\"life\"] > 0:\n alive.append(p)\n lt = p[\"life\"] / p[\"max\"]\n s = p[\"sz\"] * lt\n c = self.lerp(p[\"c\"], \"#080810\", 1 - lt)\n self.canvas.create_oval(\n p[\"x\"] - s, p[\"y\"] - s,\n p[\"x\"] + s, p[\"y\"] + s,\n fill=c, outline=\"\",\n )\n self.particles = alive\n\n # ── HUD ──\n self.canvas.create_text(\n self.W // 2, 28,\n text=f\"🐍 SCORE: {self.score}\",\n fill=\"#00ff88\", font=(\"Consolas\", 28, \"bold\"),\n )\n\n spd = max(1, (131 - self.speed) // 2)\n self.canvas.create_text(\n self.W // 2, 60,\n text=f\"Speed Level: {spd}\",\n fill=\"#4488aa\", font=(\"Consolas\", 13),\n )\n\n self.canvas.create_text(\n self.W // 2, self.H - 18,\n text=\"↑ ↓ ← → Move | SPACE Restart | ESC Quit\",\n fill=\"#3333aa\", font=(\"Consolas\", 10),\n )\n\n # ── GAME OVER overlay ──\n if not self.alive:\n self.canvas.create_rectangle(\n 0, 0, self.W, self.H,\n fill=\"#000000\", stipple=\"gray50\",\n )\n self.canvas.create_text(\n self.W // 2, self.H // 2 - 55,\n text=\"GAME OVER\",\n fill=\"#ff2244\", font=(\"Consolas\", 54, \"bold\"),\n )\n self.canvas.create_text(\n self.W // 2, self.H // 2 + 10,\n text=f\"Final Score: {self.score}\",\n fill=\"#ffffff\", font=(\"Consolas\", 30),\n )\n self.canvas.create_text(\n self.W // 2, self.H // 2 + 60,\n text=\"Press SPACE to play again\",\n fill=\"#aaaaaa\", font=(\"Consolas\", 16),\n )\n\n\n# ═══════════════════════════════════════\nif __name__ == \"__main__\":\n Snake3D()\n```\n\n---\n\n## ✨ Fitur 3D yang diterapkan\n\n| Fitur | Penjelasan |\n|---|---|\n| **Proyeksi Isometrik** | Grid miring → kesan perspektif dari atas |\n| **Kubus 3D** | Setiap segmen ular = kubus dengan 3 face (atas, depan, kanan) + shading berbeda |\n| **Bola 3D** | Makanan digambar sebagai bola dengan glow, specular highlight, dan bayangan |\n| **Bayangan** | Setiap objek punya bayangan oval di \"tanah\" |\n| **Partikel** | Efek ledakan partikel saat makan / game over |\n| **Depth Sorting** | Painter's algorithm — objek di belakang digambar duluan |\n| **Gradasi Warna** | Badan ular gradient dari terang (kepala) → gelap (ekor) |\n| **Gradien Background** | Langit gelap bertingkat untuk kesan kedalaman |\n\n## 🎮 Kontrol\n\n| Tombol | Fungsi |\n|---|---|\n| `↑ ↓ ← →` | Menggerakkan ular |\n| `SPACE` | Mulai ulang setelah game over |\n| `ESC` | Keluar game |","refusal":null,"role":"assistant","annotations":null,"audio":null,"function_call":null,"tool_calls":null,"reasoning":"The user is asking me to create a Snake game using Python's tkinter library, and they want it to be as 3D-looking as possible. Since tkinter is a 2D library, I'll need to create a pseudo-3D effect using perspective rendering, shading, and visual techniques to make it look like a 3D game.\n\nLet me create a visually impressive snake game with pseudo-3D effects including:\n1. Isometric or perspective view\n2. 3D-looking snake segments with shadows and highlights\n3. 3D-looking food with glowing effects\n4. Grid with perspective\n5. Shadows\n6. Gradient backgrounds\n7. Particle effects\n\nLet me build this step by step.\n\nI'll create a snake game that uses perspective projection to give a 3D feel, with:\n- A 3D perspective grid\n- Snake blocks that look like 3D cubes\n- Food that looks like a 3D sphere\n- Shadows cast on the ground\n- Smooth animations\n- Score display\n\nLet me write a comprehensive implementation.\n\nI'll use a pseudo-3D approach where:\n- The game board is rendered in a tilted perspective (like isometric)\n- Snake segments are drawn as 3D cubes with proper shading\n- Food items have a glowing 3D appearance\n- There's a ground plane with grid lines\n\nLet me code this up properly.\n\n```python\nimport tkinter as tk\nimport random\nimport math\n\nclass SnakeGame3D:\n def __init__(self, root):\n self.root = root\n self.root.title(\"🐍 3D Snake Game\")\n self.root.resizable(False, False)\n \n # Game settings\n self.WIDTH = 800\n self.HEIGHT = 600\n self.CELL_SIZE = 25\n self.GRID_W = 20\n self.GRID_H = 20\n \n # 3D perspective settings\n self.cam_height = 300\n self.cam_dist = 500\n self.tilt = 0.6 # tilt angle factor\n self.board_offset_x = 400\n self.board_offset_y = 250\n \n # Canvas\n self.canvas = tk.Canvas(root, width=self.WIDTH, height=self.HEIGHT, bg='#1a1a2e', highlightthickness=0)\n self.canvas.pack()\n \n # Game state\n self.direction = 'RIGHT'\n self.next_direction = 'RIGHT'\n self.snake = [(10, 10), (9, 10), (8, 10)]\n self.food = None\n self.score = 0\n self.game_over = False\n self.speed = 120\n self.particles = []\n self.bob_offset = 0\n self.bob_speed = 0\n \n self.spawn_food()\n \n # Bind keys\n self.root.bind('', self.on_key)\n \n # Start game loop\n self.update()\n \n def to_screen(self, gx, gy, z=0):\n \"\"\"Convert grid coordinates to screen coordinates with 3D perspective\"\"\"\n # Center the grid\n cx = gx - self.GRID_W / 2\n cy = gy - self.GRID_H / 2\n \n # Apply perspective transformation\n scale = self.cam_dist / (self.cam_dist + z)\n \n sx = self.board_offset_x + cx * self.CELL_SIZE * scale\n sy = self.board_offset_y + cy * self.CELL_SIZE * self.tilt * scale - z * scale * 0.5\n \n return sx, sy, scale\n \n def draw_3d_cube(self, x, y, size, color, height=15, darken=0):\n \"\"\"Draw a pseudo-3D cube at grid position (x, y)\"\"\"\n sx, sy, scale = self.to_screen(x, y)\n s = size * scale * 0.9\n h = height * scale\n \n # Shadow on ground\n shadow_color = '#0d0d1a'\n points_shadow = [\n sx - s/2 + 2, sy + 2,\n sx + s/2 + 2, sy + 2,\n sx + s/2 + 2, sy + s * self.tilt + 2,\n sx - s/2 + 2, sy + s * self.tilt + 2\n ]\n self.canvas.create_polygon(points_shadow, fill=shadow_color, outline='')\n \n # Top face (brightest)\n top_color = self.lighten_color(color, 40 + darken)\n points_top = [\n sx, sy - h,\n sx + s/2, sy - h + s * self.tilt / 2,\n sx, sy - h + s * self.tilt,\n sx - s/2, sy - h + s * self.tilt / 2\n ]\n self.canvas.create_polygon(points_top, fill=top_color, outline=self.darken_color(color, 30), width=1)\n \n # Right face (medium)\n right_color = self.darken_color(color, 20 - darken)\n points_right = [\n sx + s/2, sy - h + s * self.tilt / 2,\n sx + s/2, sy + s * self.tilt / 2,\n sx, sy + s * self.tilt,\n sx, sy - h + s * self.tilt\n ]\n self.canvas.create_polygon(points_right, fill=right_color, outline=self.darken_color(color, 50), width=1)\n \n # Left face (darkest)\n left_color = self.darken_color(color, 40 - darken)\n points_left = [\n sx - s/2, sy - h + s * self.tilt / 2,\n sx - s/2, sy + s * self.tilt / 2,\n sx, sy + s * self.tilt,\n sx, sy - h + s * self.tilt\n ]\n self.canvas.create_polygon(points_left, fill=left_color, outline=self.darken_color(color, 50), width=1)\n \n def draw_3d_sphere(self, x, y, radius, color):\n \"\"\"Draw a pseudo-3D sphere (food)\"\"\"\n sx, sy, scale = self.to_screen(x, y)\n r = radius * scale\n \n # Glow effect\n for i in range(5, 0, -1):\n glow_r = r + i * 4 * scale\n alpha_color = self.blend_color(color, '#1a1a2e', i * 0.15)\n self.canvas.create_oval(\n sx - glow_r, sy - glow_r * self.tilt,\n sx + glow_r, sy + glow_r * self.tilt,\n fill=alpha_color, outline=''\n )\n \n # Shadow\n shadow_r = r * 0.8\n self.canvas.create_oval(\n sx - shadow_r + 3, sy - shadow_r * self.tilt * 0.5 + 5,\n sx + shadow_r + 3, sy + shadow_r * self.tilt * 0.5 + 5,\n fill='#0d0d1a', outline=''\n )\n \n # Main sphere\n self.canvas.create_oval(\n sx - r, sy - r * self.tilt,\n sx + r, sy + r * self.tilt,\n fill=color, outline=self.darken_color(color, 60), width=2\n )\n \n # Highlight\n hr = r * 0.35\n self.canvas.create_oval(\n sx - hr - r * 0.2, sy - hr * self.tilt - r * self.tilt * 0.3,\n sx + hr - r * 0.2, sy + hr * self.tilt - r * self.tilt * 0.3,\n fill=self.lighten_color(color, 100), outline=''\n )\n \n def draw_grid(self):\n \"\"\"Draw 3D perspective grid\"\"\"\n grid_color = '#2a2a4a'\n \n # Draw horizontal lines\n for y in range(self.GRID_H + 1):\n x1, y1, _ = self.to_screen(0, y)\n x2, y2, _ = self.to_screen(self.GRID_W, y)\n self.canvas.create_line(x1, y1, x2, y2, fill=grid_color, width=1)\n \n # Draw vertical lines\n for x in range(self.GRID_W + 1):\n x1, y1, _ = self.to_screen(x, 0)\n x2, y2, _ = self.to_screen(x, self.GRID_H)\n self.canvas.create_line(x1, y1, x2, y2, fill=grid_color, width=1)\n \n # Draw border\n border_color = '#4a4a8a'\n corners = [\n self.to_screen(0, 0),\n self.to_screen(self.GRID_W, 0),\n self.to_screen(self.GRID_W, self.GRID_H),\n self.to_screen(0, self.GRID_H)\n ]\n points = []\n for c in corners:\n points.extend([c[0], c[1]])\n self.canvas.create_polygon(points, fill='', outline=border_color, width=3)\n \n def lighten_color(self, color, amount):\n \"\"\"Lighten a hex color\"\"\"\n color = color.lstrip('#')\n r, g, b = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16)\n r = min(255, r + amount)\n g = min(255, g + amount)\n b = min(255, b + amount)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def darken_color(self, color, amount):\n \"\"\"Darken a hex color\"\"\"\n color = color.lstrip('#')\n r, g, b = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16)\n r = max(0, r - amount)\n g = max(0, g - amount)\n b = max(0, b - amount)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def blend_color(self, c1, c2, factor):\n \"\"\"Blend two colors\"\"\"\n c1 = c1.lstrip('#')\n c2 = c2.lstrip('#')\n r1, g1, b1 = int(c1[0:2], 16), int(c1[2:4], 16), int(c1[4:6], 16)\n r2, g2, b2 = int(c2[0:2], 16), int(c2[2:4], 16), int(c2[4:6], 16)\n r = int(r1 + (r2 - r1) * factor)\n g = int(g1 + (g2 - g1) * factor)\n b = int(b1 + (b2 - b1) * factor)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def spawn_food(self):\n \"\"\"Spawn food at random position\"\"\"\n while True:\n x = random.randint(0, self.GRID_W - 1)\n y = random.randint(0, self.GRID_H - 1)\n if (x, y) not in self.snake:\n self.food = (x, y)\n break\n \n def on_key(self, event):\n \"\"\"Handle key input\"\"\"\n key = event.keysym\n if self.game_over:\n if key == 'space':\n self.restart()\n return\n \n if key == 'Up' and self.direction != 'DOWN':\n self.next_direction = 'UP'\n elif key == 'Down' and self.direction != 'UP':\n self.next_direction = 'DOWN'\n elif key == 'Left' and self.direction != 'RIGHT':\n self.next_direction = 'LEFT'\n elif key == 'Right' and self.direction != 'LEFT':\n self.next_direction = 'RIGHT'\n elif key == 'Escape':\n self.root.quit()\n \n def update(self):\n \"\"\"Game update loop\"\"\"\n if not self.game_over:\n self.direction = self.next_direction\n self.move_snake()\n \n self.draw()\n self.root.after(self.speed, self.update)\n \n def move_snake(self):\n \"\"\"Move the snake\"\"\"\n head = self.snake[0]\n if self.direction == 'UP':\n new_head = (head[0], head[1] - 1)\n elif self.direction == 'DOWN':\n new_head = (head[0], head[1] + 1)\n elif self.direction == 'LEFT':\n new_head = (head[0] - 1, head[1])\n elif self.direction == 'RIGHT':\n new_head = (head[0] + 1, head[1])\n \n # Check collision with walls\n if (new_head[0] < 0 or new_head[0] >= self.GRID_W or\n new_head[1] < 0 or new_head[1] >= self.GRID_H):\n self.game_over = True\n return\n \n # Check collision with self\n if new_head in self.snake:\n self.game_over = True\n return\n \n self.snake.insert(0, new_head)\n \n # Check food\n if new_head == self.food:\n self.score += 10\n self.spawn_particles(new_head[0], new_head[1], '#ff4444')\n self.spawn_food()\n # Speed up slightly\n if self.speed > 60:\n self.speed -= 2\n else:\n self.snake.pop()\n \n def spawn_particles(self, x, y, color):\n \"\"\"Spawn particles at position\"\"\"\n sx, sy, _ = self.to_screen(x, y)\n for _ in range(15):\n angle = random.uniform(0, 2 * math.pi)\n speed = random.uniform(2, 8)\n self.particles.append({\n 'x': sx, 'y': sy,\n 'vx': math.cos(angle) * speed,\n 'vy': math.sin(angle) * speed,\n 'life': random.randint(10, 25),\n 'max_life': 25,\n 'color': color,\n 'size': random.uniform(2, 5)\n })\n \n def update_particles(self):\n \"\"\"Update and draw particles\"\"\"\n alive = []\n for p in self.particles:\n p['x'] += p['vx']\n p['y'] += p['vy']\n p['vy'] += 0.2 # gravity\n p['life'] -= 1\n if p['life'] > 0:\n alive.append(p)\n alpha = p['life'] / p['max_life']\n size = p['size'] * alpha\n color = self.blend_color(p['color'], '#1a1a2e', 1 - alpha)\n self.canvas.create_oval(\n p['x'] - size, p['y'] - size,\n p['x'] + size, p['y'] + size,\n fill=color, outline=''\n )\n self.particles = alive\n \n def draw(self):\n \"\"\"Draw everything\"\"\"\n self.canvas.delete('all')\n \n # Background gradient\n for i in range(self.HEIGHT):\n color_val = int(26 + (40 - 26) * (i / self.HEIGHT))\n color = f'#{color_val:02x}{color_val:02x}{color_val + 20:02x}'\n self.canvas.create_line(0, i, self.WIDTH, i, fill=color)\n \n # Draw grid\n self.draw_grid()\n \n # Sort snake segments by y position for proper depth ordering\n # Also sort by x for proper left-right overlap\n sorted_segments = sorted(enumerate(self.snake), \n key=lambda s: (s[1][1], s[1][0]))\n \n # Draw snake\n for i, (gx, gy) in sorted_segments:\n if i == 0:\n # Head - brighter color\n color = '#00ff88'\n height = 20\n else:\n # Body - gradient from bright to dark\n ratio = i / len(self.snake)\n r = int(0 + 0 * ratio)\n g = int(255 - 150 * ratio)\n b = int(80 - 30 * ratio)\n color = f'#{r:02x}{g:02x}{b:02x}'\n height = int(18 - 6 * ratio)\n \n self.draw_3d_cube(gx, gy, self.CELL_SIZE, color, height=height)\n \n # Draw eyes on head\n if i == 0:\n sx, sy, scale = self.to_screen(gx, gy)\n s = self.CELL_SIZE * scale * 0.9\n eye_size = 3 * scale\n \n if self.direction == 'RIGHT':\n ex1, ey1 = sx + s * 0.2, sy - 8 * scale + s * 0.15\n ex2, ey2 = sx + s * 0.2, sy - 8 * scale + s * 0.45\n elif self.direction == 'LEFT':\n ex1, ey1 = sx - s * 0.2, sy - 8 * scale + s * 0.15\n ex2, ey2 = sx - s * 0.2, sy - 8 * scale + s * 0.45\n elif self.direction == 'UP':\n ex1, ey1 = sx - s * 0.15, sy - 8 * scale + s * 0.1\n ex2, ey2 = sx + s * 0.15, sy - 8 * scale + s * 0.1\n else:\n ex1, ey1 = sx - s * 0.15, sy - 8 * scale + s * 0.5\n ex2, ey2 = sx + s * 0.15, sy - 8 * scale + s * 0.5\n \n self.canvas.create_oval(ex1 - eye_size, ey1 - eye_size, \n ex1 + eye_size, ey1 + eye_size,\n fill='white', outline='')\n self.canvas.create_oval(ex2 - eye_size, ey2 - eye_size,\n ex2 + eye_size, ey2 + eye_size,\n fill='white', outline='')\n \n # Draw food\n if self.food:\n pulse = 1 + 0.1 * math.sin(self.bob_speed * 0.1)\n self.draw_3d_sphere(self.food[0], self.food[1], \n self.CELL_SIZE * 0.4 * pulse, '#ff3366')\n \n self.bob_speed += 1\n \n # Draw particles\n self.update_particles()\n \n # Draw score\n self.canvas.create_text(self.WIDTH // 2, 30, \n text=f\"🐍 SCORE: {self.score}\", \n fill='#00ff88', font=('Courier', 24, 'bold'))\n \n # Draw controls hint\n self.canvas.create_text(self.WIDTH // 2, self.HEIGHT - 20,\n text=\"Arrow Keys: Move | ESC: Quit\",\n fill='#6666aa', font=('Courier', 10))\n \n # Game over screen\n if self.game_over:\n self.canvas.create_rectangle(0, 0, self.WIDTH, self.HEIGHT,\n fill='#000000', stipple='gray50')\n self.canvas.create_text(self.WIDTH // 2, self.HEIGHT // 2 - 40,\n text=\"GAME OVER\", \n fill='#ff3344', font=('Courier', 48, 'bold'))\n self.canvas.create_text(self.WIDTH // 2, self.HEIGHT // 2 + 20,\n text=f\"Score: {self.score}\",\n fill='#ffffff', font=('Courier', 28))\n self.canvas.create_text(self.WIDTH // 2, self.HEIGHT // 2 + 70,\n text=\"Press SPACE to restart\",\n fill='#aaaaaa', font=('Courier', 16))\n \n def restart(self):\n \"\"\"Restart the game\"\"\"\n self.direction = 'RIGHT'\n self.next_direction = 'RIGHT'\n self.snake = [(10, 10), (9, 10), (8, 10)]\n self.food = None\n self.score = 0\n self.game_over = False\n self.speed = 120\n self.particles = []\n self.spawn_food()\n\nif __name__ == '__main__':\n root = tk.Tk()\n game = SnakeGame3D(root)\n root.mainloop()\n```\n\nThis is a good start. Let me refine it more and make sure everything works properly. Let me also think about making the 3D effect more pronounced.\n\nActually, let me think about this more carefully. The user wants a 3D snake game using tkinter. Since tkinter is 2D, I need to create convincing pseudo-3D visuals. Let me make sure the 3D cube rendering is solid and the perspective grid looks good.\n\nLet me also add some nice features:\n- Better color gradients on the snake\n- Smoother 3D perspective\n- Better visual effects\n- Score display\n- Game over screen\n\nLet me refine the code and make it more polished.\n\nI think my approach is solid. Let me finalize the code and make sure it's clean and well-commented.\n\nOne issue - I should make sure the perspective rendering actually looks good. Let me think about the coordinate transformation more carefully.\n\nFor a nice 3D perspective effect:\n- The grid should be drawn as if viewed from above at an angle\n- Objects further from the viewer should appear smaller\n- There should be proper depth ordering (far objects drawn first)\n\nLet me refine the to_screen function:\n\n```python\ndef to_screen(self, gx, gy, z=0):\n \"\"\"Convert grid coordinates to screen coordinates with 3D perspective\"\"\"\n # Center the grid\n cx = gx - self.GRID_W / 2\n cy = gy - self.GRID_H / 2\n \n # Apply perspective - objects further away (higher y) get compressed\n depth_factor = 1.0 + cy * 0.008 # slight perspective\n \n sx = self.board_offset_x + cx * self.CELL_SIZE\n sy = self.board_offset_y + cy * self.CELL_SIZE * self.tilt - z * 0.5\n \n return sx, sy, 1.0\n```\n\nHmm, actually the simpler approach might work better. Let me just make it look good visually without overcomplicating the math.\n\nLet me write the final version with clean code and good visuals.\n\nActually let me reconsider the whole approach. Instead of trying to do perspective projection (which can get messy), let me use an isometric-style view with good 3D cube rendering. This will look cleaner and more consistent.\n\nHere's my plan:\n1. Draw a flat isometric grid as the playing field\n2. Draw snake segments as 3D cubes on top of the grid\n3. Draw food as a glowing sphere\n4. Add shadows, particles, and other visual effects\n5. Proper depth ordering\n\nThe isometric transformation is:\n- screen_x = center_x + (grid_x - grid_y) * tile_width/2\n- screen_y = center_y + (grid_x + grid_y) * tile_height/2 - height_offset\n\nThis gives a nice isometric view. Let me implement this.\n\nActually, wait - for a snake game, an isometric view might make it confusing to play since the grid wouldn't align with the arrow keys intuitively. Let me instead use a simpler top-down perspective with 3D effects:\n\n- Draw the grid as a tilted plane (slight perspective)\n- Draw 3D cubes for snake segments\n- Add depth cues through shadows and shading\n\nLet me finalize the code. I think my original approach was good, let me just clean it up and make sure it works.\n\nLet me write the final version:\n\n```python\nimport tkinter as tk\nimport random\nimport math\n\nclass SnakeGame3D:\n def __init__(self):\n self.root = tk.Tk()\n self.root.title(\"🐍 3D Snake Game\")\n self.root.configure(bg='#0a0a1a')\n self.root.resizable(False, False)\n \n # Canvas\n self.WIDTH = 900\n self.HEIGHT = 650\n self.canvas = tk.Canvas(self.root, width=self.WIDTH, height=self.HEIGHT,\n bg='#0a0a1a', highlightthickness=0)\n self.canvas.pack(padx=10, pady=10)\n \n # Game config\n self.COLS = 20\n self.ROWS = 20\n self.CELL = 28\n self.TILT = 0.55 # perspective tilt factor\n self.CENTER_X = self.WIDTH // 2\n self.CENTER_Y = 280\n \n # Game state\n self.reset()\n \n # Input\n self.root.bind('', self.key)\n \n # Start\n self.tick()\n self.root.mainloop()\n \n def reset(self):\n self.snake = [(10, 10), (9, 10), (8, 10)]\n self.dir = 'R'\n self.next_dir = 'R'\n self.food = None\n self.score = 0\n self.game_over = False\n self.speed = 130\n self.particles = []\n self.frame = 0\n self.spawn_food()\n \n def grid_to_screen(self, gx, gy, z=0):\n \"\"\"Isometric-ish projection\"\"\"\n # Offset from center of grid\n dx = (gx - self.COLS / 2 + 0.5) * self.CELL\n dy = (gy - self.ROWS / 2 + 0.5) * self.CELL\n \n # 3D projection: x stays, y gets tilted, z goes up\n sx = self.CENTER_X + dx\n sy = self.CENTER_Y + dy * self.TILT - z\n \n return sx, sy\n \n def spawn_food(self):\n while True:\n pos = (random.randint(0, self.COLS-1), random.randint(0, self.ROWS-1))\n if pos not in self.snake:\n self.food = pos\n break\n \n def key(self, e):\n if self.game_over:\n if e.keysym == 'space':\n self.reset()\n return\n d = e.keysym\n if d == 'Up' and self.dir != 'D': self.next_dir = 'U'\n elif d == 'Down' and self.dir != 'U': self.next_dir = 'D'\n elif d == 'Left' and self.dir != 'R': self.next_dir = 'L'\n elif d == 'Right' and self.dir != 'L': self.next_dir = 'R'\n \n def tick(self):\n if not self.game_over:\n self.dir = self.next_dir\n self.move()\n self.render()\n self.frame += 1\n self.root.after(self.speed, self.tick)\n \n def move(self):\n hx, hy = self.snake[0]\n if self.dir == 'U': nh = (hx, hy-1)\n elif self.dir == 'D': nh = (hx, hy+1)\n elif self.dir == 'L': nh = (hx-1, hy)\n elif self.dir == 'R': nh = (hx+1, hy)\n \n if nh[0] < 0 or nh[0] >= self.COLS or nh[1] < 0 or nh[1] >= self.ROWS:\n self.game_over = True\n return\n if nh in self.snake:\n self.game_over = True\n return\n \n self.snake.insert(0, nh)\n if nh == self.food:\n self.score += 10\n self.spawn_particles(self.food[0], self.food[1])\n self.spawn_food()\n if self.speed > 60: self.speed -= 2\n else:\n self.snake.pop()\n \n def spawn_particles(self, gx, gy):\n sx, sy = self.grid_to_screen(gx, gy, 20)\n for _ in range(20):\n a = random.uniform(0, math.tau)\n v = random.uniform(1.5, 7)\n self.particles.append({\n 'x': sx, 'y': sy,\n 'vx': math.cos(a) * v,\n 'vy': math.sin(a) * v - 2,\n 'life': random.randint(12, 30),\n 'max': 30,\n 'size': random.uniform(2, 5),\n 'hue': random.choice(['#ff4466', '#ff6688', '#ffaa00', '#ffff44', '#ff8844'])\n })\n \n # --- Rendering ---\n \n def lighten(self, c, n):\n c = c.lstrip('#')\n r = min(255, int(c[0:2], 16) + n)\n g = min(255, int(c[2:4], 16) + n)\n b = min(255, int(c[4:6], 16) + n)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def darken(self, c, n):\n c = c.lstrip('#')\n r = max(0, int(c[0:2], 16) - n)\n g = max(0, int(c[2:4], 16) - n)\n b = max(0, int(c[4:6], 16) - n)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def lerp_color(self, c1, c2, t):\n c1 = c1.lstrip('#'); c2 = c2.lstrip('#')\n r = int(int(c1[0:2], 16) * (1-t) + int(c2[0:2], 16) * t)\n g = int(int(c1[2:4], 16) * (1-t) + int(c2[2:4], 16) * t)\n b = int(int(c1[4:6], 16) * (1-t) + int(c2[4:6], 16) * t)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def draw_iso_cube(self, gx, gy, w, h, color, elev=0):\n \"\"\"Draw a 3D isometric cube at grid pos\"\"\"\n sx, sy = self.grid_to_screen(gx, gy, elev)\n \n # Cube dimensions in screen space\n hw = w / 2\n hh = h * self.TILT / 2\n depth = h # vertical height of the cube\n \n # Top face\n top = self.lighten(color, 50)\n self.canvas.create_polygon(\n sx, sy - depth,\n sx + hw, sy - depth + hh,\n sx, sy - depth + 2*hh,\n sx - hw, sy - depth + hh,\n fill=top, outline=self.darken(color, 30), width=1\n )\n \n # Right face\n right = self.darken(color, 20)\n self.canvas.create_polygon(\n sx + hw, sy - depth + hh,\n sx + hw, sy + hh,\n sx, sy + 2*hh,\n sx, sy - depth + 2*hh,\n fill=right, outline=self.darken(color, 50), width=1\n )\n \n # Left face\n left = self.darken(color, 50)\n self.canvas.create_polygon(\n sx - hw, sy - depth + hh,\n sx - hw, sy + hh,\n sx, sy + 2*hh,\n sx, sy - depth + 2*hh,\n fill=left, outline=self.darken(color, 60), width=1\n )\n \n def draw_food_sphere(self, gx, gy, color='#ff3366'):\n \"\"\"Draw a glowing sphere for food\"\"\"\n sx, sy = self.grid_to_screen(gx, gy, 15)\n pulse = 1 + 0.08 * math.sin(self.frame * 0.15)\n r = 12 * pulse\n \n # Glow\n for i in range(6, 0, -1):\n gr = r + i * 5\n gc = self.lerp_color(color, '#0a0a1a', i * 0.12)\n self.canvas.create_oval(sx-gr, sy-gr*self.TILT, sx+gr, sy+gr*self.TILT,\n fill=gc, outline='')\n \n # Shadow on ground\n shx, shy = self.grid_to_screen(gx, gy, 0)\n self.canvas.create_oval(shx-10, shy-4, shx+10, shy+4,\n fill='#050510', outline='')\n \n # Main sphere\n self.canvas.create_oval(sx-r, sy-r*self.TILT, sx+r, sy+r*self.TILT,\n fill=color, outline=self.darken(color, 60), width=2)\n \n # Highlight\n hr = r * 0.35\n self.canvas.create_oval(sx-hr-r*0.25, sy-hr*self.TILT-r*self.TILT*0.3,\n sx+hr-r*0.25, sy+hr*self.TILT-r*self.TILT*0.3,\n fill=self.lighten(color, 120), outline='')\n \n def draw_grid(self):\n \"\"\"Draw the perspective grid floor\"\"\"\n gc = '#1a1a3a'\n \n for y in range(self.ROWS + 1):\n x1, y1 = self.grid_to_screen(0, y)\n x2, y2 = self.grid_to_screen(self.COLS, y)\n self.canvas.create_line(x1, y1, x2, y2, fill=gc)\n \n for x in range(self.COLS + 1):\n x1, y1 = self.grid_to_screen(x, 0)\n x2, y2 = self.grid_to_screen(x, self.ROWS)\n self.canvas.create_line(x1, y1, x2, y2, fill=gc)\n \n # Border\n pts = []\n for gx, gy in [(0,0), (self.COLS,0), (self.COLS,self.ROWS), (0,self.ROWS)]:\n sx, sy = self.grid_to_screen(gx, gy)\n pts.extend([sx, sy])\n self.canvas.create_polygon(pts, fill='', outline='#3a3a7a', width=3)\n \n def render(self):\n self.canvas.delete('all')\n \n # Background\n for i in range(0, self.HEIGHT, 4):\n t = i / self.HEIGHT\n r = int(10 + 15 * t)\n g = int(10 + 15 * t)\n b = int(26 + 30 * t)\n self.canvas.create_rectangle(0, i, self.WIDTH, i+4, \n fill=f'#{r:02x}{g:02x}{b:02x}', outline='')\n \n self.draw_grid()\n \n # Collect all drawable objects with depth for sorting\n draw_list = []\n \n # Snake segments\n for i, (gx, gy) in enumerate(self.snake):\n depth = gy * 100 + gx # simple depth key\n draw_list.append(('snake', i, gx, gy, depth))\n \n # Food\n if self.food:\n fx, fy = self.food\n depth = fy * 100 + fx\n draw_list.append(('food', 0, fx, fy, depth))\n \n # Sort by depth (back to front)\n draw_list.sort(key=lambda x: x[4])\n \n for item in draw_list:\n if item[0] == 'snake':\n i, gx, gy = item[1], item[2], item[3]\n if i == 0:\n color = '#00ff88'\n h = 22\n else:\n t = i / max(1, len(self.snake) - 1)\n color = self.lerp_color('#00dd66', '#004422', t)\n h = int(20 - 8 * t)\n \n # Shadow\n shx, shy = self.grid_to_screen(gx, gy, 0)\n self.canvas.create_oval(shx-12, shy-5, shx+12, shy+5,\n fill='#050510', outline='')\n \n self.draw_iso_cube(gx, gy, self.CELL - 2, self.CELL - 2, color, h)\n \n # Eyes on head\n if i == 0:\n sx, sy = self.grid_to_screen(gx, gy, h)\n es = 4\n if self.dir == 'R':\n self.canvas.create_oval(sx+3-es, sy-8-es, sx+3+es, sy-8+es, fill='white', outline='')\n self.canvas.create_oval(sx+3-es, sy+2-es, sx+3+es, sy+2+es, fill='white', outline='')\n self.canvas.create_oval(sx+5-es+2, sy-7-es+2, sx+5+es-2, sy-7+es-2, fill='#111', outline='')\n self.canvas.create_oval(sx+5-es+2, sy+3-es+2, sx+5+es-2, sy+3+es-2, fill='#111', outline='')\n elif self.dir == 'L':\n self.canvas.create_oval(sx-3-es, sy-8-es, sx-3+es, sy-8+es, fill='white', outline='')\n self.canvas.create_oval(sx-3-es, sy+2-es, sx-3+es, sy+2+es, fill='white', outline='')\n self.canvas.create_oval(sx-1-es+2, sy-7-es+2, sx-1+es-2, sy-7+es-2, fill='#111', outline='')\n self.canvas.create_oval(sx-1-es+2, sy+3-es+2, sx-1+es-2, sy+3+es-2, fill='#111', outline='')\n elif self.dir == 'U':\n self.canvas.create_oval(sx-6-es, sy-4-es, sx-6+es, sy-4+es, fill='white', outline='')\n self.canvas.create_oval(sx+4-es, sy-4-es, sx+4+es, sy-4+es, fill='white', outline='')\n elif self.dir == 'D':\n self.canvas.create_oval(sx-6-es, sy-es, sx-6+es, sy+es, fill='white', outline='')\n self.canvas.create_oval(sx+4-es, sy-es, sx+4+es, sy+es, fill='white', outline='')\n \n elif item[0] == 'food':\n gx, gy = item[2], item[3]\n self.draw_food_sphere(gx, gy)\n \n # Particles\n alive = []\n for p in self.particles:\n p['x'] += p['vx']\n p['y'] += p['vy']\n p['vy'] += 0.25\n p['life'] -= 1\n if p['life'] > 0:\n alive.append(p)\n t = p['life'] / p['max']\n s = p['size'] * t\n c = self.lerp_color(p['hue'], '#0a0a1a', 1-t)\n self.canvas.create_oval(p['x']-s, p['y']-s, p['x']+s, p['y']+s,\n fill=c, outline='')\n self.particles = alive\n \n # HUD\n self.canvas.create_text(self.WIDTH//2, 25, text=f\"🐍 SCORE: {self.score}\",\n fill='#00ff88', font=('Consolas', 26, 'bold'))\n self.canvas.create_text(self.WIDTH//2, 55, text=f\"SPEED: {max(1, 131 - self.speed)}\",\n fill='#4488aa', font=('Consolas', 12))\n \n self.canvas.create_text(self.WIDTH//2, self.HEIGHT - 15,\n text=\"↑↓←→ Move | SPACE Restart | ESC Quit\",\n fill='#4444aa', font=('Consolas', 10))\n \n if self.game_over:\n self.canvas.create_rectangle(0, 0, self.WIDTH, self.HEIGHT,\n fill='#000000', stipple='gray50')\n self.canvas.create_text(self.WIDTH//2, self.HEIGHT//2 - 50,\n text=\"GAME OVER\", fill='#ff2244',\n font=('Consolas', 52, 'bold'))\n self.canvas.create_text(self.WIDTH//2, self.HEIGHT//2 + 15,\n text=f\"Final Score: {self.score}\", fill='#ffffff',\n font=('Consolas', 28))\n self.canvas.create_text(self.WIDTH//2, self.HEIGHT//2 + 65,\n text=\"Press SPACE to play again\", fill='#aaaaaa',\n font=('Consolas', 16))\n\nif __name__ == '__main__':\n SnakeGame3D()\n```\n\nWait, I realize there's an issue with my approach. The elevation parameter in `draw_iso_cube` is not being used correctly. Let me fix the `draw_iso_cube` method.\n\nThe `elev` parameter should represent how high above the ground the cube sits. The cube itself also has height. So:\n- The base of the cube is at `elev` height\n- The top of the cube is at `elev + cube_height` height\n\nLet me fix this:\n\n```python\ndef draw_iso_cube(self, gx, gy, w, h, color, base_elev=0, cube_height=15):\n \"\"\"Draw a 3D cube at grid position\"\"\"\n # Bottom center of cube\n bx, by = self.grid_to_screen(gx, gy, base_elev)\n # Top center of cube \n tx, ty = self.grid_to_screen(gx, gy, base_elev + cube_height)\n \n hw = w / 2\n hh = h * self.TILT / 2\n \n # Top face at the top\n top = self.lighten(color, 50)\n self.canvas.create_polygon(\n tx, ty - hh, # no, this isn't right\n ...\n )\n```\n\nHmm, this is getting complicated. Let me simplify. The grid_to_screen function already handles z elevation. So:\n\n- `grid_to_screen(gx, gy, 0)` gives the ground position\n- `grid_to_screen(gx, gy, elev)` gives a position elevated by `elev` pixels\n\nFor the cube, I need:\n- Top face at height `elev + cube_h`\n- Side faces from `elev` to `elev + cube_h`\n\nLet me simplify the cube drawing:\n\n```python\ndef draw_iso_cube(self, gx, gy, size, color, elev=0, cube_h=15):\n \"\"\"Draw a 3D cube\"\"\"\n # Ground corners\n left = gx\n right = gx + size/self.CELL # hmm, this doesn't work because size is in pixels\n \n # Let me take a different approach - calculate screen positions directly\n```\n\nOK let me rethink this entirely. I'll calculate the cube vertices directly in screen space.\n\nFor a cube at grid position (gx, gy):\n- It occupies the grid cell from (gx, gy) to (gx+1, gy+1)\n- The corners of the cell on the ground are:\n - (gx, gy), (gx+1, gy), (gx+1, gy+1), (gx, gy+1)\n- These get projected to screen space\n- Then the top face is the same but elevated by cube_h\n\nLet me simplify by computing corner positions:\n\n```python\ndef draw_iso_cube(self, gx, gy, color, elev=0, cube_h=16):\n # Bottom face corners (ground level + elev)\n bl = self.grid_to_screen(gx, gy, elev) # back-left\n br = self.grid_to_screen(gx+1, gy, elev) # back-right\n fr = self.grid_to_screen(gx+1, gy+1, elev) # front-right\n fl = self.grid_to_screen(gx, gy+1, elev) # front-left\n \n # Top face corners\n tbl = self.grid_to_screen(gx, gy, elev + cube_h)\n tbr = self.grid_to_screen(gx+1, gy, elev + cube_h)\n tfr = self.grid_to_screen(gx+1, gy+1, elev + cube_h)\n tfl = self.grid_to_screen(gx, gy+1, elev + cube_h)\n \n # Draw top face\n top_color = self.lighten(color, 40)\n self.canvas.create_polygon(\n *tbl, *tbr, *tfr, *tfl,\n fill=top_color, outline=self.darken(color, 20)\n )\n \n # Draw right face (visible because of perspective tilt)\n right_color = self.darken(color, 20)\n self.canvas.create_polygon(\n *tbr, *tfr, *fr, *br,\n fill=right_color, outline=self.darken(color, 40)\n )\n \n # Draw front face (most visible)\n front_color = self.darken(color, 40)\n self.canvas.create_polygon(\n *tfl, *tfr, *fr, *fl,\n fill=front_color, outline=self.darken(color, 50)\n )\n```\n\nWait, but with my current projection (`grid_to_screen`), the `grid_to_screen` function doesn't handle the full 3D transformation correctly. Let me fix it.\n\nThe issue is that `grid_to_screen` takes grid_x and grid_y as the center of a cell, not as arbitrary points. Let me fix this:\n\n```python\ndef grid_to_screen(self, gx, gy, z=0):\n \"\"\"Convert grid coordinates to screen coordinates with 3D perspective\"\"\"\n # Grid center is at (COLS/2, ROWS/2)\n # Offset from center\n dx = (gx - self.COLS / 2) * self.CELL\n dy = (gy - self.ROWS / 2) * self.CELL\n \n # Apply tilt for y-axis\n sx = self.CENTER_X + dx\n sy = self.CENTER_Y + dy * self.TILT - z\n \n return sx, sy\n```\n\nThis way, grid_to_screen(0, 0) gives the top-left corner, grid_to_screen(20, 20) gives the bottom-right corner, etc.\n\nFor the cube at (gx, gy), the cell corners would be at:\n- grid_to_screen(gx, gy) - top-left\n- grid_to_screen(gx+1, gy) - top-right\n- grid_to_screen(gx+1, gy+1) - bottom-right\n- grid_to_screen(gx, gy+1) - bottom-left\n\nThis should work! Let me rewrite the cube drawing.\n\nActually wait, with this projection, what do we see? Looking at the grid from above at an angle. The y-axis is compressed by TILT. So the grid looks like a parallelogram viewed from above-right.\n\nFor the cube:\n- The top face should be visible (looking from above)\n- The front face (bottom in the grid, i.e., higher y values) should be visible\n- Maybe the right face too\n\nLet me think about which faces to draw. With the perspective tilt (y compressed), we're looking from above. The visible faces of a cube would be:\n- Top face (always visible from above)\n- Front face (the face with higher y, at the bottom of the screen)\n- Right face (the face with higher x, depends on angle)\n\nActually with a simple orthographic tilt, only top and front faces would be visible. The right face would be visible if we also add a slight x rotation, but let's keep it simple.\n\nSo for each cube:\n1. Draw the front face (face at y+1, the bottom face on screen)\n2. Draw the right face (face at x+1, might be slightly visible)\n3. Draw the top face\n\nActually, in a simple oblique projection with tilt on y, only top and front faces are visible. Let me just do those two.\n\nHmm, actually for it to look good as 3D, I should draw all three visible faces (top, front-right, front-left or similar). Let me think about this differently.\n\nIn an isometric-like view with tilt on Y:\n- We see the top face\n- We see the \"south\" face (higher y values, which appear at the bottom of screen)\n\nFor the south face:\n- Bottom-left: grid_to_screen(gx, gy+1, elev)\n- Bottom-right: grid_to_screen(gx+1, gy+1, elev)\n- Top-right: grid_to_screen(gx+1, gy+1, elev+h)\n- Top-left: grid_to_screen(gx, gy+1, elev+h)\n\nFor the top face:\n- Four corners all at elev+h:\n - grid_to_screen(gx, gy, elev+h)\n - grid_to_screen(gx+1, gy, elev+h)\n - grid_to_screen(gx+1, gy+1, elev+h)\n - grid_to_screen(gx, gy+1, elev+h)\n\nAnd optionally the right face:\n- grid_to_screen(gx+1, gy, elev)\n- grid_to_screen(gx+1, gy+1, elev)\n- grid_to_screen(gx+1, gy+1, elev+h)\n- grid_to_screen(gx+1, gy, elev+h)\n\nThis should give a nice 3D cube look! Let me implement this properly.\n\nOK, let me just write the final clean version of the code. I'll be more careful about the geometry this time.\n\n```python\nimport tkinter as tk\nimport random\nimport math\n\nclass Snake3D:\n def __init__(self):\n self.root = tk.Tk()\n self.root.title(\"🐍 3D Snake Game - MiMo\")\n self.root.configure(bg='#080810')\n self.root.resizable(False, False)\n \n self.W, self.H = 900, 680\n self.canvas = tk.Canvas(self.root, width=self.W, height=self.H,\n bg='#080810', highlightthickness=0)\n self.canvas.pack(padx=5, pady=5)\n \n # Grid\n self.COLS, self.ROWS = 20, 20\n self.CELL = 28\n self.TILT = 0.5\n self.OX = self.W // 2\n self.OY = 300\n \n self.reset()\n self.root.bind('', self.on_key)\n self.loop()\n self.root.mainloop()\n \n def reset(self):\n self.snake = [(10, 10), (9, 10), (8, 10)]\n self.dir = 'R'\n self.ndir = 'R'\n self.food = None\n self.score = 0\n self.alive = True\n self.speed = 130\n self.particles = []\n self.tick = 0\n self.spawn_food()\n \n def g2s(self, gx, gy, z=0):\n \"\"\"Grid to screen with perspective\"\"\"\n dx = (gx - self.COLS / 2) * self.CELL\n dy = (gy - self.ROWS / 2) * self.CELL\n return (self.OX + dx, self.OY + dy * self.TILT - z)\n \n def spawn_food(self):\n while True:\n p = (random.randint(0, self.COLS-1), random.randint(0, self.ROWS-1))\n if p not in self.snake:\n self.food = p\n return\n \n def on_key(self, e):\n if not self.alive:\n if e.keysym == 'space': self.reset()\n return\n k = e.keysym\n if k == 'Up' and self.dir != 'D': self.ndir = 'U'\n elif k == 'Down' and self.dir != 'U': self.ndir = 'D'\n elif k == 'Left' and self.dir != 'R': self.ndir = 'L'\n elif k == 'Right' and self.dir != 'L': self.ndir = 'R'\n \n def loop(self):\n if self.alive:\n self.dir = self.ndir\n self.step()\n self.draw()\n self.tick += 1\n self.root.after(self.speed, self.loop)\n \n def step(self):\n hx, hy = self.snake[0]\n if self.dir == 'U': nh = (hx, hy-1)\n elif self.dir == 'D': nh = (hx, hy+1)\n elif self.dir == 'L': nh = (hx-1, hy)\n else: nh = (hx+1, hy)\n \n if not (0 <= nh[0] < self.COLS and 0 <= nh[1] < self.ROWS) or nh in self.snake:\n self.alive = False\n self.burst(self.snake[0][0], self.snake[0][1], '#ff2244')\n return\n \n self.snake.insert(0, nh)\n if nh == self.food:\n self.score += 10\n self.burst(*self.food, '#ff6644')\n self.spawn_food()\n if self.speed > 55: self.speed -= 2\n else:\n self.snake.pop()\n \n def burst(self, gx, gy, c):\n sx, sy = self.g2s(gx, gy, 20)\n for _ in range(25):\n a = random.uniform(0, 6.28)\n v = random.uniform(2, 8)\n self.particles.append({\n 'x': sx, 'y': sy, 'vx': math.cos(a)*v, 'vy': math.sin(a)*v-2,\n 'life': random.randint(10, 28), 'max': 28,\n 'sz': random.uniform(2, 5), 'c': c\n })\n \n # --- Colors ---\n def lighter(self, c, n):\n c = c.lstrip('#')\n return '#{:02x}{:02x}{:02x}'.format(\n min(255, int(c[0:2], 16)+n),\n min(255, int(c[2:4], 16)+n),\n min(255, int(c[4:6], 16)+n))\n \n def darker(self, c, n):\n c = c.lstrip('#')\n return '#{:02x}{:02x}{:02x}'.format(\n max(0, int(c[0:2], 16)-n),\n max(0, int(c[2:4], 16)-n),\n max(0, int(c[4:6], 16)-n))\n \n def lerp(self, a, b, t):\n a = a.lstrip('#'); b = b.lstrip('#')\n return '#{:02x}{:02x}{:02x}'.format(\n int(int(a[0:2],16)*(1-t)+int(b[0:2],16)*t),\n int(int(a[2:4],16)*(1-t)+int(b[2:4],16)*t),\n int(int(a[4:6],16)*(1-t)+int(b[4:6],16)*t))\n \n # --- 3D Drawing ---\n def draw_cube(self, gx, gy, color, elev=0, h=16):\n \"\"\"Draw a 3D cube at grid cell (gx, gy)\"\"\"\n # Top face corners (at elev + h)\n t00 = self.g2s(gx, gy, elev+h)\n t10 = self.g2s(gx+1, gy, elev+h)\n t11 = self.g2s(gx+1, gy+1, elev+h)\n t01 = self.g2s(gx, gy+1, elev+h)\n \n # Bottom face corners (at elev)\n b00 = self.g2s(gx, gy, elev)\n b10 = self.g2s(gx+1, gy, elev)\n b11 = self.g2s(gx+1, gy+1, elev)\n b01 = self.g2s(gx, gy+1, elev)\n \n # Front face (south face, higher y)\n front = self.darker(color, 40)\n self.canvas.create_polygon(\n *t01, *t11, *b11, *b01,\n fill=front, outline=self.darker(color, 60), width=1)\n \n # Right face (east face, higher x)\n right = self.darker(color, 20)\n self.canvas.create_polygon(\n *t10, *t11, *b11, *b10,\n fill=right, outline=self.darker(color, 50), width=1)\n \n # Top face (brightest)\n top = self.lighter(color, 30)\n self.canvas.create_polygon(\n *t00, *t10, *t11, *t01,\n fill=top, outline=self.darker(color, 20), width=1)\n \n def draw_sphere(self, gx, gy, r, color, elev=20):\n \"\"\"Draw a glowing sphere\"\"\"\n sx, sy = self.g2s(gx + 0.5, gy + 0.5, elev)\n pulse = 1 + 0.1 * math.sin(self.tick * 0.15)\n r *= pulse\n \n # Glow\n for i in range(8, 0, -1):\n gr = r + i * 4\n gc = self.lerp(color, '#080810', i * 0.1)\n self.canvas.create_oval(sx-gr, sy-gr*self.TILT, sx+gr, sy+gr*self.TILT,\n fill=gc, outline='')\n \n # Shadow\n shx, shy = self.g2s(gx+0.5, gy+0.5, 0)\n self.canvas.create_oval(shx-10, shy-5, shx+10, shy+5,\n fill='#040408', outline='')\n \n # Body\n self.canvas.create_oval(sx-r, sy-r*self.TILT, sx+r, sy+r*self.TILT,\n fill=color, outline=self.darker(color, 50), width=2)\n \n # Highlight\n hr = r * 0.3\n self.canvas.create_oval(\n sx-hr-r*0.3, sy-hr*self.TILT-r*self.TILT*0.4,\n sx+hr-r*0.3, sy+hr*self.TILT-r*self.TILT*0.4,\n fill=self.lighter(color, 120), outline='')\n \n def draw_grid(self):\n \"\"\"Draw perspective grid\"\"\"\n gc = '#161630'\n for y in range(self.ROWS + 1):\n p1 = self.g2s(0, y); p2 = self.g2s(self.COLS, y)\n self.canvas.create_line(*p1, *p2, fill=gc)\n for x in range(self.COLS + 1):\n p1 = self.g2s(x, 0); p2 = self.g2s(x, self.ROWS)\n self.canvas.create_line(*p1, *p2, fill=gc)\n \n # Border\n pts = []\n for g in [(0,0),(self.COLS,0),(self.COLS,self.ROWS),(0,self.ROWS)]:\n pts.extend(self.g2s(*g))\n self.canvas.create_polygon(pts, fill='', outline='#3a3a80', width=3)\n \n def draw(self):\n self.canvas.delete('all')\n \n # Gradient background\n for i in range(0, self.H, 3):\n t = i / self.H\n r, g, b = int(8+12*t), int(8+12*t), int(16+24*t)\n self.canvas.create_line(0, i, self.W, i+3, fill=f'#{r:02x}{g:02x}{b:02x}')\n \n self.draw_grid()\n \n # Depth-sorted rendering\n items = []\n for i, (gx, gy) in enumerate(self.snake):\n items.append(('s', i, gx, gy, gy * 100 + gx))\n if self.food:\n fx, fy = self.food\n items.append(('f', 0, fx, fy, fy * 100 + fx))\n items.sort(key=lambda x: x[4])\n \n for kind, idx, gx, gy, _ in items:\n if kind == 's':\n # Shadow\n shx, shy = self.g2s(gx+0.5, gy+0.5, 0)\n self.canvas.create_oval(shx-14, shy-6, shx+14, shy+6,\n fill='#04040a', outline='')\n \n if idx == 0:\n color, h = '#00ff88', 20\n else:\n t = idx / max(1, len(self.snake)-1)\n color = self.lerp('#00ee66', '#003318', t)\n h = int(18 - 8 * t)\n self.draw_cube(gx, gy, color, elev=2, h=h)\n \n # Eyes on head\n if idx == 0:\n self.draw_eyes(gx, gy, 2 + h)\n else:\n self.draw_sphere(gx, gy, 12, '#ff3366')\n \n # Particles\n alive = []\n for p in self.particles:\n p['x'] += p['vx']; p['y'] += p['vy']; p['vy'] += 0.3; p['life'] -= 1\n if p['life'] > 0:\n alive.append(p)\n t = p['life'] / p['max']\n s = p['sz'] * t\n c = self.lerp(p['c'], '#080810', 1-t)\n self.canvas.create_oval(p['x']-s, p['y']-s, p['x']+s, p['y']+s, fill=c, outline='')\n self.particles = alive\n \n # HUD\n self.canvas.create_text(self.W//2, 25, text=f\"🐍 SCORE: {self.score}\",\n fill='#00ff88', font=('Consolas', 28, 'bold'))\n self.canvas.create_text(self.W//2, 58, text=f\"Speed Level: {max(1, 131-self.speed)//2}\",\n fill='#4488aa', font=('Consolas', 12))\n self.canvas.create_text(self.W//2, self.H-18,\n text=\"Arrow Keys: Move | SPACE: Restart | ESC: Quit\",\n fill='#3333aa', font=('Consolas', 10))\n \n if not self.alive:\n self.canvas.create_rectangle(0, 0, self.W, self.H, fill='#000000', stipple='gray50')\n self.canvas.create_text(self.W//2, self.H//2-55, text=\"GAME OVER\",\n fill='#ff2244', font=('Consolas', 54, 'bold'))\n self.canvas.create_text(self.W//2, self.H//2+10, text=f\"Final Score: {self.score}\",\n fill='#ffffff', font=('Consolas', 30))\n self.canvas.create_text(self.W//2, self.H//2+60, text=\"Press SPACE to restart\",\n fill='#aaaaaa', font=('Consolas', 16))\n \n def draw_eyes(self, gx, gy, elev):\n sx, sy = self.g2s(gx+0.5, gy+0.5, elev)\n es = 3.5\n ox, oy = 0, 0\n if self.dir == 'R': ox = 5\n elif self.dir == 'L': ox = -5\n elif self.dir == 'U': oy = -5\n else: oy = 5\n \n # Calculate eye positions based on direction\n if self.dir in ('R', 'L'):\n e1 = (ox, -6)\n e2 = (ox, 6)\n else:\n e1 = (-6, oy)\n e2 = (6, oy)\n \n for ex, ey in [e1, e2]:\n self.canvas.create_oval(sx+ex-es, sy+ey-es, sx+ex+es, sy+ey+es,\n fill='white', outline='#333')\n self.canvas.create_oval(sx+ex-es/2, sy+ey-es/2, sx+ex+es/2, sy+ey+es/2,\n fill='#111', outline='')\n\nSnake3D()\n```\n\nHmm, I realize the eyes might not look great. Let me simplify and make them look better.\n\nActually, let me also reconsider the g2s function. The issue is that with just a Y tilt, the cube won't look very 3D from certain angles. Let me add a slight X tilt too to make it look more like a true isometric view.\n\nActually, let me keep it simple. The Y tilt alone should give a decent 3D look. Let me finalize the code and make sure it works properly.\n\nLet me also handle the ESC key to quit.\n\nLet me write the final polished version:\n\n```python\nimport tkinter as tk\nimport random\nimport math\n\nclass Snake3D:\n def __init__(self):\n self.root = tk.Tk()\n self.root.title(\"🐍 3D Snake Game\")\n self.root.configure(bg='#080810')\n self.root.resizable(False, False)\n \n self.W, self.H = 900, 680\n self.canvas = tk.Canvas(self.root, width=self.W, height=self.H,\n bg='#080810', highlightthickness=0)\n self.canvas.pack(padx=5, pady=5)\n \n # Grid config\n self.COLS = 20\n self.ROWS = 20\n self.CELL = 28\n self.TILT = 0.5 # Y compression factor\n self.OX = self.W // 2\n self.OY = 300\n \n # Game state\n self.reset()\n \n # Input\n self.root.bind('', self.on_key)\n \n # Start game loop\n self.game_loop()\n self.root.mainloop()\n \n def reset(self):\n self.snake = [(10, 10), (9, 10), (8, 10)]\n self.dir = 'R'\n self.next_dir = 'R'\n self.food = None\n self.score = 0\n self.alive = True\n self.speed = 130\n self.particles = []\n self.frame = 0\n self.spawn_food()\n \n def g2s(self, gx, gy, z=0):\n \"\"\"Convert grid coordinates to screen coordinates with pseudo-3D perspective\"\"\"\n dx = (gx - self.COLS / 2) * self.CELL\n dy = (gy - self.ROWS / 2) * self.CELL\n sx = self.OX + dx\n sy = self.OY + dy * self.TILT - z\n return (sx, sy)\n \n def spawn_food(self):\n while True:\n pos = (random.randint(0, self.COLS - 1), random.randint(0, self.ROWS - 1))\n if pos not in self.snake:\n self.food = pos\n return\n \n def on_key(self, e):\n if not self.alive:\n if e.keysym == 'space':\n self.reset()\n return\n \n k = e.keysym\n if k == 'Up' and self.dir != 'D':\n self.next_dir = 'U'\n elif k == 'Down' and self.dir != 'U':\n self.next_dir = 'D'\n elif k == 'Left' and self.dir != 'R':\n self.next_dir = 'L'\n elif k == 'Right' and self.dir != 'L':\n self.next_dir = 'R'\n elif k == 'Escape':\n self.root.quit()\n \n def game_loop(self):\n if self.alive:\n self.dir = self.next_dir\n self.step()\n self.render()\n self.frame += 1\n self.root.after(self.speed, self.game_loop)\n \n def step(self):\n hx, hy = self.snake[0]\n moves = {'U': (0, -1), 'D': (0, 1), 'L': (-1, 0), 'R': (1, 0)}\n dx, dy = moves[self.dir]\n nh = (hx + dx, hy + dy)\n \n # Wall collision\n if not (0 <= nh[0] < self.COLS and 0 <= nh[1] < self.ROWS):\n self.alive = False\n self.spawn_burst(self.snake[0][0], self.snake[0][1], '#ff2244')\n return\n \n # Self collision\n if nh in self.snake:\n self.alive = False\n self.spawn_burst(self.snake[0][0], self.snake[0][1], '#ff2244')\n return\n \n self.snake.insert(0, nh)\n \n if nh == self.food:\n self.score += 10\n self.spawn_burst(self.food[0], self.food[1], '#ff6644')\n self.spawn_food()\n if self.speed > 55:\n self.speed -= 2\n else:\n self.snake.pop()\n \n def spawn_burst(self, gx, gy, color):\n \"\"\"Create particle burst at grid position\"\"\"\n sx, sy = self.g2s(gx + 0.5, gy + 0.5, 20)\n for _ in range(25):\n angle = random.uniform(0, math.tau)\n vel = random.uniform(2, 8)\n self.particles.append({\n 'x': sx, 'y': sy,\n 'vx': math.cos(angle) * vel,\n 'vy': math.sin(angle) * vel - 3,\n 'life': random.randint(10, 28),\n 'max_life': 28,\n 'size': random.uniform(2, 5),\n 'color': color\n })\n \n # ---- Color helpers ----\n \n @staticmethod\n def lighter(hex_color, amount):\n h = hex_color.lstrip('#')\n r = min(255, int(h[0:2], 16) + amount)\n g = min(255, int(h[2:4], 16) + amount)\n b = min(255, int(h[4:6], 16) + amount)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n @staticmethod\n def darker(hex_color, amount):\n h = hex_color.lstrip('#')\n r = max(0, int(h[0:2], 16) - amount)\n g = max(0, int(h[2:4], 16) - amount)\n b = max(0, int(h[4:6], 16) - amount)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n @staticmethod\n def lerp_color(c1, c2, t):\n a = c1.lstrip('#')\n b = c2.lstrip('#')\n r = int(int(a[0:2], 16) * (1 - t) + int(b[0:2], 16) * t)\n g = int(int(a[2:4], 16) * (1 - t) + int(b[2:4], 16) * t)\n b = int(int(a[4:6], 16) * (1 - t) + int(b[4:6], 16) * t)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n # ---- 3D Drawing ----\n \n def draw_cube(self, gx, gy, color, elev=0, height=16):\n \"\"\"Draw a pseudo-3D cube at grid cell (gx, gy)\"\"\"\n # Top face corners (at elevation + height)\n t_tl = self.g2s(gx, gy, elev + height)\n t_tr = self.g2s(gx + 1, gy, elev + height)\n t_br = self.g2s(gx + 1, gy + 1, elev + height)\n t_bl = self.g2s(gx, gy + 1, elev + height)\n \n # Bottom face corners (at elevation)\n b_tl = self.g2s(gx, gy, elev)\n b_tr = self.g2s(gx + 1, gy, elev)\n b_br = self.g2s(gx + 1, gy + 1, elev)\n b_bl = self.g2s(gx, gy + 1, elev)\n \n # Front face (south side - visible because we look from above)\n front_col = self.darker(color, 40)\n self.canvas.create_polygon(\n *t_bl, *t_br, *b_br, *b_bl,\n fill=front_col, outline=self.darker(color, 65), width=1)\n \n # Right face (east side)\n right_col = self.darker(color, 20)\n self.canvas.create_polygon(\n *t_tr, *t_br, *b_br, *b_tr,\n fill=right_col, outline=self.darker(color, 55), width=1)\n \n # Top face (brightest)\n top_col = self.lighter(color, 30)\n self.canvas.create_polygon(\n *t_tl, *t_tr, *t_br, *t_bl,\n fill=top_col, outline=self.darker(color, 25), width=1)\n \n def draw_food_glow(self, gx, gy):\n \"\"\"Draw a glowing 3D sphere as food\"\"\"\n cx, cy = gx + 0.5, gy + 0.5\n sx, sy = self.g2s(cx, cy, 18)\n \n pulse = 1 + 0.12 * math.sin(self.frame * 0.15)\n r = 13 * pulse\n base_color = '#ff3366'\n \n # Outer glow layers\n for i in range(8, 0, -1):\n gr = r + i * 5\n gc = self.lerp_color(base_color, '#080810', i * 0.1)\n self.canvas.create_oval(\n sx - gr, sy - gr * self.TILT,\n sx + gr, sy + gr * self.TILT,\n fill=gc, outline='')\n \n # Shadow on ground\n shx, shy = self.g2s(cx, cy, 0)\n self.canvas.create_oval(\n shx - 12, shy - 5, shx + 12, shy + 5,\n fill='#04040a', outline='')\n \n # Main sphere body\n self.canvas.create_oval(\n sx - r, sy - r * self.TILT,\n sx + r, sy + r * self.TILT,\n fill=base_color, outline=self.darker(base_color, 50), width=2)\n \n # Specular highlight\n hr = r * 0.3\n hx_off = r * 0.25\n hy_off = r * 0.35 * self.TILT\n self.canvas.create_oval(\n sx - hx_off - hr, sy - hy_off - hr,\n sx - hx_off + hr, sy - hy_off + hr,\n fill=self.lighter(base_color, 130), outline='')\n \n def draw_grid(self):\n \"\"\"Draw the 3D perspective grid floor\"\"\"\n grid_color = '#161630'\n \n # Horizontal lines\n for y in range(self.ROWS + 1):\n p1 = self.g2s(0, y)\n p2 = self.g2s(self.COLS, y)\n self.canvas.create_line(*p1, *p2, fill=grid_color)\n \n # Vertical lines\n for x in range(self.COLS + 1):\n p1 = self.g2s(x, 0)\n p2 = self.g2s(x, self.ROWS)\n self.canvas.create_line(*p1, *p2, fill=grid_color)\n \n # Border frame\n corners = [(0, 0), (self.COLS, 0), (self.COLS, self.ROWS), (0, self.ROWS)]\n pts = []\n for c in corners:\n pts.extend(self.g2s(*c))\n self.canvas.create_polygon(pts, fill='', outline='#3a3a80', width=3)\n \n def draw_eyes(self, gx, gy, elev):\n \"\"\"Draw eyes on snake head\"\"\"\n sx, sy = self.g2s(gx + 0.5, gy + 0.5, elev)\n \n # Eye positions based on direction\n offset = 6\n if self.dir == 'R':\n positions = [(offset, -5), (offset, 5)]\n elif self.dir == 'L':\n positions = [(-offset, -5), (-offset, 5)]\n elif self.dir == 'U':\n positions = [(-5, -offset), (5, -offset)]\n else: # D\n positions = [(-5, offset), (5, offset)]\n \n for ex, ey in positions:\n # White of eye\n er = 3.5\n self.canvas.create_oval(\n sx + ex - er, sy + ey - er,\n sx + ex + er, sy + ey + er,\n fill='white', outline='#222')\n # Pupil\n pr = 1.8\n self.canvas.create_oval(\n sx + ex - pr, sy + ey - pr,\n sx + ex + pr, sy + ey + pr,\n fill='#111', outline='')\n \n # ---- Main Render ----\n \n def render(self):\n self.canvas.delete('all')\n \n # Gradient background\n for i in range(0, self.H, 4):\n t = i / self.H\n r = int(8 + 12 * t)\n g = int(8 + 12 * t)\n b = int(16 + 28 * t)\n self.canvas.create_rectangle(0, i, self.W, i + 4,\n fill=f'#{r:02x}{g:02x}{b:02x}', outline='')\n \n # Grid\n self.draw_grid()\n \n # Collect and sort all objects by depth (painter's algorithm)\n render_list = []\n \n for i, (gx, gy) in enumerate(self.snake):\n render_list.append(('snake', i, gx, gy, gy * 1000 + gx))\n \n if self.food:\n fx, fy = self.food\n render_list.append(('food', 0, fx, fy, fy * 1000 + fx))\n \n # Sort back-to-front\n render_list.sort(key=lambda item: item[4])\n \n # Draw sorted items\n for kind, idx, gx, gy, _ in render_list:\n # Draw shadow first (on ground)\n shx, shy = self.g2s(gx + 0.5, gy + 0.5, 0)\n shadow_size = 15 if kind == 'snake' else 12\n self.canvas.create_oval(\n shx - shadow_size, shy - shadow_size * self.TILT,\n shx + shadow_size, shy + shadow_size * self.TILT,\n fill='#04040a', outline='')\n \n if kind == 'snake':\n if idx == 0:\n # Head\n color = '#00ff88'\n h = 20\n else:\n # Body - gradient from bright to dark\n t = idx / max(1, len(self.snake) - 1)\n color = self.lerp_color('#00dd66', '#003318', t)\n h = int(18 - 8 * t)\n \n self.draw_cube(gx, gy, color, elev=2, height=h)\n \n # Draw eyes on head\n if idx == 0:\n self.draw_eyes(gx, gy, 2 + h + 1)\n \n elif kind == 'food':\n self.draw_food_glow(gx, gy)\n \n # Particles\n new_particles = []\n for p in self.particles:\n p['x'] += p['vx']\n p['y'] += p['vy']\n p['vy'] += 0.3 # gravity\n p['life'] -= 1\n \n if p['life'] > 0:\n new_particles.append(p)\n life_ratio = p['life'] / p['max_life']\n s = p['size'] * life_ratio\n c = self.lerp_color(p['color'], '#080810', 1 - life_ratio)\n self.canvas.create_oval(\n p['x'] - s, p['y'] - s,\n p['x'] + s, p['y'] + s,\n fill=c, outline='')\n \n self.particles = new_particles\n \n # ---- HUD ----\n self.canvas.create_text(\n self.W // 2, 28,\n text=f\"🐍 SCORE: {self.score}\",\n fill='#00ff88', font=('Consolas', 28, 'bold'))\n \n speed_level = max(1, (131 - self.speed) // 2)\n self.canvas.create_text(\n self.W // 2, 60,\n text=f\"Speed Level: {speed_level}\",\n fill='#4488aa', font=('Consolas', 12))\n \n self.canvas.create_text(\n self.W // 2, self.H - 18,\n text=\"↑↓←→ Move | SPACE Restart | ESC Quit\",\n fill='#3333aa', font=('Consolas', 10))\n \n # ---- Game Over Overlay ----\n if not self.alive:\n self.canvas.create_rectangle(\n 0, 0, self.W, self.H,\n fill='#000000', stipple='gray50')\n \n self.canvas.create_text(\n self.W // 2, self.H // 2 - 55,\n text=\"GAME OVER\",\n fill='#ff2244', font=('Consolas', 54, 'bold'))\n \n self.canvas.create_text(\n self.W // 2, self.H // 2 + 10,\n text=f\"Final Score: {self.score}\",\n fill='#ffffff', font=('Consolas', 30))\n \n self.canvas.create_text(\n self.W // 2, self.H // 2 + 60,\n text=\"Press SPACE to restart\",\n fill='#aaaaaa', font=('Consolas', 16))\n\n\nif __name__ == '__main__':\n Snake3D()\n```\n\nThis looks pretty good! Let me review it one more time...\n\nOne thing I notice - the `draw_eyes` function might not work well because the eye positions relative to the grid cell center need to account for the cell size. Let me adjust.\n\nActually, the eyes should be positioned relative to the screen center of the cube. The cube's top face center would be at g2s(gx+0.5, gy+0.5, elev). The eye positions are offsets from that center in screen space. I think my current implementation should work, but the offset values might need tuning.\n\nLet me also make sure the depth sorting works correctly. In an oblique projection (tilt on Y only), objects with higher Y values should be drawn later (they appear closer to the viewer). The sorting key `gy * 1000 + gx` should work - objects with higher gy are drawn later. For same gy, higher gx is drawn later (though this doesn't matter much in a tilt-only projection).\n\nActually, there's a subtle issue: the snake body segments might overlap in depth. The tail should be drawn before the body, which should be drawn before the head. Since the head is at index 0, and the tail is at the end, and they might have different gy values, the depth sort might cause some segments to overlap incorrectly.\n\nBut for most gameplay scenarios, this should look fine. The head will be drawn on top if it's at a higher gy, and body segments will be properly layered.\n\nLet me also check: do I need to handle the case where the snake wraps around the grid? No, because the game ends when hitting a wall (no wrapping).\n\nI think the code is ready. Let me also add a nice title/splash screen or at least make the initial state look good.\n\nActually, let me keep it simple. The game works as described. Let me finalize.\n\nOne more thing - I should make the particles spawn from the food position in screen space. Let me double-check that `spawn_burst` is called with grid coordinates, and it converts to screen space. Yes, it does via `g2s`.\n\nLet me finalize the code. I think it's ready.\n\nWait, let me also reconsider the shadow drawing. Currently I draw shadows for all snake segments and the food in the render loop. The shadows are drawn at ground level. This should be fine.\n\nActually, I realized there might be a performance issue with the gradient background. Creating that many canvas items (lines) every frame could be slow. Let me optimize by using fewer bands or creating the background once.\n\nFor tkinter, drawing many items each frame with `delete('all')` can be slow. Let me consider optimizing:\n1. Reduce gradient bands (use larger steps)\n2. Or use a solid dark background\n\nLet me use a simpler background with just a few bands to improve performance.\n\nAlso, the grid lines are drawn every frame. Since they don't change, I could cache them. But with `delete('all')`, everything is redrawn. Let me keep it simple for now.\n\nActually, for the gradient background, using steps of 4 pixels means about 170 rectangles for a 680px height. That should be fine.\n\nLet me finalize and present the code. I think it's good enough.\n\nOne last thought - the `draw_eyes` function. The eye offsets need to be in screen space. Let me trace through:\n\nFor direction 'R':\n- We want eyes on the right side of the head\n- The head cube's top face center is at g2s(gx+0.5, gy+0.5, elev)\n- In screen space, \"right\" means positive X\n- So positions = [(offset, -5), (offset, 5)] means two eyes to the right, one slightly up and one slightly down\n\nThis should work for a simple implementation. The eyes won't be perfectly positioned for all directions, but they'll give a good indication of the snake's facing direction.\n\nOK I'm done. Let me write the final clean version.\n\nActually, I want to reconsider one more time. The user said \"usahakan 3d\" (try to make it 3D). So they really want the 3D effect to be prominent. Let me make sure the 3D cubes look good.\n\nThe key to making the 3D effect convincing is:\n1. The top face should be clearly visible (bright)\n2. The front face should be darker\n3. The right face should be medium brightness\n4. Shadows should ground the objects\n5. The grid should give perspective cues\n\nI think my implementation covers all of these. Let me finalize.\n\nLet me write the absolute final version now with some minor improvements for visual polish.","reasoning_details":[{"type":"reasoning.text","text":"The user is asking me to create a Snake game using Python's tkinter library, and they want it to be as 3D-looking as possible. Since tkinter is a 2D library, I'll need to create a pseudo-3D effect using perspective rendering, shading, and visual techniques to make it look like a 3D game.\n\nLet me create a visually impressive snake game with pseudo-3D effects including:\n1. Isometric or perspective view\n2. 3D-looking snake segments with shadows and highlights\n3. 3D-looking food with glowing effects\n4. Grid with perspective\n5. Shadows\n6. Gradient backgrounds\n7. Particle effects\n\nLet me build this step by step.\n\nI'll create a snake game that uses perspective projection to give a 3D feel, with:\n- A 3D perspective grid\n- Snake blocks that look like 3D cubes\n- Food that looks like a 3D sphere\n- Shadows cast on the ground\n- Smooth animations\n- Score display\n\nLet me write a comprehensive implementation.\n\nI'll use a pseudo-3D approach where:\n- The game board is rendered in a tilted perspective (like isometric)\n- Snake segments are drawn as 3D cubes with proper shading\n- Food items have a glowing 3D appearance\n- There's a ground plane with grid lines\n\nLet me code this up properly.\n\n```python\nimport tkinter as tk\nimport random\nimport math\n\nclass SnakeGame3D:\n def __init__(self, root):\n self.root = root\n self.root.title(\"🐍 3D Snake Game\")\n self.root.resizable(False, False)\n \n # Game settings\n self.WIDTH = 800\n self.HEIGHT = 600\n self.CELL_SIZE = 25\n self.GRID_W = 20\n self.GRID_H = 20\n \n # 3D perspective settings\n self.cam_height = 300\n self.cam_dist = 500\n self.tilt = 0.6 # tilt angle factor\n self.board_offset_x = 400\n self.board_offset_y = 250\n \n # Canvas\n self.canvas = tk.Canvas(root, width=self.WIDTH, height=self.HEIGHT, bg='#1a1a2e', highlightthickness=0)\n self.canvas.pack()\n \n # Game state\n self.direction = 'RIGHT'\n self.next_direction = 'RIGHT'\n self.snake = [(10, 10), (9, 10), (8, 10)]\n self.food = None\n self.score = 0\n self.game_over = False\n self.speed = 120\n self.particles = []\n self.bob_offset = 0\n self.bob_speed = 0\n \n self.spawn_food()\n \n # Bind keys\n self.root.bind('', self.on_key)\n \n # Start game loop\n self.update()\n \n def to_screen(self, gx, gy, z=0):\n \"\"\"Convert grid coordinates to screen coordinates with 3D perspective\"\"\"\n # Center the grid\n cx = gx - self.GRID_W / 2\n cy = gy - self.GRID_H / 2\n \n # Apply perspective transformation\n scale = self.cam_dist / (self.cam_dist + z)\n \n sx = self.board_offset_x + cx * self.CELL_SIZE * scale\n sy = self.board_offset_y + cy * self.CELL_SIZE * self.tilt * scale - z * scale * 0.5\n \n return sx, sy, scale\n \n def draw_3d_cube(self, x, y, size, color, height=15, darken=0):\n \"\"\"Draw a pseudo-3D cube at grid position (x, y)\"\"\"\n sx, sy, scale = self.to_screen(x, y)\n s = size * scale * 0.9\n h = height * scale\n \n # Shadow on ground\n shadow_color = '#0d0d1a'\n points_shadow = [\n sx - s/2 + 2, sy + 2,\n sx + s/2 + 2, sy + 2,\n sx + s/2 + 2, sy + s * self.tilt + 2,\n sx - s/2 + 2, sy + s * self.tilt + 2\n ]\n self.canvas.create_polygon(points_shadow, fill=shadow_color, outline='')\n \n # Top face (brightest)\n top_color = self.lighten_color(color, 40 + darken)\n points_top = [\n sx, sy - h,\n sx + s/2, sy - h + s * self.tilt / 2,\n sx, sy - h + s * self.tilt,\n sx - s/2, sy - h + s * self.tilt / 2\n ]\n self.canvas.create_polygon(points_top, fill=top_color, outline=self.darken_color(color, 30), width=1)\n \n # Right face (medium)\n right_color = self.darken_color(color, 20 - darken)\n points_right = [\n sx + s/2, sy - h + s * self.tilt / 2,\n sx + s/2, sy + s * self.tilt / 2,\n sx, sy + s * self.tilt,\n sx, sy - h + s * self.tilt\n ]\n self.canvas.create_polygon(points_right, fill=right_color, outline=self.darken_color(color, 50), width=1)\n \n # Left face (darkest)\n left_color = self.darken_color(color, 40 - darken)\n points_left = [\n sx - s/2, sy - h + s * self.tilt / 2,\n sx - s/2, sy + s * self.tilt / 2,\n sx, sy + s * self.tilt,\n sx, sy - h + s * self.tilt\n ]\n self.canvas.create_polygon(points_left, fill=left_color, outline=self.darken_color(color, 50), width=1)\n \n def draw_3d_sphere(self, x, y, radius, color):\n \"\"\"Draw a pseudo-3D sphere (food)\"\"\"\n sx, sy, scale = self.to_screen(x, y)\n r = radius * scale\n \n # Glow effect\n for i in range(5, 0, -1):\n glow_r = r + i * 4 * scale\n alpha_color = self.blend_color(color, '#1a1a2e', i * 0.15)\n self.canvas.create_oval(\n sx - glow_r, sy - glow_r * self.tilt,\n sx + glow_r, sy + glow_r * self.tilt,\n fill=alpha_color, outline=''\n )\n \n # Shadow\n shadow_r = r * 0.8\n self.canvas.create_oval(\n sx - shadow_r + 3, sy - shadow_r * self.tilt * 0.5 + 5,\n sx + shadow_r + 3, sy + shadow_r * self.tilt * 0.5 + 5,\n fill='#0d0d1a', outline=''\n )\n \n # Main sphere\n self.canvas.create_oval(\n sx - r, sy - r * self.tilt,\n sx + r, sy + r * self.tilt,\n fill=color, outline=self.darken_color(color, 60), width=2\n )\n \n # Highlight\n hr = r * 0.35\n self.canvas.create_oval(\n sx - hr - r * 0.2, sy - hr * self.tilt - r * self.tilt * 0.3,\n sx + hr - r * 0.2, sy + hr * self.tilt - r * self.tilt * 0.3,\n fill=self.lighten_color(color, 100), outline=''\n )\n \n def draw_grid(self):\n \"\"\"Draw 3D perspective grid\"\"\"\n grid_color = '#2a2a4a'\n \n # Draw horizontal lines\n for y in range(self.GRID_H + 1):\n x1, y1, _ = self.to_screen(0, y)\n x2, y2, _ = self.to_screen(self.GRID_W, y)\n self.canvas.create_line(x1, y1, x2, y2, fill=grid_color, width=1)\n \n # Draw vertical lines\n for x in range(self.GRID_W + 1):\n x1, y1, _ = self.to_screen(x, 0)\n x2, y2, _ = self.to_screen(x, self.GRID_H)\n self.canvas.create_line(x1, y1, x2, y2, fill=grid_color, width=1)\n \n # Draw border\n border_color = '#4a4a8a'\n corners = [\n self.to_screen(0, 0),\n self.to_screen(self.GRID_W, 0),\n self.to_screen(self.GRID_W, self.GRID_H),\n self.to_screen(0, self.GRID_H)\n ]\n points = []\n for c in corners:\n points.extend([c[0], c[1]])\n self.canvas.create_polygon(points, fill='', outline=border_color, width=3)\n \n def lighten_color(self, color, amount):\n \"\"\"Lighten a hex color\"\"\"\n color = color.lstrip('#')\n r, g, b = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16)\n r = min(255, r + amount)\n g = min(255, g + amount)\n b = min(255, b + amount)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def darken_color(self, color, amount):\n \"\"\"Darken a hex color\"\"\"\n color = color.lstrip('#')\n r, g, b = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16)\n r = max(0, r - amount)\n g = max(0, g - amount)\n b = max(0, b - amount)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def blend_color(self, c1, c2, factor):\n \"\"\"Blend two colors\"\"\"\n c1 = c1.lstrip('#')\n c2 = c2.lstrip('#')\n r1, g1, b1 = int(c1[0:2], 16), int(c1[2:4], 16), int(c1[4:6], 16)\n r2, g2, b2 = int(c2[0:2], 16), int(c2[2:4], 16), int(c2[4:6], 16)\n r = int(r1 + (r2 - r1) * factor)\n g = int(g1 + (g2 - g1) * factor)\n b = int(b1 + (b2 - b1) * factor)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def spawn_food(self):\n \"\"\"Spawn food at random position\"\"\"\n while True:\n x = random.randint(0, self.GRID_W - 1)\n y = random.randint(0, self.GRID_H - 1)\n if (x, y) not in self.snake:\n self.food = (x, y)\n break\n \n def on_key(self, event):\n \"\"\"Handle key input\"\"\"\n key = event.keysym\n if self.game_over:\n if key == 'space':\n self.restart()\n return\n \n if key == 'Up' and self.direction != 'DOWN':\n self.next_direction = 'UP'\n elif key == 'Down' and self.direction != 'UP':\n self.next_direction = 'DOWN'\n elif key == 'Left' and self.direction != 'RIGHT':\n self.next_direction = 'LEFT'\n elif key == 'Right' and self.direction != 'LEFT':\n self.next_direction = 'RIGHT'\n elif key == 'Escape':\n self.root.quit()\n \n def update(self):\n \"\"\"Game update loop\"\"\"\n if not self.game_over:\n self.direction = self.next_direction\n self.move_snake()\n \n self.draw()\n self.root.after(self.speed, self.update)\n \n def move_snake(self):\n \"\"\"Move the snake\"\"\"\n head = self.snake[0]\n if self.direction == 'UP':\n new_head = (head[0], head[1] - 1)\n elif self.direction == 'DOWN':\n new_head = (head[0], head[1] + 1)\n elif self.direction == 'LEFT':\n new_head = (head[0] - 1, head[1])\n elif self.direction == 'RIGHT':\n new_head = (head[0] + 1, head[1])\n \n # Check collision with walls\n if (new_head[0] < 0 or new_head[0] >= self.GRID_W or\n new_head[1] < 0 or new_head[1] >= self.GRID_H):\n self.game_over = True\n return\n \n # Check collision with self\n if new_head in self.snake:\n self.game_over = True\n return\n \n self.snake.insert(0, new_head)\n \n # Check food\n if new_head == self.food:\n self.score += 10\n self.spawn_particles(new_head[0], new_head[1], '#ff4444')\n self.spawn_food()\n # Speed up slightly\n if self.speed > 60:\n self.speed -= 2\n else:\n self.snake.pop()\n \n def spawn_particles(self, x, y, color):\n \"\"\"Spawn particles at position\"\"\"\n sx, sy, _ = self.to_screen(x, y)\n for _ in range(15):\n angle = random.uniform(0, 2 * math.pi)\n speed = random.uniform(2, 8)\n self.particles.append({\n 'x': sx, 'y': sy,\n 'vx': math.cos(angle) * speed,\n 'vy': math.sin(angle) * speed,\n 'life': random.randint(10, 25),\n 'max_life': 25,\n 'color': color,\n 'size': random.uniform(2, 5)\n })\n \n def update_particles(self):\n \"\"\"Update and draw particles\"\"\"\n alive = []\n for p in self.particles:\n p['x'] += p['vx']\n p['y'] += p['vy']\n p['vy'] += 0.2 # gravity\n p['life'] -= 1\n if p['life'] > 0:\n alive.append(p)\n alpha = p['life'] / p['max_life']\n size = p['size'] * alpha\n color = self.blend_color(p['color'], '#1a1a2e', 1 - alpha)\n self.canvas.create_oval(\n p['x'] - size, p['y'] - size,\n p['x'] + size, p['y'] + size,\n fill=color, outline=''\n )\n self.particles = alive\n \n def draw(self):\n \"\"\"Draw everything\"\"\"\n self.canvas.delete('all')\n \n # Background gradient\n for i in range(self.HEIGHT):\n color_val = int(26 + (40 - 26) * (i / self.HEIGHT))\n color = f'#{color_val:02x}{color_val:02x}{color_val + 20:02x}'\n self.canvas.create_line(0, i, self.WIDTH, i, fill=color)\n \n # Draw grid\n self.draw_grid()\n \n # Sort snake segments by y position for proper depth ordering\n # Also sort by x for proper left-right overlap\n sorted_segments = sorted(enumerate(self.snake), \n key=lambda s: (s[1][1], s[1][0]))\n \n # Draw snake\n for i, (gx, gy) in sorted_segments:\n if i == 0:\n # Head - brighter color\n color = '#00ff88'\n height = 20\n else:\n # Body - gradient from bright to dark\n ratio = i / len(self.snake)\n r = int(0 + 0 * ratio)\n g = int(255 - 150 * ratio)\n b = int(80 - 30 * ratio)\n color = f'#{r:02x}{g:02x}{b:02x}'\n height = int(18 - 6 * ratio)\n \n self.draw_3d_cube(gx, gy, self.CELL_SIZE, color, height=height)\n \n # Draw eyes on head\n if i == 0:\n sx, sy, scale = self.to_screen(gx, gy)\n s = self.CELL_SIZE * scale * 0.9\n eye_size = 3 * scale\n \n if self.direction == 'RIGHT':\n ex1, ey1 = sx + s * 0.2, sy - 8 * scale + s * 0.15\n ex2, ey2 = sx + s * 0.2, sy - 8 * scale + s * 0.45\n elif self.direction == 'LEFT':\n ex1, ey1 = sx - s * 0.2, sy - 8 * scale + s * 0.15\n ex2, ey2 = sx - s * 0.2, sy - 8 * scale + s * 0.45\n elif self.direction == 'UP':\n ex1, ey1 = sx - s * 0.15, sy - 8 * scale + s * 0.1\n ex2, ey2 = sx + s * 0.15, sy - 8 * scale + s * 0.1\n else:\n ex1, ey1 = sx - s * 0.15, sy - 8 * scale + s * 0.5\n ex2, ey2 = sx + s * 0.15, sy - 8 * scale + s * 0.5\n \n self.canvas.create_oval(ex1 - eye_size, ey1 - eye_size, \n ex1 + eye_size, ey1 + eye_size,\n fill='white', outline='')\n self.canvas.create_oval(ex2 - eye_size, ey2 - eye_size,\n ex2 + eye_size, ey2 + eye_size,\n fill='white', outline='')\n \n # Draw food\n if self.food:\n pulse = 1 + 0.1 * math.sin(self.bob_speed * 0.1)\n self.draw_3d_sphere(self.food[0], self.food[1], \n self.CELL_SIZE * 0.4 * pulse, '#ff3366')\n \n self.bob_speed += 1\n \n # Draw particles\n self.update_particles()\n \n # Draw score\n self.canvas.create_text(self.WIDTH // 2, 30, \n text=f\"🐍 SCORE: {self.score}\", \n fill='#00ff88', font=('Courier', 24, 'bold'))\n \n # Draw controls hint\n self.canvas.create_text(self.WIDTH // 2, self.HEIGHT - 20,\n text=\"Arrow Keys: Move | ESC: Quit\",\n fill='#6666aa', font=('Courier', 10))\n \n # Game over screen\n if self.game_over:\n self.canvas.create_rectangle(0, 0, self.WIDTH, self.HEIGHT,\n fill='#000000', stipple='gray50')\n self.canvas.create_text(self.WIDTH // 2, self.HEIGHT // 2 - 40,\n text=\"GAME OVER\", \n fill='#ff3344', font=('Courier', 48, 'bold'))\n self.canvas.create_text(self.WIDTH // 2, self.HEIGHT // 2 + 20,\n text=f\"Score: {self.score}\",\n fill='#ffffff', font=('Courier', 28))\n self.canvas.create_text(self.WIDTH // 2, self.HEIGHT // 2 + 70,\n text=\"Press SPACE to restart\",\n fill='#aaaaaa', font=('Courier', 16))\n \n def restart(self):\n \"\"\"Restart the game\"\"\"\n self.direction = 'RIGHT'\n self.next_direction = 'RIGHT'\n self.snake = [(10, 10), (9, 10), (8, 10)]\n self.food = None\n self.score = 0\n self.game_over = False\n self.speed = 120\n self.particles = []\n self.spawn_food()\n\nif __name__ == '__main__':\n root = tk.Tk()\n game = SnakeGame3D(root)\n root.mainloop()\n```\n\nThis is a good start. Let me refine it more and make sure everything works properly. Let me also think about making the 3D effect more pronounced.\n\nActually, let me think about this more carefully. The user wants a 3D snake game using tkinter. Since tkinter is 2D, I need to create convincing pseudo-3D visuals. Let me make sure the 3D cube rendering is solid and the perspective grid looks good.\n\nLet me also add some nice features:\n- Better color gradients on the snake\n- Smoother 3D perspective\n- Better visual effects\n- Score display\n- Game over screen\n\nLet me refine the code and make it more polished.\n\nI think my approach is solid. Let me finalize the code and make sure it's clean and well-commented.\n\nOne issue - I should make sure the perspective rendering actually looks good. Let me think about the coordinate transformation more carefully.\n\nFor a nice 3D perspective effect:\n- The grid should be drawn as if viewed from above at an angle\n- Objects further from the viewer should appear smaller\n- There should be proper depth ordering (far objects drawn first)\n\nLet me refine the to_screen function:\n\n```python\ndef to_screen(self, gx, gy, z=0):\n \"\"\"Convert grid coordinates to screen coordinates with 3D perspective\"\"\"\n # Center the grid\n cx = gx - self.GRID_W / 2\n cy = gy - self.GRID_H / 2\n \n # Apply perspective - objects further away (higher y) get compressed\n depth_factor = 1.0 + cy * 0.008 # slight perspective\n \n sx = self.board_offset_x + cx * self.CELL_SIZE\n sy = self.board_offset_y + cy * self.CELL_SIZE * self.tilt - z * 0.5\n \n return sx, sy, 1.0\n```\n\nHmm, actually the simpler approach might work better. Let me just make it look good visually without overcomplicating the math.\n\nLet me write the final version with clean code and good visuals.\n\nActually let me reconsider the whole approach. Instead of trying to do perspective projection (which can get messy), let me use an isometric-style view with good 3D cube rendering. This will look cleaner and more consistent.\n\nHere's my plan:\n1. Draw a flat isometric grid as the playing field\n2. Draw snake segments as 3D cubes on top of the grid\n3. Draw food as a glowing sphere\n4. Add shadows, particles, and other visual effects\n5. Proper depth ordering\n\nThe isometric transformation is:\n- screen_x = center_x + (grid_x - grid_y) * tile_width/2\n- screen_y = center_y + (grid_x + grid_y) * tile_height/2 - height_offset\n\nThis gives a nice isometric view. Let me implement this.\n\nActually, wait - for a snake game, an isometric view might make it confusing to play since the grid wouldn't align with the arrow keys intuitively. Let me instead use a simpler top-down perspective with 3D effects:\n\n- Draw the grid as a tilted plane (slight perspective)\n- Draw 3D cubes for snake segments\n- Add depth cues through shadows and shading\n\nLet me finalize the code. I think my original approach was good, let me just clean it up and make sure it works.\n\nLet me write the final version:\n\n```python\nimport tkinter as tk\nimport random\nimport math\n\nclass SnakeGame3D:\n def __init__(self):\n self.root = tk.Tk()\n self.root.title(\"🐍 3D Snake Game\")\n self.root.configure(bg='#0a0a1a')\n self.root.resizable(False, False)\n \n # Canvas\n self.WIDTH = 900\n self.HEIGHT = 650\n self.canvas = tk.Canvas(self.root, width=self.WIDTH, height=self.HEIGHT,\n bg='#0a0a1a', highlightthickness=0)\n self.canvas.pack(padx=10, pady=10)\n \n # Game config\n self.COLS = 20\n self.ROWS = 20\n self.CELL = 28\n self.TILT = 0.55 # perspective tilt factor\n self.CENTER_X = self.WIDTH // 2\n self.CENTER_Y = 280\n \n # Game state\n self.reset()\n \n # Input\n self.root.bind('', self.key)\n \n # Start\n self.tick()\n self.root.mainloop()\n \n def reset(self):\n self.snake = [(10, 10), (9, 10), (8, 10)]\n self.dir = 'R'\n self.next_dir = 'R'\n self.food = None\n self.score = 0\n self.game_over = False\n self.speed = 130\n self.particles = []\n self.frame = 0\n self.spawn_food()\n \n def grid_to_screen(self, gx, gy, z=0):\n \"\"\"Isometric-ish projection\"\"\"\n # Offset from center of grid\n dx = (gx - self.COLS / 2 + 0.5) * self.CELL\n dy = (gy - self.ROWS / 2 + 0.5) * self.CELL\n \n # 3D projection: x stays, y gets tilted, z goes up\n sx = self.CENTER_X + dx\n sy = self.CENTER_Y + dy * self.TILT - z\n \n return sx, sy\n \n def spawn_food(self):\n while True:\n pos = (random.randint(0, self.COLS-1), random.randint(0, self.ROWS-1))\n if pos not in self.snake:\n self.food = pos\n break\n \n def key(self, e):\n if self.game_over:\n if e.keysym == 'space':\n self.reset()\n return\n d = e.keysym\n if d == 'Up' and self.dir != 'D': self.next_dir = 'U'\n elif d == 'Down' and self.dir != 'U': self.next_dir = 'D'\n elif d == 'Left' and self.dir != 'R': self.next_dir = 'L'\n elif d == 'Right' and self.dir != 'L': self.next_dir = 'R'\n \n def tick(self):\n if not self.game_over:\n self.dir = self.next_dir\n self.move()\n self.render()\n self.frame += 1\n self.root.after(self.speed, self.tick)\n \n def move(self):\n hx, hy = self.snake[0]\n if self.dir == 'U': nh = (hx, hy-1)\n elif self.dir == 'D': nh = (hx, hy+1)\n elif self.dir == 'L': nh = (hx-1, hy)\n elif self.dir == 'R': nh = (hx+1, hy)\n \n if nh[0] < 0 or nh[0] >= self.COLS or nh[1] < 0 or nh[1] >= self.ROWS:\n self.game_over = True\n return\n if nh in self.snake:\n self.game_over = True\n return\n \n self.snake.insert(0, nh)\n if nh == self.food:\n self.score += 10\n self.spawn_particles(self.food[0], self.food[1])\n self.spawn_food()\n if self.speed > 60: self.speed -= 2\n else:\n self.snake.pop()\n \n def spawn_particles(self, gx, gy):\n sx, sy = self.grid_to_screen(gx, gy, 20)\n for _ in range(20):\n a = random.uniform(0, math.tau)\n v = random.uniform(1.5, 7)\n self.particles.append({\n 'x': sx, 'y': sy,\n 'vx': math.cos(a) * v,\n 'vy': math.sin(a) * v - 2,\n 'life': random.randint(12, 30),\n 'max': 30,\n 'size': random.uniform(2, 5),\n 'hue': random.choice(['#ff4466', '#ff6688', '#ffaa00', '#ffff44', '#ff8844'])\n })\n \n # --- Rendering ---\n \n def lighten(self, c, n):\n c = c.lstrip('#')\n r = min(255, int(c[0:2], 16) + n)\n g = min(255, int(c[2:4], 16) + n)\n b = min(255, int(c[4:6], 16) + n)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def darken(self, c, n):\n c = c.lstrip('#')\n r = max(0, int(c[0:2], 16) - n)\n g = max(0, int(c[2:4], 16) - n)\n b = max(0, int(c[4:6], 16) - n)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def lerp_color(self, c1, c2, t):\n c1 = c1.lstrip('#'); c2 = c2.lstrip('#')\n r = int(int(c1[0:2], 16) * (1-t) + int(c2[0:2], 16) * t)\n g = int(int(c1[2:4], 16) * (1-t) + int(c2[2:4], 16) * t)\n b = int(int(c1[4:6], 16) * (1-t) + int(c2[4:6], 16) * t)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n def draw_iso_cube(self, gx, gy, w, h, color, elev=0):\n \"\"\"Draw a 3D isometric cube at grid pos\"\"\"\n sx, sy = self.grid_to_screen(gx, gy, elev)\n \n # Cube dimensions in screen space\n hw = w / 2\n hh = h * self.TILT / 2\n depth = h # vertical height of the cube\n \n # Top face\n top = self.lighten(color, 50)\n self.canvas.create_polygon(\n sx, sy - depth,\n sx + hw, sy - depth + hh,\n sx, sy - depth + 2*hh,\n sx - hw, sy - depth + hh,\n fill=top, outline=self.darken(color, 30), width=1\n )\n \n # Right face\n right = self.darken(color, 20)\n self.canvas.create_polygon(\n sx + hw, sy - depth + hh,\n sx + hw, sy + hh,\n sx, sy + 2*hh,\n sx, sy - depth + 2*hh,\n fill=right, outline=self.darken(color, 50), width=1\n )\n \n # Left face\n left = self.darken(color, 50)\n self.canvas.create_polygon(\n sx - hw, sy - depth + hh,\n sx - hw, sy + hh,\n sx, sy + 2*hh,\n sx, sy - depth + 2*hh,\n fill=left, outline=self.darken(color, 60), width=1\n )\n \n def draw_food_sphere(self, gx, gy, color='#ff3366'):\n \"\"\"Draw a glowing sphere for food\"\"\"\n sx, sy = self.grid_to_screen(gx, gy, 15)\n pulse = 1 + 0.08 * math.sin(self.frame * 0.15)\n r = 12 * pulse\n \n # Glow\n for i in range(6, 0, -1):\n gr = r + i * 5\n gc = self.lerp_color(color, '#0a0a1a', i * 0.12)\n self.canvas.create_oval(sx-gr, sy-gr*self.TILT, sx+gr, sy+gr*self.TILT,\n fill=gc, outline='')\n \n # Shadow on ground\n shx, shy = self.grid_to_screen(gx, gy, 0)\n self.canvas.create_oval(shx-10, shy-4, shx+10, shy+4,\n fill='#050510', outline='')\n \n # Main sphere\n self.canvas.create_oval(sx-r, sy-r*self.TILT, sx+r, sy+r*self.TILT,\n fill=color, outline=self.darken(color, 60), width=2)\n \n # Highlight\n hr = r * 0.35\n self.canvas.create_oval(sx-hr-r*0.25, sy-hr*self.TILT-r*self.TILT*0.3,\n sx+hr-r*0.25, sy+hr*self.TILT-r*self.TILT*0.3,\n fill=self.lighten(color, 120), outline='')\n \n def draw_grid(self):\n \"\"\"Draw the perspective grid floor\"\"\"\n gc = '#1a1a3a'\n \n for y in range(self.ROWS + 1):\n x1, y1 = self.grid_to_screen(0, y)\n x2, y2 = self.grid_to_screen(self.COLS, y)\n self.canvas.create_line(x1, y1, x2, y2, fill=gc)\n \n for x in range(self.COLS + 1):\n x1, y1 = self.grid_to_screen(x, 0)\n x2, y2 = self.grid_to_screen(x, self.ROWS)\n self.canvas.create_line(x1, y1, x2, y2, fill=gc)\n \n # Border\n pts = []\n for gx, gy in [(0,0), (self.COLS,0), (self.COLS,self.ROWS), (0,self.ROWS)]:\n sx, sy = self.grid_to_screen(gx, gy)\n pts.extend([sx, sy])\n self.canvas.create_polygon(pts, fill='', outline='#3a3a7a', width=3)\n \n def render(self):\n self.canvas.delete('all')\n \n # Background\n for i in range(0, self.HEIGHT, 4):\n t = i / self.HEIGHT\n r = int(10 + 15 * t)\n g = int(10 + 15 * t)\n b = int(26 + 30 * t)\n self.canvas.create_rectangle(0, i, self.WIDTH, i+4, \n fill=f'#{r:02x}{g:02x}{b:02x}', outline='')\n \n self.draw_grid()\n \n # Collect all drawable objects with depth for sorting\n draw_list = []\n \n # Snake segments\n for i, (gx, gy) in enumerate(self.snake):\n depth = gy * 100 + gx # simple depth key\n draw_list.append(('snake', i, gx, gy, depth))\n \n # Food\n if self.food:\n fx, fy = self.food\n depth = fy * 100 + fx\n draw_list.append(('food', 0, fx, fy, depth))\n \n # Sort by depth (back to front)\n draw_list.sort(key=lambda x: x[4])\n \n for item in draw_list:\n if item[0] == 'snake':\n i, gx, gy = item[1], item[2], item[3]\n if i == 0:\n color = '#00ff88'\n h = 22\n else:\n t = i / max(1, len(self.snake) - 1)\n color = self.lerp_color('#00dd66', '#004422', t)\n h = int(20 - 8 * t)\n \n # Shadow\n shx, shy = self.grid_to_screen(gx, gy, 0)\n self.canvas.create_oval(shx-12, shy-5, shx+12, shy+5,\n fill='#050510', outline='')\n \n self.draw_iso_cube(gx, gy, self.CELL - 2, self.CELL - 2, color, h)\n \n # Eyes on head\n if i == 0:\n sx, sy = self.grid_to_screen(gx, gy, h)\n es = 4\n if self.dir == 'R':\n self.canvas.create_oval(sx+3-es, sy-8-es, sx+3+es, sy-8+es, fill='white', outline='')\n self.canvas.create_oval(sx+3-es, sy+2-es, sx+3+es, sy+2+es, fill='white', outline='')\n self.canvas.create_oval(sx+5-es+2, sy-7-es+2, sx+5+es-2, sy-7+es-2, fill='#111', outline='')\n self.canvas.create_oval(sx+5-es+2, sy+3-es+2, sx+5+es-2, sy+3+es-2, fill='#111', outline='')\n elif self.dir == 'L':\n self.canvas.create_oval(sx-3-es, sy-8-es, sx-3+es, sy-8+es, fill='white', outline='')\n self.canvas.create_oval(sx-3-es, sy+2-es, sx-3+es, sy+2+es, fill='white', outline='')\n self.canvas.create_oval(sx-1-es+2, sy-7-es+2, sx-1+es-2, sy-7+es-2, fill='#111', outline='')\n self.canvas.create_oval(sx-1-es+2, sy+3-es+2, sx-1+es-2, sy+3+es-2, fill='#111', outline='')\n elif self.dir == 'U':\n self.canvas.create_oval(sx-6-es, sy-4-es, sx-6+es, sy-4+es, fill='white', outline='')\n self.canvas.create_oval(sx+4-es, sy-4-es, sx+4+es, sy-4+es, fill='white', outline='')\n elif self.dir == 'D':\n self.canvas.create_oval(sx-6-es, sy-es, sx-6+es, sy+es, fill='white', outline='')\n self.canvas.create_oval(sx+4-es, sy-es, sx+4+es, sy+es, fill='white', outline='')\n \n elif item[0] == 'food':\n gx, gy = item[2], item[3]\n self.draw_food_sphere(gx, gy)\n \n # Particles\n alive = []\n for p in self.particles:\n p['x'] += p['vx']\n p['y'] += p['vy']\n p['vy'] += 0.25\n p['life'] -= 1\n if p['life'] > 0:\n alive.append(p)\n t = p['life'] / p['max']\n s = p['size'] * t\n c = self.lerp_color(p['hue'], '#0a0a1a', 1-t)\n self.canvas.create_oval(p['x']-s, p['y']-s, p['x']+s, p['y']+s,\n fill=c, outline='')\n self.particles = alive\n \n # HUD\n self.canvas.create_text(self.WIDTH//2, 25, text=f\"🐍 SCORE: {self.score}\",\n fill='#00ff88', font=('Consolas', 26, 'bold'))\n self.canvas.create_text(self.WIDTH//2, 55, text=f\"SPEED: {max(1, 131 - self.speed)}\",\n fill='#4488aa', font=('Consolas', 12))\n \n self.canvas.create_text(self.WIDTH//2, self.HEIGHT - 15,\n text=\"↑↓←→ Move | SPACE Restart | ESC Quit\",\n fill='#4444aa', font=('Consolas', 10))\n \n if self.game_over:\n self.canvas.create_rectangle(0, 0, self.WIDTH, self.HEIGHT,\n fill='#000000', stipple='gray50')\n self.canvas.create_text(self.WIDTH//2, self.HEIGHT//2 - 50,\n text=\"GAME OVER\", fill='#ff2244',\n font=('Consolas', 52, 'bold'))\n self.canvas.create_text(self.WIDTH//2, self.HEIGHT//2 + 15,\n text=f\"Final Score: {self.score}\", fill='#ffffff',\n font=('Consolas', 28))\n self.canvas.create_text(self.WIDTH//2, self.HEIGHT//2 + 65,\n text=\"Press SPACE to play again\", fill='#aaaaaa',\n font=('Consolas', 16))\n\nif __name__ == '__main__':\n SnakeGame3D()\n```\n\nWait, I realize there's an issue with my approach. The elevation parameter in `draw_iso_cube` is not being used correctly. Let me fix the `draw_iso_cube` method.\n\nThe `elev` parameter should represent how high above the ground the cube sits. The cube itself also has height. So:\n- The base of the cube is at `elev` height\n- The top of the cube is at `elev + cube_height` height\n\nLet me fix this:\n\n```python\ndef draw_iso_cube(self, gx, gy, w, h, color, base_elev=0, cube_height=15):\n \"\"\"Draw a 3D cube at grid position\"\"\"\n # Bottom center of cube\n bx, by = self.grid_to_screen(gx, gy, base_elev)\n # Top center of cube \n tx, ty = self.grid_to_screen(gx, gy, base_elev + cube_height)\n \n hw = w / 2\n hh = h * self.TILT / 2\n \n # Top face at the top\n top = self.lighten(color, 50)\n self.canvas.create_polygon(\n tx, ty - hh, # no, this isn't right\n ...\n )\n```\n\nHmm, this is getting complicated. Let me simplify. The grid_to_screen function already handles z elevation. So:\n\n- `grid_to_screen(gx, gy, 0)` gives the ground position\n- `grid_to_screen(gx, gy, elev)` gives a position elevated by `elev` pixels\n\nFor the cube, I need:\n- Top face at height `elev + cube_h`\n- Side faces from `elev` to `elev + cube_h`\n\nLet me simplify the cube drawing:\n\n```python\ndef draw_iso_cube(self, gx, gy, size, color, elev=0, cube_h=15):\n \"\"\"Draw a 3D cube\"\"\"\n # Ground corners\n left = gx\n right = gx + size/self.CELL # hmm, this doesn't work because size is in pixels\n \n # Let me take a different approach - calculate screen positions directly\n```\n\nOK let me rethink this entirely. I'll calculate the cube vertices directly in screen space.\n\nFor a cube at grid position (gx, gy):\n- It occupies the grid cell from (gx, gy) to (gx+1, gy+1)\n- The corners of the cell on the ground are:\n - (gx, gy), (gx+1, gy), (gx+1, gy+1), (gx, gy+1)\n- These get projected to screen space\n- Then the top face is the same but elevated by cube_h\n\nLet me simplify by computing corner positions:\n\n```python\ndef draw_iso_cube(self, gx, gy, color, elev=0, cube_h=16):\n # Bottom face corners (ground level + elev)\n bl = self.grid_to_screen(gx, gy, elev) # back-left\n br = self.grid_to_screen(gx+1, gy, elev) # back-right\n fr = self.grid_to_screen(gx+1, gy+1, elev) # front-right\n fl = self.grid_to_screen(gx, gy+1, elev) # front-left\n \n # Top face corners\n tbl = self.grid_to_screen(gx, gy, elev + cube_h)\n tbr = self.grid_to_screen(gx+1, gy, elev + cube_h)\n tfr = self.grid_to_screen(gx+1, gy+1, elev + cube_h)\n tfl = self.grid_to_screen(gx, gy+1, elev + cube_h)\n \n # Draw top face\n top_color = self.lighten(color, 40)\n self.canvas.create_polygon(\n *tbl, *tbr, *tfr, *tfl,\n fill=top_color, outline=self.darken(color, 20)\n )\n \n # Draw right face (visible because of perspective tilt)\n right_color = self.darken(color, 20)\n self.canvas.create_polygon(\n *tbr, *tfr, *fr, *br,\n fill=right_color, outline=self.darken(color, 40)\n )\n \n # Draw front face (most visible)\n front_color = self.darken(color, 40)\n self.canvas.create_polygon(\n *tfl, *tfr, *fr, *fl,\n fill=front_color, outline=self.darken(color, 50)\n )\n```\n\nWait, but with my current projection (`grid_to_screen`), the `grid_to_screen` function doesn't handle the full 3D transformation correctly. Let me fix it.\n\nThe issue is that `grid_to_screen` takes grid_x and grid_y as the center of a cell, not as arbitrary points. Let me fix this:\n\n```python\ndef grid_to_screen(self, gx, gy, z=0):\n \"\"\"Convert grid coordinates to screen coordinates with 3D perspective\"\"\"\n # Grid center is at (COLS/2, ROWS/2)\n # Offset from center\n dx = (gx - self.COLS / 2) * self.CELL\n dy = (gy - self.ROWS / 2) * self.CELL\n \n # Apply tilt for y-axis\n sx = self.CENTER_X + dx\n sy = self.CENTER_Y + dy * self.TILT - z\n \n return sx, sy\n```\n\nThis way, grid_to_screen(0, 0) gives the top-left corner, grid_to_screen(20, 20) gives the bottom-right corner, etc.\n\nFor the cube at (gx, gy), the cell corners would be at:\n- grid_to_screen(gx, gy) - top-left\n- grid_to_screen(gx+1, gy) - top-right\n- grid_to_screen(gx+1, gy+1) - bottom-right\n- grid_to_screen(gx, gy+1) - bottom-left\n\nThis should work! Let me rewrite the cube drawing.\n\nActually wait, with this projection, what do we see? Looking at the grid from above at an angle. The y-axis is compressed by TILT. So the grid looks like a parallelogram viewed from above-right.\n\nFor the cube:\n- The top face should be visible (looking from above)\n- The front face (bottom in the grid, i.e., higher y values) should be visible\n- Maybe the right face too\n\nLet me think about which faces to draw. With the perspective tilt (y compressed), we're looking from above. The visible faces of a cube would be:\n- Top face (always visible from above)\n- Front face (the face with higher y, at the bottom of the screen)\n- Right face (the face with higher x, depends on angle)\n\nActually with a simple orthographic tilt, only top and front faces would be visible. The right face would be visible if we also add a slight x rotation, but let's keep it simple.\n\nSo for each cube:\n1. Draw the front face (face at y+1, the bottom face on screen)\n2. Draw the right face (face at x+1, might be slightly visible)\n3. Draw the top face\n\nActually, in a simple oblique projection with tilt on y, only top and front faces are visible. Let me just do those two.\n\nHmm, actually for it to look good as 3D, I should draw all three visible faces (top, front-right, front-left or similar). Let me think about this differently.\n\nIn an isometric-like view with tilt on Y:\n- We see the top face\n- We see the \"south\" face (higher y values, which appear at the bottom of screen)\n\nFor the south face:\n- Bottom-left: grid_to_screen(gx, gy+1, elev)\n- Bottom-right: grid_to_screen(gx+1, gy+1, elev)\n- Top-right: grid_to_screen(gx+1, gy+1, elev+h)\n- Top-left: grid_to_screen(gx, gy+1, elev+h)\n\nFor the top face:\n- Four corners all at elev+h:\n - grid_to_screen(gx, gy, elev+h)\n - grid_to_screen(gx+1, gy, elev+h)\n - grid_to_screen(gx+1, gy+1, elev+h)\n - grid_to_screen(gx, gy+1, elev+h)\n\nAnd optionally the right face:\n- grid_to_screen(gx+1, gy, elev)\n- grid_to_screen(gx+1, gy+1, elev)\n- grid_to_screen(gx+1, gy+1, elev+h)\n- grid_to_screen(gx+1, gy, elev+h)\n\nThis should give a nice 3D cube look! Let me implement this properly.\n\nOK, let me just write the final clean version of the code. I'll be more careful about the geometry this time.\n\n```python\nimport tkinter as tk\nimport random\nimport math\n\nclass Snake3D:\n def __init__(self):\n self.root = tk.Tk()\n self.root.title(\"🐍 3D Snake Game - MiMo\")\n self.root.configure(bg='#080810')\n self.root.resizable(False, False)\n \n self.W, self.H = 900, 680\n self.canvas = tk.Canvas(self.root, width=self.W, height=self.H,\n bg='#080810', highlightthickness=0)\n self.canvas.pack(padx=5, pady=5)\n \n # Grid\n self.COLS, self.ROWS = 20, 20\n self.CELL = 28\n self.TILT = 0.5\n self.OX = self.W // 2\n self.OY = 300\n \n self.reset()\n self.root.bind('', self.on_key)\n self.loop()\n self.root.mainloop()\n \n def reset(self):\n self.snake = [(10, 10), (9, 10), (8, 10)]\n self.dir = 'R'\n self.ndir = 'R'\n self.food = None\n self.score = 0\n self.alive = True\n self.speed = 130\n self.particles = []\n self.tick = 0\n self.spawn_food()\n \n def g2s(self, gx, gy, z=0):\n \"\"\"Grid to screen with perspective\"\"\"\n dx = (gx - self.COLS / 2) * self.CELL\n dy = (gy - self.ROWS / 2) * self.CELL\n return (self.OX + dx, self.OY + dy * self.TILT - z)\n \n def spawn_food(self):\n while True:\n p = (random.randint(0, self.COLS-1), random.randint(0, self.ROWS-1))\n if p not in self.snake:\n self.food = p\n return\n \n def on_key(self, e):\n if not self.alive:\n if e.keysym == 'space': self.reset()\n return\n k = e.keysym\n if k == 'Up' and self.dir != 'D': self.ndir = 'U'\n elif k == 'Down' and self.dir != 'U': self.ndir = 'D'\n elif k == 'Left' and self.dir != 'R': self.ndir = 'L'\n elif k == 'Right' and self.dir != 'L': self.ndir = 'R'\n \n def loop(self):\n if self.alive:\n self.dir = self.ndir\n self.step()\n self.draw()\n self.tick += 1\n self.root.after(self.speed, self.loop)\n \n def step(self):\n hx, hy = self.snake[0]\n if self.dir == 'U': nh = (hx, hy-1)\n elif self.dir == 'D': nh = (hx, hy+1)\n elif self.dir == 'L': nh = (hx-1, hy)\n else: nh = (hx+1, hy)\n \n if not (0 <= nh[0] < self.COLS and 0 <= nh[1] < self.ROWS) or nh in self.snake:\n self.alive = False\n self.burst(self.snake[0][0], self.snake[0][1], '#ff2244')\n return\n \n self.snake.insert(0, nh)\n if nh == self.food:\n self.score += 10\n self.burst(*self.food, '#ff6644')\n self.spawn_food()\n if self.speed > 55: self.speed -= 2\n else:\n self.snake.pop()\n \n def burst(self, gx, gy, c):\n sx, sy = self.g2s(gx, gy, 20)\n for _ in range(25):\n a = random.uniform(0, 6.28)\n v = random.uniform(2, 8)\n self.particles.append({\n 'x': sx, 'y': sy, 'vx': math.cos(a)*v, 'vy': math.sin(a)*v-2,\n 'life': random.randint(10, 28), 'max': 28,\n 'sz': random.uniform(2, 5), 'c': c\n })\n \n # --- Colors ---\n def lighter(self, c, n):\n c = c.lstrip('#')\n return '#{:02x}{:02x}{:02x}'.format(\n min(255, int(c[0:2], 16)+n),\n min(255, int(c[2:4], 16)+n),\n min(255, int(c[4:6], 16)+n))\n \n def darker(self, c, n):\n c = c.lstrip('#')\n return '#{:02x}{:02x}{:02x}'.format(\n max(0, int(c[0:2], 16)-n),\n max(0, int(c[2:4], 16)-n),\n max(0, int(c[4:6], 16)-n))\n \n def lerp(self, a, b, t):\n a = a.lstrip('#'); b = b.lstrip('#')\n return '#{:02x}{:02x}{:02x}'.format(\n int(int(a[0:2],16)*(1-t)+int(b[0:2],16)*t),\n int(int(a[2:4],16)*(1-t)+int(b[2:4],16)*t),\n int(int(a[4:6],16)*(1-t)+int(b[4:6],16)*t))\n \n # --- 3D Drawing ---\n def draw_cube(self, gx, gy, color, elev=0, h=16):\n \"\"\"Draw a 3D cube at grid cell (gx, gy)\"\"\"\n # Top face corners (at elev + h)\n t00 = self.g2s(gx, gy, elev+h)\n t10 = self.g2s(gx+1, gy, elev+h)\n t11 = self.g2s(gx+1, gy+1, elev+h)\n t01 = self.g2s(gx, gy+1, elev+h)\n \n # Bottom face corners (at elev)\n b00 = self.g2s(gx, gy, elev)\n b10 = self.g2s(gx+1, gy, elev)\n b11 = self.g2s(gx+1, gy+1, elev)\n b01 = self.g2s(gx, gy+1, elev)\n \n # Front face (south face, higher y)\n front = self.darker(color, 40)\n self.canvas.create_polygon(\n *t01, *t11, *b11, *b01,\n fill=front, outline=self.darker(color, 60), width=1)\n \n # Right face (east face, higher x)\n right = self.darker(color, 20)\n self.canvas.create_polygon(\n *t10, *t11, *b11, *b10,\n fill=right, outline=self.darker(color, 50), width=1)\n \n # Top face (brightest)\n top = self.lighter(color, 30)\n self.canvas.create_polygon(\n *t00, *t10, *t11, *t01,\n fill=top, outline=self.darker(color, 20), width=1)\n \n def draw_sphere(self, gx, gy, r, color, elev=20):\n \"\"\"Draw a glowing sphere\"\"\"\n sx, sy = self.g2s(gx + 0.5, gy + 0.5, elev)\n pulse = 1 + 0.1 * math.sin(self.tick * 0.15)\n r *= pulse\n \n # Glow\n for i in range(8, 0, -1):\n gr = r + i * 4\n gc = self.lerp(color, '#080810', i * 0.1)\n self.canvas.create_oval(sx-gr, sy-gr*self.TILT, sx+gr, sy+gr*self.TILT,\n fill=gc, outline='')\n \n # Shadow\n shx, shy = self.g2s(gx+0.5, gy+0.5, 0)\n self.canvas.create_oval(shx-10, shy-5, shx+10, shy+5,\n fill='#040408', outline='')\n \n # Body\n self.canvas.create_oval(sx-r, sy-r*self.TILT, sx+r, sy+r*self.TILT,\n fill=color, outline=self.darker(color, 50), width=2)\n \n # Highlight\n hr = r * 0.3\n self.canvas.create_oval(\n sx-hr-r*0.3, sy-hr*self.TILT-r*self.TILT*0.4,\n sx+hr-r*0.3, sy+hr*self.TILT-r*self.TILT*0.4,\n fill=self.lighter(color, 120), outline='')\n \n def draw_grid(self):\n \"\"\"Draw perspective grid\"\"\"\n gc = '#161630'\n for y in range(self.ROWS + 1):\n p1 = self.g2s(0, y); p2 = self.g2s(self.COLS, y)\n self.canvas.create_line(*p1, *p2, fill=gc)\n for x in range(self.COLS + 1):\n p1 = self.g2s(x, 0); p2 = self.g2s(x, self.ROWS)\n self.canvas.create_line(*p1, *p2, fill=gc)\n \n # Border\n pts = []\n for g in [(0,0),(self.COLS,0),(self.COLS,self.ROWS),(0,self.ROWS)]:\n pts.extend(self.g2s(*g))\n self.canvas.create_polygon(pts, fill='', outline='#3a3a80', width=3)\n \n def draw(self):\n self.canvas.delete('all')\n \n # Gradient background\n for i in range(0, self.H, 3):\n t = i / self.H\n r, g, b = int(8+12*t), int(8+12*t), int(16+24*t)\n self.canvas.create_line(0, i, self.W, i+3, fill=f'#{r:02x}{g:02x}{b:02x}')\n \n self.draw_grid()\n \n # Depth-sorted rendering\n items = []\n for i, (gx, gy) in enumerate(self.snake):\n items.append(('s', i, gx, gy, gy * 100 + gx))\n if self.food:\n fx, fy = self.food\n items.append(('f', 0, fx, fy, fy * 100 + fx))\n items.sort(key=lambda x: x[4])\n \n for kind, idx, gx, gy, _ in items:\n if kind == 's':\n # Shadow\n shx, shy = self.g2s(gx+0.5, gy+0.5, 0)\n self.canvas.create_oval(shx-14, shy-6, shx+14, shy+6,\n fill='#04040a', outline='')\n \n if idx == 0:\n color, h = '#00ff88', 20\n else:\n t = idx / max(1, len(self.snake)-1)\n color = self.lerp('#00ee66', '#003318', t)\n h = int(18 - 8 * t)\n self.draw_cube(gx, gy, color, elev=2, h=h)\n \n # Eyes on head\n if idx == 0:\n self.draw_eyes(gx, gy, 2 + h)\n else:\n self.draw_sphere(gx, gy, 12, '#ff3366')\n \n # Particles\n alive = []\n for p in self.particles:\n p['x'] += p['vx']; p['y'] += p['vy']; p['vy'] += 0.3; p['life'] -= 1\n if p['life'] > 0:\n alive.append(p)\n t = p['life'] / p['max']\n s = p['sz'] * t\n c = self.lerp(p['c'], '#080810', 1-t)\n self.canvas.create_oval(p['x']-s, p['y']-s, p['x']+s, p['y']+s, fill=c, outline='')\n self.particles = alive\n \n # HUD\n self.canvas.create_text(self.W//2, 25, text=f\"🐍 SCORE: {self.score}\",\n fill='#00ff88', font=('Consolas', 28, 'bold'))\n self.canvas.create_text(self.W//2, 58, text=f\"Speed Level: {max(1, 131-self.speed)//2}\",\n fill='#4488aa', font=('Consolas', 12))\n self.canvas.create_text(self.W//2, self.H-18,\n text=\"Arrow Keys: Move | SPACE: Restart | ESC: Quit\",\n fill='#3333aa', font=('Consolas', 10))\n \n if not self.alive:\n self.canvas.create_rectangle(0, 0, self.W, self.H, fill='#000000', stipple='gray50')\n self.canvas.create_text(self.W//2, self.H//2-55, text=\"GAME OVER\",\n fill='#ff2244', font=('Consolas', 54, 'bold'))\n self.canvas.create_text(self.W//2, self.H//2+10, text=f\"Final Score: {self.score}\",\n fill='#ffffff', font=('Consolas', 30))\n self.canvas.create_text(self.W//2, self.H//2+60, text=\"Press SPACE to restart\",\n fill='#aaaaaa', font=('Consolas', 16))\n \n def draw_eyes(self, gx, gy, elev):\n sx, sy = self.g2s(gx+0.5, gy+0.5, elev)\n es = 3.5\n ox, oy = 0, 0\n if self.dir == 'R': ox = 5\n elif self.dir == 'L': ox = -5\n elif self.dir == 'U': oy = -5\n else: oy = 5\n \n # Calculate eye positions based on direction\n if self.dir in ('R', 'L'):\n e1 = (ox, -6)\n e2 = (ox, 6)\n else:\n e1 = (-6, oy)\n e2 = (6, oy)\n \n for ex, ey in [e1, e2]:\n self.canvas.create_oval(sx+ex-es, sy+ey-es, sx+ex+es, sy+ey+es,\n fill='white', outline='#333')\n self.canvas.create_oval(sx+ex-es/2, sy+ey-es/2, sx+ex+es/2, sy+ey+es/2,\n fill='#111', outline='')\n\nSnake3D()\n```\n\nHmm, I realize the eyes might not look great. Let me simplify and make them look better.\n\nActually, let me also reconsider the g2s function. The issue is that with just a Y tilt, the cube won't look very 3D from certain angles. Let me add a slight X tilt too to make it look more like a true isometric view.\n\nActually, let me keep it simple. The Y tilt alone should give a decent 3D look. Let me finalize the code and make sure it works properly.\n\nLet me also handle the ESC key to quit.\n\nLet me write the final polished version:\n\n```python\nimport tkinter as tk\nimport random\nimport math\n\nclass Snake3D:\n def __init__(self):\n self.root = tk.Tk()\n self.root.title(\"🐍 3D Snake Game\")\n self.root.configure(bg='#080810')\n self.root.resizable(False, False)\n \n self.W, self.H = 900, 680\n self.canvas = tk.Canvas(self.root, width=self.W, height=self.H,\n bg='#080810', highlightthickness=0)\n self.canvas.pack(padx=5, pady=5)\n \n # Grid config\n self.COLS = 20\n self.ROWS = 20\n self.CELL = 28\n self.TILT = 0.5 # Y compression factor\n self.OX = self.W // 2\n self.OY = 300\n \n # Game state\n self.reset()\n \n # Input\n self.root.bind('', self.on_key)\n \n # Start game loop\n self.game_loop()\n self.root.mainloop()\n \n def reset(self):\n self.snake = [(10, 10), (9, 10), (8, 10)]\n self.dir = 'R'\n self.next_dir = 'R'\n self.food = None\n self.score = 0\n self.alive = True\n self.speed = 130\n self.particles = []\n self.frame = 0\n self.spawn_food()\n \n def g2s(self, gx, gy, z=0):\n \"\"\"Convert grid coordinates to screen coordinates with pseudo-3D perspective\"\"\"\n dx = (gx - self.COLS / 2) * self.CELL\n dy = (gy - self.ROWS / 2) * self.CELL\n sx = self.OX + dx\n sy = self.OY + dy * self.TILT - z\n return (sx, sy)\n \n def spawn_food(self):\n while True:\n pos = (random.randint(0, self.COLS - 1), random.randint(0, self.ROWS - 1))\n if pos not in self.snake:\n self.food = pos\n return\n \n def on_key(self, e):\n if not self.alive:\n if e.keysym == 'space':\n self.reset()\n return\n \n k = e.keysym\n if k == 'Up' and self.dir != 'D':\n self.next_dir = 'U'\n elif k == 'Down' and self.dir != 'U':\n self.next_dir = 'D'\n elif k == 'Left' and self.dir != 'R':\n self.next_dir = 'L'\n elif k == 'Right' and self.dir != 'L':\n self.next_dir = 'R'\n elif k == 'Escape':\n self.root.quit()\n \n def game_loop(self):\n if self.alive:\n self.dir = self.next_dir\n self.step()\n self.render()\n self.frame += 1\n self.root.after(self.speed, self.game_loop)\n \n def step(self):\n hx, hy = self.snake[0]\n moves = {'U': (0, -1), 'D': (0, 1), 'L': (-1, 0), 'R': (1, 0)}\n dx, dy = moves[self.dir]\n nh = (hx + dx, hy + dy)\n \n # Wall collision\n if not (0 <= nh[0] < self.COLS and 0 <= nh[1] < self.ROWS):\n self.alive = False\n self.spawn_burst(self.snake[0][0], self.snake[0][1], '#ff2244')\n return\n \n # Self collision\n if nh in self.snake:\n self.alive = False\n self.spawn_burst(self.snake[0][0], self.snake[0][1], '#ff2244')\n return\n \n self.snake.insert(0, nh)\n \n if nh == self.food:\n self.score += 10\n self.spawn_burst(self.food[0], self.food[1], '#ff6644')\n self.spawn_food()\n if self.speed > 55:\n self.speed -= 2\n else:\n self.snake.pop()\n \n def spawn_burst(self, gx, gy, color):\n \"\"\"Create particle burst at grid position\"\"\"\n sx, sy = self.g2s(gx + 0.5, gy + 0.5, 20)\n for _ in range(25):\n angle = random.uniform(0, math.tau)\n vel = random.uniform(2, 8)\n self.particles.append({\n 'x': sx, 'y': sy,\n 'vx': math.cos(angle) * vel,\n 'vy': math.sin(angle) * vel - 3,\n 'life': random.randint(10, 28),\n 'max_life': 28,\n 'size': random.uniform(2, 5),\n 'color': color\n })\n \n # ---- Color helpers ----\n \n @staticmethod\n def lighter(hex_color, amount):\n h = hex_color.lstrip('#')\n r = min(255, int(h[0:2], 16) + amount)\n g = min(255, int(h[2:4], 16) + amount)\n b = min(255, int(h[4:6], 16) + amount)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n @staticmethod\n def darker(hex_color, amount):\n h = hex_color.lstrip('#')\n r = max(0, int(h[0:2], 16) - amount)\n g = max(0, int(h[2:4], 16) - amount)\n b = max(0, int(h[4:6], 16) - amount)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n @staticmethod\n def lerp_color(c1, c2, t):\n a = c1.lstrip('#')\n b = c2.lstrip('#')\n r = int(int(a[0:2], 16) * (1 - t) + int(b[0:2], 16) * t)\n g = int(int(a[2:4], 16) * (1 - t) + int(b[2:4], 16) * t)\n b = int(int(a[4:6], 16) * (1 - t) + int(b[4:6], 16) * t)\n return f'#{r:02x}{g:02x}{b:02x}'\n \n # ---- 3D Drawing ----\n \n def draw_cube(self, gx, gy, color, elev=0, height=16):\n \"\"\"Draw a pseudo-3D cube at grid cell (gx, gy)\"\"\"\n # Top face corners (at elevation + height)\n t_tl = self.g2s(gx, gy, elev + height)\n t_tr = self.g2s(gx + 1, gy, elev + height)\n t_br = self.g2s(gx + 1, gy + 1, elev + height)\n t_bl = self.g2s(gx, gy + 1, elev + height)\n \n # Bottom face corners (at elevation)\n b_tl = self.g2s(gx, gy, elev)\n b_tr = self.g2s(gx + 1, gy, elev)\n b_br = self.g2s(gx + 1, gy + 1, elev)\n b_bl = self.g2s(gx, gy + 1, elev)\n \n # Front face (south side - visible because we look from above)\n front_col = self.darker(color, 40)\n self.canvas.create_polygon(\n *t_bl, *t_br, *b_br, *b_bl,\n fill=front_col, outline=self.darker(color, 65), width=1)\n \n # Right face (east side)\n right_col = self.darker(color, 20)\n self.canvas.create_polygon(\n *t_tr, *t_br, *b_br, *b_tr,\n fill=right_col, outline=self.darker(color, 55), width=1)\n \n # Top face (brightest)\n top_col = self.lighter(color, 30)\n self.canvas.create_polygon(\n *t_tl, *t_tr, *t_br, *t_bl,\n fill=top_col, outline=self.darker(color, 25), width=1)\n \n def draw_food_glow(self, gx, gy):\n \"\"\"Draw a glowing 3D sphere as food\"\"\"\n cx, cy = gx + 0.5, gy + 0.5\n sx, sy = self.g2s(cx, cy, 18)\n \n pulse = 1 + 0.12 * math.sin(self.frame * 0.15)\n r = 13 * pulse\n base_color = '#ff3366'\n \n # Outer glow layers\n for i in range(8, 0, -1):\n gr = r + i * 5\n gc = self.lerp_color(base_color, '#080810', i * 0.1)\n self.canvas.create_oval(\n sx - gr, sy - gr * self.TILT,\n sx + gr, sy + gr * self.TILT,\n fill=gc, outline='')\n \n # Shadow on ground\n shx, shy = self.g2s(cx, cy, 0)\n self.canvas.create_oval(\n shx - 12, shy - 5, shx + 12, shy + 5,\n fill='#04040a', outline='')\n \n # Main sphere body\n self.canvas.create_oval(\n sx - r, sy - r * self.TILT,\n sx + r, sy + r * self.TILT,\n fill=base_color, outline=self.darker(base_color, 50), width=2)\n \n # Specular highlight\n hr = r * 0.3\n hx_off = r * 0.25\n hy_off = r * 0.35 * self.TILT\n self.canvas.create_oval(\n sx - hx_off - hr, sy - hy_off - hr,\n sx - hx_off + hr, sy - hy_off + hr,\n fill=self.lighter(base_color, 130), outline='')\n \n def draw_grid(self):\n \"\"\"Draw the 3D perspective grid floor\"\"\"\n grid_color = '#161630'\n \n # Horizontal lines\n for y in range(self.ROWS + 1):\n p1 = self.g2s(0, y)\n p2 = self.g2s(self.COLS, y)\n self.canvas.create_line(*p1, *p2, fill=grid_color)\n \n # Vertical lines\n for x in range(self.COLS + 1):\n p1 = self.g2s(x, 0)\n p2 = self.g2s(x, self.ROWS)\n self.canvas.create_line(*p1, *p2, fill=grid_color)\n \n # Border frame\n corners = [(0, 0), (self.COLS, 0), (self.COLS, self.ROWS), (0, self.ROWS)]\n pts = []\n for c in corners:\n pts.extend(self.g2s(*c))\n self.canvas.create_polygon(pts, fill='', outline='#3a3a80', width=3)\n \n def draw_eyes(self, gx, gy, elev):\n \"\"\"Draw eyes on snake head\"\"\"\n sx, sy = self.g2s(gx + 0.5, gy + 0.5, elev)\n \n # Eye positions based on direction\n offset = 6\n if self.dir == 'R':\n positions = [(offset, -5), (offset, 5)]\n elif self.dir == 'L':\n positions = [(-offset, -5), (-offset, 5)]\n elif self.dir == 'U':\n positions = [(-5, -offset), (5, -offset)]\n else: # D\n positions = [(-5, offset), (5, offset)]\n \n for ex, ey in positions:\n # White of eye\n er = 3.5\n self.canvas.create_oval(\n sx + ex - er, sy + ey - er,\n sx + ex + er, sy + ey + er,\n fill='white', outline='#222')\n # Pupil\n pr = 1.8\n self.canvas.create_oval(\n sx + ex - pr, sy + ey - pr,\n sx + ex + pr, sy + ey + pr,\n fill='#111', outline='')\n \n # ---- Main Render ----\n \n def render(self):\n self.canvas.delete('all')\n \n # Gradient background\n for i in range(0, self.H, 4):\n t = i / self.H\n r = int(8 + 12 * t)\n g = int(8 + 12 * t)\n b = int(16 + 28 * t)\n self.canvas.create_rectangle(0, i, self.W, i + 4,\n fill=f'#{r:02x}{g:02x}{b:02x}', outline='')\n \n # Grid\n self.draw_grid()\n \n # Collect and sort all objects by depth (painter's algorithm)\n render_list = []\n \n for i, (gx, gy) in enumerate(self.snake):\n render_list.append(('snake', i, gx, gy, gy * 1000 + gx))\n \n if self.food:\n fx, fy = self.food\n render_list.append(('food', 0, fx, fy, fy * 1000 + fx))\n \n # Sort back-to-front\n render_list.sort(key=lambda item: item[4])\n \n # Draw sorted items\n for kind, idx, gx, gy, _ in render_list:\n # Draw shadow first (on ground)\n shx, shy = self.g2s(gx + 0.5, gy + 0.5, 0)\n shadow_size = 15 if kind == 'snake' else 12\n self.canvas.create_oval(\n shx - shadow_size, shy - shadow_size * self.TILT,\n shx + shadow_size, shy + shadow_size * self.TILT,\n fill='#04040a', outline='')\n \n if kind == 'snake':\n if idx == 0:\n # Head\n color = '#00ff88'\n h = 20\n else:\n # Body - gradient from bright to dark\n t = idx / max(1, len(self.snake) - 1)\n color = self.lerp_color('#00dd66', '#003318', t)\n h = int(18 - 8 * t)\n \n self.draw_cube(gx, gy, color, elev=2, height=h)\n \n # Draw eyes on head\n if idx == 0:\n self.draw_eyes(gx, gy, 2 + h + 1)\n \n elif kind == 'food':\n self.draw_food_glow(gx, gy)\n \n # Particles\n new_particles = []\n for p in self.particles:\n p['x'] += p['vx']\n p['y'] += p['vy']\n p['vy'] += 0.3 # gravity\n p['life'] -= 1\n \n if p['life'] > 0:\n new_particles.append(p)\n life_ratio = p['life'] / p['max_life']\n s = p['size'] * life_ratio\n c = self.lerp_color(p['color'], '#080810', 1 - life_ratio)\n self.canvas.create_oval(\n p['x'] - s, p['y'] - s,\n p['x'] + s, p['y'] + s,\n fill=c, outline='')\n \n self.particles = new_particles\n \n # ---- HUD ----\n self.canvas.create_text(\n self.W // 2, 28,\n text=f\"🐍 SCORE: {self.score}\",\n fill='#00ff88', font=('Consolas', 28, 'bold'))\n \n speed_level = max(1, (131 - self.speed) // 2)\n self.canvas.create_text(\n self.W // 2, 60,\n text=f\"Speed Level: {speed_level}\",\n fill='#4488aa', font=('Consolas', 12))\n \n self.canvas.create_text(\n self.W // 2, self.H - 18,\n text=\"↑↓←→ Move | SPACE Restart | ESC Quit\",\n fill='#3333aa', font=('Consolas', 10))\n \n # ---- Game Over Overlay ----\n if not self.alive:\n self.canvas.create_rectangle(\n 0, 0, self.W, self.H,\n fill='#000000', stipple='gray50')\n \n self.canvas.create_text(\n self.W // 2, self.H // 2 - 55,\n text=\"GAME OVER\",\n fill='#ff2244', font=('Consolas', 54, 'bold'))\n \n self.canvas.create_text(\n self.W // 2, self.H // 2 + 10,\n text=f\"Final Score: {self.score}\",\n fill='#ffffff', font=('Consolas', 30))\n \n self.canvas.create_text(\n self.W // 2, self.H // 2 + 60,\n text=\"Press SPACE to restart\",\n fill='#aaaaaa', font=('Consolas', 16))\n\n\nif __name__ == '__main__':\n Snake3D()\n```\n\nThis looks pretty good! Let me review it one more time...\n\nOne thing I notice - the `draw_eyes` function might not work well because the eye positions relative to the grid cell center need to account for the cell size. Let me adjust.\n\nActually, the eyes should be positioned relative to the screen center of the cube. The cube's top face center would be at g2s(gx+0.5, gy+0.5, elev). The eye positions are offsets from that center in screen space. I think my current implementation should work, but the offset values might need tuning.\n\nLet me also make sure the depth sorting works correctly. In an oblique projection (tilt on Y only), objects with higher Y values should be drawn later (they appear closer to the viewer). The sorting key `gy * 1000 + gx` should work - objects with higher gy are drawn later. For same gy, higher gx is drawn later (though this doesn't matter much in a tilt-only projection).\n\nActually, there's a subtle issue: the snake body segments might overlap in depth. The tail should be drawn before the body, which should be drawn before the head. Since the head is at index 0, and the tail is at the end, and they might have different gy values, the depth sort might cause some segments to overlap incorrectly.\n\nBut for most gameplay scenarios, this should look fine. The head will be drawn on top if it's at a higher gy, and body segments will be properly layered.\n\nLet me also check: do I need to handle the case where the snake wraps around the grid? No, because the game ends when hitting a wall (no wrapping).\n\nI think the code is ready. Let me also add a nice title/splash screen or at least make the initial state look good.\n\nActually, let me keep it simple. The game works as described. Let me finalize.\n\nOne more thing - I should make the particles spawn from the food position in screen space. Let me double-check that `spawn_burst` is called with grid coordinates, and it converts to screen space. Yes, it does via `g2s`.\n\nLet me finalize the code. I think it's ready.\n\nWait, let me also reconsider the shadow drawing. Currently I draw shadows for all snake segments and the food in the render loop. The shadows are drawn at ground level. This should be fine.\n\nActually, I realized there might be a performance issue with the gradient background. Creating that many canvas items (lines) every frame could be slow. Let me optimize by using fewer bands or creating the background once.\n\nFor tkinter, drawing many items each frame with `delete('all')` can be slow. Let me consider optimizing:\n1. Reduce gradient bands (use larger steps)\n2. Or use a solid dark background\n\nLet me use a simpler background with just a few bands to improve performance.\n\nAlso, the grid lines are drawn every frame. Since they don't change, I could cache them. But with `delete('all')`, everything is redrawn. Let me keep it simple for now.\n\nActually, for the gradient background, using steps of 4 pixels means about 170 rectangles for a 680px height. That should be fine.\n\nLet me finalize and present the code. I think it's good enough.\n\nOne last thought - the `draw_eyes` function. The eye offsets need to be in screen space. Let me trace through:\n\nFor direction 'R':\n- We want eyes on the right side of the head\n- The head cube's top face center is at g2s(gx+0.5, gy+0.5, elev)\n- In screen space, \"right\" means positive X\n- So positions = [(offset, -5), (offset, 5)] means two eyes to the right, one slightly up and one slightly down\n\nThis should work for a simple implementation. The eyes won't be perfectly positioned for all directions, but they'll give a good indication of the snake's facing direction.\n\nOK I'm done. Let me write the final clean version.\n\nActually, I want to reconsider one more time. The user said \"usahakan 3d\" (try to make it 3D). So they really want the 3D effect to be prominent. Let me make sure the 3D cubes look good.\n\nThe key to making the 3D effect convincing is:\n1. The top face should be clearly visible (bright)\n2. The front face should be darker\n3. The right face should be medium brightness\n4. Shadows should ground the objects\n5. The grid should give perspective cues\n\nI think my implementation covers all of these. Let me finalize.\n\nLet me write the absolute final version now with some minor improvements for visual polish.","format":"unknown","index":0}]},"native_finish_reason":"stop"}],"created":1782457573,"model":"xiaomi/mimo-v2.5-pro-20260422","object":"chat.completion","service_tier":null,"system_fingerprint":null,"usage":{"completion_tokens":24981,"prompt_tokens":268,"total_tokens":25249,"completion_tokens_details":{"accepted_prediction_tokens":null,"audio_tokens":0,"reasoning_tokens":19920,"rejected_prediction_tokens":null,"image_tokens":0},"prompt_tokens_details":{"audio_tokens":0,"cached_tokens":192,"cache_write_tokens":0,"video_tokens":0},"cost":0.0217672212,"is_byok":false,"cost_details":{"upstream_inference_cost":0.0217672212,"upstream_inference_prompt_cost":0.0000337512,"upstream_inference_completions_cost":0.02173347}},"provider":"Xiaomi"}

Buatkan game ular menggunakan tkinter python. usahakan 3d.