Beispiel #1
0
class Gra:
    TLO = (255, 255, 255)
    KOLORY = {
        (255, 255, 255): 0,
        (0, 0, 0): 1,
    }  # Słownik przechowujący biały i czarny

    def __init__(self, win, connection=None):
        pygame.font.init()
        self.connection = connection
        self.win = win  #okno do wyswietlania
        #inicjalizacja parametrow
        self.ranking = Ranking(50, 125)
        self.tablica = Tablica(305, 125)
        self.pasek_gorny = PasekGorny(50, 10, 990, 100)
        self.pasek_gorny.zmiana_rundy(1)
        self.gracze = []
        self.pomin_button = PrzyciskTekstowy(810, 555, 225, 50, (255, 255, 0),
                                             "Pomin")
        self.pasek_dolny = PasekDolny(305, 880, self)
        self.chat = Chat(810, 125)
        self.kolor_rysowania = (0, 0, 0)
        self.rysujacy = False

    def dodaj_gracza(self, gracz):
        self.gracze.append(gracz)
        self.ranking.dodaj_gracza(gracz)

    def rysuj(self):

        self.win.fill(self.TLO)
        self.ranking.rysuj(self.win)
        self.pasek_gorny.rysuj(self.win)
        self.tablica.rysuj(self.win)
        self.pomin_button.rysuj(self.win)

        if self.rysujacy:
            self.pasek_dolny.rysuj(self.win)
        self.chat.rysuj(self.win)
        pygame.display.update()

    def obsluga_przyciskow(self):

        mouse = pygame.mouse.get_pos()
        # pominięcie rundy
        if self.pomin_button.klikniecie(*mouse) and not self.rysujacy:
            pominiete_rundy = self.connection.send({1: []})

        kliknieta_tablica = self.tablica.klikniecie(*mouse)
        #rysowanie
        if kliknieta_tablica:
            self.tablica.update(*kliknieta_tablica, self.kolor_rysowania)
            self.connection.send({
                8:
                [*kliknieta_tablica, self.KOLORY[tuple(self.kolor_rysowania)]]
            })

    def run(self):
        run = True
        clock = pygame.time.Clock()
        while run:
            clock.tick(60)

            try:

                odpowiedz = self.connection.send({3: []})
                if odpowiedz:
                    self.tablica.podzielona_tablica = odpowiedz
                    self.tablica.dzielenie_tablicy()

                odpowiedz = self.connection.send({9: []})
                self.pasek_gorny.czas = odpowiedz

                ################################################
                #KOD DO ZADANIA 3
                ###############################################

                self.pasek_gorny.haslo = self.connection.send({6: []})
                self.pasek_gorny.runda = self.connection.send({5: []})
                self.rysujacy = self.connection.send({11: []})
                self.pasek_gorny.rysujacy = self.rysujacy
                self.pasek_gorny.max_rund = len(self.gracze)

                odpowiedz = self.connection.send({4: []})
                for gracz in self.gracze:
                    if odpowiedz != []:
                        gracz.ustaw_wynik(odpowiedz[gracz.get_nazwa()])

            except:
                run = False
                break

            self.rysuj()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    run = False
                    break

                if pygame.mouse.get_pressed()[0]:
                    self.obsluga_przyciskow()
                    self.pasek_dolny.obsluga_przyciskow()

                if event.type == pygame.KEYDOWN:
                    if not self.rysujacy:
                        if event.key == pygame.K_RETURN:
                            self.connection.send({0: [self.chat.pisanie]})
                            self.chat.pisanie = ""
                        else:

                            key_name = pygame.key.name(event.key)

                            key_name = key_name.lower()
                            self.chat.type(key_name)

        pygame.quit()
Beispiel #2
0
class Gra(object):
    def __init__(self, id, gracze):

        self.id = id
        self.gracze = gracze
        self.uzyte_hasla = set()  #stworzenie pustego zbioru
        self.runda = None  # None - obiekt pusty, zaznaczeni, że wartość jest dostępna, ale póki co nie jest określona
        self.tablica = Tablica()
        self.rysujacy_id = 0
        self.liczba_rund = 1
        self.nowa_runda()  # wywołanie funkcji nowa_runda

    def nowa_runda(self):
        # Przy każdej rundzie wartość licznika rund oraz indeks gracza rysującego zostanie zinkrementowany, dzięki czemu będzie wiadomo kiedy odbyły
        #sie wszystkie kolejki i należy już zakończyć grę
        try:
            self.runda = Runda(self.get_haslo(), self.gracze[self.rysujacy_id],
                               self)
            self.liczba_rund += 1

            if self.rysujacy_id >= len(self.gracze):
                self.koniec_rundy()
                self.koniec_gry()

            self.rysujacy_id += 1
        except Exception as e:
            self.koniec_gry()

    def proba_zgadniecia(self, gracz, haslo):

        return self.runda.zgadywanie(gracz, haslo)

    def get_wyniki_gracza(self):

        wyniki = {gracz.nazwa: gracz.get_wynik() for gracz in self.gracze}
        return wyniki

    def pomin(self, gracz):

        if self.runda:
            nowa_runda = self.runda.pomin(gracz)
            if nowa_runda:
                self.runda.chat.update_chat("Pominięto rundę")
                self.koniec_rundy()
                return True
            return False
        else:
            raise Exception("Runda jeszcze nie została rozpoczęta")

    def koniec_rundy(self):

        self.runda.chat.update_chat(
            f"Runda {self.liczba_rund} została zakończona.")
        self.nowa_runda()
        self.tablica.czyszczenie()

    def update_tablica(self, x, y, kolor):

        if not self.tablica:
            raise Exception("Nie utworzono tablicy")
        self.tablica.update(x, y, kolor)

    def koniec_gry(self):

        print(f" Gra {self.id} skończyła się")
        for gracz in self.gracze:
            gracz.gra = None

    def get_haslo(self):

        with open("hasla.txt", "r") as f:
            hasla = []

            for line in f:
                haslo = line.strip()
                if haslo not in self.uzyte_hasla:
                    hasla.append(haslo)

        haslo = random.choice(hasla)
        self.uzyte_hasla.add(haslo)

        return haslo