Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura

Projekt końcowy: System zarządzania Parkiem Jurajskim

10 min czytania ·
W tej lekcji8

Witaj w laboratorium genetycznym Parku Jurajskiego! Po długiej podróży przez świat JavaScript, czas na wyzwanie wieńczące ten moduł. Dr Henry Wu, główny genetyk parku, powierza Ci stworzenie kompleksowego systemu zarządzania, który będzie nadzorować wszystkie aspekty działania parku - od monitorowania dinozaurów po zarządzanie bezpieczeństwem odwiedzających.

Cel projektu

Twoim zadaniem jest stworzenie zaawansowanej aplikacji JavaScript, która zintegruje wszystkie poznane przez Ciebie technologie w jeden spójny system. To będzie Twój magnum opus - dowód na to, że opanowałeś sztukę programowania w JavaScript.

Wymagania funkcjonalne systemu

1. System zarządzania dinozaurami

Twój system musi umożliwiać:

// Przykład struktury danych dinozaura
const dinosaurSpecies = {
  id: 'trex-001',
  name: 'Tyrannosaurus Rex',
  species: 'T-Rex',
  genome: {
    dnaSequence: '4A7B...9F2E', // Sekwencja DNA
    modifications: ['enhanced-strength', 'reduced-aggression'],
    purity: 0.92, // 92% oryginalne DNA
    gapsFilled: ['amphibian-dna', 'bird-dna']
  },
  physicalTraits: {
    height: 5.6, // metry
    weight: 8500, // kg
    length: 12.8, // metry
    age: 4, // lata
    healthStatus: 'excellent'
  },
  behavior: {
    aggressionLevel: 7, // 1-10
    intelligence: 8,
    socialBehavior: 'territorial',
    huntingPattern: 'ambush-predator'
  },
  habitat: {
    enclosureId: 'sector-7',
    temperature: { min: 18, max: 28, current: 24 },
    humidity: { min: 60, max: 80, current: 72 },
    terrainType: 'forest-plains'
  },
  status: 'active' // active, sedated, medical-care, quarantine
};

2. System monitorowania bezpieczeństwa

// Struktura systemu bezpieczeństwa
const securitySystem = {
  alerts: {
    breach: false,
    evacuation: false,
    containmentFailure: false,
    emergencyProtocol: false
  },
  sensors: [
    {
      id: 'fence-sensor-001',
      type: 'perimeter',
      location: 'sector-7-north',
      status: 'operational',
      lastReading: Date.now(),
      voltage: 10000 // napięcie ogrodzenia w woltach
    },
    {
      id: 'motion-detector-034',
      type: 'motion',
      location: 'visitor-center',
      status: 'operational',
      sensitivity: 'high',
      detectedMovement: false
    }
  ],
  accessControl: {
    keyCards: new Map(), // ID karty -> poziom dostępu
    restrictedAreas: ['genetic-lab', 'control-room', 'medical-bay'],
    emergencyOverride: false
  }
};

3. System zarządzania odwiedzającymi

// System zarządzania odwiedzającymi
class VisitorManagementSystem {
  constructor() {
    this.visitors = new Map();
    this.tours = new Map();
    this.emergencyContactList = [];
    this.evacuationProcedures = [];
  }

  registerVisitor(visitorData) {
    const visitor = {
      id: this.generateVisitorId(),
      personalData: {
        name: visitorData.name,
        age: visitorData.age,
        emergencyContact: visitorData.emergencyContact,
        medicalConditions: visitorData.medicalConditions || [],
        insurancePolicy: visitorData.insurancePolicy
      },
      visit: {
        arrivalTime: new Date(),
        departureTime: null,
        tourType: visitorData.tourType, // 'standard', 'vip', 'research'
        groupId: visitorData.groupId,
        currentLocation: 'entrance',
        visitedAreas: ['entrance']
      },
      safety: {
        waiverSigned: false,
        briefingCompleted: false,
        emergencyProtocolsExplained: false,
        trackingDevice: null
      }
    };

    this.visitors.set(visitor.id, visitor);
    return visitor.id;
  }

  trackVisitorLocation(visitorId, newLocation) {
    const visitor = this.visitors.get(visitorId);
    if (visitor) {
      visitor.visit.currentLocation = newLocation;
      visitor.visit.visitedAreas.push(newLocation);
      this.validateSafetyProtocols(visitor);
    }
  }
}

4. System laboratorium genetycznego

// System laboratorium genetycznego
class GeneticLaboratory {
  constructor() {
    this.dnaLibrary = new Map();
    this.activeExperiments = [];
    this.incubators = [];
    this.sequencingMachines = [];
  }

  analyzeDNA(sampleId, dnaSequence) {
    const analysis = {
      sampleId,
      sequenceLength: dnaSequence.length,
      gcContent: this.calculateGCContent(dnaSequence),
      mutations: this.detectMutations(dnaSequence),
      viability: this.assessViability(dnaSequence),
      recommendedModifications: [],
      timestamp: new Date()
    };

    return analysis;
  }

  createNewSpecimen(parentDNA, modifications = []) {
    const baseGenome = this.reconstructGenome(parentDNA);
    const modifiedGenome = this.applyModifications(baseGenome, modifications);

    const specimen = {
      id: this.generateSpecimenId(),
      genome: modifiedGenome,
      generation: this.getParentGeneration(parentDNA) + 1,
      created: new Date(),
      status: 'developing',
      expectedHatchTime: this.calculateHatchTime(modifiedGenome),
      parentSpecimens: [parentDNA.id]
    };

    return this.initiateIncubation(specimen);
  }
}

Wymagania techniczne

1. Architektura aplikacji

Twoja aplikacja musi wykorzystywać:

  • Module Pattern lub ES6 Modules do organizacji kodu
  • Observer Pattern do komunikacji między komponentami
  • Factory Pattern do tworzenia obiektów dinozaurów i odwiedzających
  • Singleton Pattern dla systemów krytycznych (bezpieczeństwo, główna baza danych)
// Przykład architektury modularnej
// modules/ParkCore.js
class ParkCore {
  constructor() {
    if (ParkCore.instance) {
      return ParkCore.instance;
    }

    this.systems = {
      security: new SecuritySystem(),
      genetic: new GeneticLaboratory(),
      visitors: new VisitorManagementSystem(),
      dinosaurs: new DinosaurRegistry(),
      weather: new WeatherMonitoring(),
      power: new PowerGrid()
    };

    this.eventBus = new EventBus();
    this.setupSystemCommunication();

    ParkCore.instance = this;
  }

  setupSystemCommunication() {
    // Komunikacja między systemami przez event bus
    this.eventBus.subscribe('security.breach', (data) => {
      this.systems.visitors.initiateEvacuation(data.location);
      this.systems.dinosaurs.activateContainmentProtocol();
    });

    this.eventBus.subscribe('dinosaur.escaped', (data) => {
      this.systems.security.raiseAlert('containment-failure', data);
      this.systems.visitors.redirectToSafeZones(data.dangerRadius);
    });
  }
}

2. Zarządzanie danymi

// System zarządzania danymi z localStorage i IndexedDB
class DataManager {
  constructor() {
    this.localDB = new LocalDatabase('park-data');
    this.cache = new Map();
    this.syncQueue = [];
  }

  async saveDinosaurData(dinosaur) {
    try {
      // Zapisz do cache
      this.cache.set(dinosaur.id, dinosaur);

      // Zapisz do localStorage jako backup
      localStorage.setItem(`dino_${dinosaur.id}`, JSON.stringify(dinosaur));

      // Zapisz do IndexedDB dla większych danych
      await this.localDB.store('dinosaurs', dinosaur);

      // Dodaj do kolejki synchronizacji z serwerem
      this.queueForSync('dinosaurs', dinosaur.id, 'update');

    } catch (error) {
      console.error('Błąd zapisywania danych dinozaura:', error);
      throw new DataError('Nie udało się zapisać danych dinozaura');
    }
  }

  async loadParkState() {
    try {
      const [dinosaurs, visitors, security] = await Promise.all([
        this.localDB.getAll('dinosaurs'),
        this.localDB.getAll('visitors'),
        this.localDB.get('security', 'current-state')
      ]);

      return {
        dinosaurs: dinosaurs || [],
        visitors: visitors || [],
        security: security || this.getDefaultSecurityState()
      };
    } catch (error) {
      console.error('Błąd ładowania stanu parku:', error);
      return this.getEmergencyFallbackState();
    }
  }
}

3. Interfejs użytkownika

Twój system musi posiadać:

  • Dashboard główny z przeglądem wszystkich systemów
  • Panel dinozaurów z listą, szczegółami i możliwością zarządzania
  • Monitor bezpieczeństwa z alertami i statusem systemów
  • Panel odwiedzających z listą aktywnych wycieczek
  • Laboratorium genetyczne z narzędziami do analizy DNA
  • System raportowania z wykresami i statystykami
// Przykład interfejsu użytkownika
class ParkInterface {
  constructor(parkCore) {
    this.park = parkCore;
    this.currentView = 'dashboard';
    this.refreshInterval = null;
    this.setupEventListeners();
  }

  render() {
    const app = document.getElementById('park-app');
    app.innerHTML = `
      <header class="park-header">
        <h1>Jurassic Park Management System</h1>
        <div class="system-status">${this.renderSystemStatus()}</div>
      </header>

      <nav class="park-navigation">
        ${this.renderNavigation()}
      </nav>

      <main class="park-content">
        ${this.renderCurrentView()}
      </main>

      <aside class="alerts-panel">
        ${this.renderAlerts()}
      </aside>
    `;

    this.bindEvents();
  }

  renderDinosaurPanel() {
    const dinosaurs = this.park.systems.dinosaurs.getAll();

    return `
      <div class="dinosaur-panel">
        <h2>Zarządzanie dinozaurami</h2>

        <div class="dinosaur-grid">
          ${dinosaurs.map(dino => `
            <div class="dinosaur-card" data-id="${dino.id}">
              <div class="dino-header">
                <h3>${dino.name}</h3>
                <span class="status ${dino.status}">${dino.status}</span>
              </div>

              <div class="dino-stats">
                <div class="stat">
                  <label>Wiek:</label>
                  <span>${dino.physicalTraits.age} lat</span>
                </div>
                <div class="stat">
                  <label>Zdrowie:</label>
                  <span>${dino.physicalTraits.healthStatus}</span>
                </div>
                <div class="stat">
                  <label>Lokalizacja:</label>
                  <span>${dino.habitat.enclosureId}</span>
                </div>
              </div>

              <div class="dino-actions">
                <button data-action="feed">Nakarm</button>
                <button data-action="checkup">Kontrola</button>
                <button data-action="relocate">Przenieś</button>
              </div>
            </div>
          `).join('')}
        </div>

        <button class="add-dinosaur-btn" data-action="add-dinosaur">
          + Dodaj nowego dinozaura
        </button>
      </div>
    `;
  }

  bindEvents() {
    // Jeden listener na kontenerze (delegacja zdarzeń): w atrybucie onclick "this" wskazywałby przycisk, a nie ParkInterface
    document.getElementById('park-app').onclick = (event) => {
      const button = event.target.closest('[data-action]');
      if (!button) return;
      const id = button.closest('.dinosaur-card')?.dataset.id;
      const actions = {
        feed: () => this.feedDinosaur(id),
        checkup: () => this.medicateCheckup(id),
        relocate: () => this.relocateDinosaur(id),
        'add-dinosaur': () => this.showAddDinosaurForm()
      };
      actions[button.dataset.action]?.();
    };
  }
}

4. Obsługa sytuacji kryzysowych

// System zarządzania kryzysowego
class EmergencyResponseSystem {
  constructor(parkCore) {
    this.park = parkCore;
    this.emergencyLevel = 0; // 0-5, gdzie 5 to najwyższy
    this.activeProtocols = [];
    this.evacuationRoutes = this.loadEvacuationRoutes();
  }

  handleEmergency(type, severity, location, additionalData = {}) {
    const emergency = {
      id: this.generateEmergencyId(),
      type, // 'containment-breach', 'power-failure', 'weather-emergency', 'medical'
      severity, // 1-5
      location,
      timestamp: new Date(),
      status: 'active',
      data: additionalData
    };

    // Automatyczne procedury w zależności od typu i wagi zagrożenia
    switch (type) {
      case 'containment-breach':
        this.handleContainmentBreach(emergency);
        break;
      case 'power-failure':
        this.handlePowerFailure(emergency);
        break;
      case 'weather-emergency':
        this.handleWeatherEmergency(emergency);
        break;
      case 'medical':
        this.handleMedicalEmergency(emergency);
        break;
      default:
        this.handleGenericEmergency(emergency);
    }

    return emergency.id;
  }

  handleContainmentBreach(emergency) {
    const { location, data } = emergency;

    // 1. Natychmiastowe zamknięcie dotkniętego sektora
    this.park.systems.security.lockdownSector(location);

    // 2. Aktywacja protokołu ewakuacji dla odwiedzających w zagrożonej strefie
    const dangerZone = this.calculateDangerZone(location, data.dinosaurType);
    this.park.systems.visitors.evacuateZone(dangerZone);

    // 3. Wysłanie zespołu ratunkowego
    this.deployResponseTeam('containment', location, data);

    // 4. Informowanie wszystkich systemów
    this.park.eventBus.publish('emergency.containment-breach', {
      location,
      dangerZone,
      estimatedContainmentTime: this.estimateContainmentTime(data.dinosaurType)
    });

    // 5. Automatyczne protokoły bezpieczeństwa
    this.activateEmergencyProtocol('Code Red - Containment Breach');
  }
}

Funkcje zaawansowane

1. Symulacja czasu rzeczywistego

// System symulacji czasu i cykli życiowych
class TimeSimulation {
  constructor() {
    this.gameTime = new Date();
    this.timeMultiplier = 1; // 1 = czas rzeczywisty, 60 = 1 minuta = 1 godzina
    this.isRunning = false;
    this.events = [];
  }

  start() {
    this.isRunning = true;
    this.simulationLoop();
  }

  simulationLoop() {
    if (!this.isRunning) return;

    // Aktualizuj czas symulacji
    this.gameTime = new Date(this.gameTime.getTime() + (1000 * this.timeMultiplier));

    // Sprawdź zaplanowane wydarzenia
    this.processScheduledEvents();

    // Symuluj naturalne procesy
    this.simulateNaturalProcesses();

    // Następna iteracja za sekundę
    setTimeout(() => this.simulationLoop(), 1000);
  }

  simulateNaturalProcesses() {
    // Starzenie się dinozaurów
    this.ageDinosaurs();

    // Zmiany pogody
    this.updateWeather();

    // Zużycie zasobów (energia, pożywienie)
    this.consumeResources();

    // Naturalne zachowania dinozaurów
    this.simulateDinosaurBehavior();
  }
}

2. System AI dla dinozaurów

// Sztuczna inteligencja dinozaurów
class DinosaurAI {
  constructor(dinosaur) {
    this.dinosaur = dinosaur;
    this.currentState = 'idle';
    this.needs = {
      hunger: 50,
      thirst: 30,
      social: 70,
      territory: 80,
      reproduction: 20
    };
    this.decisionTree = this.buildDecisionTree();
  }

  makeDecision() {
    const context = this.gatherEnvironmentalData();
    const urgentNeed = this.findMostUrgentNeed();

    const decision = this.decisionTree.evaluate(urgentNeed, context);

    return this.executeDecision(decision);
  }

  buildDecisionTree() {
    return {
      evaluate: (need, context) => {
        if (need === 'hunger' && this.needs.hunger > 80) {
          return this.findFood(context);
        }

        if (need === 'social' && this.dinosaur.behavior.socialBehavior === 'pack') {
          return this.seekPackMembers(context);
        }

        if (need === 'territory' && context.intruders.length > 0) {
          return this.defendTerritory(context.intruders);
        }

        return { action: 'wander', target: this.chooseRandomLocation() };
      }
    };
  }
}

Kryteria oceny projektu

Twój projekt będzie oceniany według następujących kryteriów:

1. Funkcjonalność (30%)

  • Wszystkie wymagane systemy działają poprawnie
  • Obsługa błędów i sytuacji wyjątkowych
  • Intuicyjny interfejs użytkownika
  • Responsywność aplikacji

2. Kod i architektura (25%)

  • Czytelny, dobrze skomentowany kod
  • Prawidłowe użycie wzorców projektowych
  • Modularna struktura aplikacji
  • Przestrzeganie dobrych praktyk JavaScript

3. Funkcje zaawansowane (20%)

  • Implementacja systemu czasu rzeczywistego
  • AI dla dinozaurów
  • Zaawansowane zarządzanie danymi
  • System raportowania i analityki

4. Kreatywność i innowacyjność (15%)

  • Unikalne funkcje i rozwiązania
  • Interaktywne elementy UI/UX
  • Ciekawe rozszerzenia tematu dinozaurów
  • Implementacja dodatkowych systemów

5. Testowanie i dokumentacja (10%)

  • Testy jednostkowe kluczowych funkcji
  • Dokumentacja API i architektury
  • Instrukcja obsługi dla użytkowników
  • Komentarze w kodzie

Dodatkowe wyzwania (punkty bonusowe)

1. System genetyczny z prawdziwą logiką DNA

Zaimplementuj rzeczywisty system analizy sekwencji DNA z:

  • Algorytmami mutacji genetycznych
  • Systemem krzyżowania DNA różnych gatunków
  • Przewidywaniem cech fizycznych na podstawie genotypu
  • Symulacją dziedziczenia cech przez pokolenia

2. Multiplayer i komunikacja w czasie rzeczywistym

Dodaj funkcjonalność wieloużytkownikową:

  • WebSocket dla komunikacji w czasie rzeczywistym
  • Wspólne zarządzanie parkiem przez wielu użytkowników
  • Chat między zarządzającymi parkiem
  • Synchronizacja stanów między klientami

3. Zaawansowane API i integracje

Połącz z zewnętrznymi serwisami:

  • Prawdziwe dane pogodowe
  • Geolokalizacja użytkowników
  • System płatności dla biletów
  • Integracja z kalendarzem rezerwacji

4. Machine Learning i predykcja

Dodaj elementy uczenia maszynowego:

  • Przewidywanie zachowań dinozaurów
  • Optymalizacja harmonogramów karmienia
  • Analiza wzorców odwiedzających
  • Predykcja awarii systemów

Rozpoczęcie projektu

Krok 1: Planowanie

  1. Narysuj diagram architektury systemu
  2. Określ główne moduły i ich odpowiedzialności
  3. Zaplanuj strukturę danych
  4. Stwórz listę funkcjonalności MVP (Minimum Viable Product)

Krok 2: Implementacja MVP

  1. Stwórz podstawową strukturę aplikacji
  2. Zaimplementuj główne klasy (ParkCore, DataManager)
  3. Dodaj podstawowy interfejs użytkownika
  4. Połącz moduły przez event bus

Krok 3: Rozszerzanie funkcjonalności

  1. Dodaj każdy system pojedynczo
  2. Testuj integrację między systemami
  3. Implementuj zaawansowane funkcje
  4. Optymalizuj wydajność

Krok 4: Finalizacja

  1. Dodaj obsługę błędów
  2. Napisz testy
  3. Stwórz dokumentację
  4. Przeprowadź testy końcowe

Wskazówki techniczne

Struktura plików

jurassic-park-system/
├── index.html
├── css/
│   ├── main.css
│   ├── dashboard.css
│   └── components.css
├── js/
│   ├── core/
│   │   ├── ParkCore.js
│   │   ├── EventBus.js
│   │   └── DataManager.js
│   ├── systems/
│   │   ├── SecuritySystem.js
│   │   ├── DinosaurRegistry.js
│   │   ├── VisitorManager.js
│   │   └── GeneticLab.js
│   ├── ui/
│   │   ├── Dashboard.js
│   │   ├── DinosaurPanel.js
│   │   └── SecurityMonitor.js
│   ├── utils/
│   │   ├── helpers.js
│   │   └── validators.js
│   └── app.js
├── data/
│   ├── dinosaurs.json
│   ├── species-data.json
│   └── default-config.json
└── tests/
    ├── core.test.js
    ├── systems.test.js
    └── integration.test.js

Przykład inicjalizacji aplikacji

// app.js - główny plik aplikacji
document.addEventListener('DOMContentLoaded', async () => {
  try {
    // Inicjalizacja systemu
    const park = new ParkCore();
    await park.initialize();

    // Ładowanie danych
    const dataManager = new DataManager();
    const savedState = await dataManager.loadParkState();

    if (savedState) {
      await park.loadState(savedState);
    } else {
      await park.initializeDefaultState();
    }

    // Inicjalizacja interfejsu
    const ui = new ParkInterface(park);
    ui.render();

    // Start symulacji
    const simulation = new TimeSimulation(park);
    simulation.start();

    console.log('Jurassic Park Management System uruchomiony pomyślnie!');

  } catch (error) {
    console.error('Błąd inicjalizacji systemu:', error);
    showErrorPage('Nie udało się uruchomić systemu zarządzania parkiem');
  }
});

To jest Twoje wielkie wyzwanie na koniec modułu, młody programisto! Czas pokazać, czego się nauczyłeś, i stworzyć coś naprawdę wyjątkowego. Dr Wu i całe laboratorium genetyczne liczą na Ciebie!

Powodzenia w budowie przyszłości Parku Jurajskiego!

Kod do tej lekcji: index.js
// System AI Dinozaurów
// Ćwiczenie: Zaimplementuj system potrzeb i zachowań

class DinosaurAI {
  constructor(name, species) {
    this.name = name;
    this.species = species;
    this.needs = { hunger: 50, energy: 80, social: 60 };
    this.behavior = "idle";
  }

  // Zaimplementuj metody:
  // updateNeeds() - zaktualizuj potrzeby (losowe zmiany)
  // decideBehavior() - podejmij decyzję o zachowaniu na podstawie potrzeb
  // getStatus() - zwróć status dinozaura

  updateNeeds() {
    // Twój kod tutaj
  }

  decideBehavior() {
    // Twój kod tutaj
  }

  getStatus() {
    // Twój kod tutaj
  }
}

const rex = new DinosaurAI("Blue", "Velociraptor");
console.log("AI dinozaura:", rex.name, "Status:", rex.behavior);

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

  1. Projekt do wysłaniaProjekt: Kompleksowy System Zarządzania Parkiem Jurajskim
  2. WideoVideo: Podsumowanie modułu

Przydatne artykuły