Question

I’m developing a very basic engine, basing myself on tutorials from Pygame, and I’m having a little problem with “smoothness”. How do I make my player walk “smoother”?

My event handler is pretty basic, pretty standard, nothing new, and I even figured out how to make a “boost” (run) for test. But the thing is, at the pygame.KEYUP, those lots of zeros destroy the “smoothness” of my little player, and I don’t want that, but I don’t want it to walk ad infinitum.

import pygame
import gfx

# Main Class

class Setup:

    background = gfx.Images.background
    player = gfx.Images.player

    pygame.init()

    # Configuration Variables:

    black = (0,0,0)
    white = (255,255,255)
    green = (0,255,0)
    red  = (255,0,0)
    title = "Ericson's Game"

    # Setup:

    size = [700,700]
    screen = pygame.display.set_mode(size)
    pygame.display.set_caption(title)
    done = False
    clock = pygame.time.Clock()

    # Logic Variables

    x_speed = 0
    y_speed = 0
    x_speed_boost = 0
    y_speed_boost = 0
    x_coord = 350
    y_coord = 350
    screen.fill(white)

    # Main Loop:

    while done == False:

        screen.blit(background,[0,0])
        screen.blit(player,[x_coord,y_coord])

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

            if event.type == pygame.KEYDOWN:               
                if event.key == pygame.K_ESCAPE:
                    done = True

                if event.key == pygame.K_a:
                    x_speed = -6
                    x_speed_boost = 1
                if event.key == pygame.K_d:
                    x_speed = 6
                    x_speed_boost = 2
                if event.key == pygame.K_w:
                    y_speed = -6
                    y_speed_boost = 1
                if event.key == pygame.K_s:
                    y_speed = 6
                    y_speed_boost = 2

                if event.key == pygame.K_LSHIFT:

                    if x_speed_boost == 1:
                        x_speed = -10
                    if x_speed_boost == 2:
                        x_speed = 10
                    if y_speed_boost == 1:
                        y_speed = -10
                    if y_speed_boost == 2:
                        y_speed = 10                  

            if event.type == pygame.KEYUP:
                if event.key == pygame.K_a:
                    x_speed = 0
                    x_speed_boost = 0
                if event.key == pygame.K_d:
                    x_speed = 0
                    x_speed_boost = 0
                if event.key == pygame.K_w:
                    y_speed = 0
                    y_speed_boost = 0
                if event.key == pygame.K_s:
                    y_speed = 0
                    y_speed_boost = 0

        x_coord = x_coord + x_speed
        y_coord = y_coord + y_speed

        pygame.display.flip()
        pygame.display.update()

        clock.tick(20)

    pygame.quit()

Answer 1

Code will be simpler/clearer using keystate polling for your use. If other parts of the game use ‘on press’ logic, you can use event handling. So your movement would be:

If you are calling pygame.display.flip() then you don’t use pygame.display.update(). Infact it will probably slow it down to use both.

I used your x_coord variable. But it would simplify things to use a tuple or vector for player location. You can use a float, for smoother precision for movement. Then it blits as an int to screen.

while not done:
    for event in pygame.event.get():
        # any other key event input
        if event.type == QUIT:
            done = True        
        elif event.type == KEYDOWN:
            if event.key == K_ESC:
                done = True

    vel_x = 0
    vel_y = 0
    speed = 1

    if pygame.key.get_mods() & KMOD_SHIFT
        speed = 2


    # get key current state
    keys = pygame.key.get_pressed()
    if keys[K_A]:
        vel_x = -1
    if keys[K_D]:
        vel_x = 1
    if keys[K_W]:
        vel_y = -1
    if keys[K_S]:
        vel_y = 1


    x_coord += vel_x * speed
    y_coord += vel_y * speed