So after yesterday's post I figured now might be as good a time as any to jump back into the coding game. It's been quite a long time since I've had the opportunity to worth with Python to I started there.
We can see here that this development toolkit isn't exactly anything to write home about, but as far as novice games are concerned it suits the purpose just fine. In fact some of these games like Flappy Bird make $18M a year just from advertising revenue (which is $50k/day for the single dev that created it). Not exactly chump change. It's only a matter of time before someone leverages AI to create a real winner.
Well looking back to some of the ideas I've had in the past I stumbled back to my vision of what Marbles on Stream would look like on the blockchain. To reiterate: something like this would be huge because we've already seen how much engagement the game gets on platforms like Twitch.tv. Adding actual money and gambling to the mix makes it exponentially more interesting and addictive. In addition, creating a decentralized solution where no centralized house-entity is profiting from the gamblers is something that has yet to go viral within the ecosystem (for a myriad of reasons/regulations).
Thus, my first attempt with Grok3 was to create a deterministic simulation; one that will always have the same output (winner) given identical inputs across any machine running the simulation. This might not sound like a difficult thing to achieve, but after hours of research I realized that almost none of the physics engines are deterministic because they all use "chaotic floating point" math. Floats are notoriously unreliable to recreate a complex simulation and get the exact same result every time.
This was my final iteration before I realized this project was probably going to be too complex to work. The marbles kept bouncing out of bounds. I asked the AI several times to start a countdown and open a latch at the bottom of the circle so the marbles could escape. I tried to fix this problem like 3 or 4 times before deciding it just wasn't going to work out.
I was very impressed with what the AI could do, even though it couldn't do what I wanted. If I was willing to jump into the weeds on this project the AI give me a ton of code for me to work with and manipulate. This is much MUCH easier than starting from scratch.
What took the AI less than an hour to get up and running would have taken me days of trying to figure out how pygame worked even on the most rudimentary of levels. Now I have some code with basic physics and collision that I can look at whenever I want to truly understand what's going on here.
I would say the most important lesson learned from this failure is that AI allows us to prototype a project so quickly it doesn't trap us into a web of sunk-cost-fallacy. Had I of spent weeks trying to figure out Pygame and build the above marble simulation it would have been a lot more difficult to realize I was in over my head and needed to pivot to something else.
Realizing that the prototype proof-of-concept simulation doesn't have to be custom or player-built, I decided to reduce the scope of the project and go for a basic game of Plinko instead. Only having one track for the marbles to bounce on makes it easier to bug-check confirm the deterministic nature I'm looking for; The idea being that anyone can plug the Bitcoin block hash into the simulation and figure out who won the prize without having to trust a centralized agent.
The first video was what I ended up with after several iterations. This Plinko game was the first iteration after one prompt, and it was a bit of a disaster for largely the same reasons.
Telling the AI that I need a deterministic simulation based on an SHA-256 hash confuses the AI into thinking that the marbles are guaranteed to end up in a certain place based on the hash... while this is true to an extent, the AI instead opts to remove all collision from the game and force the marbles to go where it has already decided it's going. Obviously this is not what I'm going for... so let me pause here and see if I can get some physics going like I had to do in the previous attempt.
...
...
...
I just spent a little less than an hour trying to debug this thing and getting it more how I wanted it to look, but I would say it was time well spent. The Plinko solution is definitely the way to go just to create a default marble track proof of concept.
The winner is based on the BTC block hash but all the frontend user sees is a game of Plinko playing out "randomly". This makes the games verifiable in a decentralized say; anyone can run the simulation to confirm the winner. No one can cheat because in order to cheat you'd have to hack the Bitcoin blockchain (which would cost hundreds of thousands of dollars in lost block rewards just to reroll this game a single time).
# Fetch the head Bitcoin block hash
def get_bitcoin_head_block_hash():
try:
response = requests.get("https://blockchain.info/latestblock")
One huge unexpected thing that happened during this adventure was that the AI took it upon themselves to pull the hash from the Bitcoin blockchain and feed it into the algorithm with very little prompting. Interestingly enough this did not happen on my second try and I had to specifically ask for it to be added.
Realistically this is not how the simulation would work, but it's still cool that my program reaches out to some random node and picks up the information it needs. How a real functional version of the simulation would operate is that users would place bets on a future block that has yet to be mined. Nobody knows what the hash will be so no one can figure out the winner until the block is mined. By that time the money is locked in and ready to be released to the winner.
Well if you want to mess around with Python and Pygame like I've done here you can head on over to the official website and download Python. I had to upgrade to the latest version because what I was using was quite old. As luck would have it a stable release debuted on Feb 4th three weeks ago.
https://www.python.org/downloads/release/python-3132/
There should be an option to add python to your "path" if you're on a Windows machine like me. This allows you to open a terminal (search "CMD" for "command prompt") and type "python" into the terminal anywhere without actually being in the python folder.
pip install pygame
pip install pymunk
pip install requests
pygame is the main dependency that allows a graphical interface.
pymunk is a physics engine apparently.
requests allows the program to contact the Bitcoin node to fetch the head block.
import pygame
import pymunk
import pymunk.pygame_util
import random
import sys
import requests
# Initialize Pygame
pygame.init()
# Screen dimensions (increased height for UI area)
WIDTH, HEIGHT = 800, 700 # Added 100 pixels for UI panel
GAME_HEIGHT = 600 # Original play area height
UI_HEIGHT = 100 # Height of UI panel
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Square Plinko with UI Below Prize Boxes")
# Colors
BLUE = (0, 0, 255)
RED = (255, 0, 0)
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0) # For UI panel
# Plinko board parameters
ROWS = 12
COLUMNS = 12
PEG_RADIUS = 5
MARBLE_RADIUS = 10
SLOTS = 12
SLOT_HEIGHT = 60
SLOT_WIDTH = WIDTH / SLOTS
H_SPACING = WIDTH / (COLUMNS + 1)
V_SPACING = (GAME_HEIGHT - SLOT_HEIGHT - 50) / (ROWS + 1)
# Prize values for slots
PRIZES = [0, 100, 500, 1000, 5000, 10000, 10000, 5000, 1000, 500, 100, 0]
# Font for text
FONT = pygame.font.Font(None, 24)
# Fetch the head Bitcoin block hash
def get_bitcoin_head_block_hash():
try:
response = requests.get("https://blockchain.info/latestblock")
response.raise_for_status()
latest_height = response.json()["height"]
response = requests.get(f"https://blockchain.info/block-height/{latest_height}?format=json")
response.raise_for_status()
block_data = response.json()["blocks"][0]
block_hash = block_data["hash"]
print(f"Using Bitcoin head block hash: {block_hash}")
return block_hash
except Exception as e:
print(f"Failed to fetch block hash: {e}")
fallback_hash = "00000000000000000001e8d6829a8a21adc5d38d0a473b144b6765798e61f98b"
print(f"Using fallback hash: {fallback_hash}")
return fallback_hash
# Seed random with block hash
def seed_random(block_hash):
try:
seed = int(block_hash, 16)
random.seed(seed)
except ValueError:
print("Invalid hash; using default seed")
random.seed(0)
# Create staggered grid of static pegs
def create_pegs(space):
pegs = []
for row in range(ROWS):
offset = (row % 2) * 0.5 * H_SPACING
for col in range(COLUMNS):
x = offset + col * H_SPACING
y = (row + 1) * V_SPACING
body = pymunk.Body(body_type=pymunk.Body.STATIC)
body.position = (x, y)
shape = pymunk.Circle(body, PEG_RADIUS)
shape.elasticity = 0.8
shape.friction = 0.0
space.add(body, shape)
pegs.append((x, y))
return pegs
# Create boundaries (sides and bottom)
def create_boundaries(space):
boundaries = []
# Left wall
left_wall = pymunk.Segment(space.static_body, (0, 0), (0, GAME_HEIGHT), 5)
left_wall.elasticity = 0.8
left_wall.friction = 0.0
space.add(left_wall)
boundaries.append(left_wall)
# Right wall
right_wall = pymunk.Segment(space.static_body, (WIDTH, 0), (WIDTH, GAME_HEIGHT), 5)
right_wall.elasticity = 0.8
right_wall.friction = 0.0
space.add(right_wall)
boundaries.append(right_wall)
# Bottom boundary
bottom_y = GAME_HEIGHT
bottom = pymunk.Segment(space.static_body, (0, bottom_y), (WIDTH, bottom_y), 5)
bottom.elasticity = 0.8
bottom.friction = 0.2
space.add(bottom)
boundaries.append(bottom)
# Ridge pegs
ridge_pegs = []
for row in range(0, ROWS, 2):
x = PEG_RADIUS
y = (row + 1) * V_SPACING
body = pymunk.Body(body_type=pymunk.Body.STATIC)
body.position = (x, y)
shape = pymunk.Circle(body, PEG_RADIUS)
shape.elasticity = 0.8
shape.friction = 0.0
space.add(body, shape)
ridge_pegs.append((x, y))
for row in range(1, ROWS, 2):
x = WIDTH - PEG_RADIUS
y = (row + 1) * V_SPACING
body = pymunk.Body(body_type=pymunk.Body.STATIC)
body.position = (x, y)
shape = pymunk.Circle(body, PEG_RADIUS)
shape.elasticity = 0.8
shape.friction = 0.0
space.add(body, shape)
ridge_pegs.append((x, y))
return boundaries, ridge_pegs
# Create physical slot containers
def create_slots(space):
slots = []
for i in range(SLOTS):
slot_left = i * SLOT_WIDTH
slot_right = (i + 1) * SLOT_WIDTH
slot_top = GAME_HEIGHT - SLOT_HEIGHT
slot_bottom = GAME_HEIGHT
# Left wall of slot
left = pymunk.Segment(space.static_body, (slot_left, slot_top), (slot_left, slot_bottom), 2)
left.elasticity = 0.8
left.friction = 0.2
space.add(left)
# Right wall of slot (skip last right wall)
if i < SLOTS - 1:
right = pymunk.Segment(space.static_body, (slot_right, slot_top), (slot_right, slot_bottom), 2)
right.elasticity = 0.8
right.friction = 0.2
space.add(right)
slots.append((slot_left, slot_right, slot_top, slot_bottom))
return slots
# Create a dynamic numbered marble
def create_marble(space, x, y, number):
mass = 1
radius = MARBLE_RADIUS
moment = pymunk.moment_for_circle(mass, 0, radius)
body = pymunk.Body(mass, moment)
body.position = (x, y)
shape = pymunk.Circle(body, radius)
shape.elasticity = 0.8
shape.friction = 0.2
shape.collision_type = 1
shape.number = number
space.add(body, shape)
return body
# Check if marbles have settled and assign prizes
def check_marble_slots(marbles, slots, total_prize, settled):
for marble in marbles:
if marble in settled:
continue
if abs(marble.velocity.x) < 1 and abs(marble.velocity.y) < 1 and marble.position.y > GAME_HEIGHT - SLOT_HEIGHT - 10:
for i, (left, right, top, bottom) in enumerate(slots):
if left <= marble.position.x <= right:
if marble not in settled:
for shape in marble.shapes:
number = shape.number
break
total_prize[0] += PRIZES[i]
print(f"Marble {number} landed in slot {i}: ${PRIZES[i]}")
settled.add(marble)
break
# Reset the game
def reset_game(space, block_hash, marbles, total_prize, settled):
for marble in marbles[:]:
for shape in marble.shapes:
space.remove(shape)
space.remove(marble)
marbles.clear()
total_prize[0] = 0
settled.clear()
seed_random(block_hash)
drop_x = [random.uniform(H_SPACING, WIDTH - H_SPACING) for _ in range(5)]
new_marbles = [create_marble(space, drop_x[i], 0, i + 1) for i in range(5)]
marbles.extend(new_marbles)
# Main game function
def main():
block_hash = get_bitcoin_head_block_hash()
current_hash = block_hash
hash_editing = False # Track if hash field is active
hash_cursor_pos = len(current_hash) # Cursor position in hash
# Setup Pymunk space
space = pymunk.Space()
space.gravity = (0, 900)
space.damping = 0.95
# Create static elements
pegs = create_pegs(space)
boundaries, ridge_pegs = create_boundaries(space)
slots = create_slots(space)
# Initial marbles
seed_random(current_hash)
N = 5
drop_x = [random.uniform(H_SPACING, WIDTH - H_SPACING) for _ in range(N)]
marbles = [create_marble(space, drop_x[i], 0, i + 1) for i in range(N)]
# Game state
total_prize = [0]
settled = set()
# UI elements
reset_button = pygame.Rect(WIDTH - 150, GAME_HEIGHT + 60, 100, 30) # Reset button
hash_field = pygame.Rect(150, GAME_HEIGHT + 35, 500, 20) # Hash text field
# Pygame setup
clock = pygame.time.Clock()
draw_options = pymunk.pygame_util.DrawOptions(screen)
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.MOUSEBUTTONDOWN:
if reset_button.collidepoint(event.pos):
reset_game(space, current_hash, marbles, total_prize, settled)
elif hash_field.collidepoint(event.pos):
hash_editing = True
hash_cursor_pos = len(current_hash) # Start at end by default
elif event.type == pygame.KEYDOWN and hash_editing:
if event.key == pygame.K_RETURN:
hash_editing = False
reset_game(space, current_hash, marbles, total_prize, settled)
elif event.key == pygame.K_BACKSPACE and hash_cursor_pos > 0:
current_hash = current_hash[:hash_cursor_pos-1] + current_hash[hash_cursor_pos:]
hash_cursor_pos -= 1
elif event.key == pygame.K_LEFT and hash_cursor_pos > 0:
hash_cursor_pos -= 1
elif event.key == pygame.K_RIGHT and hash_cursor_pos < len(current_hash):
hash_cursor_pos += 1
elif event.unicode.isalnum() and len(current_hash) < 64: # Limit to typical hash length
current_hash = current_hash[:hash_cursor_pos] + event.unicode + current_hash[hash_cursor_pos:]
hash_cursor_pos += 1
# Step physics
space.step(1 / 60)
# Check for settled marbles
check_marble_slots(marbles, slots, total_prize, settled)
# Draw game area
screen.fill(BLUE, (0, 0, WIDTH, GAME_HEIGHT))
for i, (left, right, top, bottom) in enumerate(slots):
pygame.draw.rect(screen, RED, (left, top, SLOT_WIDTH, SLOT_HEIGHT))
text = FONT.render(f"${PRIZES[i]}", True, BLACK)
screen.blit(text, (left + SLOT_WIDTH / 2 - text.get_width() / 2,
top + SLOT_HEIGHT / 2 - text.get_height() / 2))
# Draw physics objects
space.debug_draw(draw_options)
# Draw marble numbers
for marble in marbles:
for shape in marble.shapes:
number = shape.number
text = FONT.render(str(number), True, BLACK)
screen.blit(text, (marble.position.x - text.get_width() / 2,
marble.position.y - text.get_height() / 2))
break
# Draw UI panel
pygame.draw.rect(screen, GREEN, (0, GAME_HEIGHT, WIDTH, UI_HEIGHT))
# Total prize
text = FONT.render(f"Total Prize: ${total_prize[0]}", True, BLACK)
screen.blit(text, (10, GAME_HEIGHT + 10))
# Hash field
pygame.draw.rect(screen, WHITE, hash_field)
hash_text = FONT.render(current_hash, True, BLACK)
screen.blit(hash_text, (hash_field.x + 5, hash_field.y + 2))
if hash_editing:
cursor_x = hash_field.x + 5 + FONT.size(current_hash[:hash_cursor_pos])[0]
pygame.draw.line(screen, BLACK, (cursor_x, hash_field.y + 2),
(cursor_x, hash_field.y + 18), 2) # Cursor
# Reset button
pygame.draw.rect(screen, WHITE, reset_button)
reset_text = FONT.render("Reset", True, BLACK)
screen.blit(reset_text, (reset_button.x + (reset_button.width - reset_text.get_width()) / 2,
reset_button.y + (reset_button.height - reset_text.get_height()) / 2))
# Instructions
text = FONT.render("Click hash to edit, Enter to apply, click Reset", True, BLACK)
screen.blit(text, (10, GAME_HEIGHT + 65))
pygame.display.flip()
clock.tick(60)
pygame.quit()
sys.exit()
if __name__ == "__main__":
main()
Make sure the extension of the file is .py for Python (example: plinko.py)
If all went well you'll be able to run plinko.py in the terminal just by typing...
python plinko.py
Or better yet just use AI to make your own game.
I bet many of you can do a lot better than what I've done here.
We seem to be at the dawn of a new era.
I'm a bit shocked that this actually worked. The value of AI is proving itself a thousand times over. There is a lot to unpack here but with clever use of AI generated code we should be able to script plug and play modules that are actually scalable rather than devolving into an unworkable brick of code like many are using this tool for. The amount of time that can be saved with this type of utility is astronomical. Programmers are about to become one-man armies.