adolforeyna/basic1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add final 4 games for basic1 console

Browse Source 
- 2048: Grid merging, directional movement, score tracking, win/draw detection
- Tic-Tac-Toe: Minimax AI opponent, perfect play, win detection
- Lunar Lander: Gravity + thrust physics, fuel management, landing validation
- Air Hockey: Refined paddle physics, puck acceleration, goal detection

All games tested for state transitions, collision logic, and win conditions.
Suite now complete with 10 classic games ready for SD card deployment.
This commit is contained in:
Adolfo Reyna
2026-02-12 19:40:42 -05:00
parent 53a2fb046b
commit 50793ac535
4 changed files with 1025 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

378
games/lua_examples/2048.lua Normal file
View File

@@ -0,0 +1,378 @@
-- NAME: 2048
-- DESC: Merge tiles to reach 2048
-- Game states
local STATE_MENU = 0
local STATE_PLAYING = 1
local STATE_GAME_OVER = 2
local STATE_WIN = 3
-- Game constants
local GRID_SIZE = 4
local TILE_SIZE = 20
local TILE_SPACING = 2
function init()
game.vars.state = STATE_MENU
game.vars.score = 0
-- Grid (4x4, 0 = empty)
game.vars.grid = {}
for y = 1, GRID_SIZE do
game.vars.grid[y] = {}
for x = 1, GRID_SIZE do
game.vars.grid[y][x] = 0
end
end
game.vars.moved = false
game.vars.won = false
-- Enable continuous updates
game.set_frame_updates(true)
print("2048 initialized")
end
function update(event)
local state = game.vars.state
if state == STATE_MENU then
if event.type == INPUT.TOUCH_DOWN or event.type == INPUT.BUTTON_0 or event.type == INPUT.BUTTON_1 then
reset_game()
game.vars.state = STATE_PLAYING
return true
end
elseif state == STATE_PLAYING then
if event.type == INPUT.TOUCH_DOWN then
-- Determine swipe direction
local direction = get_swipe_direction(event.x, event.y)
if direction then
game.vars.moved = false
move_tiles(direction)
if game.vars.moved then
spawn_tile()
-- Check win/lose
if has_tile(2048) then
if not game.vars.won then
game.vars.state = STATE_WIN
game.vars.won = true
end
end
if not can_move() then
game.vars.state = STATE_GAME_OVER
end
return true
end
end
end
elseif state == STATE_WIN then
if event.type == INPUT.TOUCH_DOWN or event.type == INPUT.BUTTON_0 or event.type == INPUT.BUTTON_1 then
-- Can continue playing or go to menu
if event.y < game.height() / 2 then
game.vars.state = STATE_PLAYING
else
game.vars.state = STATE_MENU
end
return true
end
elseif state == STATE_GAME_OVER then
if event.type == INPUT.TOUCH_DOWN or event.type == INPUT.BUTTON_0 or event.type == INPUT.BUTTON_1 then
game.vars.state = STATE_MENU
return true
end
end
return false
end
function draw()
renderer.clear(false)
local state = game.vars.state
if state == STATE_MENU then
renderer.text(game.width() / 2 - 15, game.height() / 2 - 30, "2048", true)
renderer.text(game.width() / 2 - 50, game.height() / 2, "Tap to Start", true)
elseif state == STATE_PLAYING or state == STATE_WIN or state == STATE_GAME_OVER then
-- Draw grid
local start_x = (game.width() - (GRID_SIZE * (TILE_SIZE + TILE_SPACING))) / 2
local start_y = 20
for y = 1, GRID_SIZE do
for x = 1, GRID_SIZE do
local tile_x = start_x + (x - 1) * (TILE_SIZE + TILE_SPACING)
local tile_y = start_y + (y - 1) * (TILE_SIZE + TILE_SPACING)
local value = game.vars.grid[y][x]
if value == 0 then
-- Empty tile
renderer.rect(tile_x, tile_y, TILE_SIZE, TILE_SIZE, true, false)
else
-- Filled tile
renderer.rect(tile_x, tile_y, TILE_SIZE, TILE_SIZE, true, true)
-- Draw value (simplified)
local text = tostring(value)
if string.len(text) <= 2 then
renderer.text(tile_x + 2, tile_y + 2, text, false)
else
renderer.text(tile_x + 1, tile_y + 2, text, false)
end
end
end
end
-- Draw score
renderer.text(10, 10, "Score: " .. tostring(game.vars.score), true)
if state == STATE_WIN then
renderer.text(game.width() / 2 - 30, game.height() / 2 - 20, "YOU WIN!", true)
renderer.text(game.width() / 2 - 60, game.height() / 2, "Tap up: Continue", true)
renderer.text(game.width() / 2 - 50, game.height() / 2 + 15, "Tap down: Menu", true)
end
if state == STATE_GAME_OVER then
renderer.text(game.width() / 2 - 40, game.height() / 2, "GAME OVER", true)
renderer.text(game.width() / 2 - 30, game.height() / 2 + 15, "Score: " .. tostring(game.vars.score), true)
renderer.text(game.width() / 2 - 60, game.height() / 2 + 30, "Tap to Menu", true)
end
end
end
function get_swipe_direction(x, y)
-- Simple tap-based direction (could be enhanced with swipe tracking)
local mid_x = game.width() / 2
local mid_y = game.height() / 2
local dx = x - mid_x
local dy = y - mid_y
if math.abs(dx) > math.abs(dy) then
if dx > 0 then return "right" end
return "left"
else
if dy > 0 then return "down" end
return "up"
end
end
function move_tiles(direction)
local old_grid = {}
for y = 1, GRID_SIZE do
old_grid[y] = {}
for x = 1, GRID_SIZE do
old_grid[y][x] = game.vars.grid[y][x]
end
end
if direction == "left" then
move_left()
elseif direction == "right" then
move_right()
elseif direction == "up" then
move_up()
elseif direction == "down" then
move_down()
end
-- Check if grid changed
for y = 1, GRID_SIZE do
for x = 1, GRID_SIZE do
if old_grid[y][x] ~= game.vars.grid[y][x] then
game.vars.moved = true
return
end
end
end
end
function move_left()
for y = 1, GRID_SIZE do
-- Compact
local row = {}
for x = 1, GRID_SIZE do
if game.vars.grid[y][x] ~= 0 then
table.insert(row, game.vars.grid[y][x])
end
end
-- Merge
local i = 1
while i < #row do
if row[i] == row[i + 1] then
row[i] = row[i] * 2
game.vars.score = game.vars.score + row[i]
table.remove(row, i + 1)
end
i = i + 1
end
-- Fill back
for x = 1, GRID_SIZE do
if x <= #row then
game.vars.grid[y][x] = row[x]
else
game.vars.grid[y][x] = 0
end
end
end
end
function move_right()
for y = 1, GRID_SIZE do
local row = {}
for x = GRID_SIZE, 1, -1 do
if game.vars.grid[y][x] ~= 0 then
table.insert(row, game.vars.grid[y][x])
end
end
local i = 1
while i < #row do
if row[i] == row[i + 1] then
row[i] = row[i] * 2
game.vars.score = game.vars.score + row[i]
table.remove(row, i + 1)
end
i = i + 1
end
for x = GRID_SIZE, 1, -1 do
if GRID_SIZE - x + 1 <= #row then
game.vars.grid[y][x] = row[GRID_SIZE - x + 1]
else
game.vars.grid[y][x] = 0
end
end
end
end
function move_up()
for x = 1, GRID_SIZE do
local col = {}
for y = 1, GRID_SIZE do
if game.vars.grid[y][x] ~= 0 then
table.insert(col, game.vars.grid[y][x])
end
end
local i = 1
while i < #col do
if col[i] == col[i + 1] then
col[i] = col[i] * 2
game.vars.score = game.vars.score + col[i]
table.remove(col, i + 1)
end
i = i + 1
end
for y = 1, GRID_SIZE do
if y <= #col then
game.vars.grid[y][x] = col[y]
else
game.vars.grid[y][x] = 0
end
end
end
end
function move_down()
for x = 1, GRID_SIZE do
local col = {}
for y = GRID_SIZE, 1, -1 do
if game.vars.grid[y][x] ~= 0 then
table.insert(col, game.vars.grid[y][x])
end
end
local i = 1
while i < #col do
if col[i] == col[i + 1] then
col[i] = col[i] * 2
game.vars.score = game.vars.score + col[i]
table.remove(col, i + 1)
end
i = i + 1
end
for y = GRID_SIZE, 1, -1 do
if GRID_SIZE - y + 1 <= #col then
game.vars.grid[y][x] = col[GRID_SIZE - y + 1]
else
game.vars.grid[y][x] = 0
end
end
end
end
function spawn_tile()
local empty = {}
for y = 1, GRID_SIZE do
for x = 1, GRID_SIZE do
if game.vars.grid[y][x] == 0 then
table.insert(empty, {x = x, y = y})
end
end
end
if #empty > 0 then
local pos = empty[math.random(1, #empty)]
game.vars.grid[pos.y][pos.x] = math.random() > 0.9 and 4 or 2
end
end
function has_tile(value)
for y = 1, GRID_SIZE do
for x = 1, GRID_SIZE do
if game.vars.grid[y][x] == value then
return true
end
end
end
return false
end
function can_move()
-- Check if any empty tiles
for y = 1, GRID_SIZE do
for x = 1, GRID_SIZE do
if game.vars.grid[y][x] == 0 then
return true
end
end
end
-- Check if any merges possible
for y = 1, GRID_SIZE do
for x = 1, GRID_SIZE do
local val = game.vars.grid[y][x]
if x < GRID_SIZE and game.vars.grid[y][x + 1] == val then return true end
if y < GRID_SIZE and game.vars.grid[y + 1][x] == val then return true end
end
end
return false
end
function reset_game()
game.vars.score = 0
game.vars.won = false
for y = 1, GRID_SIZE do
for x = 1, GRID_SIZE do
game.vars.grid[y][x] = 0
end
end
spawn_tile()
spawn_tile()
end

189
games/lua_examples/air_hockey.lua Normal file
View File

@@ -0,0 +1,189 @@
-- NAME: Air Hockey
-- DESC: Fast-paced 2-player hockey
-- Game states
local STATE_MENU = 0
local STATE_PLAYING = 1
local STATE_GAME_OVER = 2
-- Game constants
local PADDLE_WIDTH = 6
local PADDLE_HEIGHT = 35
local PUCK_RADIUS = 3
local MAX_SCORE = 7
local PUCK_SPEED = 4
function init()
game.vars.state = STATE_MENU
-- Left paddle (player 1)
game.vars.paddle_left_y = (game.height() / 2) - (PADDLE_HEIGHT / 2)
game.vars.paddle_left_score = 0
-- Right paddle (player 2)
game.vars.paddle_right_y = (game.height() / 2) - (PADDLE_HEIGHT / 2)
game.vars.paddle_right_score = 0
-- Puck
game.vars.puck_x = game.width() / 2
game.vars.puck_y = game.height() / 2
game.vars.puck_vel_x = PUCK_SPEED
game.vars.puck_vel_y = 1
-- Enable continuous updates
game.set_frame_updates(true)
print("Air Hockey initialized")
end
function update(event)
local state = game.vars.state
if state == STATE_MENU then
if event.type == INPUT.TOUCH_DOWN or event.type == INPUT.BUTTON_0 or event.type == INPUT.BUTTON_1 then
reset_game()
game.vars.state = STATE_PLAYING
return true
end
elseif state == STATE_PLAYING then
-- Handle paddle input via touch
if event.type == INPUT.TOUCH_DOWN or event.type == INPUT.TOUCH_MOVE then
if event.x < game.width() / 2 then
-- Left paddle
game.vars.paddle_left_y = math.max(0, math.min(game.height() - PADDLE_HEIGHT, event.y - PADDLE_HEIGHT / 2))
else
-- Right paddle
game.vars.paddle_right_y = math.max(0, math.min(game.height() - PADDLE_HEIGHT, event.y - PADDLE_HEIGHT / 2))
end
end
-- Update physics on frame tick
if event.type == INPUT.FRAME_TICK then
update_puck()
check_collisions()
-- Check win
if game.vars.paddle_left_score >= MAX_SCORE or game.vars.paddle_right_score >= MAX_SCORE then
game.vars.state = STATE_GAME_OVER
end
return true
end
elseif state == STATE_GAME_OVER then
if event.type == INPUT.TOUCH_DOWN or event.type == INPUT.BUTTON_0 or event.type == INPUT.BUTTON_1 then
game.vars.state = STATE_MENU
return true
end
end
return false
end
function draw()
renderer.clear(false) -- Black background
local state = game.vars.state
if state == STATE_MENU then
renderer.text(game.width() / 2 - 35, game.height() / 2 - 30, "AIR HOCKEY", true)
renderer.text(game.width() / 2 - 50, game.height() / 2, "Tap to Start", true)
renderer.text(game.width() / 2 - 60, game.height() / 2 + 20, "First to " .. tostring(MAX_SCORE), true)
elseif state == STATE_PLAYING or state == STATE_GAME_OVER then
-- Draw center line
for y = 0, game.height(), 4 do
renderer.pixel(game.width() / 2, y, true)
end
-- Draw goal areas (top/bottom highlights)
renderer.line(0, 5, game.width(), 5, true, 1)
renderer.line(0, game.height() - 5, game.width(), game.height() - 5, true, 1)
-- Draw paddles
renderer.rect(5, game.vars.paddle_left_y, PADDLE_WIDTH, PADDLE_HEIGHT, true, true)
renderer.rect(game.width() - 5 - PADDLE_WIDTH, game.vars.paddle_right_y, PADDLE_WIDTH, PADDLE_HEIGHT, true, true)
-- Draw puck
renderer.circle(game.vars.puck_x, game.vars.puck_y, PUCK_RADIUS, true, true)
-- Draw scores
renderer.text(game.width() / 2 - 30, 5, tostring(game.vars.paddle_left_score), true)
renderer.text(game.width() / 2 + 20, 5, tostring(game.vars.paddle_right_score), true)
if state == STATE_GAME_OVER then
local winner = game.vars.paddle_left_score > game.vars.paddle_right_score and "Player 1" or "Player 2"
renderer.text(game.width() / 2 - 50, game.height() / 2 - 20, "GAME OVER", true)
renderer.text(game.width() / 2 - 40, game.height() / 2, winner .. " Wins!", true)
renderer.text(game.width() / 2 - 60, game.height() / 2 + 20, "Tap to Menu", true)
end
end
end
function update_puck()
-- Move puck
game.vars.puck_x = game.vars.puck_x + game.vars.puck_vel_x
game.vars.puck_y = game.vars.puck_y + game.vars.puck_vel_y
-- Bounce off top/bottom
if game.vars.puck_y - PUCK_RADIUS < 0 or game.vars.puck_y + PUCK_RADIUS > game.height() then
game.vars.puck_vel_y = -game.vars.puck_vel_y
game.vars.puck_y = math.max(PUCK_RADIUS, math.min(game.height() - PUCK_RADIUS, game.vars.puck_y))
end
-- Goal: left side
if game.vars.puck_x < 0 then
game.vars.paddle_right_score = game.vars.paddle_right_score + 1
reset_puck()
end
-- Goal: right side
if game.vars.puck_x > game.width() then
game.vars.paddle_left_score = game.vars.paddle_left_score + 1
reset_puck()
end
end
function check_collisions()
-- Left paddle collision
if game.vars.puck_x - PUCK_RADIUS < 5 + PADDLE_WIDTH then
if game.vars.puck_y > game.vars.paddle_left_y and game.vars.puck_y < game.vars.paddle_left_y + PADDLE_HEIGHT then
if game.vars.puck_vel_x < 0 then
game.vars.puck_vel_x = -game.vars.puck_vel_x + 0.5 -- Speed up slightly
-- Add spin
local hit_pos = (game.vars.puck_y - game.vars.paddle_left_y) / PADDLE_HEIGHT
game.vars.puck_vel_y = (hit_pos - 0.5) * 6
end
end
end
-- Right paddle collision
if game.vars.puck_x + PUCK_RADIUS > game.width() - 5 - PADDLE_WIDTH then
if game.vars.puck_y > game.vars.paddle_right_y and game.vars.puck_y < game.vars.paddle_right_y + PADDLE_HEIGHT then
if game.vars.puck_vel_x > 0 then
game.vars.puck_vel_x = -game.vars.puck_vel_x - 0.5 -- Speed up slightly
-- Add spin
local hit_pos = (game.vars.puck_y - game.vars.paddle_right_y) / PADDLE_HEIGHT
game.vars.puck_vel_y = (hit_pos - 0.5) * 6
end
end
end
end
function reset_puck()
game.vars.puck_x = game.width() / 2
game.vars.puck_y = game.height() / 2
game.vars.puck_vel_x = PUCK_SPEED * (math.random() > 0.5 and 1 or -1)
game.vars.puck_vel_y = (math.random() - 0.5) * 2
end
function reset_game()
game.vars.paddle_left_y = (game.height() / 2) - (PADDLE_HEIGHT / 2)
game.vars.paddle_left_score = 0
game.vars.paddle_right_y = (game.height() / 2) - (PADDLE_HEIGHT / 2)
game.vars.paddle_right_score = 0
reset_puck()
end

173
games/lua_examples/lunar_lander.lua Normal file
View File

@@ -0,0 +1,173 @@
-- NAME: Lunar Lander
-- DESC: Land safely with limited fuel
-- Game states
local STATE_MENU = 0
local STATE_PLAYING = 1
local STATE_LANDED = 2
local STATE_CRASHED = 3
-- Game constants
local GRAVITY = 0.15
local THRUST_POWER = 0.3
local MAX_FUEL = 100
local SAFE_LANDING_SPEED = 1.5
function init()
game.vars.state = STATE_MENU
game.vars.score = 0
-- Lander
game.vars.lander_x = game.width() / 2
game.vars.lander_y = 10
game.vars.lander_vel_y = 0
game.vars.fuel = MAX_FUEL
game.vars.thrusting = false
-- Terrain
game.vars.landing_zone_x = game.width() / 2 - 20
game.vars.landing_zone_w = 40
game.vars.terrain_y = game.height() - 15
-- Enable continuous updates
game.set_frame_updates(true)
print("Lunar Lander initialized")
end
function update(event)
local state = game.vars.state
if state == STATE_MENU then
if event.type == INPUT.TOUCH_DOWN or event.type == INPUT.BUTTON_0 or event.type == INPUT.BUTTON_1 then
reset_game()
game.vars.state = STATE_PLAYING
return true
end
elseif state == STATE_PLAYING then
-- Handle thrust input
if event.type == INPUT.TOUCH_DOWN or event.type == INPUT.TOUCH_MOVE then
if game.vars.fuel > 0 then
game.vars.thrusting = true
game.vars.fuel = game.vars.fuel - 1
else
game.vars.thrusting = false
end
else
game.vars.thrusting = false
end
-- Update physics on frame tick
if event.type == INPUT.FRAME_TICK then
update_lander()
check_landing()
return true
end
elseif state == STATE_LANDED or state == STATE_CRASHED then
if event.type == INPUT.TOUCH_DOWN or event.type == INPUT.BUTTON_0 or event.type == INPUT.BUTTON_1 then
game.vars.state = STATE_MENU
return true
end
end
return false
end
function draw()
renderer.clear(false)
local state = game.vars.state
if state == STATE_MENU then
renderer.text(game.width() / 2 - 50, game.height() / 2 - 30, "LUNAR LANDER", true)
renderer.text(game.width() / 2 - 70, game.height() / 2 - 5, "Land in the zone safely", true)
renderer.text(game.width() / 2 - 50, game.height() / 2 + 20, "Tap to Start", true)
elseif state == STATE_PLAYING or state == STATE_LANDED or state == STATE_CRASHED then
-- Draw terrain
renderer.rect(0, game.vars.terrain_y, game.width(), game.height() - game.vars.terrain_y, true, true)
-- Draw landing zone (outline)
renderer.rect(game.vars.landing_zone_x, game.vars.terrain_y - 2, game.vars.landing_zone_w, 2, true, true)
-- Draw lander (triangle)
local lander_w = 8
local lander_h = 6
renderer.line(game.vars.lander_x - lander_w / 2, game.vars.lander_y + lander_h,
game.vars.lander_x, game.vars.lander_y, true, 1)
renderer.line(game.vars.lander_x, game.vars.lander_y,
game.vars.lander_x + lander_w / 2, game.vars.lander_y + lander_h, true, 1)
renderer.line(game.vars.lander_x - lander_w / 2, game.vars.lander_y + lander_h,
game.vars.lander_x + lander_w / 2, game.vars.lander_y + lander_h, true, 1)
-- Draw thrust flame
if game.vars.thrusting then
renderer.line(game.vars.lander_x - 2, game.vars.lander_y + lander_h,
game.vars.lander_x - 1, game.vars.lander_y + lander_h + 3, true, 1)
renderer.line(game.vars.lander_x + 2, game.vars.lander_y + lander_h,
game.vars.lander_x + 1, game.vars.lander_y + lander_h + 3, true, 1)
end
-- Draw stats
renderer.text(5, 5, "Fuel: " .. tostring(math.floor(game.vars.fuel)), true)
renderer.text(5, 15, "Speed: " .. tostring(math.floor(game.vars.lander_vel_y * 10)), true)
if state == STATE_LANDED then
renderer.text(game.width() / 2 - 40, game.height() / 2 - 20, "LANDED!", true)
renderer.text(game.width() / 2 - 30, game.height() / 2, "Score: " .. tostring(game.vars.score), true)
renderer.text(game.width() / 2 - 60, game.height() / 2 + 20, "Tap to Menu", true)
end
if state == STATE_CRASHED then
renderer.text(game.width() / 2 - 40, game.height() / 2 - 20, "CRASHED!", true)
renderer.text(game.width() / 2 - 60, game.height() / 2 + 20, "Tap to Menu", true)
end
end
end
function update_lander()
-- Apply gravity
game.vars.lander_vel_y = game.vars.lander_vel_y + GRAVITY
-- Apply thrust
if game.vars.thrusting then
game.vars.lander_vel_y = game.vars.lander_vel_y - THRUST_POWER
end
-- Update position
game.vars.lander_y = game.vars.lander_y + game.vars.lander_vel_y
end
function check_landing()
-- Check if lander reached terrain
if game.vars.lander_y + 6 >= game.vars.terrain_y then
local lander_left = game.vars.lander_x - 4
local lander_right = game.vars.lander_x + 4
local zone_left = game.vars.landing_zone_x
local zone_right = game.vars.landing_zone_x + game.vars.landing_zone_w
-- Check if in landing zone
if lander_left >= zone_left and lander_right <= zone_right then
-- Check landing speed
if game.vars.lander_vel_y <= SAFE_LANDING_SPEED then
game.vars.state = STATE_LANDED
game.vars.score = 100 + math.floor(game.vars.fuel)
else
game.vars.state = STATE_CRASHED
end
else
game.vars.state = STATE_CRASHED
end
end
end
function reset_game()
game.vars.lander_x = game.width() / 2
game.vars.lander_y = 10
game.vars.lander_vel_y = 0
game.vars.fuel = MAX_FUEL
game.vars.thrusting = false
game.vars.score = 0
end

285
games/lua_examples/tic_tac_toe.lua Normal file
View File

@@ -0,0 +1,285 @@
-- NAME: Tic-Tac-Toe
-- DESC: Play vs AI opponent
-- Game states
local STATE_MENU = 0
local STATE_PLAYING = 1
local STATE_GAME_OVER = 2
-- Game constants
local GRID_SIZE = 3
local CELL_SIZE = 30
local CELL_SPACING = 2
function init()
game.vars.state = STATE_MENU
game.vars.grid = {}
game.vars.player = 1 -- 1 = X, 2 = O
game.vars.ai = 2
game.vars.game_over = false
game.vars.winner = 0 -- 0 = ongoing, 1 = player wins, 2 = ai wins, 3 = draw
-- Enable continuous updates
game.set_frame_updates(true)
print("Tic-Tac-Toe initialized")
end
function update(event)
local state = game.vars.state
if state == STATE_MENU then
if event.type == INPUT.TOUCH_DOWN or event.type == INPUT.BUTTON_0 or event.type == INPUT.BUTTON_1 then
reset_game()
game.vars.state = STATE_PLAYING
return true
end
elseif state == STATE_PLAYING then
if event.type == INPUT.TOUCH_DOWN then
local cell = get_cell_at(event.x, event.y)
if cell and game.vars.grid[cell] == 0 then
-- Player move
game.vars.grid[cell] = game.vars.player
-- Check win
local winner = check_winner()
if winner ~= 0 then
if winner == game.vars.player then
game.vars.winner = 1
else
game.vars.winner = 2
end
game.vars.state = STATE_GAME_OVER
return true
end
-- Check draw
if is_board_full() then
game.vars.winner = 3
game.vars.state = STATE_GAME_OVER
return true
end
-- AI move
local ai_move = find_best_move()
game.vars.grid[ai_move] = game.vars.ai
-- Check win
winner = check_winner()
if winner ~= 0 then
if winner == game.vars.ai then
game.vars.winner = 2
end
game.vars.state = STATE_GAME_OVER
return true
end
-- Check draw
if is_board_full() then
game.vars.winner = 3
game.vars.state = STATE_GAME_OVER
return true
end
return true
end
end
elseif state == STATE_GAME_OVER then
if event.type == INPUT.TOUCH_DOWN or event.type == INPUT.BUTTON_0 or event.type == INPUT.BUTTON_1 then
game.vars.state = STATE_MENU
return true
end
end
return false
end
function draw()
renderer.clear(false)
local state = game.vars.state
if state == STATE_MENU then
renderer.text(game.width() / 2 - 50, game.height() / 2 - 30, "TIC-TAC-TOE", true)
renderer.text(game.width() / 2 - 50, game.height() / 2, "Play vs AI", true)
renderer.text(game.width() / 2 - 50, game.height() / 2 + 20, "Tap to Start", true)
elseif state == STATE_PLAYING or state == STATE_GAME_OVER then
-- Draw grid
local start_x = (game.width() - (GRID_SIZE * (CELL_SIZE + CELL_SPACING))) / 2
local start_y = 30
for row = 0, GRID_SIZE - 1 do
for col = 0, GRID_SIZE - 1 do
local cell_idx = row * GRID_SIZE + col + 1
local cell_x = start_x + col * (CELL_SIZE + CELL_SPACING)
local cell_y = start_y + row * (CELL_SIZE + CELL_SPACING)
-- Draw cell
renderer.rect(cell_x, cell_y, CELL_SIZE, CELL_SIZE, true, false)
-- Draw X or O
local value = game.vars.grid[cell_idx]
if value == 1 then
-- Draw X
renderer.line(cell_x + 2, cell_y + 2, cell_x + CELL_SIZE - 2, cell_y + CELL_SIZE - 2, true, 1)
renderer.line(cell_x + CELL_SIZE - 2, cell_y + 2, cell_x + 2, cell_y + CELL_SIZE - 2, true, 1)
elseif value == 2 then
-- Draw O
renderer.circle(cell_x + CELL_SIZE / 2, cell_y + CELL_SIZE / 2, CELL_SIZE / 2 - 2, true, false)
end
end
end
if state == STATE_GAME_OVER then
if game.vars.winner == 1 then
renderer.text(game.width() / 2 - 30, 10, "YOU WIN!", true)
elseif game.vars.winner == 2 then
renderer.text(game.width() / 2 - 30, 10, "AI WINS!", true)
else
renderer.text(game.width() / 2 - 20, 10, "DRAW!", true)
end
renderer.text(game.width() / 2 - 60, game.height() - 15, "Tap to Menu", true)
end
end
end
function get_cell_at(x, y)
local start_x = (game.width() - (GRID_SIZE * (CELL_SIZE + CELL_SPACING))) / 2
local start_y = 30
for row = 0, GRID_SIZE - 1 do
for col = 0, GRID_SIZE - 1 do
local cell_x = start_x + col * (CELL_SIZE + CELL_SPACING)
local cell_y = start_y + row * (CELL_SIZE + CELL_SPACING)
if x >= cell_x and x < cell_x + CELL_SIZE and
y >= cell_y and y < cell_y + CELL_SIZE then
return row * GRID_SIZE + col + 1
end
end
end
return nil
end
function check_winner()
-- Check rows
for row = 0, GRID_SIZE - 1 do
local val = game.vars.grid[row * GRID_SIZE + 1]
if val ~= 0 then
local match = true
for col = 1, GRID_SIZE - 1 do
if game.vars.grid[row * GRID_SIZE + col + 1] ~= val then
match = false
break
end
end
if match then return val end
end
end
-- Check columns
for col = 0, GRID_SIZE - 1 do
local val = game.vars.grid[col + 1]
if val ~= 0 then
local match = true
for row = 1, GRID_SIZE - 1 do
if game.vars.grid[row * GRID_SIZE + col + 1] ~= val then
match = false
break
end
end
if match then return val end
end
end
-- Check diagonals
local val = game.vars.grid[1]
if val ~= 0 then
if game.vars.grid[5] == val and game.vars.grid[9] == val then
return val
end
end
val = game.vars.grid[3]
if val ~= 0 then
if game.vars.grid[5] == val and game.vars.grid[7] == val then
return val
end
end
return 0
end
function is_board_full()
for i = 1, 9 do
if game.vars.grid[i] == 0 then
return false
end
end
return true
end
function find_best_move()
local best_score = -1000
local best_move = nil
for i = 1, 9 do
if game.vars.grid[i] == 0 then
game.vars.grid[i] = game.vars.ai
local score = minimax(0, false)
game.vars.grid[i] = 0
if score > best_score then
best_score = score
best_move = i
end
end
end
return best_move or 5 -- Fallback to center
end
function minimax(depth, is_maximizing)
local winner = check_winner()
if winner == game.vars.ai then return 10 - depth end
if winner == game.vars.player then return depth - 10 end
if is_board_full() then return 0 end
if is_maximizing then
local best_score = -1000
for i = 1, 9 do
if game.vars.grid[i] == 0 then
game.vars.grid[i] = game.vars.ai
local score = minimax(depth + 1, false)
game.vars.grid[i] = 0
best_score = math.max(best_score, score)
end
end
return best_score
else
local best_score = 1000
for i = 1, 9 do
if game.vars.grid[i] == 0 then
game.vars.grid[i] = game.vars.player
local score = minimax(depth + 1, true)
game.vars.grid[i] = 0
best_score = math.min(best_score, score)
end
end
return best_score
end
end
function reset_game()
game.vars.grid = {}
for i = 1, 9 do
game.vars.grid[i] = 0
end
game.vars.winner = 0
end