Das deutsche Python-Forum

Code: Alles auswählen

import pygame
import sys
import random

pygame.init()
pygame.font.init()

SCREEN_WIDTH, SCREEN_HEIGHT = 1280, 720
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Breed96 - Linux Port v7.0")
clock = pygame.time.Clock()

# Farben
COLOR_DESERT, COLOR_TEXT, COLOR_UI_BG = (194, 131, 62), (255, 255, 255), (30, 30, 40)
COLOR_GRID, COLOR_RED, COLOR_GOLD, COLOR_HIGHLIGHT, COLOR_GREY = (174, 111, 42), (220, 50, 50), (255, 215, 0), (0, 255, 255), (120, 120, 130)
COLOR_DOME, COLOR_MINE, COLOR_POWER, COLOR_ROAD = (0, 200, 100), (60, 60, 80), (220, 180, 0), (100, 65, 35)
COLOR_HOUSE, COLOR_INDUSTRY, COLOR_SHOP, COLOR_LAB = (180, 60, 160), (230, 90, 40), (0, 160, 220), (150, 0, 250)
COLOR_OBS, COLOR_YARD = (0, 255, 180), (200, 50, 50)

# Spielvariablen
resources = {"Nahrung": 200, "Erz": 300, "Energie": 200, "Forschung": 0}
unlocked_techs = {"Observatorium": False, "Werft": False, "Orbiter_Erforscht": False, "Orbiter_Gebaut": False}
citizens, tax_rate = 50, 10

fleet = {
    "Leichter Gleiter": {"count": 0, "cost": {"Erz": 150, "Energie": 50}},
    "Schwerer Gleiter": {"count": 0, "cost": {"Erz": 300, "Energie": 100}},
    "Transportschiff": {"count": 0, "cost": {"Erz": 400, "Energie": 150}},
    "Abbauschiff": {"count": 0, "cost": {"Erz": 350, "Energie": 200}},
    "Kolonieschiff": {"count": 0, "cost": {"Erz": 800, "Energie": 400}},
    "Schlachtkreuzer": {"count": 0, "cost": {"Erz": 1200, "Energie": 600}}
}

asteroid_discovered, asteroid_ore_left = False, 0
space_log = "STATION AKTIV. Warte auf Orbiter..."
current_tab, game_state, tick_counter = "MAP", "PLAYING", 0
current_mode = 1

buildings = {
    1: {"name": "Kuppel", "list": [], "cost": {"N": 20, "E": 40, "P": 10}, "color": COLOR_DOME},
    2: {"name": "Erzmine", "list": [], "cost": {"N": 40, "E": 20, "P": 20}, "color": COLOR_MINE},
    3: {"name": "Kraftwerk", "list": [], "cost": {"N": 10, "E": 60, "P": 0}, "color": COLOR_POWER},
    4: {"name": "Strasse", "list": [], "cost": {"N": 0, "E": 5, "P": 0}, "color": COLOR_ROAD},
    5: {"name": "Wohnhaus", "list": [], "cost": {"N": 10, "E": 30, "P": 15}, "color": COLOR_HOUSE},
    6: {"name": "Industrie", "list": [], "cost": {"N": 30, "E": 80, "P": 30}, "color": COLOR_INDUSTRY},
    7: {"name": "Mall", "list": [], "cost": {"N": 50, "E": 100, "P": 25}, "color": COLOR_SHOP},
    8: {"name": "Forschung", "list": [], "cost": {"N": 40, "E": 150, "P": 40}, "color": COLOR_LAB},
    9: {"name": "Observat.", "list": [], "cost": {"N": 60, "E": 200, "P": 60}, "color": COLOR_OBS},
    10: {"name": "Werft", "list": [], "cost": {"N": 100, "E": 400, "P": 100}, "color": COLOR_YARD}
}

font = pygame.font.SysFont("Courier", 12, bold=True)
large_font = pygame.font.SysFont("Courier", 32, bold=True)

def has_road_connection(pos):
    neighbors = [(pos[0]-40, pos[1]), (pos[0]+40, pos[1]), (pos[0], pos[1]-40), (pos[0], pos[1]+40)]
    for n in neighbors:
        if n in buildings[4]["list"]: return True
    return False

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                running = False
            
            if game_state in ["PLAYING", "VICTORY"]:
                if event.key == pygame.K_F1: current_tab = "MAP"
                elif event.key == pygame.K_F2: current_tab = "ECONOMY"
                elif event.key == pygame.K_F3: current_tab = "RESEARCH"
                elif event.key == pygame.K_F4: current_tab = "SPACE"

            if game_state == "PLAYING" and current_tab == "ECONOMY":
                if event.key == pygame.K_UP and tax_rate < 30: tax_rate += 1
                elif event.key == pygame.K_DOWN and tax_rate > 0: tax_rate -= 1

            if game_state == "PLAYING":
                if current_tab == "MAP":
                    if pygame.K_1 <= event.key <= pygame.K_7: current_mode = event.key - pygame.K_1 + 1
                    elif event.key == pygame.K_8: current_mode = 8
                    elif event.key == pygame.K_9: current_mode = 9
                    elif event.key == pygame.K_0: current_mode = 10
                elif current_tab == "SPACE":
                    if event.key == pygame.K_f and len(buildings[10]["list"]) > 0 and resources["Forschung"] >= 500 and not unlocked_techs["Orbiter_Erforscht"]:
                        resources["Forschung"] -= 500
                        unlocked_techs["Orbiter_Erforscht"] = True
                        space_log = "Orbiter erforscht! Baue ihn mit [B]."
                    elif event.key == pygame.K_b and unlocked_techs["Orbiter_Erforscht"] and len(buildings[10]["list"]) > 0 and resources["Erz"] >= 800 and resources["Energie"] >= 400 and not unlocked_techs["Orbiter_Gebaut"]:
                        resources["Erz"] -= 800
                        resources["Energie"] -= 400
                        unlocked_techs["Orbiter_Gebaut"] = True
                        space_log = "Orbiter gebaut! Starte ihn mit [S]."
                    elif event.key == pygame.K_s and unlocked_techs["Orbiter_Gebaut"] and len(buildings[10]["list"]) > 0:
                        space_log = "ORBITER GESTARTET! Endlosmodus aktiv."
                    
                    if unlocked_techs["Orbiter_Gebaut"]:
                        if event.key == pygame.K_a and resources["Erz"] >= 150 and resources["Energie"] >= 50:
                            resources["Erz"] -= 150; resources["Energie"] -= 50; fleet["Leichter Gleiter"]["count"] += 1
                        elif event.key == pygame.K_b and resources["Erz"] >= 300 and resources["Energie"] >= 100:
                            resources["Erz"] -= 300; resources["Energie"] -= 100; fleet["Schwerer Gleiter"]["count"] += 1

            if game_state != "PLAYING" and event.key == pygame.K_SPACE:
                resources = {"Nahrung": 200, "Erz": 300, "Energie": 200, "Forschung": 0}
                unlocked_techs = {"Observatorium": False, "Werft": False, "Orbiter_Erforscht": False, "Orbiter_Gebaut": False}
                citizens, tax_rate, current_tab, game_state = 50, 10, "MAP", "PLAYING"
                for m in buildings: buildings[m]["list"] = []

        elif event.type == pygame.MOUSEBUTTONDOWN and game_state == "PLAYING" and current_tab == "MAP":
            mouse_x, mouse_y = pygame.mouse.get_pos()
            if mouse_y < 520:
                if not ((current_mode == 9 and not unlocked_techs["Observatorium"]) or (current_mode == 10 and not unlocked_techs["Werft"])):
                    b_data = buildings[current_mode]
                    if resources["Nahrung"] >= b_data["cost"]["N"] and resources["Erz"] >= b_data["cost"]["E"] and resources["Energie"] >= b_data["cost"]["P"]:
                        grid_x, grid_y = (mouse_x // 40) * 40 + 20, (mouse_y // 40) * 40 + 20
                        pos = (grid_x, grid_y)
                        occupied = any(pos in buildings[m]["list"] for m in buildings)
                        has_buildings = any(len(buildings[m]["list"]) > 0 for m in buildings)
                        adjacent_to_road = True if (current_mode == 4 or not has_buildings) else has_road_connection(pos)
                        if not occupied and adjacent_to_road:
                            resources["Nahrung"] -= b_data["cost"]["N"]
                            resources["Erz"] -= b_data["cost"]["E"]
                            resources["Energie"] -= b_data["cost"]["P"]
                            b_data["list"].append(pos)

    # Wirtschaftsticks
    if game_state == "PLAYING":
        if resources["Forschung"] >= 100: unlocked_techs["Observatorium"] = True
        if resources["Forschung"] >= 300: unlocked_techs["Werft"] = True
        tick_counter += 1
        if tick_counter >= 60:
            tick_counter = 0
            resources["Nahrung"] += 2; resources["Erz"] += 2; resources["Energie"] += 5
            
            resources["Nahrung"] += len(buildings[1]["list"]) * 8
            resources["Erz"] += len(buildings[2]["list"]) * 12
            resources["Energie"] += len(buildings[3]["list"]) * 18
            
            max_citizens = len(buildings[5]["list"]) * 15 + 20
            citizens = min(citizens + 2 if citizens < max_citizens else citizens, max_citizens)
            resources["Erz"] += len(buildings[5]["list"]) * int(tax_rate / 5)
            resources["Erz"] += len(buildings[6]["list"]) * 35
            resources["Forschung"] += len(buildings[8]["list"]) * 15 + len(buildings[9]["list"]) * 5
            
            if not asteroid_discovered and random.randint(1, 50) == 1:
                asteroid_discovered, asteroid_ore_left = True, random.randint(800, 1500)
                space_log = f"ASTEROID! Vorkommen: {asteroid_ore_left} Erz."
            
            if asteroid_discovered and fleet["Abbauschiff"]["count"] > 0:
                abbau = min(fleet["Abbauschiff"]["count"] * 15, asteroid_ore_left)
                asteroid_ore_left -= abbau; resources["Erz"] += abbau
                if asteroid_ore_left <= 0: asteroid_discovered = False
            
            if resources["Nahrung"] < 0 or resources["Erz"] < 0 or resources["Energie"] < 0: game_state = "GAME_OVER"

    # Rendering
    screen.fill(COLOR_DESERT)
    if current_tab == "MAP":
        for x in range(0, SCREEN_WIDTH, 40): pygame.draw.line(screen, COLOR_GRID, (x, 0), (x, 520))
        for y in range(0, 520, 40): pygame.draw.line(screen, COLOR_GRID, (0, y), (SCREEN_WIDTH, y))
        for r in buildings[4]["list"]: pygame.draw.rect(screen, COLOR_ROAD, (r[0]-20, r[1]-20, 40, 40))
        for d in buildings[1]["list"]: pygame.draw.circle(screen, COLOR_DOME, d, 16)
        for m in buildings[2]["list"]: pygame.draw.rect(screen, COLOR_MINE, (m[0]-15, m[1]-15, 30, 30))
        for p in buildings[3]["list"]: pygame.draw.polygon(screen, COLOR_POWER, [(p[0], p[1]-15), (p[0]-15, p[1]+15), (p[0]+15, p[1]+15)])
        for house in buildings[5]["list"]: pygame.draw.rect(screen, COLOR_HOUSE, (house[0]-14, house[1]-8, 28, 22))
        for i in buildings[6]["list"]: pygame.draw.rect(screen, COLOR_INDUSTRY, (i[0]-16, i[1]-6, 32, 20))
        for s in buildings[7]["list"]: pygame.draw.ellipse(screen, COLOR_SHOP, (s[0]-18, s[1]-12, 36, 24))
        for l in buildings[8]["list"]:
            pygame.draw.rect(screen, COLOR_LAB, (l[0]-15, l[1]-15, 30, 30))
            pygame.draw.circle(screen, COLOR_HIGHLIGHT, l, 6)
        for o in buildings[9]["list"]:
            pygame.draw.circle(screen, COLOR_OBS, o, 14)
            pygame.draw.line(screen, COLOR_TEXT, o, (o[0]+16, o[1]-16), 4)
        for y in buildings[10]["list"]: pygame.draw.rect(screen, COLOR_YARD, (y[0]-18, y[1]-18, 36, 36), 3)
    elif current_tab == "ECONOMY":
        pygame.draw.rect(screen, (20, 20, 30), (40, 40, SCREEN_WIDTH-80, 440))
        screen.blit(large_font.render("WIRTSCHAFTS-TERMINAL", True, COLOR_HIGHLIGHT), (80, 70))
        screen.blit(font.render(f"Kolonisten: {citizens} | Steuern: {tax_rate}% (Pfeiltasten)", True, COLOR_TEXT), (80, 160))
    elif current_tab == "RESEARCH":
        pygame.draw.rect(screen, (30, 20, 40), (40, 40, SCREEN_WIDTH-80, 440))
        screen.blit(large_font.render("TECHNOLOGIE-DATENBANK", True, COLOR_LAB), (80, 70))
        screen.blit(font.render(f"Observatorium: {unlocked_techs['Observatorium']} | Werft: {unlocked_techs['Werft']}", True, COLOR_TEXT), (80, 160))
    elif current_tab == "SPACE":
        pygame.draw.rect(screen, (10, 25, 35), (40, 40, SCREEN_WIDTH-80, 440))
        screen.blit(large_font.render("ORBITAL-KONTROLLE", True, COLOR_OBS), (80, 70))
        screen.blit(font.render(f"LOG: {space_log}", True, COLOR_GOLD), (80, 160))
        screen.blit(font.render(f"Gleiter L: {fleet['Leichter Gleiter']['count']} | Gleiter S: {fleet['Schwerer Gleiter']['count']}", True, COLOR_TEXT), (80, 200))

    # UI unten
    pygame.draw.rect(screen, COLOR_UI_BG, (0, 520, SCREEN_WIDTH, 200))
    res_text = f"NAHRUNG: {resources['Nahrung']} | ERZ: {resources['Erz']} | ENERGIE: {resources['Energie']} | FORSCHUNG: {resources['Forschung']} | TABs: F1-F4"
    screen.blit(font.render(res_text, True, COLOR_TEXT), (40, 530))
    if current_tab == "MAP":
        for i in range(1, 11):
            screen.blit(font.render(f"[{i%10}] {buildings[i]['name']}", True, COLOR_TEXT), (40 + ((i-1) * 120), 560))

    if game_state == "GAME_OVER":
        overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT), pygame.SRCALPHA)
        overlay.fill((0, 0, 0, 220))
        screen.blit(overlay, (0, 0))
        screen.blit(large_font.render("KOLONIE KOLLABIERT! [LEERTASTE]", True, COLOR_RED), (400, 250))

    pygame.display.flip()
    clock.tick(60)

pygame.quit()
sys.exit()

Code: Alles auswählen

from dataclasses import dataclass
from typing import Self


@dataclass
class Resources:
    food: int = 0
    ore: int = 0
    energy: int = 0
    science: int = 0

    def __add__(self, other: "Resources") -> Self:
        if isinstance(other, Resources):
            return Resources(
                food=self.food + other.food,
                ore=self.ore + other.ore,
                energy=self.energy + other.energy,
                science=self.science + other.science
            )
        return NotImplemented

    def __iadd__(self, other: "Resources") -> Self:
        if isinstance(other, Resources):
            temp = self + other
            self.energy = temp.energy
            self.food = temp.food
            self.ore = temp.ore
            self.science = temp.science
            return self
        return NotImplemented

    def __sub__(self, other: "Resources") -> Self:
        if isinstance(other, Resources):
            return Resources(
                food=self.food - other.food,
                ore=self.ore - other.ore,
                energy=self.energy - other.energy,
                science=self.science - other.science
            )
        return NotImplemented

    def __isub__(self, other: "Resources") -> Self:
        if isinstance(other, Resources):
            temp = self - other
            self.energy = temp.energy
            self.food = temp.food
            self.ore = temp.ore
            self.science = temp.science
            return self
        return NotImplemented
    def __ge__(self, other: "Resources") -> bool:
        if isinstance(other, Resources):
            return (
                self.energy >= other.energy and
                self.food >= other.food and
                self.ore >= other.ore and
                self.science >= other.science
            )
        return NotImplemented

    def __le__(self, other: "Resources") -> bool:
        if isinstance(other, Resources):
            return (
                self.energy >= other.energy and
                self.food >= other.food and
                self.ore >= other.ore and
                self.science >= other.sicence
            )
        return NotImplemented


def main():
    player_resources = Resources(400, 400, 400, 0)
    gain_science = Resources(science=20)
    build_cost = Resources(140, 200, 0, 0)

    player_resources += gain_science
    print(f"Nach Einkommen: {player_resources}")

    if player_resources >= build_cost:
        player_resources -= build_cost
        print("Bau erfolgreich!")
    else:
        print("Nicht genug Ressourcen!")

    print(f"Ende: {player_resources}")


if __name__ == '__main__':
    main()

Code: Alles auswählen

#!/usr/bin/env python
from dataclasses import dataclass, field
from resources import Resources


@dataclass(frozen=True)
class Ship:
    name: str,
    costs: Resources


@dataclass
class Fleet:
    ships: dict[Ship, int] = field(default_factory=dict)

    def add_ship(self, ship: Ship) -> None:
        self.ships[ship] = self.ships.get(ship, 0) + 1

    def get_amount(self, ship: Ship) -> int:
        return self.ships.get(ship, 0)


SHIP_TYPES = (
        Ship("Leichter Gleiter", Resources(ore=150, energy=50)),
        Ship("Schwerer Gleiter", Resources(ore=300, energy=100)),
        Ship("Transportschiff", Resources(ore=400, energy=150)),
        Ship("Abbauschiff", Resources(ore=350, energy=200)),
        Ship("Kolonieschiff", Resources(ore=800, energy=400)),
        Ship("Schlachtkreuzer", Resources(ore=1200, energy=600)),
)

Code: Alles auswählen

from enum import Flag, auto
from resources import Resources
from ships import Ship, Fleet

class Tech(Flag):
    NONE = 0
    OBSERVATORY = auto()
    SHIPYARD = auto()
    ORBITER_RESEARCHED = auto()
    ORBITER_BUILT = auto()


class Player:

    def __init__(self):
        self.account = Resources(
                food=200,
                ore=300,
                energy= 200,
        )
        self.fleet = Fleet()
        self.citizens = 50
        self._tax_rate = 10
        self.unlocked_techs: Tech = Tech.NONE
        
    def build_a_ship(self, ship: Ship) -> bool:
        if self.account >= ship.costs:
            self.account -= ship.costs
            self.fleet.add_ship(ship)
            return True
        return False

    @property
    def tax_rate(self) -> int:
        return self._tax_rate

    @tax_rate.setter
    def tax_rate(self, value: int) -> None:
        """
        set the tax_rate and clipp value between 0-30
        """
        self.tax_rate = max(0, min(value, 30))