Пример #1
0
import pygame, sys, time, random, pika, json, uuid
from threading import Thread

pygame.init()
window = pygame.display.set_mode((800, 600))
screen = pygame.Surface((800, 600))
pygame.display.set_caption("Tank")

global done
done = False
global hello
hello = False
global intl
intl = False
'''Menu'''


class Menu:
    def __init__(self,
                 lists=[360, 200, u"Write", (50, 250, 30), (250, 30, 250)]):
        self.lists = lists

    def render(self, surf, font, num_list):
        for i in self.lists:
            if num_list == i[5]:
                surf.blit(font.render(i[2], 1, i[4]), (i[0], i[1]))
            else:
                surf.blit(font.render(i[2], 1, i[3]), (i[0], i[1]))

    def menu(self):
        font_menu = pygame.font.SysFont("algerian", 50)
Пример #2
0
import sys, pygame
#pygame.font.init()
pygame.init()
size = 800, 480
screen = pygame.display.set_mode(size)

background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill((255, 255, 255))

surface = pygame.Surface((100, 100))
image = pygame.image.load('main.png')
button = pygame.image.load('button.png')
circle = pygame.image.load('circle.png')

font = pygame.font.Font(None, 36)
text = font.render("Hello, World", 1, (255, 0, 0))
textPos = text.get_rect(centerx = background.get_width()//2, centery = background.get_height()//2)
background.blit(text, textPos)
screen.blit(background, background.get_rect())
screen.blit(image, (0, 0))
screen.blit(button, (10, 10))
screen.blit(circle, (30, 30))
pygame.display.flip()
while 1:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
            all_sprites.add(new_enemy)  # why is this needed?

        elif event.type == add_cloud:
            new_cloud = Cloud()
            clouds.add(new_cloud)
            all_sprites.add(new_cloud)

    screen.fill((135, 206, 250))
    pressed_keys = pygame.key.get_pressed()
    player.update(pressed_keys)

    enemies.update()  # update enemy position
    clouds.update()  # update cloud every loop

    # create a surf object
    surf = pygame.Surface((50, 50))  # a surface object is 50 pixel by 50 pixel
    surf.fill((125, 125, 125))  # fill it black
    rect = surf.get_rect()

    surf_center = ((SCREEN_WIDTH - surf.get_width()) / 2,
                   (SCREEN_HEIGHT - surf.get_height()) / 2)
    player_location = (0, (SCREEN_HEIGHT - player.surf.get_height()) / 2)
    # block transfer putting surface onto another surface
    # screen.blit(surf, (SCREEN_WIDTH/2, SCREEN_HEIGHT/2))  # this only puts the top corner of the surface object
    # screen.blit(surf, surf_center)  # this copies surface onto the screen, at exactly the center of the screen
    # screen.blit(player.surf, player.rect)
    for entity in all_sprites:
        screen.blit(entity.surf, entity.rect)

    if pygame.sprite.spritecollideany(player, enemies):
        player.kill()
Пример #4
0
# Listing_18-1.py
# Copyright Warren & Carter Sande, 2013
# Released under MIT license   http://www.opensource.org/licenses/mit-license.php
# Version $version  ----------------------------

# Program z odbijającą się piłką, sprajtami i funkcją clock.tick()

import pygame, sys
pygame.init()
ekran = pygame.display.set_mode([640, 480])
tlo = pygame.Surface(ekran.get_size())
tlo.fill([255, 255, 255])
zegar = pygame.time.Clock()


# Klasa Pilka zawierająca metodę przesun()
class Pilka(pygame.sprite.Sprite):
    def __init__(self, plik_obrazka, predkosc, polozenie):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.image.load(plik_obrazka)
        self.rect = self.image.get_rect()
        self.rect.left, self.rect.top = polozenie
        self.predkosc = predkosc

    def przesun(self):
        if self.rect.left <= ekran.get_rect().left or \
                self.rect.right >= ekran.get_rect().right:
            self.predkosc[0] = -self.predkosc[0]
        nowaPozycja = self.rect.move(self.predkosc)
        self.rect = nowaPozycja
Пример #5
0
class Block(pygame.sprite.Sprite):
    def __init__(self, color, (width, height)):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.Surface([width, height])
        self.image.fill(color)
        self.rect = self.image.get_rect()
Пример #6
0
display.set_caption('Giperborea')

text_intro_screen = Surface ((600, 150))
start_screen = Surface((840, 630))
#background = image.load ('images/back.png')
adventure_screen = Surface ((840, 420))
instrumental_screen = Surface ((880,190))
hero_screen = Surface ((180,190))
monster_screen = Surface ((190,200))
information_screen = Surface ((680,190))
roll_screen = Surface ((600, 170))
high_screen = Surface ((810, 22))
inventory_screen = Surface ((380,380))
char_screen = Surface ((380,380))
journal_screen = Surface ((380,380))
start_screen_text_surface = pygame.Surface ((300, 100))	
start_screen_version_surface = pygame.Surface ((300, 100))	

def main_interface (level):
	window.blit(start_screen, (10, 10))

	start_screen.fill ((black))
	start_screen.blit (high_screen, (0,2))
	high_screen.fill ((black))
	start_screen.blit (adventure_screen, (0,25))
	adventure_screen.fill ((black))
	start_screen.blit (instrumental_screen, (0,430))
	instrumental_screen.fill ((black))
	instrumental_screen.blit (hero_screen, (0,2))
	hero_screen.fill ((black))
Пример #7
0
 def __init__(self, font, dim, pos):
     self.font = font
     self.dim = dim
     self.pos = pos
     self.seconds_left = 0
     self.surface = pygame.Surface(self.dim)
Пример #8
0
        def test_subsurface_lock(self):
            sf = pygame.Surface((5, 5))
            subsf = sf.subsurface((1, 1, 2, 2))
            sf2 = pygame.Surface((5, 5))

            # Simple blits, nothing should happen here.
            sf2.blit(subsf, (0, 0))
            sf2.blit(sf, (0, 0))

            # Test blitting on self:
            self.assertRaises(pygame.error, sf.blit, subsf, (0, 0))
            #self.assertRaises(pygame.error, subsf.blit, sf, (0, 0))
            # ^ Fails although it should not in my opinion. If I cannot
            # blit the subsurface to the surface, it should not be allowed
            # the other way around as well.

            # Test additional locks.
            sf.lock()
            sf2.blit(subsf, (0, 0))
            self.assertRaises(pygame.error, sf2.blit, sf, (0, 0))

            subsf.lock()
            self.assertRaises(pygame.error, sf2.blit, subsf, (0, 0))
            self.assertRaises(pygame.error, sf2.blit, sf, (0, 0))

            # sf and subsf are now explicitly locked. Unlock sf, so we can
            # (assume) to blit it.
            # It will fail though as the subsurface still has a lock around,
            # which is okay and correct behaviour.
            sf.unlock()
            self.assertRaises(pygame.error, sf2.blit, subsf, (0, 0))
            self.assertRaises(pygame.error, sf2.blit, sf, (0, 0))

            # Run a second unlock on the surface. This should ideally have
            # no effect as the subsurface is the locking reason!
            sf.unlock()
            self.assertRaises(pygame.error, sf2.blit, sf, (0, 0))
            self.assertRaises(pygame.error, sf2.blit, subsf, (0, 0))
            subsf.unlock()

            sf.lock()
            self.assertEqual(sf.get_locked(), True)
            self.assertEqual(sf.get_locks(), (sf,))
            self.assertEqual(subsf.get_locked(), False)
            self.assertEqual(subsf.get_locks(), ())

            subsf.lock()
            self.assertEqual(sf.get_locked(), True)
            self.assertEqual(sf.get_locks(), (sf, subsf))
            self.assertEqual(subsf.get_locked(), True)
            self.assertEqual(subsf.get_locks(), (subsf,))

            sf.unlock()
            self.assertEqual(sf.get_locked(), True)
            self.assertEqual(sf.get_locks(), (subsf,))
            self.assertEqual(subsf.get_locked(), True)
            self.assertEqual(subsf.get_locks(), (subsf,))

            subsf.unlock()
            self.assertEqual(sf.get_locked(), False)
            self.assertEqual(sf.get_locks(), ())
            self.assertEqual(subsf.get_locked(), False)
            self.assertEqual(subsf.get_locks(), ())

            subsf.lock()
            self.assertEqual(sf.get_locked(), True)
            self.assertEqual(sf.get_locks(), (subsf,))
            self.assertEqual(subsf.get_locked(), True)
            self.assertEqual(subsf.get_locks(), (subsf,))

            subsf.lock()
            self.assertEqual(sf.get_locked(), True)
            self.assertEqual(sf.get_locks(), (subsf, subsf))
            self.assertEqual(subsf.get_locked(), True)
            self.assertEqual(subsf.get_locks(), (subsf, subsf))
Пример #9
0
pygame.init()
window = pygame.display.set_mode((600,600))
pygame.display.set_caption("MY OWN PAINT")

color = pygame.Color(255,255,255)
window.fill(color)

color2 = pygame.Color(156,156,156)
for x in range(30):
    posx = x*20
    pygame.draw.line(window,color2,(posx,0),(posx,600))
for y in range(30):
    posy = y*20
    pygame.draw.line(window,color2,(0,posy),(600,posy))

rectan = pygame.Surface((20, 20))       #Tamano del Rectangulo
for x in range(len(colores)):
    posx = x*20
    rectan.fill(colores[x])
    window.blit(rectan, (posx, 0))

while True:
    evento = pygame.event.wait()

    if evento.type == pygame.QUIT:
        break

    ## Dibujando el mapa
    if evento.type == pygame.MOUSEBUTTONDOWN:
        if evento.button == 1:
            mouse_x,mouse_y = pygame.mouse.get_pos()
#e7-3-11彈跳球遊戲
import pygame, sys
pygame.init()  #load pygame modules
size = width, height = 400, 300  #size of window
speed = [2, 2]  #speed and direction
screen = pygame.display.set_mode(size)  #make window
s = pygame.Surface((100, 50))  #create surface 100px by 50px
s.fill((33, 66, 99))  #color the surface blue
r = s.get_rect()  #get the rectangle bounds for the surface
clock = pygame.time.Clock()  #make a clock
while 1:  #infinite loop
    clock.tick(30)  #limit framerate to 30 FPS
    for event in pygame.event.get():  #if something clicked
        if event.type == pygame.QUIT:  #if EXIT clicked
            sys.exit()  #close cleanly
    r = r.move(speed)  #move the box by the "speed" coordinates
    #if we hit a  wall, change direction
    if r.left < 0 or r.right > width: speed[0] = -speed[0]
    if r.top < 0 or r.bottom > height: speed[1] = -speed[1]
    screen.fill((0, 0, 0))  #make redraw background black
    screen.blit(s, r)  #render the surface into the rectangle
    pygame.display.flip()  #update the screen
Пример #11
0
main_theme = (0, 100, 100)
red = (100, 0, 0)
white = (255, 255, 255)

# game settings
settings = Settings()
show_notes = True
star_chance = 10  # chance of a star is 1 in 10 every update
initial_stars = 100  # create 100 stars to fill the screen
package_chance = 10  # chance of a package drop is 1 in 10 every enemy kill
# if your game runs slow, set particle count low and star chance higher
# all particles, stars, enemies and bullets are removed when they leave the screen

width = 800
height = 500
main_s = pygame.display.set_mode((width, height))
main_s.fill((255, 255, 255))
pygame.display.set_caption("SPACE SHIPS")
pygame.display.set_icon(pygame.image.load("Images/Icon.png"))
font = pygame.font.Font("./Font/tall bolder.ttf", 15)
menu_font = pygame.font.Font("./Font/tall bolder.ttf", 25)
title_font = pygame.font.Font("./Font/tall bolder.ttf", 45)

screen_rect = pygame.sprite.Sprite()
# screen_rect is slightly bigger than the screen so that objects do not get removed
# when created off screen. many objects are checked as still on screen to remove it
# from a list that it is in
screen_rect.rect = pygame.Surface((width + 30, height + 30)).get_rect()
screen_rect.rect.x = 0
screen_rect.rect.y = 0
Пример #12
0
 def initializeTextureBoard(self, size):
     for y in range(0, size - 1):
         new = []
         for x in range(0, size - 1):
             new.append(pygame.Surface((32, 32), pygame.SRCALPHA))
         self.boardTextures.append(new)
Пример #13
0
 def insertTexture(self, x, y, image):
     self.boardTextures[x][y] = pygame.Surface((32, 32), pygame.SRCALPHA)
     self.boardTextures[x][y].blit(self.imageDictionary[image], (0, 0))
Пример #14
0
def main(winstyle=0):
    # Initialize pygame
    pygame.init()
    if pygame.mixer and not pygame.mixer.get_init():
        print('Warning, no sound')
        pygame.mixer = None

    # Set the display mode
    winstyle = 0  # |FULLSCREEN
    bestdepth = pygame.display.mode_ok(SCREENRECT.size, winstyle, 32)
    screen = pygame.display.set_mode(SCREENRECT.size, winstyle, bestdepth)

    #Load images, assign to sprite classes
    #(do this before the classes are used, after screen setup)
    img = load_image('player1.gif')
    Player.images = [img, pygame.transform.flip(img, 1, 0)]
    img = load_image('explosion1.gif')
    Explosion.images = [img, pygame.transform.flip(img, 1, 1)]
    Alien.images = load_images('alien1.gif', 'alien2.gif', 'alien3.gif')
    Bomb.images = [load_image('bomb.gif')]
    Shot.images = [load_image('shot.gif')]

    #decorate the game window
    icon = pygame.transform.scale(Alien.images[0], (32, 32))
    pygame.display.set_icon(icon)
    pygame.display.set_caption('Pygame Aliens')
    pygame.mouse.set_visible(0)

    #create the background, tile the bgd image
    bgdtile = load_image('background.gif')
    background = pygame.Surface(SCREENRECT.size)
    for x in range(0, SCREENRECT.width, bgdtile.get_width()):
        background.blit(bgdtile, (x, 0))
    screen.blit(background, (0, 0))
    pygame.display.flip()

    #load the sound effects
    boom_sound = load_sound('boom.wav')
    shoot_sound = load_sound('car_door.wav')
    if pygame.mixer:
        music = os.path.join(main_dir, 'data', 'house_lo.wav')
        pygame.mixer.music.load(music)
        pygame.mixer.music.play(-1)

    # Initialize Game Groups
    aliens = pygame.sprite.Group()
    shots = pygame.sprite.Group()
    bombs = pygame.sprite.Group()
    all = pygame.sprite.RenderUpdates()
    lastalien = pygame.sprite.GroupSingle()

    #assign default groups to each sprite class
    Player.containers = all
    Alien.containers = aliens, all, lastalien
    Shot.containers = shots, all
    Bomb.containers = bombs, all
    Explosion.containers = all
    Score.containers = all

    #Create Some Starting Values
    global score
    alienreload = ALIEN_RELOAD
    kills = 0
    clock = pygame.time.Clock()

    #initialize our starting sprites
    global SCORE
    player = Player()
    Alien()  #note, this 'lives' because it goes into a sprite group
    if pygame.font:
        all.add(Score())

    while player.alive():

        #get input
        for event in pygame.event.get():
            if event.type == QUIT or \
                (event.type == KEYDOWN and event.key == K_ESCAPE):
                return
        keystate = pygame.key.get_pressed()

        # clear/erase the last drawn sprites
        all.clear(screen, background)

        #update all the sprites
        all.update()

        #handle player input
        direction = keystate[K_RIGHT] - keystate[K_LEFT]
        player.move(direction)
        firing = keystate[K_SPACE]
        if not player.reloading and firing and len(shots) < MAX_SHOTS:
            Shot(player.gunpos())
            shoot_sound.play()
        player.reloading = firing

        # Create new alien
        if alienreload:
            alienreload = alienreload - 1
        elif not int(random.random() * ALIEN_ODDS):
            Alien()
            alienreload = ALIEN_RELOAD

        # Drop bombs
        if lastalien and not int(random.random() * BOMB_ODDS):
            Bomb(lastalien.sprite)

        # Detect collisions
        for alien in pygame.sprite.spritecollide(player, aliens, dokill=1):
            boom_sound.play()
            Explosion(alien)
            Explosion(player)
            SCORE = SCORE + 1
            player.kill()

        for alien in pygame.sprite.groupcollide(shots,
                                                aliens,
                                                dokilla=1,
                                                dokillb=1).keys():
            boom_sound.play()
            Explosion(alien)
            SCORE = SCORE + 1

        for bomb in pygame.sprite.spritecollide(player, bombs, dokill=1):
            boom_sound.play()
            Explosion(player)
            Explosion(bomb)
            player.kill()

        #draw the scene
        dirty = all.draw(screen)
        pygame.display.update(dirty)

        #cap the framerate
        clock.tick(40)

    if pygame.mixer:
        pygame.mixer.music.fadeout(1000)
    pygame.time.wait(1000)
    pygame.quit()
Пример #15
0
import pygame, sys
from pygame.locals import *

pygame.init()

WINDOW_SIZE = (1000, 600)
display = pygame.Surface((1000, 600))
screen = pygame.display.set_mode(WINDOW_SIZE, 0, 32)

pygame.display.set_caption('Platformer_v01')  # Window Name

WHITE = (255, 255, 255)
BLACK = (0, 0, 0)

tile_rects = []

global player_movement
max_fall_speed = 8
fall_speed = 0.5

clock = pygame.time.Clock()

background = pygame.image.load("C:/code/Pygame/RPG/Images/sky.jpg")

character = pygame.image.load('C:/code/Pygame/RPG/Images/blue.png')
# character.set_colorkey((255, 255, 255))

grass_tile = pygame.image.load('C:/code/Pygame/RPG/Images/grass_tile.png')
dirt_tile = pygame.image.load('C:/code/Pygame/RPG/Images/dirt_tile.png')
TILE_SIZE = grass_tile.get_width()
Пример #16
0
# Main file for game environment
# Credit to: https://pygame-gui.readthedocs.io/en/latest/quick_start.html
# for pygame environment

import pygame

pygame.init()

pygame.display.set_caption('Quick Start')
window_surface = pygame.display.set_mode((800, 600))

background = pygame.Surface((800, 600))
background.fill(pygame.Color('#000000'))

is_running = True

while is_running:

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

    window_surface.blit(background, (0, 0))

    pygame.display.update()
from pygame.locals import *

pygame.init()

OKNOGRY_SZER = 800
OKNOGRY_WYS = 400
LT_BLUE = (230, 255, 255)

oknogry = pygame.display.set_mode((OKNOGRY_SZER, OKNOGRY_WYS), 0, 32)
pygame.display.set_caption('Prosty Pong')

PALETKA_SZER = 100
PALETKA_WYS = 20
BLUE = (0, 0, 255)
PALETKA_1_POZ = (350, 360)
paletka1 = pygame.Surface([PALETKA_SZER, PALETKA_WYS])
paletka1.fill(BLUE)
paletka1_prost = paletka1.get_rect()
paletka1_prost.x = PALETKA_1_POZ[0]
paletka1_prost.y = PALETKA_1_POZ[1]

P_SZER = 20
P_WYS = 20
P_PREDKOSC_X = 4
P_PREDKOSC_Y = 4
GREEN = (0, 255, 0)
pilka = pygame.Surface([P_SZER, P_WYS], pygame.SRCALPHA, 32).convert_alpha()
pygame.draw.ellipse(pilka, GREEN, [0, 0, P_SZER, P_WYS])
pilka_prost = pilka.get_rect()
pilka_prost.x = OKNOGRY_SZER / 2
pilka_prost.y = OKNOGRY_WYS / 2
Пример #18
0
import pygame
from pygame.math import Vector2
import os

pygame.init()
gameDisplay = pygame.display.set_mode((800, 600))
pygame.display.set_caption('A bit Racey')
clock = pygame.time.Clock()
loop = True
pos = (120, 120)

filename = "Snake\\Assets\Images\\car0.png"
if filename == None or not os.path.exists(filename):
    image_base = pygame.Surface((70, 50), pygame.SRCALPHA)
    pygame.draw.polygon(image_base, (50, 120, 180),
                        ((0, 0), (0, 50), (70, 25)))
    car_rect = image_base.get_rect(center=pos)
else:
    image_base = pygame.image.load(filename).convert_alpha()
    car_rect = image_base.get_rect(center=pos)
    #car_rect.centerx = car_rect.width / 2
    #car_rect.centery = car_rect.height / 2


def rot_center(image, angle):
    center = image.get_rect().center
    rotated_image = pygame.transform.rotate(image, angle)
    new_rect = rotated_image.get_rect(center=center)
    return rotated_image, new_rect

Пример #19
0
def main():
    agent = dqn()
    agent.restore('save/ckpt')
    """Mainline logic for Getaway"""
    # D - Display configuration
    screen = pygame.display.set_mode((300, 700), 0, 32)
    pygame.display.set_caption("DISPLAY!")

    # E - Entities
    background = pygame.Surface(screen.get_size())
    background = background.convert()

    #Sounds
    pygame.mixer.music.load("Sounds/bgm.wav")
    pygame.mixer.music.set_volume(0.2)
    pygame.mixer.music.play(-1)

    crash = pygame.mixer.Sound("Sounds/crash.wav")
    crash.set_volume(0.3)

    coin = pygame.mixer.Sound("Sounds/coin.wav")
    coin.set_volume(0.3)

    power_up = pygame.mixer.Sound("Sounds/power_up.wav")
    power_up.set_volume(0.3)

    #Road Background
    road = pySprites.road(screen)

    #Scorekeeper

    #Car sprite
    car = pySprites.player_car()

    #Obstacles
    opposing_cars_group = []
    car1 = pySprites.other_cars()
    opposing_cars_group.append(car1)
    Scorekeeper = pySprites.ScoreKeeper(car, 100, 'speed')
    otherspeed = pySprites.ScoreKeeper(car1, 150, 'other_speed')

    #car2 = pySprites.other_cars()

    #opposing_cars_group.append(car2)
    obstacles = pygame.sprite.Group(opposing_cars_group, [])
    coin_group = []
    road_block_group = []
    speed_boost = []
    life_boost = []
    #allSprites Group

    # A - Action

    # A - Assign values
    clock = pygame.time.Clock()
    keepGoing = True

    move_up = False
    move_down = False
    move_left = False
    move_right = False
    counter = 0

    speedboost = False
    boostcounter = 0
    invincibility_flag = False
    inv_counter = 0
    vfree = 90
    current_state = pySprites.neirong()
    current_state.bian = "side road"
    chedao = pySprites.showbian(current_state, 200, 'Road')
    Vtree = pySprites.neirong()
    Vtree.bian = vfree
    zhuangtai = pySprites.showbian(Vtree, 50, 'expect')
    allSprites = pygame.sprite.OrderedUpdates(chedao, zhuangtai, road, car,
                                              otherspeed, opposing_cars_group,
                                              road_block_group, Scorekeeper)

    # L - Loop
    h = 0
    vdf = 0
    crashh = 0
    distance = 0
    total_time = 0
    state = [
        vfree, car.road, car1.road, 10 * round(car.speed / 36),
        round(car1.speed / 3.6), 10 * round(
            (car.rect.top - car1.rect.bottom) / 30)
    ]
    while keepGoing:
        total_time += 1
        if total_time % 1000 == 0:
            agent.restore('save/ckpt')
            print(distance)
            print(h)
            h = 0
        action = agent.action(state)
        # T - Timer
        clock.tick(30)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:

                pygame.mixer.music.fadeout(2000)
                keepGoing = False
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_DOWN:
                    vfree -= 5
                    Vtree.bian = vfree
                if event.key == pygame.K_UP:
                    vfree += 5
                    Vtree.bian = vfree
        #Ingame clock counter

        if action == 1:
            if car.road == 1:
                vdf = keepgo(car, car1, vfree)
            else:
                current_state.bian = "changing"
                crashh = change(car, allSprites, screen, background, clock,
                                obstacles, Scorekeeper)
                current_state.bian = "main road"
        else:
            if car.road == 2:
                vdf = keepgo(car, car1, vfree)
            else:
                current_state.bian = "changing"
                crashh = change(car, allSprites, screen, background, clock,
                                obstacles, Scorekeeper)
                current_state.bian = "over road"

        #Collision detection
        for obstacle in pygame.sprite.spritecollide(car, obstacles, False):
            obstacle.reset()
            Scorekeeper.death()
            crashh = 1
            h += 1
            crash.play()

        if crashh == 1:
            reward = -1000
        else:
            if vdf > 3:
                reward = -150
            else:
                if car.road == 2:
                    reward = car.speed / 3.6 - vfree / 3.6 - 0.1 * vdf - 2
                else:
                    reward = car.speed / 3.6 - vfree / 3.6 - 0.1 * vdf
            # R - Refresh display

        allSprites.clear(screen, background)
        allSprites.update(car.speed)
        allSprites.draw(screen)
        if crashh == 1:
            reward = -1000
        else:
            if vdf > 3:
                reward = -150
            else:
                if car.road == 2:
                    reward = car.speed / 3.6 - vfree / 3.6 - 0.1 * vdf - 2
                else:
                    reward = car.speed / 3.6 - vfree / 3.6 - 0.1 * vdf
        next_state = [
            vfree, car.road, car1.road, 10 * round(car.speed / 36),
            round(car1.speed / 3.6), 10 * round(
                (car.rect.top - car1.rect.bottom) / 30)
        ]
        #agent.preceive(state, action, reward, next_state, 0)
        state = next_state
        distance += car.speed
        pygame.display.flip()
    # Close the game window
    pygame.quit()
Пример #20
0
def get_Rectangulo(color, tamanio):
    ''' Devuelve una superficie según color y tamaño. '''
    superficie = pygame.Surface(tamanio, flags=HWSURFACE)
    superficie.fill(color)
    return superficie
Пример #21
0
 def set_text(self, text, color=(255, 255, 255), seconds=2.0):
     text_texture = self.font.render(text, True, color)
     self.surface = pygame.Surface(self.dim)
     self.seconds_left = seconds
     self.surface.fill((0, 0, 0, 0))
     self.surface.blit(text_texture, (10, 11))
Пример #22
0
def get_Rectangulo_Transparente(tamanio):
    ''' Devuelve una superficie según color y tamaño. '''
    superficie = pygame.Surface(tamanio, flags=HWSURFACE)
    superficie.fill(get_magenta())
    superficie.set_colorkey(get_magenta(), pygame.RLEACCEL)
    return superficie
Пример #23
0
 def preRender(self):
     self.surface = pygame.Surface((self.width, self.height))
     self.surface.blit(self.tableImg, (0, 0))
Пример #24
0
 def __init__(self, image_path, perso_img=perso["standard"]):
     self.image = pygame.image.load(image_path).convert().convert_alpha()
     self.surface = pygame.Surface((1200, 700))
     self.color = get_pixel_color(image_path)
     self.perso = pygame.image.load(perso_img)
Пример #25
0
'''
 * @author  anlzou
 * @date  2020/5/1 19:24
 * @version xx
 * @description xx
'''
import random, pygame

PANEL_width = 400
PANEL_highly = 500
FONT_PX = 15
pygame.init()
# 创建一个窗口
winSur = pygame.display.set_mode((PANEL_width, PANEL_highly))
font = pygame.font.SysFont('123.ttf', 22)
bg_suface = pygame.Surface((PANEL_width, PANEL_highly), flags=pygame.SRCALPHA)
pygame.Surface.convert(bg_suface)
bg_suface.fill(pygame.Color(0, 0, 0, 28))
winSur.fill((0, 0, 0))
letter = [
    'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', 'a', 's', 'd', 'f', 'g',
    'h', 'j', 'k', 'l', 'z', 'x', 'c', 'v', 'b', 'n', 'm'
]
texts = [font.render(str(letter[i]), True, (0, 255, 0)) for i in range(26)]
# 按窗口的宽度来计算可以在画板上放几列坐标并生成一个列表
column = int(PANEL_width / FONT_PX)
drops = [0 for i in range(column)]
while True:
    # 从队列中获取事件
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
Пример #26
0
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)

win = (800, 600)

pygame.init()

screen = pygame.display.set_mode(win)
pygame.display.set_caption('Snake')
screen.fill(BLACK)
pygame.display.flip()

snake = [[200, 200]]
surface = pygame.Surface(win, 0, 24)
clock = pygame.time.Clock()
clock.tick()

direction = ''
started = False

point = newpoint()

screen.fill(WHITE)

while True:
    for e in pygame.event.get():
        if e.type == KEYDOWN:
            if not started:
                started = True
Пример #27
0
def create_sprite(img, sprite_size):
    icon = pygame.image.load(img).convert_alpha()
    icon = pygame.transform.scale(icon, (sprite_size, sprite_size))
    sprite = pygame.Surface((sprite_size, sprite_size), pygame.HWSURFACE)
    sprite.blit(icon, (0, 0))
    return sprite
Пример #28
0
import pygame
import sys

pygame.init()
size = width, height = 800, 600
black = 0, 0, 0

screen = pygame.display.set_mode(size).convert()
pygame.display.set_caption("Vertical Line")

vertical_rect = pygame.Rect(40, 40, 10, 30)
vertical_line = pygame.Surface(vertical_rect.size)
vertical_line.fill((1, 255, 1))

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()

    #screen.fill(black)
    screen.blit(vertical_line, (400, 0))
    pygame.display.flip()
Пример #29
0
# Listing_18-2.py
# Copyright Warren Sande, 2009
# Released under MIT license   http://www.opensource.org/licenses/mit-license.php
# Version 61  ----------------------------

# Bouncing ball with up and down arrow keys

import pygame, sys
pygame.init()
screen = pygame.display.set_mode([640, 480])
background = pygame.Surface(screen.get_size())
background.fill([255, 255, 255])
clock = pygame.time.Clock()


class Ball(pygame.sprite.Sprite):
    def __init__(self, image_file, speed, location):
        pygame.sprite.Sprite.__init__(self)  #call Sprite initializer
        self.image = pygame.image.load(image_file)
        self.rect = self.image.get_rect()
        self.rect.left, self.rect.top = location
        self.speed = speed

    def move(self):
        if self.rect.left <= screen.get_rect().left or \
                 self.rect.right >= screen.get_rect().right:
            self.speed[0] = -self.speed[0]
        newpos = self.rect.move(self.speed)
        self.rect = newpos

 def add(self, widget):
     self.widgets.append(widget)
     w = int(self.screen.get_width()*widget.width)
     h = int(self.screen.get_height()*widget.height)
     self.surfaces[widget] = pygame.Surface((w,h),HWSURFACE|DOUBLEBUF)