Boxhead återskapas med Python med Tkinter

Boxhead återskapas i Python från BenR på Vimeo.

Det är en fantastiskt underhållande datorspel kallas Boxhead, där i huvudsak du och/eller en andra person slåss mot horder av attackerande Zombies och djävlar med olika vapen. För en dator science klass i år som jag tar, var slutprojektet att återskapa ett dataspel i Python med Tkinter. Boxhead tycktes vara det logiska valet och jag om att återskapa den. Jag hoppas du njuta av vad det har blivit hittills och jag hoppas att lägga till fler vapen, nivå med objekt och andra spelare i framtiden.

Från och med nu Boxhead kan bara kämpa med en pistol och gruvor, men det skulle vara bra att ha tillgång till hagelgevär och raketer.

Känn dig fri att kopiera koden och spela själv eller lägga till vapen. Tänk bara på att programmet och bilder måste hållas i samma mapp och bilderna är i undermappar. Boxhead bilderna finns till exempel i en separat mapp än Zombie bilder. Zombies gå i "zombies" sub-mappen devils i "devils", boxhead i "boxhead" och gruvan/blod/devil attack (gula området) i "spelet element".

Kontrollerna för rörelse är "WASD", paus "p", FN-paus "o", växla mellan vapen "i" och "u". Viktigast dock är "space" brand.

Om du vill spela spelet alla de bilder som behövs för att gå med koden finns här tillsammans med koden.

# Boxhead
# Av Ben Rothschild
# Boxhead - en kopia av det ursprungliga spelet i Python med Tkinter
# Senaste Redigera 14/12/2012

från Tkinter import *
importera slumpmässiga
Importera tid
importera matematik

Window_Height = 550 # Ställ fönstret höjd och bredd
Window_Width = 800

X_Window_Buffer = 40
Y_Window_Buffer = 40

duk = Canvas (highlightthickness = 0, höjd = Window_Height, bredd = Window_Width)
canvas.master.title("Boxhead")
canvas.Pack()
Main = canvas.create_rectangle (0,0, Window_Width, Window_Height, fylla = "#EBDCC7", belowThis = ingen) # skapa basfärgen liknar Boxhead spel
pic = PhotoImage (bredd = Window_Width, höjd = Window_Height)
canvas.create_image(0,0,image=pic,Anchor=NW)

Zombie_Dict_Made = False # Zombies och Boxhead skapats?
boxhead_made = False
Run_Game = sant
New_Level = False

B_move_length = 2 # några spel attribut som ändras och används för den första installationen. De flesta skulle vara bättre i en central spelet klass
Zombie_per_move = 5.
Devil_move = 1
riktning = 1
shot_duration =.01
Zombie_Buffer = 30
kill_zone = 15
Number_of_Zombies = 5
total_devil_attacks = 0
blood_marks = 0
number_of_mines = 0

Global pause_game # pausa spelet om "P" är pressade eller startar upp om ' o ' trycks
pause_game = False

Mines_Dict = {} # innehar alla gruvorna
Zombie_Dict = {} # där Zombies hålls - element tas bort som Boxhead skjuter dem
Devil_Dict = {} # samma som Zombie_Dict men för Devils
Dead_Zombie_List =]
Devil_Attack_Dict = {} # sfärernas som Devils kan attackera med

klass Edge_limits(object):
"" "Berättar gränser i x någon y riktning till objekt så att de inte kör bort av spelet skärmen" ""
def __init__(self):
Self.x_start = 2 * X_Window_Buffer - 20
Self.y_start = 3 * Y_Window_Buffer-35
Self.x_end = Window_Width - X_Window_Buffer - 20
Self.y_end = Window_Height - Y_Window_Buffer - 20

klass Buffer(object):
"" "Kanten buffertar för spelet" ""
def __init__ (self, x_start, y_start, x_end, y_end, fyllning):
canvas.create_rectangle (x_start, y_start, x_end, y_end, fylla = fyllning)

left_buffer = Buffer(0,0,(X_Window_Buffer),(Y_Window_Buffer+Window_Height), "Svarta") # skapa alla buffert bilder
right_buffer = Buffer((X_Window_Buffer+Window_Width),0,(Window_Width-(X_Window_Buffer)),((2*Y_Window_Buffer)+Window_Height), "Svarta")
top_buffer = Buffer(0,0,(Window_Width-X_Window_Buffer),Y_Window_Buffer,"Black")
bottom_buffer = Buffer(0,(Window_Height-Y_Window_Buffer),Window_Width,Window_Height,"Black")

klass Blood(object):
"" "Vad händer när du dödar något. Det skapar en blod fläck på koordinaterna för de dödade Zombie(s) / Devil(s)
De tas bort i början av varje ny nivå"" "
def __init__(self,x,y):
globala base_for_blood
Self.image = PhotoImage (fil = "images/game_elements/blood.gif")
Self.blood_spot = canvas.create_image (x, y, bild = self.image)
canvas.tag_lower(Self.blood_spot)
canvas.tag_lower(main)

klass MINE(object):
"" "Klassen gruvor. Titta där du kliver"" "
def __init__(self,x,y):
Self.Photo = PhotoImage (fil = "images/game_elements/mine.gif")
Self.image = canvas.create_image (x, y, bild = self.photo) # skapa en svart rektangel för gruvan bilden
canvas.tag_lower(Self.image)
canvas.tag_lower(main)
Self.Destroy = False
Self.x = x
Self.y = y
def explode(self):
"" "Avgöra om en Zombie eller djävulen är tillräckligt nära för att ställa in i gruvan. Om det är sant då testar det
att se om någon Zombie eller djävulen i det större omgivande området ska dödas"" "
destroy_zombie =]
destroy_devil =]
Self.exploded = False
för the_zombie i Zombie_Dict:
Zombie = Zombie_Dict [the_zombie]
om abs (self.x - Zombie.x) 0: # om hastigheten i den riktningen är inte 0 det lägger till 1 hastigheten så att det är snabbare än djävulen som sköt den.
Self.x_vel += 75
om self.x_vel 0:
Self.y_vel += 75
om self.y_vel = game_limit.x_end) och self.x_vel > 0: # kan boxhead gå i den riktningen eller kommer han slå kanten av spelet
Self.x_vel = 0
om self.x = game_limit.y_end) och self.y_vel > 0:
Self.y_vel = 0
Elif self.y self.shoot_y_end och abs(Zombie.x-self.shoot_x_start) self.shoot_y_start och Zombie.y self.shoot_x_end och abs(Zombie.y-self.shoot_y_start) self.shoot_x_start och Zombie.x self.shoot_y_end och abs(Zombie.x-self.shoot_x_start) self.shoot_y_start och Zombie.y self.shoot_x_end och abs(Zombie.y-self.shoot_y_start) self.shoot_x_start och Zombie.x 0:
min = MINE(self.x,self.y)
Mines_Dict [number_of_mines] = min
number_of_mines + = 1
Self.mine_count-=1
annat:
passera

canvas.Update()

def key(self,key):
"" "Titta på indata från tangentbordet och justera Boxhead. Rörelsen = WASD brand = utrymme Pistol = jag gruvor = U paus = P återaktivera = O "" "
Global press, pause_game
tryck = nyckel
om tryck == "w":
Self.x_vel = 0
Self.y_vel = - B_move_length
Self.Direction = 1
om tryck == 's ":
Self.x_vel = 0
Self.y_vel = B_move_length
Self.Direction = 2
om tryck == "a":
Self.x_vel = - B_move_length
Self.y_vel = 0
Self.Direction = 3
om tryck == hade ":
Self.x_vel = B_move_length
Self.y_vel = 0
Self.Direction = 4
om tryck == "utrymme":
Self.fire_gun()
om tryck == "p":
pause_game = sant
om tryck == ' o ':
pause_game = False
om tryck == "i":
Self.Gun = "Pistol"
Self.ammo = "Infinte"
om tryck == "u":
Self.Gun = 'Minor'
Self.ammo = self.mine_count

def shoot_coords(self,x_start,y_start,x_end,y_end):
"" "Hjälp att justera koordinater baserat på var att skjuta från varje riktning" ""
Self.shoot_x_start = x_start
Self.shoot_y_start = y_start
Self.shoot_x_end = x_end
Self.shoot_y_end = y_end

klass Zombie(object):
"" "ZOMBIES. Inget som en massa Zombies som jagar dig runt. Boxhead är snabbare dåvarande Zombies, men Zombies kan flytta diagonalt"" "
def __init__(self):
Self.ZUP = PhotoImage (fil = "images/zombies/zup.gif") # finns 8 riktningar som Zombies kan flytta i
Self.zdown = PhotoImage (fil = "images/zombies/zdown.gif")
Self.zleft = PhotoImage (fil = "images/zombies/zleft.gif")
Self.zright = PhotoImage (fil = "images/zombies/zright.gif")
Self.zrightup = PhotoImage (fil = "images/zombies/zrightup.gif")
Self.zrightdown = PhotoImage (fil = "images/zombies/zrightdown.gif")
Self.zleftup = PhotoImage (fil = "images/zombies/zleftup.gif")
Self.zleftdown = PhotoImage (fil = "images/zombies/zleftdown.gif")
Self.x = random.randrange (game_limit.x_start, (game_limit.x_end-(game_limit.x_end / 2))) # skapa Zombies i vänstern halvan av arenan
Self.y = random.randrange(game_limit.y_start,game_limit.y_end)
Self.Direction = 1
Self.Zombie = canvas.create_image (self.x,self.y, bild = self.zup)
Self.Alive = sant
Self.distance_to_b = 0
Self.attacked = False
def move(self,target):
"" "Denna funktion som Boxhead1.move tester för att se om Zombie träffar kanten av spelet, men också tester för att se om Zombie kolliderar med en annan
Zombie framför den. Detta hjälper till att undvika att ha alla Zombies stapla ovanpå varandra och froming en riktigt tät Zombie. Det är vad riktigt lång kodraden
nedan testar"" "
globala boxhead1
which_zombie = 0
kollisionen = False
Self.x_vel = 0
Self.y_vel = 0
för which_zombie i Zombie_Dict:
test_self = Zombie_Dict [which_zombie]
om abs(self.x-boxhead1.x)-abs(boxhead1.x-test_self.x) > 0 och abs(self.x-boxhead1.x)-abs(boxhead1.x-test_self.x) 0 och abs(self.y-boxhead1.y)-abs(boxhead1.y-test_self.y) target.x:
Self.x_vel=-Zombie_per_move
Elif self.x == target.x:
Self.x_vel = 0
om self.x > = Window_Width - 25: # x coords
Self.x_vel = - Zombie_per_move
om self.x target.y:
Self.y_vel = - Zombie_per_move
Elif self.y == target.y:
Self.y_vel = 0
om self.y > = Window_Height - 25: # y coords
Self.y_vel = - Zombie_per_move
om self.y 0 och self.x_vel == 0:
canvas.itemconfigure (self.zombie, bild = self.zdown)
om self.x_vel 0 och self.y_vel == 0:
canvas.itemconfigure (self.zombie, bild = self.zright)
om self.y_vel > 0 och self.x_vel > 0:
canvas.itemconfigure (self.zombie, bild = self.zrightdown)
om self.y_vel 0:
canvas.itemconfigure (self.zombie, bild = self.zrightup)
om self.y_vel > 0 och self.x_vel 0 och abs(self.x-boxhead1.x)-abs(boxhead1.x-test_self.x) 0 och abs(self.y-boxhead1.y)-abs(boxhead1.y-test_self.y) target.x:
Self.x_vel=-Devil_move
Elif self.x == target.x:
Self.x_vel = 0
om self.x > = Window_Width - 25: # x coords
Self.x_vel = - Devil_move
om self.x target.y:
Self.y_vel = - Devil_move
Elif self.y == target.y:
Self.y_vel = 0
om self.y > = Window_Height - 25: # y coords
Self.y_vel = - Devil_move
om self.y 0 och self.x_vel == 0:
canvas.itemconfigure (self.devil, bild = self.ddown)
om self.x_vel 0 och self.y_vel == 0:
canvas.itemconfigure (self.devil, bild = self.dright)
om self.y_vel > 0 och self.x_vel > 0:
canvas.itemconfigure (self.devil, bild = self.drightdown)
om self.y_vel 0:
canvas.itemconfigure (self.devil, bild = self.drightup)
om self.y_vel > 0 och self.x_vel 45:
d_attack = Zombie_Attack(self.x,self.y,self.x_vel,self.y_vel)
Devil_Attack_Dict [total_devil_attacks] = d_attack
total_devil_attacks + = 1
Self.attack_fire = 0
annat:
Self.attack_fire + = 1

def key_press(event):
"" "Denna funktion passerar alla av knapptryckningar till funktionen Boxhead1.key för vidare analys" ""
globala pause_game
Tryck = event.keysym
boxhead1.Key(press)
om tryck == ' o ':
pause_game = False

def init_game_parts():
"" "Detta bygger alla ursprungliga spelet element som skapas endast en gång oavsett hur många nivåer. Till exempel det skapar resultattavlan"" "
globala upp, ner, höger, vänster
globala ner
globala höger
globala vänster
globala current_shot
globala game_limit
globala score_board
globala boxhead1
globala Zombie_Dict
globala game_limit
upp = Shot()
ned = Shot()
vänster = Shot()
höger = Shot()
current_shot = Shot()
game_limit = Edge_limits()
boxhead1 = Boxhead()
score_board = Stats()

def new_level():
"" "För varje ny nivå alla djävlar och Zombies har dödats så nya måste skapas. Varje tid 70% mer Zombies läggs"" "
build_zombie = 0
build_devil = 0
för i i range(Number_of_Zombies):
z = Zombie()
Zombie_Dict [build_zombie] = z
build_zombie + = 1
för jag i intervall (int(Number_of_Zombies / 5)):
D = Devil()
Devil_Dict [build_devil] = D
build_devil + = 1

def main_loop():
"" "Den centrala funktionen för spelet. Det finns 2 medan loopar. Det inre en är bara bruten för en ny nivå och den yttre loopen är endast bruten
om boxhead dör och spelet är över"" "
Global New_Level, Run_Game, Zombie_Dict, Dead_Zombie_List, Number_of_Zombies, boxhead1
init_game_parts() # skapa alla spel bilder som kanten buffertar
medan Run_Game == True:
globala Blood_Dict
Blood_Dict = {} # skapa en ny tom blod ordbok
om boxhead1.health ", key_press)
canvas.Pack()
canvas.mainloop()