# Vibe Coding: py-tank 小遊戲專案
此筆記包含了Leon 以Vibe Coding 進行簡易遊戲專案製作的過程。
## 1. 何謂Vibe Coding?
:::info
依照Vibe coding的定義，其中的重要概念是使用者接受AI產生的程式碼，不需要對其有完全的理解。
:::
OpenAI的共同創辦人安德烈·卡帕斯從2023年起的主張「最新最熱門的程式語言是英文」，意味著大型語言模型的能力已可以讓人不需要為了讓電腦運作而學習特定的程式語言。
與其說是一種工具或開發方法，Vibe Coding 更貼近一種行為或概念: 使用者不需要對程式語言或程式開發有任何理解，單純以口語方式告訴LLM 模型他們想要做出的功能，並++完全仰賴LLM 所產生出來的程式碼++。
:::spoiler 警告: 極度厭世內容
~~講難聽點，Vibe Coding 就是讓一個對程式一竅不通的蔡逼八可以在咖啡廳裡翹著二郎腿，給AI 文字描述他想要做什麼東西出來，然後讓AI 自動產生程式碼，而這個蔡逼八就能沾沾自喜地覺得花錢去讀大學讀碩士的工程師都是白癡。
這年頭會用電腦的蔡逼八都能自喻為業界講師在網路上招搖撞騙了，誰還會尊重專業領域?~~
- [吳淡如自居電腦繪圖爭議事件](https://www.thenewslens.com/article/181135)
- [自己Vibe 到害自己賠錢還怪Google 的在線上付費課程講師蔡逼八事件](https://www.facebook.com/share/p/1DUquqMHqQ/)
- [文本: 所有 vibe coding 工具都在販賣快速致富的幻覺](https://www.blocktempo.com/all-vibe-coding-is-selling-dream-of-getting-rich/)
:::
## 2. 實驗規則
依據現有的對Vibe Coding 的定義，基本上有以下特性：
- 使用者僅以口語方式描述自己想達成的目的。
- 將LLM 串聯至開發環境IDE，使其自行產生所需的檔案與腳本。
- 使用者++不需++理解LLM 所產生的程式碼以及其功能。
- 使用者++不得++理解LLM 所產生的程式碼以及其功能。
- 使用者++不可++干涉LLM 所產生的程式碼以及其功能。
基本上，這代表著使用者必須完全仰賴由LLM 所產生出來的程式碼，並且不可對其進行解析、偵錯或修改。又或者說：你可以修改，但你必須叫LLM 幫你修改，就算只是修改個int 的值也是一樣(而且理論上，你連這個int 在程式碼中所代表的變數名稱是什麼都不應該知道)。
重新整理了我們對Vibe Coding 的定義後，本次實驗計畫有以下幾點規則，並且應嚴格遵守：
1. 所有程式碼須由ChatGPT 生成。
2. 與ChatGPT 的對話過程中不可有針對程式工程相關的描述。
4. 不可閱讀與分析程式碼。
3. 除了將ChatGPT 所產生的程式碼複製至IDE以外，不可修改任何程式碼。
在遵守以上規則的條件下，我將使用GPT-5 模型嘗試在Python 中重新復刻懷舊電玩 **Tank 1990** 2D遊戲。
(**Tank 1990** 原版遊戲)
## 3. 實驗過程
### 3-1. 建立環境
首先需要遊戲的基礎環境。我讓Chatgpt 幫我產生最基礎的環境，包含了遊戲場景和玩家角色。
起初我只希望縣建立好空白場景即可，想不到在最一開始所vibe 出來的腳本就已經包含了基礎角色的操作功能了。
#### Prompt:
Leon>>
Let's make a simple 2D tank shooter game like Tank 1990 on NES.
If pygame can build this game, we use pygame.
But you need to teach me how to install pygame and everything we need.
我們來做個簡單的2D戰車遊戲，像NES 上的**Tank 1990** 一樣。
如果pygame 套件可以做出這個遊戲的話那就用pygame，但你必須要告訴我安裝pygame 的步驟。
#### Python Script
:::spoiler
```python=
import pygame
import sys
# Initialize Pygame
pygame.init()
# Screen setup
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Tank 1990 Clone")
# Colors
BLACK = (0, 0, 0)
GREEN = (0, 255, 0)
# Tank setup
tank_size = 40
tank_x = SCREEN_WIDTH // 2
tank_y = SCREEN_HEIGHT - 60
tank_speed = 5
# Game loop
clock = pygame.time.Clock()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# Handle input
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
tank_x -= tank_speed
if keys[pygame.K_RIGHT]:
tank_x += tank_speed
if keys[pygame.K_UP]:
tank_y -= tank_speed
if keys[pygame.K_DOWN]:
tank_y += tank_speed
# Draw
screen.fill(BLACK)
pygame.draw.rect(screen, GREEN, (tank_x, tank_y, tank_size, tank_size))
pygame.display.flip()
clock.tick(60)
```
:::
---
### 3-2. 加入子彈射擊
第二步是加上子彈和發射的功能，我只簡易地告訴gpt 加上子彈射擊，他便修改了原先的腳本。
不過這個版本只能固定朝同一個方向發射，不能切換方向。
#### Prompt:
Leon>> Let's add bullet shooting
我們來加上子彈和射擊吧
#### Python Script
:::spoiler
```python=
import pygame
import sys
# Initialize Pygame
pygame.init()
# Screen setup
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Tank 1990 Clone")
# Colors
BLACK = (0, 0, 0)
GREEN = (0, 255, 0)
YELLOW = (255, 255, 0)
# Tank setup
tank_size = 40
tank_x = SCREEN_WIDTH // 2
tank_y = SCREEN_HEIGHT - 60
tank_speed = 5
# Bullet setup
bullets = []
bullet_speed = 8
bullet_size = 8
# Game loop
clock = pygame.time.Clock()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# Fire bullet
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
# Spawn bullet at tank’s center top
bullet_x = tank_x + tank_size // 2 - bullet_size // 2
bullet_y = tank_y
bullets.append([bullet_x, bullet_y])
# Handle input
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
tank_x -= tank_speed
if keys[pygame.K_RIGHT]:
tank_x += tank_speed
if keys[pygame.K_UP]:
tank_y -= tank_speed
if keys[pygame.K_DOWN]:
tank_y += tank_speed
# Update bullets
for bullet in bullets:
bullet[1] -= bullet_speed
# Remove off-screen bullets
bullets = [b for b in bullets if b[1] > -bullet_size]
# Draw everything
screen.fill(BLACK)
pygame.draw.rect(screen, GREEN, (tank_x, tank_y, tank_size, tank_size))
for bullet in bullets:
pygame.draw.rect(screen, YELLOW, (bullet[0], bullet[1], bullet_size, bullet_size))
pygame.display.flip()
clock.tick(60)
```
:::
---
### 3-3. 坦克旋轉方向
關於下一步，gpt 已經給我四個不同的建議內容，我只告訴他"下一步"，gpt 便決定來實作讓玩家角色(戰車)的旋轉與移動功能。
在這個步驟中，gpt 把玩家角色修改成只能水平/垂直移動，而戰車砲管則會朝向最後移動的方向，因此子彈只會朝最後移動的方向發射。
#### Prompt:
ChatGPT<< Once you confirm it’s working, we can move to:
🔁 Making the tank face different directions and shoot accordingly
💥 Adding enemies or walls to hit
🎯 Collision detection
Which one would you like to tackle next?
Leon>> Let's go to next step
ChatGPT<< Perfect — let’s make your tank rotate
and shoot in 4 directions like in the original Tank 1990!
#### Python Script
:::spoiler
```python=
import pygame
import sys
# Initialize Pygame
pygame.init()
# Screen setup
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Tank 1990 Clone")
# Colors
BLACK = (0, 0, 0)
GREEN = (0, 255, 0)
YELLOW = (255, 255, 0)
# Tank setup
tank_size = 40
tank_x = SCREEN_WIDTH // 2
tank_y = SCREEN_HEIGHT - 60
tank_speed = 5
tank_dir = "UP" # current facing direction
# Bullet setup
bullets = []
bullet_speed = 8
bullet_size = 8
# Game loop
clock = pygame.time.Clock()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# Fire bullet
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
# Spawn bullet at tank’s center
bullet_x = tank_x + tank_size // 2 - bullet_size // 2
bullet_y = tank_y + tank_size // 2 - bullet_size // 2
# Bullet velocity based on direction
vx, vy = 0, 0
if tank_dir == "UP":
vy = -bullet_speed
elif tank_dir == "DOWN":
vy = bullet_speed
elif tank_dir == "LEFT":
vx = -bullet_speed
elif tank_dir == "RIGHT":
vx = bullet_speed
bullets.append([bullet_x, bullet_y, vx, vy])
# Handle input
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
tank_x -= tank_speed
tank_dir = "LEFT"
elif keys[pygame.K_RIGHT]:
tank_x += tank_speed
tank_dir = "RIGHT"
elif keys[pygame.K_UP]:
tank_y -= tank_speed
tank_dir = "UP"
elif keys[pygame.K_DOWN]:
tank_y += tank_speed
tank_dir = "DOWN"
# Update bullets
for bullet in bullets:
bullet[0] += bullet[2]
bullet[1] += bullet[3]
# Remove off-screen bullets
bullets = [b for b in bullets if 0 <= b[0] <= SCREEN_WIDTH and 0 <= b[1] <= SCREEN_HEIGHT]
# Draw
screen.fill(BLACK)
# Draw tank (we’ll rotate its shape based on direction)
tank_rect = pygame.Rect(tank_x, tank_y, tank_size, tank_size)
pygame.draw.rect(screen, GREEN, tank_rect)
# Draw a small barrel line to indicate direction
if tank_dir == "UP":
pygame.draw.line(screen, YELLOW, (tank_x + tank_size // 2, tank_y),
(tank_x + tank_size // 2, tank_y - 10), 3)
elif tank_dir == "DOWN":
pygame.draw.line(screen, YELLOW, (tank_x + tank_size // 2, tank_y + tank_size),
(tank_x + tank_size // 2, tank_y + tank_size + 10), 3)
elif tank_dir == "LEFT":
pygame.draw.line(screen, YELLOW, (tank_x, tank_y + tank_size // 2),
(tank_x - 10, tank_y + tank_size // 2), 3)
elif tank_dir == "RIGHT":
pygame.draw.line(screen, YELLOW, (tank_x + tank_size, tank_y + tank_size // 2),
(tank_x + tank_size + 10, tank_y + tank_size // 2), 3)
# Draw bullets
for bullet in bullets:
pygame.draw.rect(screen, YELLOW, (bullet[0], bullet[1], bullet_size, bullet_size))
pygame.display.flip()
clock.tick(60)
```
:::
---
### 3-4. 新增可擊破的障礙
在這一個階段，我想要加入簡單的可以攻擊的目標，於是我讓gpt 產生原作中的障礙物牆壁，這些牆壁是可以被玩家或敵人以子彈射擊摧毀的。
不過gpt 對原作**Tank 1990** 算是挺了解的，我只告訴他加上磚塊牆，他便自動讓這個牆可以被玩家給摧毀而不用我另外再輸入指示。
#### Prompt:
Leon>> Let's do walls and bricks first.
我們先來做磚塊牆壁吧。
#### Python Script
:::spoiler
```python=
import pygame
import sys
pygame.init()
# Screen setup
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Tank 1990 Clone")
# Colors
BLACK = (0, 0, 0)
GREEN = (0, 255, 0)
YELLOW = (255, 255, 0)
BROWN = (139, 69, 19)
# Tank setup
tank_size = 40
tank_x = SCREEN_WIDTH // 2
tank_y = SCREEN_HEIGHT - 60
tank_speed = 5
tank_dir = "UP"
# Bullet setup
bullets = []
bullet_speed = 8
bullet_size = 8
# Brick setup
brick_size = 40
bricks = []
for row in range(5):
for col in range(10):
x = 200 + col * brick_size
y = 150 + row * brick_size
bricks.append(pygame.Rect(x, y, brick_size, brick_size))
clock = pygame.time.Clock()
# Helper: rectangle collision
def rect_collide(rect1, rect2):
return rect1.colliderect(rect2)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# Fire bullet
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
bullet_x = tank_x + tank_size // 2 - bullet_size // 2
bullet_y = tank_y + tank_size // 2 - bullet_size // 2
vx, vy = 0, 0
if tank_dir == "UP":
vy = -bullet_speed
elif tank_dir == "DOWN":
vy = bullet_speed
elif tank_dir == "LEFT":
vx = -bullet_speed
elif tank_dir == "RIGHT":
vx = bullet_speed
bullets.append([bullet_x, bullet_y, vx, vy])
# Handle movement
keys = pygame.key.get_pressed()
next_x, next_y = tank_x, tank_y
if keys[pygame.K_LEFT]:
next_x -= tank_speed
tank_dir = "LEFT"
elif keys[pygame.K_RIGHT]:
next_x += tank_speed
tank_dir = "RIGHT"
elif keys[pygame.K_UP]:
next_y -= tank_speed
tank_dir = "UP"
elif keys[pygame.K_DOWN]:
next_y += tank_speed
tank_dir = "DOWN"
# Check collision with bricks before moving
next_rect = pygame.Rect(next_x, next_y, tank_size, tank_size)
if not any(next_rect.colliderect(b) for b in bricks):
tank_x, tank_y = next_x, next_y
# Update bullets
for bullet in bullets:
bullet[0] += bullet[2]
bullet[1] += bullet[3]
# Remove off-screen bullets
bullets = [b for b in bullets if 0 <= b[0] <= SCREEN_WIDTH and 0 <= b[1] <= SCREEN_HEIGHT]
# Bullet vs Brick collision
new_bullets = []
for bullet in bullets:
bullet_rect = pygame.Rect(bullet[0], bullet[1], bullet_size, bullet_size)
hit_brick = None
for brick in bricks:
if bullet_rect.colliderect(brick):
hit_brick = brick
break
if hit_brick:
bricks.remove(hit_brick) # destroy brick
else:
new_bullets.append(bullet)
bullets = new_bullets
# Draw everything
screen.fill(BLACK)
# Draw bricks
for brick in bricks:
pygame.draw.rect(screen, BROWN, brick)
# Draw tank
tank_rect = pygame.Rect(tank_x, tank_y, tank_size, tank_size)
pygame.draw.rect(screen, GREEN, tank_rect)
# Barrel
if tank_dir == "UP":
pygame.draw.line(screen, YELLOW, (tank_x + tank_size // 2, tank_y),
(tank_x + tank_size // 2, tank_y - 10), 3)
elif tank_dir == "DOWN":
pygame.draw.line(screen, YELLOW, (tank_x + tank_size // 2, tank_y + tank_size),
(tank_x + tank_size // 2, tank_y + tank_size + 10), 3)
elif tank_dir == "LEFT":
pygame.draw.line(screen, YELLOW, (tank_x, tank_y + tank_size // 2),
(tank_x - 10, tank_y + tank_size // 2), 3)
elif tank_dir == "RIGHT":
pygame.draw.line(screen, YELLOW, (tank_x + tank_size, tank_y + tank_size // 2),
(tank_x + tank_size + 10, tank_y + tank_size // 2), 3)
# Draw bullets
for bullet in bullets:
pygame.draw.rect(screen, YELLOW, (bullet[0], bullet[1], bullet_size, bullet_size))
pygame.display.flip()
clock.tick(60)
```
:::
---
### 3-5. 新增敵人角色
在這個階段，我叫gpt 加上敵人角色。
這個時候更新的腳本會讓遊戲在開始時產生兩個紅色戰車作為敵人，這些敵人角色行為模式跟玩家角色一樣會四處隨機行走，並會隨機發射子彈，子彈也會摧毀牆壁。
然而，這次gpt 所產生的敵人並不會被玩家的子彈給摧毀，而他對玩家的攻擊也沒有傷害，單純只會摧毀牆壁而已。
#### Prompt:
Leon>> Let's make enemy tanks now
我們現在來加上敵人角色
#### Python Script
:::spoiler
```python=
import pygame
import sys
import random
pygame.init()
# Screen setup
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Tank 1990 Clone")
# Colors
BLACK = (0, 0, 0)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)
BROWN = (139, 69, 19)
# Tank setup
tank_size = 35
tank_speed = 5
# Bullet setup
bullet_speed = 8
bullet_size = 8
# Brick setup
brick_size = 40
bricks = []
for row in range(5):
for col in range(10):
x = 200 + col * brick_size
y = 150 + row * brick_size
bricks.append(pygame.Rect(x, y, brick_size, brick_size))
# ====== Enemy Class ======
class Enemy:
def __init__(self, x, y):
self.rect = pygame.Rect(x, y, tank_size, tank_size)
self.dir = random.choice(["UP", "DOWN", "LEFT", "RIGHT"])
self.move_timer = 0
self.bullets = []
self.shoot_timer = 0
def update(self, dt):
# Move randomly
self.move_timer -= dt
if self.move_timer <= 0:
self.dir = random.choice(["UP", "DOWN", "LEFT", "RIGHT"])
self.move_timer = random.randint(500, 1500) # ms
dx, dy = 0, 0
if self.dir == "UP":
dy = -2
elif self.dir == "DOWN":
dy = 2
elif self.dir == "LEFT":
dx = -2
elif self.dir == "RIGHT":
dx = 2
next_rect = self.rect.move(dx, dy)
# Collision with bricks
if not any(next_rect.colliderect(b) for b in bricks):
self.rect = next_rect
# Shooting
self.shoot_timer -= dt
if self.shoot_timer <= 0:
self.shoot()
self.shoot_timer = random.randint(1500, 2500)
# Update bullets
for bullet in self.bullets:
bullet[0] += bullet[2]
bullet[1] += bullet[3]
self.bullets = [b for b in self.bullets if 0 <= b[0] <= SCREEN_WIDTH and 0 <= b[1] <= SCREEN_HEIGHT]
def shoot(self):
bullet_x = self.rect.x + tank_size // 2 - bullet_size // 2
bullet_y = self.rect.y + tank_size // 2 - bullet_size // 2
vx, vy = 0, 0
if self.dir == "UP":
vy = -bullet_speed
elif self.dir == "DOWN":
vy = bullet_speed
elif self.dir == "LEFT":
vx = -bullet_speed
elif self.dir == "RIGHT":
vx = bullet_speed
self.bullets.append([bullet_x, bullet_y, vx, vy])
def draw(self, surface):
pygame.draw.rect(surface, RED, self.rect)
# barrel
cx, cy = self.rect.center
if self.dir == "UP":
pygame.draw.line(surface, YELLOW, (cx, self.rect.top), (cx, self.rect.top - 10), 3)
elif self.dir == "DOWN":
pygame.draw.line(surface, YELLOW, (cx, self.rect.bottom), (cx, self.rect.bottom + 10), 3)
elif self.dir == "LEFT":
pygame.draw.line(surface, YELLOW, (self.rect.left, cy), (self.rect.left - 10, cy), 3)
elif self.dir == "RIGHT":
pygame.draw.line(surface, YELLOW, (self.rect.right, cy), (self.rect.right + 10, cy), 3)
# bullets
for b in self.bullets:
pygame.draw.rect(surface, YELLOW, (b[0], b[1], bullet_size, bullet_size))
# ====== Player Setup ======
tank_x = SCREEN_WIDTH // 2
tank_y = SCREEN_HEIGHT - 60
tank_dir = "UP"
bullets = []
# ====== Enemies ======
enemies = [
Enemy(100, 100),
Enemy(600, 100)
]
clock = pygame.time.Clock()
# ====== Game Loop ======
while True:
dt = clock.tick(60) # delta time in ms
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# Fire bullet
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
bullet_x = tank_x + tank_size // 2 - bullet_size // 2
bullet_y = tank_y + tank_size // 2 - bullet_size // 2
vx, vy = 0, 0
if tank_dir == "UP":
vy = -bullet_speed
elif tank_dir == "DOWN":
vy = bullet_speed
elif tank_dir == "LEFT":
vx = -bullet_speed
elif tank_dir == "RIGHT":
vx = bullet_speed
bullets.append([bullet_x, bullet_y, vx, vy])
# Player movement
keys = pygame.key.get_pressed()
next_x, next_y = tank_x, tank_y
if keys[pygame.K_LEFT]:
next_x -= tank_speed
tank_dir = "LEFT"
elif keys[pygame.K_RIGHT]:
next_x += tank_speed
tank_dir = "RIGHT"
elif keys[pygame.K_UP]:
next_y -= tank_speed
tank_dir = "UP"
elif keys[pygame.K_DOWN]:
next_y += tank_speed
tank_dir = "DOWN"
next_rect = pygame.Rect(next_x, next_y, tank_size, tank_size)
if not any(next_rect.colliderect(b) for b in bricks):
tank_x, tank_y = next_x, next_y
# Update bullets
for bullet in bullets:
bullet[0] += bullet[2]
bullet[1] += bullet[3]
bullets = [b for b in bullets if 0 <= b[0] <= SCREEN_WIDTH and 0 <= b[1] <= SCREEN_HEIGHT]
# Bullet vs Brick (player)
new_bullets = []
for bullet in bullets:
bullet_rect = pygame.Rect(bullet[0], bullet[1], bullet_size, bullet_size)
hit_brick = next((brick for brick in bricks if bullet_rect.colliderect(brick)), None)
if hit_brick:
bricks.remove(hit_brick)
else:
new_bullets.append(bullet)
bullets = new_bullets
# Update enemies
for e in enemies:
e.update(dt)
# Enemy bullet vs brick
new_enemy_bullets = []
for bullet in e.bullets:
bullet_rect = pygame.Rect(bullet[0], bullet[1], bullet_size, bullet_size)
hit_brick = next((brick for brick in bricks if bullet_rect.colliderect(brick)), None)
if hit_brick:
bricks.remove(hit_brick)
else:
new_enemy_bullets.append(bullet)
e.bullets = new_enemy_bullets
# ===== Drawing =====
screen.fill(BLACK)
# Bricks
for brick in bricks:
pygame.draw.rect(screen, BROWN, brick)
# Player tank
tank_rect = pygame.Rect(tank_x, tank_y, tank_size, tank_size)
pygame.draw.rect(screen, GREEN, tank_rect)
cx, cy = tank_rect.center
if tank_dir == "UP":
pygame.draw.line(screen, YELLOW, (cx, tank_rect.top), (cx, tank_rect.top - 10), 3)
elif tank_dir == "DOWN":
pygame.draw.line(screen, YELLOW, (cx, tank_rect.bottom), (cx, tank_rect.bottom + 10), 3)
elif tank_dir == "LEFT":
pygame.draw.line(screen, YELLOW, (tank_rect.left, cy), (tank_rect.left - 10, cy), 3)
elif tank_dir == "RIGHT":
pygame.draw.line(screen, YELLOW, (tank_rect.right, cy), (tank_rect.right + 10, cy), 3)
# Player bullets
for b in bullets:
pygame.draw.rect(screen, YELLOW, (b[0], b[1], bullet_size, bullet_size))
# Enemy tanks
for e in enemies:
e.draw(screen)
pygame.display.flip()
```
:::
---
## 4. 尾聲
由於GPT-5 的免費流量已用盡，因此本次實驗僅進行到此處。
我個人認為過程之所以如此順利，除了GPT-5 變得更聰明以外，最重要的重點在於++給予的提示過於明確++。
在這次的實驗中，我在最一開始便說明要製作一款類似**Tank 1990** 的遊戲，這樣子的提示已經給予gpt 很多的資訊，因為**Tank 1990** 已經是一款經典且悠久的遊戲，所以gpt 不需要特別重新理解便可以知道大致的概念，並且還會主動建議下一步該實作什麼樣的功能。
若是不講遊戲名稱，而是一個步驟一個步驟讓gpt 去產生程式碼，或許過程就會不夠順利而且需要反覆嘗試才能做出成品出來。
Sign in via Google
Sign in via Facebook
Sign in via X(Twitter)
Sign in via GitHub
Sign in via Dropbox
Sign in with Wallet
Connect another wallet