def main():
# Initializes pygame, window
pygame.init()
window = pygame.display.set_mode(
(globals.SCREEN_WIDTH, globals.SCREEN_HEIGHT))
input_params = Inputs()
clock = pygame.time.Clock()
app = QApplication(sys.argv)
param_win = Window()
param_win.show()
# Polygon to be controlled by arrows
polygon = Polygon(np.array([800, 500]), 30, 3, 10, (255, 255, 255))
space = Space(polygon)
while globals.RUN:
# Drawing shapes
space.draw(window)
# Adding force to main polygon
if input_params.is_left():
polygon.add_force(np.array([-globals.KEY_FORCE, 0.]))
elif input_params.is_right():
polygon.add_force(np.array([globals.KEY_FORCE, 0.]))
if input_params.is_up():
polygon.add_force(np.array([0., -globals.KEY_FORCE]))
elif input_params.is_down():
polygon.add_force(np.array([0., globals.KEY_FORCE]))
# Add shape on left click
if input_params.mouse_left_click():
space.add_shape(globals.NEW_SHAPE_TYPE, input_params.mouse_pos,
globals.NEW_SHAPE_RADIUS, globals.NEW_SHAPE_MASS,
globals.NEW_SHAPE_DEGREE)
# Remove shape on right click
if input_params.mouse_right_click():
space.remove_shape(input_params.mouse_pos)
if input_params.is_clear():
space.shapes = []
clock.tick(globals.FPS)
elapsed_time = clock.get_time()
# Update shapes in space class for movement, rotarion...
space.update(window, elapsed_time)
# Check for mouse of keyboard click
input_params.update()
pygame.display.update()
pygame.display.set_caption(str(clock.get_fps()))
sys.exit(app.exec_())
class Scene(object):
def __init__(self):
self.screen = None
self.inputs = Inputs()
# The list of components in the scene. Components are drawn in order in
# the list
self.background = []
self.foreground = []
self.midground = []
# The scene manager that this scene sits in.
self.manager = None
# The settings for the game.
self.settings = None
# Build the scene components.
def build(self):
pass
# Informs the scene of the screen.
def set_screen(self, screen):
self.screen = screen
# Informs the scene of the game settings.
def set_settings(self, settings):
self.settings = settings
# Add components to a specific layer. Only Display componetns can be added
# to a Scene.
def add_component_background(self, component):
if util.check_type(component, "DisplayObject"):
self.background.append(component)
def add_component_midground(self, component):
if util.check_type(component, "DisplayObject"):
self.midground.append(component)
def add_component_foreground(self, component):
if util.check_type(component, "DisplayObject"):
self.foreground.append(component)
def update(self):
# Update inputs.
self.inputs.update(pygame.event.get([pygame.KEYDOWN, pygame.KEYUP]))
# Update the game components.
for component in self.background + self.midground + self.foreground:
component.update()
# Re-Shuffle each layer of components.
self.background.sort(key=lambda x: x.z)
self.midground.sort(key=lambda x: x.z)
self.foreground.sort(key=lambda x: x.z)
def draw(self):
# Draw background components.
for component in self.background:
component.draw(self.screen.get_display())
# Draw middle ground components.
for component in self.midground:
component.draw(self.screen.get_display())
# Draw foreground components.
for component in self.foreground:
component.draw(self.screen.get_display())
class App():
STATES = {'menu': MenuState, 'draw': DrawState}
def __init__(self, init_state='menu'):
# Init pygame
pygame.init()
# Get clock
self.clock = pygame.time.Clock()
# Create screen
self.__screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
# Main app font
self.font = pygame.font.SysFont("Arial", 16, False, False)
# Input pipeline (instance gets replaced by each state init())
self.inputs = Inputs()
# Persistent data dictionary, for data to persist across state change
self.__data = {}
# Current state
self.__state = None
# Next state name
self.__next_state = init_state
# Main game loop escape bool
self.running = True
@property
def data(self):
return self.__data
@property
def state(self):
return self.__state
@state.setter
def state(self, name):
"""
State change setter function
"""
self.__next_state = name
@property
def screen(self):
return self.__screen
def run(self):
"""
Main run method
- Main game loop
"""
# Set window title
pygame.display.set_caption(WINDOW_TITLE)
# Main game loop
while self.running:
# Get events
events = pygame.event.get()
for event in events:
# Handle Quit
if event.type == pygame.QUIT:
pygame.quit()
return 0
# Send events to input pipeline
self.inputs.handle_events(events)
# Set FPS and get frame time
delta_time = self.clock.tick(FPS_CAP)
# Update input pipeline
self.inputs.update(delta_time)
# Update the system
self.update(delta_time)
# Draw next frame
self.draw_frame()
def update(self, delta_time):
"""
Update state of the system
"""
if self.__next_state:
self.__state = self.STATES[self.__next_state.lower()](self)
self.__next_state = ''
else:
self.__state.update(delta_time)
def draw_frame(self):
"""
Draw Next Frame
"""
# # Fill screen with background color
# bg_color = self.__state.scene_bg
# self.__screen.fill(bg_color)
# Call .draw() func of state
self.__state.draw() # For transient drawing to the screen, (arrows)
# Draw fps to screen
self.__draw_fps()
# Update the display
pygame.display.update()
def __draw_fps(self):
"""
Draw fps to screen
"""
txt = f'{round(self.clock.get_fps())} FPS'
rtxt = self.font.render(txt, False, pygame.Color('black'))
rsiz = self.font.size(txt)
self.__screen.blit(rtxt, (SCREEN_WIDTH - rsiz[0] - 5, 5))
