pacman.py

Created by fedyna-kevin

Created on October 31, 2020

8.74 KB

Rond comme un ballon, et plus jaune qu’un citron, c’est lui !

Pac-Man débarque sur ta NumWorks !

Aide le à manger toutes les pac-gommes en évitant les fantômes et accumule le plus grand score. Pour cela, tu peux :
- Manger des pac-gommes (10)
- Manger des super pac-gommes (50)
- Manger les fantômes (200, 400, 800, puis 1600)

Si tu manges tout les fantômes a chaque super pac-gommes, tu obtiendras même un bonus de 12000 points !

Bon jeu !


from kandinsky import fill_rect, draw_string
from ion import keydown
from math import sqrt
from random import randint
from time import monotonic

try:
    from kandinsky import get_keys
    color = (192, 53, 53)
except:
    color = (255, 183, 52)

terrain = (262143,131841,187245,187245,131073,186285,135969,252783,249903,251823,1152,251823,249903,251823,131841,187245,147465,219051,135969,195453,131073,262143)
bits = 18
width = 320
height = 222
colors = ((0, 0, 0), (32, 48, 248), (248, 224, 8), tuple(color))
ghost_color = ((255, 184, 255), (255, 0,0), (255, 184, 82), (0, 255, 255))
pacgommes = [0,130302,9360,74898,131070,75858,126174,8208,8208,8208,8208,8208,8208,8208,130302,74898,49140,43092,126174,66690,131070,0]
superpacgommes = [0,0,65538,0,0,0,0,0,0,0,0,0,0,0,0,0,65538,0,0,0,0,0,0]
frightened = 0
lives = 2
won = 0
lvl = 0
score = 0
chained = 0


class Entity:
    def __init__(self, x, y, clr, d=0):
        self.x = x
        self.y = y
        self.d = d
        self.nd = d
        self.f = 0
        self.out = 0
        self.color = clr
        fill_rect(int(self.x*10)+136,int(self.y*10)-3,8,8,self.color)
    def espace(self,dx=-1,dy=-1):
        if dx == dy:
            dx, dy = ((-0.1,0),(0,-0.1),(0,0.1),(0.1,0))[self.nd]
        return not terrain[int(self.y + 5.5*dy)]>>(bits-1-int(self.x + 5.5*dx)) & 1 and ((dx != 0 and self.y%1 == 0.5) or (dy != 0 and self.x%1== 0.5))
    def move(self):
        global frightened, ghosts, score, chained, lives, total, won
        dx, dy = ((-0.1,0),(0,-0.1),(0,0.1),(0.1,0))[self.d]
        if self.espace(dx,dy):
            fill_rect(int(self.x*10)+136,int(self.y*10)-3,8,8,colors[0])
            self.x = (round(self.x + dx, 1) - 0.5) % 16.5 + 0.5
            self.y = round(self.y + dy, 1)
            fill_rect(int(self.x*10)+136,int(self.y*10)-3,8,8,self.color)
        if self.color == colors[2]:
            if pacgommes[int(self.y)] >> (bits - 1 - int(self.x)) & 1:
                pacgommes[int(self.y)] -= 1 << (bits - 1 - int(self.x))
                score += 10
            if superpacgommes[int(self.y)] >> (bits - 1 - int(self.x)) & 1:
                superpacgommes[int(self.y)] -= 1 << (bits - 1 - int(self.x))
                score += 50
                chained = 0
                frightened = monotonic()
                for g in ghosts:
                    if g.out:
                        g.color = colors[1]
                        g.d = (3, 2, 1, 0)[g.d]
                        g.f = 1
            for g in range(4):
                if sqrt((self.x-ghosts[g].x)**2+(self.y-ghosts[g].y)**2) < 0.6:
                    if ghosts[g].f:
                        chained += 1
                        total += 1
                        score += (1 << chained)*100
                        ghosts[g].f = 0
                        ghosts[g].color = ghost_color[g]
                        ghosts[g].x = 9
                        ghosts[g].y = 8.5
                        if total == 16:
                            score += 12000
                    else:
                        for gp in range(4):
                            ghosts[gp].f = 0
                            ghosts[gp].color = ghost_color[gp]
                            ghosts[gp].x = 9
                            ghosts[gp].y = 10.5
                            ghosts[gp].out = 0
                        self.x = 9
                        self.y = 16.5
                        self.d, self.nd = 0, 0
                        lives -= 1
                        return render()
            if not won and score > 10000:
                lives += 1
                won = 1
        px, py = int(self.x - 5.5*dx), int(self.y - 5.5*dy)
        if pacgommes[py]>>(bits-1-px) & 1:
            fill_rect(px*10+144,py*10+5,2,2,(250, 207, 173))
        if superpacgommes[py]>>(bits-1-px) & 1:
            fill_rect(px*10+143,py*10+4,4,4,(250, 207, 173))
    def ia(self,x,y):
        if self.f:
            while True:
                d = randint(0,3)
                dx, dy = ((-0.1,0),(0,-0.1),(0,0.1),(0.1,0))[d]
                if d != (3,2,1,0)[self.d] and self.espace(dx,dy):
                    self.d = d
                    break
        else:
            distances = [9999 for _ in range(4)]
            for i in range(4):
                if i != (3,2,1,0)[self.d]:
                    dx, dy = ((-0.1,0),(0,-0.1),(0,0.1),(0.1,0))[i]
                    if self.espace(dx,dy):
                        distances[i] = sqrt((self.y + dy - y)**2 + (self.x + dx - x)**2)
            self.d = distances.index(min(distances))

def prebuild():
    fill_rect(0,0,width,height,colors[0])
    fill_rect(138, 0, 2, height, colors[3])
    draw_string("PAC-MAN", 35, 10, colors[3], colors[0])
    draw_string("nsi.xyz/pacman", 0, 204,colors[0], colors[3])
    draw_string("Score :", 35, 40, (255,)*3, colors[0])
    draw_string("Niveau :", 30, 90, (255,)*3, colors[0])

def render():
    global terrain, pacgommes, superpacgommes, lives, arrivee
    if lives == -1:
        return 42
    draw_string(str(lvl),70-5*len(str(lvl)),110,(255,)*3,colors[0])
    fill_rect(0,150,138,20,colors[0])
    for i in range(lives):
        fill_rect(60-(lives-1)*20+i*40,150,20,20,colors[2])
    for l in range(len(terrain)):
        for c in range(bits):
            fill_rect(c*10+140,l*10+1,10,10,colors[0])
            if pacgommes[l]>>(bits-1-c) & 1:
                fill_rect(c*10+144,l*10+5,2,2,(250, 207, 173))
            if superpacgommes[l]>>(bits-1-c) & 1:
                fill_rect(c*10+143,l*10+4,4,4,(250, 207, 173))
            if terrain[l]>>(bits-1-c) & 1:
                for d in ((1,0),(0,1),(-1,0),(0,-1)):
                    if 0 <= l + d[0] <= len(terrain) - 1 and 0 <= c + d[1] <= bits - 1 and not terrain[l + d[0]]>>(bits-1-(c+d[1])) & 1:
                        fill_rect(c*10+140+9*(d[1]==1),l*10+1+9*(d[0]==1),1+9*(d[1]==0),1+9*(d[0]==0),colors[1])
    arrivee = monotonic()

def engine():
    global frightened, ghosts, pacgommes, superpacgommes, lvl, arrivee, total
    while True:
        pacgommes = [0,130302,9360,74898,131070,75858,126174,8208,8208,8208,8208,8208,8208,8208,130302,74898,49140,43092,126174,66690,131070,0]
        superpacgommes = [0,0,65538,0,0,0,0,0,0,0,0,0,0,0,0,0,65538,0,0,0,0,0,0]
        lvl += 1
        total = 0
        render()
        pacman = Entity(9, 16.5, colors[2])
        ghosts = [Entity(9, 10.5, ghost_color[i]) for i in range(4)]
        while sum(pacgommes) + sum(superpacgommes):
            depart = monotonic()
            for i in range(4):
                if keydown(i):
                    if i == (3,2,1,0)[pacman.d]:
                        pacman.d = i
                    pacman.nd = i
            while monotonic() - depart < 0.01:
                if pacman.espace():
                    pacman.d = pacman.nd
                if pacman.move() == 42:
                    draw_string("GAME OVER",185,100,colors[3],colors[0])
                    return 69

            draw_string(str(score),70-5*len(str(score)),60,(255,)*3,colors[0])

            """ Fantomes """

            if frightened:
                if monotonic() - frightened > 6.5:
                    for g in ghosts:
                        if g.f:
                            g.color = (255,)*3
                if monotonic() - frightened > 8.5:
                    frightened = 0
                    for g in range(4):
                        ghosts[g].color = ghost_color[g]
                        ghosts[g].f = 0

            if arrivee:
                if monotonic() - arrivee > 0 and not ghosts[1].out:
                    ghosts[1].out = 1
                    ghosts[1].y = 8.5
                if monotonic() - arrivee > 2.5 and not ghosts[0].out:
                    ghosts[0].out = 1
                    ghosts[0].y = 8.5
                if monotonic() - arrivee > 5 and not ghosts[3].out:
                    ghosts[3].out = 1
                    ghosts[3].y = 8.5
                if monotonic() - arrivee > 7.5 and not ghosts[2].out:
                    ghosts[2].out = 1
                    ghosts[2].y = 8.5
                    fill_rect(220,101,20,10,colors[0])
                    arrivee = 0

            pdx, pdy = ((-0.1,0),(0,-0.1),(0,0.1),(0.1,0))[pacman.d]

            # Pinky
            ghosts[0].ia(pacman.x + 20 * pdx, pacman.y + 20 * pdy)
            ghosts[0].move()

            # Inky
            ghosts[3].ia(max(min(ghosts[1].x + 2*(pacman.x + 20 * pdx - ghosts[1].x), 16.5), 1.5), max(min(ghosts[1].y +2*(pacman.y + 20 * pdy - ghosts[1].y), 21.5), 1.5))
            ghosts[3].move()

            # Blinky
            ghosts[1].ia(pacman.x, pacman.y)
            ghosts[1].move()

            # Clyde
            if sqrt((ghosts[2].x - pacman.x)**2 + (ghosts[2].y - pacman.y)**2) > 4:
                ghosts[2].ia(pacman.x, pacman.y)
            else:
                ghosts[2].ia(1.5, 20.5)
            ghosts[2].move()

prebuild()
engine()

During your visit to our site, NumWorks needs to install "cookies" or use other technologies to collect data about you in order to:

With the exception of Cookies essential to the operation of the site, NumWorks leaves you the choice: you can accept Cookies for audience measurement by clicking on the "Accept and continue" button, or refuse these Cookies by clicking on the "Continue without accepting" button or by continuing your browsing. You can update your choice at any time by clicking on the link "Manage my cookies" at the bottom of the page. For more information, please consult our cookies policy.