Pygame Sprite doesn't reset

Question

I am making a platformer type game but I have run into two problems.

My Sprite is confined to a small box in the centered in the window. How do I make it so he can cover the entire window?
When I move the old sprite is not removed. It make it appear that there is a tail following the sprite.

Help for either would be appreciated!

    import random, sys, copy, os, pygame, time, math
from pygame.locals import *


TILESIZE = 20
WINDOWWIDTH = 1280
WINDOWHEIGHT = 720
FPS = 30
floorx = (WINDOWHEIGHT - (TILESIZE))
floory = (WINDOWWIDTH / TILESIZE)
TileOffset = 20
tilesNeeded = (WINDOWWIDTH / TILESIZE)
floorSize = TILESIZE * 2
OUTSIDE_DECORATION_PCT = 20
HALF_WINDOWHEIGHT = (WINDOWHEIGHT / 2)
HALF_WINDOWWIDTH = (WINDOWWIDTH / 2)
CAMERASLACK = 25
MOVERATE = 9
BOUNCERATE = 6
BOUNCEHEIGHT = 30
INVULTIME = 2
GAMEOVERTIME  = 4
MAXHEALTH = 3
STARTSIZE = 30 

BLACK =         (  0,   0,   0)
WHITE =         (255, 255, 255)
LIGHTGRAY =     (174, 174, 174)
DARKGRAY =      ( 41,  41,  41)
MEDGRAY =       (101, 101, 101)
SKYBLUE =       (200, 210, 255)
DARKTURQUOISE = (  3,  54,  73)
GREEN =         (  0,  92,   7)
LIGHTGREEN =    (  0, 135,  15)
BGCOLOR = LIGHTGRAY
TEXTCOLOR = BLACK

UP = 'up'
DOWN = 'down'
LEFT = 'left'
RIGHT = 'right'

def main():
    global FPSCLOCK, DISPLAYSURF, BASICFONT, TILESIZE, floorx, floory, floorCovered, tilesNeeded, OUTSIDEDECOMAPPING, L_Monster, R_Monster, BGIMAGE

    pygame.init()
    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
    FPSCLOCK = pygame.time.Clock()

    pygame.display.set_caption('Alpha One')
    # Set up the background image.
    boardImage = pygame.image.load('bg.png')
    # Use smoothscale() to stretch the board image to fit the entire board:
    boardImageRect = boardImage.get_rect()
    boardImageRect.topleft = (0, 0)
    BGIMAGE = pygame.image.load('bg.png')
    # Use smoothscale() to stretch the background image to fit the entire window:
    BGIMAGE = pygame.transform.smoothscale(BGIMAGE, (WINDOWWIDTH, WINDOWHEIGHT))
    BGIMAGE.blit(boardImage, boardImageRect)
    #Draw the background    
    DISPLAYSURF.blit(BGIMAGE, BGIMAGE.get_rect())
    #Draw the Floor
    drawFloor()

    L_Monster = pygame.image.load('monster.png')
    L_Monster = pygame.transform.scale(L_Monster, (1000, 600))
    R_Monster = pygame.transform.flip(L_Monster, True, False)


    pygame.display.flip()




    #Main Game Loop
    while True:
        runGame()


        #pygame.display.update()


def runGame():
    invulnerableMode = False
    invulnerableStartTime = 0
    gameOverMode = False
    gameOverStartTime = 0
    winMode = False

    camerax = 0
    cameray = 0



    playerObj = {'surface': pygame.transform.scale(L_Monster,(STARTSIZE, STARTSIZE)),
                 'facing': LEFT,
                 'size': STARTSIZE,
                 'x': HALF_WINDOWWIDTH,
                 'y': HALF_WINDOWHEIGHT,
                 'bounce':0,
                 'health': MAXHEALTH}

    moveLeft = False
    moveRight = False
    moveUp = False
    moveDown = False

    while True:
        DISPLAYSURF.blit(BGIMAGE, BGIMAGE.get_rect())
        drawFloor()
        #DISPLAYSURF.fill(WHITE)
        if invulnerableMode and time.time() - invulnerableStartTime > INVULNTIME:
            invulnerableMode = False


        playerCenterx = playerObj['x'] + int(playerObj['size'] / 2)
        playerCentery = playerObj['y'] + int(playerObj['size'] / 2)
        if (camerax + HALF_WINDOWWIDTH) - playerCenterx > CAMERASLACK:
            camerax = playerCenterx + CAMERASLACK - HALF_WINDOWWIDTH
        elif playerCenterx - (camerax +HALF_WINDOWWIDTH) > CAMERASLACK:
            camerax = playerCenterx - CAMERASLACK - HALF_WINDOWWIDTH
        if (cameray + HALF_WINDOWHEIGHT) - playerCentery > CAMERASLACK:
            cameray = playerCentery + CAMERASLACK - HALF_WINDOWHEIGHT
        elif playerCentery - (cameray +HALF_WINDOWHEIGHT) > CAMERASLACK:
            cameray = playerCentery - CAMERASLACK - HALF_WINDOWHEIGHT


        flashIsOn = round(time.time(), 1) * 10 % 2 == 1
        if not gameOverMode and not (invulnerableMode and flashIsOn):
            playerObj['rect'] = pygame.Rect((playerObj['x'] - camerax,
                                             playerObj['y'] - cameray - getBounceAmount(playerObj['bounce'], BOUNCERATE, BOUNCEHEIGHT),
                                             playerObj['size'],
                                             playerObj['size']))
            DISPLAYSURF.blit(playerObj['surface'], playerObj['rect'])

        for event in pygame.event.get():
            if event.type == QUIT:
                terminate()

            elif event.type == KEYDOWN:
                if event.key in (K_UP, K_w):
                    moveDown = False
                    moveUp = True
                elif event.key in (K_DOWN, K_s):
                    moveUp = False
                    moveDown = True
                elif event.key in (K_LEFT, K_a):
                    moveRight = False
                    moveLeft = True
                    if playerObj['facing'] == RIGHT:
                        playerObj['surface'] = pygame.transform.scale(L_Monster, (playerObj['size'], playerObj['size']))
                    playerObj['facing'] == LEFT
                elif event.key in (K_RIGHT, K_d):
                    moveLeft = False
                    moveRight = True
                    if playerObj['facing'] == LEFT:
                        playerObj['surface'] = pygame.transform.scale(R_Monster, (playerObj['size'], playerObj['size']))
                    playerObj['facing'] = RIGHT
                elif winMode and event.key == K_r:
                    return
            elif event.type == KEYUP:
                if event.key in (K_LEFT, K_a):
                    moveLeft = False
                elif event.key in (K_RIGHT, K_d):
                    moveRight = False
                elif event.key in (K_UP, K_w):
                    moveUp = False
                elif event.key in (K_DOWN, K_s):
                    moveDown = False 

                elif event.key == K_ESCAPE:
                    terminate()

        if not gameOverMode:
            if moveLeft:
                playerObj['x'] -= MOVERATE
            if moveRight:
                playerObj['x'] += MOVERATE
            if moveUp:
                playerObj['y'] -= MOVERATE
            if moveDown:
                playerObj['y'] += MOVERATE
            if (moveLeft or moveRight or moveUp or moveDown) or playerObj['bounce'] != 0:
                playerObj['bounce'] += 1

            if playerObj['bounce'] > BOUNCERATE:
                playerObj['bounce'] = 0 

        else:
            # game is over, show "game over" text
            DISPLAYSURF.blit(gameOverSurf, gameOverRect)
            if time.time() - gameOverStartTime > GAMEOVERTIME:
                return

        if winMode:
            DISPLAYSURF.blit(winSurf, winRect)
            DISPLAYSURF.blit(winSurf2, winRect2)

        pygame.display.update()
        FPSCLOCK.tick(FPS)


def getBounceAmount(currentBounce, bounceRate, bounceHeight):

    return int(math.sin( (math.pi / float(bounceRate)) * currentBounce ) * bounceHeight)

def getRandomOffCameraPos(camerax, cameray, objWidth, objHeight):
    # create a Rect of the camera view
    cameraRect = pygame.Rect(camerax, cameray, WINDOWWIDTH, WINDOWHEIGHT)
    while True:
        x = random.randint(camerax - WINDOWWIDTH, camerax + (2 * WINDOWWIDTH))
        y = random.randint(cameray - WINDOWHEIGHT, cameray + (2 * WINDOWHEIGHT))
        # create a Rect object with the random coordinates and use colliderect()
        # to make sure the right edge isn't in the camera view.
        objRect = pygame.Rect(x, y, objWidth, objHeight)
        if not objRect.colliderect(cameraRect):
            return x, y

def isOutsideActiveArea(camerax, cameray, obj):

    boundsLeftEdge = camerax - WINDOWWIDTH
    boundsTopEdge = cameray - WINDOWHEIGHT
    boundsRect = pygame.Rect(boundsLeftEdge, boundsTopEdge, WINDOWWIDTH * 3, WINDOWHEIGHT * 3)
    objRect = pygame.Rect(obj['x'], obj['y'], obj['width'], obj['height'])
    return not boundsRect.colliderect(objRect)        

def checkForQuit():
    for event in pygame.event.get(QUIT): # get all the QUIT events
        terminate() # terminate if any QUIT events are present
    for event in pygame.event.get(KEYUP): # get all the KEYUP events
        if event.key == K_ESCAPE:
            terminate() # terminate if the KEYUP event was for the Esc key
        pygame.event.post(event)



def drawFloor():
    #Open the image used for tiles and initialize N
    floorTile = pygame.image.load('tile.png')
    N = 0

    while (N < tilesNeeded):  
        DISPLAYSURF.blit(floorTile,((20 * N, (floorx + (TILESIZE/4)) - TILESIZE)), )
        DISPLAYSURF.blit(floorTile,(20 * N, (floorx + (TILESIZE/4))))
        N = N + 1

    #Updates the display
    pygame.display.flip()

def checkCollide():
    FLOOR_SURF = pygame.Rect( 0, (WINDOWHEIGHT - (TILESIZE * 2)), WINDOWWIDTH, WINDOWHEIGHT)

def terminate():
    pygame.quit()
    sys.exit()

if __name__ == '__main__':
    main()

Haz · Accepted Answer

The reason you're getting the "tail" of your sprite is because you're not clearing the screen before you begin drawing a new frame. One way to handle this would be to enter something like the following at the beginning of runGame():

DISPLAYSURF.fill(white)

This will "clear" the surface by covering everything in white. When you begin drawing images for that frame, they will be drawn over a blank white surface. The caveat to this is that you will need to redraw every sprite on the screen, not just the ones that have moved in the last frame.

For the first question, if you're asking how to scale the size of the image, you would use the scale function from pygame.transform

L_monster = pygame.transform.scale(L_monster, (500, 500))

This creates a new surface by transforming the given surface to the new size given by the tuple.

http://www.pygame.org/docs/ref/transform.html#pygame.transform.scale

Pygame Sprite doesn't reset

Answers (1)

Related Questions

Pygame Sprite doesn&#39;t reset

Answers (1)

Related Questions

Pygame Sprite doesn't reset