Open source - Python și Pygame

Python si Pygame - creați jocuri







Python este un limbaj de programare dinamic multi-paradigmă, creat în 1989 de olandezul Guido van Rossum. Van Rossum continuă și în ziua de astăzi a fi un lider al comunității de dezvoltatori care continuă să perfecționeze limbajul Python și implementarea de bază a acestuia, CPython, scrisă în C. Python este folosit de companii și organizații ca NASA, Google, Yahoo!, utilizat ca limbaj de scriere în multe aplicații, inclusiv aplicații lider în sfera graficii 3D. Multe sisteme bazate pe Unix, inclusiv Linux, BSD și Mac OS X includ din start interpretorul Cpython.











 Dar Python este puternic tipat, adică interpretatorul nu permite operații de tip cast ca în C, deși sunt unele excepții logice ca lucrul cu numere întregi și numere float.








 Pygame este un modul multi platforma al python, construit pentru realizarea jocurilor care include si o librarie sonora pentru a fi utilizata cu limbajul Python. Libraria Pygame a fost scrisa de pete Shinners și a fost lansata sub licență free. 



Descarcare și instalare Python

Software-ul Python poate fi descarcat de pe site-ul oficial http://www.python.org . 




 Dar Python este puternic tipat, adică interpretatorul nu permite operații de tip cast ca în C, deși sunt unele excepții logice ca lucrul cu numere întregi și numere float.










Python este un limbaj de programare dinamic multi-paradigmă, creat în 1989 de olandezul Guido van Rossum. Van Rossum continuă și în ziua de astăzi a fi un lider al comunității de dezvoltatori care continuă să perfecționeze limbajul Python și implementarea de bază a acestuia, CPython, scrisă în C. Python este folosit de companii și organizații ca NASA, Google, Yahoo!, utilizat ca limbaj de scriere în multe aplicații, inclusiv aplicații lider în sfera graficii 3D. Multe sisteme bazate pe Unix, inclusiv Linux, BSD și Mac OS X includ din start interpretorul Cpython.



Limbajele dinamice sunt deseori caracterizate prin tipizare dinamică, sunt interpretate, au management de memorie automatizat (garbage collecting) și au un nivel înalt de abstractizare. Tipizarea dinamică permite declararea variabilelor fară declararea tipului variabilei, interpretatorul determinînd tipul variabilei după conținutul sau operațiile efectuate.



 Dar Python este puternic tipat, adică interpretatorul nu permite operații de tip cast ca în C, deși sunt unele excepții logice ca lucrul cu numere întregi și numere float.



 Python este un limbaj multi-paradigmă, concentrându-se asupra programării imperative, orientate pe obiecte și funcționale, ceea ce permite o flexibilitate mai înaltă în scrierea aplicațiilor. Din punctul de vedere al sintaxei, Python are un număr de contrucții și cuvinte cheie cunoscute oricărui programator, dar prezintă și un concept unic: nivelul de indentare are semnificație sintactică. Blocurile de cod sunt delimitate prin simplă indentare. În C un astfel de blocuri sunt deseori desemnte prin paranteze acolade, {<cod>}, dar în Python nu este nevoie de astfel de construcții. Nivelele de indentare poartă același rol. Această importanță a indentării este foarte suprinzătoare pentru mulți noi utilizatori ai limbajului Python, chiar dacă sunt programatori cu experiență. Dar o astfel de utilizare a indentării permite codului să fie mai ușor de citit și mai compact. Programatorii cu experiență oricum indentează codul sursă, oricare ar fi limbajul, fiindcă aceasta permite a structura codul sursă și al face mai citeț și mai pe înțelese, iar Python face din această deprindere folositoare o cerință strictă. Un exemplu analogic ar fi Java, care forțează programatorii să delimiteze clasele în fișiere aparte, din motive de organizare și sporire a eficienței de scriere a softului în echipe.

Python programare


Pe un sistem Ubuntu 12.10 deschideti un terminal si introduceti urmatoarea comanda:

----------------------------------------------------------------------------

#python

#Python 2.7.3 (default, Sep 26 2012, 21:53:58)

#[GCC 4.7.2] on linux2

# Type "help", "copyright", "credits" or "licence" for more information.

# >>>

# pt. a iesi din python executati comanda Ctrl+D si intrati din nou in terminal

# in terminal rulati comanda $ mkdir mystuff

# $ cd mystuff

# folositi editorul de texte pentru a edita fila test.txt

# $ ls

# test.txt

# $

# tot ce va trebuie este programul gedit pt. a scrie programe, python pt. a le

# rula

print "Salut eu sunt un program Python"

print "Sunt Mihai C. si va scriu acest tutorial pt Python"

print " Data: 25.05.2013"

print " pt a rula programul rulati python ex1.py"

-----------------------------------------------------------------------------

Python joc de antrenarea memoriei

În jocul de pazzle, pe care îl vom prezenta in urmatoarele pagini, ne vom folosi de niste patrațele albe care vor acoperi un numar de doua imagini asemanătoare. Jucătorul poate apasa două patrațele pentru a vedea ce este dedesupt, daca imaginile sunt la fel acestea răman descoperite. Jucatorul câștigă atunci când toate imaginile sunt descoperite. Pentru a oferi un avantaj jucătorului la inceputul jocului imaginile vor fi afisate pentru scurt timp.

Inainte de a purcede la treabă, vom explica un concept care va fi folosit in aproape toate jocurile. Ciclurile for imbricate și constă in folosirea unui ciclu for in corpul altui ciclu for, de exemplu in shell-ul Python:

Python 2.7.3 (default, Aug 1 2012, 05:16:07) [GCC 4.6.3] on linux2 Type "copyright", "credits" or "license()" for more information. ==== No Subprocess ==== >>> for x in [0, 1, 2, 3, 4]: for y in ['a', 'b', 'c']: print(x, y) (0, 'a') (0, 'b') (0, 'c') (1, 'a') (1, 'b') (1, 'c') (2, 'a') (2, 'b') (2, 'c') (3, 'a') (3, 'b') (3, 'c') (4, 'a') (4, 'b') (4, 'c') >>>

Ciclurile for imbricate sunt utilizate pentru a combina liste. Daca schimbam ordinea ciclurilor for, rezultatul este urmatorul:

>>> for y in ['a', 'b', 'c']: for x in [0, 1, 2, 3, 4]: print(x, y) (0, 'a') (1, 'a') (2, 'a') (3, 'a') (4, 'a') (0, 'b') (1, 'b') (2, 'b') (3, 'b') (4, 'b') (0, 'c') (1, 'c') (2, 'c') (3, 'c') (4, 'c') >>>

În jocul nostru, avem nevoie de ciclurile for pentru a itera pe coordonatele X și Y ale ferestrei pentru a ne asigura ca am epuizat toate combinatiile.

Codul jocului de puzzle - integral si functional

# Memory Puzzle

# By Al Sweigart al@inventwithpython.com

# http://inventwithpython.com/pygame

# Released under a "Simplified BSD" license

import random, pygame, sys

from pygame.locals import *

FPS = 30 # frames per second, the general speed of the program

WINDOWWIDTH = 640 # size of window's width in pixels

WINDOWHEIGHT = 480 # size of windows' height in pixels

REVEALSPEED = 8 # speed boxes' sliding reveals and covers

BOXSIZE = 40 # size of box height & width in pixels

GAPSIZE = 10 # size of gap between boxes in pixels

BOARDWIDTH = 10 # number of columns of icons

BOARDHEIGHT = 7 # number of rows of icons

assert (BOARDWIDTH * BOARDHEIGHT) % 2 == 0, 'Board needs to have an even number of boxes for pairs of matches.'

XMARGIN = int((WINDOWWIDTH - (BOARDWIDTH * (BOXSIZE + GAPSIZE))) / 2)

YMARGIN = int((WINDOWHEIGHT - (BOARDHEIGHT * (BOXSIZE + GAPSIZE))) / 2)

#            R    G    B

GRAY     = (100, 100, 100)

NAVYBLUE = ( 60,  60, 100)

WHITE    = (255, 255, 255)

RED      = (255,   0,   0)

GREEN    = (  0, 255,   0)

BLUE     = (  0,   0, 255)

YELLOW   = (255, 255,   0)

ORANGE   = (255, 128,   0)

PURPLE   = (255,   0, 255)

CYAN     = (  0, 255, 255)

BGCOLOR = NAVYBLUE

LIGHTBGCOLOR = GRAY

BOXCOLOR = WHITE

HIGHLIGHTCOLOR = BLUE

DONUT = 'donut'

SQUARE = 'square'

DIAMOND = 'diamond'

LINES = 'lines'

OVAL = 'oval'

ALLCOLORS = (RED, GREEN, BLUE, YELLOW, ORANGE, PURPLE, CYAN)

ALLSHAPES = (DONUT, SQUARE, DIAMOND, LINES, OVAL)

assert len(ALLCOLORS) * len(ALLSHAPES) * 2 >= BOARDWIDTH * BOARDHEIGHT, "Board is too big for the number of shapes/colors defined."

def main():

    global FPSCLOCK, DISPLAYSURF

    pygame.init()

    FPSCLOCK = pygame.time.Clock()

    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))

    mousex = 0 # used to store x coordinate of mouse event

    mousey = 0 # used to store y coordinate of mouse event

    pygame.display.set_caption('Memory Game')

    mainBoard = getRandomizedBoard()

    revealedBoxes = generateRevealedBoxesData(False)

    firstSelection = None # stores the (x, y) of the first box clicked.

    DISPLAYSURF.fill(BGCOLOR)

    startGameAnimation(mainBoard)

    while True: # main game loop

        mouseClicked = False

        DISPLAYSURF.fill(BGCOLOR) # drawing the window

        drawBoard(mainBoard, revealedBoxes)

        for event in pygame.event.get(): # event handling loop

            if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):

                pygame.quit()

                sys.exit()

            elif event.type == MOUSEMOTION:

                mousex, mousey = event.pos

            elif event.type == MOUSEBUTTONUP:

                mousex, mousey = event.pos

                mouseClicked = True

        boxx, boxy = getBoxAtPixel(mousex, mousey)

        if boxx != None and boxy != None:

            # The mouse is currently over a box.

            if not revealedBoxes[boxx][boxy]:

                drawHighlightBox(boxx, boxy)

            if not revealedBoxes[boxx][boxy] and mouseClicked:

                revealBoxesAnimation(mainBoard, [(boxx, boxy)])

                revealedBoxes[boxx][boxy] = True # set the box as "revealed"

                if firstSelection == None: # the current box was the first box clicked

                    firstSelection = (boxx, boxy)

                else: # the current box was the second box clicked

                    # Check if there is a match between the two icons.

                    icon1shape, icon1color = getShapeAndColor(mainBoard, firstSelection[0], firstSelection[1])

                    icon2shape, icon2color = getShapeAndColor(mainBoard, boxx, boxy)

                    if icon1shape != icon2shape or icon1color != icon2color:

                        # Icons don't match. Re-cover up both selections.

                        pygame.time.wait(1000) # 1000 milliseconds = 1 sec

                        coverBoxesAnimation(mainBoard, [(firstSelection[0], firstSelection[1]), (boxx, boxy)])

                        revealedBoxes[firstSelection[0]][firstSelection[1]] = False

                        revealedBoxes[boxx][boxy] = False

                    elif hasWon(revealedBoxes): # check if all pairs found

                        gameWonAnimation(mainBoard)

                        pygame.time.wait(2000)

                        # Reset the board

                        mainBoard = getRandomizedBoard()

                        revealedBoxes = generateRevealedBoxesData(False)

                        # Show the fully unrevealed board for a second.

                        drawBoard(mainBoard, revealedBoxes)

                        pygame.display.update()

                        pygame.time.wait(1000)

                        # Replay the start game animation.

                        startGameAnimation(mainBoard)

                    firstSelection = None # reset firstSelection variable

        # Redraw the screen and wait a clock tick.

        pygame.display.update()

        FPSCLOCK.tick(FPS)

def generateRevealedBoxesData(val):

    revealedBoxes = []

    for i in range(BOARDWIDTH):

        revealedBoxes.append([val] * BOARDHEIGHT)

    return revealedBoxes

def getRandomizedBoard():

    # Get a list of every possible shape in every possible color.

    icons = []

    for color in ALLCOLORS:

        for shape in ALLSHAPES:

            icons.append( (shape, color) )

    random.shuffle(icons) # randomize the order of the icons list

    numIconsUsed = int(BOARDWIDTH * BOARDHEIGHT / 2) # calculate how many icons are needed

    icons = icons[:numIconsUsed] * 2 # make two of each

    random.shuffle(icons)

    # Create the board data structure, with randomly placed icons.

    board = []

    for x in range(BOARDWIDTH):

        column = []

        for y in range(BOARDHEIGHT):

            column.append(icons[0])

            del icons[0] # remove the icons as we assign them

        board.append(column)

    return board

def splitIntoGroupsOf(groupSize, theList):

    # splits a list into a list of lists, where the inner lists have at

    # most groupSize number of items.

    result = []

    for i in range(0, len(theList), groupSize):

        result.append(theList[i:i + groupSize])

    return result

def leftTopCoordsOfBox(boxx, boxy):

    # Convert board coordinates to pixel coordinates

    left = boxx * (BOXSIZE + GAPSIZE) + XMARGIN

    top = boxy * (BOXSIZE + GAPSIZE) + YMARGIN

    return (left, top)

def getBoxAtPixel(x, y):

    for boxx in range(BOARDWIDTH):

        for boxy in range(BOARDHEIGHT):

            left, top = leftTopCoordsOfBox(boxx, boxy)

            boxRect = pygame.Rect(left, top, BOXSIZE, BOXSIZE)

            if boxRect.collidepoint(x, y):

                return (boxx, boxy)

    return (None, None)

def drawIcon(shape, color, boxx, boxy):

    quarter = int(BOXSIZE * 0.25) # syntactic sugar

    half =    int(BOXSIZE * 0.5)  # syntactic sugar

    left, top = leftTopCoordsOfBox(boxx, boxy) # get pixel coords from board coords

    # Draw the shapes

    if shape == DONUT:

        pygame.draw.circle(DISPLAYSURF, color, (left + half, top + half), half - 5)

        pygame.draw.circle(DISPLAYSURF, BGCOLOR, (left + half, top + half), quarter - 5)

    elif shape == SQUARE:

        pygame.draw.rect(DISPLAYSURF, color, (left + quarter, top + quarter, BOXSIZE - half, BOXSIZE - half))

    elif shape == DIAMOND:

        pygame.draw.polygon(DISPLAYSURF, color, ((left + half, top), (left + BOXSIZE - 1, top + half), (left + half, top + BOXSIZE - 1), (left, top + half)))

    elif shape == LINES:

        for i in range(0, BOXSIZE, 4):

            pygame.draw.line(DISPLAYSURF, color, (left, top + i), (left + i, top))

            pygame.draw.line(DISPLAYSURF, color, (left + i, top + BOXSIZE - 1), (left + BOXSIZE - 1, top + i))

    elif shape == OVAL:

        pygame.draw.ellipse(DISPLAYSURF, color, (left, top + quarter, BOXSIZE, half))

def getShapeAndColor(board, boxx, boxy):

    # shape value for x, y spot is stored in board[x][y][0]

    # color value for x, y spot is stored in board[x][y][1]

    return board[boxx][boxy][0], board[boxx][boxy][1]

def drawBoxCovers(board, boxes, coverage):

    # Draws boxes being covered/revealed. "boxes" is a list

    # of two-item lists, which have the x & y spot of the box.

    for box in boxes:

        left, top = leftTopCoordsOfBox(box[0], box[1])

        pygame.draw.rect(DISPLAYSURF, BGCOLOR, (left, top, BOXSIZE, BOXSIZE))

        shape, color = getShapeAndColor(board, box[0], box[1])

        drawIcon(shape, color, box[0], box[1])

        if coverage > 0: # only draw the cover if there is an coverage

            pygame.draw.rect(DISPLAYSURF, BOXCOLOR, (left, top, coverage, BOXSIZE))

    pygame.display.update()

    FPSCLOCK.tick(FPS)

def revealBoxesAnimation(board, boxesToReveal):

    # Do the "box reveal" animation.

    for coverage in range(BOXSIZE, (-REVEALSPEED) - 1, -REVEALSPEED):

        drawBoxCovers(board, boxesToReveal, coverage)

def coverBoxesAnimation(board, boxesToCover):

    # Do the "box cover" animation.

    for coverage in range(0, BOXSIZE + REVEALSPEED, REVEALSPEED):

        drawBoxCovers(board, boxesToCover, coverage)

def drawBoard(board, revealed):

    # Draws all of the boxes in their covered or revealed state.

    for boxx in range(BOARDWIDTH):

        for boxy in range(BOARDHEIGHT):

            left, top = leftTopCoordsOfBox(boxx, boxy)

            if not revealed[boxx][boxy]:

                # Draw a covered box.

                pygame.draw.rect(DISPLAYSURF, BOXCOLOR, (left, top, BOXSIZE, BOXSIZE))

            else:

                # Draw the (revealed) icon.

                shape, color = getShapeAndColor(board, boxx, boxy)

                drawIcon(shape, color, boxx, boxy)

def drawHighlightBox(boxx, boxy):

    left, top = leftTopCoordsOfBox(boxx, boxy)

    pygame.draw.rect(DISPLAYSURF, HIGHLIGHTCOLOR, (left - 5, top - 5, BOXSIZE + 10, BOXSIZE + 10), 4)

def startGameAnimation(board):

    # Randomly reveal the boxes 8 at a time.

    coveredBoxes = generateRevealedBoxesData(False)

    boxes = []

    for x in range(BOARDWIDTH):

        for y in range(BOARDHEIGHT):

            boxes.append( (x, y) )

    random.shuffle(boxes)

    boxGroups = splitIntoGroupsOf(8, boxes)

    drawBoard(board, coveredBoxes)

    for boxGroup in boxGroups:

        revealBoxesAnimation(board, boxGroup)

        coverBoxesAnimation(board, boxGroup)

def gameWonAnimation(board):

    # flash the background color when the player has won

    coveredBoxes = generateRevealedBoxesData(True)

    color1 = LIGHTBGCOLOR

    color2 = BGCOLOR

    for i in range(13):

        color1, color2 = color2, color1 # swap colors

        DISPLAYSURF.fill(color1)

        drawBoard(board, coveredBoxes)

        pygame.display.update()

        pygame.time.wait(300)

def hasWon(revealedBoxes):

    # Returns True if all the boxes have been revealed, otherwise False

    for i in revealedBoxes:

        if False in i:

            return False # return False if any boxes are covered.

    return True

if __name__ == '__main__':

    main()