Wie erstellt man Spiele mit OpenAI o1?

Einführung

Der OpenAI o1 Die Modellfamilie verbessert die Denkleistung und die wirtschaftliche Leistung erheblich, insbesondere in den Bereichen Wissenschaft, Codierung und Problemlösung. Das Ziel von OpenAI ist es, immer fortschrittlichere KI zu schaffen, und O1-Modelle sind eine Weiterentwicklung gegenüber GPT-4 in Bezug auf Leistung und Sicherheit. In diesem Artikel wird erklärt, wie Sie mit OpenAI o1 Spiele erstellen, beispielsweise Brick Breaker und Snake-Spiele.

Hauptmerkmale der OpenAI o1-Modelle

Da die o1-Modelle explizit auf die Lösung komplexer Probleme in Bereichen wie Programmierung, Mathematik und wissenschaftlicher Forschung zugeschnitten sind, eignen sie sich besonders intestine für Aktivitäten, die fortgeschrittenes Denkvermögen erfordern. Ihre Präzision, Geschwindigkeit und Vielseitigkeit sind deutlich besser als die von GPT-4.

Verbesserte Denkfähigkeiten

Die o1-Familie ist insofern einzigartig, als sie in verschiedenen Situationen argumentieren kann. Im Gegensatz zu herkömmlichen Sprachmodellen, die möglicherweise Schwierigkeiten mit komplizierten logischen Schlussfolgerungen haben, sind die o1-Modelle hervorragend darin, komplexe Antworten abzuleiten, was sie perfekt für die Lösung von Problemen in technischen und beruflichen Bereichen macht. Sie können beispielsweise Probleme behandeln, die mehrere Wissensebenen erfordern, und mehrstufige Anweisungen auf organisierte Weise erfassen.

Effizienz und Wirtschaftlichkeit

Die o1-Modelle zeichnen sich durch ihre hohe Rechenleistung aus. Insbesondere die o1-mini-Modell Die neue Model ermöglicht geringere Kosten ohne Einbußen bei der Leistungsqualität. Mit o1-mini können Entwickler für ein Zehntel der üblichen Rechenkosten auf robuste Instruments für Debugging- und Code-Help-Aktivitäten zugreifen. Für kostensensible Anwendungen wie Lehrmittel oder junge Unternehmen mit begrenzten Ressourcen ist o1-mini von unschätzbarem Wert.

Verbesserte Sicherheit

Die o1-Modelle verfügen über bessere Sicherheitsfunktionen, wie z. B. eine höhere Widerstandsfähigkeit gegen Jailbreaks und eine präzisere Befolgung von Benutzeranweisungen. Dies macht die Modelle in akademischen und professionellen Kontexten vertrauenswürdig, in denen der sichere und ethische Einsatz von KI oberste Priorität hat. Diese Modelle sind so konzipiert, dass sie innerhalb der engen Parameter eines verantwortungsvollen KI-Einsatzes funktionieren und gleichzeitig schädliche Ergebnisse minimieren.

Lesen Sie auch: GPT-4o vs. OpenAI o1: Ist das neue OpenAI-Modell den Hype wert?

Wie erstellt man Spiele mit OpenAI o1-preview?

In diesem Abschnitt werde ich o1-preview zum Erstellen von Spielen verwenden. Es struggle eine unglaublich unterhaltsame Erfahrung, da ich mich hauptsächlich auf das Einrichten der Umgebung (was kein Drawback ist) und das einfache Kopieren und Einfügen von Code konzentrierte. Darüber hinaus erledigte o1-preview alles andere und machte den Prozess nahtlos und effizient. Okay, beginnen wir mit diesem Abschnitt.

Lesen Sie auch: Wie greife ich auf OpenAI o1 zu?

Eingabeaufforderung o1-preview

Aufforderung – „Ich möchte ein kleines/einfaches Spiel bauen. Es soll nur zur Veranschaulichung dienen.“

Im obigen Bild sehen wir die Gedankenkette von o1-preview. Dies zeigt, wie o1-preview das Drawback oder die gegebene Eingabeaufforderung angeht. Wir können auch daraus schließen, dass es 12 Sekunden dauert, um zu antworten. Dies kann auch über 40 Sekunden hinausgehen, manchmal basierend auf der Eingabeaufforderung und der erforderlichen Denkmenge. Das Bild unten zeigt die Gedanken von OpenAI o1 zum Erstellen eines neuen Spiels nach dem Erstellen des ersten.

Spiel 1: Brick Breaker

Beschreibung:

• Der Spieler steuert einen Schläger am unteren Bildschirmrand.
• Ein Ball springt über den Bildschirm und zerbricht Steine, wenn er auf sie trifft.
• Das Ziel besteht darin, alle Steine ​​zu zerstören, ohne dass der Ball den Schläger passiert.
• Beinhaltet grundlegende Physik-, Kollisionserkennungs- und Spielschleifenkonzepte.

Hauptkomponenten:

1. Spielfenster
2. Paddeln
3. Ball
4. Ziegel
5. Spielschleife
6. Ereignisbehandlung

Installieren von Abhängigkeiten

pip set up pygame

Code für Brick Breaker

Sie können diesen Code kopieren und in eine Datei mit dem Namen brick_breaker.py einfügen

# brick_breaker.py

import pygame

import sys

# Initialize Pygame

pygame.init()

# Arrange the sport window

SCREEN_WIDTH = 800

SCREEN_HEIGHT = 600

display screen = pygame.show.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

pygame.show.set_caption('Brick Breaker')

# Outline Colours

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

RED = (200, 0, 0)

# Outline Paddle Class

class Paddle:

def __init__(self):

self.width = 100

self.top = 10

self.x = (SCREEN_WIDTH - self.width) / 2

self.y = SCREEN_HEIGHT - 30

self.pace = 7

self.rect = pygame.Rect(self.x, self.y, self.width, self.top)

def transfer(self, dx):

self.rect.x += dx * self.pace

# Forestall paddle from transferring off-screen

if self.rect.left < 0:

self.rect.left = 0

if self.rect.proper > SCREEN_WIDTH:

self.rect.proper = SCREEN_WIDTH

def draw(self, floor):

pygame.draw.rect(floor, WHITE, self.rect)

# Outline Ball Class

class Ball:

def __init__(self):

self.radius = 8

self.x = SCREEN_WIDTH / 2

self.y = SCREEN_HEIGHT / 2

self.speed_x = 4

self.speed_y = -4

self.rect = pygame.Rect(self.x - self.radius, self.y - self.radius,

self.radius * 2, self.radius * 2)

def transfer(self):

self.rect.x += self.speed_x

self.rect.y += self.speed_y

# Bounce off partitions

if self.rect.left <= 0 or self.rect.proper >= SCREEN_WIDTH:

self.speed_x *= -1

if self.rect.prime <= 0:

self.speed_y *= -1

def draw(self, floor):

pygame.draw.circle(floor, WHITE,

(self.rect.x + self.radius, self.rect.y + self.radius),

self.radius)

# Outline Brick Class

class Brick:

def __init__(self, x, y):

self.width = 60

self.top = 20

self.rect = pygame.Rect(x, y, self.width, self.top)

self.colour = RED  # Crimson colour

def draw(self, floor):

pygame.draw.rect(floor, self.colour, self.rect)

# Perform to Create Bricks

def create_bricks(rows, cols):

bricks = ()

padding = 5

offset_x = 35

offset_y = 50

for row in vary(rows):

for col in vary(cols):

x = offset_x + col * (60 + padding)

y = offset_y + row * (20 + padding)

bricks.append(Brick(x, y))

return bricks

# Essential Sport Loop

def essential():

clock = pygame.time.Clock()

paddle = Paddle()

ball = Ball()

bricks = create_bricks(5, 11)  # 5 rows, 11 columns

working = True

whereas working:

clock.tick(60)  # Restrict to 60 frames per second

display screen.fill(BLACK)  # Clear display screen with black colour

# Occasion Dealing with

for occasion in pygame.occasion.get():

if occasion.kind == pygame.QUIT:

working = False

# Paddle Motion

keys = pygame.key.get_pressed()

if keys(pygame.K_LEFT):

paddle.transfer(-1)

if keys(pygame.K_RIGHT):

paddle.transfer(1)

# Transfer Ball

ball.transfer()

# Collision Detection

if ball.rect.colliderect(paddle.rect):

ball.speed_y *= -1  # Bounce off paddle

# Examine for collision with bricks

for brick in bricks(:):

if ball.rect.colliderect(brick.rect):

ball.speed_y *= -1

bricks.take away(brick)

break  # Forestall a number of collisions in a single body

# Examine if ball is out of bounds

if ball.rect.backside >= SCREEN_HEIGHT:

print("Sport Over")

working = False

# Draw Sport Objects

paddle.draw(display screen)

ball.draw(display screen)

for brick in bricks:

brick.draw(display screen)

# Replace Show

pygame.show.flip()

pygame.give up()

sys.exit()

if __name__ == "__main__":

essential()

Führen Sie das Spiel aus

python brick_breaker.py

Add brick_breaker video

Mehr erfahren: Maschinelles Lernen und KI in der Spieleentwicklung im Jahr 2024

Spiel 2: Schlangenspiel

Beschreibung:

• Sie steuern eine Schlange, die sich auf dem Bildschirm bewegt.
• Die Schlange wird mit jeder Nahrungsaufnahme länger.
• Das Spiel endet, wenn die Schlange mit den Wänden oder sich selbst kollidiert.
• Das Ziel besteht darin, so viel Nahrung wie möglich zu sich zu nehmen, um einen Highscore zu erreichen.

Spielsteuerung

Spielziel

• Essen
• Wachsen
• Kollisionen vermeiden
• Punktzahl

Code für das Snake-Spiel

# snake_game.py

import pygame

import sys

import random

# Initialize Pygame

pygame.init()

# Arrange the sport window

SCREEN_WIDTH = 600

SCREEN_HEIGHT = 400

display screen = pygame.show.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

pygame.show.set_caption('Snake Sport')

# Outline Colours

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

GREEN = (0, 255, 0)

RED = (213, 50, 80)

# Arrange the clock for a good framerate

clock = pygame.time.Clock()

# Outline the snake's preliminary place and dimension

snake_block = 10

snake_speed = 15

# Fonts for displaying rating and messages

font_style = pygame.font.SysFont(None, 30)

score_font = pygame.font.SysFont(None, 25)

def display_score(rating):

worth = score_font.render("Your Rating: " + str(rating), True, WHITE)

display screen.blit(worth, (0, 0))

def draw_snake(snake_block, snake_list):

for x in snake_list:

pygame.draw.rect(display screen, GREEN, (x(0), x(1), snake_block, snake_block))

def message(msg, colour):

mesg = font_style.render(msg, True, colour)

display screen.blit(mesg, (SCREEN_WIDTH / 6, SCREEN_HEIGHT / 3))

def game_loop():

game_over = False

game_close = False

# Beginning place of the snake

x1 = SCREEN_WIDTH / 2

y1 = SCREEN_HEIGHT / 2

# Change in place

x1_change = 0

y1_change = 0

# Snake physique record

snake_list = ()

length_of_snake = 1

# Place meals randomly

foodx = spherical(random.randrange(0, SCREEN_WIDTH - snake_block) / 10.0) * 10.0

foody = spherical(random.randrange(0, SCREEN_HEIGHT - snake_block) / 10.0) * 10.0

whereas not game_over:

whereas game_close:

display screen.fill(BLACK)

message("You Misplaced! Press C-Play Once more or Q-Give up", RED)

pygame.show.replace()

# Occasion dealing with for sport over display screen

for occasion in pygame.occasion.get():

if occasion.kind == pygame.KEYDOWN:

if occasion.key == pygame.K_q:

game_over = True

game_close = False

if occasion.key == pygame.K_c:

game_loop()

if occasion.kind == pygame.QUIT:

game_over = True

game_close = False

# Occasion dealing with for sport play

for occasion in pygame.occasion.get():

if occasion.kind == pygame.QUIT:

game_over = True

if occasion.kind == pygame.KEYDOWN:

if occasion.key == pygame.K_LEFT and x1_change != snake_block:

x1_change = -snake_block

y1_change = 0

elif occasion.key == pygame.K_RIGHT and x1_change != -snake_block:

x1_change = snake_block

y1_change = 0

elif occasion.key == pygame.K_UP and y1_change != snake_block:

y1_change = -snake_block

x1_change = 0

elif occasion.key == pygame.K_DOWN and y1_change != -snake_block:

y1_change = snake_block

x1_change = 0

# Examine for boundaries

if x1 >= SCREEN_WIDTH or x1 < 0 or y1 >= SCREEN_HEIGHT or y1 < 0:

game_close = True

# Replace snake place

x1 += x1_change

y1 += y1_change

display screen.fill(BLACK)

pygame.draw.rect(display screen, RED, (foodx, foody, snake_block, snake_block))

snake_head = (x1, y1)

snake_list.append(snake_head)

if len(snake_list) > length_of_snake:

del snake_list(0)

# Examine if snake collides with itself

for x in snake_list(:-1):

if x == snake_head:

game_close = True

draw_snake(snake_block, snake_list)

display_score(length_of_snake - 1)

pygame.show.replace()

# Examine if snake has eaten the meals

if x1 == foodx and y1 == foody:

foodx = spherical(random.randrange(0, SCREEN_WIDTH - snake_block) / 10.0) * 10.0

foody = spherical(random.randrange(0, SCREEN_HEIGHT - snake_block) / 10.0) * 10.0

length_of_snake += 1

clock.tick(snake_speed)

pygame.give up()

sys.exit()

if __name__ == "__main__":

game_loop()

Führen Sie das Spiel aus

python snake_game.py
Add Snake sport video

Lesen Sie auch: 3 praktische Experimente mit OpenAIs o1, die Sie sehen müssen

Spiel 3: Ping-Pong-Spiel

Beschreibung:

• Zwei Spieler steuern Paddel auf gegenüberliegenden Seiten des Bildschirms.
• Ein Ball springt zwischen den Schlägern hin und her.
• Jeder Spieler versucht zu verhindern, dass der Ball an seinem Schläger vorbeikommt.
• Das Spiel endet, wenn ein Spieler eine festgelegte Punktzahl erreicht.

Spielsteuerung

Spielziel

• Verhindern Sie, dass der Ball Ihren Schläger passiert.
• Erzielen Sie jedes Mal einen Punkt, wenn der Ball am Schläger des Gegners vorbeikommt.
• Das Spiel geht unbegrenzt weiter; Sie können ein Punktelimit festlegen, um das Spiel zu beenden.

Code für Ping-Pong-Spiel

# pong_game.py

import pygame

import sys

# Initialize Pygame

pygame.init()

# Arrange the sport window

SCREEN_WIDTH = 800

SCREEN_HEIGHT = 600

display screen = pygame.show.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

pygame.show.set_caption('Pong')

# Outline Colours

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

# Paddle and Ball Settings

PADDLE_WIDTH = 10

PADDLE_HEIGHT = 100

BALL_SIZE = 10

PADDLE_SPEED = 6

BALL_SPEED_X = 4

BALL_SPEED_Y = 4

# Fonts for displaying rating

score_font = pygame.font.SysFont(None, 35)

# Outline Paddle Class

class Paddle:

def __init__(self, x, y):

self.rect = pygame.Rect(x, y, PADDLE_WIDTH, PADDLE_HEIGHT)

self.pace = PADDLE_SPEED

def transfer(self, up, down):

keys = pygame.key.get_pressed()

if keys(up) and self.rect.prime > 0:

self.rect.y -= self.pace

if keys(down) and self.rect.backside < SCREEN_HEIGHT:

self.rect.y += self.pace

def draw(self, floor):

pygame.draw.rect(floor, WHITE, self.rect)

# Outline Ball Class

class Ball:

def __init__(self):

self.rect = pygame.Rect(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2, BALL_SIZE, BALL_SIZE)

self.speed_x = BALL_SPEED_X

self.speed_y = BALL_SPEED_Y

def transfer(self):

self.rect.x += self.speed_x

self.rect.y += self.speed_y

# Bounce off prime and backside partitions

if self.rect.prime <= 0 or self.rect.backside >= SCREEN_HEIGHT:

self.speed_y *= -1

def draw(self, floor):

pygame.draw.ellipse(floor, WHITE, self.rect)

# Perform to show the rating

def display_score(score1, score2):

score_text = score_font.render(f"Participant 1: {score1}   Participant 2: {score2}", True, WHITE)

display screen.blit(score_text, (SCREEN_WIDTH // 2 - score_text.get_width() // 2, 20))

# Essential Sport Loop

def essential():

clock = pygame.time.Clock()

# Create Paddles and Ball

paddle1 = Paddle(30, SCREEN_HEIGHT // 2 - PADDLE_HEIGHT // 2)

paddle2 = Paddle(SCREEN_WIDTH - 30 - PADDLE_WIDTH, SCREEN_HEIGHT // 2 - PADDLE_HEIGHT // 2)

ball = Ball()

# Initialize scores

score1 = 0

score2 = 0

working = True

whereas working:

clock.tick(60)  # Restrict to 60 frames per second

display screen.fill(BLACK)  # Clear display screen with black colour

# Occasion Dealing with

for occasion in pygame.occasion.get():

if occasion.kind == pygame.QUIT:

working = False

# Transfer Paddles

paddle1.transfer(pygame.K_w, pygame.K_s)

paddle2.transfer(pygame.K_UP, pygame.K_DOWN)

# Transfer Ball

ball.transfer()

# Collision Detection with Paddles

if ball.rect.colliderect(paddle1.rect) or ball.rect.colliderect(paddle2.rect):

ball.speed_x *= -1  # Bounce off paddles

# Examine for Scoring

if ball.rect.left <= 0:

score2 += 1

ball.rect.middle = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)  # Reset ball

ball.speed_x *= -1

if ball.rect.proper >= SCREEN_WIDTH:

score1 += 1

ball.rect.middle = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)  # Reset ball

ball.speed_x *= -1

# Draw Sport Objects

paddle1.draw(display screen)

paddle2.draw(display screen)

ball.draw(display screen)

display_score(score1, score2)

# Replace Show

pygame.show.flip()

pygame.give up()

sys.exit()

if __name__ == "__main__":

essential()

Führen Sie das Spiel aus

python pong_game.py
Add ping pong sport video

Spiel 4: Tic Tac Toe

Beschreibung:

• Ein 3×3-Raster, auf dem zwei Spieler abwechselnd ihre Markierungen (X oder O) platzieren.
• Ziel ist es, als erster Spieler drei Markierungen in einer Reihe (horizontal, vertikal oder diagonal) zu haben.
• Das Spiel endet mit einem Sieg oder einem Unentschieden, wenn alle Zellen ausgefüllt sind, ohne dass es einen Gewinner gibt.

Spielsteuerung

Spielziel

• Seien Sie der erste Spieler, der drei seiner Markierungen (X oder O) in einer Reihe, Spalte oder Diagonale platziert.
• Das Spiel endet mit einem Sieg oder einem Unentschieden, wenn alle Zellen ausgefüllt sind, ohne dass es einen Gewinner gibt.

Code für Tic Tac Toe

# tic_tac_toe.py

import pygame

import sys

# Initialize Pygame

pygame.init()

# Arrange the sport window

SCREEN_WIDTH = 600

SCREEN_HEIGHT = 600

display screen = pygame.show.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

pygame.show.set_caption('Tic-Tac-Toe')

# Outline Colours

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

RED = (255, 0, 0)

BLUE = (0, 0, 255)

# Outline Board Settings

BOARD_ROWS = 3

BOARD_COLS = 3

SQUARE_SIZE = SCREEN_WIDTH // BOARD_COLS

LINE_WIDTH = 15

# Initialize the board

board = ((None for _ in vary(BOARD_COLS)) for _ in vary(BOARD_ROWS))

current_player="X"  # Begin with participant X

def draw_board():

display screen.fill(WHITE)

# Draw grid traces

for row in vary(1, BOARD_ROWS):

pygame.draw.line(display screen, BLACK, (0, row * SQUARE_SIZE), (SCREEN_WIDTH, row * SQUARE_SIZE), LINE_WIDTH)

for col in vary(1, BOARD_COLS):

pygame.draw.line(display screen, BLACK, (col * SQUARE_SIZE, 0), (col * SQUARE_SIZE, SCREEN_HEIGHT), LINE_WIDTH)

def draw_markers():

for row in vary(BOARD_ROWS):

for col in vary(BOARD_COLS):

marker = board(row)(col)

if marker == 'X':

pygame.draw.line(display screen, RED,

(col * SQUARE_SIZE + 20, row * SQUARE_SIZE + 20),

((col + 1) * SQUARE_SIZE - 20, (row + 1) * SQUARE_SIZE - 20), LINE_WIDTH)

pygame.draw.line(display screen, RED,

(col * SQUARE_SIZE + 20, (row + 1) * SQUARE_SIZE - 20),

((col + 1) * SQUARE_SIZE - 20, row * SQUARE_SIZE + 20), LINE_WIDTH)

elif marker == 'O':

pygame.draw.circle(display screen, BLUE,

(col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2),

SQUARE_SIZE // 2 - 20, LINE_WIDTH)

def check_winner():

# Examine rows and columns for a win

for row in vary(BOARD_ROWS):

if board(row)(0) == board(row)(1) == board(row)(2) and board(row)(0) shouldn't be None:

return board(row)(0)

for col in vary(BOARD_COLS):

if board(0)(col) == board(1)(col) == board(2)(col) and board(0)(col) shouldn't be None:

return board(0)(col)

# Examine diagonals for a win

if board(0)(0) == board(1)(1) == board(2)(2) and board(0)(0) shouldn't be None:

return board(0)(0)

if board(0)(2) == board(1)(1) == board(2)(0) and board(0)(2) shouldn't be None:

return board(0)(2)

# Examine for a draw

if all(all(cell shouldn't be None for cell in row) for row in board):

return 'Draw'

return None

def game_over_message(winner):

font = pygame.font.SysFont(None, 55)

if winner == 'Draw':

textual content = font.render('Draw! Press R to Restart', True, BLACK)

else:

textual content = font.render(f'{winner} Wins! Press R to Restart', True, BLACK)

display screen.blit(textual content, (SCREEN_WIDTH // 2 - textual content.get_width() // 2, SCREEN_HEIGHT // 2 - textual content.get_height() // 2))

def reset_game():

world board, current_player

board = ((None for _ in vary(BOARD_COLS)) for _ in vary(BOARD_ROWS))

current_player="X"

def essential():

world current_player

working = True

winner = None

whereas working:

for occasion in pygame.occasion.get():

if occasion.kind == pygame.QUIT:

working = False

if occasion.kind == pygame.MOUSEBUTTONDOWN and winner is None:

mouse_x, mouse_y = occasion.pos

clicked_row = mouse_y // SQUARE_SIZE

clicked_col = mouse_x // SQUARE_SIZE

if board(clicked_row)(clicked_col) is None:

board(clicked_row)(clicked_col) = current_player

current_player="O" if current_player == 'X' else 'X'

if occasion.kind == pygame.KEYDOWN:

if occasion.key == pygame.K_r:

reset_game()

winner = None

draw_board()

draw_markers()

winner = check_winner()

if winner:

game_over_message(winner)

pygame.show.flip()

pygame.give up()

sys.exit()

if __name__ == "__main__":

essential()

Führen Sie das Spiel aus

python tic_tac_toe.py
Add tic tac toe video

Mehr erfahren: Die 10 wichtigsten KI-Instruments, die die Spieleentwicklung verändern

Spiel 5: Spiel 2048

Beschreibung:

• Das Spiel besteht aus einem 4×4-Raster aus Spielsteinen.
• Die Spieler kombinieren Steine ​​mit der gleichen Zahl, um größere Zahlen zu bilden, mit dem Ziel, den Stein 2048 zu erreichen.
• Spieler können alle Kacheln nach oben, unten, hyperlinks oder rechts bewegen.
• Wenn sich zwei Kacheln mit der gleichen Nummer berühren, verschmelzen sie zu einer.

Warum „2048“?

• Logisches Denken
• Interaktiv und fesselnd
• Erweiterbar

Spielsteuerung

Spielziel

• Kombinieren Sie Kacheln mit der gleichen Nummer, um Kacheln mit höheren Nummern zu erstellen.
• Ziel ist es, die

Code für Spiel 2048

# game_2048.py

import pygame

import sys

import random

# Initialize Pygame

pygame.init()

# Arrange the sport window

SIZE = WIDTH, HEIGHT = 400, 400

display screen = pygame.show.set_mode(SIZE)

pygame.show.set_caption('2048')

# Outline Colours

BACKGROUND_COLOR = (187, 173, 160)

EMPTY_TILE_COLOR = (205, 193, 180)

TILE_COLORS = {

2: (238, 228, 218),

4: (237, 224, 200),

8: (242, 177, 121),

16: (245, 149, 99),

32: (246, 124, 95),

64: (246, 94, 59),

128: (237, 207, 114),

256: (237, 204, 97),

512: (237, 200, 80),

1024: (237, 197, 63),

2048: (237, 194, 46),

}

FONT_COLOR = (119, 110, 101)

FONT = pygame.font.SysFont('Arial', 24, daring=True)

# Initialize sport variables

GRID_SIZE = 4

TILE_SIZE = WIDTH // GRID_SIZE

GRID = ((0) * GRID_SIZE for _ in vary(GRID_SIZE))

def add_new_tile():

empty_tiles = ((i, j) for i in vary(GRID_SIZE) for j in vary(GRID_SIZE) if GRID(i)(j) == 0)

if empty_tiles:

i, j = random.selection(empty_tiles)

GRID(i)(j) = random.selection((2, 4))

def draw_grid():

display screen.fill(BACKGROUND_COLOR)

for i in vary(GRID_SIZE):

for j in vary(GRID_SIZE):

worth = GRID(i)(j)

rect = pygame.Rect(j * TILE_SIZE, i * TILE_SIZE, TILE_SIZE, TILE_SIZE)

pygame.draw.rect(display screen, TILE_COLORS.get(worth, EMPTY_TILE_COLOR), rect)

if worth != 0:

text_surface = FONT.render(str(worth), True, FONT_COLOR)

text_rect = text_surface.get_rect(middle=rect.middle)

display screen.blit(text_surface, text_rect)

def move_left():

moved = False

for i in vary(GRID_SIZE):

tiles = (worth for worth in GRID(i) if worth != 0)

new_row = ()

skip = False

for j in vary(len(tiles)):

if skip:

skip = False

proceed

if j + 1 < len(tiles) and tiles(j) == tiles(j + 1):

new_row.append(tiles(j) * 2)

skip = True

moved = True

else:

new_row.append(tiles(j))

new_row += (0) * (GRID_SIZE - len(new_row))

if GRID(i) != new_row:

GRID(i) = new_row

moved = True

return moved

def move_right():

moved = False

for i in vary(GRID_SIZE):

tiles = (worth for worth in GRID(i) if worth != 0)

new_row = ()

skip = False

for j in vary(len(tiles) - 1, -1, -1):

if skip:

skip = False

proceed

if j - 1 >= 0 and tiles(j) == tiles(j - 1):

new_row.insert(0, tiles(j) * 2)

skip = True

moved = True

else:

new_row.insert(0, tiles(j))

new_row = (0) * (GRID_SIZE - len(new_row)) + new_row

if GRID(i) != new_row:

GRID(i) = new_row

moved = True

return moved

def move_up():

moved = False

for j in vary(GRID_SIZE):

tiles = (GRID(i)(j) for i in vary(GRID_SIZE) if GRID(i)(j) != 0)

new_column = ()

skip = False

for i in vary(len(tiles)):

if skip:

skip = False

proceed

if i + 1 < len(tiles) and tiles(i) == tiles(i + 1):

new_column.append(tiles(i) * 2)

skip = True

moved = True

else:

new_column.append(tiles(i))

new_column += (0) * (GRID_SIZE - len(new_column))

for i in vary(GRID_SIZE):

if GRID(i)(j) != new_column(i):

GRID(i)(j) = new_column(i)

moved = True

return moved

def move_down():

moved = False

for j in vary(GRID_SIZE):

tiles = (GRID(i)(j) for i in vary(GRID_SIZE) if GRID(i)(j) != 0)

new_column = ()

skip = False

for i in vary(len(tiles) - 1, -1, -1):

if skip:

skip = False

proceed

if i - 1 >= 0 and tiles(i) == tiles(i - 1):

new_column.insert(0, tiles(i) * 2)

skip = True

moved = True

else:

new_column.insert(0, tiles(i))

new_column = (0) * (GRID_SIZE - len(new_column)) + new_column

for i in vary(GRID_SIZE):

if GRID(i)(j) != new_column(i):

GRID(i)(j) = new_column(i)

moved = True

return moved

def is_game_over():

for i in vary(GRID_SIZE):

for j in vary(GRID_SIZE):

if GRID(i)(j) == 0:

return False

if j + 1 < GRID_SIZE and GRID(i)(j) == GRID(i)(j + 1):

return False

if i + 1 < GRID_SIZE and GRID(i)(j) == GRID(i + 1)(j):

return False

return True

def essential():

add_new_tile()

add_new_tile()

working = True

whereas working:

draw_grid()

pygame.show.flip()

if is_game_over():

print("Sport Over!")

working = False

proceed

for occasion in pygame.occasion.get():

if occasion.kind == pygame.QUIT:

working = False

elif occasion.kind == pygame.KEYDOWN:

moved = False

if occasion.key == pygame.K_LEFT:

moved = move_left()

elif occasion.key == pygame.K_RIGHT:

moved = move_right()

elif occasion.key == pygame.K_UP:

moved = move_up()

elif occasion.key == pygame.K_DOWN:

moved = move_down()

if moved:

add_new_tile()

pygame.give up()

sys.exit()

if __name__ == "__main__":

essential()

Führen Sie das Spiel aus

python game_2048.py
Add the video for Sport 2048

Lesen Sie auch: Wie greife ich auf die OpenAI o1-API zu?

Abschluss

Mit ihrem speziellen Design zur Lösung anspruchsvoller Denkprobleme in Wissenschaft, Mathematik und Programmierung stellt die OpenAI o1-Modellfamilie einen beeindruckenden Sprung nach vorne in der KI-Technologie dar. Sie ist aufgrund ihrer Kosteneffizienz, verbesserten Sicherheitsfunktionen und erweiterten Denkfähigkeiten für akademische, Forschungs- und professionelle Umgebungen nützlich. Ich habe das Potenzial des OpenAI o1-Modells für die Entwicklung von Spielen untersucht. Ich konnte seine Wirksamkeit bei der Erstellung interaktiver Spiele wie Brick Breaker, Snake Sport, Ping Pong, Tic Tac Toe und 2048 erkennen. Modelle wie o1 werden mit der Entwicklung der KI immer wichtiger und ermöglichen kreatives und effektives Problemlösen in verschiedenen Branchen.

Bleiben Sie dran Analytics Vidhya-Weblog um mehr über die Verwendung von o1 zu erfahren!

Häufig gestellte Fragen

Praktikant für Datenwissenschaft bei Analytics Vidhya, spezialisiert auf ML, DL und KI. Der Austausch von Erkenntnissen durch Artikel zu diesen Themen ist mir ein Anliegen. Lernbegierig und möchte zu den Fortschritten in diesem Bereich beitragen. Leidenschaftlich daran interessiert, Daten zu nutzen, um komplexe Probleme zu lösen und Innovationen voranzutreiben.