#!/usr/bin/python3
if __name__ == "__main__":
import module.ctrl as ctrl
ctr = ctrl.Ctrl()
ctr.run()
else:
import sdl2
import sdl2.ext
import random
sdl2.ext.init()
window = sdl2.ext.Window("Triggered", size=(320, 371))
window.show()
RESOURCES = sdl2.ext.Resources(__file__, "./res")
factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE)
sprite = factory.from_image(RESOURCES.get_path("triggered.png"))
spriterenderer = factory.create_sprite_render_system(window)
running = True
while running:
events = sdl2.ext.get_events()
for event in events:
if event.type == sdl2.SDL_QUIT:
running = False
break
sprite.position = random.randrange(-5, 6), random.randrange(-5, 6)
spriterenderer.render(sprite)
sdl2.SDL_Delay(16)
window.hide()
def run():
out_blocks = ""
out_images = ""
all_blocks = []
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_EVERYTHING)
sdl_image.IMG_Init(sdl_image.IMG_INIT_PNG)
window = sdl2.ext.Window("BAConv", size=(1024, 384))
window.show()
ren = sdl2.ext.Renderer(window, flags=sdl2.SDL_RENDERER_ACCELERATED)
# makes zoomed graphics blocky (for retro effect)
sdl2.SDL_SetHint(sdl2.SDL_HINT_RENDER_SCALE_QUALITY, b"nearest")
# makes the graphics look and act like the desired screen size, even though they may be rendered at a different one
sdl2.SDL_RenderSetLogicalSize(ren.sdlrenderer, 256, 96)
max_blocks = 0
total_blocks = 0
count = 0
limit = 100
# pass 1 - gather all the blocks
for i in range(0, int(6565 / 4)):
count += 1
if count > limit: # stop early
break
events = sdl2.ext.get_events() # otherwise window doesn't update
ren.clear()
file = f"image-{i*4+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
image, blocks = processImage(
file, ren) # also draws left hand side pre-processed
# add blocks to master list
for i, block in enumerate(blocks):
found = False
for j, b in enumerate(all_blocks):
if block == b: # better match found update existing record
all_blocks[j].count += blocks[i].count
found = True # found a match of some sort
if not found: # totally new block
all_blocks.append(block)
num_blocks = len(blocks)
total_blocks += num_blocks
if max_blocks < num_blocks:
max_blocks = num_blocks
renderImage(image, blocks, ren) # right hand side post-process
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
print(f"Max blocks: {max_blocks}")
print(f"Total blocks: {total_blocks}")
print(f"Average blocks: {total_blocks/count}")
print(f"Processed {count} frames.")
# sort and choose top blocks
all_blocks.sort(reverse=True)
# 1024 is currently all you're planning to store
# todo: choose final number of blocks to use
# all_blocks=all_blocks[0:1024]
for i, b in enumerate(all_blocks):
print(f"Block {i}: {b.count}")
# pass 2 - build new images with top blocks
all_images = []
count = 0
for i in range(43, int(6509 / 2)):
count += 1
if count > limit: # stop early
break
ren.clear()
file = f"image-{i*2+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
image = reprocessImage(
file, ren, all_blocks) # also draws left hand side pre-processed
all_images.append(image)
renderImage(image, all_blocks, ren) # right hand side post-process
events = sdl2.ext.get_events() # otherwise window doesn't update
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
fr = 0
while True:
fr = (fr + 1) % len(all_images)
events = sdl2.ext.get_events() # otherwise window doesn't update
ren.clear()
file = f"image-{i*2+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
renderImage(all_images[fr], all_blocks, ren)
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
sdl2.SDL_Delay(10)
def main():
from os import sys
if len(sys.argv) <= 1:
show_commandline_help()
import font
from font import Font
import layers
from layers import HDTextLayer, TextLayer
import time
import sdl2
t0 = time.clock()
import ctypes
from ctypes import byref, cast, POINTER, c_int, c_float, sizeof, c_uint32, c_double, c_voidp, c_void_p
from sdl2 import endian
exp_font_name = sys.argv[1]
font_size = 48
if len(sys.argv) > 2:
font_size = int(sys.argv[2])
sdl2_DisplayManager.Init(10, 10, 1)
sdl2_DisplayManager.inst().fonts_init("Courier", "HHSam")
font_path = match_font(exp_font_name) #"coalition")
sdl2_DisplayManager.inst().font_add(
font_path=font_path, font_alias="export_font",
size=font_size) #, color=None, bgcolor=None)
char_size = 0
lChars = [chr(i + ord(' ')) for i in xrange(0, 95)]
for char_offset, c in zip(xrange(0, 95), lChars):
# surf = f.textHollow(c, line_color, interior_color, line_width, fill_color)
(font_width, font_height) = sdl2_DisplayManager.inst().font_get_size(
c, 'export_font', font_size)
char_size = max(char_size, font_width, font_height)
width = height = char_size * 10
font_sizes = ''
# hack stuff to re-attach the correctly sized window
sdl2_DisplayManager.inst().window = sdl2.ext.Window("Font Preview",
size=(width, height))
sdl2_DisplayManager.inst().texture_renderer = sdl2.ext.Renderer(
sdl2_DisplayManager.inst().window)
sdl2_DisplayManager.inst().fill = sdl2_DisplayManager.inst(
).texture_renderer.fill
sdl2_DisplayManager.inst().clear = sdl2_DisplayManager.inst(
).texture_renderer.clear
sdl2_DisplayManager.inst().factory = sdl2.ext.SpriteFactory(
renderer=sdl2_DisplayManager.inst().texture_renderer)
sdl2_DisplayManager.inst().show_window()
frame = Frame(width, height)
#BGR?
interior_color = (255, 255, 255)
line_width = 0
#fill_color = (255,0,0)
line_color = (1, 1, 1)
for char_offset, c in zip(xrange(0, 95), lChars):
# surf = f.textHollow(c, line_color, interior_color, line_width, fill_color)
surf = sdl2_DisplayManager.inst().font_render_bordered_text(
c,
font_alias='export_font',
size=font_size,
border_width=line_width,
border_color=line_color,
color=interior_color)
(w, h) = surf.size
(font_width, font_height) = sdl2_DisplayManager.inst().font_get_size(
c, 'export_font', font_size)
#font_sizes += format(font_width,'x')
font_sizes += str(font_width)
font_sizes += ","
F = Frame(width=w, height=h, from_surface=surf)
char_x = char_size * (char_offset % 10)
char_y = char_size * (char_offset / 10)
Frame.copy_rect(dst=frame,
dst_x=char_x,
dst_y=char_y,
src=F,
src_x=0,
src_y=0,
width=w,
height=h,
op='copy')
#x += width + self.tracking
sdl2_DisplayManager.inst().screen_blit(
source_tx=frame.pySurface,
expand_to_fill=True) #, area=(10,10,400,200))
texture_renderer = sdl2_DisplayManager.inst().texture_renderer
bk = sdl2.SDL_GetRenderTarget(texture_renderer.renderer)
t = sdl2.render.SDL_CreateTexture(texture_renderer.renderer,
sdl2.pixels.SDL_PIXELFORMAT_RGBA8888,
sdl2.render.SDL_TEXTUREACCESS_STREAMING,
width, height)
#create a new texture and blit the frame to it, then grab bits from that
texture_renderer.clear((0, 0, 0, 0))
sdl2.SDL_SetRenderTarget(texture_renderer.renderer, t)
#sdl2_DisplayManager.inst().blit(source_tx=frame.pySurface, dest_tx = t, dest = (0,0,512,512))
texture_renderer.copy(frame.pySurface, (0, 0, width, height),
(0, 0, width, height))
pitch = c_int()
bytes = c_void_p()
rect = sdl2.SDL_Rect(0, 0, width, height)
sdl2.SDL_LockTexture(t, rect, ctypes.byref(bytes), ctypes.byref(pitch))
if endian.SDL_BYTEORDER == endian.SDL_LIL_ENDIAN:
rmask = 0x000000FF
gmask = 0x0000FF00
bmask = 0x00FF0000
amask = 0xFF000000
else:
rmask = 0xFF000000
gmask = 0x00FF0000
bmask = 0x0000FF00
amask = 0x000000FF
print rmask
imgsurface = sdl2.surface.SDL_CreateRGBSurfaceFrom(bytes, width, height,
32, pitch, rmask, gmask,
bmask, amask)
if not imgsurface:
raise sdl2.ext.SDLError()
sdl2.SDL_RenderReadPixels(texture_renderer.renderer, rect, 0, bytes, pitch)
sdl2.SDL_SaveBMP(imgsurface, 'image.png')
#4) Restore renderer's texture target
sdl2.SDL_SetRenderTarget(texture_renderer.renderer, bk)
#ss = sdl2.ext.SoftwareSprite(surf, True)
#ss = sdl2.ext.SoftwareSprite(imgsurface, True)
#sdl2.SDL_SaveBMP(ss.contents, "file.bmp")
#
#
print font_sizes
sdl2_DisplayManager.inst().flip()
sdl2.SDL_Delay(2)
def main():
#cause I don't want to pass these around
global REN, SPRITE_FACTORY, SPRITE_RENDERER
global RESET_BUTTON, NEW_BUTTON, SOLVE_BUTTON
sdl2.ext.init()
window = sdl2.ext.Window("Slide Puzzle", size=(WINDOWWIDTH, WINDOWHEIGHT))
REN = sdl2.ext.Renderer(window)
window.show()
font_file = sysfont.get_font("freesans", sysfont.STYLE_BOLD)
font_manager = sdl2.ext.FontManager(font_file, size=BASICFONTSIZE)
#fontmanager=font_manager will be default_args passed to every sprite creation method
SPRITE_FACTORY = sdl2.ext.SpriteFactory(renderer=REN,
fontmanager=font_manager,
free=True)
SPRITE_RENDERER = SPRITE_FACTORY.create_sprite_render_system(window)
RESET_BUTTON, reset_rect = make_text(SPRITE_FACTORY,
"Reset",
WINDOWWIDTH - 120,
WINDOWHEIGHT - 90,
bg_color=TILECOLOR)
NEW_BUTTON, new_rect = make_text(SPRITE_FACTORY,
"New Game",
WINDOWWIDTH - 120,
WINDOWHEIGHT - 60,
bg_color=TILECOLOR)
SOLVE_BUTTON, solve_rect = make_text(SPRITE_FACTORY,
"Solve",
WINDOWWIDTH - 120,
WINDOWHEIGHT - 30,
bg_color=TILECOLOR)
mainBoard, solutionSeq = generateNewPuzzle(NUMSLIDES)
SOLVEDBOARD = getStartingBoard(
) # a solved board is the same as the board in a start state.
allMoves = [] # list of moves made from the solved configuration
print(NEW_BUTTON.area)
running = True
while running:
slideTo = None # the direction, if any, a tile should slide
msg = 'Click tile or press arrow keys to slide.' # contains the message to show in the upper left corner.
if mainBoard == SOLVEDBOARD:
msg = 'Solved!'
drawBoard(mainBoard, msg)
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_QUIT:
running = False
break
elif event.type == sdl2.SDL_WINDOWEVENT:
if event.window.event == sdl2.SDL_WINDOWEVENT_EXPOSED:
print("window exposed")
drawBoard(mainBoard, msg)
elif event.type == sdl2.SDL_MOUSEBUTTONUP:
pos = event.button.x, event.button.y
spotx, spoty = getSpotClicked(mainBoard, pos[0], pos[1])
pt = sdl2.SDL_Point(pos[0], pos[1])
if (spotx, spoty) == (None, None):
if sdl2.SDL_PointInRect(pt, reset_rect):
resetAnimation(mainBoard, allMoves)
allMoves = []
elif sdl2.SDL_PointInRect(pt, new_rect):
mainBoard, solutionSeq = generateNewPuzzle(NUMSLIDES)
allMoves = []
elif sdl2.SDL_PointInRect(pt, solve_rect):
resetAnimation(mainBoard, solutionSeq + allMoves)
allMoves = []
else:
#check if clicked tile was next to blank
blankx, blanky = getBlankPosition(mainBoard)
if spotx == blankx + 1 and spoty == blanky:
slideTo = LEFT
elif spotx == blankx - 1 and spoty == blanky:
slideTo = RIGHT
elif spotx == blankx and spoty == blanky + 1:
slideTo = UP
elif spotx == blankx and spoty == blanky - 1:
slideTo = DOWN
elif event.type == sdl2.SDL_KEYUP:
# check if the user pressed a key to slide a tile
sym = event.key.keysym.sym
if sym in (sdl2.SDLK_LEFT, sdl2.SDLK_a) and isValidMove(
mainBoard, LEFT):
slideTo = LEFT
elif sym in (sdl2.SDLK_RIGHT, sdl2.SDLK_d) and isValidMove(
mainBoard, RIGHT):
slideTo = RIGHT
elif sym in (sdl2.SDLK_UP, sdl2.SDLK_w) and isValidMove(
mainBoard, UP):
slideTo = UP
elif sym in (sdl2.SDLK_DOWN, sdl2.SDLK_s) and isValidMove(
mainBoard, DOWN):
slideTo = DOWN
elif event.key.keysym.sym == sdl2.SDLK_ESCAPE:
running = False
break
if slideTo:
slideAnimation(mainBoard, slideTo,
'Click tile or press arrow keys to slide.',
8) # show slide on screen
allMoves.append(slideTo) # record the slide
REN.present()
sdl2.SDL_Delay(1000 // FPS)
sdl2.ext.quit()
def sleep(self, ms):
"""Sleep a tick to avoid hogging the cpu."""
sdl2.SDL_Delay(ms)
video.SDL_GL_CONTEXT_PROFILE_CORE)
context = sdl2.SDL_GL_CreateContext(window)
glClearColor(0.5, 0.5, 0.5, 1.0)
glEnable(GL_DEPTH_TEST)
glViewport(0, 0, 800, 600)
shader = OpenGL.GL.shaders.compileProgram(
shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER))
vertex_array_object, vertex_buffer = create_vbo(shader)
event = sdl2.SDL_Event()
running = True
while running:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
if event.type == sdl2.SDL_QUIT:
running = False
elif (event.type == sdl2.SDL_KEYDOWN
and event.key.keysym.sym == sdl2.SDLK_ESCAPE):
running = False
render()
sdl2.SDL_GL_SwapWindow(window)
sdl2.SDL_Delay(10)
sdl2.SDL_GL_DeleteContext(context)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
def run():
global button_alpha
sdl2.ext.init()
#container = av.open(RESOURCES.get_path("darknet.mp4"))
container = av.open(RESOURCES.get_path("BOKK (loop)-162670765.mp4"))
video = next(s for s in container.streams)
W = video.format.width
H = video.format.height
window = sdl2.ext.Window("Hello World!", size=(W, H))
window.show()
print("Using hardware acceleration")
renderer = sdl2.ext.Renderer(window)
factory = sdl2.ext.SpriteFactory(sdl2.ext.TEXTURE, renderer=renderer)
sprite = factory.from_color(sdl2.ext.Color(r=255, g=255, b=255, a=255),
size=(W, H))
uifactory = sdl2.ext.UIFactory(factory)
button = uifactory.from_image(sdl2.ext.BUTTON,
RESOURCES.get_path("button.png"))
button.position = 200, 160
processor = sdl2.ext.TestEventProcessor()
button.click += onclick
spriterenderer = factory.create_sprite_render_system(window)
uiprocessor = sdl2.ext.UIProcessor()
sdl2.render.SDL_SetTextureAlphaMod(button.texture, 255)
font_mgr = sdl2.ext.FontManager(RESOURCES.get_path("Arial Bold.ttf"),
size=160,
color=RED)
print(dir(renderer))
#texture = sdl2.render.SDL_CreateTexture(renderer.renderer, sdl2.SDL_PIXELFORMAT_RGBA8888, sdl2.SDL_TEXTUREACCESS_STREAMING, W, H)
running = True
# while running:
for packet in container.demux(video):
fps = packet.duration // 10
dec = packet.decode()
for frame in dec:
sdl2.render.SDL_SetRenderDrawColor(renderer.renderer, 255, 128,
128, 255)
sdl2.render.SDL_RenderClear(renderer.renderer)
# frame = clip.get_frame(t)
pixels = frame.to_rgb().to_nd_array().ctypes.data_as(
ctypes.c_void_p)
surface = sdl2.surface.SDL_CreateRGBSurfaceFrom(
pixels, W, H, 8 * 3, 3 * W, 0x0000FF, 0x00FF00, 0x00FF00, 1)
tex = sdl2.render.SDL_CreateTextureFromSurface(
renderer.renderer, surface)
events = sdl2.ext.get_events()
for event in events:
if event.type == sdl2.SDL_QUIT:
running = False
break
# Pass the SDL2 events to the UIProcessor, which takes care of
# the user interface logic.
uiprocessor.dispatch([
button,
], event)
# Render all user interface elements on the window.
text_sprite = factory.from_text(
text, fontmanager=font_mgr) # Creating TextureSprite from Text
text_sprite.position = 10, 10
sprite.texture = tex
sdl2.render.SDL_SetTextureAlphaMod(sprite.texture, button_alpha)
spriterenderer.render((sprite, button, text_sprite))
sdl2.surface.SDL_FreeSurface(surface)
sdl2.render.SDL_DestroyTexture(tex)
sdl2.SDL_Delay(10)
sdl2.ext.quit()
return 0
def delay(self, ms):
''' Задержка в ms
* @returns {self}
'''
SDL.SDL_Delay(ms)
return self
raise RuntimeError("Cannot initialize audio system: {}".format(
sdl2.SDL_GetError()))
# int Mix_OpenAudio(int frequency, Uint16 format, int channels, int chunksize)
if sdlmixer.Mix_OpenAudio(44100, sdlmixer.MIX_DEFAULT_FORMAT, 2, 1024):
raise RuntimeError("Cannot open mixed audio: {}".format(
sdlmixer.Mix_GetError()))
sdlmixer.Mix_AllocateChannels(64)
sound_file = RESOURCES.get_path("Cat.wav")
sample = sdlmixer.Mix_LoadWAV(sdl2.ext.compat.byteify(sound_file, "utf-8"))
if sample is None:
raise RuntimeError("Cannot open audio file: {}".format(
sdlmixer.Mix_GetError()))
count = 5
while count > 0:
channel = sdlmixer.Mix_PlayChannel(channel=-1, chunk=sample, loops=0)
sdlmixer.Mix_SetPosition(channel, 270, 100)
print(channel)
if channel == -1:
raise RuntimeError("Cannot play sample: {}".format(
sdlmixer.Mix_GetError()))
# while sdlmixer.Mix_Playing(channel):
sdl2.SDL_Delay(800)
count -= 1
sdlmixer.Mix_CloseAudio()
sdl2.SDL_Quit(sdl2.SDL_INIT_AUDIO)
import logging
import math
import numpy as np
import sdl2
import sdl2.ext
from sdl2 import sdlgfx
width = 800
height = 600
sdl2.ext.init()
window = sdl2.ext.Window('window_title', size=(width, height))
window.show()
context = sdl2.ext.Renderer(window)
sdlgfx_green = 0xFFFFFFFF # 255 << 8
t = 0
while True:
context.clear(0)
t += 1
r = int(20 * (math.sin(t / 20) + 1))
print(r)
for i in range(0, 800, 20):
for j in range(0, 600, 20):
sdlgfx.circleColor(context.sdlrenderer, i, j, r, sdlgfx_green)
context.present()
sdl2.SDL_Delay(20)
def main():
sdl2.ext.init()
# Create the window
window = sdl2.ext.Window("Foo", size=(960, 640))
window.show()
# Create the spirte factory and the sprite for the player
factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE)
# Create the worl and spriterenderer system
world = sdl2.ext.World()
spriterenderer = SoftwareRenderer(window)
movement = MovementSystem(0, 0, 960, 640)
playerMovement = PlayerMovementSystem()
collision = CollisionSystem()
battleSystem = BattleSystem()
# Add all systems to the world
world.add_system(playerMovement)
world.add_system(collision)
world.add_system(movement)
world.add_system(spriterenderer)
world.add_system(battleSystem)
# Test map generation
grid = mapGen.buildMap(world, factory, 4)
grid.build(world, factory)
enemyTile = random.choice(grid.tiles)
enemy = Enemy(world, factory, enemyTile.position.x, enemyTile.position.y)
# Pick random location for player
playerTile = random.choice(grid.tiles)
player = Player(world, factory, playerTile.position.x, playerTile.position.y)
player_speed = 1
battleSystem.player = player
playerMovement.player = player
playerMovement.grid = grid
gridSystem = GridSystem(960, 640, player)
world.add_system(gridSystem)
# Colliders for said items
collision.player = player
collision.grid = grid
# Main event loop
running = True
key_down = False
while(running):
events = sdl2.ext.get_events()
for event in events:
# Hittin' dat X button doe
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_KEYUP:
key_down = False
# Movement
if event.type == sdl2.SDL_KEYDOWN:
d = None
if(not key_down):
if event.key.keysym.sym == sdl2.SDLK_UP:
d = Direction.NORTH
key_down = True
elif event.key.keysym.sym == sdl2.SDLK_e:
print("I'm attacking with", player.get_damage(), "!")
key_down = True
elif event.key.keysym.sym == sdl2.SDLK_f:
print("Consuming")
player.consume()
print("Player health now at,", player.playerdata.health)
elif event.key.keysym.sym == sdl2.SDLK_DOWN:
d = Direction.SOUTH
key_down = True
elif event.key.keysym.sym == sdl2.SDLK_LEFT:
d = Direction.EAST
key_down = True
elif event.key.keysym.sym == sdl2.SDLK_RIGHT:
d = Direction.WEST
key_down = True
if d != None:
collision.player_dir = d
enemy.random_move(grid)
playerMovement.walk(d)
sdl2.SDL_Delay(10)
world.process()
return 0
def main():
if len(sys.argv) < 3:
print("Please provide player file name and player id")
sys.exit(1)
gameplay.state.my_player_id = None
players_str = None
with open(sys.argv[1], "r") as player_file:
gameplay.state.my_player_id = int(sys.argv[2])
players_str = player_file.read()
player_adds = players_str.split()
num_players = len(player_adds)
messaging = MessagingHandler()
messaging.connect(player_adds, num_players, gameplay.state.my_player_id)
graphics.view.initView()
graphics.view.makeGameSubView()
running = True
gameplay.state.floor = Floor()
gameplay.state.floor.genFloor(10, 25)
gameplay.state.players = []
sim = Simulation()
for i in range(num_players):
gameplay.state.players.append(Player(i, 50 * i, 50))
sim.add_object(gameplay.state.players[i].collider)
gameplay.state.floor.board[0][0] = Room()
gameplay.state.floor.board[0][0].enemies = []
gameplay.state.floor.board[0][0].enemies.append(Monster(0, 100, 100))
sim.add_object(gameplay.state.floor.board[0][0].enemies[0].collider)
last_phys_time = sdl2.SDL_GetTicks()
while running == True:
frame_start = sdl2.SDL_GetTicks()
input_events = sdl2.ext.get_events()
game_events = []
for event in input_events:
if event.type == sdl2.SDL_QUIT:
running = False
break
else:
if not ControlsState.should_process_input_event(event):
continue
ControlsState.update_state(event)
player_event = gameplay.state.players[gameplay.state.my_player_id].processInputEvent(event)
if player_event.params["code"] == "NONE":
continue
game_events.append(player_event)
messaging.broadcast(player_event.serialize().encode("utf-8"))
for enemy in gameplay.state.floor.board[0][0].enemies:
enemy.chooseNewDirection(gameplay.state.players)
messages = messaging.get_messages()
while messages.qsize() > 0:
msg = messages.get()
game_events.append(GameEvent.deserialize(msg.decode("utf-8")))
for event in game_events:
if (event.params["type"] == "PLAYER"):
gameplay.state.players[event.params["player_id"]].processPlayerEvent(event)
curr_time = sdl2.SDL_GetTicks()
delta = curr_time - last_phys_time
last_phys_time = curr_time
sim.step(delta / 1000)
graphics.view.render()
frame_end = sdl2.SDL_GetTicks()
remaining_time = (frame_start + FRAME_LENGTH) - frame_end
if remaining_time > 0:
sdl2.SDL_Delay(remaining_time)
sdl2.ext.quit()
def run():
global camera, STEPS_PER_FRAME, world, astronomical_objects, stars
astronomical_objects = []
stars = []
sdl2.ext.init()
window = sdl2.ext.Window("Solar Orbiters", size=WINDOW_SIZE)
window.show()
if True:
print("Using hardware acceleration")
renderer = sdl2.ext.Renderer(window)
factory = sdl2.ext.SpriteFactory(sdl2.ext.TEXTURE, renderer=renderer)
else:
print("Using software rendering")
factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE)
world = sdl2.ext.World()
if factory.sprite_type == sdl2.ext.SOFTWARE:
spriterenderer = SoftwareRenderSystem(window)
else:
spriterenderer = TextureRenderSystem(renderer)
movementsystem = MovementSystem()
spritemovementsystem = SpriteMovementSystem()
camera = Camera3D()
world.add_system(movementsystem)
world.add_system(spritemovementsystem)
world.add_system(spriterenderer)
# Instantiate stars
for x, y, z in generate_random_directions(NUM_OF_STARS):
stars.append(Star(world, x, y, z))
# Parse solar system data from xml
tree = ET.parse(ASTRO_OBJECTS_XML_PATH)
root = tree.getroot()
# Instantiate planets
for astro_object in root.findall('object'):
if not MAKE_PLANETS:
break
color_elem = astro_object.find('color')
color = sdl2.ext.Color(int(color_elem[0].text),
int(color_elem[1].text),
int(color_elem[2].text))
diameter = max(1, int(float(astro_object.find('diameter').text) * 10))
sprite = factory.from_color(color, size=(diameter, diameter))
mass = (float(astro_object.find('mass').text) *
10**int(astro_object.find('mass')[0].text))
radius = 10000 # Temporary test number.
x = int(astro_object.find('position').find('x').text) * 1000
y = int(astro_object.find('position').find('y').text) * 1000
z = int(astro_object.find('position').find('z').text) * 1000
vx = float(astro_object.find('velocity').find('x').text) * 1000
vy = float(astro_object.find('velocity').find('y').text) * 1000
vz = float(astro_object.find('velocity').find('z').text) * 1000
astronomical_objects.append(
AstronomicalObject(world, sprite, mass, radius, x, y, z, vx, vy,
vz))
# Instantiate some Trojans... or were they Greeks?
mass = 100
origin = 778412010000
x0 = origin * math.cos(math.pi / 3)
y0 = origin * math.sin(math.pi / 3)
z0 = 0
radius = 1e11
vel0 = 13.0697 * 1000
vx0 = vel0 * math.cos(math.pi / 3 + math.pi / 2)
vy0 = vel0 * math.sin(math.pi / 3 + math.pi / 2)
vz0 = 0
v_deviation = 200
for i in range(TROJANS):
sprite = factory.from_color(GRAY, size=(2, 2))
x, y, z, vx, vy, vz = generate_asteroid_data(x0, y0, z0, radius, 0,
vx0, vy0, vz0,
v_deviation)
asteroid_radius = 10000 # Test variable, no real effect yet.
astronomical_objects.append(
AstronomicalObject(world, sprite, mass, asteroid_radius, x, y, z,
vx, vy, vz))
# Instantiate some Jupiter Orbiters
mass = 100
x0 = 778412010000
y0 = 0
z0 = 0
max_radius = 1e11
min_radius = 1e7
vx0 = 0
vy0 = 13.0697 * 1000
vz0 = 0
v_deviation = 1e3
radius = 10000 # Temporary test number.
for i in range(JUPITER_ORBITERS):
sprite = factory.from_color(GRAY, size=(2, 2))
x, y, z, vx, vy, vz = generate_asteroid_data(x0, y0, z0, max_radius,
min_radius, vx0, vy0, vz0,
v_deviation)
astronomical_objects.append(
AstronomicalObject(world, sprite, mass, radius, x, y, z, vx, vy,
vz))
# Instantiate some random asteroids.
mass = 100
x0 = 0
y0 = 0
z0 = 0
max_radius = 1e12
min_radius = 1e7
vx0 = 0
vy0 = 0
vz0 = 0
v_deviation = 1e5
radius = 10000 # Temporary test number.
for i in range(FREE_ASTEROIDS):
sprite = factory.from_color(GRAY, size=(2, 2))
x, y, z, vx, vy, vz = generate_asteroid_data(x0, y0, z0, max_radius,
min_radius, vx0, vy0, vz0,
v_deviation)
astronomical_objects.append(
AstronomicalObject(world, sprite, mass, radius, x, y, z, vx, vy,
vz))
# Instantiate some random planetoids.
# Pretty messy. Should clean up a bit.
mass = 1e28
x0 = 0
y0 = 0
z0 = 0
max_radius = 1e12
min_radius = 1e7
vx0 = 0
vy0 = 0
vz0 = 0
v_deviation = 1e4
radius = 10000 # Temporary test number.
for i in range(EXTRA_PLANETOIDS):
sprite = factory.from_color(GRAY, size=(10, 10))
x, y, z, vx, vy, vz = generate_asteroid_data(x0, y0, z0, max_radius,
min_radius, vx0, vy0, vz0,
v_deviation)
astronomical_objects.append(
AstronomicalObject(world, sprite, mass, radius, x, y, z, vx, vy,
vz))
running = True
# An input dictionary for continuous input.
keymap_dict = {
'translate-left': sdl2.SDLK_j,
'translate-right': sdl2.SDLK_l,
'translate-up': sdl2.SDLK_i,
'translate-down': sdl2.SDLK_k,
'translate-forward': sdl2.SDLK_h,
'translate-backward': sdl2.SDLK_n,
'zoom-in': sdl2.SDLK_x,
'zoom-out': sdl2.SDLK_z,
'pitch-down': sdl2.SDLK_w,
'pitch-up': sdl2.SDLK_s,
'yaw-left': sdl2.SDLK_a,
'yaw-right': sdl2.SDLK_d,
'roll-left': sdl2.SDLK_q,
'roll-right': sdl2.SDLK_e
}
input_set = set()
while running:
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_QUIT:
running = False
break
elif event.type == sdl2.SDL_KEYDOWN:
# The repeat delay is useful for speeding up or slowing down
# the simulation, but not for camera rotation.
if event.key.keysym.sym == sdl2.SDLK_PERIOD:
STEPS_PER_FRAME += 1
elif event.key.keysym.sym == sdl2.SDLK_COMMA:
STEPS_PER_FRAME = max(0, STEPS_PER_FRAME - 1)
else:
input_set.add(event.key.keysym.sym)
elif event.type == sdl2.SDL_KEYUP:
try:
input_set.remove(event.key.keysym.sym)
except:
# Ignore orphan KEYUP events.
pass
if keymap_dict['translate-forward'] in input_set:
camera.translate(0.5, 0, 0)
if keymap_dict['translate-backward'] in input_set:
camera.translate(-0.5, 0, 0)
if keymap_dict['translate-up'] in input_set:
camera.translate(0, 0.5, 0)
if keymap_dict['translate-down'] in input_set:
camera.translate(0, -0.5, 0)
if keymap_dict['translate-left'] in input_set:
camera.translate(0, 0, -0.5)
if keymap_dict['translate-right'] in input_set:
camera.translate(0, 0, 0.5)
if keymap_dict['zoom-in'] in input_set:
camera.zoom(0.1)
if keymap_dict['zoom-out'] in input_set:
camera.zoom(-0.1)
if keymap_dict['pitch-down'] in input_set:
camera.pitch(0.03)
if keymap_dict['pitch-up'] in input_set:
camera.pitch(-0.03)
if keymap_dict['yaw-left'] in input_set:
camera.yaw(-0.03)
if keymap_dict['yaw-right'] in input_set:
camera.yaw(0.03)
if keymap_dict['roll-left'] in input_set:
camera.roll(-0.03)
if keymap_dict['roll-right'] in input_set:
camera.roll(0.03)
sdl2.SDL_Delay(10)
world.process()
def run():
sdl2.ext.init()
window = sdl2.ext.Window("Parallax Scroll", size=window_size)
world = sdl2.ext.World()
renderer = sdl2.ext.Renderer(window)
renderer.blendmode = sdl2.SDL_BLENDMODE_NONE
if txtr == 1:
sprite_factory = sdl2.ext.SpriteFactory(renderer=renderer)
else:
sprite_factory = sdl2.ext.SpriteFactory(sprite_type=sdl2.ext.SOFTWARE,
renderer=renderer)
sprite_render_system = sprite_factory.create_sprite_render_system(window)
print("created sprite render system " + str(type(sprite_render_system)))
movement = move(0, 0, window_size[0], window_size[1])
rands = [] #([],[],[])
for i in range(0, (window_size[1] / 2) * 3):
#print(i)
for j in range(0, 3):
#print(j)
if txtr == 1:
sprite = sprite_factory.create_texture_sprite(renderer, (8, 8))
else:
sprite = sprite_factory.create_software_sprite((8, 8))
sprite.fill((255, 0, 255, 0.5))
#sprite.from
init_sprite_loc(sprite)
vel = Velocity()
vel.vy = j
vels.append(vel)
#rands[j].append((vel, sprite))
rands.append(sprite)
noise_obj(world, sprite, vel)
#print(rands)
window.show()
#divide in half whatever the desired percentage of the screen is (0.5 becomes 0.25, 0.8 would be 0.4)
for i in range(0, int(window_size[1] * percentage // 2.0)):
renderer.draw_line((0, (window_size[1] / 2) - i - 2, window_size[0],
(window_size[1] / 2) - i - 2), (0x000000FF))
renderer.draw_line((0, (window_size[1] / 2) - i - 1, window_size[0],
(window_size[1] / 2) - i - 1), (0x000000FF))
renderer.draw_line((0, (window_size[1] / 2) - i, window_size[0],
(window_size[1] / 2) - i), (0x000000AF))
renderer.draw_line((0, (window_size[1] / 2) + i, window_size[0],
(window_size[1] / 2) + i), (0x000000AF))
renderer.draw_line((0, (window_size[1] / 2) + i + 1, window_size[0],
(window_size[1] / 2) + i + 1), (0x000000FF))
renderer.draw_line((0, (window_size[1] / 2) + i + 2, window_size[0],
(window_size[1] / 2) + i + 2), (0x000000FF))
renderer.present()
sdl2.SDL_Delay(10)
world.add_system(movement)
#print(world.systems)
running = True
while running:
events = sdl2.ext.get_events()
#for i in range(0, 300):
sprite_render_system.render(rands)
renderer.present()
for event in events:
if event.type == sdl2.SDL_QUIT or (event.type == sdl2.SDL_KEYDOWN
and event.key.keysym.sym
== sdl2.SDLK_ESCAPE):
running = False
break
#sdl2.SDL_Delay(33)
world.process()
sprite_render_system.render(rands) #, clear=True)
#renderer.clear()
renderer.present()
#refresh only needed for sw/surface
window.refresh()
return 0
def frame_limiter(self, speed):
now = sdl2.SDL_GetTicks()
delay = int(1000.0 / (60.0 * speed) - (now - self._ticks))
sdl2.SDL_Delay(delay if delay > 0 else 0)
self._ticks = sdl2.SDL_GetTicks()
def _sleep(self):
""" Sleep a tick to avoid hogging the cpu. """
sdl2.SDL_Delay(tick_ms)
def main():
sdl2.sdl2_load(
ctypes.util.find_library('SDL2'), # '/usr/local/lib/libSDL2.dylib'
ttf_libpath=ctypes.util.find_library('SDL2_ttf'),
img_libpath=ctypes.util.find_library('SDL2_image'),
gfx_libpath=ctypes.util.find_library('SDL2_gfx'))
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
WINDOW_W = 640
WINDOW_H = 360
window = sdl2.SDL_CreateWindow(b"Minimal SDL2_gfx Test via python-sdl2", 0,
0, WINDOW_W, WINDOW_H,
sdl2.SDL_WINDOW_OPENGL)
renderer = sdl2.SDL_CreateRenderer(window, -1, 0)
fpsdelay = 100
count = 0
event = sdl2.SDL_Event()
done = False
while not done:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
# 'type' and 'timestamp' are common members for all SDL Event structs.
event_type = event.common.type
# event_timestamp = event.common.timestamp
# print("Event : type=0x%s, timestamp=%s" % (event_type, event_timestamp) )
if event_type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
done = True
sdl2.SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF)
sdl2.SDL_RenderClear(renderer)
sdl2.pixelColor(renderer, 100, 100,
0xFFFFFFFF) # Uint32 color = 0x[AA][BB][GG][RR]
sdl2.pixelRGBA(renderer, 101, 100, 0xFF, 0x00, 0x00, 0xFF)
sdl2.hlineColor(renderer, 0, 100, 50, 0xFFFFFFFF)
sdl2.vlineColor(renderer, 50, 0, 100, 0xFFFF00FF)
sdl2.rectangleColor(renderer, 5, 5, 95, 95, 0xFF00FFFF)
sdl2.rectangleRGBA(renderer, 10, 10, 90, 90, 0, 0, 0xFF, 0xFF)
sdl2.circleColor(renderer, 150, 150, 50, 0xFF00FF00)
sdl2.filledCircleRGBA(renderer, 150, 150, 45, 0x00, 0xFF, 0x00, 0xFF)
sdl2.aalineColor(renderer, 200, 200, 300, 300, 0xFFFFFFFF)
sdl2.aalineColor(renderer, 300, 200, 200, 300, 0xFFFFFFFF)
sdl2.aacircleColor(renderer, 300, 200, 25, 0xFF00FF00)
sdl2.pieColor(renderer, 200, 300, 25, 0, 270, 0xFF00FF00)
sdl2.SDL_RenderPresent(renderer)
sdl2.SDL_Delay(fpsdelay)
sdl2.IMG_Quit()
sdl2.SDL_DestroyRenderer(renderer)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
def run():
# Create the environment, in which our particles will exist.
world = sdl2.ext.World()
# Set up the globally available information about the current mouse
# position. We use that information to determine the emitter
# location for new particles.
world.mousex = 400
world.mousey = 300
# Create the particle engine. It is just a simple System that uses
# callback functions to update a set of components.
engine = sdl2.ext.particles.ParticleEngine()
# Bind the callback functions to the particle engine. The engine
# does the following on processing:
# 1) reduce the life time of each particle by one
# 2) create a list of particles, which's life time is 0 or below.
# 3) call createfunc() with the world passed to process() and
# the list of dead particles
# 4) call updatefunc() with the world passed to process() and the
# set of particles, which still are alive.
# 5) call deletefunc() with the world passed to process() and the
# list of dead particles. deletefunc() is respsonible for
# removing the dead particles from the world.
engine.createfunc = createparticles
engine.updatefunc = updateparticles
engine.deletefunc = deleteparticles
world.add_system(engine)
# We create all particles at once before starting the processing.
# We also could create them in chunks to have a visually more
# appealing effect, but let's keep it simple.
createparticles(world, None, 300)
# Initialize the video subsystem, create a window and make it visible.
sdl2.ext.init()
window = sdl2.ext.Window("Particles", size=(800, 600))
window.show()
# Create a hardware-accelerated sprite factory. The sprite factory requires
# a rendering context, which enables it to create the underlying textures
# that serve as the visual parts for the sprites.
renderer = sdl2.ext.Renderer(window)
factory = sdl2.ext.SpriteFactory(sdl2.ext.TEXTURE, renderer=renderer)
# Create a set of images to be used as particles on rendering. The
# images are used by the ParticleRenderer created below.
images = (factory.from_image(RESOURCES.get_path("circle.png")),
factory.from_image(RESOURCES.get_path("square.png")),
factory.from_image(RESOURCES.get_path("star.png")))
# Center the mouse on the window. We use the SDL2 functions directly
# here. Since the SDL2 functions do not know anything about the
# sdl2.ext.Window class, we have to pass the window's SDL_Window to it.
sdl2.SDL_WarpMouseInWindow(window.window, world.mousex, world.mousey)
# Hide the mouse cursor, so it does not show up - just show the
# particles.
sdl2.SDL_ShowCursor(0)
# Create the rendering system for the particles. This is somewhat
# similar to the SoftSpriteRenderSystem, but since we only operate with
# hundreds of particles (and not sprites with all their overhead),
# we need an own rendering system.
particlerenderer = ParticleRenderSystem(renderer, images)
world.add_system(particlerenderer)
# The almighty event loop. You already know several parts of it.
running = True
while running:
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_MOUSEMOTION:
# Take care of the mouse motions here. Every time the
# mouse is moved, we will make that information globally
# available to our application environment by updating
# the world attributes created earlier.
world.mousex = event.motion.x
world.mousey = event.motion.y
# We updated the mouse coordinates once, ditch all the
# other ones. Since world.process() might take several
# milliseconds, new motion events can occur on the event
# queue (10ths to 100ths!), and we do not want to handle
# each of them. For this example, it is enough to handle
# one per update cycle.
sdl2.SDL_FlushEvent(sdl2.SDL_MOUSEMOTION)
break
world.process()
sdl2.SDL_Delay(1)
sdl2.ext.quit()
return 0
def run():
lib.init()
window = lib.Window('RLSnake', size=(window_width, window_height))
window.show()
renderer = lib.Renderer(window)
font_manager = sdl2.ext.FontManager(
font_path="assets/fonts/Roboto-Regular.ttf", size=14)
factory = sdl2.ext.SpriteFactory(renderer=renderer)
text = factory.from_text("Current score: ", fontmanager=font_manager)
snake = Snake(n_grid_x, n_grid_y)
snake.reset()
moves = 0
running = True
game_over = False
current_tiles = snake.get_tiles()
while running:
events = sdl2.ext.get_events()
for event in events:
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
running = False
break
if event.key.keysym.sym == 114:
snake.reset()
game_over = False
current_tiles = snake.get_tiles()
moves = 0
break
if not game_over:
if event.key.keysym.sym == sdl2.SDLK_UP:
_, game_over, _ = snake.step(3)
current_tiles = snake.get_tiles()
moves += 1
elif event.key.keysym.sym == sdl2.SDLK_DOWN:
_, game_over, _ = snake.step(2)
current_tiles = snake.get_tiles()
moves += 1
elif event.key.keysym.sym == sdl2.SDLK_LEFT:
_, game_over, _ = snake.step(1)
current_tiles = snake.get_tiles()
moves += 1
elif event.key.keysym.sym == sdl2.SDLK_RIGHT:
_, game_over, _ = snake.step(0)
current_tiles = snake.get_tiles()
moves += 1
renderer.clear(sdl2.ext.Color(0, 0, 0))
draw_grid(renderer)
for x in range(len(current_tiles)):
for y in range(len(current_tiles[x])):
tile = current_tiles[x][y]
if tile == 0:
continue
if tile == 1:
continue
if tile == 2:
if game_over:
fill_tile(renderer, int(x), int(y),
COLOR_SNAKE_GAME_OVER)
else:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE)
if tile == 4:
if game_over:
fill_tile(renderer, int(x), int(y),
COLOR_SNAKE_GAME_OVER)
else:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_HEAD)
if tile == 3:
fill_circle(renderer, int(x), int(y), COLOR_FOOD)
text = factory.from_text("Current score: " + str(snake.get_score()),
fontmanager=font_manager)
renderer.copy(text, dstrect=(0, 0, text.size[0], text.size[1]))
text = factory.from_text("Move: " + str(moves),
fontmanager=font_manager)
renderer.copy(text, dstrect=(0, 14, text.size[0], text.size[1]))
renderer.present()
sdl2.SDL_Delay(33)
return 0
def run():
lib.init()
window = lib.Window('RLSnake', size=(window_width, window_height))
window.show()
renderer = lib.Renderer(window)
fontManager = sdl2.ext.FontManager(font_path = "assets/fonts/Roboto-Regular.ttf", size = 14)
factory = sdl2.ext.SpriteFactory(renderer=renderer)
text = factory.from_text("Current score: ",fontmanager=fontManager)
snake = Snake(n_grid_x, n_grid_y)
snake.set_visibility_range(args.visibility_range)
snake.reset()
network = ActorCriticNetwork(4, fc1_dims=args.neurons, fc2_dims=args.neurons)
agent = TfAgent(network)
agent.load_weights(args.model_path)
autoplay = args.autoplay
moves = 0
running = True
game_over = False
old_score = 0
current_tiles = snake.get_tiles()
while running:
events = sdl2.ext.get_events()
for event in events:
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
running = False
break
if event.key.keysym.sym == 112:
autoplay = not autoplay
if event.key.keysym.sym == 114:
snake.reset()
moves = 0
old_score = 0
game_over = False
current_tiles = snake.get_tiles()
break
if not game_over:
if not autoplay:
if event.key.keysym.sym == sdl2.SDLK_SPACE:
action = agent.get_action(snake.get_view_obs())
_, game_over, _ = snake.step(action)
current_tiles = snake.get_tiles()
moves += 1
if autoplay:
action = agent.get_action(snake.get_view_obs())
_, game_over, _ = snake.step(action)
current_tiles = snake.get_tiles()
moves += 1
renderer.clear(sdl2.ext.Color(0, 0, 0))
draw_grid(renderer)
for x in range(len(current_tiles)):
for y in range(len(current_tiles[x])):
tile = current_tiles[x][y]
if tile == 0:
continue
if tile == 1:
continue
if tile == 2:
if game_over:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_GAME_OVER)
else:
if snake.get_score() > old_score:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_EATEN)
else:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE)
if tile == 4:
if game_over:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_GAME_OVER)
else:
if snake.get_score() > old_score:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_HEAD_EATEN)
else:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_HEAD)
if tile == 3:
fill_circle(renderer, int(x), int(y), COLOR_FOOD)
for tile in snake.get_current_view():
fill_tile(renderer, int(tile[0]), int(tile[1]), COLOR_VIEW_RANGE)
if snake.get_score() > old_score:
old_score = snake.get_score()
text = factory.from_text("Current score: " + str(snake.get_score()), fontmanager=fontManager)
renderer.copy(text, dstrect=(0, 0, text.size[0],text.size[1]))
if autoplay:
text = factory.from_text("Move: " + str(moves) + " / " + str(MAX_MOVES), fontmanager=fontManager)
else:
text = factory.from_text("Move: " + str(moves), fontmanager=fontManager)
renderer.copy(text, dstrect=(0, 14, text.size[0],text.size[1]))
renderer.present()
sdl2.SDL_Delay(args.sleep)
if autoplay and (game_over or moves >= MAX_MOVES):
snake.reset()
moves = 0
old_score = 0
game_over = False
return 0
def run(self):
prompt = CommandPrompt(self)
print(">>> ", end='', flush=True)
event = sdl2.SDL_Event()
toc = 0
tic_toc_freq = sdl2.SDL_GetPerformanceFrequency()
period = 1
excess = 0
remaining_cycles = 0
input_line = []
if self.has_sdl_audio:
sdl2.SDL_PauseAudioDevice(self.audio_dev, 0)
cpu_clock_rate = self.atari.color_clock_rate / 3
reasons = [Atari2600.StoppingReason.FRAME_DONE]
current_input = self.input_stream[self.atari.frame_number]
new_input = copy.deepcopy(current_input)
while not self.done:
# Timing.
tic = toc
toc = sdl2.timer.SDL_GetPerformanceCounter()
elapsed = (toc - tic) / tic_toc_freq
if elapsed > 1:
# Too slow: reset counters. This may be caused by the program being
# resumed or initialized.
tic = toc
elapsed = 0
elif elapsed < 1 / self.max_fps:
# Too fast: throttle the simulation. This may be caused by
# VSYNC is not working, for instance because the game window is hidden.
sdl2.SDL_Delay(int(1000 * (1 / self.max_fps - elapsed)))
toc = sdl2.timer.SDL_GetPerformanceCounter()
elapsed = (toc - tic) / tic_toc_freq
period = 0.95 * period + 0.05 * elapsed
# Parse the SDL events.
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
if event.type == sdl2.SDL_QUIT:
self.done = True
elif (event.type == sdl2.SDL_KEYUP or event.type
== sdl2.SDL_KEYDOWN) and event.key.repeat == 0:
if event.type == sdl2.SDL_KEYDOWN:
if (event.key.keysym.sym == sdl2.SDLK_EQUALS
or event.key.keysym.sym == sdl2.SDLK_KP_PLUS):
self.speed = min(5., self.speed + 0.25)
print(f"Speed increased to {self.speed}")
continue
elif event.key.keysym.sym == sdl2.SDLK_0:
self.speed = 1.
print(f"Speed reset to {self.speed}")
continue
elif event.key.keysym.sym == sdl2.SDLK_MINUS:
self.speed = max(0., self.speed - 0.25)
print(f"Speed decreased to {self.speed}")
continue
if self.switches_interface.update(event.key, new_input):
continue
if new_input.peripheral_type == Input.Type.JOYSTICK:
if self.joysticks_interface.update(
event.key, new_input):
continue
elif new_input.peripheral_type == Input.Type.PADDLE:
if self.paddles_interface.update(event.key, new_input):
continue
elif event.type == sdl2.SDL_WINDOWEVENT:
if event.window.event == sdl2.SDL_WINDOWEVENT_RESIZED:
pass
elif (event.type == sdl2.SDL_JOYDEVICEADDED
or event.type == sdl2.SDL_CONTROLLERDEVICEADDED):
self.joysticks_interface.associate_sdl_joystick(
event.cdevice.which, verbose=self.verbosity > 0)
elif (event.type == sdl2.SDL_JOYDEVICEREMOVED
or event.type == sdl2.SDL_CONTROLLERDEVICEREMOVED):
self.joysticks_interface.disassociate_sdl_device(
event.cdevice.which)
elif (event.type == sdl2.SDL_JOYAXISMOTION
or event.type == sdl2.SDL_JOYHATMOTION
or event.type == sdl2.SDL_JOYBUTTONUP
or event.type == sdl2.SDL_JOYBUTTONDOWN):
if new_input.peripheral_type == Input.Type.JOYSTICK:
if self.joysticks_interface.update_sdl_joystick(
event, new_input):
continue
elif new_input.peripheral_type == Input.Type.PADDLE:
if self.paddles_interface.update_sdl_joystick(
event, new_input):
continue
# Parse the console events.
if os.name == 'nt':
pass
else:
dr, _, _ = select.select([sys.stdin], [], [], 0.0)
if sys.stdin in dr:
input_line = sys.stdin.read(1024)
prompt.onecmd(input_line)
print(">>> ", end='', flush=True)
# Simulate an amount of CPU cycles equivalent to the real time elapsed.
# Limit this to roughly two video frames.
if not self.paused:
remaining_cycles += cpu_clock_rate * elapsed * self.speed
remaining_cycles = int(
min(remaining_cycles, cpu_clock_rate * 2 / 60))
while remaining_cycles > 0:
# At the beginning of each new frame, adjust the input stream.
if Atari2600.StoppingReason.FRAME_DONE in reasons:
if new_input.peripheral_type == Input.Type.PADDLE:
self.paddles_interface.integrate(new_input)
# Feed the *current* input to the console.
if new_input != current_input:
self.input_stream[self.atari.frame_number] = new_input
current_input = self.input_stream[self.atari.frame_number]
self.atari.set_panel(current_input.panel)
if current_input.peripheral_type == Input.Type.JOYSTICK:
for k in range(2):
self.atari.set_joystick(
k, current_input.peripheral[k])
elif current_input.peripheral_type == Input.Type.PADDLE:
for k in range(4):
self.atari.set_paddle(k,
current_input.peripheral[k])
new_input = copy.deepcopy(current_input)
# Simulate.
reasons, remaining_cycles = self.atari.cycle(
remaining_cycles)
# Copy the screen content to the video texture.
frame = self.atari.get_last_frame()
pixels = ctypes.c_void_p()
pitch = ctypes.c_int()
sdl2.SDL_LockTexture(self.texture, None, ctypes.byref(pixels),
ctypes.byref(pitch))
ctypes.memmove(pixels, bytes(frame),
frame.width * frame.height * 4)
sdl2.SDL_UnlockTexture(self.texture)
sdl2.SDL_SetRenderTarget(self.renderer, self.texture)
# Render the video texture.
bounds = [0, frame.height - 1]
sdl2.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, 0xff)
sdl2.SDL_RenderClear(self.renderer)
w = ctypes.c_int()
h = ctypes.c_int()
sdl2.SDL_GetWindowSize(self.screen, w, h)
scale = min(w.value / (frame.width * self.aspect),
h.value / (bounds[1] - bounds[0] + 1))
w_ = int(frame.width * self.aspect * scale)
h_ = int((bounds[1] - bounds[0] + 1) * scale)
dh_ = int(bounds[0] * scale)
r = sdl2.SDL_Rect((int(w.value) - w_) // 2,
(int(h.value) - h_) // 2 - dh_, w_, h_)
sdl2.SDL_RenderCopy(self.renderer, self.texture, None, r)
sdl2.SDL_RenderPresent(self.renderer)
if self.has_sdl_audio:
sdl2.SDL_PauseAudioDevice(self.audio_dev, 1)
def run():
sdl2.ext.init()
factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE)
window = sdl2.ext.Window("Arkanoid v1", size=(800, 1000))
window.show()
world = sdl2.ext.World()
spriteRenderer = SoftwareRenderer(window)
world.add_system(spriteRenderer)
movement = MovementSyste(0, 0, 800, 1000)
world.add_system(movement)
collision = CollisionSystem(0, 0, 800, 1000)
world.add_system(collision)
sp_paddle = factory.from_color(WHITE, size=(100, 20))
paddle = Paddle(world, sp_paddle, 350, 980)
collision.paddle = paddle
sp_ball = factory.from_color(WHITE, size=(20, 20))
ball = Ball(world, sp_ball, 390, 960)
collision.ball = ball
brickList = []
for j in range(0, 25):
poy = 52 + j*22
for i in range(0, 10):
pox = 52 + i*42
sp_brick = factory.from_color(WHITE, size=(40,20))
brick = Brick(world, sp_brick, pox, poy)
brickList.append(brick)
collision.lis = brickList
player = Player(1)
collision.player = player
img = factory.from_image(RESOURCES.get_path("koniecgry.jpg"))
running = True
flag = False
while running:
events = sdl2.ext.get_events()
if player.zycia < 0:
world.process()
break
for event in events:
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_RIGHT:
paddle.velocity.vx = 3
if(ball.velocity.vx == 0 and ball.velocity.vy == 0 and
ball.sprite.x < 800-62):
ball.velocity.vx = 3
flag = True
elif event.key.keysym.sym == sdl2.SDLK_LEFT:
paddle.velocity.vx = -3
if(ball.velocity.vx == 0 and ball.velocity.vy == 0 and
ball.sprite.x > 42):
ball.velocity.vx = -3
flag = True
if event.key.keysym.sym == sdl2.SDLK_SPACE:
if ball.velocity.vx == 0 and ball.velocity.vy == 0:
ball.velocity.vy = -3
tmp = random.randint(1, 2)
if tmp == 1: ball.velocity.vx = -3
else: ball.velocity.vx = 3
elif event.type == sdl2.SDL_KEYUP:
if event.key.keysym.sym in (sdl2.SDLK_RIGHT, sdl2.SDLK_LEFT):
paddle.velocity.vx = 0
if flag:
ball.velocity.vx = 0
ball.velocity.vy = 0
flag = False
sdl2.SDL_Delay(8)
world.process()
while running:
ball = None
#spriterenderer = factory.create_sprite_render_system(window)
#spriterenderer.render(img)
events = sdl2.ext.get_events()
for event in events:
if event.type == sdl2.SDL_QUIT:
running = False
break
return 0
def run(game_info):
sdl2.ext.init()
window = sdl2.ext.Window("The Pong Game", size=(800, 600))
window.show()
factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE)
# Create the paddles - we want white ones. To keep it easy enough for us,
# we create a set of surfaces that can be used for Texture- and
# Software-based sprites.
sp_paddle1 = factory.from_color(WHITE, size=(20, 100))
sp_paddle2 = factory.from_color(WHITE, size=(20, 100))
sp_ball = factory.from_color(WHITE, size=(20, 20))
sp_midline = factory.from_color(WHITE, size=(4, 600))
world = sdl2.ext.World()
movement = MovementSystem(0, 0, 800, 600)
spriterenderer = SoftwareRenderSystem(window)
world.add_system(movement)
world.add_system(spriterenderer)
if game_info.num_players == 1:
if game_info.difficulty == 'Easy':
PADDLE_SPEED_AI = 3
BALL_SPEED = 3
elif game_info.difficulty == 'Medium':
PADDLE_SPEED_AI = 5
BALL_SPEED = 4
# Eventually this else will handle a much better AI
else:
PADDLE_SPEED_AI = 3
BALL_SPEED = 3
aicontroller = TrackingAIController(0, 600, PADDLE_SPEED_AI)
world.add_system(aicontroller)
midline = Midline(world, sp_midline)
ball = Ball(world, sp_ball, 390, 290)
ball.velocity.vx = -BALL_SPEED
aicontroller.ball = ball
player1 = Player(world, sp_paddle1, 0, 250)
player2 = Player(world, sp_paddle2, 780, 250, True)
collision = CollisionSystem(0, 0, 800, 600, player1.playerdata,
player2.playerdata)
world.add_system(collision)
collision.ball = ball
running = True
while running:
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_UP:
player1.velocity.vy = -PADDLE_SPEED
elif event.key.keysym.sym == sdl2.SDLK_DOWN:
player1.velocity.vy = PADDLE_SPEED
elif event.type == sdl2.SDL_KEYUP:
if event.key.keysym.sym in (sdl2.SDLK_UP, sdl2.SDLK_DOWN):
player1.velocity.vy = 0
sdl2.SDL_Delay(10)
world.process()
else:
BALL_SPEED = 3
ball = Ball(world, sp_ball, 390, 290)
ball.velocity.vx = -BALL_SPEED
player1 = Player(world, sp_paddle1, 0, 250)
player2 = Player(world, sp_paddle2, 780, 250)
collision = CollisionSystem(0, 0, 800, 600, player1.playerdata,
player2.playerdata)
world.add_system(collision)
collision.ball = ball
running = True
while running:
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_w:
player1.velocity.vy = -PADDLE_SPEED
elif event.key.keysym.sym == sdl2.SDLK_s:
player1.velocity.vy = PADDLE_SPEED
if event.key.keysym.sym == sdl2.SDLK_UP:
player2.velocity.vy = -PADDLE_SPEED
elif event.key.keysym.sym == sdl2.SDLK_DOWN:
player2.velocity.vy = PADDLE_SPEED
elif event.type == sdl2.SDL_KEYUP:
if event.key.keysym.sym in (sdl2.SDLK_w, sdl2.SDLK_s):
player1.velocity.vy = 0
if event.key.keysym.sym in (sdl2.SDLK_UP, sdl2.SDLK_DOWN):
player2.velocity.vy = 0
sdl2.SDL_Delay(10)
world.process()
def run(game_info):
sdl2.ext.init()
window = sdl2.ext.Window("The Pong Game", size=(800, 600))
window.show()
factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE)
# Create the paddles - we want white ones. To keep it easy enough for us,
# we create a set of surfaces that can be used for Texture- and
# Software-based sprites.
sp_paddle1 = factory.from_color(WHITE, size=(20, 100))
sp_paddle2 = factory.from_color(WHITE, size=(20, 100))
sp_ball = factory.from_color(WHITE, size=(20, 20))
sp_midline = factory.from_color(WHITE, size=(4, 600))
world = sdl2.ext.World()
movement = MovementSystem(0, 0, 800, 600)
spriterenderer = SoftwareRenderSystem(window)
dirname = os.path.dirname(__file__)
filename = os.path.join(dirname, '../wrapper/Fonts/battle_star/Battle Star.ttf')
fontmanager = sdl2.ext.FontManager(font_path=os.path.join(dirname, filename))
world.add_system(movement)
world.add_system(spriterenderer)
#world.add_componenttype(sdl2.ext.SpriteFactory)
# add a midline for aesthetic
midline = Midline(world, sp_midline)
if game_info.num_players == 1:
if game_info.difficulty == 'Easy':
PADDLE_SPEED_AI = 3
BALL_SPEED = 3
elif game_info.difficulty == 'Medium':
PADDLE_SPEED_AI = 5
BALL_SPEED = 4
# Eventually this else will handle a much better AI
else:
PADDLE_SPEED_AI = 3
BALL_SPEED = 3
aicontroller = TrackingAIController(0, 600, PADDLE_SPEED_AI)
world.add_system(aicontroller)
ball = Ball(world, sp_ball, 390, 290)
ball.velocity.vx = -BALL_SPEED
aicontroller.ball = ball
player1 = Player(world, sp_paddle1, 0, 250)
player2 = Player(world, sp_paddle2, 780, 250, True)
displayscore1 = DisplayScore1(world, player1.playerdata.points, factory, fontmanager)
displayscore2 = DisplayScore2(world, player2.playerdata.points, factory, fontmanager)
collision = CollisionSystem(0, 0, 800, 600, player1, player2)
world.add_system(collision)
collision.ball = ball
collision.displayscore1 = displayscore1
collision.displayscore2 = displayscore2
running = True
while running:
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_UP:
player1.velocity.vy = -PADDLE_SPEED
elif event.key.keysym.sym == sdl2.SDLK_DOWN:
player1.velocity.vy = PADDLE_SPEED
elif event.type == sdl2.SDL_KEYUP:
if event.key.keysym.sym in (sdl2.SDLK_UP, sdl2.SDLK_DOWN):
player1.velocity.vy = 0
sdl2.SDL_Delay(10)
world.process()
else:
BALL_SPEED = 3
ball = Ball(world, sp_ball, 390, 290)
ball.velocity.vx = -BALL_SPEED
player1 = Player(world, sp_paddle1, 0, 250)
player2 = Player(world, sp_paddle2, 780, 250)
displayscore1 = DisplayScore1(world, player1.playerdata.points, factory, fontmanager)
displayscore2 = DisplayScore2(world, player2.playerdata.points, factory, fontmanager)
collision = CollisionSystem(0, 0, 800, 600, player1, player2)
world.add_system(collision)
collision.ball = ball
collision.displayscore1 = displayscore1
collision.displayscore2 = displayscore2
running = True
while running:
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_w:
player1.velocity.vy = -PADDLE_SPEED
elif event.key.keysym.sym == sdl2.SDLK_s:
player1.velocity.vy = PADDLE_SPEED
if event.key.keysym.sym == sdl2.SDLK_UP:
player2.velocity.vy = -PADDLE_SPEED
elif event.key.keysym.sym == sdl2.SDLK_DOWN:
player2.velocity.vy = PADDLE_SPEED
elif event.type == sdl2.SDL_KEYUP:
if event.key.keysym.sym in (sdl2.SDLK_w, sdl2.SDLK_s):
player1.velocity.vy = 0
if event.key.keysym.sym in (sdl2.SDLK_UP, sdl2.SDLK_DOWN):
player2.velocity.vy = 0
sdl2.SDL_Delay(10)
world.process()
def run():
sdl2.ext.init()
window = sdl2.ext.Window("Arkanoid v1", size=(800, 1000))
window.show()
world = sdl2.ext.World()
spriterenderer = factory.create_sprite_render_system(window)
spriteRenderer = SoftwareRenderer(window)
world.add_system(spriteRenderer)
movement = MovementSyste(0, 0, 800, 1000)
world.add_system(movement)
collision = CollisionSystem(0, 0, 800, 1000)
world.add_system(collision)
sp_paddle = factory.from_color(WHITE, size=(100, 20))
paddle = Paddle(world, sp_paddle, 350, 980)
collision.paddle = paddle
sp_ball = factory.from_color(WHITE, size=(20, 20))
ball = Ball(world, sp_ball, 390, 960)
collision.ball = ball
player = Player()
collision.player = player
img = factory.from_image(RESOURCES.get_path("koniecgry.jpg"))
zycList = []
for i in range(0, player.zycia + 1):
pox = 5 + i * 11
sp_hart = factory.from_color(RED, size=(10, 10))
hart = Brick(world, sp_hart, pox, 985)
zycList.append(hart)
collision.zyc = zycList
running = True
flag = False
while running:
events = sdl2.ext.get_events()
if player.zycia < 0:
world.process()
break
if collision.lis == [] and player.zycia >= 0 and player.lv < 8:
player.lv += 1
brickList = []
for k in range(0, 1):
for j in range(0, 3 * player.lv):
poy = 220 - 22 * player.lv + j * 22
for i in range(0, 17):
pox = 44 + i * 42
sp_brick = factory.from_color(WHITE, size=(40, 20))
brick = Brick(world, sp_brick, pox, poy)
brickList.append(brick)
collision.lis = brickList
ball.sprite.x = paddle.sprite.x + 40
ball.sprite.y = paddle.sprite.y - 20
ball.velocity.vx = 0
ball.velocity.vy = 0
for event in events:
if event.type == sdl2.SDL_QUIT:
running = False
world.process()
break
if event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_RIGHT:
paddle.velocity.vx = 3
if (ball.velocity.vx == 0 and ball.velocity.vy == 0
and ball.sprite.x < 800 - 62):
ball.velocity.vx = 3
flag = True
elif event.key.keysym.sym == sdl2.SDLK_LEFT:
paddle.velocity.vx = -3
if (ball.velocity.vx == 0 and ball.velocity.vy == 0
and ball.sprite.x > 42):
ball.velocity.vx = -3
flag = True
if event.key.keysym.sym == sdl2.SDLK_SPACE:
if ball.velocity.vx == 0 and ball.velocity.vy == 0:
ball.velocity.vy = -3
tmp = random.randint(1, 2)
if tmp == 1: ball.velocity.vx = -3
else: ball.velocity.vx = 3
elif event.type == sdl2.SDL_KEYUP:
if event.key.keysym.sym in (sdl2.SDLK_RIGHT, sdl2.SDLK_LEFT):
paddle.velocity.vx = 0
if flag:
ball.velocity.vx = 0
ball.velocity.vy = 0
flag = False
sdl2.SDL_Delay(8)
world.process()
if running:
spriterenderer.render(img)
posy = 760
score = str(player.score)
for i in range(0, len(score)):
posx = 270 + i * 90
name = ""
name = score[i] + ".jpg"
img = factory.from_image(RESOURCES.get_path(name))
spriterenderer.render(img, posx, posy)
while running:
events = sdl2.ext.get_events()
for event in events:
if event.type == sdl2.SDL_QUIT:
running = False
break
return 0
def main():
if len(sys.argv) < 3:
print("Please provide player file name and player id")
sys.exit(1)
gameplay.state.my_player_id = None
players_str = None
with open(sys.argv[1], "r") as player_file:
gameplay.state.my_player_id = int(sys.argv[2])
players_str = player_file.read()
player_adds = players_str.split()
num_players = len(player_adds)
messaging = MessagingHandler()
messaging.connect(player_adds, num_players, gameplay.state.my_player_id)
running = True
graphics.view.initView()
gameplay.state.floor = Floor()
gameplay.state.floor.genFloor(3, 0)
gameplay.state.players = []
for i in range(num_players):
new_player = Player(i, 200 + 200 * i, 350)
gameplay.state.players.append(new_player)
new_player.roomX = gameplay.state.floor.startingLocs[0][0]
new_player.roomY = gameplay.state.floor.startingLocs[0][1]
print("Starting room: %d %d" % (new_player.roomX, new_player.roomY))
gameplay.state.floor.board[new_player.roomX][new_player.roomY].simulation.add_object(new_player.collider)
graphics.view.makeGameSubView()
last_phys_time = sdl2.SDL_GetTicks()
while running == True:
frame_start = sdl2.SDL_GetTicks()
input_events = sdl2.ext.get_events()
game_events = []
for event in input_events:
if event.type == sdl2.SDL_QUIT:
running = False
break
else:
if not ControlsState.should_process_input_event(event):
continue
ControlsState.update_state(event)
player_event = gameplay.state.players[gameplay.state.my_player_id].processInputEvent(event)
if player_event.params["code"] == "NONE":
continue
game_events.append(player_event)
messaging.broadcast(player_event.serialize().encode("utf-8"))
messages = messaging.get_messages()
while messages.qsize() > 0:
msg = messages.get()
game_events.append(GameEvent.deserialize(msg.decode("utf-8")))
for event in game_events:
if (event.params["type"] == "PLAYER"):
gameplay.state.players[event.params["player_id"]].processPlayerEvent(event)
if (event.params["type"] == "STATUS"):
room = gameplay.state.floor.board[event.params["room_x"]["room_y"]]
if event.params["kind"] == "bullet":
print("UPDATING BULLET")
obj = room.projectiles[event.params["id"]]
obj.collider.pos.from_dict(event.params["pos"])
obj.collider.vel.from_dict(event.params["vel"])
curr_time = sdl2.SDL_GetTicks()
delta = curr_time - last_phys_time
last_phys_time = curr_time
roomX = 0
for column in gameplay.state.floor.board:
roomY = 0
for room in column:
if room is not None:
for p in [x for x in room.projectiles.keys() if x in gameplay.state.responsible_for]:
b = room.projectiles[p]
heartbeat_dict = {
"type": "STATUS",
"kind": "bullet",
"player_id": b.id,
"room_id": (roomX, roomY),
"room_x": roomX,
"room_y": roomY,
"id": b.id,
"pos": b.collider.pos.to_dict(),
"vel": b.collider.pos.to_dict(),
}
print(heartbeat_dict)
messaging.broadcast(player_event.serialize().encode("utf-8"))
room.simulation.step(delta / 1000)
roomY += 1
roomX += 1
graphics.view.render()
frame_end = sdl2.SDL_GetTicks()
remaining_time = (frame_start + FRAME_LENGTH) - frame_end
if remaining_time > 0:
sdl2.SDL_Delay(remaining_time)
sdl2.ext.quit()
def main():
nodes = None
edges = None
if len(sys.argv) >= 2 and Path(sys.argv[1]).exists():
map_file = Path(sys.argv[1])
with map_file.open() as roadmap_input:
nodes, edges = read_map(roadmap_input)
# print(nodes, edges)
else:
nodes = [
Vector(100.0, 100.0),
Vector(200.0, 200.0),
Vector(300.0, 100.0),
Vector(400, 200)
]
edges = [[0, 1], [1, 2], [2, 0], [1, 3], [2, 3]]
wps = []
for n in nodes:
wps.append(WayPoint(n.x, n.y))
for e in edges:
edge = WayPointEdge(wps[e[0]], wps[e[1]])
wps[e[0]].neighbors.append(edge)
wps[e[1]].neighbors.append(edge)
# print(Vector.distance(wps[e[0]].pos, wps[e[1]].pos))
rp = RoutePlanner(wps)
start = Vector(0.0, 0.0)
goal = Vector(500.0, 200.0)
route_plan = rp.plan(start, goal)
sdl2.sdl2_load(
ctypes.util.find_library('SDL2'), # '/usr/local/lib/libSDL2.dylib'
gfx_libpath=ctypes.util.find_library('SDL2_gfx'))
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
window = sdl2.SDL_CreateWindow(b"A* demonstration", 0, 0, WINDOW_W,
WINDOW_H, sdl2.SDL_WINDOW_OPENGL)
renderer = sdl2.SDL_CreateRenderer(window, -1, 0)
mouse_x = ctypes.c_int()
mouse_y = ctypes.c_int()
fps_delay = 100
event = sdl2.SDL_Event()
done = False
while not done:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
# 'type' and 'timestamp' are common members for all SDL Event structs.
event_type = event.common.type
# event_timestamp = event.common.timestamp
# print("Event : type=0x%s, timestamp=%s" % (event_type, event_timestamp) )
if event_type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
done = True
if event.key.keysym.sym == sdl2.SDLK_SPACE:
route_plan = rp.plan(start, goal)
sdl2.SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF)
sdl2.SDL_RenderClear(renderer)
mouse_state = sdl2.SDL_GetMouseState(ctypes.byref(mouse_x),
ctypes.byref(mouse_y))
if mouse_state == (1 << (sdl2.SDL_BUTTON_LEFT - 1)):
prev_x = start.x
prev_y = start.y
start.x = float(mouse_x.value)
start.y = float(mouse_y.value)
if start.x != prev_x or start.y != prev_y:
route_plan = rp.plan(start, goal)
elif mouse_state == (1 << (sdl2.SDL_BUTTON_RIGHT - 1)):
prev_x = goal.x
prev_y = goal.y
goal.x = float(mouse_x.value)
goal.y = float(mouse_y.value)
if goal.x != prev_x or goal.y != prev_y:
route_plan = rp.plan(start, goal)
map_renderer.render_waypoints(renderer, wps)
map_renderer.render_route_plan(renderer, start, goal, route_plan)
sdl2.SDL_RenderPresent(renderer)
sdl2.SDL_Delay(fps_delay)
sdl2.SDL_DestroyRenderer(renderer)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
def run():
global shaderProgram
global rot
global projection
global translation
global view
global lightVec
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
return -1
window = sdl2.SDL_CreateWindow(b"OpenGL demo",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, windowwidth,
windowheight, sdl2.SDL_WINDOW_OPENGL)
if not window:
print(sdl2.SDL_GetError())
return -1
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION, 3)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION, 3)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK,
video.SDL_GL_CONTEXT_PROFILE_CORE)
context = sdl2.SDL_GL_CreateContext(window)
# Setup GL shaders, data, etc.
initialize()
event = sdl2.SDL_Event()
running = True
# Initial position
animated = 1
init_t = glm.vec3(0.0, 0.0, -4.0)
rot = glm.mat4(1.0)
rot = glm.rotate(rot, glm.radians(45), glm.vec3(0.0, 1.0, 0.0))
rot = glm.rotate(rot, glm.radians(20), glm.vec3(1.0, 0.0, 0.0))
rot = glm.rotate(rot, glm.radians(20), glm.vec3(0.0, 0.0, 1.0))
step = 0.5
translation = glm.mat4(1.0)
translation = glm.translate(translation, init_t)
projection = glm.perspective(glm.radians(45.0), windowwidth / windowheight,
1.0, 10.0)
cameraPos = glm.vec3(0.0, 0.0, 1.0)
cameraFront = glm.vec3(0.0, 0.0, -1.0)
cameraUp = glm.vec3(0.0, 1.0, 0.0)
view = glm.lookAt(cameraPos, cameraPos + cameraFront, cameraUp)
while running:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
if event.type == sdl2.SDL_QUIT:
running = False
elif (event.type == sdl2.SDL_KEYDOWN
and event.key.keysym.sym == sdl2.SDLK_ESCAPE):
running = False
# Animation
elif (event.type == sdl2.SDL_KEYDOWN
and event.key.keysym.sym == sdl2.SDLK_s):
if animated == 1:
animated = 0
else:
animated = 1
# Rotation
elif (event.type == sdl2.SDL_KEYDOWN
and event.key.keysym.sym == sdl2.SDLK_RIGHT):
rot = glm.rotate(rot, glm.radians(step),
glm.vec3(0.0, 0.0, 1.0))
elif (event.type == sdl2.SDL_KEYDOWN
and event.key.keysym.sym == sdl2.SDLK_LEFT):
rot = glm.rotate(rot, glm.radians(-step),
glm.vec3(0.0, 0.0, 1.0))
elif (event.type == sdl2.SDL_KEYDOWN
and event.key.keysym.sym == sdl2.SDLK_q):
rot = glm.rotate(rot, glm.radians(step),
glm.vec3(0.0, 1.0, 0.0))
elif (event.type == sdl2.SDL_KEYDOWN
and event.key.keysym.sym == sdl2.SDLK_a):
rot = glm.rotate(rot, glm.radians(-step),
glm.vec3(0.0, 1.0, 0.0))
elif (event.type == sdl2.SDL_KEYDOWN
and event.key.keysym.sym == sdl2.SDLK_UP):
rot = glm.rotate(rot, glm.radians(step),
glm.vec3(1.0, 0.0, 0.0))
elif (event.type == sdl2.SDL_KEYDOWN
and event.key.keysym.sym == sdl2.SDLK_DOWN):
rot = glm.rotate(rot, glm.radians(-step),
glm.vec3(1.0, 0.0, 0.0))
render()
if animated == 1:
rot = glm.rotate(rot, glm.radians(step), glm.vec3(0.0, 1.0, 0.0))
sdl2.SDL_GL_SwapWindow(window)
sdl2.SDL_Delay(10)
sdl2.SDL_GL_DeleteContext(context)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
return 0
def run():
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
return -1
window = sdl2.SDL_CreateWindow(b"OpenGL demo",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, 800, 600,
sdl2.SDL_WINDOW_OPENGL)
if not window:
print(sdl2.SDL_GetError())
return -1
# Force OpenGL 3.3 'core' context.
# Must set *before* creating GL context!
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION, 3)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION, 3)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK,
video.SDL_GL_CONTEXT_PROFILE_CORE)
context = sdl2.SDL_GL_CreateContext(window)
quad = [
-0.5, -0.5, 0.0, 1.0, 0.0, 0.0, 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 0.5,
0.5, 0.0, 0.0, 0.0, 1.0, -0.5, 0.5, 0.0, 1.0, 1.0, 1.0
]
quad = numpy.array(quad, dtype=numpy.float32)
indices = [0, 1, 2, 2, 3, 0]
indices = numpy.array(indices, dtype=numpy.uint32)
# Setup GL shaders, data, etc.
vertex_shader = shaders.compileShader(
"""
#version 330
in vec3 position;
in vec3 color;
out vec3 newColor;
void main()
{
gl_Position = vec4(position, 1.0f);
newColor = color;
}
""", GL.GL_VERTEX_SHADER)
fragment_shader = shaders.compileShader(
"""
#version 330
in vec3 newColor;
out vec4 outColor;
void main()
{
outColor = vec4(newColor, 1.0f);
}
""", GL.GL_FRAGMENT_SHADER)
shaderProgram = shaders.compileProgram(vertex_shader, fragment_shader)
GL.glUseProgram(shaderProgram)
VAO = GL.glGenVertexArrays(1)
GL.glBindVertexArray(VAO)
# Need VBO for triangle vertices and colours
VBO = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, VBO)
GL.glBufferData(GL.GL_ARRAY_BUFFER, 96, quad, GL.GL_STATIC_DRAW)
EBO = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, EBO)
GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, 24, indices, GL.GL_STATIC_DRAW)
position = GL.glGetAttribLocation(shaderProgram, "position")
GL.glVertexAttribPointer(position, 3, GL.GL_FLOAT, GL.GL_FALSE, 24,
ctypes.c_void_p(0))
GL.glEnableVertexAttribArray(position)
color = GL.glGetAttribLocation(shaderProgram, "color")
GL.glVertexAttribPointer(color, 3, GL.GL_FLOAT, GL.GL_FALSE, 24,
ctypes.c_void_p(12))
GL.glEnableVertexAttribArray(color)
event = sdl2.SDL_Event()
running = True
GL.glClearColor(0, 0, 0, 1)
while True:
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
GL.glDrawElements(GL.GL_TRIANGLES, 6, GL.GL_UNSIGNED_INT, None)
sdl2.SDL_GL_SwapWindow(window)
sdl2.SDL_Delay(10)
sdl2.SDL_GL_DeleteContext(context)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
return 0
import random
import sdl2
import sdl2.ext
from sdl2 import sdlgfx
width = 800
height = 600
window = sdl2.ext.Window('window_title', size=(width, height))
window.show()
surface = window.get_surface()
pixels = sdl2.ext.pixels2d(surface)
while True:
skip = random.randint(2, 20)
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
color = (r << 16) + (g << 8) + b
for i in range(0, width, skip):
pixels[i:i + 2, :] = color
window.refresh()
sdl2.SDL_Delay(5)
# sdl2.SDL_Delay(3000)
# sdl2.ext.quit()
