def __init__(self, *args, **kwags):
super(SitePlugin, self).__init__(*args, **kwags)
# Now spawn background process if needed
io = {"output": self.backgroundOutput, "input": self.backgroundInput, "allowed_import": (), "modules": storage.modules}
self.spawner = Spawner(self, io=io)
self.spawned_background_processes = False
if "BACKGROUND" in self.settings["permissions"]:
self.spawnBackgroundProcesses()
class SitePlugin(object):
def __init__(self, *args, **kwags):
super(SitePlugin, self).__init__(*args, **kwags)
# Now spawn background process if needed
io = {"output": self.backgroundOutput, "input": self.backgroundInput, "allowed_import": (), "modules": storage.modules}
self.spawner = Spawner(self, io=io)
self.spawned_background_processes = False
if "BACKGROUND" in self.settings["permissions"]:
self.spawnBackgroundProcesses()
def spawnBackgroundProcesses(self):
if self.spawned_background_processes:
return
self.log.debug("Spawning background processes")
self.spawned_background_processes = True
files = self.storage.list("")
for file in files:
# Run every file that starts with 0background.
if file.startswith("0background."):
self.spawnBackgroundProcess(file)
# Spawn background process if needed
def spawnBackgroundProcess(self, file_name):
ext = file_name.replace("0background.", "")
# Read code
code = self.storage.read(file_name)
# Spawn
self.spawner.spawn(ext, code)
def delete(self):
# First really delete
super(SitePlugin, self).delete(self)
# Now stop all threads
self.spawner.stopAll()
def saveSettings(self):
super(SitePlugin, self).saveSettings()
# Spawn if just got the permission
if "BACKGROUND" in self.settings["permissions"]:
self.spawnBackgroundProcesses()
# IO
def backgroundOutput(self, *args):
raise NotImplementedError
def backgroundInput(self, *args):
raise NotImplementedError
def __init__(self,
population_size,
mutation_rate,
target,
good_sample_size,
random_sample_size,
spawner=None,
):
self.mutation_rate = mutation_rate
self.population_size = population_size
self.target = target
self.good_sample_size = good_sample_size
self.random_sample_size = random_sample_size
self.spawner = Spawner() if spawner is None else spawner
def __init__(self, world):
self.id = type(self).instance_num # const and public
type(self).instance_num += 1
# TODO: switches and goals and hives
self.spawner = Spawner(world)
self.wall = Wall(world)
self.mines = Mines(world)
self.balls = Balls(world)
self.elapsed_time = KahanSum()
self.can_mutate = True
def __init__(self, simVars, delta=50, tick=0):
self.delta = delta
self.simVars = simVars
self.map = Map(simVars)
self.spawner = Spawner(self)
self.tick = tick
self.physics = Physics()
def __init__(self, *args, **kwags):
super(SitePlugin, self).__init__(*args, **kwags)
# Now spawn background process if needed
io = {
"output": self.backgroundOutput,
"input": self.backgroundInput,
"allowed_import": ("json",),
"modules": storage.modules,
"site": self,
"scope0": []
}
self.spawner = Spawner(self, io=io)
self.spawned_background_processes = False
if "BACKGROUND" in self.settings["permissions"]:
self.spawnBackgroundProcesses()
self.onFileDone.append(self.reloadBackgroundProcess)
def add_spawner(self, spawner_name):
try:
spawner = None
for spawner in Spawner.__subclasses__():
spawner_instance = spawner()
if spawner_instance.name == spawner_name:
spawner_instance.spawn()
self.spawners.append(spawner_instance)
except InvalidFilePathException as e:
print e
def start():
PixelsManager.setup()
Map.setup()
GameEnder.setup()
TimeManager.setup()
InputManager()
Player.get_instance()
Spawner()
print("Starting game")
GameManager.get_instance().run()
print("Ending game")
TimeManager.destroy()
Player.destroy_instance()
ObjectsHolder.objects.clear()
class GeneticAlgo(object):
def __init__(self,
population_size,
mutation_rate,
target,
good_sample_size,
random_sample_size,
spawner=None,
):
self.mutation_rate = mutation_rate
self.population_size = population_size
self.target = target
self.good_sample_size = good_sample_size
self.random_sample_size = random_sample_size
self.spawner = Spawner() if spawner is None else spawner
def get_next_generation(self, generation):
scored_generation = generation.score(self.target)
selection = self._select_from_generation(scored_generation)
next_population = self._crossover_selection(selection)
return Generation(next_population)
def _select_from_generation(self, scored_generation):
population = scored_generation.population
good_samples = population[:self.good_sample_size]
remaining_population = population[self.good_sample_size:]
random.shuffle(remaining_population)
random_samples = remaining_population[:self.random_sample_size]
concat_list = good_samples + random_samples
return concat_list
def _crossover_selection(self, selection):
next_population = []
max_int = len(selection) - 1
for i in range(self.population_size):
index_1 = random.randint(0, max_int)
index_2 = random.randint(0, max_int)
child = self.spawner.crossover(
selection[index_1],
selection[index_2],
self.mutation_rate
)
next_population.append(child)
return next_population
def __init__(self, surface):
self.surface = surface
self.width = surface.get_width()
self.height = surface.get_height()
self.reverseGravity = False
self.sprites = []
self.player = Player(world = self, position = [self.width / 2, self.height / 2])
self.add(self.player)
self.background = BACKGROUND
self.spawner = Spawner(self)
for i in range(self.MAX_NODES):
self.add(self.spawner.spawn())
self.text = Text(self)
self.collisionSound = mixer.Sound("resources/chime.aif")
self.hitSounds = []
for i in range(1, HITS + 1):
self.hitSounds.append(mixer.Sound("resources/hit" + str(i) + ".aif"))
#!/usr/bin/env python
import pika
import time
import asyncio
from utils.color import style
from spawner import Spawner
if __name__ == '__main__':
connection = pika.BlockingConnection(
pika.ConnectionParameters('localhost'))
if connection.is_closed:
print(
"The RabbitMQ server was not found (check connection localhost:5672). Quitting simulation."
)
channel = connection.channel()
if channel.is_closed:
print("The RabbitMQ server was not found. Quitting simulation.")
connection.close()
task_spawner = Spawner()
task_spawner.execute_concurrent()
# asyncio.run(task_spawner.execute_concurrent())
# canceled = False
# while canceled == False:
# time.sleep(1)
print(style.GREEN('Program exited normally.'))
def main():
# Importing data from config
with open('data/config.json') as cfg:
data=json.load(cfg)
terminal_width=data['terminal_width']
terminal_height=data['terminal_height']
map_width=data['map_width']
map_height=data['map_height']
fov_algorithm=data['fov_algorithm']
fov_light_walls=data['fov_light_walls']
fov_radius=data['fov_radius']
# Init root console
tcod.console_set_custom_font('gfx/fonts/terminal12x16_gs_ro.png', tcod.FONT_TYPE_GREYSCALE | tcod.tcod.FONT_LAYOUT_CP437)
console_root=tcod.console_init_root(terminal_width, terminal_height, 'Python Game Lol', False, tcod.RENDERER_SDL2, 'C', False)
console_display=tcod.console.Console(terminal_width, terminal_height, 'C')
with open('gfx/palette.json') as colours:
palette=json.load(colours)
console_display.bg[:]=palette['terminal_green']
#console_interface=tcod.console.Console(terminal_width, map_height, 'C')
game_map=GameMap(map_width, map_height)
spawner=Spawner(map_width, map_height, 0)
# Testing creatures
generate_test_area(game_map, spawner)
player=spawner.entities[0]
# Then generate map
fov_recompute=True
# message log
game_state=GameStates.TURN_PLAYER
prev_game_state=game_state
#targeting_item=None
# Rendering for the first time
game_map.recompute_fov(player.x, player.y, fov_radius, fov_light_walls, fov_algorithm)
render_all(console_root, console_display, spawner.entities, game_map, fov_recompute)
fov_recompute=False
tcod.console_flush()
# Game loop
while True:
# Render
if fov_recompute:
game_map.recompute_fov(player.x, player.y, fov_radius, fov_light_walls, fov_algorithm)
render_all(console_root, console_display, spawner.entities, game_map, fov_recompute)
fov_recompute=False
tcod.console_flush()
erase_entities(console_display, spawner.entities, game_map)
# Processing action
action=handle_event(game_state)
move=action.get('move')
pickup=action.get('pickup')
take_inventory=action.get('take_inventory')
fullscreen=action.get('fullscreen')
exit=action.get('exit')
# Player's Turn
results_player=[]
# Results: Extend if player turn ends and append if doesn't? Tcod tutorial is confusing.
if game_state==GameStates.TURN_PLAYER:
if move:
dx, dy=move
results_movement=player.handle_move(dx, dy, spawner, game_map.path_map, swappable=True)
if results_movement:
results_player.extend(results_movement)
fov_recompute=True
game_state=GameStates.TURN_ALLY
elif pickup: # Should implement a pickup list like POWDER
for entity in spawner.entities:
if entity.item and entity.x==player.x and entity.y==player.y:
print('ADD ITEM') # Add item
break
else:
print('GRAB GROUND') # Message log to grab ground
if take_inventory:
prev_game_state=game_state
game_state=GameStates.MENU_INVENTORY
if exit:
if game_state.value>=10: # Game states >= 10 are menus: inventory, quipment, etc.
game_state=prev_game_state
if game_state.value>=20: # Game states >= 20 are targetings
results_player.append({'targeting_cancelled': True})
# else brings up main menu
if fullscreen:
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
# Player turn messages: handled by an announcer (translation friendly probably)
# Faction turns (handled by an announcer also)
if game_state==GameStates.TURN_ALLY:
for entity in spawner.entities:
if entity.faction==Factions.ALLY and entity!=player:
results_ally=entity.ai.take_turn(spawner, game_map.path_map)
game_state=GameStates.TURN_ENEMY
if game_state==GameStates.TURN_ENEMY:
for entity in spawner.entities:
if entity.faction==Factions.ENEMY:
results_enemy=entity.ai.take_turn(spawner, game_map.path_map)
game_state=GameStates.TURN_NEUTRAL
if game_state==GameStates.TURN_NEUTRAL:
for entity in spawner.entities:
if entity.faction==Factions.NEUTRAL:
if entity.ai:
resutls_neutral=entity.ai.take_turn(spawner, game_map.path_map)
game_state=GameStates.TURN_PLAYER
from spawner import Spawner spawner = Spawner() spawner.get_counter()
from force_ball import ForceBall
from game_state import GameState
from physics import update_ball, handle_wall_collision
#Set window position on screen
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (50, 50)
pygame.init()
SCREEN_WIDTH = 1200
SCREEN_HEIGHT = 900
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
balls = initial_balls(SCREEN_WIDTH, SCREEN_HEIGHT)
force_balls = []
game_state = GameState()
object_handler = Spawner()
painter = screen_painter.ScreenPainter()
painter.ball_painting_algorithm = screen_painter.speed
while game_state.running:
game_state.handle_inputs(pygame.event.get())
object_handler.update(game_state.get_click_spawn_behaviour())
if pygame.mouse.get_pressed()[0]:
object_handler.handle_action(game_state.get_click_action(), balls,
force_balls,
game_state.get_new_spawn_force())
if not game_state.paused:
balls_to_delete = []
for ball in balls:
def startNewGame(self, load):
#Hide menu background on start of game.
self.mainMenuImage.hide()
#Get window properties, hide the cursor, set properties
properties = WindowProperties()
properties.setCursorHidden(True)
base.win.requestProperties(properties)
#Disable default mouse controls
self.disableMouse()
#Create new collision system
base.cTrav = CollisionTraverser()
base.pusher = CollisionHandlerPusher()
#Init player here
#If we don't already have a player
if self.needPlayer:
self.player = Player()
self.needPlayer = False
#Display HUD and set default stats
self.player.show()
self.player.resetEnergy()
#Load first environment
self.environ = self.loader.loadModel("./resources/theSouthBridge")
self.environ.reparentTo(self.render)
self.environ.setScale(7, 7, 3)
#Load skybox
self.skybox = loader.loadModel("resources/skyBox")
self.skyboxPath = NodePath(self.skybox)
self.skyboxPath.setCompass()
self.skybox.setBin('background',1)
self.skybox.setDepthWrite(False)
self.skybox.setLightOff()
self.skybox.reparentTo(camera)
#Global current player spawn coordinates
self.xPos = 0
self.yPos = 0
self.zPos = 3
#Create level changer
self.levelChanger = LevelChanger()
#Check to see if load game was pressed
if load:
self.levelChanger.goToBoss()
#Create spawner open on current level
self.spawner = Spawner(self.environ, "theRoot")
else:
#Create spawner open on current level
self.spawner = Spawner(self.environ, "theSouthBridge")
#Populate level with enemies
self.spawner.spawn()
#Add tasks
#base.taskMgr.add(self.spawner.checkSpawn, "Spawn Enemies", taskChain='GameTasks')
base.taskMgr.add(self.projCleanTask, "Projectile Clean Up", taskChain='GameTasks')
base.taskMgr.add(self.enemyCleanUp, "enemyCleanup", taskChain='GameTasks')
base.taskMgr.add(self.levelChanger.checkLevel, "checkLevel", taskChain='GameTasks')
base.taskMgr.add(self.pickupClean, "Pickup celeanup", taskChain='GameTasks')
#Get movement controls from config file
self.forward = self.configList[0].split("=")[1].translate(None,"\n")
self.backward = self.configList[1].split("=")[1].translate(None,"\n")
self.left = self.configList[2].split("=")[1].translate(None,"\n")
self.right = self.configList[3].split("=")[1].translate(None,"\n")
#Controls
self.accept("escape", sys.exit, [0])
self.accept("enter", self.startPause)
#Set Controls
self.accept(self.forward, self.setKey, ["forward", True])
self.accept(self.backward, self.setKey, ["backward", True])
self.accept(self.left, self.setKey, ["left", True])
self.accept(self.right, self.setKey, ["right", True])
self.accept(self.forward+"-up", self.setKey, ["forward", False])
self.accept(self.backward+"-up", self.setKey, ["backward", False])
self.accept(self.left+"-up", self.setKey, ["left", False])
self.accept(self.right+"-up", self.setKey, ["right", False])
class GameStart(ShowBase):
#Lists for storing entities
projectileList = []
enemyList = []
pickuplist = []
#Initialize keys
keyMap = {"forward":False, "backward":False, "left":False, "right":False, "m":False}
fsm = 0
levelChanger = 0
player = 0
def __init__(self):
#Start ShowBase
ShowBase.__init__(self)
#Set up task chain for game play
base.taskMgr.setupTaskChain('GameTasks')
#Flag to see if a player has already been spawned
self.needPlayer = True
#Load in all menu images. If the don't all get set initially, it stutters on switch,
self.mainMenuImage = OnscreenImage("./resources/mainMenu1.png")
self.mainMenuImage.setImage("./resources/mainMenu2.png")
self.mainMenuImage.reparentTo(render2d)
self.gameOverImage = OnscreenImage("./resources/gameOver1.png")
self.gameOverImage.setImage("./resources/gameOver2.png")
self.gameOverImage.reparentTo(render2d)
self.gameOverImage.hide()
self.victoryImage = OnscreenImage("./resources/victory1.png")
self.victoryImage.setImage("./resources/victory2.png")
self.victoryImage.reparentTo(render2d)
self.victoryImage.hide()
#start FSM
self.fsm = TerminalZoneFSM()
#Open file to get configs
self.configFile = open("config.txt")
self.configList = self.configFile.readlines()
self.configFile.close()
#Get and set resolution
properties = WindowProperties()
self.xRes = self.configList[4].split("=")[1].translate(None,"\n")
self.yRes = self.configList[5].split("=")[1].translate(None,"\n")
properties.setSize(int(self.xRes), int(self.yRes))
base.win.requestProperties(properties)
#Determine prepare to cry mode
if self.configList[7].split("=")[1].translate(None,"\n") == "True":
self.damageMod = 2
else:
self.damageMod = 1
#Starts main menu
self.fsm.request('MainMenu', 1)
def startNewGame(self, load):
#Hide menu background on start of game.
self.mainMenuImage.hide()
#Get window properties, hide the cursor, set properties
properties = WindowProperties()
properties.setCursorHidden(True)
base.win.requestProperties(properties)
#Disable default mouse controls
self.disableMouse()
#Create new collision system
base.cTrav = CollisionTraverser()
base.pusher = CollisionHandlerPusher()
#Init player here
#If we don't already have a player
if self.needPlayer:
self.player = Player()
self.needPlayer = False
#Display HUD and set default stats
self.player.show()
self.player.resetEnergy()
#Load first environment
self.environ = self.loader.loadModel("./resources/theSouthBridge")
self.environ.reparentTo(self.render)
self.environ.setScale(7, 7, 3)
#Load skybox
self.skybox = loader.loadModel("resources/skyBox")
self.skyboxPath = NodePath(self.skybox)
self.skyboxPath.setCompass()
self.skybox.setBin('background',1)
self.skybox.setDepthWrite(False)
self.skybox.setLightOff()
self.skybox.reparentTo(camera)
#Global current player spawn coordinates
self.xPos = 0
self.yPos = 0
self.zPos = 3
#Create level changer
self.levelChanger = LevelChanger()
#Check to see if load game was pressed
if load:
self.levelChanger.goToBoss()
#Create spawner open on current level
self.spawner = Spawner(self.environ, "theRoot")
else:
#Create spawner open on current level
self.spawner = Spawner(self.environ, "theSouthBridge")
#Populate level with enemies
self.spawner.spawn()
#Add tasks
#base.taskMgr.add(self.spawner.checkSpawn, "Spawn Enemies", taskChain='GameTasks')
base.taskMgr.add(self.projCleanTask, "Projectile Clean Up", taskChain='GameTasks')
base.taskMgr.add(self.enemyCleanUp, "enemyCleanup", taskChain='GameTasks')
base.taskMgr.add(self.levelChanger.checkLevel, "checkLevel", taskChain='GameTasks')
base.taskMgr.add(self.pickupClean, "Pickup celeanup", taskChain='GameTasks')
#Get movement controls from config file
self.forward = self.configList[0].split("=")[1].translate(None,"\n")
self.backward = self.configList[1].split("=")[1].translate(None,"\n")
self.left = self.configList[2].split("=")[1].translate(None,"\n")
self.right = self.configList[3].split("=")[1].translate(None,"\n")
#Controls
self.accept("escape", sys.exit, [0])
self.accept("enter", self.startPause)
#Set Controls
self.accept(self.forward, self.setKey, ["forward", True])
self.accept(self.backward, self.setKey, ["backward", True])
self.accept(self.left, self.setKey, ["left", True])
self.accept(self.right, self.setKey, ["right", True])
self.accept(self.forward+"-up", self.setKey, ["forward", False])
self.accept(self.backward+"-up", self.setKey, ["backward", False])
self.accept(self.left+"-up", self.setKey, ["left", False])
self.accept(self.right+"-up", self.setKey, ["right", False])
# Changes the states of the keys pressed
def setKey(self, key, value):
self.keyMap[key] = value
#Spawn and append pickups to the list
def spawnPickup(self, id, node):
n = Pickup(id, node)
self.pickuplist.append(n)
#Cleans projectiles after impact and specified duration
def projCleanTask(self, task):
#using this task to find all the projectiles in the projList
#that have reached the end of their lifespan
#use the built in destroy to remove them
for i in self.projectileList:
if i.flag:
i.projectileNode.removeNode()
self.projectileList.remove(i)
return task.cont
#Clears pickups from the environment after collection
def pickupClean(self, task):
for i in self.pickuplist:
if i.deletePickup:
i.destroy()
self.pickuplist.remove(i)
return task.cont
#Clears enemies from the environment after being killed or upon player death
def enemyCleanUp(self, task):
self.levelChanger.checkLevel(task)
#Remove flagged enemies
for i in self.enemyList:
if i.delFlag:
#i.enemyNode.removeNode()
i.destroy()
self.enemyList.remove(i)
#self.spawner.spawnableCount-=1
return task.cont
#Requests pause from the fsm
def startPause(self):
self.fsm.request('PauseMenu')
#Handles the delay between menu image swaps
def menusTasks(self, s, task):
if task.time > .75:
if s == "mainmenu1":
base.fsm.request('MainMenu', 2)
elif s == "mainmenu2":
base.fsm.request('MainMenu', 1)
elif s == "gameover1":
base.fsm.request('GameOver', 2)
elif s == "gameover2":
base.fsm.request('GameOver', 1)
elif s == "winmenu1":
base.fsm.request('WinMenu', 2)
elif s == "winmenu2":
base.fsm.request('WinMenu', 1)
return task.cont
import pygame from player import Player from spawner import Spawner from menu import Menu pygame.init() player = Player() spawner = Spawner() menu = Menu() menu.game_run(player, spawner)
def main():
"""
Main game logic loop.
"""
containerTextStyle = {
'color': '#ffffff',
'font': '10px',
'stroke': '#000000',
'strokeWidth': .15
}
spawnerRole = Spawner()
# Clean up memory
for creepName in Object.keys(Memory.creeps):
if not Game.creeps[creepName]:
if Memory.creeps[creepName].role == "remoteHarvester":
print("Cleaning up remoteHarvester. It mined: " +
Memory.creeps[creepName].totalHarvested)
del Memory.creeps[creepName]
#print("Clearing non-existent creep memory: " + creepName)
if Game.cpu.bucket == 10000:
Game.cpu.generatePixel()
# Run each creep
for name in Object.keys(Game.creeps):
creep = Game.creeps[name]
if creep.memory.role in Spawner.roles:
Spawner.roles[creep.memory.role].run(creep)
else:
creep.say("No role")
# Run tower code
homeRoom = Object.values(Game.spawns)[0].room
towers = [
struct for room in Object.values(Game.rooms)
for struct in room.find(FIND_STRUCTURES)
if struct.structureType == STRUCTURE_TOWER
]
hostiles = homeRoom.find(FIND_HOSTILE_CREEPS)
for tower in towers:
structures = sorted([
struct for struct in tower.room.find(FIND_STRUCTURES)
if struct.hits < struct.hitsMax
],
key=lambda struct: struct.hits)
if len(hostiles) > 0:
tower.attack(tower.pos.findClosestByPath(hostiles))
continue
for structure in structures:
if structure.hits < structure.hitsMax and structure.hits < 100000:
tower.repair(structure)
break
# Run visuals
for room in Object.values(Game.rooms):
for container in [
struct for struct in room.find(FIND_STRUCTURES)
if struct.structureType == STRUCTURE_CONTAINER
or struct.structureType == STRUCTURE_STORAGE
]:
room.visual.text(
Spawner.roles['harvester'].getStructureFutureEnergy(container),
container.pos, containerTextStyle)
# Run each spawn
for name in Object.keys(Game.spawns)[0:1]:
spawn = Game.spawns[name]
spawnerRole.run(spawn)
import pickle
pygame.init()
objects = []
mousex = 0
mousey = 0
width = 800
height = 800
size = width, height
lives = 3
font = pygame.font.Font('freesansbold.ttf', 32)
screen = pygame.display.set_mode(size)
game_running = True
move1 = False
s = Spawner(width, height)
round_num = 1
fire_cooldown = 0
score = 0
pygame.display.set_caption('Asteriods')
def game_over():
if score > get_high_score():
with open('score.bat', 'wb') as file:
pickle.dump(score, file)
print("New High Score!")
else:
print("All time high score is " + str(get_high_score()))
from spawner import Spawner
from genetic_algo import GeneticAlgo
population_size = 1000
a = Spawner()
generation = a.spawn_generation('tomallpress', population_size)
c = GeneticAlgo(population_size, 0.01, 'tomallpress', 100, 1)
for i in range(20):
generation = c.get_next_generation(generation)
print(generation.display())
def main():
# Initial setup:
pygame.init()
pygame.display.set_mode(config.resolution, DOUBLEBUF | OPENGL)
gluPerspective(config.camera_fov, config.resolution[0] / config.resolution[1], 0.1, 50.0)
glTranslatef(0, 0, config.camera_z)
# Entities
simulated = list()
drawn = list()
test_cube = Entity((0, 0, 0))
move = 0.5
drawn.append(test_cube)
asteroid_spawner = Spawner(drawn, simulated, Asteroid, 2)
wait_t = int(config.delta_t*1000)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.quit()
quit()
if event.key == pygame.K_w:
test_cube.pos = add(test_cube.pos, (0, move, 0))
if event.key == pygame.K_s:
test_cube.pos = add(test_cube.pos, (0, -move, 0))
if event.key == pygame.K_a:
test_cube.pos = add(test_cube.pos, ( -move, 0, 0))
if event.key == pygame.K_d:
test_cube.pos = add(test_cube.pos, (move, 0, 0))
print("x: {} y: {} z: {}".format(test_cube.pos[0], test_cube.pos[1], test_cube.pos[2]))
for entity in simulated:
entity.sim()
asteroid_spawner.sim()
# Collisions
# Despawn
for entity in simulated:
if entity.pos[0] < config.x_min - config.margin:
simulated.remove(entity)
drawn.remove(entity)
mouse_pos = get_input()
test_cube.pos = (mouse_pos[0], mouse_pos[1], 0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
for entity in drawn:
entity.draw()
pygame.display.flip()
pygame.time.wait(wait_t)
class World(object):
# publicly accesible constants
COLORS = (
(189, 125, 15),
(125, 15, 188),
(15, 188, 125)
)
G = 1000 # gravitational constant
MAX_NODES = 8
PARTICLE_COUNT = 100
def __init__(self, surface):
self.surface = surface
self.width = surface.get_width()
self.height = surface.get_height()
self.reverseGravity = False
self.sprites = []
self.player = Player(world = self, position = [self.width / 2, self.height / 2])
self.add(self.player)
self.background = BACKGROUND
self.spawner = Spawner(self)
for i in range(self.MAX_NODES):
self.add(self.spawner.spawn())
self.text = Text(self)
self.collisionSound = mixer.Sound("resources/chime.aif")
self.hitSounds = []
for i in range(1, HITS + 1):
self.hitSounds.append(mixer.Sound("resources/hit" + str(i) + ".aif"))
def add(self, sprite):
self.sprites.append(sprite)
self.sprites = sorted(self.sprites, key = lambda d: d.drawDepth)
def addParticle(self):
position = [randint(0, self.width), randint(0, self.height)]
self.add(Particle(self, position))
def update(self, millis):
keys = key.get_pressed()
self.reverseGravity = keys[pygame.K_LSHIFT] or keys[pygame.K_SPACE]
self.text.update(millis)
for sprite in self.sprites:
sprite.update(millis)
def draw(self):
self.surface.fill(self.background)
self.text.draw(self.surface)
for sprite in self.sprites:
sprite.draw(self.surface)
def playerNodeCollide(self, node):
if self.text.tutorial == 0: self.text.nextTutorial()
self.player.score(node)
self.sprites.remove(node)
self.add(self.spawner.spawn())
self.dink(self.player, node)
def nodeNodeCollide(self, node1, node2):
if node1.color == node2.color:
color = choice((node1.color, node2.color))
velocity = [ node1.velocity[0] + node2.velocity[0],
node1.velocity[1] + node2.velocity[1] ]
position = [ node1.position[0] + (node1.position[0] - node2.position[0]) / 2,
node1.position[1] + (node1.position[1] - node2.position[1]) / 2 ]
mass = node1.mass + node2.mass
density = (node1.density + node2.density) / 2
self.sprites.remove(node1)
self.sprites.remove(node2)
self.add(Node(
world = self,
color = color,
position = position,
velocity = velocity,
mass = mass,
density = density,
))
def dong(self):
self.collisionSound.play()
def dink(self, ball1, ball2):
diff = [ball1.velocity[0] - ball2.velocity[0], ball1.velocity[1] - ball2.velocity[1]]
dist = sqrt(diff[0]**2 + diff[1]**2)
volume = dist / 800
if volume > 1: volume = 1
sound = choice(self.hitSounds)
sound.set_volume(volume)
sound.play()
class PhysicsState:
instance_num = 0
def update_ball_vels(self, ball_inputs):
vels = []
ids = self.balls.get_ids()
for ball_index in range(len(ids)):
input_index = ids[ball_index]
input = ball_inputs[input_index]
# The AI needs to know everything that could possibly
# affect the ball - that is, the whole const PhysicsState -
# so pass `self`.
# Also give a ball index to the input so the AI knows
# which ball it's controlling.
vel = input.calc_vel(ball_index, self)
vels.append(vel)
self.invalidate_public_data()
self.balls.set_vels(vels)
def get_nearest_ball_sqr_dist(self, pos):
# TODO: `sqr_dist` should be shortest path distance.
nearest_ball_pos, sqr_dist = get_nearest(pos, self.balls.get_poss())
return sqr_dist
def can_add_mine(self, pos):
is_collision = (self.wall.is_circle_collision(pos, self.mines.rad))
sqr_dist = self.get_nearest_ball_sqr_dist(pos)
return self.spawner.can_add_mine(sqr_dist) and not is_collision
def maybe_add_mine(self, mine_input):
pos = mine_input.calc_pos(self) # const self
self.invalidate_public_data()
if not pos:
return
sqr_dist = self.get_nearest_ball_sqr_dist(pos)
if not self.spawner.try_add_mine(pos, sqr_dist):
# TODO: Notify of failure to spawn mine at `pos`.
pass
def maybe_spawn_mine(self):
pos = self.spawner.try_take_live_mine()
if pos is not None:
self.mines.add(pos)
# For SimplePhysicsState:
# def move_mines_without_walls(self, dt): # Mines could be moved in parallel.
# for i in range(0, len(self.mine_poss)):
# self.update_mine_vel(i, self.ball_pos)
# self.mine_poss[i] += vec_scale(self.mine_vels[i], dt)
# Public (including constants):
def reset(self, initial_wall_bitmap):
assert(self.can_mutate)
self.elapsed_time = KahanSum()
# TODO: switches and goals and hives
self.wall.reset(initial_wall_bitmap)
self.spawner.reset()
self.balls.reset()
self.mines.reset()
def __init__(self, world):
self.id = type(self).instance_num # const and public
type(self).instance_num += 1
# TODO: switches and goals and hives
self.spawner = Spawner(world)
self.wall = Wall(world)
self.mines = Mines(world)
self.balls = Balls(world)
self.elapsed_time = KahanSum()
self.can_mutate = True
# `get_*` functions return constant values (including elements of lists).
# If public data has been retrieved by, for example, calling
# `physics_state.get_mines`, then it must be invalidated before
# mutating the PhysicsState (for example, by calling `advance`).
# After invalidation, `get_mines` must be called again for new data.
def invalidate_public_data(self):
self.can_mutate = True
def get_elapsed_time(self):
return self.elapsed_time.get()
def get_mines(self):
self.can_mutate = False
return self.mines
def get_balls(self):
self.can_mutate = False
return self.balls
def get_spawner(self):
self.can_mutate = False
return self.spawner # Also constant - can't spawn mines.
def get_wall(self):
self.can_mutate = False
return self.wall
# TODO: switches, goals, hives
def has_finished(self):
arent_any_balls = (len(self.balls.get_poss()) == 0)
are_all_goals_reached = False # TODO
return arent_any_balls or are_all_goals_reached
def toggle_invincible_balls(self):
assert(self.can_mutate)
self.balls.toggle_invincibility()
def advance(self, mine_input, ball_inputs, dt):
assert(self.can_mutate)
if self.has_finished():
return False
# Simulate spawner.
self.spawner.advance(dt)
self.maybe_spawn_mine()
# Use inputs.
self.update_ball_vels(ball_inputs)
self.maybe_add_mine(mine_input) # Allow AI to prevent explosion.
if self.spawner.is_exploding():
self.mines.explode()
# Simulate balls.
self.balls.advance(self.wall, dt)
# Simulate mines.
ball_poss = self.balls.get_poss()
self.mines.advance(ball_poss, self.wall, dt)
# Simulate ball-mine collisions.
collisions = self.mines.find_ball_collisions(ball_poss, self.balls.rad)
self.balls.update_collided(collisions)
if any(collisions):
print('time:\t' + str(self.get_elapsed_time())) # For debugging
# Finish step.
self.elapsed_time.add(dt)
return True
def run(self):
player = Player((Settings.WIDTH // 2, Settings.HEIGHT // 2))
if Settings.AGENT_PLAYER:
player.attach_controller(AgentController(player))
else:
player.attach_controller(
HumanController(player, {
"FORWARD": pg.K_w,
"BACKWARD": pg.K_s
}))
if Settings.AGENT_PLAYER:
episode = player.controller.agent.current_episode
start_time = t.time()
l = 0
while True:
player.reset((Settings.WIDTH // 2, Settings.HEIGHT // 2))
if Settings.AGENT_PLAYER:
player.controller.reset_training_data()
# 0: Players, 1: Player Projectiles, 2: Enemies, 3: Enemy Projectiles
self.env = {0: [player], 1: [], 2: [], 3: []}
self.spawner = Spawner(self.env)
ScoreManager.SCORE = 0
while True:
e = pg.event.poll()
if (e.type == pg.QUIT):
quit(0)
deleted_elements = []
collidable_elements = []
ScoreManager.TRIGGER = 0
# Check Collisions
for key in self.env:
collidable_elements += self.env[key]
for i in range(len(collidable_elements)):
for j in range(i + 1, len(collidable_elements)):
result = collidable_elements[i].check_collide(
collidable_elements[j])
if (result):
collidable_elements[i].on_collide(
collidable_elements[j])
collidable_elements[j].on_collide(
collidable_elements[i])
# Handle all GameObjects
for key in self.env:
for obj in self.env[key]:
if obj.destroyed:
deleted_elements.append((obj, key))
continue
if key % 2 == 0: # Controllable
obj.controller.handle(e, self.env)
else: # Projectile
obj.step()
self._delete_elements(deleted_elements)
if player.destroyed: # Player dead
if Settings.AGENT_PLAYER:
player.controller.add_reward(Settings.DIE_REWARD)
break
else:
if Settings.AGENT_PLAYER:
reward = Settings.ALIVE_REWARD
if ScoreManager.TRIGGER:
reward += Settings.KILL_REWARD
player.controller.add_reward(reward)
self.spawner.spawn()
self._render_all()
# Use to control the frame rate of the game
# Disable while training to make training faster
# t.sleep(1/Settings.FRAME_RATE)
# Use to save screen:
# l += 1
# pg.image.save(self.screen, f"../resources/generated_images/{Settings.LOAD_MODEL_EPISODE}/model-{Settings.LOAD_MODEL_EPISODE}-{l}.png")
if Settings.AGENT_PLAYER and Settings.TRAINING_MODE:
episode += 1
player.controller.train_wrapper(episode)
elapsed_time = t.time() - start_time
time_str = t.strftime("%H:%M:%S", t.gmtime(elapsed_time))
output_string = "Episode: {:0>4} Score: {:0>5} Reward: {:07.3f} T+: {}".format(
episode, ScoreManager.SCORE,
sum(player.controller.rewards), time_str)
print(output_string)
else:
print(f"Game Over. Score: {ScoreManager.SCORE}")