def get_newgame():
"""returns the game scene"""
scene = Scene()
background_layer = BackgroundLayer()
# model
model = GameModel(background_layer)
# controller
ctrl = GameCtrl(model)
# view
hud = HUD()
view = GameView(model, hud)
# set controller in model
model.set_controller(ctrl)
# add controller
scene.add(ctrl, z=1, name="controller")
# add view
scene.add(hud, z=3, name="hud")
scene.add(background_layer, z=0, name="background")
scene.add(view, z=2, name="view")
return scene
def __init__(self, gsm):
self.gsm = gsm
self.background = Background(
os.path.join("res", "PlayState", "background.png"))
self.camera = Camera(self)
self.HUD = HUD(self.gsm)
# Key handling
self.leftKeyDown = False
self.rightKeyDown = False
self.upKeyDown = False
self.spriteSheet = SpriteSheet(
os.path.join("res", "PlayState", "Spritesheet.png"), 1)
# Holds all the objects in the game
self.allObjectList = pygame.sprite.Group()
self.activeObjectList = pygame.sprite.Group()
self.terrainList = pygame.sprite.Group()
self.interactableList = pygame.sprite.Group()
self.enemyList = pygame.sprite.Group()
self.enemyAIList = pygame.sprite.Group()
self.player = None
self.level = currentLevel # Sets the current level
self.loadLevel(self.level) # Loads the level
def __init__(self, nw_tile, nh_tile):
self.nw_tile = nw_tile # Set number of tile in x
self.nh_tile = nh_tile # Set number of tile in y
self.number_body = 3 # Set number of snake's body
self.score = 0 # Set score of sanke
self.db_save_size = 6 # Column size of data base
self.id = 0 # index of database's column
self.type = 1
self.x = 2
self.y = 3
self.s = 4
self.t = 5
self.enemy_dict = {} # Enemy snake dictionary
self.client_state_dict = {
'OK': 0,
'notNStart': 1,
'notNExit': 2
} # KList state of client
self.client_state = self.client_state_dict[
'notNStart'] # State of cleint
self.play_state = False # Playing state
self.game_time = 0 # time of game
self.tile_mng = TileManager(width, height, self.nw_tile,
self.nh_tile) # Set TileManager
self.snake = Snake(1, 1, self.tile_mng, green, SNAKE,
raw_input("Enter : "),
self.number_body) # Set my sanke
self.apple = Apple(0, 0, self.tile_mng, red, 0) # Set apple
self.hud = HUD() # Set HUD
def __init__(self, world):
#화면 크기
self.width = 800
self.height = 600
#센서 종류
self.actor_list = []
self.extra_list = []
self.extra_controller_list = []
self.player = None
self.camera_rgb = None
self.camera_semseg = None
self.lane_invasion_sensor = None
self.collision_sensor = None
self.gnss_sensor = None
self.waypoint = None
self.path = []
self.world = world
self.map = world.get_map()
self.spectator = self.world.get_spectator()
self.hud = HUD(self.width, self.height)
self.waypoints = self.map.generate_waypoints(3.0)
## visualize all waypoints ##
# for n, p in enumerate(self.waypoints):
# if n>1000:
# break
# world.debug.draw_string(p.transform.location, 'o', draw_shadow=True,
# color=carla.Color(r=255, g=255, b=255), life_time=30)
self.extra_num = 5
self.control_mode = None
self.restart()
self.main()
def __init__(self, world):
#화면 크기
n_iters = 100
self.width = 800
self.height = 600
#센서 종류
self.actor_list = []
self.extra_list = []
self.extra_list = []
self.extra_controller_list = []
self.extra_dl_list = []
self.extra_dl_list = []
self.player = None
self.camera_rgb = None
self.camera_semseg = None
self.lane_invasion_sensor = None
self.collision_sensor = None
self.gnss_sensor = None
self.waypoint = None
self.path = []
self.save_dir = None
self.world = world
self.map = world.get_map()
self.spectator = self.world.get_spectator()
self.hud = HUD(self.width, self.height)
self.waypoints = self.map.generate_waypoints(3.0)
self.lane_change_time = time.time()
self.max_Lane_num = 4
self.ego_Lane = 2
self.agent = None
self.controller = None
self.is_first_time = True
self.decision = None
self.simul_time = time.time()
self.accumulated_reward = 0
self.end_point = 0
self.ROI_length = 1000 #(meters)
## visualize all waypoints ##
# for n, p in enumerate(self.waypoints):
# world.debug.draw_string(p.transform.location, 'o', draw_shadow=True,
# color=carla.Color(r=255, g=255, b=255), life_time=999)
settings = self.world.get_settings()
# settings.no_rendering_mode = True
# settings.synchronous_mode = True
settings.fixed_delta_seconds = 0.02
self.world.apply_settings(settings)
self.extra_num = 30
self.section = 0
self.lane_distance_between_start = None
self.lane_distance_between_end = None
self.lane_change_point = None
self.episode_start = None
self.index = 0
self.pre_max_Lane_num = self.max_Lane_num
self.restart()
self.main()
def init():
#game
pygame.init()
screen = pygame.display.set_mode((val.width + val.l_width, val.height))
clock = pygame.time.Clock()
pygame.font.init()
pygame.display.set_caption(val.title)
font = pygame.font.SysFont('Comic Sans MS', 20)
#HUD
hud = HUD(font, pygame, screen)
return (screen, pygame, clock, font, hud)
def __init__(self, gsm):
self.gsm = gsm
self.HUD = HUD(self.gsm)
global currentLevel
global highestLevelComplete
# If you beat all the levels
if highestLevelComplete == 5:
self.gsm.setState(self.gsm.VICTORYSTATE)
# Level Images
self.levelImgRed = pygame.image.load(
os.path.join("res", "MapState", "map level red.png"))
self.levelImgRed = pygame.transform.scale(self.levelImgRed, (50, 50))
self.levelImgBlue = pygame.image.load(
os.path.join("res", "MapState", "map level blue.png"))
self.levelImgBlue = pygame.transform.scale(self.levelImgBlue, (50, 50))
self.levelImgGray = pygame.image.load(
os.path.join("res", "MapState", "map level gray.png"))
self.levelImgGray = pygame.transform.scale(self.levelImgGray, (50, 50))
# Level Locations
# Level1
self.level1X = 100
self.level1Y = 500
# Level2
self.level2X = 450
self.level2Y = 425
# Level 3
self.level3X = 275
self.level3Y = 325
# Level 4
self.level4X = 600
self.level4Y = 250
# Level 5
self.level5X = 350
self.level5Y = 125
# Player boat (navigator)
self.player = pygame.image.load(
os.path.join("res", "MapState", "menu boat.png"))
self.playerX = 90
self.playerY = 450
def get_newgame():
scene = Scene()
model = GameModel()
controller = GameController(model)
# view
hud = HUD()
view = GameView(model, hud)
# set controller in model
model.set_controller(controller)
# add controller
scene.add(controller, z=1, name="controller")
scene.add(hud, z=3, name="hud")
scene.add(view, z=2, name="view")
return scene
def get_newgame():
scene = Scene()
model = GameModel()
controller = GameController(model)
# 视图
hud = HUD()
view = GameView(model, hud)
# 模型中的控制器
model.set_controller(controller)
# 添加控制器
scene.add(controller, z=1, name="controller")
scene.add(hud, z=3, name="hud")
scene.add(view, z=2, name="view")
return scene
def __init__(self, proxy_map, startup_check=False):
super(SpecificWorker, self).__init__(proxy_map)
self.width = 1280
self.height = 720
pygame.init()
pygame.font.init()
self.display = pygame.display.set_mode(
(self.width, self.height), pygame.HWSURFACE | pygame.DOUBLEBUF)
self.camera_manager = CameraManager(self.width, self.height)
self.gnss_sensor = GNSSSensor()
self.imu_sensor = IMUSensor()
self.hud = HUD(self.width, self.height, self.gnss_sensor,
self.imu_sensor)
self.controller = None
self.clock = pygame.time.Clock()
data_to_save = {
'control': [
'Time', 'Throttle', 'Steer', 'Brake', 'Gear', 'Handbrake',
'Reverse', 'Manualgear'
],
'communication': ['Time', 'CommunicationTime']
}
self.logger = Logger(self.melexlogger_proxy, 'carlaRemoteControl',
data_to_save)
self.logger_signal.connect(self.logger.publish_to_logger)
self.Period = 0
self.previousLat = None
self.previousLong = None
self.currentLat = None
self.currentLong = None
if startup_check:
self.startup_check()
else:
self.timer.timeout.connect(self.compute)
self.timer.start(self.Period)
def get_newgame(level = 1):
status.score = 0
status.level = level
scene = Scene()
model = GameModel(hud_offset=director.window.get_size()[0]-800) #MAGIC original width
controller = GameController(model)
# view
hud = HUD()
view = GameView(model, hud)
# set controller in model
model.set_controller(controller)
# add controller
scene.add(controller, z=1, name="controller")
scene.add(hud, z=3, name="hud")
scene.add(view, z=2, name="view")
return scene
def __init__(self, width, height):
self.windowWidth = width
self.windowHeight = height
self.widthNumber = 0
self.heightNumber = 0
self.map = [] # Contains all the cells that make up the map
self.path = [
] # Ordered list of cells that make up the path for the enemies
self.walls = [] # List containing all the cells that make up the walls
self.enemies = [] # List of all enemies currently on the field
self.level = 0 # Incrementing level variable, increases difficulty
self.towers = [] # List of all towers currently on the map
self.bullets = [] # List of all bullets
self.start = 0
self.end = 0
self.startCell = None
self.endCell = None
self.hud = HUD(width, height)
def __init__(self):
"""
Main game class initialization. All other class references point to this class as "game"
"""
# window setup
pygame.display.set_caption('Necromonster')
pygame.display.set_icon(
pygame.image.load(os.path.join('rec', 'misc', 'icon.png')))
self.main_path = os.getcwd()
# initiate the clock and screen object
self.clock = pygame.time.Clock()
self.FPS = 50
self.last_tick = pygame.time.get_ticks()
self.screen_res = [900, 650]
self.center_point = [470, 350]
self.screen = pygame.display.set_mode(self.screen_res,
pygame.HWSURFACE, 32)
#DEBUG values
self.DEBUG = 1
self.RECT_DEBUG = 0
self.angle = 0
#Init and assign custom game class(es)
self.EntityHandler = EntityHandler(self)
self.ParticleManager = ParticleManager(self)
self.Scheduler = Schedule(self)
self.Entity = Entity
self.Projectile = Projectile
self.Monster = Monster
self.NPC = NPC
self.NPCText = NPCText
self.Item = Item
self.Inventory = Invent
self.Invent = self.Inventory(self)
self.Weapon = Weapon
self.Garment = Garment
self.Player = Player(self)
self.HUD = HUD(self)
# Init entity manager vars
self.entities = []
self.shadows = []
# load fonts, create font list
# do not use pygame.font.SysFont!
self.text_list = []
self.default_font = pygame.font.Font(
os.path.join('rec', 'font', 'freesansbold.ttf'), 15)
self.speak_font = pygame.font.Font(
os.path.join('rec', 'font', 'freesansbold.ttf'), 30)
# load the map that player is on
self.INSIDE = 0
self.blit_list = mapLoader.load('home', self)
# spawn initial map items/entities
self.Item(self, 'Mythril', [350, 400], world=1)
self.NPC(self, "blacksmith", [400, 400], 100, 'still')
for i in xrange(4):
self.Monster(self, 'chicken', [200 + (i * 50), 650], 1, 'neutral')
self.Monster(self, "goop", [100, 100], 1, 'aggressive')
# begin main game loop
while 1:
self.Loop()
def core_game_loop(DISPLAYSURF, DISPLAYWIDTH, DISPLAYHEIGHT):
ranlevel = randint(1, 2)
if ranlevel == 1:
lvl_type_choice = "t"
if ranlevel == 2:
lvl_type_choice = "f"
if lvl_type_choice == "t":
t_or_f_level = 1
scroll_speed = 140
if lvl_type_choice == "f":
t_or_f_level = 2
scroll_speed = 210
tile_list = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
minion_list = []
striker_list = []
turret_list = []
player_list = []
minion_kill_list = []
striker_kill_list = []
turret_kill_list = []
player_kill_list = []
wait_control = 0
calc_control = 1
level_end_in = LEVEL_LENGTH_CONTROL * 60
tile_make_in = 0
minion_make_in = 0
striker_make_in = 0
turret_make_in = 0
asteroid_make_in = 0
minion_make_in_max = 5 * 60
striker_make_in_max = 3 * 60
turret_make_in_max = 4 * 60
minions_killed = 0
strikers_killed = 0
turrets_killed = 0
asteroids_killed = 0
if lvl_type_choice == "t":
tile_make_in_max = 60
tile_list_clear_max = 600
pcmaxhp = 150
pccurhp = 150
if lvl_type_choice == "f":
tile_make_in_max = 43
tile_list_clear_max = 430
## For some reason this is the number needed to make the tiles line up.
pcmaxhp = 80
pccurhp = 80
tile_num = 11
print(lvl_type_choice)
start_tile1 = tileFactory(scroll_speed, t_or_f_level, 1, 0)
start_tile2 = tileFactory(scroll_speed, t_or_f_level, 1, 140)
start_tile3 = tileFactory(scroll_speed, t_or_f_level, 1, 280)
start_tile4 = tileFactory(scroll_speed, t_or_f_level, 1, 420)
start_tile5 = tileFactory(scroll_speed, t_or_f_level, 1, 560)
start_tile6 = tileFactory(scroll_speed, t_or_f_level, 1, 700)
start_tile7 = tileFactory(scroll_speed, t_or_f_level, 1, 840)
start_tile8 = tileFactory(scroll_speed, t_or_f_level, 1, 980)
start_tile9 = tileFactory(scroll_speed, t_or_f_level, 1, 1120)
start_tile10 = tileFactory(scroll_speed, t_or_f_level, 1, 1260)
past_row = 1
prev_row = 1
cur_row = 1
if t_or_f_level == 1:
temp_row = tile_gen_tank(past_row, prev_row, cur_row)
if t_or_f_level == 2:
temp_row = tile_gen_fight(past_row, prev_row, cur_row)
cur_row = temp_row
start_tile11 = tileFactory(scroll_speed, t_or_f_level, temp_row)
tile_list[0] = start_tile1
tile_list[1] = start_tile2
tile_list[2] = start_tile3
tile_list[3] = start_tile4
tile_list[4] = start_tile5
tile_list[5] = start_tile6
tile_list[6] = start_tile7
tile_list[7] = start_tile8
tile_list[8] = start_tile9
tile_list[9] = start_tile10
tile_list[10] = start_tile11
timer_font = pygame.font.Font("Fixedsys.ttf", 30)
HUD_display = HUD(DISPLAYSURF, DISPLAYWIDTH, DISPLAYHEIGHT, timer_font,
pcmaxhp)
great_asteroid = asteroidTestClass(
(randint(8, 12) * 300, randint(70, 440)), DISPLAYHEIGHT)
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if wait_control == 0 or wait_control == 1:
wait_amount = 17
wait_control += 1
else:
wait_amount = 16
wait_control = 0
if calc_control == 1 or calc_control == 2 or calc_control == 3:
wait_amount = wait_amount - 4
if calc_control == 4:
wait_amount = wait_amount - 3
if calc_control == 5:
wait_amount = wait_amount - 3
calc_control = 0
pygame.time.wait(wait_amount)
calc_control += 1
if tile_make_in == tile_make_in_max:
if level_end_in <= 600 and lvl_type_choice == "t":
tile_list.append(0)
tile_list[tile_num] = tileFactory(scroll_speed, t_or_f_level,
1)
temp_list = []
for index in range(len(tile_list) - 1):
temp_list.append(tile_list[index + 1])
tile_list = temp_list
tile_make_in = 0
## Tells the loop to generate tiles only on row 1 as the level will
## end in ten seconds.
elif level_end_in > 600:
if t_or_f_level == 1:
temp_row = tile_gen_tank(past_row, prev_row, cur_row)
if t_or_f_level == 2:
temp_row = tile_gen_fight(past_row, prev_row, cur_row)
past_row = prev_row
prev_row = cur_row
cur_row = temp_row
tile_list.append(0)
tile_list[tile_num] = tileFactory(scroll_speed, t_or_f_level,
temp_row)
temp_list = []
for index in range(len(tile_list) - 1):
temp_list.append(tile_list[index + 1])
## Change "index + 1" into "len(tile_list) - 1" for a
## hilarious bug.
tile_list = temp_list
tile_make_in = 0
if turret_make_in >= turret_make_in_max and level_end_in > 600:
turret_gen(turret_list, turret_kill_list, temp_row,
t_or_f_level)
turret_make_in = 0
elif level_end_in <= 600 and lvl_type_choice == "f":
temp_list = []
for index in range(len(tile_list) - 1):
temp_list.append(tile_list[index + 1])
## Tells the loop to stop generating tiles if it's a fighter level,
## since the level will end in ten seconds.
if minion_make_in == minion_make_in_max and level_end_in > 600:
minion_gen(minion_list, minion_kill_list, DISPLAYWIDTH,
DISPLAYHEIGHT)
minion_make_in = 0
if striker_make_in == striker_make_in_max and level_end_in > 600:
striker_gen(striker_list, striker_kill_list, DISPLAYWIDTH,
DISPLAYHEIGHT)
striker_make_in = 0
## Generate enemies here and supply classes with their indicies.
tile_make_in += 1
minion_make_in += 1
striker_make_in += 1
turret_make_in += 1
level_end_in -= 1
if len(minion_list) > 0:
for x in range(len(minion_list)):
minion_list[x].index_update(x)
minion_list[x].pos_change()
if len(striker_list) > 0:
for x in range(len(striker_list)):
striker_list[x].index_update(x)
striker_list[x].pos_change()
if len(turret_list) > 0:
for x in range(len(turret_list)):
turret_list[x].index_update(x)
turret_list[x].pos_change()
great_asteroid.pos_change()
## check for collision and enemy death here
if len(minion_kill_list) > 0:
for index in minion_kill_list:
DISPLAYSURF.blit(minion_list[index].MINSURF,
(DISPLAYWIDTH + 1, DISPLAYHEIGHT + 1))
minion_list[index] = 0
minion_kill_list = []
if len(striker_kill_list) > 0:
for index in striker_kill_list:
DISPLAYSURF.blit(striker_list[index].STRISURF,
(DISPLAYWIDTH + 1, DISPLAYHEIGHT + 1))
striker_list[index] = 0
striker_kill_list = []
if len(turret_kill_list) > 0:
for index in turret_kill_list:
DISPLAYSURF.blit(turret_list[index].TURSURF,
(DISPLAYWIDTH + 1, DISPLAYHEIGHT + 1))
turret_list[index] = 0
turret_kill_list = []
## Removes a sprite class from their sprite list at the index stored in
## their kill list (which should always be accurate at this point) and
## replaces it with a 0. (Does not directly remove them from the list
## as that would make the rest of the indicies in the kill list
## inaccurate due to list length being changed.)
##
## The DISPLAYSURF.blit is strictly for moving them offscreen first
## so they don't remain and interact with other entites. Will not work
## at this moment.
## for minion in minion_list:
## minion.update()
## for striker in striker_list:
## striker.update()
## for turret in turret_list:
## turret.update()
if 0 in minion_list:
temp_list = []
for x in range(len(minion_list)):
if not minion_list[x] == 0:
temp_list.append(minion_list[x])
minion_list = temp_list
for x in range(len(minion_list)):
minion_list[x].index_update(x)
if 0 in striker_list:
temp_list = []
for x in range(len(striker_list)):
if not striker_list[x] == 0:
temp_list.append(striker_list[x])
striker_list = temp_list
for x in range(len(striker_list)):
striker_list[x].index_update(x)
if 0 in turret_list:
temp_list = []
for x in range(len(turret_list)):
if not turret_list[x] == 0:
temp_list.append(turret_list[x])
turret_list = temp_list
for x in range(len(turret_list)):
turret_list[x].index_update(x)
for tile in tile_list:
tile.pos_change()
DISPLAYSURF.fill(BLACK)
for tile in tile_list:
DISPLAYSURF.blit(tile.TILESURF, tile.pos)
for minion in minion_list:
DISPLAYSURF.blit(minion.MINSURF, minion.pos)
for striker in striker_list:
DISPLAYSURF.blit(striker.STRISURF, striker.pos)
for turret in turret_list:
DISPLAYSURF.blit(turret.TURSURF, turret.pos)
DISPLAYSURF.blit(great_asteroid.ASTSURF, great_asteroid.pos)
HUD_display.timer_display(level_end_in)
HUD_display.health_display(pccurhp)
if level_end_in % 60 == 0:
if pccurhp > 0:
pccurhp -= 1
if level_end_in == 0:
level_end(DISPLAYSURF, DISPLAYWIDTH, DISPLAYHEIGHT, tile_list,
lvl_type_choice, minions_killed, strikers_killed,
turrets_killed, asteroids_killed)
pygame.display.update()
def run(self):
"""
Runs the game.
@return: Exit status. Signals what screen comes next.
"""
self.music.fadeout(1000)
self.music.load(self.music.game)
self.music.play(-1)
pygame.mouse.set_visible(False)
self.background = pygame.Surface(self.screen.get_size())
self.background.fill((0, 0, 0))
self.screen.blit(self.background, (0, 0))
# Game objects.
cursor = Reticule(self.screen)
player = Player(self.screen, self.DEBUG)
playerSonar = PlayerSonar(self.screen, player)
self.sonarList.add(playerSonar)
gun = GunHandler(self.screen, player, self.sfx, self.DEBUG)
hud = HUD(self.screen, player, self.clock, gun)
playerHealth = PlayerHealth(self.screen, player)
# Sprite Lists.
self.playerList.add(player)
self.hudList.add(playerHealth)
self.hudList.add(cursor)
self.hudList.add(hud)
# Main game loop.
while (player.health > 0):
self.clock.tick(self.FPS)
self.addEnemies(player)
pygame.time.wait(5)
for event in pygame.event.get():
# Close the window.
if event.type == pygame.QUIT:
pygame.quit()
sys.exit(0)
# Keyboard input.
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.quit()
sys.exit(0)
elif event.key == pygame.K_1:
gun.setGun(gun.k_pistol)
elif event.key == pygame.K_2:
gun.setGun(gun.k_shotgun)
elif event.key == pygame.K_3:
gun.setGun(gun.k_smg)
pygame.event.clear()
# Mouse Button Press.
self.handleMouse(player, gun)
# Update Sprite Lists.
self.handleCollisions(player)
self.handleSonar(player)
self.updateScreen()
if not self.DEBUG:
self.addScore(player.score)
return 2
def __init__(self, size):
self.hud = HUD(size)
