BlockBlast AI

https://github.com/wojtek746/blockblast-ai
Admin
BlockBlast AI is an AI-powered solver for the BlockBlast puzzle game that uses intelligent...
Tokens:2,859
Snippets:19
Trust Score:4.9
Update:7 months ago
Show doc for...
Tokens:
Raw
### Simulate Block Blast Game State and Actions - Python

Source: https://context7.com/wojtek746/blockblast-ai/llms.txt

The GameSimulator class models an 8x8 block puzzle board, handling shape placement, line clearing, scoring, and generating valid game states. It provides methods to start a game, check its state, retrieve available shapes, get valid actions, place shapes, and obtain a state vector for AI training.

```python
from GameSimulator import GameSimulator
import numpy as np

# Initialize and start a new game
game = GameSimulator()
game.start(episode=0)  # episode number affects initial board fill ratio

# Check current game state
print(f"Score: {game.score}")
print(f"Combo: {game.combo}")
print(f"Board shape: {game.board.shape}")  # (8, 8) numpy bool array

# Get available shapes from shop (3 shapes, each 5x5 bool array)
for i, shape in enumerate(game.shop):
    print(f"Shop slot {i}: {np.sum(shape)} cells")

# Get all valid actions (action = shop_index * 64 + row * 8 + col)
valid_actions = game.get_all_valid_actions()
print(f"Valid moves: {len(valid_actions)}")

# Place a shape: returns (success, lines_cleared)
if valid_actions:
    action = valid_actions[0]
    shop_index = action // 64
    row = (action % 64) // 8
    col = action % 8
    success, lines_cleared = game.place_shape(shop_index, row, col)
    print(f"Placed shape {shop_index} at ({row}, {col}): {lines_cleared} lines cleared")

# Get state vector for neural network (171 features)
state = game.get_state()
print(f"State vector size: {len(state)}")

# Check if game is over
if game.is_game_over():
    print(f"Game over! Final score: {game.score}")
```

--------------------------------

### Brute Force Player Logic in Python

Source: https://context7.com/wojtek746/blockblast-ai/llms.txt

Implements a brute-force AI player that selects the best move based on heuristic board evaluation. It can run single games or multiple games in parallel for benchmarking. The 'best_action' function can be used to get a suggested move for a given game state.

```python
from brute_force import run, loop, best_action
from GameSimulator import GameSimulator

# Run single game with brute force AI
score, moves = run()
print(f"Final score: {score}, Total moves: {moves}")

# Run multiple games in parallel for benchmarking
loop()  # Runs 10 games across all CPU cores
# Output: Avg: 156.2, Avg Moves: 45.3, Max: 312, Min: 67, Std: 71.4, Time: 2.3

# Use best_action directly
game = GameSimulator()
game.start(0)
valid_actions = game.get_all_valid_actions()
action = best_action(game, valid_actions)
shop_index, row, col = action // 64, (action % 64) // 8, action % 8
print(f"Best move: shape {shop_index} at ({row}, {col})")
```

--------------------------------

### Evaluate Board States with Python

Source: https://context7.com/wojtek746/blockblast-ai/llms.txt

Uses heuristic functions from the 'plansza2' module to score board states. It considers cell occupancy, neighbor connectivity, and survivability. Inputs include the board state and shop configuration, outputting a predicted reward and survival status.

```python
from plansza2 import predicted_reward, penalty_for_losing, clear_lines, is_imposible_to_survive
import numpy as np

# Create sample board state
board = [[False] * 8 for _ in range(8)]
board[0][0] = True
board[0][1] = True

# Create sample shop (3 shapes, each 5x5)
shop = [
    [[True, True, False, False, False],
     [True, False, False, False, False],
     [False, False, False, False, False],
     [False, False, False, False, False],
     [False, False, False, False, False]],
    None,  # Empty slot
    None
]

# Evaluate board position
lines_cleared = 0
reward = predicted_reward(board, lines_cleared, shop)
print(f"Board evaluation: {reward}")
print(f"Penalty for losing: {penalty_for_losing}")  # -5000

# Check if position is survivable
is_dead = is_imposible_to_survive(board, shop)
print(f"Position survivable: {not is_dead}")
```

--------------------------------

### Android Game Interaction with Python

Source: https://context7.com/wojtek746/blockblast-ai/llms.txt

Provides functions to capture the Android game screen, parse the board and shop state, and execute moves. It utilizes ADB for screenshots and OpenCV for image processing. Outputs include parsed game state and executed touch/swipe gestures.

```python
from main import get_screenshot, board_to_bool_array, array_of_shape, move, tap, swipe
import cv2

# Capture screenshot from connected Android device
get_screenshot('screen.png')  # Requires ADB connection

# Parse game state from screenshot
screen = cv2.imread('screen.png')
board = board_to_bool_array(screen)  # 8x8 bool array
print(f"Filled cells: {sum(sum(row) for row in board)}")

# Parse shop shapes (returns 5x5 bool arrays or None)
shop = []
for i in range(3):
    shape = array_of_shape(screen, i)
    shop.append(shape)
    if shape:
        cells = sum(sum(row) for row in shape)
        print(f"Shop {i}: {cells} cells")

# Execute move on device (swipe shape to board position)
action = 0 * 64 + 3 * 8 + 4  # Shop 0, row 3, col 4
move(shop, action)

# Direct touch controls
tap(500, 500)  # Tap at coordinates
swipe(100, 100, 500, 500, duration_ms=300)  # Swipe gesture
```

--------------------------------

### Parallel Training System for Block Blast AI - Python

Source: https://context7.com/wojtek746/blockblast-ai/llms.txt

The PipelinedTrainer class facilitates multi-process training by running game simulations in parallel across CPU cores. It collects experience batches and performs policy updates, significantly speeding up training. The `train_ai` function orchestrates the full training loop.

```python
from train import PipelinedTrainer, train_ai
from GameAI import GameAI
from multiprocessing import cpu_count

# Initialize trainer with parallel workers
ai = GameAI()
num_workers = max(1, cpu_count() - 10)
trainer = PipelinedTrainer(ai, num_workers)
print(f"Using {num_workers} parallel workers")
print(f"Batch size: {trainer.batch_episodes} episodes")

# Start async simulation batch
futures = trainer.start_simulation_batch(episode_num=0)

# Collect results when ready
all_episodes, batch_scores = trainer.collect_simulation_results(futures)
print(f"Collected {len(all_episodes)} episodes")
print(f"Average score: {sum(batch_scores) / len(batch_scores):.1f}")

# Train on collected batch
trainer.train_on_batch(all_episodes)

# Full training loop (1M episodes)
trained_ai, training_scores = train_ai()

# Training outputs:
# - ai_training_state.pt: Epsilon, baseline scores, network weights
```

--------------------------------

### Human Player Interface with Pygame

Source: https://context7.com/wojtek746/blockblast-ai/llms.txt

A Pygame-based interface allowing manual play of the BlockBlast game. It displays AI move suggestions and game information like score and combo. User inputs include clicking to select shapes and place them, with R to restart and ESC to exit.

```python
from human_player import HumanPlayer

# Launch interactive game window
game = HumanPlayer()
game.run()

# Controls:
# - Click shop shape to select
# - Click board position to place
# - R key: Restart game
# - ESC: Exit

# AI suggestion shown in yellow overlay on board
# Game displays: score, combo, available moves count
```

--------------------------------

### Reinforcement Learning Agent for Block Blast - Python

Source: https://context7.com/wojtek746/blockblast-ai/llms.txt

The GameAI class implements a reinforcement learning agent using a policy network and epsilon-greedy exploration. It utilizes the REINFORCE algorithm with baseline subtraction for variance reduction and supports both single-episode learning and batch updates. It manages exploration, stores transitions, and updates the neural network.

```python
from GameAI import GameAI, PolicyNetwork
import torch

# Initialize AI agent with custom learning rate
ai = GameAI(learning_rate=0.0001, memory_file="ai_training_state.pt")

# Network architecture: 171 inputs -> 2048 hidden -> 192 outputs
# 192 outputs = 3 shop slots × 8 rows × 8 cols
print(f"Epsilon: {ai.epsilon}")
print(f"Device: {ai.device}")

# Get action from current state (with exploration)
state = game.get_state() # Assuming 'game' is an instance of GameSimulator
valid_actions = game.get_all_valid_actions()
action, log_prob = ai.act(state, valid_actions)

# Store transition for episode-based learning
# Note: 'reward' needs to be defined based on game outcome
reward = 0 # Placeholder for actual reward calculation
ai.episode_data.append((state, action, reward, valid_actions))

# Complete episode and update network
final_score = game.score
ai.finish_episode(final_score)

# Decay exploration rate
ai.update_epsilon()

# Save/load training state
ai.save_training_state()
ai.load_training_state()

# Batch update for parallel training
# Assuming 'game' and 'valid_actions' are available for demonstration
states = [game.get_state() for _ in range(10)]
actions = [valid_actions[0] for _ in range(10)]
advantages = [1.0 for _ in range(10)]
valid_actions_list = [valid_actions for _ in range(10)]
ai.batch_update(states, actions, advantages, valid_actions_list)
```

--------------------------------

### Digit Recognition CNN with PyTorch

Source: https://context7.com/wojtek746/blockblast-ai/llms.txt

A Convolutional Neural Network (NumberNet) implemented using PyTorch for recognizing digits from game board screenshots. It loads a pre-trained model ('number_net.pth') and can predict digits from image fragments. The script also includes instructions for training a new model.

```python
from learnNumberAI import NumberNet
import torch
from PIL import Image

# Load trained model
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = NumberNet().to(device)
model.load_state_dict(torch.load("number_net.pth", map_location=device))
model.eval()

# Predict digit from image fragment (56x57 pixels)
img = Image.open("cell_fragment.png")
tensor = model.transform(img).unsqueeze(0).to(device)

with torch.no_grad():
    outputs = model(tensor)
    _, predicted = torch.max(outputs, 1)
    digit = predicted.item()  # 0-9

print(f"Recognized digit: {digit}")

# Training new model
# Requires train/ and test/ folders with digit images organized by class
# python learnNumberAI.py  # Trains for 10 epochs, saves number_net.pth
```
Tokens:
Raw