I was recently coding a platformer game, when I faced into a problem: The user could spam space to jump infinitely.
Here is my code:
def __init__(self, pos):
super().__init__()
self.image = pygame.Surface((32, 64))
self.image.fill("green")
self.rect = self.image.get_rect(topleft = pos)
self.direction = pygame.math.Vector2(0, 0)
self.speed = speed
self.gravity = gravity
self.jump_height = jump_height
def get_input(self):
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT] and keys[pygame.K_RIGHT]: pass
elif keys[pygame.K_LEFT]: self.direction.x = -1
elif keys[pygame.K_RIGHT]: self.direction.x = 1
else: self.direction.x = 0
if keys[pygame.K_SPACE]:
self.jump()
I tried several things, such as implementing a self.antispam boolean, set to True, at the __init__ method that turns into False when the space key is pressed, and then turns True again after the jump method, or turning the jump method into a coroutine to make an asyncio loop, but none of them worked.
To jump you have to use KEYDOWN instead of pygame.key.get_pressed(). Use pygame.key.get_pressed() to move but not to jump.
pygame.key.get_pressed() returns a sequence with the state of each key. If a key is held down, the state for the key is True, otherwise False. Use pygame.key.get_pressed() to evaluate the current state of a button and get continuous movement.
The keyboard events (see pygame.event module) occur only once when the state of a key changes. The KEYDOWN event occurs once every time a key is pressed. KEYUP occurs once every time a key is released. Use the keyboard events for a single action like jumping or spawning a bullet.
Make sure you only call pygame.get.event() once (see Faster version of 'pygame.event.get()'. Why are events being missed and why are the events delayed?):
def get_input(self, event_list):
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT] and keys[pygame.K_RIGHT]: pass
elif keys[pygame.K_LEFT]: self.direction.x = -1
elif keys[pygame.K_RIGHT]: self.direction.x = 1
else: self.direction.x = 0
for event in event_list:
if event.type == pygame.KEYDONW and event.key == pygame.K_SPACE:
self.jump()
# application loop
while run:
# event loop
event_list = pygame.get.event()
for event in event_list:
if event.type == pygame.QUIT:
# [...]
player.get_input(event_list)
The other option is to state if SPACE was pressed in previous frames. So you can detect that the SPACE is hold down:
def __init__(self, pos):
super().__init__()
# [...]
self.space_was_pressed = False
def get_input(self):
keys = pygame.key.get_pressed()
# [...]
space_is_pressed = keys[pygame.K_SPACE]
if space_is_pressed and not self.space_was_pressed:
self.jump()
self.space_was_pressed = space_is_pressed
See also How to make a character jump in Pygame?
while True:
pencere = pygame.display.set_mode((800,600))
pygame.display.set_caption("Oyun")
for olay in pygame.event.get():
if olay.type == pygame.QUIT:
pygame.quit()
sys.exit()
keys = pygame.key.get_pressed()
if keys[pygame.K_UP]:
y -= 3
if keys[pygame.K_DOWN]:
y += 3
if keys[pygame.K_LEFT]:
x -= 3
if keys[pygame.K_RIGHT]:
x += 3
pencere.fill(beyaz)
pygame.draw.rect(pencere, mavi, (x, y, 40, 60))
pygame.display.update()
When i press navigate buttons, the rectangle goes 3 pixel. But how would I make it so when I hold the keys down?
You are reinitialising the pygame window every time round your loop with set_mode. Apparently this resets keyboard input too. (I'm actually surprised this doesn't make the whole window flicker or have other obvious effects.) You should only call set_mode once and you should do it before your main loop.
You can do
import time
key_1 = pygame.key.get_pressed()
time.sleep(0.5)
key_2 = pygame.key.get_pressed()
if key_1 == key_2:
if key_1[pygame.K_UP]:
y -= 3
if key_1[pygame.K_DOWN]:
y += 3
if key_1[pygame.K_LEFT]:
x -= 3
if key_1[pygame.K_RIGHT]:
x += 3
So x and y are updated only if one of the navigation keys is hold down
I use a feature like this a lot in my pygame projects.
The basis of it is to set a variable to True if a key is pressed and false if it is released. When you call a function like move(), you will check if the movement variables are True or False.
If you pressed the right and left arrows at the same time, there would be no movement.
This is just some of the code I use. Since you are using up and down aswell, you should just add more event checks for up and down and the code should be good to go.
Code:
running = True
directions = {"right": False, "left": False}
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
directions['right'] = True
elif event.key == pygame.K_LEFT:
directions['left'] = True
if event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
directions['right'] = False
elif event.key == pygame.K_LEFT:
directions['left'] = False
if directions['right']:
x += 3
if directions['left']:
x -= 3
I'm trying to get my character to move as long as the key is pressed but so far it moves once per single press and the key needs to be released for him to move again.
I've tried using the pygame.key.get_pressed() as shown and I can't figure out what's wrong with it.
def keyPressed(input_key):
keysPressed = pygame.key.get_pressed()
if keysPressed[input_key]:
return True
else:
return False
...
run = True
while run:
for event in pygame.event.get():
if keyPressed(pygame.K_LEFT) and x > vel:
x -= vel
...
You have to call pygame.key.get_pressed() in the application loop rather than the main loop. The event loop is only executed when an event occurs (like pygame.KEYDOWN). But the application loop is executed in every frame.
The typical use for pygame.key.get_pressed() may look as follows:
while run:
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
#<---| Indentation
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT] and x > vel:
x -= vel
if keys[pygame.K_RIGHT] and x < width-vel:
x += vel
# [...]
This question already has answers here:
Pygame: key.get_pressed() does not coincide with the event queue
(4 answers)
Closed 3 years ago.
i'm actually creating my first game with pygame, but i encounter an issue :
When i'm holding 2 button, everything work perfectly , but as soon as i release one of them , pygame.event.get() return a empty list even if i keep holding the other one.
Because of that issue , my character can't jump forward.
thx for help !
Using python Windows 10 and pygame 1.9.6
in the "character" class :
def move_right(self):
self.speedx += 3
self.sprite = "stand_r"
def move_left(self):
self.speedx -= 3
self.sprite = "stand_l"
def speed_effect(self):
self.posx += self.speedx
self.posy -= self.speedy
#speed limitation :
if self.speedx > 10 :
self.speedx = 10
if self.speedx < -10 :
self.speedx = -10
before main loop :
pygame.key.set_repeat(100,30)
pygame.time.Clock().tick(30)
in the main loop :
for event in pygame.event.get():
keys = pygame.key.get_pressed()
if event.type == QUIT:
continuer = 0
if event.type == KEYDOWN:
if keys[pygame.K_d] or event.key == K_d:
character.move_right()
if keys[pygame.K_a] or event.key == K_a:
character.move_left()
#jump
if character.grounded :
if keys[pygame.K_SPACE]:
character.speedy = 30
pygame.event.get() return a empty list after releasing one button.
The event loop is only executed, when an event occurs. An event occurs at the moment when a button is pressed and a 2nd time when the button is released. When the button is hold no event happens, and the event loop is not executed.
The movement of the mouse would be an event which causes the event loop to be executed.
Use pygame.key.get_pressed() in the main loop (outside the event loop), to get the state of the keys at any time and to perform the movement of the character. The states which are given by pygame.key.get_pressed() are synchronized when pygame.event.get() is called.
for event in pygame.event.get():
keys = pygame.key.get_pressed()
if event.type == QUIT:
continuer = 0
if event.type == KEYDOWN:
if character.grounded :
if event.key == pygame.K_SPACE:
character.speedy = 30
keys = pygame.key.get_pressed()
if keys[pygame.K_d]:
character.move_right()
if keys[pygame.K_a]:
character.move_left()
I'm attempting to work out simple controls for an application using pygame in Python. I have got the basics working, but I'm hitting a weird wall: I am using the arrow keys to control my character. If I hold down one arrow key, then hold down another arrow key (to move diagonally), the character moves as expected. However, if I release the second key that I pressed (while still holding down the first key), the character stops moving, even though I am still holding down that first key. Here is my simple movement code:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == KEYDOWN:
if pygame.key.get_pressed()[K_LEFT]:
player.pos = (player.pos[0] - 2, player.pos[1])
if pygame.key.get_pressed()[K_RIGHT]:
player.pos = (player.pos[0] + 2, player.pos[1])
if pygame.key.get_pressed()[K_UP]:
player.pos = (player.pos[0], player.pos[1] - 2)
if pygame.key.get_pressed()[K_DOWN]:
player.pos = (player.pos[0], player.pos[1] + 2)
Now, I was naturally very confused by this. So I tried to print some lines to debug. In the top of the main control loop, I wrote:
print (pygame.key.get_pressed()[K_DOWN], pygame.key.get_pressed()[K_RIGHT])
print pygame.event.get()
...to output a tuple displaying the state of the down and right arrow keys, and then display the pygame event queue. My results baffled me even more. If I move the character diagonally down and right, pressing the down key first and then the right key, then release the right key to make it move simply downward, the character stops moving as before... but this is printed to the shell:
(1, 0)
[]
That is, when I release the right arrow key and still hold down the down arrow key, pygame.key.get_pressed() understands that the down arrow key is still being held down, but there is nothing in the event queue.
Also, earlier in the code (before the control loop) I am invoking
pygame.key.set_repeat(1, 2)
to make the character continue to move while the key is held down.
Any help will be appreciated! Thanks :)
For things like movement, you should not check for events (like KEYDOWN or KEYUP), but check every iteration of your mainloop if your movement keys are pressed (using get_pressed).
In your code, you check the pressed keys only if there's also a KEYDOWN event.
There are also some other things to consider:
You should seperate the key-mapping and the speed of your player, so it will be easier later on to change either of this.
You should determine a movement vector and normalize it first, since otherwise, if your vertical and horizontal movement speed is 10, your diagonal movement speed would be ~14.
Working example:
import pygame
pygame.init()
screen = pygame.display.set_mode((200, 200))
run = True
pos = pygame.Vector2(100, 100)
clock = pygame.time.Clock()
# speed of your player
speed = 2
# key bindings
move_map = {pygame.K_LEFT: pygame.Vector2(-1, 0),
pygame.K_RIGHT: pygame.Vector2(1, 0),
pygame.K_UP: pygame.Vector2(0, -1),
pygame.K_DOWN: pygame.Vector2(0, 1)}
while run:
for e in pygame.event.get():
if e.type == pygame.QUIT: run = False
screen.fill((30, 30, 30))
# draw player, but convert position to integers first
pygame.draw.circle(screen, pygame.Color('dodgerblue'), [int(x) for x in pos], 10)
pygame.display.flip()
# determine movement vector
pressed = pygame.key.get_pressed()
move_vector = pygame.Vector2(0, 0)
for m in (move_map[key] for key in move_map if pressed[key]):
move_vector += m
# normalize movement vector if necessary
if move_vector.length() > 0:
move_vector.normalize_ip()
# apply speed to movement vector
move_vector *= speed
# update position of player
pos += move_vector
clock.tick(60)
just use the events return data, instead of trying to poll, you're already checking if its a keydown event TYPE, now just interrogate the KEY index, like so:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == KEYDOWN:
if event.key == K_LEFT:
player.pos = (player.pos[0] - 2, player.pos[1])
rest of code.....
also consider using a separate data structure to store the state of your controls, then just use the events to update that data structure. That will help make the controls a bit more flexible as you wont be relying on the event queue to cause your character to move, which in my experience causes problems like: not being able to push more than two buttons at a time, and odd delay or timing issues with character movements. so something like:
keystates={'up':False, 'down':False, 'left':False, 'right':False}
running=True
#start main pygame event processing loop here
while running:
for event in pygame.event.get():
if event.type == QUIT:
running=False
#check for key down events
if event.type == KEYDOWN:
if event.key == K_UP:
keystates['up']=True
if event.key == K_DOWN:
keystates['down']=True
if event.key == K_LEFT:
keystates['left']=True
if event.key == K_RIGHT:
keystates['right']=True
#check for key up events
if event.type == KEYUP:
if event.key == K_UP:
keystates['up']=False
if event.key == K_DOWN:
keystates['down']=False
if event.key == K_LEFT:
keystates['left']=False
if event.key == K_RIGHT:
keystates['right']=False
#do something about the key states here, now that the event queue has been processed
if keystates['up']:
character.moveUp() #or whatever your call for these are...
if keystates['down']:
character.moveDown()
if keystates['left']:
character.moveLeft()
if keystates['right']:
character.moveRight()
#gracefully exit pygame here
pygame.quit()
You are using event-based input , but in this case you want polling-based input. Then you don't mess with key-repeats.
import pygame
from pygame.locals import *
done = False
player.pos = Rect(0,0,10,10)
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
elif event.key == K_F1:
print "hi world mode"
# get key current state
keys = pygame.key.get_pressed()
if keys[K_LEFT]:
player.pos.left -= 10
if keys[K_RIGHT]:
player.pos.left += 10
if keys[K_UP]:
player.pos.top -= 10
if keys[K_DOWN]:
player.pos.left += 10
if keys[K_SPACE]:
print 'firing repeated gun'
My guess is that set repeat doesn't work the way that you think it will. Basically, after your second key goes up, the repeat doesn't happen. This would seem to make sense to me: open up a text editor and hold down the "A" key. "A"s will spill out across the screen. Then, press the "J" key with the "A" key still held down. The "A"s stop. That is a typical key repeat system.
I'm not sure using this "set_repeat" method is going to work out in the end anyway. Basically, any key that the player presses will now "repeat", even if they click "fire" or "jump".
As an alternative, try saving the state when the user presses or releases. Don't use the set_repeat, but do something like the following:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == KEYDOWN:
if pygame.key.get_pressed()[K_LEFT]:
player.moving_left = True
if pygame.key.get_pressed()[K_RIGHT]:
player.moving_right = True
if pygame.key.get_pressed()[K_UP]:
player.moving_up = True
if pygame.key.get_pressed()[K_DOWN]:
player.moving_down = True
elif event.type == KEYUP:
if pygame.key.get_pressed()[K_LEFT]:
player.moving_left = False
if pygame.key.get_pressed()[K_RIGHT]:
player.moving_right = False
if pygame.key.get_pressed()[K_UP]:
player.moving_up = False
if pygame.key.get_pressed()[K_DOWN]:
player.moving_down = False
# Somewhere else in your game loop...
if player.moving_left:
player.pos[0] -= 2
if player.moving_right:
player.pos[0] += 2
if player.moving_up:
player.pos[1] -= 2
if player.moving_right:
player.pos[1] += 2