OSCR

I think, therefore I hit: EEG parameters predict performance in complex cognitive tasks

Code ↔ Paper

1 match between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 1 match
  1. [1] § Material and methods › Tasks and material › Space Fortress Game ↔ src/game.py, lines 357 to 406 · score 0.64 · destroyed fortresses, destroyed mines, capturing bonuses, deaths, graphics, shots · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 1,534 lines · 78 KB · no license · 1 match

  1. from __future__ import division
  3. import numpy as np
  5. from twisted.internet import reactor
  6. from twisted.internet.task import LoopingCall
  8. import os, sys, math, copy, time, datetime, pkg_resources
  9. from random import randrange, choice
  11. import platform as plat
  13. os.environ['SDL_VIDEO_WINDOW_POS'] = 'center'
  15. from OpenGL.GL import *
  16. from OpenGL.GLU import *
  18. import pygame
  19. from pygame.locals import *
  20. import pygl2d
  21. from pygl2d.display import scissor_box, subspace
  23. from gameevent import GameEvent, GameEventList
  24. from frame import Frame
  25. from score import Score
  26. from sound import Sound
  27. from timer import Timer
  28. from hexagon import Hex
  29. from mine import Mine, MineList
  30. from missile import MissileList
  31. from shell import ShellList
  32. from ship import Ship
  33. from bonus import Bonus
  34. from fortress import Fortress
  36. import defaults
  38. get_time = time.time
  39. if plat.system() == 'Windows':
  40. get_time = time.clock
  41. def get_time_ms(): return get_time() * 1000
  43. from version import __version__
  44. def get_psf_version_string():
  45. return "Space Fortress 5"
  47. def get_default_logdir():
  48. _home = os.environ.get('HOME', '/')
  49. if plat.system() == 'Windows':
  50. logdir = os.path.join(os.environ['USERPROFILE'], 'My Documents', 'Spacefortress')
  51. elif plat.system() == 'Linux' or plat.system() == 'Darwin':
  52. logdir = os.path.join(_home, 'Documents', 'Spacefortress')
  53. else:
  54. logdir = os.path.join(_home, 'Spacefortress')
  55. return logdir
  57. release_build = False
  59. class Game(object):
  60. """Main game application"""
  61. def __init__(self):
  62. super(Game, self).__init__()
  64. self.ret = 1
  66. self.reactor = reactor
  68. self.STATE_UNKNOWN = -1
  69. self.STATE_CALIBRATE = 0
  70. self.STATE_INTRO = 1
  71. self.STATE_SETUP = 2
  72. self.STATE_GAMENO = 3
  73. self.STATE_SETUP_IFF = 4
  74. self.STATE_IFF = 5
  75. self.STATE_PREPARE = 6
  76. self.STATE_PLAY = 7
  77. self.STATE_PAUSED = 8
  78. self.STATE_SCORES = 9
  79. self.STATE_DONE = 10
  81. self.state = self.STATE_INTRO
  83. self.ship = None
  84. self.bonus = None
  85. self.score = None
  86. self.fortress = None
  87. self.missile_list = None
  88. self.shell_list = None
  90. self.current_game = 0
  91. self.flight2 = 0
  92. self.mine2 = 0
  93. self.fps = 30
  94. self.header = {}
  95. self.bonus_captured = False
  97. self.modifier = pygame.KMOD_CTRL
  98. if plat.system() == 'Darwin':
  99. self.modifier = pygame.KMOD_META
  101. self.gameevents = GameEventList(self)
  102. self.plugins = {}
  103. #self.plugins = defaults.load_plugins(self, pkg_resources.resource_stream(__name__, 'plugins'), self.plugins)
  104. self.plugins = defaults.load_plugins(self, defaults.get_plugin_home(), self.plugins)
  105. for name in self.plugins:
  106. if hasattr(self.plugins[name], 'eventCallback'):
  107. self.gameevents.addCallback(self.plugins[name].eventCallback)
  109. self.gameevents.add("game", "version", __version__, type='EVENT_SYSTEM')
  111. self.config = defaults.get_config()
  112. if os.path.isfile('config.json'):
  113. self.config.set_user_file('config.json')
  114. else:
  115. self.config.set_user_file(defaults.get_user_file())
  116. self.gameevents.add("config", "load", "defaults", type='EVENT_SYSTEM')
  117. self.config.update_from_user_file()
  118. self.gameevents.add("config", "load", "user", type='EVENT_SYSTEM')
  120. for name in self.plugins:
  121. if hasattr(self.plugins[name], "ready"):
  122. self.plugins[name].ready()
  124. pygame.display.init()
  125. pygame.font.init()
  127. pygame.event.set_blocked((pygame.MOUSEMOTION, pygame.MOUSEBUTTONUP, pygame.MOUSEBUTTONDOWN))
  129. mode_list = pygame.display.list_modes()
  130. if self.config['Display']['display_mode'] == 'Windowed':
  131. if self.config['Display']['screen_width'] > 0 and self.config['Display']['screen_height'] > 0:
  132. best_mode = (self.config['Display']['screen_width'], self.config['Display']['screen_height'])
  133. else:
  134. for mode in mode_list:
  135. tmp = mode[0] / 2
  136. for m in mode_list:
  137. if tmp == m[0]:
  138. mode_list.remove(mode)
  139. break
  140. best_mode = mode_list[1]
  141. else:
  142. if self.config['Display']['display_mode'] == 'Current':
  143. info = pygame.display.Info()
  144. best_mode = (info.current_w, info.current_h)
  145. else:
  146. best_mode = mode_list[0]
  147. self.SCREEN_WIDTH = best_mode[0]
  148. self.SCREEN_HEIGHT = best_mode[1]
  149. self.screen_size = (self.SCREEN_WIDTH, self.SCREEN_HEIGHT)
  151. if self.config['Logging']['logging']:
  152. d = datetime.datetime.now().timetuple()
  153. base = "SpaceFortress-%s_%s_%d-%d-%d_%d-%d-%d" % (__version__, self.config['General']['id'], d[0], d[1], d[2], d[3], d[4], d[5])
  154. logdir = self.config['Logging']['logdir']
  155. if len(logdir.strip()) == 0:
  156. logdir = get_default_logdir()
  157. if not os.path.exists(logdir):
  158. os.makedirs(logdir)
  159. self.log_basename = os.path.join(logdir, base)
  160. self.gameevents.add("log", "basename", "ready", type='EVENT_SYSTEM')
  161. self.log_filename = "%s.txt.incomplete" % (self.log_basename)
  162. self.log = open(self.log_filename, "w")
  163. self.log_header = ["event_type", "system_time", "game_time",
  164. "current_game", "eid", "e1", "e2", "e3", "foes", "ship_alive",
  165. "ship_health", "ship_x", "ship_y", "smod", "dmod", "ship_vel_x",
  166. "ship_vel_y", "ship_orientation", "distance", "mine_no", "mine_id",
  167. "mine", "fortress_alive", "fortress_x", "fortress_y",
  168. "fortress_orientation", "missile", "shell", "bonus_no",
  169. "bonus_prev", "bonus_cur", "bonus_cur_x", "bonus_cur_y"]
  170. if self.config['General']['bonus_system'] == "AX-CPT":
  171. self.log_header.append('bonus_isi')
  172. self.log_header = self.log_header + ["score_pnts", "score_cntrl", "score_vlcty", "score_vlner", "score_iff",
  173. "score_intrvl", "score_speed", "score_shots", "score_flight", "score_flight2",
  174. "score_fortress", "score_mine", "score_mine2", "score_bonus", "thrust_key",
  175. "left_key", "right_key", "fire_key", "iff_key", "shots_key", "pnts_key"]
  176. for name in self.plugins:
  177. if hasattr(self.plugins[name], "logHeader"):
  178. self.log_header = self.log_header + self.plugins[name].logHeader()
  180. self.log.write("\t".join(self.log_header) + "\n")
  182. self.gameevents.add("log", "header", "ready", log=False, type='EVENT_SYSTEM')
  183. self.gameevents.add("log", "version", "8", type='EVENT_SYSTEM')
  185. self.gameevents.add("config", "running", str(self.config), type='EVENT_SYSTEM')
  187. pygame.mouse.set_visible(False)
  189. self.set_aspect_ratio()
  190. os.environ['SDL_VIDEO_WINDOW_POS'] = str(int(mode_list[0][0] / 2 - self.SCREEN_WIDTH / 2)) + "," + str(int(mode_list[0][1] / 2 - self.SCREEN_HEIGHT / 2))
  191. if self.config['General']['next_gen']:
  192. self.WORLD_WIDTH = int((710 + 57) * self.aspect_ratio)
  193. self.WORLD_HEIGHT = int((626 + 57) * self.aspect_ratio)
  194. else:
  195. self.WORLD_WIDTH = int(710 * self.aspect_ratio)
  196. self.WORLD_HEIGHT = int(626 * self.aspect_ratio)
  197. self.linewidth = self.config['Display']['linewidth']
  199. self.stars = []
  201. self.kp_space = self.linewidth
  202. self.kp_right = self.linewidth
  203. self.kp_left = self.linewidth
  204. self.kp_thrust = self.linewidth
  205. self.kp_iff = self.linewidth
  206. self.kp_shots = self.linewidth
  207. self.kp_points = self.linewidth
  209. self.fh = int(self.SCREEN_HEIGHT / 72)
  211. self.fp = pkg_resources.resource_stream('resources', 'fonts/freesansbold.ttf')
  212. self.font1 = pygame.font.Font(self.fp, int(self.SCREEN_HEIGHT / 10))
  213. self.fp.seek(0)
  214. self.font2 = pygame.font.Font(self.fp, self.fh)
  215. self.fp.seek(0)
  216. self.f = pygame.font.Font(self.fp, int(14 * self.aspect_ratio))
  217. self.fp.seek(0)
  218. self.f6 = pygame.font.Font(self.fp, int(12 * self.aspect_ratio))
  219. self.fp.seek(0)
  220. self.f24 = pygame.font.Font(self.fp, int(20 * self.aspect_ratio))
  221. self.fp.seek(0)
  222. self.f28 = pygame.font.Font(self.fp, int(28 * self.aspect_ratio))
  223. self.fp.seek(0)
  224. self.f96 = pygame.font.Font(self.fp, int(72 * self.aspect_ratio))
  225. self.fp.seek(0)
  226. self.f36 = pygame.font.Font(self.fp, int(36 * self.aspect_ratio))
  228. self.joystick = None
  229. if self.config['Joystick']['use_joystick']:
  230. pygame.joystick.init()
  231. self.joystick = pygame.joystick.Joystick(self.config['Joystick']['joystick_id'])
  232. self.joystick.init()
  233. self.fire_button = self.config['Joystick']['fire_button']
  234. self.IFF_button = self.config['Joystick']['iff_button']
  235. self.shots_button = self.config['Joystick']['shots_button']
  236. self.pnts_button = self.config['Joystick']['pnts_button']
  238. self.thrust_key = eval("pygame.K_%s" % self.config['Keybindings']['thrust_key'])
  239. self.left_turn_key = eval("pygame.K_%s" % self.config['Keybindings']['left_turn_key'])
  240. self.right_turn_key = eval("pygame.K_%s" % self.config['Keybindings']['right_turn_key'])
  241. self.fire_key = eval("pygame.K_%s" % self.config['Keybindings']['fire_key'])
  242. self.IFF_key = eval("pygame.K_%s" % self.config['Keybindings']['IFF_key'])
  243. self.shots_key = eval("pygame.K_%s" % self.config['Keybindings']['shots_key'])
  244. self.pnts_key = eval("pygame.K_%s" % self.config['Keybindings']['pnts_key'])
  246. self.pause_key = eval("pygame.K_%s" % self.config['Keybindings']['pause_key'])
  248. if self.config['General']['sound']:
  249. pygame.mixer.init()
  250. pygame.mixer.set_num_channels(32)
  252. self.snd_shell_fired = Sound(self, pkg_resources.resource_stream("resources", "sounds/shellfired.wav"))
  253. self.snd_missile_fired = Sound(self, pkg_resources.resource_stream("resources", "sounds/missilefired.wav"))
  254. self.snd_explosion = Sound(self, pkg_resources.resource_stream("resources", "sounds/expfort.wav"))
  255. self.snd_collision = Sound(self, pkg_resources.resource_stream("resources", "sounds/collision.wav"))
  256. self.snd_vlner_reset = Sound(self, pkg_resources.resource_stream("resources", "sounds/vulnerzeroed.wav"))
  257. self.snd_bonus_success = Sound(self, pkg_resources.resource_stream("resources", "sounds/bonus_success.wav"))
  258. self.snd_bonus_fail = Sound(self, pkg_resources.resource_stream("resources", "sounds/bonus_fail.wav"))
  259. self.snd_empty = Sound(self, pkg_resources.resource_stream("resources", "sounds/emptychamber.wav"))
  261. if self.config['Display']['display_mode'] == 'Fullscreen' or self.config['Display']['display_mode'] == 'Current':
  262. self.screen = pygl2d.display.set_mode((self.SCREEN_WIDTH, self.SCREEN_HEIGHT), pygame.FULLSCREEN | pygame.DOUBLEBUF)
  263. elif self.config['Display']['display_mode'] == 'Fake Fullscreen':
  264. self.screen = pygl2d.display.set_mode((self.SCREEN_WIDTH, self.SCREEN_HEIGHT), pygame.NOFRAME | pygame.DOUBLEBUF)
  265. else:
  266. self.screen = pygl2d.display.set_mode((self.SCREEN_WIDTH, self.SCREEN_HEIGHT), pygame.DOUBLEBUF)
  267. self.screen_rect = self.screen.get_rect()
  268. self.gameevents.add("display", 'setmode', (self.SCREEN_WIDTH, self.SCREEN_HEIGHT, self.aspect_ratio), type='EVENT_SYSTEM')
  270. self.gametimer = Timer(get_time_ms)
  271. self.flighttimer = Timer(self.gametimer.elapsed)
  273. self.frame = Frame(self)
  274. self.score = Score(self)
  276. self.gameevents.add("score1", self.score.scores_locations[0][0], self.score.scores_locations[0][1], type='EVENT_SYSTEM')
  277. self.gameevents.add("score2", self.score.scores_locations[1][0], self.score.scores_locations[1][1], type='EVENT_SYSTEM')
  278. self.gameevents.add("score3", self.score.scores_locations[2][0], self.score.scores_locations[2][1], type='EVENT_SYSTEM')
  279. self.gameevents.add("score4", self.score.scores_locations[3][0], self.score.scores_locations[3][1], type='EVENT_SYSTEM')
  280. self.gameevents.add("score5", self.score.scores_locations[4][0], self.score.scores_locations[4][1], type='EVENT_SYSTEM')
  281. self.gameevents.add("score6", self.score.scores_locations[5][0], self.score.scores_locations[5][1], type='EVENT_SYSTEM')
  282. self.gameevents.add("score7", self.score.scores_locations[6][0], self.score.scores_locations[6][1], type='EVENT_SYSTEM')
  283. self.gameevents.add("score8", self.score.scores_locations[7][0], self.score.scores_locations[7][1], type='EVENT_SYSTEM')
  285. if self.config['Graphics']['fancy']:
  286. self.explosion = pygl2d.image.Image(pkg_resources.resource_stream("resources", 'gfx/exp2.png'))
  287. self.explosion_rect = self.explosion.get_rect()
  288. self.explosion.scale(182 * self.aspect_ratio / 344)
  289. self.explosion.colorize(255.0, 255.0, 255.0, 204)
  290. self.explosion_small = pygl2d.image.Image(pkg_resources.resource_stream("resources", 'gfx/exp3.png'))
  291. self.explosion_small_rect = self.explosion_small.get_rect()
  292. self.explosion_small.scale(70 * self.aspect_ratio / 85)
  293. self.explosion_small.colorize(255.0, 255.0, 255.0, 204)
  294. else:
  295. self.explosion = pygl2d.image.Image(pkg_resources.resource_stream("resources", 'gfx/exp.png'))
  296. self.explosion_rect = self.explosion.get_rect()
  297. self.explosion_small = pygl2d.image.Image(pkg_resources.resource_stream("resources", 'gfx/exp.png'))
  298. self.explosion_small_rect = self.explosion_small.get_rect()
  300. self.world = pygame.rect.Rect(0, 0, self.WORLD_WIDTH, self.WORLD_HEIGHT)
  301. self.world.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 2)
  302. if not self.config['Score']['new_scoring_pos']:
  303. self.world.top = 5 * self.aspect_ratio
  304. else:
  305. self.world.top = 70 * self.aspect_ratio
  307. self.bighex = Hex(self, self.config['Hexagon']['big_hex'])
  308. self.smallhex = Hex(self, self.config['Hexagon']['small_hex'])
  309. if self.config['Mine']['mine_exists']:
  310. self.mine_exists = True
  311. else:
  312. self.mine_exists = False
  313. self.mine_list = MineList(self)
  315. self.dmod = -1
  316. self.smod = -1
  318. self.intro_title = pygl2d.font.RenderText(get_psf_version_string(), (255, 200, 100), self.font1)
  319. self.intro_title_rect = self.intro_title.get_rect()
  320. self.intro_title_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 5)
  322. self.intro_vers = pygl2d.font.RenderText('Version: %s' % (__version__), (255, 200, 100), self.font2)
  323. self.intro_vers_rect = self.intro_vers.get_rect()
  324. self.intro_vers_rect.center = (self.SCREEN_WIDTH / 2, 4 * self.SCREEN_HEIGHT / 5 - self.fh / 2 - 2)
  326. self.intro_copy = pygl2d.font.RenderText('Copyright \xa92011 CogWorks Laboratory, Rensselaer Polytechnic Institute', (255, 200, 100), self.font2)
  327. self.intro_copy_rect = self.intro_copy.get_rect()
  328. self.intro_copy_rect.center = (self.SCREEN_WIDTH / 2, 4 * self.SCREEN_HEIGHT / 5 + self.fh / 2 + 2)
  330. self.intro_logo = pygl2d.image.Image(pkg_resources.resource_stream("resources", 'gfx/psf5.png'))
  331. self.intro_logo_rect = self.intro_logo.get_rect()
  332. self.intro_logo_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 2)
  333. self.intro_logo.scale(.4 * self.SCREEN_HEIGHT / 128)
  335. self.pause = pygl2d.font.RenderText("Paused!", (255, 255, 255), self.f96)
  336. self.pause_rect = self.pause.get_rect()
  337. self.pause_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 2)
  339. self.happy = pygl2d.image.load_xbm(pkg_resources.resource_stream("resources", "gfx/fill1.xbm"))
  340. self.gameevents.add("session", "ready", type='EVENT_SYSTEM')
  342. def set_aspect_ratio(self):
  343. self.aspect_ratio = self.SCREEN_HEIGHT / 768
  344. xover = self.SCREEN_WIDTH + 2 * (495 * self.aspect_ratio - self.SCREEN_WIDTH / 2)
  345. if xover > self.SCREEN_WIDTH:
  346. self.aspect_ratio = self.SCREEN_WIDTH / 1024
  348. def setup_world(self):
  349. """initializes gameplay"""
  350. self.gameevents.add("game", "setup", type='EVENT_SYSTEM')
  351. self.missile_list = MissileList(self)
  352. self.shell_list = ShellList(self)
  353. self.ship = Ship(self)
  355. self.gametimer.reset()
  357. if self.config['Fortress']['fortress_exists']:
  358. self.fortress = Fortress(self)
  359. self.fortress_exists = True
  360. else:
  361. self.fortress_exists = False
  362. if self.config['Bonus']['bonus_exists']:
  363. self.bonus = Bonus(self)
  364. self.bonus_exists = True
  365. else:
  366. self.bonus_exists = False
  368. self.destroyedFortresses = 0
  369. self.totalMines = 0
  370. self.destroyedMines = 0
  371. self.totalBonuses = 0
  372. self.capturedBonuses = 0
  373. self.deaths = 0
  375. self.score.pnts = 0
  376. self.score.cntrl = 0
  377. self.score.vlcty = 0
  378. self.score.speed = 0
  379. self.score.flight = 0
  380. self.flight2 = 0
  381. self.mine2 = 0
  382. self.score.fortress = 0
  383. self.score.mines = 0
  384. self.score.bonus = 0
  385. self.score.vlner = 0
  386. self.score.shots = self.config['Missile']['missile_num']
  388. self.flighttimer.reset()
  389. self.mine_list.timer.reset()
  390. if self.config['Graphics']['parallax_mode'] == 'Fortress':
  391. self.starfield_orientation = self.fortress.orientation
  392. else:
  393. self.starfield_orientation = randrange(0, 359)
  394. self.star_velocty_x = math.cos(math.radians(self.starfield_orientation - 180)) * self.config['Graphics']['star_speed']
  395. self.star_velocty_y = math.sin(math.radians(self.starfield_orientation)) * self.config['Graphics']['star_speed']
  396. if self.config['Graphics']['show_starfield']:
  397. self.init_stars()
  399. def draw_pause_overlay(self):
  400. self.pause.draw(self.pause_rect.topleft)
  402. def process_input(self):
  403. """creates game events based on pygame events"""
  404. for event in pygame.event.get():
  406. if self.joystick and self.state == self.STATE_PLAY:
  408. if event.type == pygame.JOYAXISMOTION:
  409. self.gameevents.add("joyaxismotion", event.axis, event.value, type='EVENT_USER')
  410. elif event.type == pygame.JOYBUTTONDOWN:
  411. if event.button == self.fire_button:
  412. self.gameevents.add("press", "fire", type='EVENT_USER')
  413. elif event.button == self.IFF_button:
  414. self.gameevents.add("press", "iff", type='EVENT_USER')
  415. elif event.button == self.shots_button:
  416. self.gameevents.add("press", "shots", type='EVENT_USER')
  417. elif event.button == self.pnts_button:
  418. self.gameevents.add("press", "pnts", type='EVENT_USER')
  419. elif event.type == pygame.JOYBUTTONUP:
  420. if event.button == self.fire_button:
  421. self.gameevents.add("release", "fire", type='EVENT_USER')
  422. elif event.button == self.IFF_button:
  423. self.gameevents.add("release", "iff", type='EVENT_USER')
  424. elif event.button == self.shots_button:
  425. self.gameevents.add("release", "shots", type='EVENT_USER')
  426. elif event.button == self.pnts_button:
  427. self.gameevents.add("release", "pnts", type='EVENT_USER')
  429. else:
  431. if event.type == pygame.KEYDOWN:
  433. if (pygame.key.get_mods() & self.modifier):
  434. if event.key == pygame.K_q:
  435. self.gameevents.add("press", "quit", type='EVENT_USER')
  437. if event.key == pygame.K_RETURN:
  439. if self.state == self.STATE_INTRO:
  440. self.state = self.STATE_SETUP
  442. elif self.state == self.STATE_SETUP:
  443. self.state = self.STATE_GAMENO
  445. elif self.state == self.STATE_GAMENO:
  446. if self.mine_exists:
  447. self.state = self.STATE_SETUP_IFF
  448. else:
  449. self.state = self.STATE_PREPARE
  451. elif self.state == self.STATE_IFF:
  452. self.state = self.STATE_PREPARE
  454. elif self.state == self.STATE_SCORES:
  455. self.state = self.STATE_SETUP
  457. elif self.state == self.STATE_PLAY:
  459. if event.key == self.thrust_key:
  460. self.gameevents.add("press", "thrust", type='EVENT_USER')
  461. elif event.key == self.left_turn_key:
  462. self.gameevents.add("press", "left", type='EVENT_USER')
  463. elif event.key == self.right_turn_key:
  464. self.gameevents.add("press", "right", type='EVENT_USER')
  465. elif event.key == self.fire_key:
  466. self.gameevents.add("press", "fire", type='EVENT_USER')
  467. elif event.key == self.IFF_key:
  468. self.gameevents.add("press", "iff", type='EVENT_USER')
  469. elif event.key == self.shots_key:
  470. self.gameevents.add("press", "shots", type='EVENT_USER')
  471. elif event.key == self.pnts_key:
  472. self.gameevents.add("press", "pnts", type='EVENT_USER')
  473. elif event.key == self.pause_key and self.config['General']['allow_pause']:
  474. self.gameevents.add("press", "pause", type='EVENT_USER')
  475. else:
  476. self.gameevents.add("press", event.key, "user", type='EVENT_SYSTEM')
  478. elif self.state == self.STATE_PAUSED and event.key == self.pause_key:
  479. self.gameevents.add("press", "unpause", type='EVENT_USER')
  481. else:
  482. self.gameevents.add("press", event.key, "user", type='EVENT_SYSTEM')
  484. elif event.type == pygame.KEYUP:
  486. if self.state == self.STATE_PLAY:
  488. if event.key == self.thrust_key:
  489. self.gameevents.add("release", "thrust", type='EVENT_USER')
  490. elif event.key == self.left_turn_key:
  491. self.gameevents.add("release", "left", type='EVENT_USER')
  492. elif event.key == self.right_turn_key:
  493. self.gameevents.add("release", "right", type='EVENT_USER')
  494. elif event.key == self.fire_key:
  495. self.gameevents.add("release", "fire", type='EVENT_USER')
  496. elif event.key == self.IFF_key:
  497. self.gameevents.add("release", "iff", type='EVENT_USER')
  498. elif event.key == self.shots_key:
  499. self.gameevents.add("release", "shots", type='EVENT_USER')
  500. elif event.key == self.pnts_key:
  501. self.gameevents.add("release", "pnts", type='EVENT_USER')
  503. def process_game_logic(self):
  504. """processes game logic to produce game events"""
  505. self.dmod = -1
  506. self.smod = -1
  507. if self.state == self.STATE_SETUP:
  508. if self.current_game < self.config['General']['games_per_session']:
  509. self.current_game += 1
  510. self.state = self.STATE_GAMENO
  511. self.game_title = "Game: %d of %d" % (self.current_game, self.config['General']['games_per_session'])
  512. self.game_title = pygl2d.font.RenderText(self.game_title, (255, 255, 0), self.f36)
  513. self.game_title_rect = self.game_title.get_rect()
  514. self.game_title_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 16 * 7)
  515. self.gameevents.add("display_game", self.current_game)
  516. else:
  517. self.state = self.STATE_DONE
  518. self.ret = 0
  519. self.lc.stop()
  520. elif self.state == self.STATE_SETUP_IFF:
  521. self.mine_list.generate_foes()
  522. self.gameevents.add("display_foes", " ".join(self.mine_list.foe_letters), "player")
  523. self.foe_top = pygl2d.font.RenderText("The Type-2 mines for this session are:", (255, 255, 0), self.f24)
  524. self.foe_top_rect = self.foe_top.get_rect()
  525. self.foe_top_rect.center = (self.SCREEN_WIDTH / 2, 270 * self.aspect_ratio)
  526. self.foe_middle = pygl2d.font.RenderText(", ".join(self.mine_list.foe_letters), (255, 255, 255), self.f96)
  527. self.foe_middle_rect = self.foe_middle.get_rect()
  528. self.foe_middle_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 2)
  529. self.foe_midbot = pygl2d.font.RenderText("Try to memorize them before proceeding", (255, 255, 0), self.f24)
  530. self.foe_midbot_rect = self.foe_midbot.get_rect()
  531. self.foe_midbot_rect.center = (self.SCREEN_WIDTH / 2, 500 * self.aspect_ratio)
  532. self.foe_bottom = pygl2d.font.RenderText("Press return to begin", (255, 255, 0), self.f24)
  533. self.foe_bottom_rect = self.foe_bottom.get_rect()
  534. self.foe_bottom_rect.center = (self.SCREEN_WIDTH / 2, 600 * self.aspect_ratio)
  535. self.state = self.STATE_IFF
  536. elif self.state == self.STATE_PREPARE:
  537. self.gameevents.add("game", "ready", type='EVENT_SYSTEM')
  538. self.setup_world()
  539. self.state = self.STATE_PLAY
  540. self.gameevents.add("game", "start", type='EVENT_SYSTEM')
  541. elif self.state == self.STATE_PLAY:
  542. self.ship.compute()
  543. distance = self.ship.get_distance_to_point(self.WORLD_WIDTH / 2, self.WORLD_HEIGHT / 2)
  544. flight_max_inc = self.config['Score']['flight_max_increment']
  545. dmod = 1 - (distance - self.smallhex.radius * 1.125) / (self.WORLD_WIDTH / 2)
  546. if dmod > 1.0: dmod = 1.0
  547. if dmod < 0.0: dmod = 0.0
  548. smod = max([abs(self.ship.velocity.x), abs(self.ship.velocity.y)]) / self.ship.max_vel
  549. self.dmod = dmod
  550. self.smod = smod
  551. for missile in self.missile_list:
  552. missile.compute()
  553. if self.fortress_exists == True:
  554. self.fortress.compute()
  555. for shell in self.shell_list:
  556. shell.compute()
  557. if self.config['Hexagon']['hex_shrink']:
  558. self.bighex.compute()
  559. if self.mine_exists:
  560. if self.mine_list.flag == False and self.mine_list.timer.elapsed() > self.mine_list.spawn_time:
  561. self.gameevents.add("spawn", "mine")
  562. elif self.mine_list.flag and self.mine_list.timer.elapsed() > self.mine_list.timeout:
  563. self.gameevents.add("timeout", "mine")
  564. self.mine_list.compute()
  565. self.check_bounds()
  566. #test collisions to generate game events
  567. self.test_collisions()
  568. if self.flighttimer.elapsed() > self.config['Score']['update_timer']:
  569. self.flighttimer.reset()
  570. def pointspace (a0, a1, a2, b0, b1, b2): return math.exp(a1 ** (a0 * a2)) * math.exp(b1 ** (b0 * b2))
  571. points = flight_max_inc * pointspace(self.dmod, 2, 1, self.smod, 2, 1.75) / pointspace(1, 2, 1, 1, 2, 1.75)
  572. self.gameevents.add("score+", "flight", points)
  573. self.flight2 += flight_max_inc * pointspace(self.dmod, 2, .45, self.smod, 2, 1) / pointspace(1, 2, .45, 1, 2, 1)
  574. if (self.ship.velocity.x ** 2 + self.ship.velocity.y ** 2) ** 0.5 < self.config['Score']['speed_threshold']:
  575. self.gameevents.add("score+", "vlcty", self.config['Score']['VLCTY_increment'])
  576. #self.gameevents.add("score+", "flight", self.config['Score']['VLCTY_increment'])
  577. else:
  578. self.gameevents.add("score-", "vlcty", self.config['Score']['VLCTY_increment'])
  579. #self.gameevents.add("score-", "flight", self.config['Score']['VLCTY_increment'])
  580. if self.bighex.collide(self.ship):
  581. self.gameevents.add("score+", "cntrl", self.config['Score']['CNTRL_increment'])
  582. #self.gameevents.add("score+", "flight", self.config['Score']['CNTRL_increment'])
  583. else:
  584. self.gameevents.add("score+", "cntrl", self.config['Score']['CNTRL_increment'] / 2)
  585. #self.gameevents.add("score+", "flight", self.config['Score']['CNTRL_increment']/2)
  586. if self.bonus_exists:
  587. if self.config['General']['bonus_system'] == "AX-CPT":
  588. self.bonus.axcpt_update()
  589. else:
  590. if self.bonus.visible == False and self.bonus.timer.elapsed() > self.config['Bonus']['symbol_down_time']:
  591. self.gameevents.add("activate", "bonus")
  592. elif self.bonus.visible == True and self.bonus.timer.elapsed() >= self.config['Bonus']['symbol_up_time']:
  593. self.gameevents.add("deactivate", "bonus", self.bonus.current_symbol)
  594. #update scores
  595. self.score.pnts = self.score.__getattribute__("pnts")
  596. self.score.vlcty = self.score.__getattribute__("vlcty")
  597. self.score.cntrl = self.score.__getattribute__("cntrl")
  598. self.score.speed = self.score.__getattribute__("speed")
  599. self.score.flight = self.score.__getattribute__("flight")
  600. self.score.fortress = self.score.__getattribute__("fortress")
  601. self.score.mines = self.score.__getattribute__("mines")
  602. self.score.bonus = self.score.__getattribute__("bonus")
  604. if self.gametimer.elapsed() > self.config['General']['game_time']:
  605. self.gameevents.add("game", "over", type='EVENT_SYSTEM')
  606. self.state = self.STATE_SCORES
  608. def process_events(self):
  609. """processes internal list of game events for this frame"""
  610. gameevents = copy.copy(self.gameevents)
  611. del self.gameevents[:]
  612. while len(gameevents) > 0:
  613. currentevent = gameevents.pop(0)
  614. ticks = currentevent.ticks
  615. time = currentevent.time
  616. eid = currentevent.eid
  617. game = currentevent.game
  618. command = currentevent.command
  619. obj = currentevent.obj
  620. target = currentevent.target
  621. type = currentevent.type
  622. if self.config['Logging']['logging'] and currentevent.log:
  623. self.log.write("%s\t%f\t%d\t%d\t%d\t%s\t%s\t%s\n" % (type, time, ticks, game, eid, command, obj, target))
  624. if command == "press":
  625. if obj == "pause":
  626. self.gametimer.pause()
  627. self.state = self.STATE_PAUSED
  628. elif obj == "unpause":
  629. self.state = self.STATE_PLAY
  630. self.gametimer.unpause()
  631. elif obj == "quit":
  632. self.lc.stop()
  633. elif obj == "left":
  634. self.ship.turn_left_flag = True
  635. elif obj == "right":
  636. self.ship.turn_right_flag = True
  637. elif obj == "thrust":
  638. self.ship.thrust_flag = True
  639. elif obj == "fire":
  640. self.ship.fire()
  641. elif obj == "iff":
  642. #print len(self.mine_list)
  643. #don't do anything if there's no mine on the screen
  644. if len(self.mine_list) == 0:
  645. pass
  646. elif self.mine_list[0].tagged == "fail":
  647. self.gameevents.add("tag", "already_failed")
  648. elif self.mine_list[0].tagged == "disable":
  649. self.gameevents.add("tag", "already_disabled")
  650. elif self.mine_list[0].tagged == "tagged":
  651. self.gameevents.add("tag", "already_tagged")
  652. #if the mine is untagged and this is the first tap
  653. elif self.mine_list[0].tagged == "untagged" and self.mine_list.iff_flag == False:
  654. if self.score.iff in self.mine_list.foe_letters:
  655. self.gameevents.add("first_tag", "foe")
  656. else:
  657. self.gameevents.add("first_tag", "friend_fail")
  658. #if the mine is a foe, untagged, and this is the second tap, check timer, set intrvl
  659. elif self.mine_list[0].tagged == "untagged" and self.mine_list.iff_flag:
  660. self.score.intrvl = self.mine_list.iff_timer.elapsed()
  661. if (self.mine_list.iff_timer.elapsed() > self.config['Mine']['intrvl_min']) and (self.mine_list.iff_timer.elapsed() < self.config['Mine']['intrvl_max']):
  662. self.gameevents.add("second_tag", "foe")
  663. else:
  664. self.gameevents.add("second_tag", "out_of_bounds")
  665. elif obj == "shots":
  666. if not self.bonus_captured:
  667. self.bonus_captured = True
  668. if self.config['General']['bonus_system'] == "standard":
  669. #if current symbol is bonus but previous wasn't, set flag to deny bonus if next symbol happens to be the bonus symbol
  670. if (self.bonus.current_symbol == self.bonus.bonus_symbol) and (self.bonus.prior_symbol != self.bonus.bonus_symbol):
  671. self.bonus.flag = True
  672. self.gameevents.add("flagged_for_first_bonus")
  673. if (self.bonus.current_symbol == self.bonus.bonus_symbol) and (self.bonus.prior_symbol == self.bonus.bonus_symbol):
  674. #bonus available, check flag to award or deny bonus
  675. if self.bonus.flag:
  676. self.gameevents.add("attempt_to_capture_flagged_bonus")
  677. else:
  678. self.capturedBonuses += 1
  679. self.gameevents.add("shots_bonus_capture")
  680. self.gameevents.add("score+", "shots", self.config['Score']['bonus_missiles'])
  681. self.gameevents.add("score+", "bonus", self.config['Score']['bonus_points'] / 2)
  682. self.bonus.flag = True
  683. else: #AX-CPT
  684. if self.bonus.axcpt_flag == True and (self.bonus.state == "iti" or self.bonus.state == "target") and self.bonus.current_pair == "ax":
  685. self.snd_bonus_success.play()
  686. self.capturedBonuses += 1
  687. self.gameevents.add("shots_bonus_capture")
  688. self.gameevents.add("score+", "shots", self.config['Score']['bonus_missiles'])
  689. if self.config['General']['next_gen']:
  690. self.gameevents.add("score+", "pnts", self.config['Score']['bonus_points'] / 2)
  691. else:
  692. self.gameevents.add("score+", "bonus", self.config['Score']['bonus_points'] / 2)
  693. elif self.bonus.axcpt_flag:
  694. self.bonus.axcpt_flag = False
  695. self.snd_bonus_fail.play()
  696. self.gameevents.add("shots_bonus_failure")
  697. if self.config['General']['next_gen']:
  698. self.gameevents.add("score-", "pnts", self.config['Score']['bonus_points'] / 2)
  699. else:
  700. self.gameevents.add("score-", "bonus", self.config['Score']['bonus_points'] / 2)
  701. elif obj == "pnts":
  702. if not self.bonus_captured:
  703. self.bonus_captured = True
  704. if self.config['General']['bonus_system'] == "standard":
  705. #if current symbol is bonus but previous wasn't, set flag to deny bonus if next symbol happens to be the bonus symbol
  706. if (self.bonus.current_symbol == self.bonus.bonus_symbol) and (self.bonus.prior_symbol != self.bonus.bonus_symbol):
  707. self.bonus.flag = True
  708. self.gameevents.add("flagged_for_first_bonus")
  709. if (self.bonus.current_symbol == self.bonus.bonus_symbol) and (self.bonus.prior_symbol == self.bonus.bonus_symbol):
  710. #bonus available, check flag to award or deny bonus
  711. if self.bonus.flag:
  712. self.gameevents.add("attempt_to_capture_flagged_bonus")
  713. else:
  714. self.capturedBonuses += 1
  715. self.gameevents.add("pnts_pnts_capture")
  716. self.gameevents.add("score+", "bonus", self.config['Score']['bonus_points'])
  717. self.gameevents.add("score+", "pnts", self.config['Score']['bonus_points'])
  718. self.bonus.flag = True
  719. else: #AX-CPT
  720. if self.bonus.axcpt_flag == True and (self.bonus.state == "iti" or self.bonus.state == "target") and self.bonus.current_pair == "ax":
  721. self.snd_bonus_success.play()
  722. self.capturedBonuses += 1
  723. self.gameevents.add("pnts_bonus_capture")
  724. if self.config['General']['next_gen']:
  725. self.gameevents.add("score+", "pnts", self.config['Score']['bonus_points'])
  726. else:
  727. self.gameevents.add("score+", "pnts", self.config['Score']['bonus_points'])
  728. self.gameevents.add("score+", "bonus", self.config['Score']['bonus_points'])
  729. elif self.bonus.axcpt_flag:
  730. self.bonus.axcpt_flag = False
  731. self.snd_bonus_fail.play()
  732. self.gameevents.add("pnts_bonus_failure")
  733. if self.config['General']['next_gen']:
  734. self.gameevents.add("score-", "pnts", self.config['Score']['bonus_points'] / 2)
  735. else:
  736. self.gameevents.add("score-", "bonus", self.config['Score']['bonus_points'] / 2)
  737. elif command == "destroyed":
  738. if obj == "ship":
  739. self.deaths += 1
  740. self.reset_position()
  741. self.reset_mines()
  742. elif command == "bonus_available":
  743. self.totalBonuses += 1
  744. elif command == "first_tag":
  745. if obj == "foe":
  746. self.mine_list.iff_flag = True
  747. self.mine_list.iff_timer.reset()
  748. elif len(self.mine_list) > 0:
  749. self.mine_list[0].tagged = "fail"
  750. elif command == "second_tag":
  751. self.mine_list.iff_flag = False
  752. if obj == "foe" and len(self.mine_list) > 0:
  753. self.mine_list[0].tagged = "tagged"
  754. elif command == "release":
  755. if obj == "left":
  756. self.ship.turn_left_flag = False
  757. elif obj == "right":
  758. self.ship.turn_right_flag = False
  759. elif obj == "thrust":
  760. self.ship.thrust_flag = False
  761. elif command == "warp":
  762. self.gameevents.add("score-", "pnts", self.config['Score']['warp_penalty'])
  763. self.gameevents.add("score-", "flight", self.config['Score']['warp_penalty'])
  764. elif command == "activate":
  765. if obj == "bonus":
  766. self.bonus.visible = True
  767. self.bonus.timer.reset()
  768. self.bonus.get_new_symbol()
  769. self.gameevents.add("new_bonus", self.bonus.current_symbol, self.bonus.prior_symbol)
  770. if self.bonus.current_symbol == self.bonus.prior_symbol == self.bonus.bonus_symbol:
  771. self.gameevents.add("bonus_available")
  772. #"reset" the bonus flag (which prevents premature capture) if symbol is not bonus
  773. if self.bonus.current_symbol != self.bonus.bonus_symbol:
  774. self.bonus.flag = False
  775. elif command == "deactivate":
  776. if obj == "bonus":
  777. self.bonus.visible = False
  778. self.bonus.timer.reset()
  779. elif command == "spawn":
  780. self.totalMines += 1
  781. self.mine_list.flag = True
  782. self.mine_list.timer.reset()
  783. self.mine_list.add()
  784. if self.mine_list[0].iff in self.mine_list.foe_letters:
  785. self.gameevents.add("new_mine", "foe")
  786. else:
  787. self.gameevents.add("new_mine", "friend")
  788. elif command == "timeout":
  789. self.mine_list.flag = False
  790. self.mine_list.iff_flag = False
  791. self.mine_list.timer.reset()
  792. if len(self.mine_list) > 0:
  793. del self.mine_list[0]
  794. self.score.iff = ''
  795. self.score.intrvl = 0
  796. self.gameevents.add("score-", "mines", self.config['Score']['mine_timeout_penalty'])
  797. elif command == "score++":
  798. if obj == "bonus_points":
  799. self.gameevents.add("score+", "pnts", int(target))
  800. elif command == "score+":
  801. self.score.__setattr__(obj, self.score.__getattribute__(obj) + float(target))
  802. if self.score.shots > self.config['Missile']['missile_max']:
  803. self.score.shots = self.config['Missile']['missile_max']
  804. elif command == "score-":
  805. self.score.__setattr__(obj, self.score.__getattribute__(obj) - float(target))
  806. elif command == "collide":
  807. self.process_collision(obj, target)
  808. elif command == "joyaxismotion":
  809. if obj == 0:
  810. self.ship.joy_turn = target
  811. elif obj == 1:
  812. self.ship.joy_thrust = target
  815. def process_collision(self, obj, target):
  816. """process single collision event"""
  817. if obj == "small_hex" and not self.smallhex.small_hex_flag:
  818. self.ship.velocity.x = -self.ship.velocity.x
  819. self.ship.velocity.y = -self.ship.velocity.y
  820. self.gameevents.add("score-", "pnts", self.config['Score']['small_hex_penalty'])
  821. self.gameevents.add("score-", "flight", self.config['Score']['small_hex_penalty'])
  822. self.smallhex.small_hex_flag = True
  823. elif obj == "shell":
  824. #remove shell, target is index of shell in shell_list
  825. del self.shell_list[target]
  826. self.gameevents.add("score-", "pnts", self.config['Score']['shell_hit_penalty'])
  827. self.gameevents.add("score-", "fortress", self.config['Score']['shell_hit_penalty'])
  828. self.ship.take_damage()
  829. if not self.ship.alive:
  830. self.gameevents.add("destroyed", "ship", "shell")
  831. self.gameevents.add("score-", "pnts", self.config['Score']['ship_death_penalty'])
  832. self.gameevents.add("score-", "fortress", self.config['Score']['ship_death_penalty'])
  833. self.ship.color = (255, 255, 0)
  834. elif self.config['Ship']['colored_damage']:
  835. g = 255 / self.ship.start_health * (self.ship.health - 1)
  836. self.ship.color = (255, g, 0)
  838. elif obj.startswith("missile_"):
  839. #if missile hits fortress, need to check if it takes damage when mine is onscreen
  840. if target == "fortress" and (len(self.mine_list) == 0 or self.config['Fortress']['hit_fortress_while_mine']):
  841. if self.ship.shot_timer.elapsed() >= self.config['Fortress']['vlner_time']:
  842. self.gameevents.add("score+", "vlner", 1)
  843. if self.ship.shot_timer.elapsed() < self.config['Fortress']['vlner_time'] and self.score.vlner >= self.config['Fortress']['vlner_threshold']:
  844. self.gameevents.add("destroyed", "fortress")
  845. self.fortress.alive = False
  846. #r = choice([0,45,90,135,180,225,270,315])
  847. #if r:
  848. # self.explosion.rotate(r)
  849. self.fortress.reset_timer.reset()
  850. self.snd_explosion.play()
  851. self.gameevents.add("score+", "pnts", self.config['Score']['destroy_fortress'])
  852. self.gameevents.add("score+", "fortress", self.config['Score']['destroy_fortress'])
  853. self.score.vlner = 0
  854. self.destroyedFortresses += 1
  855. self.gameevents.add("reset", "VLNER")
  856. #do we reset the mine timer?
  857. if self.config['Mine']['fortress_resets_mine']:
  858. self.mine_list.timer.reset()
  859. self.mine_list.flag = False
  860. elif self.ship.shot_timer.elapsed() < self.config['Fortress']['vlner_time'] and self.score.vlner < self.config['Fortress']['vlner_threshold']:
  861. self.gameevents.add("reset", "VLNER")
  862. self.score.vlner = 0
  863. self.snd_vlner_reset.play()
  864. self.ship.shot_timer.reset()
  865. elif target.startswith("mine_"):
  866. #deal with missile hitting mine
  867. #can the mine be hit?
  868. if len(self.mine_list) > 0:
  869. if self.mine_list[0].tagged == "fail":
  870. self.gameevents.add("collide", "fail_tagged_mine")
  871. elif self.mine_list[0].tagged == "disabled":
  872. self.gameevents.add("collide", "disable_tagged_mine")
  873. elif self.mine_list[0].tagged == "untagged":
  874. if self.score.iff in self.mine_list.foe_letters:
  875. self.mine_list[0].tagged = "disable"
  876. self.gameevents.add("collide", "untagged_foe_mine")
  877. else:
  878. self.gameevents.add("collide", "friend_mine")
  879. elif self.mine_list[0].tagged == "tagged" and self.score.iff in self.mine_list.foe_letters:
  880. self.gameevents.add("collide", "tagged_foe_mine")
  881. elif obj.startswith("mine_"):
  882. #mine hit the ship
  883. index = int(obj[-1])
  884. #check to see if mine is still alive, it is possible to shot and
  885. #collide with a mine at the same time, ties go to ship
  886. if index < len(self.mine_list):
  887. del self.mine_list[index]
  888. self.score.iff = ''
  889. self.score.intrvl = 0
  890. self.mine_list.flag = False
  891. self.mine_list.iff_flag = False
  892. self.mine_list.timer.reset()
  893. self.gameevents.add("score-", "pnts", self.config['Score']['mine_hit_penalty'])
  894. self.gameevents.add("score-", "mines", self.config['Score']['mine_hit_penalty'])
  895. self.mine2 -= self.config['Score']['mine_hit_penalty']
  896. self.ship.take_damage()
  897. if not self.ship.alive:
  898. self.gameevents.add("destroyed", "ship", "mine")
  899. self.gameevents.add("score-", "pnts", self.config['Score']['ship_death_penalty'])
  900. self.gameevents.add("score-", "mines", self.config['Score']['ship_death_penalty'])
  901. self.mine2 -= self.config['Score']['ship_death_penalty']
  902. self.ship.color = (255, 255, 0)
  903. elif self.config['Ship']['colored_damage']:
  904. g = 255 / self.ship.start_health * (self.ship.health - 1)
  905. self.ship.color = (255, g, 0)
  906. elif obj == "friend_mine":
  907. #get rid of mine
  908. self.destroyedMines += 1
  909. self.mine_list.flag = False
  910. self.mine_list.iff_flag = False
  911. self.gameevents.add("score+", "mines", self.config['Score']['energize_friend'])
  912. self.gameevents.add("score+", "pnts", self.config['Score']['energize_friend'])
  913. #see how long mine has been alive. 0-100 points if destroyed within 10 seconds
  914. self.gameevents.add("score+", "mines", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))
  915. self.gameevents.add("score+", "speed", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))
  916. #print self.mine_list.timer.elapsed()
  917. #print 100 - 10 * math.floor(self.mine_list.timer.elapsed()/1000)
  918. self.mine_list.timer.reset()
  919. self.mine2 += 50
  920. #amazingly, missile can hit the mine in the same frame as the mine hits the ship
  921. if len(self.mine_list) > 0:
  922. del self.mine_list[0]
  923. self.score.iff = ''
  924. self.score.intrvl = 0
  925. elif obj == "tagged_foe_mine":
  926. #get rid of mine
  927. self.destroyedMines += 1
  928. self.mine_list.flag = False
  929. self.mine_list.iff_flag = False
  930. self.gameevents.add("score+", "mines", self.config['Score']['destroy_foe'])
  931. self.gameevents.add("score+", "pnts", self.config['Score']['destroy_foe'])
  932. #see how long mine has been alive. 0-100 points if destroyed within 10 seconds
  933. self.gameevents.add("score+", "mines", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))
  934. self.gameevents.add("score+", "speed", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))
  935. self.mine_list.timer.reset()
  936. self.mine2 += 75
  937. if len(self.mine_list) > 0:
  938. del self.mine_list[0]
  939. self.score.iff = ''
  940. self.score.intrvl = 0
  942. def reset_mines(self):
  943. del self.mine_list[:]
  944. self.mine_list.flag = False
  945. self.mine_list.iff_flag = False
  946. self.mine_list.timer.reset()
  948. def test_collisions(self):
  949. """test collisions between relevant game entities"""
  950. if self.fortress_exists:
  951. if self.smallhex.collide(self.ship):
  952. self.gameevents.add("collide", "small_hex", "ship")
  953. else:
  954. self.smallhex.small_hex_flag = False
  955. for i, shell in enumerate(self.shell_list):
  956. if shell.collide(self.ship):
  957. self.gameevents.add("collide", "shell", i)
  958. #need to treat this carefully - the mine can overlap the fortress, so we don't want to remove the same missile twice
  959. for i, missile in enumerate(self.missile_list):
  960. del_missile = False
  961. if self.fortress_exists and missile.collide(self.fortress):
  962. self.gameevents.add("collide", "missile_" + str(i), "fortress")
  963. del_missile = True
  964. for j, mine in enumerate(self.mine_list):
  965. if missile.collide(mine) and not missile.collide(self.fortress):
  966. self.gameevents.add("collide", "missile_" + str(i), "mine_" + str(j))
  967. del_missile = True
  968. if del_missile:
  969. del self.missile_list[i]
  970. for i, mine in enumerate(self.mine_list):
  971. if mine.collide(self.ship):
  972. self.gameevents.add("collide", "mine_" + str(i), "ship")
  974. def check_bounds(self):
  975. """determine whether any shells or missiles have left the world"""
  976. for i, missile in enumerate(self.missile_list):
  977. if missile.out_of_bounds(self.world):
  978. del self.missile_list[i]
  979. self.gameevents.add("bounds_remove", "missile")
  980. for i, shell in enumerate(self.shell_list):
  981. if shell.out_of_bounds(self.world):
  982. del self.shell_list[i]
  983. self.gameevents.add("bounds_remove", "shell")
  986. def reset_position(self):
  987. """pauses the game and resets"""
  988. self.snd_explosion.play()
  989. pygame.time.delay(1000)
  990. self.score.iff = ""
  991. self.ship.alive = True
  992. self.ship.position.x = self.world.left + self.config['Ship']['ship_pos_x'] * self.aspect_ratio
  993. self.ship.position.y = self.world.top + self.config['Ship']['ship_pos_y'] * self.aspect_ratio
  994. self.ship.velocity.x = self.config['Ship']['ship_vel_x']
  995. self.ship.velocity.y = self.config['Ship']['ship_vel_y']
  996. self.ship.orientation = self.config['Ship']['ship_orientation']
  998. def draw_stars(self):
  999. stars = [[], [], []]
  1000. for star in self.stars:
  1001. if self.state == self.STATE_PLAY:
  1002. star[0] += star[2] * self.star_velocty_x
  1003. star[1] += star[2] * self.star_velocty_y
  1004. if star[0] >= self.world.right - self.linewidth:
  1005. star[0] = self.world.left + self.linewidth
  1006. star[1] = randrange(self.world.top + self.linewidth, self.world.bottom - self.linewidth)
  1007. star[2] = choice([1, 2, 3])
  1008. elif star[0] <= self.world.left + self.linewidth:
  1009. star[0] = self.world.right - self.linewidth
  1010. star[1] = randrange(self.world.top + self.linewidth, self.world.bottom - self.linewidth)
  1011. star[2] = choice([1, 2, 3])
  1012. elif star[1] >= self.world.bottom - self.linewidth:
  1013. star[1] = self.world.top + self.linewidth
  1014. star[0] = randrange(self.world.left + self.linewidth, self.world.right - self.linewidth)
  1015. star[2] = choice([1, 2, 3])
  1016. elif star[1] <= self.world.top + self.linewidth:
  1017. star[1] = self.world.bottom - self.linewidth
  1018. star[0] = randrange(self.world.left + self.linewidth, self.world.right - self.linewidth)
  1019. star[2] = choice([1, 2, 3])
  1020. stars[star[2] - 1].append((star[0], star[1]))
  1021. pygl2d.draw.points2(stars[0], (100, 100, 100), 1)
  1022. pygl2d.draw.points2(stars[1], (190, 190, 190), 2)
  1023. pygl2d.draw.points2(stars[2], (255, 255, 255), 3)
  1025. def draw_world(self):
  1026. if self.config['Graphics']['max_stars']:
  1027. self.draw_stars()
  1029. if not self.config['Hexagon']['hide_big_hex']:
  1030. self.bighex.draw()
  1031. if self.fortress_exists and not self.fortress.alive:
  1032. pass
  1033. else:
  1034. if not self.config['Hexagon']['hide_small_hex']:
  1035. self.smallhex.draw()
  1037. for shell in self.shell_list:
  1038. shell.draw()
  1039. if self.fortress_exists:
  1040. if self.fortress.alive:
  1041. self.fortress.draw()
  1042. else:
  1043. self.explosion_rect.center = (self.fortress.position.x, self.fortress.position.y)
  1044. self.explosion.draw(self.explosion_rect.topleft)
  1045. for missile in self.missile_list:
  1046. missile.draw()
  1047. if self.ship.alive:
  1048. self.ship.draw()
  1049. else:
  1050. self.explosion_small_rect.center = (self.ship.position.x, self.ship.position.y)
  1051. self.explosion_small.draw(self.explosion_small_rect.topleft)
  1052. self.mine_list.draw()
  1053. if self.bonus_exists and self.bonus.visible:
  1054. self.bonus.draw()
  1056. def draw(self):
  1057. """draws the world"""
  1059. pygl2d.display.begin_draw(self.screen_size)
  1061. if self.state == self.STATE_INTRO:
  1062. self.draw_intro()
  1064. elif self.state == self.STATE_GAMENO:
  1065. self.draw_game_number()
  1067. elif self.state == self.STATE_IFF:
  1068. self.draw_foe_mines()
  1070. elif self.state == self.STATE_PLAY or self.state == self.STATE_PAUSED:
  1071. if self.state == self.STATE_PAUSED and self.config['Display']['pause_overlay']:
  1072. self.draw_pause_overlay()
  1073. else:
  1074. pygl2d.draw.polygon([self.screen_rect.topleft, self.screen_rect.topright, self.screen_rect.bottomright, self.screen_rect.bottomleft], (64, 64, 64), stipple_pattern=self.happy[::-1])
  1075. self.frame.draw()
  1076. self.score.draw()
  1077. with scissor_box(self.world):
  1078. self.draw_world()
  1080. elif self.state == self.STATE_SCORES:
  1081. self.draw_scores()
  1083. self.gameevents.add("display", 'preflip', 'main', False, type='EVENT_SYSTEM')
  1085. pygl2d.display.end_draw()
  1087. def log_world(self):
  1088. """logs current state of world to logfile"""
  1089. system_time = get_time()
  1090. game_time = pygame.time.get_ticks()
  1091. if self.state == 2:
  1092. smod = self.smod
  1093. dmod = self.dmod
  1094. else:
  1095. smod = "NA"
  1096. dmod = "NA"
  1097. if self.ship and self.ship.alive:
  1098. ship_alive = "y"
  1099. ship_x = "%.3f" % (self.ship.position.x)
  1100. ship_y = "%.3f" % (self.ship.position.y)
  1101. ship_vel_x = "%.3f" % (self.ship.velocity.x)
  1102. ship_vel_y = "%.3f" % (self.ship.velocity.y)
  1103. ship_orientation = "%.3f" % (self.ship.orientation)
  1104. ship_health = str(self.ship.health)
  1105. distance = str(self.ship.get_distance_to_point(self.WORLD_WIDTH / 2, self.WORLD_HEIGHT / 2))
  1106. else:
  1107. ship_alive = "n"
  1108. ship_x = "NA"
  1109. ship_y = "NA"
  1110. ship_vel_x = "NA"
  1111. ship_vel_y = "NA"
  1112. ship_orientation = "NA"
  1113. ship_health = "NA"
  1114. distance = "NA"
  1115. if len(self.mine_list) > 0:
  1116. mine_no = self.mine_list.mine_count
  1117. mine_id = self.mine_list[0].iff
  1118. else:
  1119. mine_no = "NA"
  1120. mine_id = "NA"
  1121. if self.fortress and self.fortress_exists and self.fortress.alive:
  1122. fortress_alive = "y"
  1123. fortress_orientation = str(self.fortress.orientation)
  1124. fortress_x = str(self.fortress.position.x)
  1125. fortress_y = str(self.fortress.position.y)
  1126. else:
  1127. fortress_alive = "n"
  1128. fortress_orientation = "NA"
  1129. fortress_x = "NA"
  1130. fortress_y = "NA"
  1131. if self.bonus and self.config['General']['bonus_system'] == "AX-CPT":
  1132. bonus_isi = str(self.bonus.isi_time)
  1133. else:
  1134. bonus_isi = 'NA'
  1135. if self.bonus and self.bonus.visible:
  1136. bonus_no = self.bonus.bonus_count
  1137. bonus_cur_x = self.bonus.position.x
  1138. bonus_cur_y = self.bonus.position.y
  1139. else:
  1140. bonus_no = "NA"
  1141. bonus_cur_x = "NA"
  1142. bonus_cur_y = "NA"
  1143. if not self.bonus or self.bonus.current_symbol == '':
  1144. bonus_cur = "NA"
  1145. else:
  1146. bonus_cur = self.bonus.current_symbol
  1147. if not self.bonus or self.bonus.prior_symbol == '':
  1148. bonus_prev = "NA"
  1149. else:
  1150. bonus_prev = self.bonus.prior_symbol
  1151. if not self.score and self.score.iff == '':
  1152. iff_score = 'NA'
  1153. else:
  1154. iff_score = self.score.iff
  1155. keys = pygame.key.get_pressed()
  1156. if keys[self.thrust_key]:
  1157. thrust_key = "y"
  1158. else:
  1159. thrust_key = "n"
  1160. if keys[self.left_turn_key]:
  1161. left_key = "y"
  1162. else:
  1163. left_key = "n"
  1164. if keys[self.right_turn_key]:
  1165. right_key = "y"
  1166. else:
  1167. right_key = "n"
  1168. if keys[self.fire_key]:
  1169. fire_key = "y"
  1170. else:
  1171. fire_key = "n"
  1172. if keys[self.IFF_key]:
  1173. iff_key = "y"
  1174. else:
  1175. iff_key = "n"
  1176. if keys[self.shots_key]:
  1177. shots_key = "y"
  1178. else:
  1179. shots_key = "n"
  1180. if keys[self.pnts_key]:
  1181. pnts_key = "y"
  1182. else:
  1183. pnts_key = "n"
  1185. data = ["STATE", system_time, game_time, self.current_game, "NA", "NA", "NA", "NA",
  1186. " ".join(self.mine_list.foe_letters), ship_alive, ship_health, ship_x, ship_y,
  1187. smod, dmod, ship_vel_x, ship_vel_y, ship_orientation, distance, mine_no, mine_id,
  1188. self.mine_list, fortress_alive, fortress_x, fortress_y, fortress_orientation,
  1189. self.missile_list, self.shell_list]
  1191. if self.config['General']['bonus_system'] == "AX-CPT":
  1192. data = data + [ bonus_no, bonus_prev, bonus_cur, bonus_cur_x, bonus_cur_y, bonus_isi ]
  1193. else:
  1194. data = data + [ bonus_no, bonus_prev, bonus_cur, bonus_cur_x, bonus_cur_y ]
  1196. data = data + [self.score.pnts, self.score.cntrl, self.score.vlcty,
  1197. self.score.vlner, iff_score, self.score.intrvl, self.score.speed,
  1198. self.score.shots, self.score.flight, self.flight2, self.score.fortress,
  1199. self.score.mines, self.mine2, self.score.bonus, thrust_key, left_key,
  1200. right_key, fire_key, iff_key, shots_key, pnts_key]
  1202. for name in self.plugins:
  1203. if hasattr(self.plugins[name], "logCallback"):
  1204. data = data + self.plugins[name].logCallback()
  1206. self.log.write("\t".join(map(str, data)) + "\n")
  1208. def draw_intro(self):
  1209. """display intro scene"""
  1210. self.intro_title.draw(self.intro_title_rect.topleft)
  1211. self.intro_vers.draw(self.intro_vers_rect.topleft)
  1212. self.intro_copy.draw(self.intro_copy_rect.topleft)
  1213. self.intro_logo.draw(self.intro_logo_rect.topleft)
  1215. def draw_game_number(self):
  1216. """before game begins, present the game number"""
  1217. self.game_title.draw(self.game_title_rect.topleft)
  1218. pygl2d.draw.line((self.SCREEN_WIDTH / 4 , self.SCREEN_HEIGHT / 16 * 8.5), (self.SCREEN_WIDTH / 4 * 3, self.SCREEN_HEIGHT / 16 * 8.5), (255, 255, 255))
  1219. pygl2d.draw.line((self.SCREEN_WIDTH / 4 , self.SCREEN_HEIGHT / 16 * 5.5), (self.SCREEN_WIDTH / 4 * 3, self.SCREEN_HEIGHT / 16 * 5.5), (255, 255, 255))
  1221. def draw_foe_mines(self):
  1222. """before game begins, present the list of IFF letters to target"""
  1223. self.foe_top.draw(self.foe_top_rect.topleft)
  1224. self.foe_middle.draw(self.foe_middle_rect.topleft)
  1225. self.foe_midbot.draw(self.foe_midbot_rect.topleft)
  1226. self.foe_bottom.draw(self.foe_bottom_rect.topleft)
  1228. def draw_old_score(self):
  1229. """shows score for last game and waits to continue"""
  1230. pygame.event.get() #clear event list? Otherwise it skips
  1231. self.screen.fill((0, 0, 0))
  1232. gamesurf = self.f36.render("Game %d" % (self.current_game), True, (255, 255, 0))
  1233. gamerect = gamesurf.get_rect()
  1234. gamerect.centery = self.SCREEN_HEIGHT / 16 * 2
  1235. gamerect.centerx = self.SCREEN_WIDTH / 2
  1236. self.screen.blit(gamesurf, gamerect)
  1237. pygame.draw.line(self.screen, (255, 255, 255), (self.SCREEN_WIDTH / 4 , self.SCREEN_HEIGHT / 16 * 3), (self.SCREEN_WIDTH / 4 * 3, self.SCREEN_HEIGHT / 16 * 3))
  1238. pntssurf = self.f24.render("PNTS score:", True, (255, 255, 0))
  1239. pntsrect = pntssurf.get_rect()
  1240. pntsrect.left = self.SCREEN_WIDTH / 3
  1241. pntsrect.centery = self.SCREEN_HEIGHT / 16 * 4
  1242. self.screen.blit(pntssurf, pntsrect)
  1243. cntrlsurf = self.f24.render("CNTRL score:", True, (255, 255, 0))
  1244. cntrlrect = cntrlsurf.get_rect()
  1245. cntrlrect.left = self.SCREEN_WIDTH / 3
  1246. cntrlrect.centery = self.SCREEN_HEIGHT / 16 * 6
  1247. self.screen.blit(cntrlsurf, cntrlrect)
  1248. vlctysurf = self.f24.render("VLCTY score:", True, (255, 255, 0))
  1249. vlctyrect = vlctysurf.get_rect()
  1250. vlctyrect.left = self.SCREEN_WIDTH / 3
  1251. vlctyrect.centery = self.SCREEN_HEIGHT / 16 * 8
  1252. self.screen.blit(vlctysurf, vlctyrect)
  1253. speedsurf = self.f24.render("SPEED score:", True, (255, 255, 0))
  1254. speedrect = speedsurf.get_rect()
  1255. speedrect.left = self.SCREEN_WIDTH / 3
  1256. speedrect.centery = self.SCREEN_HEIGHT / 16 * 10
  1257. self.screen.blit(speedsurf, speedrect)
  1258. pntsnsurf = self.f24.render("%d" % self.score.pnts, True, (255, 255, 255))
  1259. pntsnrect = pntsnsurf.get_rect()
  1260. pntsnrect.right = self.SCREEN_WIDTH / 3 * 2
  1261. pntsnrect.centery = self.SCREEN_HEIGHT / 16 * 4
  1262. self.screen.blit(pntsnsurf, pntsnrect)
  1263. cntrlnsurf = self.f24.render("%d" % self.score.cntrl, True, (255, 255, 255))
  1264. cntrlnrect = cntrlnsurf.get_rect()
  1265. cntrlnrect.right = self.SCREEN_WIDTH / 3 * 2
  1266. cntrlnrect.centery = self.SCREEN_HEIGHT / 16 * 6
  1267. self.screen.blit(cntrlnsurf, cntrlnrect)
  1268. vlctynsurf = self.f24.render("%d" % self.score.vlcty, True, (255, 255, 255))
  1269. vlctynrect = vlctynsurf.get_rect()
  1270. vlctynrect.right = self.SCREEN_WIDTH / 3 * 2
  1271. vlctynrect.centery = self.SCREEN_HEIGHT / 16 * 8
  1272. self.screen.blit(vlctynsurf, vlctynrect)
  1273. speednsurf = self.f24.render("%d" % self.score.speed, True, (255, 255, 255))
  1274. speednrect = speednsurf.get_rect()
  1275. speednrect.right = self.SCREEN_WIDTH / 3 * 2
  1276. speednrect.centery = self.SCREEN_HEIGHT / 16 * 10
  1277. self.screen.blit(speednsurf, speednrect)
  1278. #draw line
  1279. pygame.draw.line(self.screen, (255, 255, 255), (self.SCREEN_WIDTH / 4 , self.SCREEN_HEIGHT / 16 * 11), (self.SCREEN_WIDTH / 4 * 3, self.SCREEN_HEIGHT / 16 * 11))
  1280. totalsurf = self.f24.render("Total game score:", True, (255, 255, 0))
  1281. totalrect = totalsurf.get_rect()
  1282. totalrect.left = self.SCREEN_WIDTH / 3
  1283. totalrect.centery = self.SCREEN_HEIGHT / 16 * 12
  1284. self.screen.blit(totalsurf, totalrect)
  1285. totalnsurf = self.f24.render("%d" % (self.score.pnts + self.score.cntrl + self.score.vlcty + self.score.speed), True, (255, 255, 255))
  1286. totalnrect = totalnsurf.get_rect()
  1287. totalnrect.right = self.SCREEN_WIDTH / 3 * 2
  1288. totalnrect.centery = self.SCREEN_HEIGHT / 16 * 12
  1289. self.screen.blit(totalnsurf, totalnrect)
  1290. if self.current_game == self.config['General']['games_per_session']:
  1291. finalsurf = self.f24.render("You're done! Press return to exit", True, (0, 255, 0))
  1292. else:
  1293. finalsurf = self.f24.render("Press return for next game", True, (0, 255, 0))
  1294. finalrect = finalsurf.get_rect()
  1295. finalrect.centerx = self.SCREEN_WIDTH / 2
  1296. finalrect.centery = self.SCREEN_HEIGHT / 16 * 14
  1297. self.screen.blit(finalsurf, finalrect)
  1300. def draw_ng_score(self, time):
  1301. pygame.event.get() #clear event list? Otherwise it skips
  1302. #self.screen.fill((0, 0, 0))
  1303. gamesurf = pygl2d.font.RenderText("Game %d Stats" % (self.current_game), (255, 255, 0), self.f36)
  1304. gamerect = gamesurf.get_rect()
  1305. gamerect.centery = self.SCREEN_HEIGHT / 16 * 2
  1306. gamerect.centerx = self.SCREEN_WIDTH / 2
  1307. gamesurf.draw(gamerect.topleft)
  1308. pygl2d.draw.line((self.SCREEN_WIDTH / 4 , self.SCREEN_HEIGHT / 16 * 3), (self.SCREEN_WIDTH / 4 * 3, self.SCREEN_HEIGHT / 16 * 3), (255, 255, 255))
  1309. pntssurf = pygl2d.font.RenderText("Points:", (255, 255, 0), self.f24)
  1310. pntsrect = pntssurf.get_rect()
  1311. pntsrect.left = self.SCREEN_WIDTH / 3
  1312. pntsrect.centery = self.SCREEN_HEIGHT / 16 * 4
  1313. pntssurf.draw(pntsrect.topleft)
  1314. pntsnsurf = pygl2d.font.RenderText("%d" % self.score.pnts, (255, 255, 255), self.f24)
  1315. pntsnrect = pntsnsurf.get_rect()
  1316. pntsnrect.right = self.SCREEN_WIDTH / 3 * 2
  1317. pntsnrect.centery = self.SCREEN_HEIGHT / 16 * 4
  1318. pntsnsurf.draw(pntsnrect.topleft)
  1319. deathsurf = pygl2d.font.RenderText("Deaths:", (255, 255, 0), self.f24)
  1320. deathrect = deathsurf.get_rect()
  1321. deathrect.left = self.SCREEN_WIDTH / 3
  1322. deathrect.centery = self.SCREEN_HEIGHT / 16 * 5.5
  1323. deathsurf.draw(deathrect.topleft)
  1324. deathnsurf = pygl2d.font.RenderText("%d" % (self.deaths), (255, 255, 255), self.f24)
  1325. deathnrect = deathnsurf.get_rect()
  1326. deathnrect.right = self.SCREEN_WIDTH / 3 * 2
  1327. deathnrect.centery = self.SCREEN_HEIGHT / 16 * 5.5
  1328. deathnsurf.draw(deathnrect.topleft)
  1329. cntrlsurf = pygl2d.font.RenderText("Destroyed fortresses:", (255, 255, 0), self.f24)
  1330. cntrlrect = cntrlsurf.get_rect()
  1331. cntrlrect.left = self.SCREEN_WIDTH / 3
  1332. cntrlrect.centery = self.SCREEN_HEIGHT / 16 * 7
  1333. cntrlsurf.draw(cntrlrect.topleft)
  1334. cntrlnsurf = pygl2d.font.RenderText("%d" % (self.destroyedFortresses), (255, 255, 255), self.f24)
  1335. cntrlnrect = cntrlnsurf.get_rect()
  1336. cntrlnrect.right = self.SCREEN_WIDTH / 3 * 2
  1337. cntrlnrect.centery = self.SCREEN_HEIGHT / 16 * 7
  1338. cntrlnsurf.draw(cntrlnrect.topleft)
  1339. vlctysurf = pygl2d.font.RenderText("Destroyed mines:", (255, 255, 0), self.f24)
  1340. vlctyrect = vlctysurf.get_rect()
  1341. vlctyrect.left = self.SCREEN_WIDTH / 3
  1342. vlctyrect.centery = self.SCREEN_HEIGHT / 16 * 8.5
  1343. vlctysurf.draw(vlctyrect.topleft)
  1344. vlctynsurf = pygl2d.font.RenderText("%d of %d" % (self.destroyedMines, self.totalMines), (255, 255, 255), self.f24)
  1345. vlctynrect = vlctynsurf.get_rect()
  1346. vlctynrect.right = self.SCREEN_WIDTH / 3 * 2
  1347. vlctynrect.centery = self.SCREEN_HEIGHT / 16 * 8.5
  1348. vlctynsurf.draw(vlctynrect.topleft)
  1349. speedsurf = pygl2d.font.RenderText("Captured bonuses:", (255, 255, 0), self.f24)
  1350. speedrect = speedsurf.get_rect()
  1351. speedrect.left = self.SCREEN_WIDTH / 3
  1352. speedrect.centery = self.SCREEN_HEIGHT / 16 * 10
  1353. speedsurf.draw(speedrect.topleft)
  1354. speednsurf = pygl2d.font.RenderText("%d of %d" % (self.capturedBonuses, self.totalBonuses), (255, 255, 255), self.f24)
  1355. speednrect = speednsurf.get_rect()
  1356. speednrect.right = self.SCREEN_WIDTH / 3 * 2
  1357. speednrect.centery = self.SCREEN_HEIGHT / 16 * 10
  1358. speednsurf.draw(speednrect.topleft)
  1359. pygl2d.draw.line((self.SCREEN_WIDTH / 4 , self.SCREEN_HEIGHT / 16 * 11), (self.SCREEN_WIDTH / 4 * 3, self.SCREEN_HEIGHT / 16 * 11), (255, 255, 255))
  1360. if self.current_game == self.config['General']['games_per_session']:
  1361. finalsurf = pygl2d.font.RenderText("You're done! Press return to exit", (0, 255, 0), self.f24)
  1362. else:
  1363. finalsurf = pygl2d.font.RenderText("Press return for next game", (0, 255, 0), self.f24)
  1364. finalrect = finalsurf.get_rect()
  1365. finalrect.centerx = self.SCREEN_WIDTH / 2
  1366. finalrect.centery = self.SCREEN_HEIGHT / 16 * 14
  1367. finalsurf.draw(finalrect.topleft)
  1369. def draw_new_score(self):
  1370. """shows score for last game and waits to continue"""
  1371. pygame.event.get() #clear event list? Otherwise it skips
  1372. self.screen.fill((0, 0, 0))
  1373. #sessionsurf = self.f24.render("Session %d, Game %d/%s"%(self.session_number, self.game_number, self.config["games_per_session"]), True, (255,255,255))
  1374. # sessionrect = sessionsurf.get_rect()
  1375. # sessionrect.centerx = self.SCREEN_WIDTH / 2
  1376. # sessionrect.y = 100
  1377. # self.screen.blit(sessionsurf, sessionrect)
  1378. gamesurf = self.f36.render("Game %d" % (self.current_game), True, (255, 255, 0))
  1379. gamerect = gamesurf.get_rect()
  1380. gamerect.centery = self.SCREEN_HEIGHT / 16 * 2
  1381. gamerect.centerx = self.SCREEN_WIDTH / 2
  1382. self.screen.blit(gamesurf, gamerect)
  1383. pygame.draw.line(self.screen, (255, 255, 255), (self.SCREEN_WIDTH / 4 , self.SCREEN_HEIGHT / 16 * 3), (self.SCREEN_WIDTH / 4 * 3, self.SCREEN_HEIGHT / 16 * 3))
  1384. pntssurf = self.f24.render("Flight score:", True, (255, 255, 0))
  1385. pntsrect = pntssurf.get_rect()
  1386. pntsrect.left = self.SCREEN_WIDTH / 3
  1387. pntsrect.centery = self.SCREEN_HEIGHT / 16 * 4
  1388. self.screen.blit(pntssurf, pntsrect)
  1389. cntrlsurf = self.f24.render("Fortress score:", True, (255, 255, 0))
  1390. cntrlrect = cntrlsurf.get_rect()
  1391. cntrlrect.left = self.SCREEN_WIDTH / 3
  1392. cntrlrect.centery = self.SCREEN_HEIGHT / 16 * 6
  1393. self.screen.blit(cntrlsurf, cntrlrect)
  1394. vlctysurf = self.f24.render("Mine score:", True, (255, 255, 0))
  1395. vlctyrect = vlctysurf.get_rect()
  1396. vlctyrect.left = self.SCREEN_WIDTH / 3
  1397. vlctyrect.centery = self.SCREEN_HEIGHT / 16 * 8
  1398. self.screen.blit(vlctysurf, vlctyrect)
  1399. speedsurf = self.f24.render("Bonus score:", True, (255, 255, 0))
  1400. speedrect = speedsurf.get_rect()
  1401. speedrect.left = self.SCREEN_WIDTH / 3
  1402. speedrect.centery = self.SCREEN_HEIGHT / 16 * 10
  1403. self.screen.blit(speedsurf, speedrect)
  1404. pntsnsurf = self.f24.render("%d" % self.score.flight, True, (255, 255, 255))
  1405. pntsnrect = pntsnsurf.get_rect()
  1406. pntsnrect.right = self.SCREEN_WIDTH / 3 * 2
  1407. pntsnrect.centery = self.SCREEN_HEIGHT / 16 * 4
  1408. self.screen.blit(pntsnsurf, pntsnrect)
  1409. cntrlnsurf = self.f24.render("%d" % self.score.fortress, True, (255, 255, 255))
  1410. cntrlnrect = cntrlnsurf.get_rect()
  1411. cntrlnrect.right = self.SCREEN_WIDTH / 3 * 2
  1412. cntrlnrect.centery = self.SCREEN_HEIGHT / 16 * 6
  1413. self.screen.blit(cntrlnsurf, cntrlnrect)
  1414. vlctynsurf = self.f24.render("%d" % self.score.mines, True, (255, 255, 255))
  1415. vlctynrect = vlctynsurf.get_rect()
  1416. vlctynrect.right = self.SCREEN_WIDTH / 3 * 2
  1417. vlctynrect.centery = self.SCREEN_HEIGHT / 16 * 8
  1418. self.screen.blit(vlctynsurf, vlctynrect)
  1419. speednsurf = self.f24.render("%d" % self.score.bonus, True, (255, 255, 255))
  1420. speednrect = speednsurf.get_rect()
  1421. speednrect.right = self.SCREEN_WIDTH / 3 * 2
  1422. speednrect.centery = self.SCREEN_HEIGHT / 16 * 10
  1423. self.screen.blit(speednsurf, speednrect)
  1424. #draw line
  1425. pygame.draw.line(self.screen, (255, 255, 255), (self.SCREEN_WIDTH / 4 , self.SCREEN_HEIGHT / 16 * 11), (self.SCREEN_WIDTH / 4 * 3, self.SCREEN_HEIGHT / 16 * 11))
  1426. totalsurf = self.f24.render("Total game score:", True, (255, 255, 0))
  1427. totalrect = totalsurf.get_rect()
  1428. totalrect.left = self.SCREEN_WIDTH / 3
  1429. totalrect.centery = self.SCREEN_HEIGHT / 16 * 12
  1430. self.screen.blit(totalsurf, totalrect)
  1431. totalnsurf = self.f24.render("%d" % (self.score.flight + self.score.fortress + self.score.mines + self.score.bonus), True, (255, 255, 255))
  1432. totalnrect = totalnsurf.get_rect()
  1433. totalnrect.right = self.SCREEN_WIDTH / 3 * 2
  1434. totalnrect.centery = self.SCREEN_HEIGHT / 16 * 12
  1435. self.screen.blit(totalnsurf, totalnrect)
  1436. if self.current_game == self.config['General']['games_per_session']:
  1437. finalsurf = self.f24.render("You're done! Press return to exit", True, (0, 255, 0))
  1438. else:
  1439. finalsurf = self.f24.render("Press return for next game", True, (0, 255, 0))
  1440. finalrect = finalsurf.get_rect()
  1441. finalrect.centerx = self.SCREEN_WIDTH / 2
  1442. finalrect.centery = self.SCREEN_HEIGHT / 16 * 14
  1443. self.screen.blit(finalsurf, finalrect)
  1445. def init_stars(self):
  1446. """ Create the starfield """
  1447. self.stars = []
  1448. for i in range(self.config['Graphics']['max_stars']):
  1449. star = [randrange(self.world.left, self.world.right),
  1450. randrange(self.world.top, self.world.bottom),
  1451. choice([1, 2, 3])]
  1452. self.stars.append(star)
  1454. def draw_kp(self):
  1456. color = (48, 48, 48)
  1458. left = self.WORLD_WIDTH / 2 - self.WORLD_WIDTH / 12
  1459. top = self.WORLD_HEIGHT - self.WORLD_HEIGHT / 18 * 2
  1460. width = self.WORLD_WIDTH / 12 * 2
  1461. height = self.WORLD_HEIGHT / 18 * .75
  1462. pygame.draw.rect(self.worldsurf, color, (left, top, width, height), self.kp_space)
  1464. top = top - height * 1.5
  1465. left = left + width + height / 2
  1466. width = height
  1467. pygame.draw.rect(self.worldsurf, color, (left, top, width, height), self.kp_iff)
  1469. left = left + width + height / 2
  1470. pygame.draw.rect(self.worldsurf, color, (left, top, width, height), self.kp_shots)
  1472. left = left + width + height / 2
  1473. pygame.draw.rect(self.worldsurf, color, (left, top, width, height), self.kp_points)
  1475. left = self.WORLD_WIDTH / 2 - self.WORLD_WIDTH / 12 - width - height / 2
  1476. pygame.draw.rect(self.worldsurf, color, (left, top, width, height), self.kp_right)
  1478. left = left - width - height / 2
  1479. top = top - height * 1.5
  1480. pygame.draw.rect(self.worldsurf, color, (left, top, width, height), self.kp_thrust)
  1482. left = left - width - height / 2
  1483. top = top + height * 1.5
  1484. pygame.draw.rect(self.worldsurf, color, (left, top, width, height), self.kp_left)
  1486. def draw_complete(self):
  1487. fpssurf = self.f96.render("Session Complete", True, (255, 0, 0))
  1488. fpsrect = fpssurf.get_rect()
  1489. fpsrect.centerx = self.SCREEN_WIDTH / 2
  1490. fpsrect.centery = self.SCREEN_HEIGHT / 2
  1491. self.screen.blit(fpssurf, fpsrect)
  1493. def quit(self, lc):
  1494. self.gameevents.add("game", "quit", self.ret, type='EVENT_USER')
  1495. if self.ret == 0:
  1496. self.gameevents.add("session", "complete", type='EVENT_SYSTEM')
  1497. else:
  1498. self.gameevents.add("session", "incomplete", type='EVENT_SYSTEM')
  1499. self.process_events()
  1500. if self.config['Logging']['logging']:
  1501. self.log.close()
  1502. if self.ret == 0:
  1503. os.rename(self.log_filename, self.log_filename[:-11])
  1504. pygame.quit()
  1505. self.reactor.stop()
  1507. def draw_scores(self, time=0):
  1508. self.gameevents.add("game", "end", type='EVENT_SYSTEM')
  1509. self.gameevents.add("scores", "show", type='EVENT_SYSTEM')
  1510. if self.config['General']['next_gen']:
  1511. self.draw_ng_score(time)
  1512. elif self.config['Score']['new_scoring']:
  1513. self.draw_new_score()
  1514. else:
  1515. self.draw_old_score()
  1516. self.gameevents.add("scores", "hide", type='EVENT_SYSTEM')
  1518. def refresh(self):
  1519. if self.state != self.STATE_CALIBRATE:
  1520. self.process_input()
  1521. self.process_events()
  1522. self.process_game_logic()
  1523. self.draw()
  1524. if self.config['Logging']['logging'] and self.config['Logging']['logDriver'] == 'Default':
  1525. self.log_world()
  1527. def start(self):
  1528. self.lc = LoopingCall(self.refresh)
  1529. cleanupD = self.lc.start(1.0 / self.fps)
  1530. cleanupD.addCallbacks(self.quit)
  1532. def run(self):
  1533. reactor.callLater(0, self.start)
  1534. reactor.run()

game.py at commit 710e123, no license · at the source

Overview

Authors: Anneke Hamann1, Julia Schön1, Nils Carstengerdes1
  1. Institut für Flugführung, Deutsches Zentrum für Luft- und Raumfahrt e.V. (DLR), Braunschweig, Germany
Journal: Frontiers in neuroergonomics, volume 7, article 1894934
Dates: received 29 May 2026; accepted 31 August 2026; published online 23 September 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI · PMCID PMC13642727
Status: code verified (how the code is found and verified)
Categories: EEG (modality), human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Preprocessing, Smoothing, state filtering, decompositions, Statistics, Physiology & signal measures
Keywords: aviation, cross-task performance prediction, EEG, mental workload, n-back, operator state, Space Fortress Game, training
Citations: not cited yet (Europe PMC); 68 references in the paper

Abstract

In recent years, operator state assessment has gained much attention in the aviation domain. The ability to assess or even predict performance from behavioral or physiological data offers the possibility to tailor training schedules and assistance systems to the human operators' needs. Yet, to date, there is still no valid or reliable method for such an assessment. In the present study, we present evidence that brain activity recorded via electroencephalography (EEG) can be used to predict complex cognitive task performance. 26 participants performed multiple rounds of a dual n-back task and the complex Space Fortress Game while their brain activity was recorded via EEG. Results from multiple linear regression analyses indicate that Space Fortress Game performance could be predicted reasonably well from EEG Power Spectral Density parameters from the same game, a previous game and from the dual n-back task. Our findings show that it is possible to use data from task training and even from dissimilar, less complex tasks to predict complex task performance (in offline analyses after data collection). They also underline the utility of using EEG measurements for operator state monitoring.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 1 match between paragraphs and lines of code.

CogWorks/SpaceFortress

License: none: the authors keep all their rights
State: the link answers, verified on 8 October 2026
Evidence: files inventoried
Commit: 710e12302e8adbdda597ff29f686324804fbf294, 3 March 2015
Languages: Python (27)
Size: 68 files, 27 scripts
Software Heritage: not archived
Found in: the text, “Space Fortress Game”
Holds: README, documentation
Not found: license file, CITATION.cff, environment file, tests, continuous integration
Tools: NumPy (2 files)
Availability: 1 check, the latest on 8 October 2026: the link answers
  • 8 October 2026: the link answers
28 files
At the source: github.com/CogWorks/SpaceFortress

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 27 scripts, each with its path and the digest of its content;
  • 1 match between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data availability statement

The raw data supporting the conclusions of this article will be made available by the authors, without undue reservation.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 8 October 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 3 authors, 8 keywords, 62 references.

Cite

This paper

Hamann, A., Schön, J., & Carstengerdes, N. (2026). I think, therefore I hit: EEG parameters predict performance in complex cognitive tasks. Frontiers in neuroergonomics, 7, 1894934.

BibTeX

@article{hamann2026i,
author = {Hamann, Anneke and Schön, Julia and Carstengerdes, Nils},
title = {{I think, therefore I hit: EEG parameters predict performance in complex cognitive tasks}},
journal = {Frontiers in neuroergonomics},
year = {2026},
month = oct,
volume = {7},
pages = {1894934},
publisher = {Frontiers Media SA},
issn = {2673-6195},
pmcid = {PMC13642727}
}

RIS

TY - JOUR
AU - Hamann, Anneke
AU - Schön, Julia
AU - Carstengerdes, Nils
TI - I think, therefore I hit: EEG parameters predict performance in complex cognitive tasks
T2 - Frontiers in neuroergonomics
J2 - Front Neuroergon
PY - 2026
DA - 2026/10/08
VL - 7
SP - 1894934
SN - 2673-6195
PB - Frontiers Media SA
LA - en
ER -

CSL-JSON

{
"id": "pmcid:PMC13642727",
"type": "article-journal",
"title": "I think, therefore I hit: EEG parameters predict performance in complex cognitive tasks",
"container-title": "Frontiers in neuroergonomics",
"author": [
{
"family": "Hamann",
"given": "Anneke"
},
{
"family": "Schön",
"given": "Julia"
},
{
"family": "Carstengerdes",
"given": "Nils"
}
],
"container-title-short": "Front Neuroergon",
"volume": "7",
"page": "1894934",
"PMCID": "PMC13642727",
"ISSN": "2673-6195",
"publisher": "Frontiers Media SA",
"language": "en",
"issued": {
"date-parts": [
[
2026,
10,
8
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.3389/fphys.2026.1893570
Examining physiological parameters of mental workload in the cockpit: a multimethod approach.
Journal: Frontiers in physiology
In common: 9 references
[2] doi:10.3389/fnrgo.2022.1007673 [code]
Predictions of task using neural modeling.
Journal: Frontiers in neuroergonomics
In common: NumPy, EEG, cognitive, 4 references
[3] doi:10.1111/ejn.70283 [code]
Shielding the Mind With Flow: Attention Allocation and Auditory Event-Related Potentials Under Varying Mental Workload.
Journal: The European journal of neuroscience
In common: EEG, cognitive, 3 references
[4] doi:10.1016/j.isci.2026.114757 [code]
Decoding P300 as a shared neural mechanism for oddball target detection and working memory updating.
Journal: iScience
In common: EEG, cognitive, 3 references
[5] doi:10.1038/s42003-023-05168-4 [code]
Comparative analysis of multifaceted neural effects associated with varying endogenous cognitive load.
Journal: Communications biology
In common: NumPy, EEG, cognitive, 2 references
[6] doi:10.1038/s41598-025-90540-z
Effects of startle on cognitive performance and physiological activity revealed by fNIRS and thermal imaging.
Journal: Scientific reports
In common: cognitive, 3 references
[7] doi:10.1038/s41467-024-52541-w [code]
Maintenance and transformation of representational formats during working memory prioritization.
Journal: Nature communications
In common: NumPy, EEG, cognitive, 2 references
[8] doi:10.1038/s41598-023-31264-w [code]
Assessing the development of mental fatigue during simulated flights with concurrent EEG-fNIRS measurement.
Journal: Scientific reports
In common: EEG, 2 references
[9] doi:10.1016/j.neuroimage.2026.121718 [code]
Frontotemporal bursting supports human working memory.
Journal: NeuroImage
In common: NumPy, cognitive, 2 references
[10] doi:10.1038/s41467-026-73818-2 [code]
Prefrontal parvalbumin neurons mediate working memory in a task demand-dependent manner.
Journal: Nature communications
In common: NumPy, cognitive, 2 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/repo/github.com/cogworks/spacefortress.svg)](https://openscicode.org/badge/repo/github.com/cogworks/spacefortress)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/repo/github.com/cogworks/spacefortress.svg
   :target: https://openscicode.org/badge/repo/github.com/cogworks/spacefortress
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/repo/github.com/cogworks/spacefortress"><img src="https://openscicode.org/badge/repo/github.com/cogworks/spacefortress.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.