def test_two_living_sides(self):
joe = Player("Joe")
darf = Mob("Darf")
self.assertTrue(two_sides([joe, darf]))
joe.take_damage(150)
self.assertFalse(joe.is_alive)
self.assertFalse(two_sides(living_fighters([joe, darf])))
def game_loop():
contestants = [
Player('Rick', 100),
Player('Morty', 10),
Player('Summer', 25),
Player('Beth', 50),
Player('Jerry', 3),
Alien('Amish Cyborg', 40, 2)
]
print('The contestants are {}'.format(contestants))
print('The battle begins...')
while len(contestants) > 1:
p1 = random.choice(contestants)
p2 = random.choice(contestants)
print('{} attacks {}'.format(p1, p2))
if p1.attack() > p2.defense():
print('{} is defeated'.format(p2))
contestants.remove(p2)
else:
print('{} blocks'.format(p2))
winner = contestants[0]
print('{} wins the battle'.format(winner))
def __init__(self, win, net, username):
self.menu = False
self.grid = False
self.win = win
self.net = net
#generate and save map
# new_map = Map()
# new_map.generate_map('random', False)
self.bg = pygame.image.load('sprites/background.jpg').convert()
#load first shuffled map from server
self.current_map = 0
Map.load(self.net.maps[self.current_map])
#create client player object and assign colour based on ID, username from input, map from server
self.ash = Player(
RandomNode(Map.nodes).node, self.net.playerID, username,
self.current_map)
#other player objects
p2, p3, p4, p5 = None, None, None, None
self.players = [p2, p3, p4, p5]
self.bikes = [Bike() for i in range(config.bikes)]
self.mushrooms = [Mushroom() for i in range(config.mushrooms)]
WeaponStatus.set_locations(self.bikes, self.mushrooms)
music = pygame.mixer.music.load(config.theme)
pygame.mixer.music.set_volume(0.5)
pygame.mixer.music.play(-1)
self.ash.ID = self.net.playerID
def test_rifle(self):
# setup
player = Player("joe")
monster = Mob("darf")
starting_monster_hp = monster.hp
# player shoots monster with rifle
player.perform_attack(attacks['rifle'], [monster])
# assert the monster was hit and the weapon must cooldown
self.assertEqual(monster.hp, starting_monster_hp - attacks['rifle']['damage'])
self.assertNotIn('rifle', player.available_attacks)
def test_grenade(self):
# setup
player = Player("joe")
monster1 = Mob("darf")
starting_monster1_hp = monster1.hp
monster2 = Mob("weebo")
starting_monster2_hp = monster2.hp
# player throws grenade at 2 monsters
player.perform_attack(attacks['grenade'], [monster1, monster2])
# assert both monsters were hit and the weapon must cooldown
self.assertEqual(monster1.hp, starting_monster1_hp - attacks['grenade']['damage'])
self.assertEqual(monster2.hp, starting_monster2_hp - attacks['grenade']['damage'])
self.assertNotIn('grenade', player.available_attacks)
def add_character(self,map,sprite,pos,direction):
p = Player()
p.map = map
p.pos = pos
p.load(sprite)
getattr(p,direction)()
p.idle()
self.add(p)
return p
def play():
skeleton = Monster('Skeleton', 50, 10, 0)
player = Player()
skeleton.attack(player)
player.attack(skeleton)
player.attack(skeleton)
player.attack(skeleton)
player.attack(skeleton)
def create_player():
# create player
decision = input("Create a new player? YES/NO").lower()
if decision == 'yes':
new_player = Player.Player()
new_player.generate_character()
# player.type_name()
new_player.generate_name()
new_player.generate_equipment()
print(new_player)
return new_player
elif decision == 'no':
print("No player, no game!")
return False
else:
create_player()
# json1_str = json1_file.read()
# json1_data = json.loads(json1_str)
data_file = open("testmap.py")
data_str = data_file.read()
#
game_manager = Manager()
# list of vars filled by exec
data = None
start = None
exec(data_str)
game_manager.hack_map(data, start)
game_manager.player = Player()
# only use this when not hacking
# game_manager.make_map(json1_data)
print(
"""You wake up, badly bruised, freezing and with barely enough energy to move.
Getting up, you inspect your surroundings...""")
# debug
# print(game_manager.location.name)
last_command = None
while True:
# enemies only attack after a non-inspect action
if not (last_command is None or last_command.root == "inspect"):
### Let's Game to be started ###
################################
pg.init()
pg.display.set_caption('Hello pygame')
mainScreen = pg.display.set_mode((WIDTH, HEIGHT))
clock = pg.time.Clock()
imge = pg.image.load(os.path.join(IMG_FOLDER,
'colored_packed.png')).convert_alpha()
imgKit = []
for i in range(22):
for j in range(48):
imgKit.append(imge.subsurface(j * 16, i * 16, 16, 16))
player1 = Player(16, 16, imgKit[25])
brickRectsList = []
bricksList = []
wallGroup, prixGroup, enemyGroup = worldCreate(levels[0])
# Цикл игры
game = True
while game:
# Keep tempo
clock.tick(FPS)
# check for events
for e in pg.event.get():
# check for closing window
if e.type == pg.QUIT or (e.type == pg.KEYDOWN
and e.key == pg.K_ESCAPE):
import random
from card_book import Card, Deck
from characters import Player
from actions import deal, game_on, dealer_on
from actions import bank
# GAME LOGIC STARTS HERE
Player1 = Player(input("Enter you Name:\n"))
Dealer1 = Player('Dealer')
champ = True
# player_turn = game_on(Player1)
# dealer_turn = Dealer1.current_hand[0].value + Dealer1.current_hand[1].value
game_turns = 0
while True:
if game_turns == 0:
Current_Bank = bank(
int(input("How much would you like to play with? \n")))
print(f"{Player1.name} is entering the game with ${Current_Bank}\n")
while True:
print(deal(Player1, Dealer1))
bet = int(input("What is your bet for this hand?\n"))
if bet > Current_Bank:
print("Insufficient Amount, Please enter new amount to bet!")
bet = int(input("What is your bet for this hand?\n"))
player_turn = game_on(Player1, Dealer1)
dealer_hand = Dealer1.current_hand[0].value + Dealer1.current_hand[
1].value
fpsClock = pygame.time.Clock()
# programIcon = pygame.image.load(icon_img)
background = pygame.transform.scale(pygame.image.load(background_img),
(990, 660))
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Zoe Town")
# pygame.display.set_icon(programIcon)
# loot_sound = pygame.mixer.Sound("crash.wav")
# score
base_font = pygame.font.Font(None, 32)
color = pygame.Color("orange")
# Initializing sprites and loot
player = Player(player_img)
gem1 = Gem(gems[0], screen)
gem2 = Gem(gems[1], screen)
villain = Villain(monster_img)
# Initializing joystick
try:
joystick = pygame.joystick.Joystick(0)
joystick.init()
except:
print("no joystick")
# setting up game loop
running = True
while running:
for pig, skill in choice_dict.items():
result += f"-- {pig} with a skill: {skill.name}\n"
else:
for pig, skill in choice_dict.items():
result += f"-- {pig}: {skill}\n"
return result
player_name = input("What is your name? \n>> ")
print(f"Yo {player_name}! \n")
chosen_skills = player_type_choice()
# Create player
player = Player(name=player_name,
hp=[30, 30],
dmg=[5, 15],
skills=chosen_skills)
# Play game
while True:
play_or_stats = input("If you want check your stats type 'stats'. \
Otherwise type 'play'\n>> ")
if play_or_stats.lower() == "stats":
player.get_stats()
print(MONSTERS_DICT)
elif play_or_stats.lower() == "play":
event = create_random_event(player, BATTLE_DESCRIPTS, MONSTERS_DICT,
OTHER_EVENTS)
if not event:
player.get_stats()
exit("You won the game!") # Futureproofing
def setup(self):
if G.SINGLEPLAYER:
try:
# TODO: create world menu
G.SAVE_FILENAME = "world"
start_server(internal=True)
sock = socket.socket()
time.sleep(2)
sock.connect(("localhost", 1486))
except socket.error as e:
#Otherwise back to the main menu we go
return False
except Exception as e:
import traceback
traceback.print_exc()
return False
else:
try:
#Make sure the address they want to connect to works
ipport = G.IP_ADDRESS.split(":")
if len(ipport) == 1: ipport.append(1486)
sock = socket.socket()
sock.connect((tuple(ipport)))
except socket.error as e:
#Otherwise back to the main menu we go
return False
self.init_gl()
self.debug_text = TextWidget(self.window, 'Loading information...',
0, self.window.height - 300,
500, 300,
visible=True, multi_line=True, readonly=True,
font_name='Arial', font_size=8,
text_color=(255, 255, 255, 255),
background_color=(0, 0, 0, 0))
self.debug_text.write_escape("$$r")
sky_rotation = -20.0 # -20.0
# TERRAIN_CHOICE = self.biome_generator.get_biome_type(sector[0], sector[2])
default_skybox = 'skydome.jpg'
# if TERRAIN_CHOICE == G.NETHER:
# default_skybox = 'skydome_nether.jpg'
# else:
# default_skybox = 'skybox.jpg'
self.skydome = Skydome(
'resources/' + default_skybox,
#'resources/skydome.jpg',
0.7,
100.0,
sky_rotation,
)
self.player_ids = {} # Dict of all players this session, indexes are their ID's [0: first Player on server,]
self.focus_block = Block(width=1.05, height=1.05)
self.earth = vec(0.8, 0.8, 0.8, 1.0)
self.white = vec(1.0, 1.0, 1.0, 1.0)
self.polished = GLfloat(100.0)
self.crack_batch = pyglet.graphics.Batch()
# if G.DISABLE_SAVE and world_exists(G.game_dir, G.SAVE_FILENAME):
# open_world(self, G.game_dir, G.SAVE_FILENAME)
self.world = World()
self.packetreceiver = PacketReceiver(self.world, self, sock)
self.world.packetreceiver = self.packetreceiver
G.CLIENT = self.packetreceiver
self.packetreceiver.start()
#Get our position from the server
self.packetreceiver.request_spawnpos()
#Since we don't know it yet, lets disable self.update, or we'll load the wrong chunks and fall
self.update_disabled = self.update
self.update = lambda dt: None
#We'll re-enable it when the server tells us where we should be
self.player = Player(game_mode=G.GAME_MODE)
self.item_list = ItemSelector(self, self.player, self.world)
self.inventory_list = InventorySelector(self, self.player, self.world)
self.item_list.on_resize(self.window.width, self.window.height)
self.inventory_list.on_resize(self.window.width, self.window.height)
self.text_input = TextWidget(self.window, '',
0, 0,
self.window.width,
visible=False,
font_name=G.CHAT_FONT)
self.text_input.push_handlers(on_toggled=self.on_text_input_toggled, key_released=self.text_input_callback)
self.chat_box = TextWidget(self.window, '',
0, self.text_input.y + self.text_input.height + 50,
self.window.width // 2, height=min(300, self.window.height // 3),
visible=False, multi_line=True, readonly=True,
font_name=G.CHAT_FONT,
text_color=(255, 255, 255, 255),
background_color=(0, 0, 0, 100),
enable_escape=True)
self.camera = Camera3D(target=self.player)
if G.HUD_ENABLED:
self.label = pyglet.text.Label(
'', font_name='Arial', font_size=8, x=10, y=self.window.height - 10,
anchor_x='left', anchor_y='top', color=(255, 255, 255, 255))
self.debug_text.write_escape("$$D")
pyglet.clock.schedule_interval_soft(self.world.process_queue,
1.0 / G.MAX_FPS)
pyglet.clock.schedule_interval_soft(self.world.hide_sectors, 10.0, self.player)
return True
from Magic import Spell
from Map import *
from Menu import Menu
from characters import Player
from inventory import *
def gen_spells(): # generates the spells from txt file and put them in list, to be used by player
filepath = 'spells.txt'
file = open(filepath, "r")
for line in file:
split = line.split(";")
spellss.append(Spell(split[0], split[1], split[2], int(split[3])))
player = Player()
map = Map() # the map for the game
mobkilled = 0
menu = Menu() # the menu
game_on = False
spellss = [] # contains all the spells
gen_spells()
inv = Inventory()
inv.god_inventory()
# player.inventory = inv #cheat, gives player all items in the game
# player.equiped[2] = inv.items[len(inv.items -1 )] # gives player the cheat item
for i in range(len(spellss)): # for now, the player starts with all the spellss
player.spells.append(spellss[i])
def get_player_data(ash, net, players, bikes, mushrooms):
'''get player data from server and map data to local player objects'''
attrs = net.send(ash.attributes()) #return attributes of other players
for i in range(len(players)):
'''ith player should map to ith attribute on server as players are
added in order which clients connect. If client DCs and reconnects, they are
issued the same player id'''
a = attrs[i]
#create new player instance if:
#1) we haven't already created an instance
#2) they have an ID (they are connected to server)
if not players[i] and a['ID'] != None:
print(f'{a["username"]} connected.')
players[i] = Player((a['x'], a['y']), a['ID'])
#update (in place) the ith player from server
elif players[i]:
players[i].x, players[i].y = a['x'], a['y']
players[i].left, players[i].right, players[i].up, players[
i].down = a['L'], a['R'], a['U'], a['D']
players[i].standing, players[i].walk_count = a['standing'], a[
'walk count']
players[i].hit_slow, players[i].bike, players[i].mushroom = a[
'hit slow'], a['bike'], a['mushroom']
players[i].inventory = a['inventory']
players[i].stats = a['stats']
players[i].killed = a['killed']
players[i].dead = a['dead']
players[i].ID = a['ID']
players[i].username = a['username']
players[i].map = a['map']
#change local map if the host has changed the map
if players[i].ID == 0 and players[i].map != ash.map:
ash.map = players[i].map
Map.load(net.maps[players[i].map])
WeaponStatus.set_locations(bikes, mushrooms)
def _create_player(name, curr_pos): """Generates a Player object for the user to move around """ return Player(name=name, curr_pos=curr_pos)
class GameController(Controller):
def __init__(self, window):
super(GameController, self).__init__(window)
self.sector, self.highlighted_block, self.crack, self.last_key = (None,) * 4
self.bg_red, self.bg_green, self.bg_blue = (0.0,) * 3
self.mouse_pressed, self.sorted = (False,) * 2
self.block_damage = 0
self.time_of_day = 6.0
self.back_to_main_menu = threading.Event()
def update(self, dt):
if self.back_to_main_menu.isSet():
self.switch_controller_class(MainMenuController)
return
self.update_sector(dt)
self.update_player(dt)
self.update_mouse(dt)
self.update_time(dt)
self.camera.update(dt)
def update_sector(self, dt):
sector = sectorize(self.player.position)
if sector != self.sector:
self.world.change_sectors(sector)
# When the world is loaded, show every visible sector.
if self.sector is None:
self.world.process_entire_queue()
self.sector = sector
def update_player(self, dt):
m = 8
df = min(dt, 0.2)
for _ in range(m):
self.player.update(df / m, self)
for ply in self.player_ids.values():
for _ in range(m):
ply.update(df / m, self)
momentum = self.player.get_motion_vector(15 if self.player.flying else 5*self.player.current_density)
if momentum != self.player.momentum_previous:
self.player.momentum_previous = momentum
self.packetreceiver.send_movement(momentum, self.player.position)
def update_mouse(self, dt):
if self.mouse_pressed:
vector = self.player.get_sight_vector()
block, previous = self.world.hit_test(self.player.position, vector,
self.player.attack_range)
self.set_highlighted_block(block)
if self.highlighted_block:
hit_block = self.world[self.highlighted_block]
if hit_block.hardness >= 0:
self.update_block_damage(dt, hit_block)
self.update_block_remove(dt, hit_block)
def update_block_damage(self, dt, hit_block):
multiplier = 1
current_item = self.item_list.get_current_block()
if current_item is not None:
if isinstance(current_item, Tool): # tool
if current_item.tool_type == hit_block.digging_tool:
multiplier = current_item.multiplier
self.block_damage += self.player.attack_power * dt * multiplier
def update_block_remove(self, dt, hit_block):
if self.block_damage >= hit_block.hardness:
self.world.remove_block(self.player,
self.highlighted_block)
self.set_highlighted_block(None)
if getattr(self.item_list.get_current_block_item(), 'durability', -1) != -1:
self.item_list.get_current_block_item().durability -= 1
if self.item_list.get_current_block_item().durability <= 0:
self.item_list.remove_current_block()
self.item_list.update_items()
if hit_block.drop_id is None:
return
if type(hit_block.drop_id) == list:
for index, item in enumerate(hit_block.drop_id):
if not self.player.add_item(item, quantity=hit_block.drop_quantity[index]):
return
elif not self.player.add_item(hit_block.drop_id, quantity=hit_block.drop_quantity):
return
self.item_list.update_items()
self.inventory_list.update_items()
def init_gl(self):
glEnable(GL_ALPHA_TEST)
glAlphaFunc(GL_GREATER, 0.1)
glEnable(GL_COLOR_MATERIAL)
glEnable(GL_BLEND)
glEnable(GL_LINE_SMOOTH)
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
glEnable(GL_POLYGON_SMOOTH)
glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST)
# glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, GL_FALSE)
# glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, GL_FALSE)
# glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE)
# glClearColor(0, 0, 0, 0)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def setup(self):
if G.SINGLEPLAYER:
try:
# TODO: create world menu
G.SAVE_FILENAME = "world"
start_server(internal=True)
sock = socket.socket()
time.sleep(2)
sock.connect(("localhost", 1486))
except socket.error as e:
#Otherwise back to the main menu we go
return False
except Exception as e:
import traceback
traceback.print_exc()
return False
else:
try:
#Make sure the address they want to connect to works
ipport = G.IP_ADDRESS.split(":")
if len(ipport) == 1: ipport.append(1486)
sock = socket.socket()
sock.connect((tuple(ipport)))
except socket.error as e:
#Otherwise back to the main menu we go
return False
self.init_gl()
self.debug_text = TextWidget(self.window, 'Loading information...',
0, self.window.height - 300,
500, 300,
visible=True, multi_line=True, readonly=True,
font_name='Arial', font_size=8,
text_color=(255, 255, 255, 255),
background_color=(0, 0, 0, 0))
self.debug_text.write_escape("$$r")
sky_rotation = -20.0 # -20.0
# TERRAIN_CHOICE = self.biome_generator.get_biome_type(sector[0], sector[2])
default_skybox = 'skydome.jpg'
# if TERRAIN_CHOICE == G.NETHER:
# default_skybox = 'skydome_nether.jpg'
# else:
# default_skybox = 'skybox.jpg'
self.skydome = Skydome(
'resources/' + default_skybox,
#'resources/skydome.jpg',
0.7,
100.0,
sky_rotation,
)
self.player_ids = {} # Dict of all players this session, indexes are their ID's [0: first Player on server,]
self.focus_block = Block(width=1.05, height=1.05)
self.earth = vec(0.8, 0.8, 0.8, 1.0)
self.white = vec(1.0, 1.0, 1.0, 1.0)
self.polished = GLfloat(100.0)
self.crack_batch = pyglet.graphics.Batch()
# if G.DISABLE_SAVE and world_exists(G.game_dir, G.SAVE_FILENAME):
# open_world(self, G.game_dir, G.SAVE_FILENAME)
self.world = World()
self.packetreceiver = PacketReceiver(self.world, self, sock)
self.world.packetreceiver = self.packetreceiver
G.CLIENT = self.packetreceiver
self.packetreceiver.start()
#Get our position from the server
self.packetreceiver.request_spawnpos()
#Since we don't know it yet, lets disable self.update, or we'll load the wrong chunks and fall
self.update_disabled = self.update
self.update = lambda dt: None
#We'll re-enable it when the server tells us where we should be
self.player = Player(game_mode=G.GAME_MODE)
self.item_list = ItemSelector(self, self.player, self.world)
self.inventory_list = InventorySelector(self, self.player, self.world)
self.item_list.on_resize(self.window.width, self.window.height)
self.inventory_list.on_resize(self.window.width, self.window.height)
self.text_input = TextWidget(self.window, '',
0, 0,
self.window.width,
visible=False,
font_name=G.CHAT_FONT)
self.text_input.push_handlers(on_toggled=self.on_text_input_toggled, key_released=self.text_input_callback)
self.chat_box = TextWidget(self.window, '',
0, self.text_input.y + self.text_input.height + 50,
self.window.width // 2, height=min(300, self.window.height // 3),
visible=False, multi_line=True, readonly=True,
font_name=G.CHAT_FONT,
text_color=(255, 255, 255, 255),
background_color=(0, 0, 0, 100),
enable_escape=True)
self.camera = Camera3D(target=self.player)
if G.HUD_ENABLED:
self.label = pyglet.text.Label(
'', font_name='Arial', font_size=8, x=10, y=self.window.height - 10,
anchor_x='left', anchor_y='top', color=(255, 255, 255, 255))
self.debug_text.write_escape("$$D")
pyglet.clock.schedule_interval_soft(self.world.process_queue,
1.0 / G.MAX_FPS)
pyglet.clock.schedule_interval_soft(self.world.hide_sectors, 10.0, self.player)
return True
def update_time(self, dt: float):
self.time_of_day += dt * 24.0 / G.TIME_RATE
if self.time_of_day > 24.0:
self.time_of_day = 0.0
# Calculate sky colour according to time of day.
sin_t = sin(pi * (((self.time_of_day / 12.0) + 1) % 2 - 1))
self.bg_red = 0.1 * (1.0 - sin_t)
self.bg_green = 0.9 * sin_t
self.bg_blue = min(sin_t + 0.4, 0.8)
self.skydome.update_time_of_day(self.time_of_day)
def set_highlighted_block(self, block):
if self.highlighted_block == block:
return
self.highlighted_block = block
self.block_damage = 0
if self.crack:
self.crack.delete()
self.crack = None
def on_mouse_press(self, x, y, button, modifiers):
if self.window.exclusive:
vector = self.player.get_sight_vector()
block, previous = self.world.hit_test(self.player.position, vector, self.player.attack_range)
if button == pyglet.window.mouse.LEFT:
self.on_mouse_press_left(block, x, y, button, modifiers)
else:
self.on_mouse_press_right(block, previous, x, y, button, modifiers)
else:
self.window.set_exclusive_mouse(True)
def on_mouse_press_left(self, block, x, y, button, modifiers):
if block:
self.mouse_pressed = True
self.set_highlighted_block(None)
def on_mouse_press_right(self, block, previous, x, y, button, modifiers):
if previous:
hit_block = self.world[block]
if hit_block.id == craft_block.id:
self.inventory_list.switch_mode(1)
self.inventory_list.toggle(False)
elif hit_block.id == furnace_block.id:
self.inventory_list.switch_mode(2)
self.inventory_list.set_furnace(hit_block)
self.inventory_list.toggle(False)
elif hit_block.density >= 1:
self.place_block(previous)
elif self.item_list.get_current_block() and getattr(self.item_list.get_current_block(), 'regenerated_health', 0) != 0 and self.player.health < self.player.max_health:
self.eat_food()
def place_block(self, previous):
current_block = self.item_list.get_current_block()
if current_block is not None:
if current_block.id.is_item():
if current_block.on_right_click(self.world, self.player):
self.item_list.get_current_block_item().change_amount(-1)
self.item_list.update_health()
self.item_list.update_items()
else:
localx, localy, localz = map(operator.sub,previous,normalize(self.player.position))
if localx != 0 or localz != 0 or (localy != 0 and localy != -1):
self.world.add_block(previous, current_block)
self.item_list.remove_current_block()
def eat_food(self):
self.player.change_health(self.item_list.get_current_block().regenerated_health)
self.item_list.get_current_block_item().change_amount(-1)
self.item_list.update_health()
self.item_list.update_items()
def on_mouse_release(self, x, y, button, modifiers):
if self.window.exclusive:
self.set_highlighted_block(None)
self.mouse_pressed = False
def on_mouse_motion(self, x, y, dx, dy):
if self.window.exclusive:
m = 0.15
x, y = self.player.rotation
x, y = x + dx * m, y + dy * m
y = max(-90, min(90, y))
self.player.rotation = (x, y)
self.camera.rotate(x, y)
def on_mouse_drag(self, x, y, dx, dy, button, modifiers):
if button == pyglet.window.mouse.LEFT:
self.on_mouse_motion(x, y, dx, dy)
def on_key_press(self, symbol, modifiers):
if symbol == G.TOGGLE_HUD_KEY:
G.HUD_ENABLED = not G.HUD_ENABLED
if symbol == G.TOGGLE_DEBUG_TEXT_KEY:
self.debug_text.visible = not self.debug_text.visible
self.debug_text.delete()
elif symbol == G.INVENTORY_SORT_KEY:
if self.last_key == symbol and not self.sorted:
self.player.quick_slots.sort()
self.player.inventory.sort()
self.sorted = True
else:
self.player.quick_slots.change_sort_mode()
self.player.inventory.change_sort_mode()
self.item_list.update_items()
self.inventory_list.update_items()
elif symbol == G.INVENTORY_KEY:
self.set_highlighted_block(None)
self.mouse_pressed = False
self.inventory_list.toggle()
elif symbol == G.SOUND_UP_KEY:
G.EFFECT_VOLUME = min(G.EFFECT_VOLUME + .1, 1)
elif symbol == G.SOUND_DOWN_KEY:
G.EFFECT_VOLUME = max(G.EFFECT_VOLUME - .1, 0)
elif symbol == G.SCREENCAP_KEY: # dedicated screencap key
now = datetime.datetime.now()
dt = datetime.datetime(now.year, now.month, now.day, now.hour, now.minute, now.second)
st = dt.strftime('%Y-%m-%d_%H.%M.%S')
filename = str(st) + '.png'
if not os.path.exists('screencaptures'):
os.makedirs('screencaptures')
path = 'screencaptures/' + filename
pyglet.image.get_buffer_manager().get_color_buffer().save(path)
elif symbol == G.SHOWMAP_KEY:
self.show_map()
elif symbol == G.QUIT_KEY:
self.back_to_main_menu.set()
savingsystem.save_quit_world(G.SERVER)
self.window.set_exclusive_mouse(False)
self.last_key = symbol
def on_key_release(self, symbol, modifiers):
if symbol == G.TALK_KEY:
self.toggle_text_input()
return pyglet.event.EVENT_HANDLED
def on_resize(self, width, height):
if G.HUD_ENABLED:
self.label.y = height - 10
self.text_input.resize(x=0, y=0, width=self.window.width)
self.chat_box.resize(x=0, y=self.text_input.y + self.text_input.height + 50,
width=self.window.width // 2, height=min(300, self.window.height // 3))
self.debug_text.resize(0, self.window.height - 300,
500, 300)
def set_3d(self):
width, height = self.window.get_size()
glEnable(GL_DEPTH_TEST)
glViewport(0, 0, width, height)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(G.FOV, width / float(height),
G.NEAR_CLIP_DISTANCE,
G.FAR_CLIP_DISTANCE)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
glPushMatrix()
self.camera.look()
self.skydome.draw()
glPopMatrix()
self.camera.transform()
def clear(self):
glClearColor(self.bg_red, self.bg_green, self.bg_blue, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
def on_draw(self):
self.clear()
#self.window.clear()
self.set_3d()
self.world.batch.draw()
self.world.transparency_batch.draw()
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
self.crack_batch.draw()
glDisable(GL_BLEND)
self.draw_focused_block()
for ply in self.player_ids.values():
ply.model.draw()
self.set_2d()
if G.HUD_ENABLED:
self.item_list.draw()
self.inventory_list.draw()
self.update_label()
self.debug_text.draw()
self.text_input.draw()
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
self.chat_box.draw()
glDisable(GL_BLEND)
def show_cracks(self, hit_block, vertex_data):
if self.block_damage: # also show the cracks
crack_level = int(CRACK_LEVELS * self.block_damage
// hit_block.hardness) # range: [0, CRACK_LEVELS]
if crack_level >= CRACK_LEVELS:
return
texture_data = crack_textures.texture_data[crack_level]
count = len(texture_data) // 2
if self.crack:
self.crack.delete()
self.crack = self.crack_batch.add(count, GL_QUADS, crack_textures.group,
('v3f/static', vertex_data),
('t2f/static', texture_data))
def draw_focused_block(self):
glDisable(GL_LIGHTING)
vector = self.player.get_sight_vector()
position = self.world.hit_test(self.player.position, vector, self.player.attack_range)[0]
if position:
hit_block = self.world[position]
if hit_block.density >= 1:
self.focus_block.width = hit_block.width * 1.05
self.focus_block.height = hit_block.height * 1.05
vertex_data = self.focus_block.get_vertices(*position)
if hit_block.hardness > 0.0:
self.show_cracks(hit_block, vertex_data)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glColor4f(0.0, 0.0, 0.0, 0.4)
glLineWidth(2.0)
glDisable(GL_TEXTURE_2D)
glDepthMask(False)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
pyglet.graphics.draw(24, GL_QUADS, ('v3f/static', vertex_data))
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
glDepthMask(True)
glEnable(GL_TEXTURE_2D)
glDisable(GL_BLEND)
def update_label(self):
x, y, z = self.player.position
self.debug_text.clear()
self.debug_text.write_line(' '.join((G.APP_NAME, str(G.APP_VERSION))))
self.debug_text.write_line('FPS:%02d Blocks Shown: %d / %d sector_packets:%d' \
% (pyglet.clock.get_fps(),len(self.world._shown),len(self.world),
len(self.world.sector_packets)))
self.debug_text.write_line('x: %.2f, chunk: %d' %(x, x // G.SECTOR_SIZE))
self.debug_text.write_line('y: %.2f, chunk: %d' %(y, y // G.SECTOR_SIZE))
self.debug_text.write_line('z: %.2f, chunk: %d' %(z, z // G.SECTOR_SIZE))
dirs = ['East', 'South', 'West', 'North']
vec, direction, angle = self.player.get_sight_direction()
dx, dy, dz = vec
self.debug_text.write_line('Direction: (%.2f, %.2f, %.2f) %d(%s) %.2f' % (dx, dy, dz, direction, dirs[direction], angle))
def write_line(self, text, **kwargs):
self.chat_box.write_line(text, **kwargs)
def text_input_callback(self, symbol, modifier):
if symbol == G.VALIDATE_KEY:
txt = self.text_input.text.replace('\n', '')
self.text_input.clear()
if txt:
self.world.packetreceiver.send_chat(txt)
return pyglet.event.EVENT_HANDLED
def hide_chat_box(self, dt):
self.chat_box.toggle(False)
def on_text_input_toggled(self):
pyglet.clock.unschedule(self.hide_chat_box) # Disable the fade timer
self.chat_box.toggle(state=self.text_input.visible) # Pass through the state incase chat_box was already visible
if self.chat_box.visible:
self.chat_box.focused = True # Allow scrolling
self.window.push_handlers(self.chat_box)
else:
self.chat_box.focused = False
self.window.remove_handlers(self.chat_box)
def toggle_text_input(self):
self.text_input.toggle()
if self.text_input.visible:
self.player.velocity = 0
self.player.strafe = [0, 0]
self.window.push_handlers(self.text_input)
self.text_input.focus()
else:
self.window.remove_handlers(self.text_input)
def push_handlers(self):
if self.setup():
self.window.push_handlers(self.camera)
self.window.push_handlers(self.player)
self.window.push_handlers(self)
self.window.push_handlers(self.item_list)
self.window.push_handlers(self.inventory_list)
else:
self.switch_controller_class(MainMenuController)
def pop_handlers(self):
while self.window._event_stack:
self.window.pop_handlers()
def on_close(self):
G.save_config()
self.world.packetreceiver.stop() # Disconnect from the server so the process can close
def show_map(self):
# taken from Nebual's biome_explorer, this is ment to be a full screen map that uses mini tiles to make a full 2d map.
with open(os.path.join(G.game_dir, "world", "seed"), "r") as f:
SEED = f.read()
b = BiomeGenerator(SEED)
x, y, z = self.player.position
curx = x
cury = y
xsize = 79
ysize = 28
pbatch = pyglet.graphics.Batch()
pgroup = pyglet.graphics.OrderedGroup(1)
DESERT, PLAINS, MOUNTAINS, SNOW, FOREST = list(range(5))
letters = ["D","P","M","S","F"]
# temp background pic...
image = load_image('resources', 'textures', 'main_menu_background.png')
#map_frame = image_sprite(image, pbatch, 0, y=G.WINDOW_WIDTH, height=G.WINDOW_HEIGHT)
#sprite = pyglet.sprite.Sprite(image)
#sprite.image(image)
#sprite.visible = True
# map_frame.draw()
# map_frame.visible = True
for y in range(int(cury),int(cury+ysize)):
for x in range(int(curx),int(curx+xsize)):
#string += letters[b.get_biome_type(x,y)]
tmap = letters[b.get_biome_type(x,y)]
tile_map = load_image('resources', 'textures', tmap +'.png')
tile_map.anchor_x = x * 8
tile_map.anchor_y = y * 8
sprite = pyglet.sprite.Sprite(tile_map, x=x * 8, y=y * 8, batch=pbatch)
game_map = image_sprite(tile_map, pbatch, pgroup, x * 8, y * 8, 8, 8)
game_map = pyglet.sprite.Sprite(image,x=G.WINDOW_WIDTH, y=G.WINDOW_HEIGHT,batch=pbatch, group=pgroup)
game_map = pyglet.sprite.Sprite(tile_map,x=x*8, y=y*8,batch=pbatch, group=pgroup)
tile_map.blit(x *8, y * 8)
#tile_map.draw()
#map.append(tmap)
game_map.draw()
pbatch.draw()
# initialize pygame
pygame.init()
# initialize game window
screen = pygame.display.set_mode(size=(PAGE_WIDTH, PAGE_HEIGHT))
# set caption of game window
pygame.display.set_caption('Space Invaders')
# load icon for game
icon = pygame.image.load('./images/ufo.png')
# set icon for the game
pygame.display.set_icon(icon)
# player -
p1 = Player(x=PLAYER_X,
y=PLAYER_Y,
screen=screen,
image_path="./images/space-invaders.png")
# list of enemies -
enemies = list()
# make 2 rows
for j in range(2):
# of 10 enemies each
for i in range(10):
enemy = Enemy(x=((PAGE_WIDTH - 2 * PAGE_BORDER) // 11) * (i + 1),
y=ENEMY_Y + j * ENEMY_START_HEIGHT,
screen=screen,
image_path="./images/spaceship.png",
respawn_status=False)
enemies.append(enemy)
def dequeue_packet(self):
with self.lock:
packetid, packet = self.world.sector_packets.popleft()
if packetid == 1: # Entire Sector
blocks, sectors = self.world, self.world.sectors
secpos = struct.unpack("iii", packet[:12])
sector = sectors[secpos]
cx, cy, cz = sector_to_blockpos(secpos)
fpos = 12
exposed_pos = fpos + 1024
for x in range(cx, cx+8):
for y in range(cy, cy+8):
for z in range(cz, cz+8):
read = packet[fpos:fpos+2]
fpos += 2
unpacked = structuchar2.unpack(read)
if read != null2 and unpacked in BLOCKS_DIR:
position = x,y,z
try:
blocks[position] = BLOCKS_DIR[unpacked]
if blocks[position].sub_id_as_metadata:
blocks[position] = type(BLOCKS_DIR[unpacked])()
blocks[position].set_metadata(0)
except KeyError:
main_blk = BLOCKS_DIR[(unpacked[0], 0)]
if main_blk.sub_id_as_metadata: # sub id is metadata
blocks[position] = type(main_blk)()
blocks[position].set_metadata(unpacked[-1])
sector.append(position)
if packet[exposed_pos:exposed_pos+1] == b"1":
blocks.show_block(position)
exposed_pos += 1
if secpos in self.world.sector_queue:
del self.world.sector_queue[secpos] #Delete any hide sector orders
elif packetid == 2: # Blank Sector
self.world.sectors[struct.unpack("iii", packet)] = []
elif packetid == 3: # Add Block
self.world._add_block(struct.unpack("iii", packet[:12]),
BLOCKS_DIR[struct.unpack("BB", packet[12:])])
elif packetid == 4: # Remove Block
self.world._remove_block(struct.unpack("iii", packet))
elif packetid == 5: # Chat Print
self.controller.write_line(packet[:-4].decode('utf-8'), color=struct.unpack("BBBB", packet[-4:]))
if not self.controller.text_input.visible:
self.controller.chat_box.visible = True
pyglet.clock.unschedule(self.controller.hide_chat_box)
pyglet.clock.schedule_once(self.controller.hide_chat_box, G.CHAT_FADE_TIME)
elif packetid == 6: # Inventory
player = self.controller.player
caret = 0
for inventory in (player.quick_slots.slots, player.inventory.slots, player.armor.slots):
for i in range(len(inventory)):
id_main, id_sub, amount = struct.unpack("HBB", packet[caret:caret+4])
caret += 4
if id_main == 0: continue
durability = -1
if id_main >= G.ITEM_ID_MIN and (id_main, id_sub) not in G.ITEMS_DIR:
#The subid must be durability
durability = id_sub * G.ITEMS_DIR[(id_main, 0)].durability // 255
id_sub = 0
inventory[i] = ItemStack(type=BlockID(id_main, id_sub), amount=amount, durability=durability)
self.controller.item_list.update_items()
self.controller.inventory_list.update_items()
elif packetid == 7: # New player connected
plyid, name = struct.unpack("H", packet[:2])[0], packet[2:].decode('utf-8')
if plyid not in self.controller.player_ids:
self.controller.player_ids[plyid] = Player(username=name, local_player=False)
elif name == '\0':
del self.controller.player_ids[plyid]
elif packetid == 8: # Player Movement
ply = self.controller.player_ids[struct.unpack("H", packet[:2])[0]]
ply.momentum = struct.unpack("fff", packet[2:14])
ply.position = struct.unpack("ddd", packet[14:])
elif packetid == 9: # Player Jump
self.controller.player_ids[struct.unpack("H", packet)[0]].dy = 0.016
elif packetid == 10: # Update Tile Entity
try:
self.world[struct.unpack("iii", packet[:12])].update_tile_entity(packet[12:])
except Exception as e:
warn(str(e))
elif packetid == 255: # Spawn Position
self.controller.player.position = struct.unpack("iii", packet[:12])
packet = packet[12:]
packet, seed = extract_string_packet(packet)
self.world.biome_generator = BiomeGenerator(seed)
#Now that we know where the player should be, we can enable .update again
self.controller.update = self.controller.update_disabled
else:
warn("Received unknown packetid %s, there's probably a version mismatch between client and server!" % packetid)
def main():
pygame.init()
pygame.running = True
running = True
routes = None
# window for drawing on
window_width = config.window_width
window_height = config.window_height
grid_spacing = config.grid_spacing
win = pygame.display.set_mode(
(window_width, window_height)) #width and height of window
pygame.display.set_caption("Pokémon Crisis")
bg = pygame.image.load('sprites/background.jpg').convert()
oak = pygame.image.load('sprites/oak.png')
new_map = Map()
#use all objects, set specific number of grass tree and water objects
new_map.generate_map(grass=20, trees=20, water=2)
clock = pygame.time.Clock()
ash = Player(choice(tuple(new_map.nodes)))
font = pygame.font.SysFont('verdana', 10, False, True)
path = Pathfinding(new_map.nodes, new_map.movement_cost_area)
def redraw_gamewindow():
win.blit(bg, (0, 0)) #put picutre on screen (background)
pygame.draw.rect(win, (200, 200, 200),
(0, 0, window_width, window_height))
# # draw grid
# for x in range(0,window_width,grid_spacing): #col
# for y in range(0,window_height,grid_spacing): #row
# pygame.draw.rect(win, (125,125,125), (x,y,grid_spacing,grid_spacing),1)
Map.draw(win)
if routes:
# draw bfs route
for x, y in routes['BFS']:
pygame.draw.rect(win, (0, 0, 255),
(x, y, grid_spacing, grid_spacing))
#draw dfs route
for x, y in routes['DFS']:
pygame.draw.rect(win, (0, 0, 100),
(x, y, grid_spacing, grid_spacing))
# draw dijkstra route
for x, y in routes['GBFS']:
pygame.draw.rect(win, (255, 0, 0),
(x, y, grid_spacing, grid_spacing))
#draw DA route
for x, y in routes['DA']:
pygame.draw.rect(win, (0, 255, 0),
(x, y, grid_spacing, grid_spacing))
# draw A* route
for x, y in routes['A*']:
pygame.draw.rect(win, (100, 100, 100),
(x, y, grid_spacing, grid_spacing))
# re-position oak if oob
oak_x = target_x
oak_y = target_y
if oak_x > window_width - oak.get_width(): oak_x -= grid_spacing
elif oak_y > window_height - oak.get_height():
oak_y -= grid_spacing
win.blit(oak, (oak_x, oak_y))
ash.draw(win)
pygame.display.update()
#main event loop
while running:
clock.tick(9) #9 FPS
for event in pygame.event.get(
): #get mouse positions, keyboard clicks etc
if event.type == pygame.QUIT: #we pressed the exit button
running = False
if event.type == pygame.MOUSEBUTTONDOWN:
target_x, target_y = event.pos[0], event.pos[1]
routes = path.compute_all_paths(ash.x, ash.y, target_x,
target_y)
#move amongst available nodes
#(no movement out of bounds and in object coordinates)
#movement cost in grass / water
ash.move(new_map.objs_area, new_map.movement_cost_area)
redraw_gamewindow()
pygame.quit()
class Game:
def __init__(self, screen):
self.screen = screen
self.objects = []
self.game_messages = []
self.game_state = Game_States.none
self.map = []
self.characters = []
self.text_background = pygame.Surface((config.screen_width, 180))
self.scene_surface = pygame.Surface((config.screen_width, config.screen_height))
self.message_count = 0
self.grid_index_X = int(config.screen_width / config.scale) - 1
self.grid_index_Y = int(config.screen_height / config.scale)
self.main_map = pygame.Surface((config.screen_width, config.screen_height))
self.game_map = [[Map_Tile(True, False) for y in range(0, config.screen_height)] for x in
range(0, config.screen_width)]
for x in range(5, 12):
for y in range(5, 7):
self.game_map[x][y].movement = False
self.game_map[x][y].movement = False
self.player = Player(self.screen, self.game_map) # initialise player
# initialise first tester npc
self.tester_npc = CharacterController("NPC1", 7, 8, self.screen, config.NPC01IDLE, self.game_map,
config.NPC01LEFT, config.NPC01RIGHT, config.NPC01BACK,
config.NPC01FRONT, config.NPC01IDLE)
self.message1 = self.tester_npc.text_to_speak(self.screen, "Hi there! How are you doing?",
config.game_messages,
(1 * config.scale, 9 * config.scale),
config.black)
self.message2 = self.tester_npc.text_to_speak(self.screen, "I like you very much!", config.game_messages,
(1 * config.scale, 9 * config.scale),
config.black)
self.my_creatures = [creature.charmander]
# initialise the route creatures
self.route1 = [creature.bulbasaur, creature.squirtle, creature.charmander]
# TODO: find out a better way to do this
# sets the tree objects
# self.tester_npc2 = CharacterController("NPC2", 3, 3, self.screen, config.NPC02, self.game_map)
self.treesXb = [Obstacles(config.tree01, x, 11, self.player.group)
for x in range(self.grid_index_X)]
self.treesXt = [Obstacles(config.tree01, x, 0, self.player.group)
for x in range(self.grid_index_X)]
self.treesYl = [Obstacles(config.tree01, 0, y, self.player.group)
for y in range(self.grid_index_Y)]
self.treesYr = [Obstacles(config.tree01, self.grid_index_X, y, self.player.group)
for y in range(self.grid_index_Y)]
self.tall_grass = [[Non_Obstacle_Tiles(config.tallgrass01, x, y, self.player)
for x in range(9, self.grid_index_X)] for y in range(1, 4)]
self.trees = [self.treesXb, self.treesXt, self.treesYl, self.treesYr]
# adds the tree border to the game
for x in range(self.grid_index_X):
self.game_map[x][self.grid_index_Y - 1].blocked = True
self.game_map[x][0].blocked = True
for y in range(self.grid_index_Y):
self.game_map[0][y].blocked = True
self.game_map[self.grid_index_X][y].blocked = True
# scene mechanics
self.scene = Scene(self.scene_surface)
self.scene.set_background(config.battle_background, self.scene_surface)
def set_up(self):
print("setting up")
self.game_state = Game_States.running
# self.objects.append(self.tester_npc)
# self.objects.append(self.tester_npc2)
self.characters.append(self.tester_npc)
# self.characters.append(self.tester_npc2)
# TODO: find out a better way to do this
for tree_list in self.trees:
for tree in tree_list:
self.objects.append(tree)
self.objects.append(self.player) # adds player to object list
for tallgrass in self.tall_grass:
for i in tallgrass:
self.objects.append(i)
self.render_map(self.game_map)
self.screen.blit(self.main_map, (0, 0))
pygame.display.flip() # update screen
def update(self, clock):
self.game_messages = [self.message1, self.message2]
fps_count = Text_Controller(self.screen, "FPS: " + str(int(clock.get_fps())),
config.fps_Counter, (5, 5), config.black)
self.screen.blit(self.main_map, (0, 0))
self.render_blocked_tiles(self.game_map)
self.manage_events()
self.manage_ais()
for obj in self.objects: # draws all objects into the screen
obj.image.convert()
obj.draw(self.screen)
fps_count.draw_text()
self.player.rect.topleft = self.player.rect.x, self.player.rect.y # updates player's rect
self.tester_npc.rect.topleft = self.tester_npc.rect.x, self.tester_npc.rect.y
for grass in self.tall_grass:
for i in grass:
i.check_collide(self)
for character in self.characters:
self.player.check_collision(character.group)
character.check_collision(self.player, self) # the one that identifies it
pygame.display.flip()
def manage_ais(self):
self.tester_npc.ai_left_right()
self.tester_npc.play_animation()
# self.tester_npc2.ai_up_down()
def manage_events(self):
rdm_pos = self.random_grass()
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.game_state = Game_States.quit
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.game_state = Game_States.quit
elif event.key == pygame.K_a: # left
self.player.update_position(0, -1)
self.player.left = True
self.player.right = False
self.player.front = False
self.player.back = False
elif event.key == pygame.K_d: # right
self.player.update_position(0, 1)
self.player.left = False
self.player.right = True
self.player.front = False
self.player.back = False
elif event.key == pygame.K_w: # up
self.player.update_position(-1, 0)
self.player.front = False
self.player.back = True
self.player.left = False
self.player.right = False
elif event.key == pygame.K_s: # down
self.player.update_position(1, 0)
self.player.front = True
self.player.back = False
self.player.left = False
self.player.right = False
elif self.player.position == rdm_pos:
print(rdm_pos)
print("yes")
else:
self.player.left = False
self.player.right = False
self.player.back = False
self.player.front = False
self.player.walk_count = 0
if event.key == pygame.K_p: # pause
self.pause_game()
if event.key == pygame.K_o:
pass
def render_map(self, drawn_map):
for x in range(0, config.screen_width):
for y in range(0, config.screen_height):
if drawn_map[x][y].movement:
self.main_map.blit(config.grass01, (x * config.scale, y * config.scale))
def render_blocked_tiles(self, drawn_map):
for x in range(0, config.screen_width):
for y in range(0, config.screen_height):
if not drawn_map[x][y].movement:
self.screen.blit(config.water01, (x * config.scale, y * config.scale))
def pause_game(self):
self.game_state = Game_States.pause
self.screen.blit(self.scene_surface, (0, 0))
pygame.display.flip()
for event in pygame.event.get(): # pause sequence
if event.type == pygame.QUIT:
quit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_r:
self.game_state = Game_States.running
elif event.key == pygame.K_ESCAPE:
quit()
def play_scene(self):
self.game_state = Game_States.play_scene
self.screen.blit(self.scene_surface, (0, 0))
print("displaying scene")
pygame.display.flip()
def play_message(self):
count = 0
done = False
self.text_background.blit(config.text_background, (0, 0))
self.screen.blit(self.text_background, (0, 300))
self.game_messages[0].draw_text()
pygame.display.flip()
while not done:
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
quit()
elif event.key == pygame.K_SPACE:
count += 1
print(len(self.game_messages))
if count == len(self.game_messages):
self.game_state = Game_States.running
done = True
elif count < len(self.game_messages):
self.screen.blit(self.text_background, (0, 300))
self.game_messages[count].draw_text()
pygame.display.flip()
def random_grass(self):
random_list = []
for tallgrass in self.tall_grass:
for i in tallgrass:
position = i.get_position()
random_list.append((position))
return random_list[random.randint(0, len(random_list) - 1)]
@staticmethod
def button_mechanics(button, mouse):
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
if button.rect.x < mouse[0] < (
button.rect.x + button.rect[2]):
if button.rect.y < mouse[1] < (
button.rect.y + button.rect[3]):
# add what happens after fight button is clicked here
print("click")
ended = True
elif event.type == pygame.MOUSEMOTION:
if button.rect.x < mouse[0] < (
button.rect.x + button.rect[2]):
if button.rect.y < mouse[1] < (
button.rect.y + button.rect[3]):
# print("hover")
button.image = config.fight_button_H
button.draw()
else:
button.image = config.fight_button
button.draw()
def game_mechanics(self):
self.scene_surface.blit(config.battle_background, (0, 0))
self.play_scene()
self.name = "Where are we now"
# Position of Where are we now tile
super().__init__(x, y)
class Hooligan(MapTile):
"""Lake location containing easy difficutly fish"""
def __init__(self, x, y):
self.name = "Hooligan"
# Position of Hooligan tile
super().__init__(x, y)
class Residential(MapTile):
"""Lake containing trader to obtain items"""
def __init__(self, x, y):
self.name = "Residential"
# Position of Residential tile
super().__init__(x, y)
# The map
world_map = [[None, None, Ethereal(2, 0), None, None],
[None, None, None, None, None],
[Juliot(0, 2), None, None, None,
Kytersize(4, 2)], [None, None, None, None, None],
[None, Where(1, 4), None,
Hooligan(3, 4), None],
[None, None, Residential(2, 5), None, None],
[None, None, None, Player(3, 6), None]]
def __init__(self, screen):
self.screen = screen
self.objects = []
self.game_messages = []
self.game_state = Game_States.none
self.map = []
self.characters = []
self.text_background = pygame.Surface((config.screen_width, 180))
self.scene_surface = pygame.Surface((config.screen_width, config.screen_height))
self.message_count = 0
self.grid_index_X = int(config.screen_width / config.scale) - 1
self.grid_index_Y = int(config.screen_height / config.scale)
self.main_map = pygame.Surface((config.screen_width, config.screen_height))
self.game_map = [[Map_Tile(True, False) for y in range(0, config.screen_height)] for x in
range(0, config.screen_width)]
for x in range(5, 12):
for y in range(5, 7):
self.game_map[x][y].movement = False
self.game_map[x][y].movement = False
self.player = Player(self.screen, self.game_map) # initialise player
# initialise first tester npc
self.tester_npc = CharacterController("NPC1", 7, 8, self.screen, config.NPC01IDLE, self.game_map,
config.NPC01LEFT, config.NPC01RIGHT, config.NPC01BACK,
config.NPC01FRONT, config.NPC01IDLE)
self.message1 = self.tester_npc.text_to_speak(self.screen, "Hi there! How are you doing?",
config.game_messages,
(1 * config.scale, 9 * config.scale),
config.black)
self.message2 = self.tester_npc.text_to_speak(self.screen, "I like you very much!", config.game_messages,
(1 * config.scale, 9 * config.scale),
config.black)
self.my_creatures = [creature.charmander]
# initialise the route creatures
self.route1 = [creature.bulbasaur, creature.squirtle, creature.charmander]
# TODO: find out a better way to do this
# sets the tree objects
# self.tester_npc2 = CharacterController("NPC2", 3, 3, self.screen, config.NPC02, self.game_map)
self.treesXb = [Obstacles(config.tree01, x, 11, self.player.group)
for x in range(self.grid_index_X)]
self.treesXt = [Obstacles(config.tree01, x, 0, self.player.group)
for x in range(self.grid_index_X)]
self.treesYl = [Obstacles(config.tree01, 0, y, self.player.group)
for y in range(self.grid_index_Y)]
self.treesYr = [Obstacles(config.tree01, self.grid_index_X, y, self.player.group)
for y in range(self.grid_index_Y)]
self.tall_grass = [[Non_Obstacle_Tiles(config.tallgrass01, x, y, self.player)
for x in range(9, self.grid_index_X)] for y in range(1, 4)]
self.trees = [self.treesXb, self.treesXt, self.treesYl, self.treesYr]
# adds the tree border to the game
for x in range(self.grid_index_X):
self.game_map[x][self.grid_index_Y - 1].blocked = True
self.game_map[x][0].blocked = True
for y in range(self.grid_index_Y):
self.game_map[0][y].blocked = True
self.game_map[self.grid_index_X][y].blocked = True
# scene mechanics
self.scene = Scene(self.scene_surface)
self.scene.set_background(config.battle_background, self.scene_surface)
class StartGame:
'''main game class'''
def __init__(self, win, net, username):
self.menu = False
self.grid = False
self.win = win
self.net = net
#generate and save map
# new_map = Map()
# new_map.generate_map('random', False)
self.bg = pygame.image.load('sprites/background.jpg').convert()
#load first shuffled map from server
self.current_map = 0
Map.load(self.net.maps[self.current_map])
#create client player object and assign colour based on ID, username from input, map from server
self.ash = Player(
RandomNode(Map.nodes).node, self.net.playerID, username,
self.current_map)
#other player objects
p2, p3, p4, p5 = None, None, None, None
self.players = [p2, p3, p4, p5]
self.bikes = [Bike() for i in range(config.bikes)]
self.mushrooms = [Mushroom() for i in range(config.mushrooms)]
WeaponStatus.set_locations(self.bikes, self.mushrooms)
music = pygame.mixer.music.load(config.theme)
pygame.mixer.music.set_volume(0.5)
pygame.mixer.music.play(-1)
self.ash.ID = self.net.playerID
def redraw_gamewindow(self):
'''draw objects onto the screen: background, grid, players, weapons'''
self.win.blit(self.bg, (0, 0)) #put picutre on screen (background)
# draw grid
if self.grid:
for x in range(0, config.window_width, config.grid_spacing): #col
for y in range(0, config.window_height,
config.grid_spacing): #row
pygame.draw.rect(
self.win, (125, 125, 125),
(x, y, config.grid_spacing, config.grid_spacing), 1)
Map.draw(self.win)
for bike in self.bikes:
bike.draw(self.win)
for mushroom in self.mushrooms:
mushroom.draw(self.win)
self.ash.draw(self.win)
#draw all players
for p in self.players:
if p and p.ID != None:
p.draw(self.win)
#note that we are 20px behind (last position doesnt show... this is temp fix)
for bullet in p.inventory:
bullet_sprite = pygame.image.load(
'sprites/objects/pokeball.png').convert_alpha()
x, y, _dir, start_x, start_y = bullet
if _dir == 'L':
x += 20
elif _dir == 'R':
x -= 20
elif _dir == 'U':
y += 20
elif _dir == 'D':
y -= 20
self.win.blit(bullet_sprite, (x, y))
self.ash.check_trample(p)
#pressed z
if self.menu:
Menu(self.win, [self.ash.stats, self.ash.username],
[[p.stats, p.username] for p in self.players if p])
for bullet in self.ash.inventory:
self.ash.draw_bullet(self.win, bullet)
for p in self.players:
if p and p.ID != None:
self.ash.check_kill(bullet, p)
pygame.display.update()
def change_map(self):
'''host (ID=0) may change map i.e. go to next shuffled map from server or back to 0'''
if self.ash.map < len(self.net.maps) - 1:
self.ash.map += 1
else:
self.ash.map = 0
Map.load(self.net.maps[self.ash.map])
WeaponStatus.set_locations(self.bikes, self.mushrooms)
def check_keyboard_input(self, event):
'''check for Z,X,C'''
if event.type == pygame.KEYUP:
if event.key == pygame.K_SPACE:
self.ash.space_up = True
if event.key == pygame.K_z: #z for menu
self.menu = True if not self.menu else False
if event.key == pygame.K_x: #a for grid
self.grid = True if not self.grid else False
if event.key == pygame.K_c and self.ash.ID == 0: #host can press c to change map
self.change_map()
def fetch_data(self):
'''get data from server, player positions, stats, kill status etc'''
Multiplayer.get_player_data(self.ash, self.net, self.players,
self.bikes, self.mushrooms)
Multiplayer.check_death_status(self.ash, self.players)
def check_collisions_and_pickups(self):
WeaponStatus(self.ash)
self.ash.move(Map.objs_area, Map.movement_cost_area, self.bikes,
self.mushrooms)
from characters import Player
from obstacles import Stone
import os
import pygame
###Resources###
resources = "resources"
background_path = os.path.join(resources, "background.jpg")
###Backgrounds###
background = pygame.image.load(background_path)
###Characters###
#alucard_path = os.path.join(resources, "images.png")
#img = pygame.image.load(alucard_path)
img = pygame.Surface((32, 48))
img.fill((255, 0, 0))
alucard = Player(image=img, pos=(20, 200), walk=10, jump_height=10)
###Obstacles###
stones = []
for i in range(10):
s = Stone()
stones.append(s)
# CS 30
# Period 4
# Date : 12/9/2019
# Krutik Rana
# Program description : Players inventory and command to heal player
from characters import Player
# Creates and instance of player to be used
player = Player(None, None)
def inventory():
"""Commands to access the characters inventory"""
# While loop to continously play
while True:
# Print statement detailing how to go to the last menu
print('\ntype q to go back to previous menu')
# Aquiring user input for what they want to access of the inventory
user = input('action: ')
# Making the user input all lower case to match if and elif statements
user = user.lower()
# Checks to see if the user typed weapon
if user == 'backpack':
# Prints the current inventory of the player
player.print_inventory()
# Checks to see if user typed heal
elif user == 'heal':
# Bring up the heal menu
player.heal()
# Checks to see if user typed q
elif user == 'q':
class Game:
""" Class used to play the game. """
# We start Pygame
pygame.init()
pygame.font.init()
# We prepare the font of our caption to indicate how many items we picked
# up
myfont = pygame.font.SysFont(None, 40)
# We display the window
square_window = pygame.display.set_mode(WINDOW_DIMENSIONS)
# We make the labyrinth
labyrinth = Labyrinth(FLOOR_IMAGE, WALL_IMAGE, LEVEL_FILE)
labyrinth.initialize_labyrinth(square_window)
# We initialize McGyver and the gatekeeper
mac = Player(PLAYER_PIC, labyrinth.PLAYER_COORDINATES)
gatekeeper = Boss(BOSS_PIC, labyrinth.BOSS_COORDINATES)
# We initialize the three components of the serynge
needle = Items(NEEDLE_PIC, labyrinth)
tube = Items(TUBE_PIC, labyrinth)
ether = Items(ETHER_PIC, labyrinth)
# Displays Items
def display_items(self, item):
self.square_window.blit(item.image, item.coordinates)
# Display characters
def display_character(self, character):
self.square_window.blit(character.head, character.coordinates)
def main(self):
""" Function that runs the game """
is_running = True
# Loop of the game
while is_running:
# Displays the game
self.labyrinth.display_labyrinth(self.square_window)
self.display_character(self.mac)
self.display_character(self.gatekeeper)
for item in Items.LIST_OF_ITEMS:
self.display_items(item)
pygame.display.flip()
# What happens when we meet the gatekeeper
if self.mac.coordinates in self.labyrinth.FIGHT_POSITION:
if self.mac.count == 3:
self.mac.neutralize(
self.labyrinth,
self.gatekeeper,
self.labyrinth.EXIT_POSITION)
else:
self.gatekeeper.lose(self.mac, CARCASS)
self.square_window.blit(
self.mac.head, self.mac.coordinates)
is_running = False
# Reaching the exit position
if self.mac.coordinates == self.labyrinth.EXIT_POSITION:
self.mac.victorious = True
is_running = False
# Events detection
for event in pygame.event.get():
if event.type == QUIT:
is_running = False
if event.type == KEYDOWN:
x, y = self.mac.move(event)
# Square where we can walk, or with a serynge component, or
# wall so we can't use it
if (x, y) in [
item.coordinates for item in Items.LIST_OF_ITEMS]:
self.mac.count += 1
Items.LIST_OF_ITEMS = [
item for item in Items.LIST_OF_ITEMS if item.coordinates != (
x, y)]
moving = True
print(self.mac.count)
else:
moving = False
if self.labyrinth.reachable((x / 40, y / 40)):
moving = True
# Moving means replace the position of Mac by en empty square
# Moving also means replacing an empty square by the
# position of Mac
if moving:
self.labyrinth.void.append(self.mac.coordinates)
self.mac.coordinates = (x, y)
txt = self.myfont.render(
str(self.mac.count) + "items picked up!", False, (255, 255, 255))
self.square_window.blit(txt, (0, 0))
pygame.display.flip()
# Outcome of the game
if self.mac.victorious:
path = VICTORY
else:
path = FAILURE
# Showing the outcome notification
notification = pygame.image.load(path).convert()
self.square_window.blit(notification, (100, 300))
pygame.display.flip()
# Waiting 1 seconds before closing the window
sleep(1)
def main(self):
""" Main Program """
pygame.init()
# Create the player
player = Player(SpriteSheet('catman.png'))
# Create all the levels
level_list = []
level_list.append(levels.Level_01(player))
level_list.append(levels.Level_02(player))
# Set the current level & player position
current_level_no = 0
current_level = level_list[current_level_no]
active_sprite_list = pygame.sprite.Group()
player.level = current_level
player.rect.x = 340
player.rect.y = constants.SCREEN_HEIGHT - player.rect.height - 500
active_sprite_list.add(player)
# Loop until the user clicks the close button.
done = False
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
start_ticks = pygame.time.get_ticks() #starter tick
# -------- Main Program Loop -----------
while not done:
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
elif event.type == None:
player.idle()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_a or event.key == pygame.K_LEFT:
player.go_left()
elif event.key == pygame.K_d or event.key == pygame.K_RIGHT:
player.go_right()
elif event.key == pygame.K_w or event.key == pygame.K_UP:
player.jump()
elif event.key == pygame.K_SPACE:
if len(player.bullet_list) < 4:
# Fire a bullet if the user clicks the mouse button
bullet = Bullet(player)
# Set the bullet so it is where the player is
bullet.rect.x = player.rect.x + 10
bullet.rect.y = player.rect.y + 10
# Add the bullet to the lists
player.bullet_list.add(bullet)
# set what happens when player lets the key up
elif event.type == pygame.KEYUP:
if event.key == pygame.K_a or event.key == pygame.K_LEFT and player.change_x < 0:
player.stop()
elif event.key == pygame.K_d or event.key == pygame.K_RIGHT and player.change_x > 0:
player.stop()
# Update the player.
active_sprite_list.update()
player.bullet_list.update()
# Update items in the level
current_level.update()
ydiff = 0
diff = 0
# if the player gets near the top, shift the world up (ydiff)
if player.rect.top <= 20:
ydiff = player.rect.top - 20
player.rect.top = 20
current_level.shift_world_y(ydiff)
# if the player gets near the bottom, shift the world down (ydiff)
if player.rect.bottom >= 550:
ydiff = player.rect.bottom - 550
player.rect.bottom = 550
current_level.shift_world_y(ydiff)
# If the player gets near the right side, shift the world left (-x)
if player.rect.right >= 500:
diff = player.rect.right - 500
player.rect.right = 500
current_level.shift_world(-diff)
# If the player gets near the left side, shift the world right (+x)
if player.rect.left <= 120:
diff = 120 - player.rect.left
player.rect.left = 120
current_level.shift_world(diff)
# If the player gets to the end of the level, go to the next level
current_position = player.rect.x + current_level.world_shift
if current_position < current_level.level_limit:
player.rect.x = 150
if current_level_no < len(level_list) - 1:
current_level_no += 1
current_level = level_list[current_level_no]
player.level = current_level
player.stop()
# IF the player falls, game done
if player.rect.y + player.level.world_shift_y + 75 > constants.SCREEN_HEIGHT:
done = True
seconds = (pygame.time.get_ticks() -
start_ticks) / 1000 #calculate how many seconds
# ALL CODE TO DRAW SHOULD GO BELOW THIS COMMENT
current_level.draw(screen)
active_sprite_list.draw(screen)
player.bullet_list.draw(screen)
font = pygame.font.SysFont(None, 25)
showscore = font.render(f"Score: {player.score}", True,
constants.BLACK)
showclock = font.render(f"Time: {round(seconds,2)}", True,
constants.BLACK)
screen.blit(showscore, (10, 10))
screen.blit(showclock, (constants.SCREEN_WIDTH / 2, 10))
for crony in player.level.enemy_list:
crony.draw(screen)
for platform in player.level.platform_list:
try:
platform.draw(screen)
except:
pass
# ALL CODE TO DRAW SHOULD GO ABOVE THIS COMMENT
# Limit to 60 frames per second
clock.tick(60)
# Go ahead and update the screen with what we've drawn.
pygame.display.update()
print(player.rect.x - player.level.world_shift, player.rect.y)
# Be IDLE friendly. If you forget this line, the program will 'hang'
# on exit.
pygame.quit()
