class ActorManager(object):
def __init__(self, game_manager, player=None, npc_list=None):
self.game_manager = game_manager
self.npc_list = npc_list if npc_list is not None else []
self.player = player
def find_actor(self, name):
for npc in self.npc_list:
if npc.name == name:
return npc
def save(self):
return {
"npc_list": [npc.save() for npc in self.npc_list],
"player": None if self.player is None else self.player.save()
}
def load_base_element(self, value):
self.npc_list = []
for npc_dict in value["npc_list"]:
npc = NPC(self.game_manager)
npc.load_base_element(npc_dict)
self.npc_list.append(npc)
if value["player"] is not None:
self.player = Player(self.game_manager)
self.player.load_base_element(value["player"])
def load_reference(self, value):
for npc_dict in value["npc_list"]:
npc = self.find_actor(npc_dict['name'])
npc.load_reference(npc_dict)
if value["player"] is not None:
self.player.load_reference(value['player'])
def load_base_element(self, value):
self.npc_list = []
for npc_dict in value["npc_list"]:
npc = NPC(self.game_manager)
npc.load_base_element(npc_dict)
self.npc_list.append(npc)
if value["player"] is not None:
self.player = Player(self.game_manager)
self.player.load_base_element(value["player"])
def __init__(self,
visible=False,
enemies=[],
player=Player(),
canvasWidth=1200,
canvasHeight=700):
self.visible = visible
self.canvasWidth = canvasWidth
self.canvasHeight = canvasHeight
self.enemies = enemies
self.buttons = []
#all the button objects
self.AssaultRifle = Button(Vector(250, 250), 50, AutoRifle(), 800)
self.UpgradedShotgun = Button(Vector(250, 400), 100, Shotgun(6), 700)
self.homingLauncher = Button(Vector(450, 400), 50, RPG(self.enemies),
1200)
self.Shotgun = Button(Vector(450, 250), 50, Shotgun(), 300)
self.AtomicBomb = Button(Vector(750, 250), 75, Shotgun(96), 1500)
self.Pistol = Button(Vector(600, 250), 50, Pistol(), 100)
self.Sniper = Button(Vector(600, 400), 50, Sniper(), 600)
self.Knife = Button(Vector(750, 400), 50, Knife(self.enemies), 100)
self.Default = Button(Vector(900, 325), 150, player.weapon, 0)
self.buttons.append(self.AssaultRifle)
self.buttons.append(self.Shotgun)
self.buttons.append(self.Pistol)
self.buttons.append(self.Knife)
self.buttons.append(self.UpgradedShotgun)
self.buttons.append(self.AtomicBomb)
self.buttons.append(self.homingLauncher)
self.buttons.append(self.Sniper)
self.buttons.append(self.Default)
def initialise(self):
self.mouse = Mouse()
self.kbd = Keyboard()
self.player = Player(
Vector(self.CANVAS_WIDTH / 2, self.CANVAS_HEIGHT / 4 * 3))
self.move = Movement(self.player, self.kbd)
self.enemies = []
self.items = []
self.Pistol = Pistol()
self.SG = Shotgun()
self.melee = Knife(self.enemies)
self.Sniper = Sniper()
self.AR = AutoRifle()
self.UpgradedShotgun = Shotgun(6)
self.homingLauncher = RPG(self.enemies)
self.AtomicBomb = Shotgun(96)
self.noMoney = False
self.newWave = False
self.backgroundImage = simplegui.load_image(
'https://image.ibb.co/kEhcuc/map.png')
def test_save_game(self):
old = GameManager()
npc1 = NPC(old, 'Penguin', 'Penguin', 1000000000000, None)
player1 = Player(old, 'Husky', 'Dog', 9, None)
node1 = BaseMapNode(old, "shop")
player1.move_location(node1)
old.actor_manager.player = player1
old.actor_manager.npc_list.append(npc1)
old.map_manager.node_list.append(node1)
old.save_game('GameFile2.txt')
new = GameManager()
new.load_game('GameFile2.txt')
self.assertEqual(len(old.map_manager.node_list), len(new.map_manager.node_list))
self.assertEqual(old.map_manager.node_list[0].name, new.map_manager.node_list[0].name)
self.assertEqual(old.actor_manager.player.name, new.actor_manager.player.name)
self.assertEqual(old.actor_manager.player.current_location.name, new.actor_manager.player.current_location.name)
self.assertEqual(new.map_manager.node_list[0].name, new.actor_manager.player.current_location.name)
def generate_actor_from_map(maps):
res = []
for map_ in maps:
act_ctr = ActorController()
for _ in range(map_.width * map_.height // 50):
act_ctr.add_actor(Enemy({"name":"rat","SPD":10,"HP":10,"STR":5,\
"DEF":5,"x":randint(0,map_.width-1),"y":randint(0,map_.height-1),"dist":1,"image":267}),target=None)
if res:
prev = res[-1]
prev_x = randint(0, prev["field"].width - 1)
prev_y = randint(0, prev["field"].height - 1)
cur_x = randint(0, map_.width - 1)
cur_y = randint(0, map_.height - 1)
prev["field"].door[prev_y][prev_x] = [
map_, act_ctr, cur_x, cur_y
]
map_.door[cur_y][cur_x] = [
prev["field"], prev["ActorController"], prev_x, prev_y
]
res.append({"field": map_, "ActorController": act_ctr})
p = Player({
"name": "Player",
"SPD": 20,
"HP": 100,
"STR": 150,
"DEF": 5,
"x": 0,
"y": 0,
"image": 282
})
res[0]["ActorController"].add_actor_as_player(p)
res[0]["ActorController"].update_target(
res[0]["ActorController"].player)
return res
else:
g.actor_ctr.del_actor(target)
else:
print(actor.name, "attacked but too far.")
show_map()
print(self.actor_ctr.player)
return self
if __name__ == "__main__":
room1_act = ActorController()
p = Player({
"name": "Player",
"SPD": 20,
"HP": 100,
"STR": 150,
"DEF": 5,
"x": 5,
"y": 5
})
room1_act.add_actor_as_player(p)
room1_act.add_actor(Enemy({
"name": "rat",
"SPD": 10,
"HP": 10,
"STR": 5,
"DEF": 5,
"x": 8,
"y": 1,
"dist": 1
}),
return 0
def pick_next_actor(self):
self.tick_for_move_queue()
return self.move_queue.popleft()
def get_next_actor(self):
self.tick_for_move_queue()
return self.move_queue[0]
def get_action(self):
self.tick_for_move_queue()
print(self.move_queue)
actor=self.move_queue.popleft()
print(actor.name)
res={"act_id":actor.act_id}
res.update(actor.get_action())
return res
def get_random_param():
return {"HP":1,"x":20,"y":2,"job":"test","SPD":rnd.randint(30,60)}
if __name__=="__main__":
actCtr=ActorController()
p=Player({"SPD":15,"x":1,"y":2})
actCtr.add_actor_as_player(p)
actCtr.add_actor(Enemy({"SPD":20,"x":2,"y":2}),target=actCtr.player)
print([x.SPD for _,x in actCtr.actors.items()])
for i in range(100):
request=actCtr.get_action()
print(request)
MOUSE_MODE_INIT=['title.png','start']
MUSIC_INIT=['start.wav',1,1]
TIME=60 # Calling the pygame.time.clock.tick function TIME times per second
SPEED=5
MOVE_TIMES=3 # Movement of SPEED*MOVE_TIMES pixels for every time pressing keyboard
pygame.init()
# Import the Game_set class, create an instance object of the class Game_set, and store it in the game_main variable
game_main=Game_set(SCREEN_SIZE,SCREEN_IMAGE,TITLE)
# Putting the created instance object into the Global_var file so that classes in other files can be called at any time
gv.put_dict('game_main',game_main)
map1=Game_map(game_main,MAP_RELATE)
gv.put_dict('map',map1)
player1=Player(PLAYER_IMAGE[0],PLAYER_IMAGE[1],PLAYER_IMAGE[2])
gv.put_dict('player',player1)
monster_list1=Monster_list()
gv.put_dict('monster_list1',monster_list1)
bullet_group1=Bullet_group()
gv.put_dict('bullet_group1',bullet_group1)
dialog1=Dialog()
gv.put_dict('dialog1',dialog1)
mouse_click_screen1=Mouse_click_screen(MOUSE_MODE_INIT)
gv.put_dict('mouse_click_screen1',mouse_click_screen1)
clock=pygame.time.Clock()# Track running events
Music.play_music(MUSIC_INIT)#Initializing music playback
while(True):
class Game:
count = [1, 1]
damage = 5
def __init__(self, w=1200, h=700):
self.CANVAS_WIDTH = w
self.CANVAS_HEIGHT = h
self.pointer = Vector()
self.initialise()
self.score = 0
self.state = State()
self.waveCount = 1
self.menu = Menu_Screen()
self.state.startGame()
self.waves()
self.shop = Shop(False, self.enemies, self.player)
self.hud = hud(True)
self.frame = simplegui.create_frame('Debt Runners', self.CANVAS_WIDTH,
self.CANVAS_HEIGHT)
self.frame.set_draw_handler(self.draw)
self.frame.set_keydown_handler(self.kbd.keyDown)
self.frame.set_keyup_handler(self.kbd.keyUp)
self.frame.set_mouseclick_handler(self.click)
self.frame.set_canvas_background('Gray')
self.frame.start()
def initialise(self):
self.mouse = Mouse()
self.kbd = Keyboard()
self.player = Player(
Vector(self.CANVAS_WIDTH / 2, self.CANVAS_HEIGHT / 4 * 3))
self.move = Movement(self.player, self.kbd)
self.enemies = []
self.items = []
self.Pistol = Pistol()
self.SG = Shotgun()
self.melee = Knife(self.enemies)
self.Sniper = Sniper()
self.AR = AutoRifle()
self.UpgradedShotgun = Shotgun(6)
self.homingLauncher = RPG(self.enemies)
self.AtomicBomb = Shotgun(96)
self.noMoney = False
self.newWave = False
self.backgroundImage = simplegui.load_image(
'https://image.ibb.co/kEhcuc/map.png')
def outOfBoundsCheck(self):
# Bullet OoB(Out of Bounds) check
for bullet in self.player.weapon.attack:
if bullet.pos.y > self.CANVAS_HEIGHT - 20 or bullet.pos.y < 20 or bullet.pos.x > self.CANVAS_WIDTH - 20 or bullet.pos.x < 20:
self.player.weapon.removeAttack(bullet)
for enemy in self.enemies:
for bullet in enemy.weapon.attack:
if bullet.pos.y > self.CANVAS_HEIGHT - 20 or bullet.pos.y < 20 or bullet.pos.x > self.CANVAS_WIDTH - 20 or bullet.pos.x < 20:
enemy.weapon.removeAttack(bullet)
def playerOutOfBounds(self):
if self.player.pos.x < 0 or self.player.pos.y < 0 or self.player.pos.x > self.CANVAS_WIDTH or self.player.pos.y > self.CANVAS_HEIGHT:
if Game.count[0] % 60 == 0:
self.player.damage(Game.damage)
if Game.damage < 40:
Game.damage *= 2
Game.count[0] = 1
Game.count[0] += 1
Game.count[1] = 1
elif Game.damage > 5 or Game.count[1] > 1:
Game.count[1] += 1
if Game.count[1] % 60 == 0:
Game.damage = 5
Game.count[0] = 1
Game.count[1] = 1
def bulletHitCheck(self):
# This is for checking to see if the bullet is within the enemies hitbox.
for bullet in self.player.weapon.attack:
for enemyIndex in range(len(self.enemies)):
if (bullet.pos.x <
(self.enemies[enemyIndex].pos.x +
self.enemies[enemyIndex].size)) and (
bullet.pos.x >
(self.enemies[enemyIndex].pos.x -
self.enemies[enemyIndex].size)) and (
bullet.pos.y <
(self.enemies[enemyIndex].pos.y +
self.enemies[enemyIndex].size)) and (
bullet.pos.y >
(self.enemies[enemyIndex].pos.y -
self.enemies[enemyIndex].size)):
# Subtracting damage from enemies health
self.enemies[enemyIndex].damage(self.player.weapon.damage)
# Removing bullet, so that it does not go through the enemy
self.player.weapon.removeAttack(bullet)
# Removing enemies from list enemy list
if self.killCheck(self.enemies[enemyIndex]):
break
for enemy in self.enemies:
for bullet in enemy.weapon.attack:
if (bullet.pos.x <
(self.player.pos.x + self.player.size)) and (
bullet.pos.x >
(self.player.pos.x - self.player.size)) and (
bullet.pos.y <
(self.player.pos.y + self.player.size)) and (
bullet.pos.y >
(self.player.pos.y - self.player.size)):
# Decreasing player health when bullet lands
self.player.damage(enemy.weapon.damage)
# Removing the bullet so that is does not go though the enemy
enemy.weapon.removeAttack(bullet)
def waves(self):
# This will add the enemies to the list if round 1 is true, see State class. Each wave should only ever occur one at a time.
#basic pistol round
if self.waveCount == 1:
self.placeRandomPickups()
for e in range(3): # 3 is number of enemies
# Assigns the enemies different positions, health and a new weapon
self.enemies.append(
Enemy(
Vector(self.CANVAS_WIDTH / 5 * (e + 1),
self.CANVAS_HEIGHT / 5), 15, Pistol(), 10))
#basic shotgun round
elif self.waveCount == 2:
self.placeRandomPickups()
for e in range(3): # 3 is number of enemies
# Assigns the enemies different positions, health and a new weapon
self.enemies.append(
Enemy(
Vector(self.CANVAS_WIDTH / 4 * (e + 1),
self.CANVAS_HEIGHT / 4), 40, Shotgun(), 10))
for e in range(2): # 3 is number of enemies
# Assigns the enemies different positions, health and a new weapon
self.enemies.append(
Enemy(
Vector(self.CANVAS_WIDTH / 5 * (e + 1),
self.CANVAS_HEIGHT / 8), 40, Pistol(), 10))
#sniper round
elif self.waveCount == 3:
self.placeRandomPickups()
for e in range(5): # 3 is number of enemies
# Assigns the enemies different positions, health and a new weapon
self.enemies.append(
Enemy(
Vector(self.CANVAS_WIDTH / 6 * (e + 1),
self.CANVAS_HEIGHT / 4), 300, Pistol(), 10, 1))
elif self.waveCount == 4:
self.placeRandomPickups()
for e in range(3): # 3 is number of enemies
# Assigns the enemies different positions, health and a new weapons
self.enemies.append(
Enemy(
Vector(self.CANVAS_WIDTH / 4 * (e + 1),
self.CANVAS_HEIGHT / 4), 50, Shotgun(), 30))
elif self.waveCount == 5:
self.placeRandomPickups()
for e in range(3): # 3 is number of enemies
# Assigns the enemies different positions, health and a new weapons
self.enemies.append(
Enemy(
Vector(self.CANVAS_WIDTH / 4 * (e + 1),
self.CANVAS_HEIGHT / 4), 100, Shotgun(), 30))
elif self.waveCount == 6:
self.placeRandomPickups()
for e in range(4): # 3 is number of enemies
# Assigns the enemies different positions, health and a new weapons
self.enemies.append(
Enemy(
Vector(self.CANVAS_WIDTH / 8 * (e + 1),
self.CANVAS_HEIGHT / 4), 100, AutoRifle(), 30))
elif self.waveCount == 7:
self.placeRandomPickups()
for e in range(5): # 3 is number of enemies
# Assigns the enemies different positions, health and a new weapons
self.enemies.append(
Enemy(
Vector(self.CANVAS_WIDTH / 8 * (e + 1),
self.CANVAS_HEIGHT / 4), 100, Shotgun(6), 30))
elif self.waveCount == 8:
self.placeRandomPickups()
for e in range(6): # 3 is number of enemies
# Assigns the enemies different positions, health and a new weapons
self.enemies.append(
Enemy(
Vector(self.CANVAS_WIDTH / 8 * (e + 1),
self.CANVAS_HEIGHT / 4), 100, AutoRifle(), 30))
elif self.waveCount == 9:
self.placeRandomPickups()
for e in range(2): # 3 is number of enemies
# Assigns the enemies different positions, health and a new weapons
self.enemies.append(
Enemy(
Vector(self.CANVAS_WIDTH / 4 * (e + 1),
self.CANVAS_HEIGHT / 4), 200, Shotgun(24), 30))
elif self.waveCount == 10:
self.placeRandomPickups()
for e in range(4): # 3 is number of enemies
# Assigns the enemies different positions, health and a new weapons
self.enemies.append(
Enemy(
Vector(self.CANVAS_WIDTH / 8 * (e + 1),
self.CANVAS_HEIGHT / 4), 250, Shotgun(96), 30))
else:
self.state.playerWin()
def draw(self, canvas):
if self.newWave == True:
time.sleep(2)
self.shop.setVisible(True)
self.newWave = False
################################################
# DRAW AND UPDATE
################################################
# UPDATE PLAYABLE CHARS
self.move.update()
self.player.update(self.mouse.pos.copy())
self.mouse.update()
# Displaying the background image on the screen.
canvas.draw_image(self.backgroundImage, (450, 450), (900, 900),
(self.CANVAS_WIDTH / 2, self.CANVAS_HEIGHT / 2),
(self.CANVAS_WIDTH, self.CANVAS_HEIGHT))
# DRAW AND UPDATE ENEMIES
for enemy in self.enemies:
enemy.update(self.player.pos.copy())
enemy.draw(canvas)
#DRAW AND UPDATE ITEMS
for item in self.items:
item.draw(canvas)
item.update()
# DRAW CHARS HERE
self.player.draw(canvas, self.player.pos.copy())
self.shop.draw(canvas)
self.hud.draw(canvas, self.player.lives,
self.player.health, self.score,
self.player.weapon.__str__(), self.player.money)
self.outOfBoundsCheck()
self.bulletHitCheck()
self.playerOutOfBounds()
#DISPLAY WIN SCREEN
if self.state.winner:
playScore = "Score: " + str(self.score)
canvas.draw_text(
'Winner', [(self.CANVAS_WIDTH / 2) -
(self.frame.get_canvas_textwidth('Winner', 50)) / 2,
self.CANVAS_HEIGHT / 2], 50, 'Red')
canvas.draw_text(
playScore,
[(self.CANVAS_WIDTH / 2) -
(self.frame.get_canvas_textwidth(playScore, 50)) / 2,
(self.CANVAS_HEIGHT / 2) + 51], 50, 'Red')
if self.state.end:
time.sleep(5)
self.frame.stop()
self.state.end = True
#Seeing if the enemies array is empty, if so than increase the round counter by 1, change the state, then run the waves function again. Which will then load in round 2 enemies
if len(
self.enemies
) == 0 and self.shop.visible == False and self.state.winner == False:
roundString = "Round " + str(self.waveCount) + " complete!"
canvas.draw_text(
roundString,
[(self.CANVAS_WIDTH / 2) -
(self.frame.get_canvas_textwidth(roundString, 50)) / 2,
self.CANVAS_HEIGHT / 2], 50, 'Red')
self.newWave = True
# These two if statements must be in this order for the death screen to come up.
if self.state.over:
time.sleep(3)
self.frame.stop()
self.livesCheck(self.player)
if self.player.lives == 0:
self.state.gameOver()
showScore = "Score: " + str(self.score)
canvas.draw_text(
"Bankrupted",
[(self.CANVAS_WIDTH / 2) -
(self.frame.get_canvas_textwidth('Bankrupted', 50)) / 2,
self.CANVAS_HEIGHT / 2], 50, 'Red')
canvas.draw_text(
showScore,
[(self.CANVAS_WIDTH / 2) -
(self.frame.get_canvas_textwidth(showScore, 50)) / 2,
(self.CANVAS_HEIGHT / 2) + 50], 50, 'Red')
if self.noMoney == True:
canvas.draw_text('Not enough money! Try again', [900, 400], 15,
'Black')
def click(self, pos):
if self.shop.visible == False:
self.player.weapon.addAttack(self.mouse.pos.copy(),
self.player.pos.copy())
if self.shop.visible:
for button in self.shop.getButtons():
if (self.mouse.pos.x < (button.pos.x + button.size)) and (
self.mouse.pos.x >
(button.pos.x - button.size)) and (
self.mouse.pos.y < (button.pos.y + button.size)) and (
self.mouse.pos.y > (button.pos.y - button.size)):
if button.price == 0:
self.waveCount += 1
self.waves()
elif button.price <= self.player.money:
self.player.weapon = button.gun
self.player.money -= button.price
self.waveCount += 1
self.waves()
else:
self.noMoney = True
self.shop.setVisible(False)
def killCheck(self, enemy):
kill = False
if enemy.health <= 0:
kill = True
self.score += enemy.points
self.enemies.remove(enemy)
self.player.money += 100
return kill
def livesCheck(self, player):
if player.health <= 0:
self.player.lives -= 1
if player.lives > 0:
self.player.health = 100
def placeRandomPickups(self):
self.pistolPickup = WeaponPickup(
self.Pistol, self.player,
Vector(randint(100, 1100), randint(200, 700)), 60, 60,
'https://raw.githubusercontent.com/NJHewadewa/DebtRunners/master/Sprites/Pistol.png',
self.items)
self.knifePickup = WeaponPickup(
self.melee, self.player,
Vector(randint(100, 1100), randint(200, 700)), 60, 60,
'https://raw.githubusercontent.com/NJHewadewa/DebtRunners/master/Sprites/knife.png',
self.items)
self.ak47Pickup = WeaponPickup(
self.AR, self.player, Vector(randint(100, 1100),
randint(200, 700)), 60, 60,
'https://raw.githubusercontent.com/NJHewadewa/DebtRunners/master/Sprites/Rifle.png',
self.items)
self.shotgunPickup = WeaponPickup(
self.SG, self.player, Vector(randint(100, 1100),
randint(200, 700)), 60, 60,
'https://raw.githubusercontent.com/NJHewadewa/DebtRunners/master/Sprites/Shotgun.png',
self.items)
self.sniperPickup = WeaponPickup(
self.Sniper, self.player,
Vector(randint(100, 1100), randint(200, 700)), 60, 60,
'https://raw.githubusercontent.com/NJHewadewa/DebtRunners/master/Sprites/Sniper.png',
self.items)
self.RPGPickup = WeaponPickup(
self.homingLauncher, self.player,
Vector(randint(100, 1100), randint(200, 700)), 60, 60,
'https://raw.githubusercontent.com/NJHewadewa/DebtRunners/master/Sprites/Rocket.png',
self.items)
Pickups = [
self.pistolPickup, self.knifePickup, self.ak47Pickup,
self.ak47Pickup, self.shotgunPickup, self.shotgunPickup,
self.shotgunPickup, self.sniperPickup, self.RPGPickup
]
for x in range(randint(0, 4)):
self.items.append(Pickups[randint(0, len(Pickups) - 1)])
self.healthPickup = HealthPickup(
25, self.player, Vector(randint(100, 1100), randint(200,
700)), 60, 60,
'https://raw.githubusercontent.com/NJHewadewa/DebtRunners/master/Sprites/HP.png',
self.items)
self.items.append(self.healthPickup)
self.noMoney = False