def __init__(self, screen):
tilevid.Tilevid.__init__(self)
self.screen = screen
## create a background layer
self.bg = tilevid.Tilevid()
self.num_bibles = base.num_bibles
## This is the rectangle that we're focusing on.
self.focus_rect = (0, 0, 1, 1)
## self.loadLevel(self.level_maj, self.level_min)
## Create a new HUD
self.hud = hud.HUD(self)
##MAYO: add the Bible verse set up
if base.gameDifficulty == 1:
self.mybible = bibleverse("easy")
print "easy"
elif base.gameDifficulty == 2:
self.mybible = bibleverse("medium")
print "medium"
elif base.gameDifficulty == 3:
self.mybible = bibleverse("hard")
print "hard"
self.inputing = False
self.retval = []
# for testing
self.safeMode = False
self.player = None
def __init__(self):
self.asteroids = set()
self.hud = hud.HUD()
self.ship = ship.Ship(hud=self.hud)
self.level = 1
self.hud.set_level(self.level)
self._level_frame = 0
self.enemies = set()
self.asteroids.update(levels.level[self.level].create_asteroids())
self._update_func = self._update_during_level
self.ship.fly_in()
def __init__(self, player):
global screen
self.time = time.time()
self.screen = screen # our screen
self.textures = {} # for saving the textures
self.camera = camera.CCamera()
self.list = glGenLists(7) # display lists
self.rotation = 0.0 # set rotation variable for rotation objects
glInit() # initialize OpenGL and window
texture.loadTextures(self.textures) # load all textures
self.HUD = hud.HUD(self.textures) # The HUD
self.player = player
def __init__(self, prevhandler):
self.startlevel = 1
self.ticks = 0
self.levelnum = -1
self.gamewon = 0
self.donegetready = 0
self.waitforactivation = 0
self.donelevelup = 0
self.getreadyimage = 0
self.player = objairplane.PlayerAirplane(35, 5,
objairplane.player_images)
self.prevhandler = prevhandler
self.staticobjs = []
self.doneplayerdie = 0
self.baddyshotobjs = []
self.playershotobjs = []
self.powerupobjs = []
self.popobjs = []
self.smokeobjs = []
self.asteroidobjs = []
self.waves = 0
self.donequit = 0
self.explodetick = 0
self.ptick = 0
self.quitimage = 0
self.pos = game.arena.width / 2, game.arena.height - 20
self.curwave = []
self.map = None
self.objlists = [
self.baddyshotobjs, self.playershotobjs, self.popobjs,
self.smokeobjs, self.powerupobjs, self.asteroidobjs,
self.staticobjs
]
self.hud = hud.HUD()
self.lastwavecreated = 0
self.levelchanged = 0
self.state = ''
self.statetick = self.dummyfunc
self.lives_left = game.start_lives
self.powerupcount = 0.0
self.numdeaths = 0
self.lasttick = pygame.time.get_ticks()
self.wavetick = 0
self.speedadjust = 1.0
self.startmusic = 1
self.song = ''
self.songtime = 0
self.changestate('getready')
self.bgfill = gfx.surface.fill
def load(self):
hud_scene = [s for s in bge.logic.getSceneList() if s.name == 'HUD']
if hud_scene:
self.hud = hud.HUD(hud_scene[0])
self.hud.log_book.set_location_list(self.areas)
self.hud.log_book.set_found_location_list(self.been_areas)
self.hud.log_book.close_text.text = "Close the logbook with the {}".format(
bge.events.EventToString(LOGBOOKKEY))
self.ship.on_ship_move.append(self._update_hud_radio_box)
self.ship.on_ship_move.append(self._check_areas)
return True
return False
def __init__(self):
self.basedir = os.path.dirname(sys.modules[self.__module__].__file__)
self.open_save_game()
items.init(self.basedir)
self.name = "Renegade game"
self.save_data = SaveGameObject()
self.save_data.map = None
try:
self.load()
except:
self.new_game()
self.save()
self.hud = hud.HUD(self.save_data.hero)
#self.fps = dialog.FpsDialog()
core.display.set_caption(self.name)
self.impending_actions = []
self.inventory_screen = InventoryScreen()
def __init__(self, prevhandler):
self.startlevel = game.player.start_level()
self.newcontinue = 0
self.levelnum = -1
self.gamewon = 0
self.player = objship.Ship()
self.prevhandler = prevhandler
self.staticobjs = []
self.boxobjs = []
self.shotobjs = []
self.spikeobjs = []
self.powerupobjs = []
self.powereffects = []
self.popobjs = []
self.textobjs = []
self.smokeobjs = []
self.asteroidobjs = []
self.guardobjs = [objguard.Guard(x) for x in range(4)]
self.objlists = [
self.boxobjs, self.shotobjs, self.spikeobjs, self.popobjs,
self.smokeobjs, self.powerupobjs, self.asteroidobjs,
self.guardobjs, self.staticobjs, self.textobjs
]
self.glitter = objshot.Glitter()
self.hud = hud.HUD()
self.state = ''
self.statetick = self.dummyfunc
self.lives_left = 0
self.grabbedboxes = 0
self.powerupcount = 0.0
self.numdeaths = 0
self.secretspikes = []
self.touchingsecretspike = None
self.complement = random.randint(0, len(game.Complements) - 1)
self.lasttick = pygame.time.get_ticks()
self.speedadjust = 1.0
self.startmusic = 1
self.song = ''
self.songtime = 0
self.changestate('gamestart')
self.bgfill = gfx.surface.fill
def __init__(self):
#center screen
os.environ['SDL_VIDEO_CENTERED'] = '1'
#initialize pygame lib
pygame.init()
#creates window
self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption('The Avengers - Six Guys')
logger.get().setScreen(self.screen)
#Make a camera (this might need to go inside the level object, but that's ok)
self.camera = camera.Camera(self.screen)
logger.get().setCamera(self.camera)
#number of the current level
self.levelNumber = 0 #default 1, change for debugging
self.currLevel = self.getCurrentLevel()
logger.get().setLevel(self.levelNumber)
#player starts with 3 lives
self.player_lives = constants.PLAYER_LIVES
self.invincible = False
#menus
self.startMenu = startmenu.StartMenu()
self.pauseMenu = pausemenu.PauseMenu()
logger.get().setMenu(self.startMenu)
logger.get().setAvengersObj(self)
#the hud
self.hud = hud.HUD()
#I wanna listen to my music while I develop dammit!
if "-m" in sys.argv:
sound.set_bgm_vol(0)
sound.set_sfx_vol(0)
self.hud.vol = False
#Skip all that clicking, ain't nobody got time for that
if "-p" in sys.argv:
self.startMenu.playing = True
def __init__(self):
self.players = None
self.light = None
self.objs = []
self.hero = None
self.track = None
self.opponents = None
self.cam = None
self.screen = thorpy.get_screen()
self.screen_rect = self.screen.get_rect().move((0,parameters.H//2))
self.i = 0 #frame
self.vessels = []
self.background = thorpy.load_image(parameters.BACKGROUNDS[parameters.CURRENT_QUALITY])
self.background = thorpy.get_resized_image(self.background,
(parameters.W,parameters.H//2),
type_=max)
self.hud = hud.HUD()
self.debris = []
## self.background = pygame.transform.smoothscale(self.background, (parameters.W,parameters.H//2))
self.start_i = 5
self.start_delay = 10 + int(random.random()*1000)//40
self.ranking = []
self.hero_dead = None
self.abandon = False
sum = 0.0
count = 0
for f in data['filter']:
air = interp.query(f['time'], 'air')
if air['airspeed'] < 5.0:
sum += f['alt']
count += 1
if count > 0:
ground_m = sum / float(count)
else:
ground_m = data['filter'][0].alt
print("ground est:", ground_m)
# overlay hud(s)
hud1 = hud_glass.HUD()
hud2 = hud.HUD(K)
#cam_ypr = [-3.0, -12.0, -3.0] # yaw, pitch, roll
#ref = [44.7260320000, -93.0771072000, 0]
ref = [ data['gps'][0]['lat'], data['gps'][0]['lon'], 0.0 ]
hud1.set_ned_ref(data['gps'][0]['lat'], data['gps'][0]['lon'])
hud2.set_ned_ref(data['gps'][0]['lat'], data['gps'][0]['lon'])
print('ned ref:', ref)
print('temporarily disabling airport loading')
#hud1.load_airports()
hud1.set_ground_m(ground_m)
hud2.set_ground_m(ground_m)
if args.features:
import sys
import pygame
sys.path.append('./data')
import gamestate
import hud
if __name__ == '__main__':
pygame.init()
pygame.mixer.pre_init(44100, -16, 2)
pygame.mixer.init()
screen = pygame.display.set_mode((800, 640))
pygame.display.set_caption("Space Invaders")
pygame.mouse.set_visible(False)
clock = pygame.time.Clock()
game = gamestate.GameState(screen)
hud = hud.HUD(game)
last = game.level
try:
while True:
clock.tick(30)
game.update()
hud.update()
game.draw(screen)
hud.draw(screen)
pygame.display.update()
if game.level != last:
last = game.level
hud.nextLevel(screen)
except KeyboardInterrupt:
pass
plt.figure(4)
plt.ylabel('yaw rate (deg per sec)')
plt.xlabel('flight time (sec)')
plt.plot(movie[:, 0] + time_shift, (movie[:, 4] / rratio) * r2d,
label='estimate from flight movie')
plt.plot(flight_imu[:, 0], flight_imu[:, 3] * r2d, label='flight data log')
plt.legend()
plt.show()
# adjust K for output scale.
K = K * args.scale
K[2, 2] = 1.0
# overlay hud(s)
hud1 = hud.HUD(K)
hud2 = hud.HUD(K)
# these are fixed tranforms between ned and camera reference systems
proj2ned = np.array([[0, 0, 1], [1, 0, 0], [0, 1, 0]], dtype=float)
ned2proj = np.linalg.inv(proj2ned)
#cam_ypr = [-3.0, -12.0, -3.0] # yaw, pitch, roll
#ref = [44.7260320000, -93.0771072000, 0]
ref = [data['gps'][0].lat, data['gps'][0].lon, 0.0]
hud1.set_ned_ref(data['gps'][0].lat, data['gps'][0].lon)
hud2.set_ned_ref(data['gps'][0].lat, data['gps'][0].lon)
print 'ned ref:', ref
hud1.set_ground_m(ground_m)
hud2.set_ground_m(ground_m)
active_sprites = currentL.active_sprites
bullets = pygame.sprite.Group()
enemyBullets = pygame.sprite.Group()
plr.level = currentL
plr.rect.x = 200
plr.rect.y = HEIGHT - plr.rect.height
active_sprites.add(plr)
close = False
clock = pygame.time.Clock()
camPos = 0
HUD = hud.HUD("monospace", 15, plr, screen)
win = 0
enemiesLeft = 0
def ShiftCamera(shift):
for a in active_sprites:
if a != plr:
a.rect.x += shift
while win == 0 and close == False:
if (plr.invincible
== True) and (pygame.time.get_ticks() - plr.coll_time) > 300:
def __init__(self, parent):
# Assign some constant attributes
self.parent = parent
self.display = self.parent.display
self.clock = self.parent.clock
self.fast = self.parent.parent.fast
self.controls = self.parent.parent.controls
# Create an instance of the sound engine
self.sound_engine = sounds.SoundEngine()
self.sound_engine.light_sound.set_volume(0)
self.sound_engine.dissolve_sound.set_volume(0.2)
# Show the loading screen
self.loading_screen = covers.LoadingScreen()
if self.parent.parent.small:
# Adjust the loading screen for the small display
self.loading_screen.image = self.loading_screen.image_small
loading_label_x = 360
loading_label_y = 400
else:
loading_label_x = 480
loading_label_y = 500
# Fade in the loading screen
for n in range(63):
spritesheet.blit_alpha(self.display, self.loading_screen.image, (0, 0), n * 4)
pygame.display.flip()
# Create the loading label
label = text.LoadingLabel("", 300, 500)
# Create the player
self.player = p.Player(self.sound_engine)
# Create a group that contains only the player
# This is so I can call .draw() on the group
# and pygame will draw the sprite for me
self.player_group = pygame.sprite.GroupSingle()
self.player_group.add(self.player)
# Create the levels
self.level_list = list()
# For each level, update the text on the level
# then draw the loading screen and text to the display
# Then load the level into the level list
# Level 1
label.update_text("Loading Level 1...", loading_label_x, loading_label_y)
label.draw(self.display)
pygame.display.flip()
self.level_list.append(level.Level01(self.player, True, self.fast, self.controls, self.sound_engine))
# Level 2
self.loading_screen.draw(self.display)
label.update_text("Loading Level 2...", loading_label_x, loading_label_y)
label.draw(self.display)
pygame.display.flip()
self.level_list.append(level.Level02(self.player, True, self.fast, self.controls, self.sound_engine))
# Level 3
self.loading_screen.draw(self.display)
label.update_text("Loading Level 3...", loading_label_x, loading_label_y)
label.draw(self.display)
pygame.display.flip()
self.level_list.append(level.Level03(self.player, True, self.fast, self.controls, self.sound_engine))
# Level 4
self.loading_screen.draw(self.display)
label.update_text("Loading Level 4...", loading_label_x, loading_label_y)
label.draw(self.display)
pygame.display.flip()
self.level_list.append(level.Level04(self.player, True, self.fast, self.controls, self.sound_engine))
# Level 5
self.loading_screen.draw(self.display)
label.update_text("Loading Level 5...", loading_label_x, loading_label_y)
label.draw(self.display)
pygame.display.flip()
self.level_list.append(level.Level05(self.player, True, self.fast, self.controls, self.sound_engine))
# Level 6
self.loading_screen.draw(self.display)
label.update_text("Loading Level 6...", loading_label_x, loading_label_y)
label.draw(self.display)
pygame.display.flip()
self.level_list.append(level.Level06(self.player, True, self.fast, self.controls, self.sound_engine))
# Level 7
self.loading_screen.draw(self.display)
label.update_text("Loading Level 7...", loading_label_x, loading_label_y)
label.draw(self.display)
pygame.display.flip()
self.level_list.append(level.Level07(self.player, True, self.fast, self.controls, self.sound_engine))
# Level 8
self.loading_screen.draw(self.display)
label.update_text("Loading Level 8...", loading_label_x, loading_label_y)
label.draw(self.display)
pygame.display.flip()
self.level_list.append(level.Level08(self.player, True, self.fast, self.controls, self.sound_engine))
# Level 9
self.loading_screen.draw(self.display)
label.update_text("Loading Level 9...", loading_label_x, loading_label_y)
label.draw(self.display)
pygame.display.flip()
self.level_list.append(level.Level09(self.player, True, self.fast, self.controls, self.sound_engine))
# Level 10
self.loading_screen.draw(self.display)
label.update_text("Loading Level 10...", loading_label_x, loading_label_y)
label.draw(self.display)
pygame.display.flip()
self.level_list.append(level.Level10(self.player, True, self.fast, self.controls, self.sound_engine))
# Set the current level
self.current_level_no = 0
self.current_level = self.level_list[self.current_level_no]
# Assign references between objects
self.player.level = self.current_level
self.current_level.player = self.player
# Create the blackout
self.blackout = covers.Blackout()
self.blackout.player = self.player
# Create the game over screens
# Again, if it's set to the small display
# then use the small image
self.game_over = covers.GameOverScreen()
if self.parent.parent.small:
self.game_over.image = self.game_over.image_small
self.black_screen = covers.DarkScreen()
self.game_over2 = covers.GameOverScreen2()
if self.parent.parent.small:
self.game_over2.image = self.game_over2.image_small
# Using a custom image as the pointer
# suits the theme a bit better than the mouse pointer
self.crosshair = entities.Crosshair()
# Instantiate the HUD
self.hud = hud.HUD(self.player, self.parent.parent.small)
self.timer = hud.Timer(180)
self.update_timer_event = USEREVENT + 1
pygame.time.set_timer(self.update_timer_event, 1000)
# Load the parts of the intro
if self.parent.parent.small:
self.intro = [gif.GIFImage(os.path.join("resources/intro/small", image))
for image in os.listdir("resources/intro/small")]
else:
self.intro = [gif.GIFImage(os.path.join("resources/intro/normal", image))
for image in os.listdir("resources/intro/normal")]
self.intro_background = pygame.image.load("resources/darkscreen.png").convert()
self.intro_thresholds = [156,
177,
181]
if self.parent.parent.small:
self.part2_scene = [gif.GIFImage("resources/anims/part2_small.gif")]
else:
self.part2_scene = [gif.GIFImage("resources/anims/part2.gif")]
self.part2_scene_thresholds = [158]
if self.parent.parent.small:
self.outro = [gif.GIFImage("resources/anims/outro_small.gif")]
else:
self.outro = [gif.GIFImage("resources/anims/outro.gif")]
self.outro_thresholds = [112]
model_data = model.StaticModelData()
model_data.setup() # Everybody do the setup shake!
# I seriously thing something is wrong with me, putting in all these random comments and strings and stuff.
# Oh well
clock = pygame.time.Clock()
pygame.mouse.set_pos(config.window_info.window_size[0] / 2,
config.window_info.window_size[1] / 2)
user = User(model.geom_data["spawn"], camera, model_data)
input_handler = InputHandler(user)
hud = hud.HUD(model_data)
scripter = ScriptHolder(model_data, user)
scripter.load("script.txt")
while True:
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
user.update_camera()
camera.apply()
model_data.draw()
model_data.setup_price_labels(user)
hud.apply(user)
for event in pygame.event.get():
if event.type == pygame.QUIT:
raise
input_handler.dispatch(event)
track_names = [
t for t in os.listdir("tracks")
if os.path.isfile(os.path.join("tracks", t)) and t.endswith(".json")
]
loaded_tracks = []
for track_name in track_names:
with open(f"tracks/{track_name}") as t:
loaded_tracks.append(track.Track(json.load(t)))
print(f"Loading track: {track_name}")
sm = SceneManager()
gm = GameManager(loaded_tracks)
main_menu = ui.MainMenu()
race_options = ui.RaceOptions(gm)
results = ui.Results(gm)
game_hud = hud.HUD(gm)
pause_screen = ui.PauseScreen()
def redraw():
pygame.display.flip()
screen.fill(core.BLACK)
if sm.scene == SceneManager.MAIN_MENU:
main_menu.draw(screen)
elif sm.scene == SceneManager.RACE_OPTIONS:
race_options.draw(screen)
elif sm.scene == SceneManager.GAME:
gm.current_track.draw(screen)
[p.car.draw(screen) for p in gm.players]
game_hud.draw(screen)
elif sm.scene == SceneManager.RESULTS:
results.draw(screen)
