base_game complete

Reviewed-on: http://192.168.2.198:3000/Yadciel/LF08/pulls/2

.gitignore

@@ -1,6 +1,2 @@
-
 __pycache__/
-
-.idea/misc.xml
-
-.idea/TruckSimulator.iml
+.idea/

.idea/.gitignore

@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml

.idea/inspectionProfiles/profiles_settings.xml

@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <settings>
-    <option name="USE_PROJECT_PROFILE" value="false" />
-    <version value="1.0" />
-  </settings>
-</component>

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/TruckSimulator.iml" filepath="$PROJECT_DIR$/.idea/TruckSimulator.iml" />
-    </modules>
-  </component>
-</project>

.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>

README.md

@@ -1 +1,32 @@
-# TruckSimulator
+# Trucksimulator
+
+Willkommen im Trucksimulator-Repository! In diesem Spiel geht es darum, einen Truck zu fahren und eine Ladung von einer Mine abzuholen und zum Ziel zu bringen, ohne dabei von einem Helikopter erwischt zu werden, der einen verfolgt.
+
+## Installation
+
+Um das Spiel zu spielen, müssen Sie es zuerst herunterladen und auf Ihrem Computer installieren. Hier sind die Schritte:
+
+1. Klonen Sie das Repository auf Ihren Computer mit dem Befehl
+   `git clone https://git.braveslave.duckdns.org/Ihr Benutzername/LF08.git`.
+   Oder
+   Ziehen sie sich die ".Exe" aus dem Pakete Tab.
+2. Stellen Sie sicher, dass Sie die neueste Version von Python und der pygame-Bibliothek installiert haben.
+3. Navigieren Sie zum Ordner `trucksimulator` und führen Sie das Spiel mit dem Befehl `python main.py` aus.
+
+## Spielanleitung
+
+Das Ziel des Spiels ist es, eine Ladung von einer Mine abzuholen und zum Ziel zu bringen, ohne dabei von einem Helikopter erwischt zu werden. Hier sind die Schritte:
+
+1. Starten Sie das Spiel, indem Sie die Datei `main.py` ausführen.
+2. Fahren Sie den Truck zur Mine und laden Sie die Ladung auf.
+3. Bringen Sie die Ladung zum Ziel, indem Sie den Truck auf der Straße halten und Hindernissen ausweichen.
+4. Seien Sie vorsichtig und vermeiden Sie es, vom Helikopter erwischt zu werden, der Sie verfolgt. Wenn er zu nahe kommt, verlieren Sie das Spiel.
+5. Wenn Sie die Ladung erfolgreich zum Ziel gebracht haben, haben Sie das Spiel gewonnen!
+
+## Mitwirkende
+
+Dieses Spiel wurde von Nico Schmidt entwickelt.
+
+## Lizenz
+
+Dieses Spiel steht unter der MIT-Lizenz. Siehe die Datei `LICENSE` für weitere Informationen.

fahrzeug.py

@@ -0,0 +1,36 @@
+import pygame
+import math
+
+
+def get_angle(p1, p2):
+    dx = p2[0] - p1[0]
+    dy = p2[1] - p1[1]
+    rads = math.atan2(-dy, dx)
+    rads %= 2 * math.pi
+    degs = math.degrees(rads)
+    return degs
+
+
+class Fahrzeug(pygame.sprite.Sprite):
+    def __init__(self, x, y):
+        super().__init__()
+        self.speed = 1
+        self.dest_x = x
+        self.dest_y = y
+        self.direction = pygame.math.Vector2(0, -1)
+        self.angle = 0
+        self.Tank = 250
+
+    def update(self):
+        self.move()
+
+        if self.rect.centerx != self.dest_x or self.rect.centery != self.dest_y:
+            if self.Tank > 0:
+                self.Tank -= 0.1
+            self.angle = get_angle((self.rect.centerx, self.rect.centery), (self.dest_x, self.dest_y)) - 90
+
+        def move(self):
+            pass
+
+    def dest(self, pos):
+        self.dest_x, self.dest_y = pos

game.py

@@ -1,25 +1,29 @@
 import pygame
 import player
+import helicopter
+import object
+import game_over
+import tilemap
 import sys
 
+
 def start():
     pygame.init()
     win = pygame.display.set_mode((800, 800))
-    player1 = player.Player(0, 0)
+    player1 = player.Player(500, 500)
+    enemy = helicopter.Helicopter(50, 50)
+    Erzmine = object.Erz(600, 40)
+    Tanken = object.Tank(200, 220)
+    Ziele = object.Ziel(600, 750)
+    GameOver = False
+    GO = game_over.GameOver()
+
+    tile_set = pygame.image.load("resources/roads2W.png").convert_alpha()
 
     # Farben
     white = (255, 255, 255)
     blue = (0, 0, 255)
 
-    # Tilemap
-    tile_size = 16
-    map_width = 200
-    map_height = 200
-    tilemap = [[0 for y in range(map_height)] for x in range(map_width)]
-
-    for x in range(map_width):
-        for y in range(map_height):
-            tilemap[x][y] = 1
 
     while True:
         for event in pygame.event.get():
@@ -29,16 +33,73 @@ def start():
             if event.type == pygame.MOUSEBUTTONDOWN:
                 player1.dest(pygame.mouse.get_pos())
 
-        # Hintergrundfarbe
-        win.fill(white)
+        if player1.rect.colliderect(Tanken.rect):
+            player1.Tank = 250
 
-        # Tilemap zeichnen
-        for x in range(map_width):
-            for y in range(map_height):
-                if tilemap[x][y] == 1:
-                    pygame.draw.rect(win, blue, (x * tile_size, y * tile_size, tile_size, tile_size))
+        if player1.rect.colliderect(enemy.rect):
+            GameOver = True
 
-        player1.update()
-        player1.draw(win)
+        if player1.rect.colliderect(Erzmine.rect):
+            player1.Erz += 1
 
-        pygame.display.update()
+        if player1.rect.colliderect(Ziele.rect):
+            if player1.Erz >= 1:
+                player1.Erz -= 1
+
+        if GameOver == False:
+            # Hintergrundfarbe
+            win.fill(white)
+            tile = tilemap.tilemap()
+            # Tilemap
+            tile_size = tile.tilesize
+            # Schleife durch das Tilemap-Array
+            for y in range(len(tile.map_array)):
+                for x in range(len(tile.map_array[y])):
+                    # Überprüfen, ob der Wert in der aktuellen Zelle gleich 0 ist
+                    if tile.map_array[y][x] == 0:
+                        win.blit(tile.road_quer, (x * tile_size, y * tile_size))
+                    if tile.map_array[y][x] == 1:
+                        win.blit(tile.road_senkrecht, (x * tile_size, y * tile_size))
+                    if tile.map_array[y][x] == 2:
+                        win.blit(tile.road_btr, (x * tile_size, y * tile_size))
+                    if tile.map_array[y][x] == 3:
+                        win.blit(tile.road_tbr, (x * tile_size, y * tile_size))
+
+            Erzmine.update()
+            Erzmine.draw(win)
+
+            Tanken.update()
+            Tanken.draw(win)
+
+            Ziele.update()
+            Ziele.draw(win)
+
+            player1.update()
+            player1.draw(win)
+
+            enemy.update(player1)
+            enemy.dest((player1.rect.centerx, player1.rect.centery))
+            enemy.draw(win)
+
+            # Game UI--------------------------------
+            font = pygame.font.SysFont(None, 24)
+            tank_label = font.render('Tank: ' + str(round(player1.Tank, 2)), True, white)
+            win.blit(tank_label, (20, 20))
+            font = pygame.font.SysFont(None, 24)
+            tank_label = font.render('Erz: ' + str(round(player1.Erz, 0)), True, white)
+            win.blit(tank_label, (20, 40))
+
+            # debug ausgabe
+            # ---------------------------
+            debug_selfrect = font.render('self centerx: ' + str(player1.rect.centerx) + ' self centery: ' + str(player1.rect.centery), True, white)
+            win.blit(debug_selfrect, (20, 60))
+
+            debug_selfrect = font.render('dest x: ' + str(player1.dest_x) + ' dest y: ' + str(player1.dest_y), True, white)
+            win.blit(debug_selfrect, (20, 80))
+            # ---------------------------
+            # ----------------------------------------
+        else:
+            GO.draw(win)
+            pass
+
+        pygame.display.update()

game_over.py

@@ -0,0 +1,49 @@
+import pygame
+import game
+import sys
+
+
+class GameOver(pygame.sprite.Sprite):
+    def __init__(self):
+        super().__init__()
+        self.label = pygame.font.SysFont("Arial", 50).render("Game Over", True, (255, 0, 0))
+        self.rect = self.label.get_rect(center=(400, 300))
+
+    def draw(self, win):
+        win.fill((0, 0, 0))  # Black
+        win.blit(self.label, self.rect)
+
+        self.start_quit(win)
+
+    @staticmethod
+    def start_quit(win):
+        # Rechtecke
+        start_button = pygame.Rect(200, 400, 100, 50)
+        quit_button = pygame.Rect(500, 400, 120, 50)
+        # Schriftart
+        font = pygame.font.Font(None, 32)
+        # Text
+        start_text = font.render("Start", True, (0, 0, 0))
+        quit_text = font.render("Beenden", True, (0, 0, 0))
+        # Buttons zeichnen
+        pygame.draw.rect(win, (100, 100, 100), start_button)
+        win.blit(start_text, (start_button.x + 25, start_button.y + 10))
+        pygame.draw.rect(win, (100, 100, 100), quit_button)
+        win.blit(quit_text, (quit_button.x + 10, quit_button.y + 10))
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                pygame.quit()
+                sys.exit()
+            if event.type == pygame.MOUSEBUTTONDOWN:
+                mouse_pos = event.pos
+
+                # Start-Button
+                if start_button.collidepoint(mouse_pos) or \
+                        start_text.get_rect(center=(start_button.x + 50, start_button.y + 25)).collidepoint(mouse_pos):
+                    game.start()
+
+                # Beenden-Button
+                if quit_button.collidepoint(mouse_pos) or \
+                        quit_text.get_rect(center=(quit_button.x + 60, quit_button.y + 25)).collidepoint(mouse_pos):
+                    pygame.quit()
+                    sys.exit()

helicopter.py

@@ -0,0 +1,74 @@
+import pygame
+import player
+import rotor
+from fahrzeug import Fahrzeug, get_angle
+import time
+
+
+class Helicopter(Fahrzeug, pygame.sprite.Sprite):
+    def __init__(self, x, y):
+        super().__init__(x, y)
+        self.image = pygame.image.load("resources/helicopter.jpg").convert_alpha()
+        self.image = self.image.subsurface(44, 0, 44, 99)
+        self.image = pygame.transform.scale(self.image, (self.image.get_width() * 1.2, self.image.get_height() * 1.2))
+        self.rect = self.image.get_rect(center=(x, y))
+        self.rect.centerx = x
+        self.rect.centery = y
+        self.rotor = rotor.Rotor(self.rect.centerx, self.rect.centery)
+        self.dest_x = x
+        self.dest_y = y
+        self.rect = self.image.get_rect()
+        self.angle = 0
+        self.speed = 1
+        self.duration_speed = 0.02
+        self.start_time = time.time()
+
+    def update(self, player):
+        keys = pygame.key.get_pressed()
+        if keys[pygame.K_a]:
+            self.rect.centerx -= self.speed
+            self.dest_x -= self.speed
+            self.angle = 90
+        if keys[pygame.K_d]:
+            self.rect.centerx += self.speed
+            self.dest_x += self.speed
+            self.angle = 270
+        if keys[pygame.K_w]:
+            self.rect.centery -= self.speed
+            self.dest_y -= self.speed
+            self.angle = 0
+        if keys[pygame.K_s]:
+            self.rect.centery += self.speed
+            self.dest_y += self.speed
+            self.angle = 180
+
+        elapsed_time = time.time() - self.start_time
+        if elapsed_time >= self.duration_speed:
+            if self.rect.centerx < player.rect.centerx:
+                self.rect.centerx += self.speed
+            if self.rect.centery < player.rect.centery:
+                self.rect.centery += self.speed
+            if self.rect.centerx > player.rect.centerx:
+                self.rect.centerx -= self.speed
+            if self.rect.centery > player.rect.centery:
+                self.rect.centery -= self.speed
+            self.start_time = time.time()
+
+        if self.rect.centerx != self.dest_x or self.rect.centery != self.dest_y:
+            if self.Tank > 0:
+                self.Tank -= 0.1
+            self.angle = get_angle((self.rect.centerx, self.rect.centery), (self.dest_x, self.dest_y)) - 90
+
+        self.rotor.update(self)
+
+    def draw(self, win):
+        rotated_image = pygame.transform.rotate(self.image, self.angle)
+        rotated_rect = rotated_image.get_rect(center=self.rect.center)
+
+        # debug nicht anrühren
+        # self.angle += 1
+        pygame.draw.rect(win, (255, 0, 0), rotated_rect)
+
+        win.blit(rotated_image, rotated_rect)
+
+        self.rotor.draw(win)

jenkinsfile

@@ -0,0 +1,28 @@
+pipeline {
+  agent {
+    label 'python' // Uses the Jenkins agent with the label 'python'
+  }
+  stages {
+    stage('Build') {
+      steps {
+        bat """
+          @echo off
+          rem Set the path to the workspace directory
+          cd C:/Program Files/jenkins-agent/workspace/TS
+
+          rem Delete the "dist" folder if it exists
+          if exist dist rmdir /s /q dist
+
+          rem Use PyInstaller to compile the Python application into a single executable file
+          python -m PyInstaller --onefile main.py
+
+          rem Move the "resources" folder into the "dist" folder
+          move resources dist
+
+          rem Output a success message
+          echo Resources folder was successfully moved to the dist folder.
+        """
+      }
+    }
+  }
+}

main.py

@@ -5,6 +5,8 @@ import game
 pygame.init()
 win = pygame.display.set_mode((500, 500))
 
+clock = pygame.time.Clock()
+
 # Farben
 white = (255, 255, 255)
 black = (0, 0, 0)
@@ -12,7 +14,7 @@ gray = (128, 128, 128)
 
 # Rechtecke
 start_button = pygame.Rect(100, 100, 100, 50)
-quit_button = pygame.Rect(300, 100, 100, 50)
+quit_button = pygame.Rect(300, 100, 120, 50)
 
 # Schriftart
 font = pygame.font.Font(None, 32)
@@ -30,11 +32,13 @@ while True:
             mouse_pos = event.pos
 
             # Start-Button
-            if start_button.collidepoint(mouse_pos):
+            if start_button.collidepoint(mouse_pos) or \
+                    start_text.get_rect(center=(start_button.x + 50, start_button.y + 25)).collidepoint(mouse_pos):
                 game.start()
 
             # Beenden-Button
-            if quit_button.collidepoint(mouse_pos):
+            if quit_button.collidepoint(mouse_pos) or \
+                    quit_text.get_rect(center=(quit_button.x + 60, quit_button.y + 25)).collidepoint(mouse_pos):
                 pygame.quit()
                 sys.exit()
 
@@ -48,4 +52,5 @@ while True:
     pygame.draw.rect(win, gray, quit_button)
     win.blit(quit_text, (quit_button.x + 10, quit_button.y + 10))
 
+    clock.tick(60)
     pygame.display.update()

object.py

@@ -0,0 +1,51 @@
+import pygame
+
+# Farbe Weiß
+WHITE = (255, 255, 255)
+
+
+class Erz(pygame.sprite.Sprite):
+    def __init__(self, x, y):
+        super().__init__()
+        self.image = pygame.image.load("resources/Erzmine.png").convert_alpha()
+        self.scaled_image = pygame.transform.scale(self.image, (self.image.get_width() / 2, self.image.get_height() / 2))
+        self.rect = self.scaled_image.get_rect(center=(x, y))
+        self.rect.centerx = x
+        self.rect.centery = y
+
+    def draw(self, win):
+        pygame.draw.rect(win, (255, 0, 0), self.rect)
+        win.blit(self.scaled_image, self.rect)
+
+
+
+class Tank(pygame.sprite.Sprite):
+    def __init__(self, x, y):
+        super().__init__()
+        self.image = pygame.image.load("resources/Tank.jpg").convert_alpha()
+        self.scaled_image = pygame.transform.scale(self.image, (self.image.get_width() / 20, self.image.get_height() / 20))
+        self.rect = self.scaled_image.get_rect(center=(x, y))
+        self.rect.centerx = x
+        self.rect.centery = y
+
+    def draw(self, win):
+        pygame.draw.rect(win, (255, 0, 0), self.rect)
+        win.blit(self.scaled_image, self.rect)
+
+
+
+
+class Ziel(pygame.sprite.Sprite):
+    def __init__(self, x, y):
+        super().__init__()
+        self.image = pygame.image.load("resources/Ziel.jpg").convert_alpha()
+        self.scaled_image = pygame.transform.scale(self.image, (self.image.get_width() / 3, self.image.get_height() / 3))
+        self.rect = self.scaled_image.get_rect(center=(x, y))
+        self.rect.centerx = x
+        self.rect.centery = y
+
+    def draw(self, win):
+        pygame.draw.rect(win, (255, 0, 0), self.rect)
+        win.blit(self.scaled_image, self.rect)
+
+

player.py

@@ -1,36 +1,61 @@
 import pygame
-import math
+from fahrzeug import Fahrzeug
 
-class Player(pygame.sprite.Sprite):
+class Player(Fahrzeug, pygame.sprite.Sprite):
     def __init__(self, x, y):
-        super().__init__()
-        self.image = pygame.image.load("player.png").convert_alpha()
-        self.rect = self.image.get_rect()
-        self.rect.x = x
-        self.rect.y = y
-        self.speed = 2
+        super().__init__(x, y)
+        self.image = pygame.image.load("resources/player.png").convert_alpha()
+        self.image = pygame.transform.scale(self.image, (self.image.get_width()/1.2, self.image.get_height()/1.2))
+        self.rect = self.image.get_rect(center=(x, y))
+        self.rect.centerx = x
+        self.rect.centery = y
+        self.speed = 1
         self.dest_x = x
         self.dest_y = y
-        self.direction = pygame.math.Vector2(1, 0)
+        self.direction = pygame.math.Vector2(0, -1)
+        self.angle = 0
+        self.Tank = 250
+        self.Erz = 0
+
 
     def draw(self, win):
-        win.blit(self.image, self.rect)
+        rotated_image = pygame.transform.rotate(self.image, self.angle)
+        rotated_rect = rotated_image.get_rect(center=self.rect.center)
 
-    def update(self):
-        if self.rect.x < self.dest_x:
-            self.rect.x += self.speed
-        if self.rect.x > self.dest_x:
-            self.rect.x -= self.speed
-        if self.rect.y < self.dest_y:
-            self.rect.y += self.speed
-        if self.rect.y > self.dest_y:
-            self.rect.y -= self.speed
+        #debug, nicht anrühren
+        #self.angle += 1
+        pygame.draw.rect(win, (255, 0, 0), rotated_rect)
 
-        direction = pygame.math.Vector2(self.dest_x - self.rect.centerx, self.dest_y - self.rect.centery)
-        angle = -math.degrees(math.atan2(direction.y, direction.x))
-        self.image = pygame.transform.rotate(self.image, angle)
-        self.rect = self.image.get_rect(center=self.rect.center)
-        self.direction = direction.normalize()
+        win.blit(rotated_image, rotated_rect)
+
+    def move(self):
+        if self.Tank > 0:
+            if self.rect.centerx < self.dest_x:
+                self.rect.centerx += self.speed
+            if self.rect.centerx > self.dest_x:
+                self.rect.centerx -= self.speed
+            if self.rect.centery < self.dest_y:
+                self.rect.centery += self.speed
+            if self.rect.centery > self.dest_y:
+                self.rect.centery -= self.speed
+
+            keys = pygame.key.get_pressed()
+            if keys[pygame.K_LEFT]:
+                self.rect.centerx -= self.speed
+                self.dest_x -= self.speed
+                self.angle = 90
+            if keys[pygame.K_RIGHT]:
+                self.rect.centerx += self.speed
+                self.dest_x += self.speed
+                self.angle = 270
+            if keys[pygame.K_UP]:
+                self.rect.centery -= self.speed
+                self.dest_y -= self.speed
+                self.angle = 0
+            if keys[pygame.K_DOWN]:
+                self.rect.centery += self.speed
+                self.dest_y += self.speed
+                self.angle = 180
 
     def dest(self, pos):
-        self.dest_x, self.dest_y = pos
+        self.dest_x, self.dest_y = pos

rotor.py

@@ -0,0 +1,32 @@
+import pygame
+import helicopter
+from fahrzeug import Fahrzeug
+
+class Rotor(Fahrzeug, pygame.sprite.Sprite):
+    def __init__(self, x, y):
+        super().__init__(x, y)
+        self.image = pygame.image.load("resources/helicopter.jpg").convert_alpha()
+        self.image = self.image.subsurface(132, 98, 94, 94)
+        self.rect = self.image.get_rect(center=(x, y))
+
+
+    def update(self, helicopter):
+        self.rect.center = helicopter.rect.center
+        if helicopter.angle == 0:
+            self.rect.centery -= 10
+        if helicopter.angle == 90:
+            self.rect.centerx -= 10
+        if helicopter.angle == 180:
+            self.rect.centery += 10
+        if helicopter.angle == 270:
+            self.rect.centerx += 10
+
+    def draw(self, win):
+        rotated_image = pygame.transform.rotate(self.image, self.angle)
+        rotated_rect = rotated_image.get_rect(center=self.rect.center)
+
+        #debug, nicht anrühren
+        self.angle += 1
+        #pygame.draw.rect(win, (255, 0, 0), rotated_rect)
+
+        win.blit(rotated_image, rotated_rect)

tilemap.py

@@ -0,0 +1,18 @@
+import pygame
+class tilemap(pygame.sprite.Sprite):
+    def __init__(self):
+        super().__init__()
+        self.image = pygame.image.load("resources/roads2W.png").convert_alpha()
+        self.scaled_image = pygame.transform.scale(self.image, (self.image.get_width()*4, self.image.get_height()*4))
+        self.rect = self.image.get_rect()
+        self.rect = 0, 0
+        self.tilesize = self.scaled_image.get_width()/8
+        self.road_quer = self.scaled_image.subsurface((self.scaled_image.get_width()/8)*2, 0, self.scaled_image.get_height()/3, self.scaled_image.get_width()/8)
+        self.road_senkrecht = self.scaled_image.subsurface((self.scaled_image.get_width()/8)*3,  0, self.scaled_image.get_height()/3, self.scaled_image.get_width()/8)
+        self.road_btr = self.scaled_image.subsurface((self.scaled_image.get_width()/8)*0, (self.scaled_image.get_height()/3)*1, self.scaled_image.get_height()/3, self.scaled_image.get_width()/8)
+        self.road_tbr = pygame.transform.flip(self.scaled_image.subsurface((self.scaled_image.get_width()/8)*2, (self.scaled_image.get_height()/3)*1, self.scaled_image.get_height()/3, self.scaled_image.get_width()/8), True, False)
+        self.map_array = [[2, 0, 0, 0, 0],
+                            [1, 0, 0, 0, 0],
+                            [3, 0, 0, 0, 0],
+                            [1, 0, 0, 0, 0],
+                            [0, 0, 0, 0, 0]]