如何模拟物体的更逼真的运动？

Question

I am writing a game environment, in which a person (worker) should move inside the area in a random direction, until it crosses with one of green-coloured obstacles (defined as pygame.draw.rect(screen, GREEN, [510,150,75,52]) and pygame.draw.rect(screen, GREEN, [450,250,68,40]) ).

Until now I can simulate a random movement of a worker, but it moves somehow irregularly and non-smoothly, jumping around the same area and slowly shifting to the right bottom corner.

How can I update the function create_randomPATH to support a more realistic smooth movement of a worker inside the screen area? I tried to increase a tick size till 70 or even more ( clock.tick(70) ) as it is indicated in one of threads, but it does not seem to solve the problem.

import pygame, random
import sys

WHITE = (255, 255, 255)
GREEN = (20, 255, 140)
GREY = (210, 210 ,210)
RED = (255, 0, 0)
PURPLE = (255, 0, 255)

SCREENWIDTH=1000
SCREENHEIGHT=578      

class Worker(pygame.sprite.Sprite):
    def __init__(self, image_file, location):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.image.load(image_file)
        self.rect = self.image.get_rect()
        self.rect.left, self.rect.top = location

    def create_randomPATH(self,x,y):
        randomX = random.randint(1,5)
        randomY = random.randint(1,5)
        if random.uniform(0,1)>0.5:
            valX = x  + randomX
            valY = y  + randomY
        else:
            valX = x  - randomX
            valY = y  - randomY   
        return valX, valY

class Background(pygame.sprite.Sprite):
    def __init__(self, image_file, location):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.image.load(image_file)
        self.rect = self.image.get_rect()
        self.rect.left, self.rect.top = location

pygame.init()

size = (SCREENWIDTH, SCREENHEIGHT)
screen = pygame.display.set_mode(size)
screen_rect=screen.get_rect()
pygame.display.set_caption("TEST")

worker = Worker("worker.png", [0,0])
w_x = worker.rect.left
w_y = worker.rect.top

bg = Background("background.jpg", [0,0])

carryOn = True
clock=pygame.time.Clock()

while carryOn:
        for event in pygame.event.get():
            if event.type==pygame.QUIT:
                carryOn=False
                pygame.display.quit()
                pygame.quit()
                quit()

        # Draw floor layout 
        screen.blit(pygame.transform.scale(bg.image, (SCREENWIDTH, SCREENHEIGHT)), bg.rect)

        # Draw obstacles
        pygame.draw.rect(screen, GREEN, [510,150,75,52])
        pygame.draw.rect(screen, GREEN, [450,250,68,40])

        w_x,w_y = worker.create_randomPATH(w_x,w_y)

        # worker should not go outside the screen area
        worker.rect.clamp_ip(screen_rect)

        screen.blit(worker.image, (w_x,w_y))

        # Refresh Screen
        pygame.display.flip()

        clock.tick(5)

pygame.display.quit()
pygame.quit()
quit()

Answer 1

You could use an extra direction variable in your code which says in which direction the player is currently moving. One of four values: up, right, down or left. Every once in a while update that direction variable. Meanwhile move only one coordinate at a time in that direction.

def create_randomPATH(self, x, y, dir):
    if random.uniform(0,1)>0.8:
        # there is a 20% chance every time that direction is changed
        dir = random.randInt(1,4)

    if dir == 1:
        return x, y+1, dir # up
    if dir == 2:
        return x+1, y, dir # right
    if dir == 3:
        return x, y-1, dir # down
    if dir == 4:
        return x-1, y, dir # left

In your code you would also need a global direction variable, initially it should also have a value 1, 2, 3 or 4:

w_x,w_y,w_dir = worker.create_randomPATH(w_x,w_y,w_dir)

By moving only one step on every iteration, we assure that the movement speed is always constant. In your code, it was varying from 1 to 5 steps. Also if you move a few steps in a given direction straight, it would seem more natural than changing the direction very suddenly very often. Try to play with the percentage (currently 20% chance) of how often the direction is changed and see if it makes the movement even smoother.

EDIT:

Because of the randomness of the movement, eventually the moving object will reach the borders of the game and might leave the screen. Adjust the position after each movement:

w_x,w_y,w_dir = worker.create_randomPATH(w_x,w_y,w_dir)

if (w_x + worker.rect.width > SCREENWIDTH): w_x = SCREENWIDTH - worker.rect.width
if (w_x < 0): w_x = 0
if (w_y + worker.rect.height > SCREENHEIGHT): w_y = SCREENHEIGHT - worker.rect.height
if (w_y < 0): w_y = 0

Then the object will not exit the screen and will eventually randomly move in other directions again. Because each direction is equally likely, it will move all around the screen properly.

Answer 2

Take screen.blit(worker.image, (w_x,w_y)) and put it in it's own method. Then you can create a loop to loop from the oldX and oldY to the new position found by create_randomPATH You can even make the direction to move random by making them move in the x or y direction randomly each time.

Below is a rough example, but you probably have to modify it to match your code.

def UpdatePerson(image, x, y):
    screen.blit(image, x, y)

while carryOn:

    ...
    ...

    oldX = w_x
    oldY = w_y

    w_x,w_y = worker.create_randomPATH(w_x,w_y)


    while(oldX < w_x || oldY < w_y):
        randomDir = random.randint(1,2)

        if randomDir == 1 && oldX < w_x:
            UpdatePerson(worker.image, oldX, w_y)
            oldX += 1
        elif randomDir == 2 && oldY < w_x
            UpdatePerson(worker.image, w_x, oldY)
            oldY += 1