Skip to content
BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

3 Commits
README.md
README.md
 
 

Repository files navigation

Pflichtenheft – Centipede (Mensch gegen PC)

1. Ziel

Browserbasiertes Einzelspieler-Spiel nach dem Arcade-Klassiker Centipede: Mensch steuert die Figur, der PC steuert Gegner (Centipede und weitere).

Muss

  • Steuerbare Spielfigur (unterer Bereich)
  • Centipede mit Bewegung, Teilung und Abstieg
  • Schüsse, Pilze, Punkte, Leben, Game Over
  • Steigender Schwierigkeitsgrad (Level)
  • Start-, Pause- und Game-Over-Bildschirm

Kann

  • Spinne, Floh, Skorpion
  • Highscore (lokal)
  • Sound, Partikel, Schwierigkeitsgrade
  • Gamepad-Steuerung

Nicht enthalten (V1)

  • Mehrspieler, Backend, Mobile-Apps, Level-Editor

2. Team & Aufgaben

Person Verantwortung Module / Themen
Simon R. Engine & Spielzustand Game Loop, Level-Wechsel, Pause/Start/Game Over, Integration
Simon F. Spieler & Eingabe Bewegung, Schüsse, Tastatur/Maus, optional Gamepad
Alex Gegner Centipede (Segmente, Teilung), Spinne, Floh, Skorpion
Bastian Grafik & UI Canvas-Rendering, HUD, Menüs, Partikel/Effekte, CSS
Matthias Systeme & Audio Kollision, Pilze, Punkte/Leben, Highscore, Sound

3. Funktionen (Kurz)

Spieler (Simon F.)

ID Anforderung Prio
F-01 Bewegung mit Pfeiltasten/WASD im unteren Bereich Muss
F-02 Schuss mit Leertaste/Maus nach oben Muss
F-03 Leben verlieren bei Gegnerkontakt Muss
F-04 Game Over nach 0 Leben Muss
F-05 Optional Gamepad Kann

Gegner (Alex)

ID Anforderung Prio
F-10 Centipede aus Segmenten, schlangenartige Bewegung Muss
F-11 Richtungs-/Zeilenwechsel an Pilz oder Rand Muss
F-12 Teilung bei Treffer auf Mittelsegment Muss
F-13 Neuer Kopf nach Kopf-Treffer Muss
F-14 Spinne, Floh, Skorpion Kann
F-15 Geschwindigkeit steigt mit dem Level Muss

Spielfeld (Matthias + Alex)

ID Anforderung Prio
F-20 Raster mit Pilzen Muss
F-21 Pilze beschädigbar / zerstörbar Muss
F-22 Pilzverteilung zu Levelbeginn Muss
F-23 Floh legt neue Pilze Kann

Punkte & Status (Mat5hias + Simon R.)

ID Anforderung Prio
F-30 Punkte für zerstörte Gegner/Segmente Muss
F-31 HUD: Punkte, Leben, Level Muss
F-32 Nächstes Level nach komplettem Centipede Muss
F-34 Highscore lokal speichern Kann

Menüs (Bastian + Simon R.)

ID Anforderung Prio
F-40 Startbildschirm Muss
F-41 Pause (z. B. ESC) Muss
F-42 Game-Over mit Neustart Muss
F-43 Einstellungen (Schwierigkeit, Lautstärke) Kann

4. Technik

  • Stack: HTML5 Canvas, JavaScript (modular), CSS
  • Kein Server; optional LocalStorage für Highscore
  • Ziel: Desktop-Browser (Chrome, Firefox, Edge, Safari)
  • Performance: mind. ~60 FPS, Eingabe ohne spürbare Verzögerung

Modulzuordnung (Ist-Stand)

Modul Zuständig
engine.js, main.js Simon R.
input.js, entities/player.js, entities/projectile.js Simon F.
entities/centipede.js, spider.js, flea.js, skorpion.js Alex
renderer.js, ui.js, particles.js, style.css Bastian
collision.js, audio.js, constants.js (Balance) Matthias

5. Klassendiagramm

Alle erforderlichen Klassen mit Attributen, Methoden, Beziehungen und Kardinalitäten.

classDiagram
  direction TB

  class Engine {
    -state: string
    -score: number
    -level: number
    -highscore: number
    -difficulty: string
    -player: Player
    -centipede: Centipede
    -spider: Spider
    -flea: Flea
    -skorpion: Skorpion
    +init()
    +start()
    -startGame()
    -spawnLevel()
    -nextLevel()
    -gameOver()
    -updateGame(now, dt)
    -checkCollisions(now)
    -render()
    -loadHighscore()
    -saveHighscore()
  }

  class Player {
    +x: number
    +y: number
    +width: number
    +height: number
    +speed: number
    +angle: number
    +projectiles: Projectile[]
    +lives: number
    +alive: boolean
    +invulnerable: boolean
    +reset()
    +update(now, dt)
    +shoot(now)
    +hit() boolean
    +draw(ctx)
    +getBounds() Bounds
  }

  class Projectile {
    +x: number
    +y: number
    +width: number
    +height: number
    +speed: number
    +dx: number
    +dy: number
    +angle: number
    +active: boolean
    +update()
    +draw(ctx)
    +getBounds() Bounds
  }

  class Centipede {
    +segments: CentipedeSegment[]
    +speed: number
    +active: boolean
    +init(level, difficulty)
    +update(dt)
    +removeSegment(index) Result
    +draw(ctx)
    +getSegmentBounds() Bounds[]
  }

  class CentipedeSegment {
    +x: number
    +y: number
    +isHead: boolean
    +active: boolean
    +direction: number
    +moveDir: Vec2
    +size: number
    +getBounds() Bounds
  }

  class Mushroom {
    +x: number
    +y: number
    +hp: number
    +maxHp: number
    +poisoned: boolean
    +active: boolean
    +hit() boolean
    +draw(ctx)
    +getBounds() Bounds
  }

  class Spider {
    +x: number
    +y: number
    +speed: number
    +active: boolean
    +dirX: number
    +dirY: number
    +init(level)
    +update(dt)
    +draw(ctx)
    +getBounds() Bounds
  }

  class Flea {
    +x: number
    +y: number
    +speed: number
    +active: boolean
    +init(level)
    +update(dt)
    +draw(ctx)
    +getBounds() Bounds
  }

  class Skorpion {
    +x: number
    +y: number
    +speed: number
    +active: boolean
    +dirX: number
    +init(level)
    +update(dt)
    +poisonMushroom(mushroom)
    +draw(ctx)
    +getBounds() Bounds
  }

  class Input {
    +init(canvas)
    +isLeft() boolean
    +isRight() boolean
    +isUp() boolean
    +isDown2() boolean
    +isFire() boolean
    +wasEscapePressed() boolean
    +getTouchPos() Pos
    +clearFrame()
  }

  class Renderer {
    +init() Canvas
    +clear()
    +drawGrid()
    +drawPlayerZone()
    +drawHUD(score, lives, level, highscore)
    +drawFlash(color)
    +drawLevelTransition(level, timer)
    +getCtx() Context
  }

  class UI {
    +init()
    +showMenu(highscore)
    +showControls()
    +showSettings(...)
    +showPause()
    +showGameOver(score, highscore, isNew)
    +hide()
  }

  class Collision {
    +rectsOverlap(a, b) boolean
    +checkProjectileCentipede(proj, segs) Segment
    +checkProjectileEnemy(proj, enemy) boolean
    +checkPlayerEnemy(player, enemy) boolean
    +checkPlayerSegment(player, segs) Segment
  }

  class Particles {
    +emit(x, y, color, count, speed, life)
    +update(dt)
    +draw(ctx)
    +clear()
  }

  class Audio {
    +resume()
    +setVolume(v)
    +getVolume() number
    +shoot()
    +destroy()
    +playerHit()
    +levelUp()
    +gameOver()
  }

  Engine "1" --> "1" Player : steuert
  Engine "1" --> "1" Centipede : verwaltet
  Engine "1" --> "0..1" Spider : spawnt
  Engine "1" --> "0..1" Flea : spawnt
  Engine "1" --> "0..1" Skorpion : spawnt
  Engine "1" --> "1" Input : nutzt
  Engine "1" --> "1" Renderer : nutzt
  Engine "1" --> "1" UI : nutzt
  Engine "1" --> "1" Collision : nutzt
  Engine "1" --> "1" Particles : nutzt
  Engine "1" --> "1" Audio : nutzt
  Engine "1" --> "*" Mushroom : verwaltet

  Player "1" --> "*" Projectile : feuert
  Player ..> Input : liest
  Player ..> Audio : spielt
  Player ..> Particles : emit

  Centipede "1" --> "1..*" CentipedeSegment : besteht aus
  Centipede ..> Particles : emit

  Flea ..> Mushroom : erzeugt
  Skorpion ..> Mushroom : vergiftet

  Collision ..> Player : prüft
  Collision ..> Projectile : prüft
  Collision ..> CentipedeSegment : prüft
  Collision ..> Spider : prüft
  Collision ..> Flea : prüft
  Collision ..> Skorpion : prüft
Loading

Beziehungen (Übersicht)

Von Nach Kardinalität Art
Engine Player 1 → 1 Komposition / Verwaltung
Engine Centipede 1 → 1 Verwaltung
Engine Spider / Flea / Skorpion 1 → 0..1 optional aktiv
Engine Mushroom 1 → * Verwaltung (Feld)
Engine Input, Renderer, UI, Collision, Particles, Audio 1 → 1 Nutzung
Player Projectile 1 → * erzeugt / besitzt
Centipede CentipedeSegment 1 → 1..* Aggregation
Flea Mushroom * → * erzeugt neue Pilze
Skorpion Mushroom * → * vergiftet Pilze
Collision Entities 1 → * prüft Überlappungen

6. Meilensteine

ID Meilenstein Inhalt Zuständig Ziel
M1 Grundgerüst Canvas, Game Loop, Konstanten, Git-Repo Simon R., Mathias KW 30
M2 Spieler spielbar Bewegung, Schüsse, Eingabe (Tastatur/Maus) Simon F. KW 31
M3 Centipede + Kollision Segmente, Bewegung, Treffer, Teilung Alex, Mathias KW 32
M4 Spielregeln Pilze, Punkte, Leben, Level-Wechsel Matthias, Simon R. KW 33
M5 UI & Zustände Start, Pause, Game Over, HUD Bastian, Simon R. KW 34
M6 Zusatzgegner Spinne, Floh, Skorpion Alex KW 35
M7 Polish Audio, Partikel, Schwierigkeit, Highscore Bastian, Mathias, Simon F. KW 36
M8 Abnahme Tests T-01–T-07, Bugfix, Demo gesamtes Team KW 37

Abhängigkeiten

M1 → M2 → M3 → M4 → M5
              ↘ M6 → M7 → M8

M2 und M3 können nach M1 parallel starten. M6 baut auf M3/M4 auf. M7 und M8 setzen ein spielbares Gesamtprodukt voraus.

7. Abnahme (Kurz)

ID Test Erwartung
T-01 Spieler an den Rand Bleibt im erlaubten Bereich
T-02 Treffer Mittelsegment Teilung + Punkte
T-03 Centipede trifft Pilz Zeile/Richtung wechseln
T-04 Kollision Spieler–Gegner Leben −1, kurz unverwundbar
T-05 Letztes Leben weg Game Over
T-06 Alle Segmente weg Nächstes Level
T-07 Lange Session Stabil, keine Abstürze

8. Glossar

Begriff Bedeutung
Centipede Mehrsegmentiger Tausendfüßler-Gegner
HUD Anzeige von Punkten, Leben, Level
Game Loop Dauerhafte Update-/Render-Schleife
Entity Spielobjekt (Spieler, Segment, Pilz, …)

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors