Baru-baru ini saya terjumpa petikan oleh influencer teknologi "the primeagen" Saya tidak ingat betul-betul tetapi seingat saya ia seperti ini :
"Jika anda tidak gagal dalam apa yang anda lakukan, maka anda tidak belajar."
Ini membuatkan saya terfikir tentang perjalanan pengekodan saya. Saya telah menjadi agak selesa dengan membina bahagian belakang, sehingga menulis import ekspres daripada 'ekspres'; telah menjadi kerja kerja.
Daripada melalui acara kanun untuk mempelajari satu lagi rangka kerja JavaScript untuk membina apl todo revolusioner saya yang kejuta (kerana jelasnya, dunia memerlukan lebih banyak daripada itu), saya memutuskan untuk melakukan sesuatu yang lain. Saya telah membaca tentang protokol WebSocket dan mendapati keupayaannya untuk mengendalikan mesej tak segerak dua arah antara pelayan dan pelanggan menarik. Saya mahu membina sesuatu dengannya, tetapi saya memerlukan rehat daripada JavaScript.
Selepas beberapa pertimbangan, saya memilih permainan 2D berbilang pemain yang mudah. Ia akan melibatkan pengiraan (pengesan perlanggaran), struktur data (senarai terpaut, peta cincang) dan penyegerakan pemain. Permainan ular kelihatan sempurna, dengan beberapa peraturan mudah:
Memakan buah menjadikan anda membesar dan menambah 1 pada markah anda
Merempuh badan pemain lain membuatkan anda mengecut, menetapkan semula kedudukan anda secara rawak dan mensifarkan markah anda
Perlanggaran satu sama lain menyebabkan kedua-dua pemain mengecut, menetapkan semula kedudukan mereka dan mensifarkan markah mereka
Semua pengiraan ini berlaku di bahagian pelayan untuk mengelakkan pemain daripada mengganggu logik permainan. Kami akan menggunakan Python 3 dengan Pygame untuk grafik dan perpustakaan soket web untuk mengendalikan mesej tak segerak melalui asyncio.
Sekarang, mari kita selami kod yang anda mungkin mendapati ia tidak kemas kerana ingat peraturan pertama pengaturcaraan:
"Jika ia berkesan, jangan sentuhnya."
Anda sudah cukup membaca tawa saya, mari beralih ke bahagian yang menyeronokkan: Pengekodan. Tetapi jika anda ingin melangkau sembang dan menyelam terus, pergi sahaja ke repo GitHub.
Jika anda ingin menyumbang , jangan ragu untuk membuka isu atau menyerahkan permintaan tarik. Sebarang penambahbaikan atau pembetulan pepijat dialu-alukan!
Pertama, kami mentakrifkan struktur data kami:
class Object :
def __init__(self , x : float , y :float , width:int , height :int):
####################################
# init object's size and postion #
####################################
self.x = x
self.y = y
self.height = height
self.width = width
def render(self , screen , color) :
pygame.draw.rect(screen ,color ,pygame.Rect(self.x , self.y , self.width , self.height))
class Player(Object) :
def __init__(self, x: float, y: float, width: int, height: int):
super().__init__(x, y, width, height)
self.next = None
self.prev = None
self.tail = self
self.direction = 'LEFT'
self.length = 1
self.color = 'red'
# move the Snake to a certain direction
# the "changed" will be a way to tell either to continue in the same direction
# or change the direction of the head to the new direction
# it is used in the game
def change_direction(self, keys):
changed = False
if self.direction in ['LEFT', 'RIGHT']:
if keys[pygame.K_w] and self.direction != 'DOWN':
self.direction = 'UP'
changed = True
elif keys[pygame.K_s] and self.direction != 'UP':
self.direction = 'DOWN'
changed = True
elif self.direction in ['UP', 'DOWN']:
if keys[pygame.K_a] and self.direction != 'RIGHT':
self.direction = 'LEFT'
changed = True
elif keys[pygame.K_d] and self.direction != 'LEFT':
self.direction = 'RIGHT'
changed = True
return changed
# move the Snake to a certain direction with a certain speed
def move(self, screen, dt):
speed = 150 * dt
if self.direction == 'UP':
self.move_all(screen, 0, -speed)
elif self.direction == 'DOWN':
self.move_all(screen, 0, speed)
elif self.direction == 'LEFT':
self.move_all(screen, -speed, 0)
elif self.direction == 'RIGHT':
self.move_all(screen, speed, 0)
def bound(self , screen) :
if self.y < 0 :
self.y = screen.get_height()
if self.y > screen.get_height() :
self.y = 0
if self.x < 0 :
self.x = screen.get_width()
if self.x > screen.get_width() :
self.x = 0
def get_pos(self) :
arr = []
current = self
while current :
arr.append([current.x , current.y])
current = current.next
return arr
# move the snake and its body to some coordinates
def move_all(self, screen, dx, dy):
# Store old positions
old_positions = []
current = self
while current:
old_positions.append((current.x, current.y))
current = current.next
# Move head
self.x += dx
self.y += dy
self.bound(screen)
# self.render(screen, self.color)
# Move body
current = self.next
i = 0
while current:
current.x, current.y = old_positions[i]
current.bound(screen)
# current.render(screen, self.color)
current = current.next
i += 1
def add(self ):
new = Player(self.tail.x+self.tail.width+10 ,
self.tail.y ,self.tail.width ,
self.tail.height)
new.prev = self.tail
self.tail.next = new
self.tail = new
self.length +=1
def shrink(self , x , y):
self.next = None
self.tail = self
self.length = 1
self.x = x
self.y = y
# used for the and the opponent player when
# receiving its coordinates
def setall(self , arr) :
self.x = arr[0][0]
self.y = arr[0][1]
self.next = None
self.tail = self
current = self
for i in range(1 , len(arr)) :
x = arr[i][0]
y = arr[i][1]
new = Player(x ,y ,self.width , self.height)
current.next = new
self.tail = new
current = current.next
# render the whole snake on the screen
# used for both the current player and the opponent
def render_all(self, screen, color):
current = self
if self.next :
self.render(screen,'white')
current = self.next
while current :
current.render(screen , color)
current = current.next
Salin selepas log masuk
Kelas Objek ialah kelas asas untuk objek permainan, manakala kelas Pemain memanjangkannya dengan kefungsian khusus ular. Kelas Pemain termasuk kaedah untuk menukar arah, bergerak, membesar, mengecut dan membuat ular.
Seterusnya, kami mempunyai logik permainan:
import pygame
from objects import Player
import websockets
import asyncio
import json
uri = 'ws://localhost:8765'
pygame.font.init()
# Render the text on a transparent surface
font = pygame.font.Font(None, 36)
# playing the main theme (you should hear it)
def play() :
pygame.mixer.init()
pygame.mixer.music.load('unknown.mp3')
pygame.mixer.music.play()
def stop():
if pygame.mixer.music.get_busy(): # Check if music is playing
pygame.mixer.music.stop()
# initialize players and the fruit
def init(obj) :
print(obj)
player = Player(*obj['my'][0])
opp = Player(*obj['opp'][0] )
food = Food(*obj['food'])
return (player , opp , food)
async def main():
async with websockets.connect(uri) as ws:
choice = int(input('1 to create a room \n2 to join a room\n>>>'))
room_name = input('enter room name: ')
await ws.send(json.dumps({
"choice" : choice ,
"room" : room_name
}))
## waiting for the other player to connecet
res = {}
while True:
res = await ws.recv()
try:
res = json.loads(res)
break
except Exception as e:
pass
player, opp, food = init(res)
pygame.init()
screen = pygame.display.set_mode((600, 400))
clock = pygame.time.Clock()
running = True
dt = 0
play()
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
screen.fill("black")
my_pos = {
'pos': player.get_pos(),
'len': player.length
}
await ws.send(json.dumps(my_pos))
response = await ws.recv()
response = json.loads(response)
# Update food position
pygame.draw.rect(screen ,'green' ,pygame.Rect(response['food'][0] ,response['food'][1] ,20, 20))
# Handle actions
if response['act'] == 'grow':
player.add()
elif response['act'] == 'shrinkall':
player.shrink(*response['my'][0][0:2])
opp.shrink(*response['opp'][0][0:2])
elif response['act'] == 'shrink':
player.shrink(*response['my'][0][0:2])
# restarting the song each time you bump into the other player
stop()
play()
else:
opp.setall(response['opp'])
# Render everything once per frame
player.render_all(screen, 'red')
opp.render_all(screen, 'blue')
## score
## x | y => x you , y opponent
text = font.render(f'{response["my_score"]} | {response["other_score"]}', True, (255, 255, 255))
screen.blit(text, (0, 0))
pygame.display.flip()
keys = pygame.key.get_pressed()
changed = player.change_direction(keys)
# keep moving in the same direction if it is not changed
if not changed:
player.move(screen, dt)
dt = clock.tick(60) / 1000
pygame.quit()
asyncio.run(main())
Salin selepas log masuk
ini akan menghubungkan anda pelayan dan membolehkan anda membuat dan menyertai bilik , ia akan menghantar kemas kini kedudukan anda kepada pelayan dan mendapatkan kedudukan lawan dan kedudukan buah dan tindakan yang akan menjadi perintah kepada pemain untuk sama ada mengecut atau membesar
Akhir sekali, kod pelayan:
import asyncio
import websockets
import random
import json
def generate_food_position(min_x, max_x, min_y, max_y):
x = random.randint(min_x, max_x)
y = random.randint(min_y, max_y)
return [x, y, 20, 20]
rooms = {}
def collide(a , b , width):
return (abs(a[0] - b[0]) < width and
abs(a[1] - b[1]) < width)
# detecting possible collides :
def collides(a , b , food ) :
head_to_head = collide(a[0] , b[0] ,30) ;
head_to_food = collide(a[0] , food ,25 )
head_to_body = False
this_head = a[0]
for part in b :
if collide(this_head , part ,30) :
head_to_body = True
break
return (head_to_head , head_to_body , head_to_food)
# return response as (act ,opponents position(s) , my position(s) , the food and the scores)
def formulate_response(id , oid , food , roomName) :
this= rooms[roomName][id]['pos']
other= rooms[roomName][oid]['pos']
hh , hb , hf = collides(this ,other ,food)
act = 'None'
if hh :
act = 'shrink'
rooms[roomName][id]['pos'] = initPlayer()
rooms[roomName][id]['score'] =0
# rooms[roomName][oid]['pos'] = initPlayer()
# rooms[roomName][oid]['respawn'] = True
elif hb :
act = 'shrink'
rooms[roomName][id]['pos'] = initPlayer()
rooms[roomName][id]['score'] = 0
elif hf :
act = 'grow'
rooms[roomName]['food'] = generate_food_position(20, 580, 20, 380)
rooms[roomName][id]['score']+=1
return {
'act' : act ,
'opp' : rooms[roomName][oid]['pos'] ,
'my' : rooms[roomName][id]['pos'] ,
'food': rooms[roomName]['food'] ,
'my_score' : rooms[roomName][id]['score'] ,
'other_score' : rooms[roomName][oid]['score']
}
def initPlayer():
return [[random.randint(30 , 600 ) , random.randint(30 , 400 ) , 30 , 30 ]]
async def handler(websocket) :
handshake = await websocket.recv()
handshake = json.loads(handshake)
roomName = handshake["room"]
if handshake['choice'] == 1 :
rooms[roomName] = {}
rooms[roomName]['food'] =generate_food_position(30 ,570 ,30 ,370)
rooms[roomName][websocket.id] = {
'socket' : websocket ,
'pos' : initPlayer() ,
'respawn' : False ,
'score' :0
}
if len(rooms[roomName]) >= 3 :
await broadcast(rooms[roomName])
id = websocket.id
while True :
room = rooms[roomName]
this_pos = await websocket.recv()
## synchrnisation issue with this
## after couple of times they collide head to head
## the cordinates shown on the screen aren't same
## as the server
if room[id]['respawn']==True :
rooms[roomName][id]['respawn'] = False
# generate response :
response = {
'act' : 'shrinkall',
'my' : room[id]['pos'] ,
'opp' : get_other_pos(get_other_id(id ,room),room),
'food': room['food']
}
await websocket.send(json.dumps(response))
else :
# update player position
this_pos = json.loads(this_pos)
rooms[roomName][id]['pos'] = this_pos['pos']
rooms[roomName][id]['len'] = this_pos['len']
other_id = get_other_id(id , room)
food = room['food']
response = formulate_response(id ,other_id ,food ,roomName)
await websocket.send(json.dumps(response))
def get_other_id(id , room) :
for thing in room.keys():
if thing != 'food' and thing != id :
return thing
def get_other_pos(id , room) :
return room[id]['pos']
async def broadcast(room) :
for thing in room.keys() :
if thing!= 'food' :
init = {
'my' : room[thing]['pos'] ,
'opp' : room[get_opp(thing, room)]['pos'] ,
'food': room['food']
}
await room[thing]['socket'].send(json.dumps(init))
def get_opp(id , room) :
for thing in room.keys() :
if thing!= 'food' and thing != id:
return thing
async def main():
async with websockets.serve(handler , 'localhost' ,8765 ):
await asyncio.Future()
if __name__ == '__main__' :
print('listenning ... ')
asyncio.run(main())
Salin selepas log masuk
ia mengendalikan pergerakan pemain, perlanggaran dan interaksi. Ia menjana makanan, mengesan perlanggaran dan menyegerakkan keadaan permainan antara pemain. Pelayan juga menguruskan sambungan pemain dan menolak kemas kini permainan
Dan di sana anda mempunyai permainan ular berbilang pemain yang boleh menjadi perkara besar seterusnya dalam dunia permainan. Siapa tahu, ia mungkin akan pergi ke persidangan teknologi besar seterusnya!
Buat masa ini, mengapa tidak mencuba dan melihat perkara yang boleh anda tambahkan? Lihat repo GitHub dan buat tanda anda pada perkara besar seterusnya dalam permainan ular.
Selamat mengekod!
Atas ialah kandungan terperinci Membina Sesuatu yang Bukan Apl Todo: Permainan Ular Berbilang Pemain Dalam Talian. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
