Cara menggunakan Python+Pygame untuk melaksanakan permainan empat catur

1. Penjelasan permainan

"Zou Si Er" kebanyakannya aktif di Jinan, Liaocheng, Heze dan tempat-tempat lain di Wilayah Shandong Ia adalah permainan catur, terutamanya sesuai untuk dicuba oleh kanak-kanak.

Pada papan catur 4×4, setiap sisi mempunyai 4 keping, yang diletakkan di empat kedudukan pada dua garisan hujung atas papan catur. Gambar di bawah

ialah rupa permainan "Go Four" pada mulanya.

2 Peraturan permainan

Peraturan permainan "Go Four" ialah:

1. Kedua-dua belah pihak bergilir-gilir untuk bergerak, dan setiap langkah hanya boleh menggerakkan satu petak dalam salah satu arah atas, bawah, kiri dan kanan, dan tidak boleh bergerak secara menyerong. Jika satu pihak tidak boleh bergerak, pihak yang lain pergi.

2． Apabila salah satu keping Parti A bergerak ke satu baris, hanya terdapat dua keping Parti A dan satu keping Pihak B pada baris ini, dan dua keping Pihak A disambungkan, dan kepingan Pihak B disambungkan ke satu daripada dua keping Pihak A . Jika kepingan itu disambung, maka kepingan Parti B akan dimakan.

Gambar di bawah adalah contoh gaya yang boleh ditangkap:

3. Bahagian yang kurang daripada 2 keping adalah yang kalah. Jika kedua-dua pihak tidak dapat mengalahkan pihak lain, ia boleh dianggap seri.

3. Pemasangan persekitaran

1) Bahan (gambar)

2) Persekitaran berjalan Persekitaran yang digunakan oleh editor: Python3, Pycharm Versi komuniti, Pygame dan modul numpy disertakan jadi saya tidak akan menunjukkannya satu per satu.

Pemasangan modul: pemasangan pip -i https://pypi.douban.com/simple/+nama modul

4 Paparan kod

import pygame as pg
from pygame.locals import *
import sys
import time
import numpy as np

pg.init()
size = width, height = 600, 400
screen = pg.display.set_mode(size)
f_clock = pg.time.Clock()
fps = 30
pg.display.set_caption("走四棋儿")
background = pg.image.load("background.png").convert_alpha()
glb_pos = [[(90, 40), (190, 40), (290, 40), (390, 40)],
           [(90, 140), (190, 140), (290, 140), (390, 140)],
           [(90, 240), (190, 240), (290, 240), (390, 240)],
           [(90, 340), (190, 340), (290, 340), (390, 340)]]


class ChessPieces():
    def __init__(self, img_name):
        self.name = img_name
        self.id = None
        if self.name == 'heart':
            self.id = 2
        elif self.name == 'spade':
            self.id = 3
        self.img = pg.image.load(img_name + ".png").convert_alpha()
        self.rect = self.img.get_rect()
        self.pos_x, self.pos_y = 0, 0
        self.alive_state = True

    def get_rect(self):
        return (self.rect[0], self.rect[1])

    def get_pos(self):
        return (self.pos_x, self.pos_y)

    def update(self):
        if self.alive_state == True:
            self.rect[0] = glb_pos[self.pos_y][self.pos_x][0]
            self.rect[1] = glb_pos[self.pos_y][self.pos_x][1]
            screen.blit(self.img, self.rect)


class Pointer():
    def __init__(self):
        self.img = pg.image.load("pointer.png").convert_alpha()
        self.rect = self.img.get_rect()
        self.show = False
        self.selecting_item = False

    def point_to(self, Heart_Blade_class):
        if Heart_Blade_class.alive_state:
            self.pointing_to_item = Heart_Blade_class
            self.item_pos = Heart_Blade_class.get_rect()
            self.rect[0], self.rect[1] = self.item_pos[0], self.item_pos[1] - 24

    def update(self):
        screen.blit(self.img, self.rect)


class GlobalSituation():
    def __init__(self):
        self.glb_situation = np.array([[2, 2, 2, 2],
                                       [0, 0, 0, 0],
                                       [0, 0, 0, 0],
                                       [3, 3, 3, 3]], dtype=np.uint8)
        self.spade_turn = None

    def refresh_situation(self):
        self.glb_situation = np.zeros([4, 4], np.uint8)
        for i in range(4):
            if heart[i].alive_state:
                self.glb_situation[heart[i].pos_y, heart[i].pos_x] = heart[i].id
        for i in range(4):
            if spade[i].alive_state:
                self.glb_situation[spade[i].pos_y, spade[i].pos_x] = spade[i].id
        for i in range(4):
            print(self.glb_situation[i][:])
        print('=' * 12)
        if self.spade_turn != None:
            self.spade_turn = not self.spade_turn

    def check_situation(self, moved_item):
        curr_pos_x, curr_pos_y = moved_item.get_pos()
        curr_pos_col = self.glb_situation[:, curr_pos_x]
        curr_pos_raw = self.glb_situation[curr_pos_y, :]
        enemy_die = False
        if moved_item.id == 2:
            if np.sum(curr_pos_col) == 7:
                if (curr_pos_col == np.array([0, 2, 2, 3])).all():
                    enemy_die = True
                    self.glb_situation[3, curr_pos_x] = 0
                    for spade_i in spade:
                        if spade_i.alive_state and spade_i.pos_x == curr_pos_x and spade_i.pos_y == 3:
                            spade_i.alive_state = False
                elif (curr_pos_col == np.array([2, 2, 3, 0])).all():
                    enemy_die = True
                    self.glb_situation[2, curr_pos_x] = 0
                    for spade_i in spade:
                        if spade_i.alive_state and spade_i.pos_x == curr_pos_x and spade_i.pos_y == 2:
                            spade_i.alive_state = False
                elif (curr_pos_col == np.array([0, 3, 2, 2])).all():
                    enemy_die = True
                    self.glb_situation[1, curr_pos_x] = 0
                    for spade_i in spade:
                        if spade_i.alive_state and spade_i.pos_x == curr_pos_x and spade_i.pos_y == 1:
                            spade_i.alive_state = False
                elif (curr_pos_col == np.array([3, 2, 2, 0])).all():
                    enemy_die = True
                    self.glb_situation[0, curr_pos_x] = 0
                    for spade_i in spade:
                        if spade_i.alive_state and spade_i.pos_x == curr_pos_x and spade_i.pos_y == 0:
                            spade_i.alive_state = False
            if np.sum(curr_pos_raw) == 7:
                if (curr_pos_raw == np.array([0, 2, 2, 3])).all():
                    enemy_die = True
                    self.glb_situation[curr_pos_y, 3] = 0
                    for spade_i in spade:
                        if spade_i.alive_state and spade_i.pos_x == 3 and spade_i.pos_y == curr_pos_y:
                            spade_i.alive_state = False
                elif (curr_pos_raw == np.array([2, 2, 3, 0])).all():
                    enemy_die = True
                    self.glb_situation[curr_pos_y, 2] = 0
                    for spade_i in spade:
                        if spade_i.alive_state and spade_i.pos_x == 2 and spade_i.pos_y == curr_pos_y:
                            spade_i.alive_state = False
                elif (curr_pos_raw == np.array([0, 3, 2, 2])).all():
                    enemy_die = True
                    self.glb_situation[curr_pos_y, 1] = 0
                    for spade_i in spade:
                        if spade_i.alive_state and spade_i.pos_x == 1 and spade_i.pos_y == curr_pos_y:
                            spade_i.alive_state = False
                elif (curr_pos_raw == np.array([3, 2, 2, 0])).all():
                    enemy_die = True
                    self.glb_situation[curr_pos_y, 0] = 0
                    for spade_i in spade:
                        if spade_i.alive_state and spade_i.pos_x == 0 and spade_i.pos_y == curr_pos_y:
                            spade_i.alive_state = False
        elif moved_item.id == 3:
            if np.sum(curr_pos_col) == 8:
                if (curr_pos_col == np.array([0, 3, 3, 2])).all():
                    enemy_die = True
                    self.glb_situation[3, curr_pos_x] = 0
                    for heart_i in heart:
                        if heart_i.alive_state and heart_i.pos_x == curr_pos_x and heart_i.pos_y == 3:
                            heart_i.alive_state = False
                elif (curr_pos_col == np.array([3, 3, 2, 0])).all():
                    enemy_die = True
                    self.glb_situation[2, curr_pos_x] = 0
                    for heart_i in heart:
                        if heart_i.alive_state and heart_i.pos_x == curr_pos_x and heart_i.pos_y == 2:
                            heart_i.alive_state = False
                elif (curr_pos_col == np.array([0, 2, 3, 3])).all():
                    enemy_die = True
                    self.glb_situation[1, curr_pos_x] = 0
                    for heart_i in heart:
                        if heart_i.alive_state and heart_i.pos_x == curr_pos_x and heart_i.pos_y == 1:
                            heart_i.alive_state = False
                elif (curr_pos_col == np.array([2, 3, 3, 0])).all():
                    enemy_die = True
                    self.glb_situation[0, curr_pos_x] = 0
                    for heart_i in heart:
                        if heart_i.alive_state and heart_i.pos_x == curr_pos_x and heart_i.pos_y == 0:
                            heart_i.alive_state = False
            if np.sum(curr_pos_raw) == 8:
                if (curr_pos_raw == np.array([0, 3, 3, 2])).all():
                    enemy_die = True
                    self.glb_situation[curr_pos_y, 3] = 0
                    for heart_i in heart:
                        if heart_i.alive_state and heart_i.pos_x == 3 and heart_i.pos_y == curr_pos_y:
                            heart_i.alive_state = False
                elif (curr_pos_raw == np.array([3, 3, 2, 0])).all():
                    enemy_die = True
                    self.glb_situation[curr_pos_y, 2] = 0
                    for heart_i in heart:
                        if heart_i.alive_state and heart_i.pos_x == 2 and heart_i.pos_y == curr_pos_y:
                            heart_i.alive_state = False
                elif (curr_pos_raw == np.array([0, 2, 3, 3])).all():
                    enemy_die = True
                    self.glb_situation[curr_pos_y, 1] = 0
                    for heart_i in heart:
                        if heart_i.alive_state and heart_i.pos_x == 1 and heart_i.pos_y == curr_pos_y:
                            heart_i.alive_state = False
                elif (curr_pos_raw == np.array([2, 3, 3, 0])).all():
                    enemy_die = True
                    self.glb_situation[curr_pos_y, 0] = 0
                    for heart_i in heart:
                        if heart_i.alive_state and heart_i.pos_x == 0 and heart_i.pos_y == curr_pos_y:
                            heart_i.alive_state = False
        if enemy_die == True:
            self.glb_situation = np.zeros([4, 4], np.uint8)
            for i in range(4):
                if heart[i].alive_state:
                    self.glb_situation[heart[i].pos_y, heart[i].pos_x] = heart[i].id
            for i in range(4):
                if spade[i].alive_state:
                    self.glb_situation[spade[i].pos_y, spade[i].pos_x] = spade[i].id
            for i in range(4):
                print(self.glb_situation[i][:])
            print('=' * 12)

    def check_game_over(self):
        heart_alive_num, spade_alive_num = 0, 0
        for heart_i in heart:
            if heart_i.alive_state:
                heart_alive_num += 1
        for spade_i in spade:
            if spade_i.alive_state:
                spade_alive_num += 1
        if heart_alive_num <= 1:
            print(&#39;Spades win!&#39;)
            GlobalSituation.__init__(self)
            Pointer.__init__(self)
            chess_pieces_init()
        if spade_alive_num <= 1:
            print(&#39;Hearts win!&#39;)
            GlobalSituation.__init__(self)
            Pointer.__init__(self)
            chess_pieces_init()


heart, spade = [None] * 4, [None] * 4
for i in range(4):
    heart[i] = ChessPieces(&#39;heart&#39;)
    spade[i] = ChessPieces(&#39;spade&#39;)


def chess_pieces_init():
    for i in range(4):
        heart[i].pos_y, heart[i].pos_x = 0, i
        spade[i].pos_y, spade[i].pos_x = 3, i
        heart[i].alive_state = True
        spade[i].alive_state = True

chess_pieces_init()
pointer = Pointer()
situation = GlobalSituation()


def check_click_item(c_x, c_y):
    selected_item = None
    if situation.spade_turn==None:
        for heart_i in heart:
            if heart_i.alive_state and heart_i.rect.collidepoint(c_x, c_y):
                situation.spade_turn = False
                selected_item = heart_i

        for spade_i in spade:
            if spade_i.alive_state and spade_i.rect.collidepoint(c_x, c_y):
                situation.spade_turn = True
                selected_item = spade_i

    else:
        if situation.spade_turn:
            for spade_i in spade:
                if spade_i.alive_state and spade_i.rect.collidepoint(c_x, c_y):
                    selected_item = spade_i
        else:
            for heart_i in heart:
                if heart_i.alive_state and heart_i.rect.collidepoint(c_x, c_y):
                    selected_item = heart_i
    return selected_item


def move_to_dst_pos(selected_item, c_x, c_y):
    update_situation = False
    enemy_exist = False
    if selected_item.name == &#39;heart&#39;:
        for spade_i in spade:
            if spade_i.rect.collidepoint(c_x, c_y) and spade_i.alive_state:
                enemy_exist = True
    elif selected_item.name == &#39;spade&#39;:
        for heart_i in heart:
            if heart_i.rect.collidepoint(c_x, c_y) and heart_i.alive_state:
                enemy_exist = True
    if enemy_exist == False:
        delta_y, delta_x = c_y - selected_item.rect[1], c_x - selected_item.rect[0]
        if 80 <= abs(delta_x) <= 120 and abs(delta_y) <= 20:
            if delta_x < 0:
                if selected_item.pos_x > 0:
                    selected_item.pos_x -= 1
            else:
                if selected_item.pos_x < 3:
                    selected_item.pos_x += 1
            update_situation = True
        if 80 <= abs(delta_y) <= 120 and abs(delta_x) <= 20:
            if delta_y < 0:
                if selected_item.pos_y > 0:
                    selected_item.pos_y -= 1
            else:
                if selected_item.pos_y < 3:
                    selected_item.pos_y += 1
            update_situation = True
    return update_situation


while True:
    for event in pg.event.get():
        if event.type == pg.QUIT:
            sys.exit()
        elif event.type == pg.MOUSEBUTTONDOWN:
            cursor_x, cursor_y = pg.mouse.get_pos()
            clicked_item = check_click_item(cursor_x, cursor_y)
            if clicked_item != None:
                pointer.selecting_item = True
                pointer.point_to(clicked_item)
            else:
                if pointer.selecting_item:
                    update_situation_flag = move_to_dst_pos(pointer.pointing_to_item, cursor_x, cursor_y)
                    if update_situation_flag:
                        situation.refresh_situation()
                        situation.check_situation(pointer.pointing_to_item)
                        situation.check_game_over()
                pointer.selecting_item = False
    screen.blit(background, (0, 0))
    for heart_i in heart:
        heart_i.update()
    for spade_i in spade:
        spade_i.update()
    if pointer.selecting_item:
        pointer.update()
    f_clock.tick(fps)
    pg.display.update()

5 🎜>

Atas ialah kandungan terperinci Cara menggunakan Python+Pygame untuk melaksanakan permainan empat catur. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!