pygame malware

Author: joshuaepstein

.gitignore

@@ -0,0 +1,2 @@
+**/.vscode
+**/__pycache__

Malware_Game/.gitignore

@@ -0,0 +1,2 @@
+.vscode
+__pycache__

Malware_Game/AssetsLibrary.py

@@ -0,0 +1,12 @@
+# export a dictionary which stores the assets used for the backgrounds
+
+backgrounds = {
+    0: "assets/0-20 Percent Health.png",
+    20: "assets/20-40 Percent Health.png",
+    40: "assets/40-60 Percent Health.png",
+    60: "assets/60-80 Percent Health.png",
+    80: "assets/80-100 Percent Health.png",
+    100: "assets/80-100 Percent Health.png"
+}
+
+decoderPath = "assets/decoder.png"

Malware_Game/Settings.py

@@ -0,0 +1,13 @@
+# settings should store all of the settings, I want to be able to do Settings.speed, Settings.width, Settings.height, etc.
+
+Settings = {
+    "speed": 1,
+    "backgrounds": [
+        "assets/backgrounds/100.png",
+        "assets/backgrounds/80.png",
+        "assets/backgrounds/60.png",
+        "assets/backgrounds/40.png",
+        "assets/backgrounds/20.png",
+        "assets/backgrounds/0.png"
+    ]
+}

Malware_Game/assets/0-20 Percent Health.png

@@ -0,0 +1,105 @@
+import random
+import pygame
+from AssetsLibrary import decoderPath
+
+class Decoder:
+    def __init__(self, x, y, screen, level):
+        self.x = x
+        self.y = y
+        self.screen = screen
+        self.health = 10
+        self.size = 50
+        self.level = level
+        self.rotation = 0
+        self.cooldown = 0
+        
+    def drawImage(self):
+        image = self.health > 0 and pygame.image.load(decoderPath) or pygame.image.load("assets/decoder-dead.png")
+        image = pygame.transform.scale(image, (self.size, self.size))
+        image = pygame.transform.rotate(image, self.rotation)
+        # opacity should be 255 - if there is a cooldown then it should increase opacity until the cooldown is over
+        opacity = (self.cooldown > 0 and self.health > 0) and 255 - self.cooldown * 2 or 255
+        image.set_alpha(opacity)
+        self.screen.blit(image, (self.x, self.y))
+        self.cooldown -= 0.5
+        
+    def draw(self):
+        self.drawImage()
+        
+    def move(self, x, y):
+        self.x += x
+        self.y += y
+        
+    def remove(self):
+        self.health = 0
+        self.x = -100
+        self.y = -100
+        
+    def getHealth(self):
+        return self.health
+    
+    def getSize(self):
+        return self.size
+    
+    def getLevel(self):
+        return self.level
+    
+    def setLevel(self, level):
+        self.level = level
+        return self
+    
+    def getX(self):
+        return self.x
+    
+    def getY(self):
+        return self.y
+    
+    def setX(self, x):
+        self.x = x
+        return self
+    
+    def setY(self, y):
+        self.y = y
+        return self
+    
+    def getRect(self):
+        return pygame.Rect(self.x, self.y, self.size, self.size)
+    
+    def getRotation(self):
+        return self.rotation
+    
+    def getCenter(self):
+        return (self.x + self.size / 2, self.y + self.size / 2)
+    
+    def getDistance(self, other):
+        return ((self.getCenter()[0] - other.getCenter()[0]) ** 2 + (self.getCenter()[1] - other.getCenter()[1]) ** 2) ** 0.5
+    
+    def shoot(self, malwares): # malwares is a list of malware objects
+        if self.health <= 0:
+            return
+        if self.cooldown > 0:
+            return
+        nearestMalware = None
+        for malware in malwares:
+            if nearestMalware == None:
+                nearestMalware = malware
+            elif self.getDistance(malware) < self.getDistance(nearestMalware):
+                nearestMalware = malware
+        if nearestMalware != None:
+            if self.getDistance(nearestMalware) < 150:
+                self.shootAt(malwares, nearestMalware)
+
+    def shootAt(self, malwares, malware):
+        if self.health <= 0:
+            return
+        if self.cooldown > 0:
+            return
+        pygame.draw.line(self.screen, (255, 50, 50), self.getCenter(), malware.getCenter(), 5)
+        
+        if self.cooldown <= 0:
+            self.cooldown = 120
+        malware.health -= 1
+        self.health -= 1
+        if malware.health <= 0:
+            malware.remove()
+            malwares.remove(malware)

Malware_Game/assets/20-40 Percent Health.png

@@ -0,0 +1,144 @@
+import random
+import pygame
+from malware import Malware
+from AssetsLibrary import backgrounds
+from decoder import Decoder
+
+# pygame setup
+pygame.init()
+screen = pygame.display.set_mode((1280, 720))
+pygame.display.set_caption("The Malware Game")
+pygame.display.set_icon(pygame.image.load("assets/icon.png"))
+pygame.mouse.set_visible(False)
+
+clock = pygame.time.Clock()
+running = True
+lastClickedKeybind = "None"
+malwares = []
+cpuHealth = 100
+level = 1
+decoders = []
+
+def chanceOfSpawningMalware():
+    return level / 100
+
+def shouldSpawnMalware():
+    return random.random() < chanceOfSpawningMalware()
+
+def checkIfAndSpawnMalware():
+    if shouldSpawnMalware():
+        malwares.append(Malware(151, 675, screen))
+
+def drawSidebar():
+    sidebarWidth = screen.get_width() / 4
+    sidebarHeight = screen.get_height()
+    sidebar = pygame.Rect(screen.get_width() - sidebarWidth, 0, sidebarWidth, sidebarHeight)
+    sidebarColor = pygame.Color("black")
+    pygame.draw.rect(screen, sidebarColor, sidebar)
+    
+    pygame.font.init()
+    font = pygame.font.SysFont('Arial', 30)
+    text = font.render("CPU Health: " + str(cpuHealth) + "%", False, (255, 255, 255))
+    screen.blit(text, (sidebar.x + 20, sidebar.y + 20))
+    
+    levelFont = pygame.font.SysFont("Arial", 25)
+    subtitle = pygame.font.SysFont("Arial", 20)
+    levelText = levelFont.render("Level " + str(level), False, (255, 255, 255))
+    screen.blit(levelText, (sidebar.x + 20, sidebar.y + 60))
+    
+    selectYourDecoderText = subtitle.render("Select Your Decoder", False, (200, 200, 200))
+    screen.blit(selectYourDecoderText, (sidebar.x + 20, sidebar.y + 90))
+    
+    decoderOpacity = len(decoders) >= 5 and 100 or 255
+    decoderPath = "assets/decoder.png"
+    decoderImage = pygame.image.load(decoderPath)
+    decoderImage = pygame.transform.scale(decoderImage, (50, 50))
+    decoderImage.set_alpha(decoderOpacity)
+    screen.blit(decoderImage, (sidebar.x + 20, sidebar.y + 110))
+
+cursorPosition = [0, 0]
+clickedDecoder = False
+alert = {
+    "time": 0,
+    "message": ""
+}
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+        elif event.type == pygame.KEYDOWN:
+            lastClickedKeybind = pygame.key.name(event.key)
+        
+            
+    checkIfAndSpawnMalware()
+
+    screen.fill("white")
+    if cpuHealth <= 0:
+        cpuHealth = 0
+        running = False
+    
+    current_background = backgrounds[cpuHealth // 20 * 20]
+    screen.blit(pygame.image.load(current_background), (0, 0))
+
+    drawSidebar()
+    
+    for malware in malwares:
+        malware.draw()
+        malware.move()
+        if malware.y < -20:
+            malware.remove()
+            cpuHealth -= 1
+            malwares.remove(malware)
+
+    for decoder in decoders:
+        decoder.shoot(malwares)
+        decoder.draw()
+            
+    mousePosition = pygame.Vector2(pygame.mouse.get_pos())
+    for malware in malwares:
+        if malware.getRect().collidepoint(mousePosition):
+            malware.remove()
+            malwares.remove(malware)
+
+    # to render over everything else
+    for event in pygame.event.get():
+        if event.type == pygame.MOUSEMOTION:
+            cursorPosition = event.pos
+        elif event.type == pygame.MOUSEBUTTONDOWN:
+            if len(decoders) < 5:
+                if clickedDecoder:
+                    clickedDecoder = False
+                    decoders.append(Decoder(cursorPosition[0] - 25, cursorPosition[1] - 25, screen, level))
+                if pygame.Rect(screen.get_width() - screen.get_width() / 4 + 20, 110, 50, 50).collidepoint(event.pos):
+                    clickedDecoder = True
+            elif pygame.Rect(screen.get_width() - screen.get_width() / 4 + 20, 110, 50, 50).collidepoint(event.pos):
+                alert = {
+                    "time": 60 * 3,
+                    "message": "You can only have 5 decoders!"
+                }
+
+
+    
+    if not clickedDecoder:
+        cursorPath = "assets/cursor.png" # w=12 h=19
+        cursorImage = pygame.image.load(cursorPath)
+        cursorImage = pygame.transform.scale(cursorImage, (12, 19))
+        screen.blit(cursorImage, (cursorPosition[0], cursorPosition[1]))
+    else:
+        cursorPath = "assets/decoder.png"
+        cursorImage = pygame.image.load(cursorPath)
+        cursorImage = pygame.transform.scale(cursorImage, (50, 50))
+        screen.blit(cursorImage, (cursorPosition[0] - 25, cursorPosition[1] -25))
+
+    if alert["time"] > 0:
+        alert["time"] -= 1
+        alertFont = pygame.font.SysFont("Arial", 20)
+        alertText = alertFont.render(alert["message"], False, (255, 255, 255))
+        screen.blit(alertText, (screen.get_width() - screen.get_width() / 4 + 20, 170))
+
+    # flip() the display to put your work on screen
+    pygame.display.flip()
+
+    clock.tick(60)  # limits FPS to 60
+
+pygame.quit()

Malware_Game/assets/40-60 Percent Health.png

@@ -0,0 +1,67 @@
+# object for malware
+
+import random
+import pygame
+from Settings import Settings
+
+
+class Malware:
+    # Store the x, y, and rectangle from pygame, also store the health: 1-10
+    def __init__(self, x, y, screen):
+        self.x = x
+        self.y = y
+        self.screen = screen
+        self.rect = pygame.Rect(self.x, self.y, 20, 20)
+        self.health = random.randint(1, 2) == 1 and random.randint(1, 2) or 1
+        self.size = 20
+        self.aliveTime = 0 
+        
+    def draw(self):
+        color = self.health > 1 and (255, 0, 0) or (0, 0, 0)
+        scale = min(20, self.aliveTime * 0.1 + 20)
+        self.rect.width = scale
+        self.rect.height = scale
+        self.rect.x = self.x - scale / 2
+        self.rect.y = self.y - scale / 2
+        shape = pygame.draw.rect(self.screen, color, self.rect)
+        self.aliveTime += 1
+
+    def move(self):
+        # we want it to follow a path, it should start at 151, 675 - then go up to 151, 545. Once at this point it should go to 777, 545, then up to 777, 415, then to 256, 415, then to 253, 415, then to 253, 270, then finally 854, 260.
+        if self.x == 151 and self.y > 545:
+            self.y -= Settings["speed"] 
+        elif self.x < 777 and self.y == 545:
+            self.x += Settings["speed"] 
+        elif self.x == 777 and self.y > 415:
+            self.y -= Settings["speed"] 
+        elif self.x > 256 and self.y == 415:
+            self.x -= Settings["speed"] 
+        elif self.x == 256 and self.y > 270:
+            self.y -= Settings["speed"] 
+        elif self.x == 253 and self.y > 260:
+            self.y -= Settings["speed"] 
+        elif self.x < 854 and self.y == 260:
+            self.x += Settings["speed"] 
+        elif self.x == 854 and self.y > 80:
+            self.y -= Settings["speed"] 
+        # then reduce the x between 854 and 50 - and then just reduce the y
+        elif self.x > 50 and self.y == 80:
+            self.x -= Settings["speed"] 
+        else:
+            self.y -= Settings["speed"]        
+            
+        self.rect.x = self.x
+        self.rect.y = self.y
+        
+    def remove(self):
+        self.health = 0
+        self.x = -100
+        self.y = -100
+        self.rect.x = self.x
+        self.rect.y = self.y
+        
+    def getRect(self):
+        return self.rect
+    
+    def getCenter(self):
+        return (self.x + self.size / 2, self.y + self.size / 2)