Boxhead mit Python neu mit Tkinter

1 Schritt:

<Iframe frameborder = 0 height = 377 src=http://player.vimeo.com/video/56589377 width = 500> </ iframe> Boxhead neu in Python von BenR auf Vimeo. Video Boxhead neu mit Python mit Tkinter Es ist ein fantastisch unterhaltsame Computerspiel namens Boxhead, wo im wesentlichen Sie und / oder eine zweite Person abzuwehren Horden von angreifenden Zombies und Devils mit verschiedenen Waffen. Für einen Computer Science-Klasse in diesem Jahr, die ich nehme, war der letzte Projekt, ein Computerspiel in Python mit Tkinter neu zu erstellen. Boxhead schien die logische Wahl zu sein und ich über dieses anschließend eingestellt. Ich hoffe, dass Sie genießen, was sie in so weit gedreht hat, und ich hoffe, mehr Waffen, Ebene mit Objekten und einen zweiten Spieler in der Zukunft hinzuzufügen.

Ab sofort Boxhead kann nur kämpfen, mit einer Pistole und Minen, aber es wäre toll, um den Zugriff auf Schrotflinte und Raketen haben.

Fühlen Sie sich frei, um den Code zu kopieren und spielen Sie oder fügen Sie Waffen. Denken Sie auch daran, dass das Programm und Bilder müssen im gleichen Ordner aufbewahrt werden und die Bilder werden in Unterordnern. Zum Beispiel die Boxhead Bilder sind in einem separaten Ordner als die Zombie Bilder. Die Zombies gehen in die "Zombies" Unterordner, Teufel in "Teufel", boxhead in "Boxhead" und mine / Blut / Teufel Angriff (gelbe Kugel) in "Spielelemente".

Die Bedienelemente für die Bewegung sind "WASD", Pause "p", un-Pause "o", Wechsel zwischen Waffen "i" und "u". Am wichtigsten ist aber, "Raum" ist Feuer.

Wenn Sie das Spiel spielen wollen alle Bilder benötigt, um zusammen mit dem Code verfügbar sind, gehen hier zusammen mit dem Code.

  # # Boxhead Von Ben Rothschild # Boxhead - eine Kopie der Original-Spiel in Python mit Tkinter # from Tkinter import * Einfuhrzufallsimportzeit import math window_height = 550 # gemacht Letzte Änderung 2012.12.14 stellen Sie die Fensterhöhe und -breite window_width = 800 X_Window_Buffer = 40 Y_Window_Buffer = 40 = Leinwand auf Keilrahmen (highlightthickness = 0, height = window_height, width = window_width) canvas.master.title ("Boxhead") canvas.pack () Main = canvas.create_rectangle (0,0, window_width, window_height, füllen = "# EBDCC7", belowThis = None) # schaffen die Grundfarbe ähnlich dem von der Boxhead Spiel pic = photoimage (width = window_width, height = window_height) canvas.create_image (0,0, image = Bild, Anker = NW) Zombie_Dict_Made = False # haben die Zombies und Boxhead geschaffen?  boxhead_made = False Run_Game = True New_Level = False B_move_length = 2 # Einige der Spiel-Attribute diese Änderung und sind für die Erstkonfiguration verwendet.  Die meisten würden besser in einem zentralen Spielklasse Zombie_per_move = 0,5 Devil_move = 1 sein Richtung = 1 shot_duration = 0,01 Zombie_Buffer = 30 = 15 kill_zone Number_of_Zombies = 5 total_devil_attacks = 0 = 0 blood_marks number_of_mines = 0 global pause_game # Pause das Spiel, wenn "P 'gedrückt wird oder starten Sie es, wenn' O 'wird pause_game gedrückt = False Mines_Dict = {} # hält alle Minen Zombie_Dict = {} # Wo die Zombies sind gehalten - Elemente gelöscht werden als Boxhead schießt sie Devil_Dict = {} # gleichen wie Zombie_Dict aber für Devils Dead_Zombie_List = [] Devil_Attack_Dict = {} # Die Kugeln, die die Devils mit Klasse Edge_limits (Objekt) anzugreifen: "" "Weist Grenzen in jeder x y-Richtung, um Objekte, so dass sie nicht aus der Lauf Spiel-Bildschirm "" "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 Klasse Buffer ( Gegenstand): "" "Die Randpuffer für das Spiel" "" def __init__ (self, x_start, y_start, x_end, y_end, füllen): canvas.create_rectangle (x_start, y_start, x_end, y_end, füllen = fill) left_buffer = Buffer (0,0, (X_Window_Buffer), (Y_Window_Buffer + window_height), "Black") # erstellen alle Puffer Bilder right_buffer = Buffer((X_Window_Buffer+Window_Width),0,(Window_Width-(X_Window_Buffer)),((2*Y_Window_Buffer)+Window_Height),  "Black") top_buffer = Puffer (0,0, (window_width-X_Window_Buffer), Y_Window_Buffer, "Black") bottom_buffer = Puffer (0, (window_height-Y_Window_Buffer), window_width, window_height, "Black") Klasse Blood (Objekt): "" "" def __init __ (self, x "Was passiert, wenn Sie etwas zu töten. Es schaffen ein Blutfleck auf den Koordinaten der getötet Zombie (n) / Devil (e) Sie sind am Anfang jeder neuen Ebene gelöscht", y): global base_for_blood self.image = photoimage (file = "images / game_elements / blood.gif") self.blood_spot = canvas.create_image (x, y, image = self.image) canvas.tag_lower (self.blood_spot) Leinwand .tag_lower (Main) Klasse MINE (Objekt): "" "Die Minen Klasse Pass auf, wo Sie Schritt." "" def __init __ (self, x, y): = self.photo photoimage (file = "images / game_elements / Bergwerk. gif ") self.image = canvas.create_image (x, y, image = self.photo) # Erstellen Sie ein schwarzes Rechteck für das Bergwerk Bild canvas.tag_lower (self.image) canvas.tag_lower (Main) self.destroy = False Selbst .x = x = y self.y def explodieren (self): "" "fest, ob ein Zombie oder Teufel ist nah genug an der Mine eingestellt.  Wenn das wahr ist, dann testet, um zu sehen, ob ein Zombie oder Teufel in der größeren Umgebung getötet werden sollten "" "destroy_zombie = [] destroy_devil = [] self.exploded = False für the_zombie in Zombie_Dict: Zombie = Zombie_Dict [the_zombie] if abs (self.x - Zombie.x) <20 und abs (self.y - Zombie.y) <20: # Test, um zu sehen, wenn ein Zombie / Devil ist innerhalb der Box, die +/- 40 Pixel von der Mine x und y = True self.exploded self.destroy = True für the_devil in Devil_Dict: Devil = Devil_Dict [the_devil], wenn abs (self.x - Devil.x) <20 und abs (self.y - Devil.y) <20: self.exploded = True self.destroy = True, wenn self.exploded == True: explodieren = canvas.create_oval ((self.x - 80), (self.y - 80), (self.x + 80), (Selbst .y + 80) einzutragen, füllen = 'Orange') # der Radius der Explosion ist 80 canvas.update (), wenn self.exploded == True: zum Teufel in Devil_Dict: Devil = Devil_Dict [Teufel] # den Zombie, um ein In Liste gelöscht werden, da kann man nicht ändern, Wörterbücher beim Überqueren Sie sie, wenn abs (self.x - Devil.x) <80 und abs (self.y - Devil.y) <80: destroy_devil.append (Teufel) für Zombie in Zombie_Dict : Zombie = Zombie_Dict [Zombie], wenn abs (self.x - Zombie.x) <80 und abs (self.y - Zombie.y) <80: destroy_zombie.append (Zombie) für Artikel in destroy_zombie: # Löschen der Zombie / Devils in der Explosion canvas.delete (Zombie_Dict [Artikel] .zombie) gefangen del Zombie_Dict [Artikel] für Einzelteil in destroy_devil: canvas.delete (Devil_Dict [Artikel] .devil) del Devil_Dict [Option], wenn self.exploded == true : canvas.delete (explodieren) Klasse Zombie_Attack (Objekt): "" "Der gelbe Kreis, dass die Zombies verwendet, um Boxhead angreifen.  Es hat eine Lebensdauer von 125 Fällen in der while-Schleife, bevor es verschwindet.  Es sei denn, es Streiks boxhead und senkt Gesundheits boxhead die von vielen "" "def __init __ (self, x, y, x_vel, y_vel): self.x = x = y self.y self.image = photoimage (file =" Bilder /game_elements/devil_a.gif ") self.attack = canvas.create_image (self.x, self.y, image = self.image) self.x_vel = x_vel wenn self.x_vel> 0: # Wenn die Geschwindigkeit in diese Richtung ist nicht 0 Es addiert 1 zu der Geschwindigkeit, so dass es schneller als der Teufel, der sie erschossen self.x_vel + = 0,75, wenn self.x_vel <0:. self.x_vel - = .75 self.y_vel = y_vel wenn self.y_vel > 0: self.y_vel + = 0,75, wenn self.y_vel <0: self.y_vel - = .75 self.life_span = 125 def move (self): global boxhead1 self.x + = self.x_vel self.y + = self.y_vel canvas.coords (self.attack, self.x, self.y) self.life_span - = 1, wenn abs (self.x - boxhead1.x) <30 und abs (self.y - boxhead1.y) < 30: #Strike Boxhead, wenn innerhalb von 30 Pixel boxhead1.health - = 10 = 0 self.life_span Klasse Shot (Objekt): "" "Korrigieren, wo gun versuchte je nachdem, welche Richtung Boxhead ist.  Wegen der Boxhead Bild die Koordinaten von wo die Waffe ist, wenn Boxhead dreht sich unterscheidet, dass wenn er mit dem linken Dreharbeiten in Bezug auf die ursprünglichen x, y Position in der oberen linken Ecke des Bildes "" "Klasse Stats (Objekt ): "" "Legt die Partitur label / info.  Dies aktualisiert einmal pro Schleife auf der Basis aller Boxhead Attribute ab.  Gesundheit und Punktzahl "" "def __init __ (self): global boxhead1 self.board = self.board = canvas.create_text (200,65) canvas.create_rectangle(X_Window_Buffer,Y_Window_Buffer,Window_Width-X_Window_Buffer,Y_Window_Buffer+20,fill="Red")  def Update (self): health_string = str (boxhead1.health) score_string = str (boxhead1.score) level_string = str (boxhead1.level) gun_string = str (boxhead1.gun) ammo_string = str (boxhead1.ammo) score_board = "Health : "+ health_string +" "+" Score: "+ score_string +" "+" Level: "+ level_string +" "+" Gun: "+ gun_string +" "+" Ammo: "+ ammo_string canvas.delete (Selbst. board) self.board = canvas.create_text (230,52, text = score_board) Klasse Boxhead (Objekt): "" "Die Boxhead charecter.  Schießen, verschieben, Minen legen etc. sind alle in der Klasse Boxhead contianed.  Schließlich all der Pistole Details müssen auf thier eigenen Klasse verschoben werden, so dass Pistol Gun = (Bereich Schaden) und Minen = Gun (Radius, Beschädigung) schließlich sogar Shotgun = Gun (Bereich damange, arc_width) und so weiter "," "def __init __ (self): self.image_up = photoimage (file =" images / boxhead / bhup.gif ") # Das Bild ändert, wenn Boxhead nach oben unten links rechts self.image_down = photoimage (file =" images / boxhead / bhdown.gif ") self.image_left = photoimage (file =" images / boxhead / bhleft.gif ") self.image_right = photoimage (file =" images / boxhead / bhright.gif ") self.x = random.randrange (( (game_limit.x_start / 2) 15), game_limit.x_end) # einen zufälligen Startpunkt auf der rechten Seite des Feldes. Zombies beginnen auf der linken Hälfte. self.y = random.randrange (game_limit.y_start, game_limit. y_end) self.image = canvas.create_image (self.x, self.y, image = self.image_up) self.x_vel = 0 = 0 self.y_vel self.direction = 1 self.health = 100 # +5 Gesundheit hinzugefügt am Anfang jeder Ebene self.gun = "Pistol" self.level = 1 self.score = 0 self.ammo = "unendlich" self.pause = False self.bonus_score = 0 self.pistol_range = 150 # der Bereich der Pistole in Pixel self.mine_count = 0 # Wie viele Minen def links zu bewegen (self): global unterwegs if (self.x> = game_limit.x_end) und self.x_vel> 0: # Kann Bewegung in diese Richtung Boxhead oder wird er Streik der Kante des Spiels self.x_vel = 0, wenn self.x <= game_limit.x_start und self.x_vel <0: self.x_vel = 0 sonst: übergeben, wenn (self.y> = game_limit.y_end) und self.y_vel > 0: self.y_vel = 0 elif self.y <= game_limit.y_start und self.y_vel <0: self.y_vel = 0 sonst: pass self.x + = + = self.x_vel self.y self.y_vel Leinwand. coords (self.image, (self.x), (self.y)) def shot_coords_update (self): "" "aktualisieren Sie die Koordinaten, wo die Waffe sollte aus abgefeuert werden" "" Wenn self.gun == "Pistol" oder self.gun == 'Mines': gun_range = self.pistol_range globalen up global unten links global global rechten up.x_start = 10 + boxhead1.x up.y_start = -5 + boxhead1.y up.x_end = 11 + boxhead1. x up.y_end = boxhead1.y - (gun_range + 5) = down.x_start boxhead1.x - 10 down.y_start = 5 + boxhead1.y down.x_end = boxhead1.x - 9 down.y_end = gun_range + 5 + boxhead1 .y left.x_start = 15 + boxhead1.x left.y_start = boxhead1.y - 15 left.x_end = boxhead1.x - gun_range - 15 left.y_end = boxhead1.y -15 right.x_start = 5 + boxhead1.x rechts .y_start = 0 + boxhead1.y right.x_end = gun_range + 5 + boxhead1.x right.y_end = 1 + boxhead1.y wenn self.direction == 1: # welche Richtung Boxhead ist Tatsache, 1 = bis 2 = unten usw. boxhead1.shoot_coords (up.x_start, up.y_start, up.x_end, up.y_end) wenn self.direction == 2: boxhead1.shoot_coords (down.x_start, down.y_start, down.x_end, down.y_end), wenn Selbst .Direction == 3: boxhead1.shoot_coords (left.x_start, left.y_start, left.x_end, left.y_end) wenn self.direction == 4: boxhead1.shoot_coords (right.x_start, right.y_start, right.x_end, right.y_end) def pic (self): "" "Ändern Boxhead das Image auf der Basis der Richtung er sich bewegt" "" Wenn self.direction == 1: canvas.itemconfigure (self.image, image = self.image_up), wenn Selbst .Direction == 2: canvas.itemconfigure (self.image, image = self.image_down) wenn self.direction == 3: canvas.itemconfigure (self.image, image = self.image_left) wenn self.direction == 4: canvas.itemconfigure (self.image, image = self.image_right) def fire_gun (self): "" "Fires je nachdem, welcher Waffe, die Boxhead wird mit im Moment" "" global blood_marks, Blood_Dict self.bonus_score = 0 Dead_Zombie_List = [] which_zombie = 0 global Zombie_Dict kill_list = [] # die Librarys, die halten, was Zombie muss von Zombie_Dict kill_devil = [], wenn self.gun == "Pistol" gelöscht werden: self.bullet_image = canvas.create_rectangle(self.shoot_x_start,self.shoot_y_start,self.shoot_x_end+1,self.shoot_y_end+1,fill="Black")  # Erstellen die Kugel canvas.update () für Each_Zombie in Zombie_Dict: Zombie = Zombie_Dict [Each_Zombie] # Test, ob jeder Zombie ist im Weg der Kugel, wenn self.direction == 1: wenn Zombie.y <self.shoot_y_start und Zombie .y> self.shoot_y_end und abs (Zombie.x - self.shoot_x_start) <25: kill_list.append (Each_Zombie) elif self.direction == 2: wenn Zombie.y> self.shoot_y_start und Zombie.y <self.shoot_y_end und abs (Zombie.x - self.shoot_x_start) <25: kill_list.append (Each_Zombie) elif self.direction == 3: Wenn Zombie.x <self.shoot_x_start und Zombie.x> self.shoot_x_end und abs (Zombie.y - self.shoot_y_start) <25: kill_list.append (Each_Zombie) elif self.direction == 4: wenn Zombie.x> self.shoot_x_start und Zombie.x <self.shoot_x_end und abs (Zombie.y - self.shoot_y_start) < 25: kill_list.append (Each_Zombie) für each_devil in Devil_Dict: Zombie = Devil_Dict [each_devil], wenn self.direction == 1: wenn Zombie.y <self.shoot_y_start und Zombie.y> self.shoot_y_end und abs (Zombie.x - self.shoot_x_start) <25: Zombie.health - = 26 # Lower Teufels Gesundheit durch 26, so dass es dauert 4 Schüsse, ein Teufel, während 1 für einen Zombie kill_devil.append (each_devil) elif self.direction == 2 schlagen: wenn Zombie.y> self.shoot_y_start und Zombie.y <self.shoot_y_end und abs (Zombie.x - self.shoot_x_start) <25: Zombie.health - = 26 kill_devil.append (each_devil) elif self.direction == 3: if Zombie.x <self.shoot_x_start und Zombie.x> self.shoot_x_end und abs (Zombie.y - self.shoot_y_start) <25: Zombie.health - = 26 kill_devil.append (each_devil) elif self.direction == 4: if Zombie.x> self.shoot_x_start und Zombie.x <self.shoot_x_end und abs (Zombie.y - self.shoot_y_start) <25: Zombie.health - = 26 kill_devil.append (each_devil) für Each_Zombie in kill_list: # Zerstören Sie die Zombie- von der Zombie_Dict und Leinwand Zeichen = Blut getötet werden (Zombie_Dict [Each_Zombie] .x, Zombie_Dict [Each_Zombie] .y) Blood_Dict [blood_marks] = Zeichen blood_marks + = 1 canvas.delete (Zombie_Dict [Each_Zombie]) del Zombie_Dict [Each_Zombie] boxhead1.score + = 1 self.bonus_score + = 1 für the_devil in kill_devil: mark = Blood (Devil_Dict [the_devil] .x, Devil_Dict [the_devil] .y) Blood_Dict [blood_marks] = Zeichen blood_marks + = 1, wenn Devil_Dict [the_devil]. Gesundheit <= 0: canvas.delete (Devil_Dict [the_devil]) del Devil_Dict [the_devil] boxhead1.score + = 1 self.bonus_score + = 1 canvas.delete (self.bullet_image) self.score + = (self.bonus_score / 3) wenn self.gun == 'Mines': # lag ein Bergwerk und geben Sie es mine.x = boxhead1.x und mine.y = boxhead1.y globalen number_of_mines wenn self.mine_count> 0: mine = mine (self.x Selbst .y) Mines_Dict [number_of_mines] = mine number_of_mines + = 1 self.mine_count - = 1 sonst: pass canvas.update () def Taste (self, key): "" "Schauen Sie sich die Eingabe von der Tastatur und passen Boxhead entsprechend.  Bewegung = WASD Feuer = Raum Pistol = I Mines = U Pause = P = O Erneut aktivieren "" "Weltpresse, pause_game drücken = Taste drücken, wenn == 'w': self.x_vel = 0 = self.y_vel -B_move_length self.direction = 1, wenn Presse == 's': self.x_vel = 0 = self.y_vel B_move_length self.direction = 2, wenn Presse == 'a': self.x_vel = -B_move_length self.y_vel = 0 self.direction = 3, wenn Presse == 'd': self.x_vel = B_move_length self.y_vel = 0 self.direction = 4, wenn Presse == "Raum": self.fire_gun (), wenn Presse == 'p': pause_game = True, wenn Presse == 'o': pause_game = False, wenn Presse == 'i': self.gun = "Pistol" self.ammo = 'Unendlich' drücken, wenn == 'u': self.gun = 'Mines' self.ammo = Selbst. mine_count def shoot_coords (self, x_start, y_start, x_end, y_end): "" "Hilfe, um die Koordinaten der Grundlage von wo aus jeder Richtung zu schießen einstellen" "" self.shoot_x_start = x_start self.shoot_y_start = y_start self.shoot_x_end = x_end Selbst .shoot_y_end = y_end Klasse Zombie (Objekt): "" "ZOMBIES.  Nichts wie ein Haufen von Zombies, die Sie um zu jagen.  Boxhead ist schneller als Zombies, aber Zombies können diagonal bewegen "" "def __init __ (self): self.zup = photoimage (file =" images / Zombies / zup.gif ") # gibt es 8 Richtungen, die Zombies können in Selbst bewegen. Zdown = photoimage (file = "images / Zombies / zdown.gif") self.zleft = photoimage (file = "images / Zombies / zleft.gif") self.zright = photoimage (file = "images / Zombies / zright.gif ") self.zrightup = photoimage (file =" images / Zombies / zrightup.gif ") self.zrightdown = photoimage (file =" images / Zombies / zrightdown.gif ") self.zleftup = photoimage (file =" images / Zombies /zleftup.gif ") self.zleftdown = photoimage (file =" images / Zombies / zleftdown.gif ") self.x = random.randrange (game_limit.x_start, (game_limit.x_end- (game_limit.x_end / 2))) # erstellen Zombies in der linken Hälfte der Arena self.y = random.randrange (game_limit.y_start, game_limit.y_end) self.direction = 1 self.zombie = canvas.create_image (self.x, self.y, image = Selbst .zup) self.alive = True self.distance_to_b = 0 self.attacked = False def move (self, Ziel): "" "Diese Funktion wie Boxhead1.move prüft, um zu sehen, ob der Zombie wird die Kante des Spiels treffen, aber auch Tests, um zu sehen, ob der Zombie wird mit einem anderen Zombie davor zusammenstoßen.  Dies hilft zu vermeiden, dass alle Zombies stapeln sich auf der jeweils anderen und froming wirklich dichte Zombie.  Das ist, was das wirklich lange Codezeile unten testet "" "global boxhead1 which_zombie = 0 Kollision = False self.x_vel = 0 self.y_vel = 0 für which_zombie in Zombie_Dict: test_self = Zombie_Dict [which_zombie], wenn abs (self.x - boxhead1.x) - abs (boxhead1.x - test_self.x)> 0 und abs (self.x - boxhead1.x) - abs (boxhead1.x - test_self.x) <Zombie_Buffer und abs (self.y - boxhead1 .y) - abs (boxhead1.y - test_self.y)> 0 und abs (self.y - boxhead1.y) - abs (boxhead1.y - test_self.y) <Zombie_Buffer: Kollision = True anderes: übergeben, wenn Kollision = = True: pass elif Kollision == False: Wenn self.x <target.x: self.x_vel = Zombie_per_move wenn self.x> target.x: self.x_vel = -Zombie_per_move elif self.x == target.x: Selbst .x_vel = 0, wenn self.x> = window_width - 25: # x coords self.x_vel = -Zombie_per_move wenn self.x <= 0 + 5: self.x_vel = Zombie_per_move wenn self.y <target.y: self.y_vel = Zombie_per_move wenn self.y> target.y: self.y_vel = -Zombie_per_move elif self.y == target.y: self.y_vel = 0, wenn self.y> = window_height - 25: # y Koordinaten self.y_vel = - Zombie_per_move wenn self.y <= 0 + 5: self.y_vel = Zombie_per_move self.y + = + = self.y_vel self.x self.x_vel canvas.coords (self.zombie, (self.x), (self.y )) # Bewegen Sie den Zombie entsprechend basierend auf, ob er fahren soll oder ein anderer Zombie ist in seinem Weg anderes: pass def pic (self): "" "Aktualisieren Sie die Zombie-Bild basierend auf dem der 8 Richtungen, die sie auf Reisen", " "wenn self.y_vel <0 und self.x_vel == 0: canvas.itemconfigure (self.zombie, image = self.zup) wenn self.y_vel> 0 und self.x_vel == 0: canvas.itemconfigure (self.zombie , image = self.zdown) wenn self.x_vel <0 und self.y_vel == 0: canvas.itemconfigure (self.zombie, image = self.zleft) wenn self.x_vel> 0 und self.y_vel == 0: Leinwand .itemconfigure (self.zombie, image = self.zright) wenn self.y_vel> 0 und self.x_vel> 0: canvas.itemconfigure (self.zombie, image = self.zrightdown) wenn self.y_vel <0 und self.x_vel > 0: canvas.itemconfigure (self.zombie, image = self.zrightup) wenn self.y_vel> 0 und self.x_vel <0: canvas.itemconfigure (self.zombie, image = self.zleftdown) wenn self.y_vel <0 und self.x_vel <0: canvas.itemconfigure (self.zombie, image = self.zleftup) def Kontakt (self): "" "Dies ist, wie die Zombies zu tun Schäden an Boxhead.  Wenn sie in Kontakt mit Boxhead com es zieht die Gesundheit von Boxhead "" ", wenn abs (boxhead1.x - self.x) <10 und abs (boxhead1.y - self.y) <10 und self.attacked == False: boxhead1 .Wohlbefinden - = 1 self.attacked = True anderes: self.attacked = False Klasse Devil (Objekt): "" "Der Teufel Class.  Sie bewegen sich schneller als Zombies haben mehr Gesundheit und kann Boxhead durch Kollision mit ihm oder von ihm schießen "" "def __init __ (self) angreifen: self.x = random.randrange (game_limit.x_start, (game_limit.x_end- (game_limit.x_end / 2))) self.y = random.randrange (game_limit.y_start, game_limit.y_end) self.direction = 1 self.alive = True self.distance_to_b = 0 self.attacked = False self.attack_fire = 0 self.health = 100 self.dup = photoimage (file = "images / devils / du.gif") # 8 die Teufel Bilder self.ddown = photoimage (file = "images / devils / db.gif") self.dleft = photoimage (file = "images / devils / dl.gif") self.dright = photoimage (file = "images / devils / dr.gif") self.drightup = photoimage (file = "images / devils / dtr.gif") self.drightdown = photoimage (file = "images / devils / dbr.gif") self.dleftup = photoimage (file = "images / devils / dtl.gif") self.dleftdown = photoimage (file = "images / devils / dbl.gif") self.devil = canvas.create_image (self.x, self.y, image = self.dup) def bewegen (self, Ziel): "" "Die Teufels Bewegung ist die gleiche wie die Zombies außer dass Devils bewegen sich schneller" "" which_zombie = 0 Kollision = False self.x_vel = 0 self.y_vel = 0 für the_devil in Devil_Dict: test_self = Devil_Dict [the_devil], wenn abs (self.x - boxhead1.x) - abs (boxhead1.x - test_self.x)> 0 und abs (self.x - boxhead1.x) - abs (boxhead1.x - test_self.x) <Zombie_Buffer und abs (self.y - boxhead1.y) - abs (boxhead1.y - test_self.y)> 0 und abs (self.y - boxhead1.y) - abs (boxhead1.y - test_self.y) <Zombie_Buffer: Kollision = True anderes: übergeben, wenn Kollision == True: geben elif Kollision == False: Wenn self.x <target. x: = self.x_vel Devil_move wenn self.x> target.x: self.x_vel = -Devil_move elif self.x == target.x: self.x_vel = 0, wenn self.x> = window_width - 25: # x coords self.x_vel = -Devil_move wenn self.x <= 0 + 5: self.x_vel = Devil_move wenn self.y <target.y: self.y_vel = Devil_move wenn self.y> target.y: self.y_vel = -Devil_move elif self.y == target.y: self.y_vel = 0, wenn self.y> = window_height - 25: # y Koordinaten self.y_vel = -Devil_move wenn self.y <= 0 + 5: self.y_vel = Devil_move Selbst .y + = + = self.y_vel self.x self.x_vel canvas.coords (self.devil, (self.x), (self.y)) else: pass def pic (self): "" "Aktualisierung der Bild "" "Wenn self.y_vel <0 und self.x_vel == 0: canvas.itemconfigure (self.devil, image = self.dup) wenn self.y_vel> 0 und self.x_vel == 0: canvas.itemconfigure (Selbst .devil, image = self.ddown) wenn self.x_vel <0 und self.y_vel == 0: canvas.itemconfigure (self.devil, image = self.dleft) wenn self.x_vel> 0 und self.y_vel == 0 : canvas.itemconfigure (self.devil, image = self.dright) wenn self.y_vel> 0 und self.x_vel> 0: canvas.itemconfigure (self.devil, image = self.drightdown) wenn self.y_vel <0 und Selbst .x_vel> 0: canvas.itemconfigure (self.devil, image = self.drightup) wenn self.y_vel> 0 und self.x_vel <0: canvas.itemconfigure (self.devil, image = self.dleftdown) wenn self.y_vel <0 und self.x_vel <0: canvas.itemconfigure (self.devil, image = self.dleftup) def Kontakt (self): "" "Wenn ein Teufel in Kontakt mit boxhead es zieht mehr Gesundheit als ein Zombie würde" " "wenn abs (boxhead1.x - self.x) <10 und abs (boxhead1.y - self.y) <10 und self.attacked == False: boxhead1.health - = 2 self.attacked = True anderes: Selbst. angegriffen = False def Angriff (self, boxhead1): "" "Wenn der Teufel innerhalb von +/- 200 Pixel in der X und Y-Richtung dann einen Feuerball auf boxhead 1 Mal schießt es und wartet dann 45 Schleifen zu schießen agian" "" global total_devil_attacks wenn abs (boxhead1.x - self.x) <200 und abs (boxhead1.y - self.y) <200 und self.attack_fire> 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 sonst: self.attack_fire + = 1 def key_press (event): "" "Diese Funktion durchläuft alle Tastendrücke an das Boxhead1.key Funktion für die weitere Analyse "" "global pause_game drücken = event.keysym boxhead1.key (drücken), wenn Presse == 'o': pause_game = False def init_game_parts ():" "" Dies baut alle inital Spielelemente, die nur einmal unabhängig von der Anzahl der Ebenen erzeugt.  Zum Beispiel ist es die Anzeigetafel "" "global nach oben, unten, rechts, links unten global global global rechts links globalen current_shot globalen game_limit globalen score_board globalen boxhead1 globalen Zombie_Dict globalen game_limit up = Shot () nach unten = Shot () links = Shot (erstellt ) rechts = Shot () current_shot = Shot () game_limit = Edge_limits () boxhead1 = Boxhead () score_board = Stats () def new_level (): "" "Für jede neue Ebene alle Devils und Zombies getötet wurden so neue erstellt werden müssen.  Jedes Mal, 70% mehr Zombies sind "" build_zombie = 0 build_devil = 0 für i in range (Number_of_Zombies) aufgenommen ": im Bereich z = Zombie () Zombie_Dict [build_zombie] = z build_zombie + = 1 für i (int (Number_of_Zombies / 5) ): D = Devil () Devil_Dict [build_devil] = D build_devil + = 1 def main_loop (): "" "Die zentrale Funktion für das Spiel.  Es gibt 2 while-Schleifen.  Das innere ist nur für eine neue Ebene und dem äußeren gebrochen while-Schleife wird nur unterbrochen, wenn boxhead Matrizen und das Spiel ist vorbei "" "global New_Level, Run_Game, Zombie_Dict, Dead_Zombie_List, Number_of_Zombies, boxhead1 init_game_parts () # erstellen gesamte Spiel Bilder wie die Kantenpuffer während Run_Game == True: global Blood_Dict Blood_Dict = {} # ein neues leeres Blut Wörterbuch zu erstellen, wenn boxhead1.health <= 0: # boxhead gestorben - game over return '! Game Over Final Score: "+ str ( boxhead1.score) + 'Finale Level: "+ str ((boxhead1.level - 1)) else: new_level () boxhead1.health + = 5 # fügen +5 bis Boxheads Gesundheits jedem neuen Level boxhead1.mine_count + = int (Number_of_Zombies / 5) # Boxhead erhält 1/5 der Anzahl der Zombies of Mines Wenn es 5 Zombies Boxhead bekommt 1 Mine während New_Level == False:. # das loop-Ebene, die bis Boxhead stirbt oder alle der Zombie läuft / Devils wurden getötet New_Level = False "" "Verschiebt die Devils and Zombies" "" für the_zombie in Zombie_Dict: wenn pause_game = True: Zombie_Dict [the_zombie] .move (boxhead1) Zombie_Dict [the_zombie] .pic () Zombie_Dict [the_zombie] .contact ( ) für the_devil in Devil_Dict: wenn pause_game = True: Devil_Dict [the_devil] .move (boxhead1) Devil_Dict [the_devil] .attack (boxhead1) Devil_Dict [the_devil] .pic () Devil_Dict [the_devil] .contact () zerstören = [] "" "Der Angriff Bereich, dass die Devils shoot" "" Wenn pause_game = True: für d_attack in Devil_Attack_Dict: Devil_Attack_Dict [d_attack] .move (), wenn Devil_Attack_Dict [d_attack] .life_span <= 0: destroy.append (d_attack) für Artikel in zerstören: canvas.delete (Devil_Attack_Dict [Artikel] .attack) del Devil_Attack_Dict [Artikel] "" "Explode die Minen" "" mine_destroy = [] für die Mine in Mines_Dict: Mines_Dict [mine] .explode (), wenn Mines_Dict [mine ] .Destroy == True: mine_destroy.append (von mir) für die Minen in mine_destroy: canvas.delete (Mines_Dict [mine] .Bild) del Mines_Dict [mine] "" "Boxhead bewegt" "" Wenn pause_game = True: boxhead1. move () boxhead1.pic () boxhead1.shot_coords_update () score_board.update () time.sleep (0,02) # Schlaf für 1/100 Sekunde zwischen Schleifen canvas.update () If Len (Zombie_Dict) == 0 und len (Devil_Dict) == 0: # wenn sie beide = 0 wird eine neue Ebene erstellt New_Level = True, wenn boxhead1.health <= 0: = True New_Level Run_Game = False boxhead1.level + = 1 Number_of_Zombies = int (float (Number_of_Zombies ) * 1,7) # Erhöhung der Zahl der Zombies in jeder Runde für Blut in Blood_Dict: # gesamte Blut für die neue Runde canvas.delete (löschen Blood_Dict [Blut]) New_Level = False print 'Game Over!  Final Score: "+ str (boxhead1.score) + 'Final Level:" + str (boxhead1.level - 1) # print das Endergebnis canvas.after (30, main_loop) canvas.master.bind ("   ", Key_press) canvas.pack () canvas.mainloop ()