Forem: Marcelo Martins

Dominoes Game ⚅

Marcelo Martins — Wed, 14 Jan 2026 10:14:32 +0000

import random

Create domino set

def create_dominoes():
return [(i, j) for i in range(7) for j in range(i, 7)]

Print domino nicely

def print_domino(d):
return f"[{d[0]}|{d[1]}]"

def print_hand(hand):
for i, d in enumerate(hand):
print(f"{i}: {print_domino(d)}")

def can_play(domino, left, right):
return domino[0] == left or domino[1] == left or \
domino[0] == right or domino[1] == right

def play_domino(domino, board, side):
left, right = board[0][0], board[-1][1]

a, b = domino
if side == "L":
    if b == left:
        board.insert(0, (a, b))
    else:
        board.insert(0, (b, a))
else:
    if a == right:
        board.append((a, b))
    else:
        board.append((b, a))

def pip_sum(hand):
return sum(a + b for a, b in hand)

def main():
dominoes = create_dominoes()
random.shuffle(dominoes)

player = dominoes[:7]
computer = dominoes[7:14]

# Find starting tile (highest double)
all_tiles = player + computer
doubles = [d for d in all_tiles if d[0] == d[1]]

if doubles:
    start = max(doubles)
else:
    start = max(all_tiles)

if start in player:
    turn = "player"
    player.remove(start)
else:
    turn = "computer"
    computer.remove(start)

board = [start]

print("Starting tile:", print_domino(start))

passes = 0

while True:
    print("\nBoard:", " ".join(print_domino(d) for d in board))
    left, right = board[0][0], board[-1][1]

    if turn == "player":
        print("\nYour hand:")
        print_hand(player)

        playable = [d for d in player if can_play(d, left, right)]
        if not playable:
            print("You pass.")
            passes += 1
            turn = "computer"
            continue

        passes = 0
        choice = int(input("Choose tile index: "))
        side = input("Play Left or Right? (L/R): ").upper()

        domino = player[choice]
        if not can_play(domino, left, right):
            print("Invalid move!")
            continue

        play_domino(domino, board, side)
        player.remove(domino)

        if not player:
            print("🎉 You win!")
            break

        turn = "computer"

    else:
        playable = [d for d in computer if can_play(d, left, right)]
        if not playable:
            print("\nComputer passes.")
            passes += 1
            turn = "player"
            continue

        passes = 0
        domino = random.choice(playable)

        if domino[0] == left or domino[1] == left:
            play_domino(domino, board, "L")
        else:
            play_domino(domino, board, "R")

        computer.remove(domino)
        print("\nComputer plays", print_domino(domino))

        if not computer:
            print("💻 Computer wins!")
            break

        turn = "player"

    if passes == 2:
        print("\nGame blocked!")
        ps, cs = pip_sum(player), pip_sum(computer)
        print("Your pips:", ps, "| Computer pips:", cs)
        if ps < cs:
            print("🎉 You win!")
        elif cs < ps:
            print("💻 Computer wins!")
        else:
            print("🤝 Draw!")
        break

if name == "main":
main()

Ninja Fruit 🥷 ⚔️ 🥥

Marcelo Martins — Mon, 24 Nov 2025 11:58:06 +0000

import pygame
import random
import math
import sys

pygame.init()

WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
clock = pygame.time.Clock()
font = pygame.font.Font(None, 40)

Colors

WHITE = (255, 255, 255)
RED = (200, 50, 50)
BLACK = (0, 0, 0)
YELLOW = (240, 230, 40)

Game data

fruits = []
score = 0
game_over = False

def spawn_fruit():
"""Create fruit objects."""
x = random.randint(100, WIDTH - 100)
y = HEIGHT + 50
speed_x = random.uniform(-3, 3)
speed_y = random.uniform(-10, -15)
fruit_type = random.choice(["fruit", "fruit", "fruit", "bomb"]) # bombs are rarer
fruits.append({
"x": x,
"y": y,
"vx": speed_x,
"vy": speed_y,
"type": fruit_type
})

def draw_fruit(f):
if f["type"] == "fruit":
pygame.draw.circle(screen, RED, (int(f["x"]), int(f["y"])), 25)
else:
pygame.draw.circle(screen, BLACK, (int(f["x"]), int(f["y"])), 25)
pygame.draw.circle(screen, YELLOW, (int(f["x"]), int(f["y"])), 10)

def update_fruit(f):
f["x"] += f["vx"]
f["y"] += f["vy"]
f["vy"] += 0.4 # gravity

def slice_check(f, mouse_path):
"""Check if mouse swiped across the fruit."""
if len(mouse_path) < 2:
return False

for i in range(len(mouse_path) - 1):
    x1, y1 = mouse_path[i]
    x2, y2 = mouse_path[i+1]
    dist = abs((x2-x1)*(f["y"]-y1) - (y2-y1)*(f["x"]-x1)) / (
        math.hypot(x2-x1, y2-y1) + 0.001
    )
    if dist < 30:  # slice width
        return True
return False

mouse_path = []

SPAWN_EVENT = pygame.USEREVENT + 1
pygame.time.set_timer(SPAWN_EVENT, 700)

while True:
screen.fill((30, 30, 30))
mouse_path = mouse_path[-15:] + [pygame.mouse.get_pos()] # trailing swipe path

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        pygame.quit()
        sys.exit()

    if game_over and event.type == pygame.MOUSEBUTTONDOWN:
        # restart game
        fruits = []
        score = 0
        game_over = False

    if event.type == SPAWN_EVENT and not game_over:
        spawn_fruit()

if not game_over:
    # Update & draw fruits
    for f in fruits[:]:
        update_fruit(f)
        draw_fruit(f)

        if slice_check(f, mouse_path):
            if f["type"] == "bomb":
                game_over = True
            else:
                score += 1
            fruits.remove(f)

        if f["y"] > HEIGHT + 100:
            fruits.remove(f)

    # Draw swipe trail
    if len(mouse_path) > 1:
        pygame.draw.lines(screen, WHITE, False, mouse_path, 2)

    # Score
    s_text = font.render(f"Score: {score}", True, WHITE)
    screen.blit(s_text, (10, 10))

else:
    over_text = font.render("GAME OVER - Click to restart", True, WHITE)
    screen.blit(over_text, (200, HEIGHT // 2))

pygame.display.flip()
clock.tick(60)

Tic Tac Toe#️⃣❎0️⃣

Marcelo Martins — Wed, 22 Oct 2025 20:33:08 +0000

Tic Tac Toe game in Python

def print_board(board):
for row in board:
print(" | ".join(row))
print("-" * 9)

def check_winner(board, player):
# Check rows, columns, and diagonals
for row in board:
if all(s == player for s in row):
return True
for col in range(3):
if all(board[row][col] == player for row in range(3)):
return True
if all(board[i][i] == player for i in range(3)):
return True
if all(board[i][2 - i] == player for i in range(3)):
return True
return False

def is_full(board):
return all(all(cell != " " for cell in row) for row in board)

def tic_tac_toe():
board = [[" " for _ in range(3)] for _ in range(3)]
current_player = "X"

while True:

    print_board(board)

    print(f"Player {current_player}'s turn.")

# Ask for move
try:
    row = int(input("Enter row (0-2): "))
    col = int(input("Enter column (0-2): "))
except ValueError:
    print("Please enter a valid number!")
    continue

if row not in range(3) or col not in range(3):
    print("Invalid coordinates! Try again.")
    continue
if board[row][col] != " ":
    print("Cell already taken! Try again.")
    continue

board[row][col] = current_player

if check_winner(board, current_player):
    print_board(board)
    print(f"Player {current_player} wins!")
    break
if is_full(board):
    print_board(board)
    print("It's a tie!")
    break

# Switch player
current_player = "O" if current_player == "X" else "X"

Start the game

tic_tac_toe()

Ping Pong 🏓

Marcelo Martins — Fri, 10 Oct 2025 12:29:31 +0000

"""
Simple Ping Pong (Pong) game in Python using pygame

Controls:

Left paddle: W (up), S (down)
Right paddle: Up Arrow, Down Arrow
P to pause, R to reset scores
Escape or close window to quit

Requirements:

Python 3.8+
pygame (pip install pygame)

Run:
python pong_game.py

This is a single-file, self-contained implementation with basic sound effects (requires SDL mixer
support available in pygame). It uses simple collision, scoring, and gradual speed increase.
"""

import pygame
import sys
import random

---- Configuration ----

WIDTH, HEIGHT = 900, 600
FPS = 60
PADDLE_WIDTH, PADDLE_HEIGHT = 10, 100
BALL_SIZE = 16
PADDLE_SPEED = 6
BALL_START_SPEED = 5
SCORE_FONT_SIZE = 48
WINNING_SCORE = 10

Colors

WHITE = (255, 255, 255)
BLACK = (0, 0, 0)

---- Classes ----

class Paddle:
def init(self, x, y):
self.rect = pygame.Rect(x, y, PADDLE_WIDTH, PADDLE_HEIGHT)
self.speed = 0

def move(self, dy):
    self.speed = dy
    self.rect.y += dy
    # clamp
    if self.rect.top < 0:
        self.rect.top = 0
    if self.rect.bottom > HEIGHT:
        self.rect.bottom = HEIGHT

def update(self):
    self.move(self.speed)

def draw(self, surface):
    pygame.draw.rect(surface, WHITE, self.rect)

class Ball:
def init(self):
self.rect = pygame.Rect((WIDTH // 2) - BALL_SIZE // 2,
(HEIGHT // 2) - BALL_SIZE // 2,
BALL_SIZE, BALL_SIZE)
self.reset()

def reset(self, serveto=None):
    self.rect.center = (WIDTH // 2, HEIGHT // 2)
    angle = random.uniform(-0.4, 0.4)  # slight vertical angle
    direction = random.choice([-1, 1]) if serveto is None else serveto
    self.speed = BALL_START_SPEED
    self.vx = direction * self.speed * (1 - abs(angle))
    self.vy = self.speed * angle

def update(self, left_paddle, right_paddle):
    self.rect.x += int(self.vx)
    self.rect.y += int(self.vy)

    # Top/bottom collision
    if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
        self.vy = -self.vy
        play_sound('wall')

    # Paddle collisions
    if self.rect.colliderect(left_paddle.rect) and self.vx < 0:
        self._bounce(left_paddle)
        play_sound('paddle')

    if self.rect.colliderect(right_paddle.rect) and self.vx > 0:
        self._bounce(right_paddle)
        play_sound('paddle')

def _bounce(self, paddle):
    # Determine hit position on paddle: -1 (top) .. 0 center .. 1 bottom
    rel = (self.rect.centery - paddle.rect.centery) / (paddle.rect.height / 2)
    rel = max(-1, min(1, rel))
    # Increase speed slightly each hit
    self.speed *= 1.05
    # New velocities
    self.vx = -self.vx / abs(self.vx) * self.speed * (1 - 0.5 * abs(rel))
    self.vy = self.speed * rel

def draw(self, surface):
    pygame.draw.ellipse(surface, WHITE, self.rect)

---- Sound helper ----

SOUNDS = {}

def load_sounds():
try:
SOUNDS['paddle'] = pygame.mixer.Sound(pygame.mixer.Sound.get_length)
except Exception:
# If loading real files isn't desired, we'll skip. Sound optional.
pass

def play_sound(name):
# Keep non-fatal: if sound present, play it. We intentionally keep this minimal.
s = SOUNDS.get(name)
if s:
try:
s.play()
except Exception:
pass

---- Main Game ----

def draw_center_line(surface):
for y in range(0, HEIGHT, 20):
pygame.draw.rect(surface, WHITE, (WIDTH // 2 - 1, y, 2, 12))

def main():
pygame.init()
try:
pygame.mixer.init()
except Exception:
pass

screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('Ping Pong - Python (pygame)')
clock = pygame.time.Clock()

# Score
score_left = 0
score_right = 0

# Entities
left_paddle = Paddle(30, (HEIGHT - PADDLE_HEIGHT) // 2)
right_paddle = Paddle(WIDTH - 30 - PADDLE_WIDTH, (HEIGHT - PADDLE_HEIGHT) // 2)
ball = Ball()

font = pygame.font.Font(None, SCORE_FONT_SIZE)
small_font = pygame.font.Font(None, 24)

paused = False

# Optional simple AI toggle (comment/uncomment to enable)
ai_enabled = False

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                pygame.quit()
                sys.exit()
            if event.key == pygame.K_p:
                paused = not paused
            if event.key == pygame.K_r:
                score_left = 0
                score_right = 0
                ball.reset()
            if event.key == pygame.K_a:
                ai_enabled = not ai_enabled

    # Input handling
    keys = pygame.key.get_pressed()
    left_speed = 0
    right_speed = 0
    if keys[pygame.K_w]:
        left_speed = -PADDLE_SPEED
    elif keys[pygame.K_s]:
        left_speed = PADDLE_SPEED

    if not ai_enabled:
        if keys[pygame.K_UP]:
            right_speed = -PADDLE_SPEED
        elif keys[pygame.K_DOWN]:
            right_speed = PADDLE_SPEED
    else:
        # Very simple AI: follow ball with some damping
        if ball.rect.centery < right_paddle.rect.centery - 10:
            right_speed = -PADDLE_SPEED
        elif ball.rect.centery > right_paddle.rect.centery + 10:
            right_speed = PADDLE_SPEED
        else:
            right_speed = 0

    if not paused:
        left_paddle.move(left_speed)
        right_paddle.move(right_speed)
        ball.update(left_paddle, right_paddle)

        # Check scoring
        if ball.rect.right < 0:
            score_right += 1
            ball.reset(serveto=1)
            play_sound('score')

        if ball.rect.left > WIDTH:
            score_left += 1
            ball.reset(serveto=-1)
            play_sound('score')

        # Win condition
        if score_left >= WINNING_SCORE or score_right >= WINNING_SCORE:
            paused = True

    # Draw
    screen.fill(BLACK)
    draw_center_line(screen)
    left_paddle.draw(screen)
    right_paddle.draw(screen)
    ball.draw(screen)

    # Scores
    left_surf = font.render(str(score_left), True, WHITE)
    right_surf = font.render(str(score_right), True, WHITE)
    screen.blit(left_surf, (WIDTH // 4 - left_surf.get_width() // 2, 20))
    screen.blit(right_surf, (WIDTH * 3 // 4 - right_surf.get_width() // 2, 20))

    # Hints
    hint = small_font.render("W/S: left  |  Up/Down: right  |  P: pause  |  R: reset  |  A: toggle AI", True, WHITE)
    screen.blit(hint, (WIDTH // 2 - hint.get_width() // 2, HEIGHT - 30))

    if paused:
        pause_surf = font.render("PAUSED" if not (score_left >= WINNING_SCORE or score_right >= WINNING_SCORE) else "GAME OVER", True, WHITE)
        screen.blit(pause_surf, (WIDTH // 2 - pause_surf.get_width() // 2, HEIGHT // 2 - pause_surf.get_height() // 2))
        if score_left >= WINNING_SCORE or score_right >= WINNING_SCORE:
            winner = 'Left' if score_left > score_right else 'Right'
            win_surf = small_font.render(f"{winner} player wins! Press R to restart.", True, WHITE)
            screen.blit(win_surf, (WIDTH // 2 - win_surf.get_width() // 2, HEIGHT // 2 + 40))

    pygame.display.flip()
    clock.tick(FPS)

if name == 'main':
main()

Sudoku

Marcelo Martins — Fri, 10 Oct 2025 12:27:34 +0000

import random

def print_grid(grid):
for i in range(9):
if i % 3 == 0 and i != 0:
print("-" * 21)
for j in range(9):
if j % 3 == 0 and j != 0:
print("|", end=" ")
print(grid[i][j] if grid[i][j] != 0 else ".", end=" ")
print()

def is_valid(grid, row, col, num):
# Check row
if num in grid[row]:
return False

# Check column
for i in range(9):
    if grid[i][col] == num:
        return False

# Check 3x3 square
start_row, start_col = row - row % 3, col - col % 3
for i in range(3):
    for j in range(3):
        if grid[start_row + i][start_col + j] == num:
            return False
return True

def solve(grid):
for row in range(9):
for col in range(9):
if grid[row][col] == 0:
for num in range(1, 10):
if is_valid(grid, row, col, num):
grid[row][col] = num
if solve(grid):
return True
grid[row][col] = 0
return False
return True

def generate_sudoku():
grid = [[0 for _ in range(9)] for _ in range(9)]
for _ in range(15): # Fill some numbers randomly
row, col = random.randint(0, 8), random.randint(0, 8)
num = random.randint(1, 9)
if is_valid(grid, row, col, num):
grid[row][col] = num
return grid

Game

grid = generate_sudoku()
print("Welcome to Sudoku!")
print_grid(grid)

while True:
try:
row = int(input("Row (0-8): "))
col = int(input("Col (0-8): "))
num = int(input("Number (1-9): "))

    if grid[row][col] == 0 and is_valid(grid, row, col, num):
        grid[row][col] = num
        print_grid(grid)
    else:
        print("Invalid move!")
except ValueError:
    print("Please enter valid integers.")

TETRIS TIME 👾

Marcelo Martins — Wed, 01 Oct 2025 11:17:50 +0000

"""
Simple Tetris implementation in Python using pygame.

Features:

Playable Tetris with 7 tetrominoes
Rotation, left/right, soft drop, hard drop
Line clearing and scoring
Next piece preview and hold

Controls:

Left/Right Arrow: move
Up Arrow or X: rotate clockwise
Z: rotate counter-clockwise
Down Arrow: soft drop
Space: hard drop
C: hold piece
P: pause
Esc / Q: quit

Requirements:

Python 3.8+
pygame (pip install pygame)

Save as tetris.py and run: python tetris.py
"""

import pygame
import random
import sys
from copy import deepcopy

---------- Configuration ----------

FPS = 60
CELL_SIZE = 30
COLS = 10
ROWS = 20
PLAY_WIDTH = COLS * CELL_SIZE
PLAY_HEIGHT = ROWS * CELL_SIZE
SIDE_PANEL = 200
WIDTH = PLAY_WIDTH + SIDE_PANEL + 40
HEIGHT = PLAY_HEIGHT + 40
TOP_LEFT_X = 20
TOP_LEFT_Y = 20

Colors

WHITE = (255, 255, 255)
GRAY = (128, 128, 128)
BLACK = (0, 0, 0)

SHAPE_COLORS = [
(0, 240, 240), # I - cyan
(0, 0, 240), # J - blue
(240, 160, 0), # L - orange
(240, 240, 0), # O - yellow
(0, 240, 0), # S - green
(160, 0, 240), # T - purple
(240, 0, 0), # Z - red
]

Tetromino shapes (4x4 grids represented by strings)

S = [['.....',
'.....',
'..00.',
'.00..',
'.....'],
['.....',
'..0..',
'..00.',
'...0.',
'.....']]

Z = [['.....',
'.....',
'.00..',
'..00.',
'.....'],
['.....',
'..0..',
'.00..',
'.0...',
'.....']]

I = [['..0..',
'..0..',
'..0..',
'..0..',
'.....'],
['.....',
'0000.',
'.....',
'.....',
'.....']]

O = [['.....',
'.....',
'.00..',
'.00..',
'.....']]

J = [['.....',
'.0...',
'.000.',
'.....',
'.....'],
['.....',
'..00.',
'..0..',
'..0..',
'.....'],
['.....',
'.....',
'.000.',
'...0.',
'.....'],
['.....',
'..0..',
'..0..',
'.00..',
'.....']]

L = [['.....',
'...0.',
'.000.',
'.....',
'.....'],
['.....',
'..0..',
'..0..',
'..00.',
'.....'],
['.....',
'.....',
'.000.',
'.0...',
'.....'],
['.....',
'.00..',
'..0..',
'..0..',
'.....']]

T = [['.....',
'..0..',
'.000.',
'.....',
'.....'],
['.....',
'..0..',
'..00.',
'..0..',
'.....'],
['.....',
'.....',
'.000.',
'..0..',
'.....'],
['.....',
'..0..',
'.00..',
'..0..',
'.....']]

SHAPES = [S, Z, I, O, J, L, T]
SHAPE_NAMES = ['S', 'Z', 'I', 'O', 'J', 'L', 'T']

---------- Game Logic ----------

class Piece:
def init(self, x, y, shape_index):
self.x = x
self.y = y
self.shape_index = shape_index
self.shape = SHAPES[shape_index]
self.rotation = 0

def image(self):
    return self.shape[self.rotation % len(self.shape)]

def get_cells(self):
    """Return list of (x,y) cells occupied by this piece relative to grid."""
    positions = []
    format = self.image()
    for i, line in enumerate(format):
        row = list(line)
        for j, column in enumerate(row):
            if column == '0':
                positions.append((self.x + j - 2, self.y + i - 4))
    return positions

def create_grid(locked_positions={}):
grid = [[BLACK for _ in range(COLS)] for _ in range(ROWS)]

for i in range(ROWS):
    for j in range(COLS):
        if (j, i) in locked_positions:
            grid[i][j] = locked_positions[(j, i)]
return grid

def valid_space(piece, grid):
accepted_positions = [[(j, i) for j in range(COLS) if grid[i][j] == BLACK] for i in range(ROWS)]
accepted = [pos for row in accepted_positions for pos in row]

for pos in piece.get_cells():
    x, y = pos
    if x < 0 or x >= COLS or y >= ROWS:
        return False
    if y >= 0 and (x, y) not in accepted:
        return False
return True

def check_lost(positions):
for pos in positions:
x, y = pos
if y < 0:
return True
return False

def get_shape():
index = random.randrange(len(SHAPES))
return Piece(COLS // 2 - 2, -2, index)

def convert_shape_format(piece):
positions = []
format = piece.image()

for i, line in enumerate(format):
    row = list(line)
    for j, column in enumerate(row):
        if column == '0':
            positions.append((piece.x + j - 2, piece.y + i - 4))

return positions

def clear_rows(grid, locked):
"""Check for full rows and clear them. Return number of cleared rows."""
inc = 0
for i in range(ROWS - 1, -1, -1):
row = grid[i]
if BLACK not in row:
inc += 1
# remove from locked
for j in range(COLS):
try:
del locked[(j, i)]
except:
continue

if inc > 0:
    # shift every row above down
    new_locked = {}
    for (x, y), color in sorted(locked.items(), key=lambda x: x[0][1]):
        shift = 0
        for _ in range(inc):
            if y < ROWS and True:
                shift += 1
        new_locked[(x, y + inc)] = color
    locked.clear()
    locked.update(new_locked)
return inc

---------- Drawing Helpers ----------

def draw_text_middle(surface, text, size, y_offset=0):
font = pygame.font.SysFont('comicsans', size, bold=True)
label = font.render(text, 1, WHITE)

surface.blit(label, (TOP_LEFT_X + PLAY_WIDTH/2 - (label.get_width()/2), TOP_LEFT_Y + PLAY_HEIGHT/2 - label.get_height()/2 + y_offset))

def draw_grid(surface, grid):
sx = TOP_LEFT_X
sy = TOP_LEFT_Y
for i in range(ROWS):
pygame.draw.line(surface, GRAY, (sx, sy + i * CELL_SIZE), (sx + PLAY_WIDTH, sy + i * CELL_SIZE))
for j in range(COLS):
pygame.draw.line(surface, GRAY, (sx + j * CELL_SIZE, sy), (sx + j * CELL_SIZE, sy + PLAY_HEIGHT))

def draw_window(surface, grid, score=0, level=1):
surface.fill(BLACK)

# Title
font = pygame.font.SysFont('comicsans', 40)
label = font.render('TETRIS', 1, WHITE)

surface.blit(label, (TOP_LEFT_X + PLAY_WIDTH/2 - label.get_width()/2, 5))

# Score
font_small = pygame.font.SysFont('comicsans', 24)
score_label = font_small.render(f'Score: {score}', 1, WHITE)
level_label = font_small.render(f'Level: {level}', 1, WHITE)
surface.blit(score_label, (TOP_LEFT_X + PLAY_WIDTH + 20, TOP_LEFT_Y + 50))
surface.blit(level_label, (TOP_LEFT_X + PLAY_WIDTH + 20, TOP_LEFT_Y + 90))

# draw play area
sx = TOP_LEFT_X
sy = TOP_LEFT_Y

for i in range(ROWS):
    for j in range(COLS):
        pygame.draw.rect(surface, grid[i][j], (sx + j * CELL_SIZE, sy + i * CELL_SIZE, CELL_SIZE, CELL_SIZE), 0)

# draw grid lines
draw_grid(surface, grid)

# border
pygame.draw.rect(surface, WHITE, (sx, sy, PLAY_WIDTH, PLAY_HEIGHT), 4)

def draw_next_shape(surface, shape):
font = pygame.font.SysFont('comicsans', 24)
label = font.render('Next', 1, WHITE)
surface.blit(label, (TOP_LEFT_X + PLAY_WIDTH + 20, TOP_LEFT_Y + 140))

format = shape.image()
sx = TOP_LEFT_X + PLAY_WIDTH + 50
sy = TOP_LEFT_Y + 170

for i, line in enumerate(format):
    row = list(line)
    for j, column in enumerate(row):
        if column == '0':
            pygame.draw.rect(surface, SHAPE_COLORS[shape.shape_index], (sx + j * CELL_SIZE, sy + i * CELL_SIZE, CELL_SIZE, CELL_SIZE), 0)

def draw_hold_shape(surface, shape):
font = pygame.font.SysFont('comicsans', 24)
label = font.render('Hold', 1, WHITE)
surface.blit(label, (TOP_LEFT_X + PLAY_WIDTH + 20, TOP_LEFT_Y + 260))

if not shape:
    return

format = shape.image()
sx = TOP_LEFT_X + PLAY_WIDTH + 50
sy = TOP_LEFT_Y + 300

for i, line in enumerate(format):
    row = list(line)
    for j, column in enumerate(row):
        if column == '0':
            pygame.draw.rect(surface, SHAPE_COLORS[shape.shape_index], (sx + j * CELL_SIZE, sy + i * CELL_SIZE, CELL_SIZE, CELL_SIZE), 0)

---------- Main Game Loop ----------

def main():
pygame.init()
win = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('Tetris')
clock = pygame.time.Clock()

locked_positions = {}
grid = create_grid(locked_positions)

change_piece = False
run = True
current_piece = get_shape()
next_piece = get_shape()
hold_piece = None
hold_locked = False

fall_time = 0
fall_speed = 0.5  # seconds per cell fall
level = 1
score = 0
lines_cleared_total = 0

while run:
    grid = create_grid(locked_positions)
    dt = clock.tick(FPS) / 1000.0
    fall_time += dt

    # handle fall speed acceleration by level
    if lines_cleared_total >= level * 10:
        level += 1
        fall_speed = max(0.05, fall_speed * 0.9)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            run = False
            pygame.quit()
            sys.exit()

        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE or event.key == pygame.K_q:
                run = False
                pygame.quit()
                sys.exit()

            if event.key == pygame.K_LEFT:
                current_piece.x -= 1
                if not valid_space(current_piece, grid):
                    current_piece.x += 1

            elif event.key == pygame.K_RIGHT:
                current_piece.x += 1
                if not valid_space(current_piece, grid):
                    current_piece.x -= 1

            elif event.key == pygame.K_DOWN:
                current_piece.y += 1
                if not valid_space(current_piece, grid):
                    current_piece.y -= 1

            elif event.key == pygame.K_UP or event.key == pygame.K_x:
                current_piece.rotation = (current_piece.rotation + 1) % len(current_piece.shape)
                if not valid_space(current_piece, grid):
                    current_piece.rotation = (current_piece.rotation - 1) % len(current_piece.shape)

            elif event.key == pygame.K_z:
                current_piece.rotation = (current_piece.rotation - 1) % len(current_piece.shape)
                if not valid_space(current_piece, grid):
                    current_piece.rotation = (current_piece.rotation + 1) % len(current_piece.shape)

            elif event.key == pygame.K_SPACE:
                # hard drop
                while valid_space(current_piece, grid):
                    current_piece.y += 1
                current_piece.y -= 1
                change_piece = True

            elif event.key == pygame.K_c:
                if not hold_locked:
                    if hold_piece is None:
                        hold_piece = Piece(COLS//2 - 2, -2, current_piece.shape_index)
                        current_piece = next_piece
                        next_piece = get_shape()
                    else:
                        temp = Piece(COLS//2 - 2, -2, current_piece.shape_index)
                        current_piece = Piece(COLS//2 - 2, -2, hold_piece.shape_index)
                        hold_piece = Piece(COLS//2 - 2, -2, temp.shape_index)
                    hold_locked = True

            elif event.key == pygame.K_p:
                paused = True
                while paused:
                    for e in pygame.event.get():
                        if e.type == pygame.QUIT:
                            pygame.quit()
                            sys.exit()
                        if e.type == pygame.KEYDOWN and e.key == pygame.K_p:
                            paused = False

    # automatic piece fall
    if fall_time >= fall_speed:
        fall_time = 0
        current_piece.y += 1
        if not valid_space(current_piece, grid):
            current_piece.y -= 1
            change_piece = True

    shape_pos = convert_shape_format(current_piece)

    # add piece to the grid for drawing
    for i in range(len(shape_pos)):
        x, y = shape_pos[i]
        if y >= 0:
            grid[y][x] = SHAPE_COLORS[current_piece.shape_index]

    # when piece lands
    if change_piece:
        for pos in shape_pos:
            p = (pos[0], pos[1])
            locked_positions[p] = SHAPE_COLORS[current_piece.shape_index]
        current_piece = next_piece
        next_piece = get_shape()
        change_piece = False
        hold_locked = False

        # clear rows
        cleared = clear_rows(grid, locked_positions)
        if cleared > 0:
            lines_cleared_total += cleared
            # scoring (classic-ish)
            if cleared == 1:
                score += 40 * level
            elif cleared == 2:
                score += 100 * level
            elif cleared == 3:
                score += 300 * level
            elif cleared >= 4:
                score += 1200 * level

    draw_window(win, grid, score, level)
    draw_next_shape(win, next_piece)
    draw_hold_shape(win, hold_piece)

    if check_lost(list(locked_positions.keys())):
        draw_text_middle(win, 'GAME OVER', 50)
        pygame.display.update()
        pygame.time.delay(1500)
        run = False

    pygame.display.update()

pygame.quit()

if name == 'main':
main()

"""
runnable Python file named tetris.py in a code canvas. It uses pygame and includes:

All 7 tetrominoes with rotation and collision handling

Left / right movement, soft drop, hard drop, rotate (CW/CCW)

Hold piece, next-piece preview, scoring, levels, and game-over detection

Pause, quit, and simple UI

How to run:

Install pygame if you don't have it: pip install pygame

Save the canvas file as tetris.py (it's already created in the code canvas) and run:
python tetris.py

Controls recap:

Left / Right arrows: move

Down arrow: soft drop

Space: hard drop

Up arrow or X: rotate clockwise

Z: rotate counter-clockwise

C: hold piece

P: pause

Esc or Q: quit
"""

Snake Game 🐍

Marcelo Martins — Thu, 18 Sep 2025 16:42:58 +0000

before running the game please do install dependencies in requirements.txt file

import os
import sys

Use psycopg2 only (simpler for beginners)

try:
import psycopg2 as pg
except ImportError:
print("Missing dependency: psycopg2-binary")
print("Please run: pip install psycopg2-binary")
sys.exit(1)

DB_PARAMS = {
'dbname': os.getenv('PGDATABASE', 'postgres'),
'user': os.getenv('PGUSER', 'postgres'),
'password': os.getenv('PGPASSWORD', 'postgres'),
'host': os.getenv('PGHOST', 'localhost'),
'port': int(os.getenv('PGPORT', '5432')),
}

def connect():
return pg.connect(**DB_PARAMS)

def init_game(rows=10, cols=20):
with connect() as conn, conn.cursor() as cur:
cur.execute("SELECT init_game(%s,%s)", (rows, cols))
gid = cur.fetchone()[0]
return gid

def get_board(gid):
with connect() as conn, conn.cursor() as cur:
cur.execute("SELECT get_board(%s)", (gid,))
return cur.fetchone()[0]

def step(gid, direction):
with connect() as conn, conn.cursor() as cur:
cur.execute("SELECT step(%s,%s)::text", (gid, direction))
return cur.fetchone()[0]

KEY_TO_DIR = {
'w': 'U',
's': 'D',
'a': 'L',
'd': 'R',
}

def read_key():
"""Read a single keypress from stdin (Linux/Mac)."""
import termios, tty
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(fd)
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch

def main():
print("Starting new SQL Snake game...")
gid = init_game(10, 20)
print(f"Game id: {gid}\n")

current_dir = 'R'

while True:
    os.system('clear')
    print(get_board(gid))
    print("Use WASD keys to move, q to quit.")

    ch = read_key()
    if ch == 'q':
        print("Quitting.")
        break
    if ch in KEY_TO_DIR:
        current_dir = KEY_TO_DIR[ch]

    status = step(gid, current_dir)
    if 'dead' in status:
        os.system('clear')
        print(get_board(gid))
        print("Game over! Final status:", status)
        break

if name == "main":
main()

Rock 🗿 Paper 🗞️ Scissors ✂️

Marcelo Martins — Mon, 15 Sep 2025 09:51:35 +0000

Rock 🗿 Paper 🗞️ Scissors ✂️ - the classic hand game where:

Rock beats Scissors (crushes them)
Scissors beat Paper (cut it)
Paper beats Rock (wraps it)

enhanced version of Rock–Paper–Scissors in Python where you can play multiple rounds, keep score, and even choose when to quit:

import random

Choices available

choices = ["rock", "paper", "scissors"]

Function to determine the winner

def determine_winner(user_choice, computer_choice):
if user_choice == computer_choice:
return "tie"
elif (user_choice == "rock" and computer_choice == "scissors") or \
(user_choice == "scissors" and computer_choice == "paper") or \
(user_choice == "paper" and computer_choice == "rock"):
return "user"
else:
return "computer"

Main game loop

def play_game():
user_score = 0
computer_score = 0
round_number = 1

print("Welcome to Rock-Paper-Scissors!")

print("Type 'quit' to exit the game anytime.\n")

while True:

    print(f"--- Round {round_number} ---")

    user_choice = input("Enter rock, paper, or scissors: ").lower()

if user_choice == "quit":
    break

if user_choice not in choices:
    print("Invalid choice. Try again.\n")
    continue

computer_choice = random.choice(choices)
print(f"Computer chose: {computer_choice}")

winner = determine_winner(user_choice, computer_choice)
if winner == "user":
    print("You win this round!\n")
    user_score += 1
elif winner == "computer":
    print("Computer wins this round!\n")
    computer_score += 1
else:
    print("This round is a tie!\n")

print(f"Score -&gt; You: {user_score} | Computer: {computer_score}\n")
round_number += 1



print("Thanks for playing!")

print(f"Final Score -> You: {user_score} | Computer: {computer_score}")

if user_score > computer_score:

    print("You won the game! 🎉")

elif user_score < computer_score:

    print("Computer won the game! 🤖")

else:

    print("It's a tie overall!")

Start the game

play_game()

✅ Features:

Multiple rounds until the user quits.
Keeps track of your score and the computer’s score.
Declares the overall winner at the end.

SQL PUZZLE GAME

Marcelo Martins — Wed, 10 Sep 2025 13:41:54 +0000

DataBricks SQL experience for measuring 4L of water with 2 bukcets one with 5L capacity and other with 3L capacity

-- Possible Tables
CREATE TABLE Buckets (
step INT PRIMARY KEY,
action VARCHAR(50),
bucket5 INT,
bucket3 INT
);

-- method
INSERT INTO Bucket VALUES
(1, 'Fill 5L' , 5, 0),
(2, 'Transfer 5L to 3L', 2, 3),
(3, 'Empty 3L' , 2, 0),
(4, 'Transfer 2L to 3L', 0, 2),
(5, 'Fill 5L' , 5, 2),
(6, 'Transfer 5L to 3L', 4, 3);

-- consult final solution (4 l on the bucket of 5L)
SELECT *
FROM Buckets
WHERE bucket5 = 4;