Kurs JavaScript i TypeScript · Moduł 8: Zdarzenia i DOM
Wydarzenia myszy i klawiatury
W tej lekcji5
"W systemach bezpieczeństwa Parku Jurajskiego," Ray Arnold pokazuje wielki panel kontrolny, "mamy różne typy sensorów. Czujniki ruchu reagują na ruch, czujniki ciśnienia na dotyk, czujniki dźwięku na hałas. Każdy typ wymaga innej reakcji. W JavaScript mamy podobną sytuację - różne typy wejścia wymagają różnej obsługi."
Ray wskazuje na monitor i klawiaturę. "Mysz i klawiatura to dwa podstawowe źródła interakcji użytkownika. Każde ma swoje unikalne wydarzenia i zachowania."
Wydarzenia myszy - pełny zakres interakcji
Mysz generuje kilkanaście różnych typów wydarzeń, od prostych kliknięć po zaawansowane gesty przeciągania. Jedno kliknięcie to trzy sygnały: mousedown, mouseup i dopiero na końcu click.
Podstawowe wydarzenia kliknięć
Obszar obserwacyjny rozróżnia pojedyncze i podwójne kliknięcie.
const dinosaurViewingArea = document.getElementById('viewing-area');
// click - pojedyncze kliknięcie (najpopularniejsze)
dinosaurViewingArea.addEventListener('click', (event) => {
console.log('Pojedyncze kliknięcie w obszar obserwacyjny');
console.log('Pozycja:', event.clientX, event.clientY);
selectDinosaurAtPosition(event.clientX, event.clientY);
});
// dblclick - podwójne kliknięcie
dinosaurViewingArea.addEventListener('dblclick', (event) => {
console.log('Podwójne kliknięcie - zbliżenie');
// Uwaga: to NIE blokuje zaznaczania tekstu, które startuje już przy mousedown
event.preventDefault();
zoomInOnDinosaur(event.clientX, event.clientY);
});Pola clientX i clientY to pozycja kursora w oknie. Uwaga: preventDefault() w dblclick nie zablokuje zaznaczania tekstu, bo startuje ono już przy mousedown. Do tego służy reguła CSS user-select: none.
// auxclick - kliknięcie środkowym/innym przyciskiem (nie lewy)
dinosaurViewingArea.addEventListener('auxclick', (event) => {
if (event.button === 1) {
console.log('Środkowy przycisk - otwieranie w nowym oknie');
openInNewWindow(event.target);
}
});
// contextmenu - prawy przycisk myszy (menu kontekstowe)
dinosaurViewingArea.addEventListener('contextmenu', (event) => {
event.preventDefault(); // Zablokuj domyślne menu
console.log('Prawy przycisk - własne menu kontekstowe');
showCustomContextMenu(event.clientX, event.clientY);
});
function selectDinosaurAtPosition(x, y) {
console.log(`Sprawdzanie czy dinozaur znajduje się na pozycji (${x}, ${y})`);
// Logika selekcji
}
function zoomInOnDinosaur(x, y) {
console.log(`Zbliżenie na pozycję (${x}, ${y})`);
// Logika zoom
}
function showCustomContextMenu(x, y) {
const menu = document.getElementById('custom-menu');
menu.style.left = x + 'px';
menu.style.top = y + 'px';
menu.style.display = 'block';
console.log('Menu kontekstowe wyświetlone');
}Wartość event.button równa 1 to środkowy przycisk, a preventDefault() przy contextmenu chowa menu przeglądarki, robiąc miejsce dla własnego.
Wydarzenia przycisków myszy
Między wciśnięciem a puszczeniem przycisku trwa przeciąganie, więc zapamiętujemy punkt startu.
const controlPanel = document.getElementById('control-panel');
// mousedown - naciśnięcie przycisku myszy (przed puszczeniem)
controlPanel.addEventListener('mousedown', (event) => {
console.log('Przycisk myszy wciśnięty');
console.log('Który przycisk:', event.button); // 0=lewy, 1=środek, 2=prawy
if (event.button === 0) {
console.log('Lewy przycisk - rozpoczynam przeciąganie');
startDragging(event);
}
});
// mouseup - puszczenie przycisku myszy
controlPanel.addEventListener('mouseup', (event) => {
console.log('Przycisk myszy puszczony');
if (isDragging) {
console.log('Kończę przeciąganie');
stopDragging(event);
}
});
let isDragging = false;
let dragStartX = 0;
let dragStartY = 0;
function startDragging(event) {
isDragging = true;
dragStartX = event.clientX;
dragStartY = event.clientY;
console.log(`Rozpoczęcie przeciągania z pozycji (${dragStartX}, ${dragStartY})`);
}
function stopDragging(event) {
const deltaX = event.clientX - dragStartX;
const deltaY = event.clientY - dragStartY;
console.log(`Przeciągnięto o: X=${deltaX}px, Y=${deltaY}px`);
isDragging = false;
}Flaga isDragging łączy oba wydarzenia w jedną historię, a różnica współrzędnych mówi, jak daleko przesunięto kursor.
Wydarzenia ruchu myszy
Ruch kursora nad mapą parku śledzi mousemove, czujnik odzywający się przy każdym drgnięciu myszy.
const parkMap = document.getElementById('interactive-park-map');
// mousemove - ruch myszy (UWAGA: bardzo częste!)
// Używaj z rozwagą - może generować setki eventów na sekundę
let mouseMoveCount = 0;
parkMap.addEventListener('mousemove', (event) => {
mouseMoveCount++;
// Aktualizuj pozycję kursora
updateCursorPosition(event.clientX, event.clientY);
// Jeśli przeciągamy, aktualizuj pozycję
if (isDragging) {
updateDragPosition(event.clientX, event.clientY);
}
// Log co 10-te wydarzenie (żeby nie zaśmiecać konsoli)
if (mouseMoveCount % 10 === 0) {
console.log(`Ruch myszy #${mouseMoveCount}: (${event.clientX}, ${event.clientY})`);
}
});
function updateCursorPosition(x, y) {
const coordsDisplay = document.getElementById('mouse-coords');
if (coordsDisplay) {
coordsDisplay.textContent = `X: ${x}, Y: ${y}`;
}
}
function updateDragPosition(x, y) {
const draggableElement = document.getElementById('draggable');
if (draggableElement) {
draggableElement.style.left = x + 'px';
draggableElement.style.top = y + 'px';
}
}Dlatego log trafia do konsoli co dziesiąte wydarzenie, a lekcja o throttlingu pokaże, jak ograniczać takie lawiny. Teraz wejście i wyjście kursora.
// mouseenter - mysz wchodzi w obszar elementu (nie bąbelkuje!)
parkMap.addEventListener('mouseenter', (event) => {
console.log('Mysz weszła na mapę parku');
parkMap.classList.add('mouse-active');
showMapControls();
});
// mouseleave - mysz opuszcza obszar elementu (nie bąbelkuje!)
parkMap.addEventListener('mouseleave', (event) => {
console.log('Mysz opuściła mapę parku');
parkMap.classList.remove('mouse-active');
hideMapControls();
});
// mouseover - mysz wchodzi (bąbelkuje - uruchamia się też dla dzieci!)
parkMap.addEventListener('mouseover', (event) => {
if (event.target.classList.contains('enclosure-marker')) {
const enclosureName = event.target.dataset.name;
console.log(`Najechano na marker zagrody: ${enclosureName}`);
showEnclosureTooltip(event.target, enclosureName);
}
});
// mouseout - mysz wychodzi (bąbelkuje)
parkMap.addEventListener('mouseout', (event) => {
if (event.target.classList.contains('enclosure-marker')) {
console.log('Opuszczono marker zagrody');
hideEnclosureTooltip();
}
});
function showMapControls() {
const controls = document.getElementById('map-controls');
if (controls) {
controls.style.display = 'block';
}
}
function hideMapControls() {
const controls = document.getElementById('map-controls');
if (controls) {
controls.style.display = 'none';
}
}Para mouseenter i mouseleave nie bąbelkuje, więc reaguje tylko na samą mapę, a mouseover i mouseout bąbelkują z każdego dziecka, stąd sprawdzanie event.target.
Praktyczny przykład - system przeciągania
"Jedną z najbardziej użytecznych funkcji," mówi Ray, "jest drag & drop." Pierwsza część klasy zaczyna przeciąganie.
class DinosaurCardDragSystem {
constructor() {
this.draggedElement = null;
this.dragOffsetX = 0;
this.dragOffsetY = 0;
this.initialize();
}
initialize() {
const cards = document.querySelectorAll('.dinosaur-card');
cards.forEach(card => {
card.addEventListener('mousedown', (e) => this.handleDragStart(e));
});
document.addEventListener('mousemove', (e) => this.handleDragMove(e));
document.addEventListener('mouseup', (e) => this.handleDragEnd(e));
console.log('System drag & drop zainicjalizowany');
}
handleDragStart(event) {
this.draggedElement = event.currentTarget;
const rect = this.draggedElement.getBoundingClientRect();
this.dragOffsetX = event.clientX - rect.left;
this.dragOffsetY = event.clientY - rect.top;
this.draggedElement.style.position = 'fixed';
this.draggedElement.style.zIndex = '1000';
this.draggedElement.classList.add('dragging');
const dinoName = this.draggedElement.dataset.dinoName;
console.log(`Rozpoczęto przeciąganie karty: ${dinoName}`);
event.preventDefault(); // Prevent text selection
}Listenery mousemove i mouseup wiszą na dokumencie, bo szybki ruch wyprowadzi kursor poza kartę. Tu preventDefault() w mousedown naprawdę blokuje zaznaczanie tekstu, a getBoundingClientRect() pozwala wyliczyć punkt chwytu.
handleDragMove(event) {
if (!this.draggedElement) return;
const x = event.clientX - this.dragOffsetX;
const y = event.clientY - this.dragOffsetY;
this.draggedElement.style.left = x + 'px';
this.draggedElement.style.top = y + 'px';
}
handleDragEnd(event) {
if (!this.draggedElement) return;
const dinoName = this.draggedElement.dataset.dinoName;
console.log(`Zakończono przeciąganie karty: ${dinoName}`);
// Sprawdź czy karta została upuszczona w odpowiedniej strefie
const dropZone = this.findDropZone(event.clientX, event.clientY);
if (dropZone) {
console.log('Karta upuszczona w strefie:', dropZone.id);
this.handleDrop(this.draggedElement, dropZone);
} else {
console.log('Karta upuszczona poza strefą - powrót do pozycji początkowej');
this.returnToOriginalPosition();
}
this.draggedElement.classList.remove('dragging');
this.draggedElement = null;
}Karta podąża za kursorem, a po puszczeniu przycisku klasa szuka strefy, w której wylądowała.
findDropZone(x, y) {
const dropZones = document.querySelectorAll('.drop-zone');
for (const zone of dropZones) {
const rect = zone.getBoundingClientRect();
if (x >= rect.left && x <= rect.right &&
y >= rect.top && y <= rect.bottom) {
return zone;
}
}
return null;
}
handleDrop(card, dropZone) {
console.log('Dodawanie karty do strefy drop');
dropZone.appendChild(card);
// Reset stylów
card.style.position = '';
card.style.left = '';
card.style.top = '';
card.style.zIndex = '';
}
returnToOriginalPosition() {
// Powrót na miejsce - bez animacji, bo zmiany position nie da się animować.
// Bez setTimeout: handleDragEnd zaraz potem ustawia this.draggedElement na null
this.draggedElement.style.position = '';
this.draggedElement.style.left = '';
this.draggedElement.style.top = '';
this.draggedElement.style.zIndex = '';
}
}
// Inicjalizacja
const dragSystem = new DinosaurCardDragSystem();Karta upuszczona w strefie przenosi się do nowej zagrody, a poza nią wraca na miejsce.
Przeciąganie wbudowane w przeglądarkę
Przeglądarka ma też własne API Drag and Drop. Element z atrybutem draggable="true" wysyła dragstart, a strefa docelowa dostaje dragover i drop.
// HTML: <div class="dino-item" draggable="true">T-Rex</div>
const dino = document.querySelector('.dino-item');
const zone = document.getElementById('zone-c');
dino.addEventListener('dragstart', (e) => {
e.dataTransfer.setData('text/plain', dino.textContent);
dino.classList.add('dragging');
});
dino.addEventListener('dragend', () => dino.classList.remove('dragging'));
zone.addEventListener('dragover', (e) => {
e.preventDefault(); // bez tego strefa nie przyjmie upuszczenia
});
zone.addEventListener('drop', (e) => {
e.preventDefault(); // blokuje domyślną akcję, np. otwarcie linku
zone.appendChild(dino);
});Kluczowy jest preventDefault() w dragover, bo bez niego upuszczenie jest zabronione, a dragend sprząta po każdym przeciąganiu.
Wydarzenia klawiatury - kontrola z klawiatury
"Klawiatura," Ray wskazuje na panel kontrolny, "to drugi kluczowy sposób interakcji. Skróty klawiszowe, nawigacja, wprowadzanie danych."
Podstawowe wydarzenia klawiatury
Każde naciśnięcie zostawia w obiekcie wydarzenia pełny raport.
// keydown - klawisz naciśnięty (powtarza się gdy trzymany)
document.addEventListener('keydown', (event) => {
console.log('=== KEYDOWN ===');
console.log('Klawisz:', event.key); // 'a', 'Enter', 'ArrowUp', etc.
console.log('Kod:', event.code); // 'KeyA', 'Enter', 'ArrowUp', etc.
console.log('KeyCode (deprecated):', event.keyCode);
console.log('Czy to powtórzenie:', event.repeat);
console.log('Ctrl:', event.ctrlKey);
console.log('Shift:', event.shiftKey);
console.log('Alt:', event.altKey);
console.log('Meta (Cmd/Win):', event.metaKey);
});
// keyup - klawisz puszczony
document.addEventListener('keyup', (event) => {
console.log(`Puszczono klawisz: ${event.key}`);
});
// keypress - DEPRECATED! Nie używaj (użyj keydown zamiast tego)
// keypress jest przestarzały i nie odpala np. dla strzałek ani Escapeevent.key to znak lub nazwa klawisza, a event.code to fizyczny klawisz, niezależny od układu klawiatury. Trzymany klawisz wysyła kolejne keydown z event.repeat równym true, a keyup przychodzi raz.
Praktyczne skróty klawiszowe
Skróty obsługuje jeden listener na dokumencie. Najpierw zapis, wyszukiwanie i Escape.
// System skrótów klawiszowych dla parku
document.addEventListener('keydown', (event) => {
// Ctrl/Cmd + S - Zapisz
if ((event.ctrlKey || event.metaKey) && event.key === 's') {
event.preventDefault();
console.log('Zapisywanie konfiguracji parku...');
saveParkConfiguration();
return;
}
// Ctrl/Cmd + F - Szukaj
if ((event.ctrlKey || event.metaKey) && event.key === 'f') {
event.preventDefault();
console.log('Otwieranie wyszukiwarki dinozaurów');
openSearchDialog();
return;
}
// Escape - Zamknij wszystkie okna
if (event.key === 'Escape') {
console.log('Zamykanie wszystkich okien dialogowych');
closeAllModals();
return;
}Sprawdzamy ctrlKey albo metaKey, żeby skrót działał też z Cmd na Macu, a preventDefault() zatrzymuje zapis strony przez przeglądarkę. Dalej strzałki, spacja, F1 i cyfry.
// Strzałki - Nawigacja po mapie
const arrowKeys = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'];
if (arrowKeys.includes(event.key)) {
event.preventDefault();
const direction = {
'ArrowUp': 'north',
'ArrowDown': 'south',
'ArrowLeft': 'west',
'ArrowRight': 'east'
}[event.key];
console.log(`Przesunięcie mapy w kierunku: ${direction}`);
moveMap(direction);
return;
}
// Spacja - Pauza/Wznów monitoring
if (event.key === ' ') {
event.preventDefault();
console.log('Toggle pauzy monitoringu');
toggleMonitoringPause();
return;
}
// F1 - Pomoc
if (event.key === 'F1') {
event.preventDefault();
console.log('Otwieranie pomocy');
openHelp();
return;
}
// Cyfry 1-9 - Szybki dostęp do zagród
if (event.key >= '1' && event.key <= '9') {
const enclosureNumber = parseInt(event.key);
console.log(`Przełączanie na zagrodę #${enclosureNumber}`);
jumpToEnclosure(enclosureNumber);
return;
}
});Spacja ma nazwę ' ', a mapa kierunków zamienia klawisz na stronę świata. Dalej proste funkcje wykonawcze.
function saveParkConfiguration() {
console.log('Konfiguracja zapisana');
}
function openSearchDialog() {
console.log('Dialog wyszukiwania otwarty');
}
function closeAllModals() {
document.querySelectorAll('.modal').forEach(modal => {
modal.style.display = 'none';
});
console.log('Wszystkie okna zamknięte');
}
function moveMap(direction) {
console.log(`Mapa przesunięta w kierunku: ${direction}`);
}
function toggleMonitoringPause() {
console.log('Monitoring wstrzymany/wznowiony');
}
function openHelp() {
console.log('Pomoc otwarta');
}
function jumpToEnclosure(number) {
console.log(`Przejście do zagrody #${number}`);
}Listener rozpoznaje skrót, a logika żyje w funkcjach.
Walidacja wejścia z klawiatury
Listener keydown może odrzucić znak, zanim trafi do pola: kod bezpieczeństwa przyjmuje tylko cyfry, telefon także spacje, nawiasy i myślniki, a imię dostaje wielką literę.
const securityCodeInput = document.getElementById('security-code');
const phoneInput = document.getElementById('phone-number');
const nameInput = document.getElementById('visitor-name');
// Tylko cyfry - kod bezpieczeństwa
securityCodeInput.addEventListener('keydown', (event) => {
// Zezwól na klawisze funkcyjne
const allowedKeys = [
'Backspace', 'Delete', 'Tab', 'Escape', 'Enter',
'ArrowLeft', 'ArrowRight', 'Home', 'End'
];
if (allowedKeys.includes(event.key)) {
return; // Pozwól
}
// Tylko cyfry
if (event.key >= '0' && event.key <= '9') {
// Maksymalnie 6 cyfr
if (securityCodeInput.value.length >= 6 && !event.ctrlKey && !event.metaKey) {
event.preventDefault();
console.log('Maksymalnie 6 cyfr');
}
return;
}
// Wszystko inne - blokuj
event.preventDefault();
console.log('Tylko cyfry są dozwolone');
});
// Formatowanie numeru telefonu
phoneInput.addEventListener('keydown', (event) => {
const allowedKeys = [
'Backspace', 'Delete', 'Tab', 'Escape', 'Enter',
'ArrowLeft', 'ArrowRight', 'Home', 'End'
];
if (allowedKeys.includes(event.key)) return;
// Tylko cyfry, spacje, myślniki, nawiasy
const phoneChars = /^[0-9 ()-]$/;
if (!phoneChars.test(event.key)) {
event.preventDefault();
console.log('Niedozwolony znak w numerze telefonu');
}
});
// Auto-kapitalizacja pierwszej litery
nameInput.addEventListener('keyup', (event) => {
const value = nameInput.value;
if (value.length === 1) {
nameInput.value = value.toUpperCase();
}
});Taki filtr to tylko wygoda, bo tekst da się wkleić z menu kontekstowego, więc wartość sprawdzaj też przy input lub submit.
Kombinacja myszy i klawiatury
"Najlepsze interfejsy," mówi Ray, "łączą oba typy wejścia." Klawisze modyfikujące zmieniają znaczenie kliknięcia.
const enclosureCards = document.querySelectorAll('.enclosure-card');
let selectedCards = new Set();
enclosureCards.forEach(card => {
card.addEventListener('click', (event) => {
const enclosureId = card.dataset.enclosureId;
// Różne zachowania w zależności od klawiszy modyfikujących
if (event.ctrlKey || event.metaKey) {
// Ctrl + Click = Toggle selekcji
console.log('Ctrl+Click: Toggle selekcji');
if (selectedCards.has(enclosureId)) {
selectedCards.delete(enclosureId);
card.classList.remove('selected');
} else {
selectedCards.add(enclosureId);
card.classList.add('selected');
}
} else if (event.shiftKey) {
// Shift + Click = Wybór zakresu
console.log('Shift+Click: Wybór zakresu');
selectRange(lastSelected, enclosureId);
} else {
// Zwykłe kliknięcie = Tylko ta jedna karta
console.log('Zwykłe kliknięcie: Pojedyncza selekcja');
selectedCards.clear();
document.querySelectorAll('.enclosure-card.selected').forEach(c => {
c.classList.remove('selected');
});
selectedCards.add(enclosureId);
card.classList.add('selected');
}
lastSelected = enclosureId;
updateSelectionInfo();
});
});
let lastSelected = null;
function selectRange(startId, endId) {
console.log(`Wybieranie zakresu od ${startId} do ${endId}`);
// Logika wyboru zakresu
}
function updateSelectionInfo() {
console.log(`Wybrano ${selectedCards.size} zagród`);
}Ctrl lub Cmd przełącza zaznaczenie, Shift wybiera zakres, zwykłe kliknięcie zostawia jedną kartę. Dalej strzałki.
// Nawigacja klawiaturą przez karty
let focusedCardIndex = 0;
const cards = Array.from(enclosureCards);
document.addEventListener('keydown', (event) => {
// Tylko gdy żadne pole input nie jest aktywne
if (document.activeElement.tagName === 'INPUT') return;
switch(event.key) {
case 'ArrowRight':
case 'ArrowDown':
event.preventDefault();
focusedCardIndex = Math.min(focusedCardIndex + 1, cards.length - 1);
focusCard(focusedCardIndex);
break;
case 'ArrowLeft':
case 'ArrowUp':
event.preventDefault();
focusedCardIndex = Math.max(focusedCardIndex - 1, 0);
focusCard(focusedCardIndex);
break;
case 'Enter':
case ' ':
event.preventDefault();
cards[focusedCardIndex].click();
break;
}
});
function focusCard(index) {
cards.forEach(card => card.classList.remove('focused'));
cards[index].classList.add('focused');
cards[index].scrollIntoView({ behavior: 'smooth', block: 'nearest' });
console.log(`Fokus na karcie #${index}: ${cards[index].dataset.enclosureName}`);
}Warunek z activeElement nie przeszkadza w pisaniu w polach, a click() na karcie uruchamia ten sam listener co mysz.
Wydarzenia okna i dotyku
DOMContentLoaded odpala, gdy HTML jest wczytany, choć obrazy mogą się jeszcze ładować. load na window czeka na całą stronę z zasobami. Przewijanie zgłasza scroll, a window.scrollY podaje przewinięte piksele, więc większa wartość niż poprzednio oznacza ruch w dół. Na ekranach dotykowych palec wysyła po kolei touchstart, touchmove i touchend, do których wrócimy przy gestach.
Podsumowanie
"Wydarzenia myszy i klawiatury," podsumowuje Ray, "to fundament interaktywności. Podobnie jak różne sensory w Parku Jurajskim wykrywają różne typy zagrożeń, tak różne wydarzenia pozwalają na różnorodne interakcje użytkownika. Kluczem jest używanie odpowiednich wydarzeń do odpowiednich zadań."
Kluczowe wydarzenia myszy:
click,dblclick,contextmenu- kliknięciamousedown,mouseup- kontrola przyciskówmousemove- śledzenie pozycji (używaj ostrożnie!)mouseenter,mouseleave- najechanie (nie bąbelkują)mouseover,mouseout- najechanie (bąbelkują)
Kluczowe wydarzenia klawiatury:
keydown- naciśnięcie klawisza (użyj tego)keyup- puszczenie klawiszaevent.key- znak/nazwa klawisza ('a', 'Enter', 'ArrowUp')event.code- fizyczny klawisz ('KeyA', 'Enter', 'ArrowUp')- Klawisze modyfikujące:
ctrlKey,shiftKey,altKey,metaKey
Moja rada: skróty opieraj na keydown, a przenoszenie między strefami na wbudowanym Drag and Drop. Następna lekcja: formularze.
Pamiętaj: każdy czujnik w parku reaguje na inny sygnał, więc dobieraj wydarzenie do zadania.
Kod do tej lekcji: index.html
<!DOCTYPE html>
<html lang="pl">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Wydarzenia myszy i klawiatury - Sterowanie kamerą</title>
<style>
body {
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
background: linear-gradient(135deg, #2c3e50 0%, #34495e 100%);
margin: 0;
padding: 20px;
color: white;
}
.container {
max-width: 1000px;
margin: 0 auto;
}
h1 {
text-align: center;
margin-bottom: 20px;
}
.instructions {
background: rgba(52, 152, 219, 0.2);
border: 1px solid #3498db;
border-radius: 10px;
padding: 15px;
margin-bottom: 20px;
text-align: center;
}
.instructions kbd {
background: rgba(255, 255, 255, 0.2);
padding: 2px 8px;
border-radius: 4px;
font-family: monospace;
margin: 0 3px;
}
.camera-viewport {
position: relative;
width: 100%;
height: 400px;
background: linear-gradient(180deg, #34495e 0%, #2c3e50 100%);
border-radius: 15px;
overflow: hidden;
cursor: move;
margin-bottom: 20px;
border: 3px solid #7f8c8d;
}
.camera-content {
position: absolute;
width: 200%;
height: 200%;
transition: transform 0.3s ease;
}
.dinosaur {
position: absolute;
font-size: 60px;
cursor: pointer;
transition: transform 0.2s ease;
user-select: none;
}
.dinosaur:hover {
transform: scale(1.2);
filter: drop-shadow(0 0 10px rgba(255, 255, 255, 0.5));
}
.dinosaur.clicked {
animation: bounce 0.5s ease;
}
@keyframes bounce {
0%, 100% { transform: scale(1); }
50% { transform: scale(1.3); }
}
.controls-panel {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 20px;
margin-bottom: 20px;
}
.control-box {
background: rgba(0, 0, 0, 0.6);
border-radius: 10px;
padding: 20px;
border: 1px solid #34495e;
}
.control-box h3 {
margin-top: 0;
color: #3498db;
}
.stats {
display: grid;
grid-template-columns: repeat(2, 1fr);
gap: 10px;
}
.stat-item {
background: rgba(255, 255, 255, 0.1);
padding: 10px;
border-radius: 5px;
}
.stat-label {
color: #bdc3c7;
font-size: 12px;
}
.stat-value {
color: #ecf0f1;
font-size: 18px;
font-weight: bold;
}
.arrow-buttons {
display: grid;
grid-template-areas:
". up ."
"left . right"
". down .";
gap: 5px;
justify-content: center;
align-items: center;
}
.arrow-btn {
width: 60px;
height: 60px;
background: linear-gradient(45deg, #3498db, #2980b9);
border: none;
border-radius: 10px;
color: white;
font-size: 24px;
cursor: pointer;
transition: all 0.2s ease;
}
.arrow-btn:hover {
background: linear-gradient(45deg, #2980b9, #21618c);
transform: scale(1.05);
}
.arrow-btn:active {
transform: scale(0.95);
}
.arrow-btn.up { grid-area: up; }
.arrow-btn.down { grid-area: down; }
.arrow-btn.left { grid-area: left; }
.arrow-btn.right { grid-area: right; }
.event-log {
background: rgba(0, 0, 0, 0.8);
border-radius: 10px;
padding: 15px;
max-height: 200px;
overflow-y: auto;
font-family: 'Courier New', monospace;
font-size: 12px;
}
.log-entry {
padding: 5px;
border-bottom: 1px solid rgba(255, 255, 255, 0.1);
color: #bdc3c7;
}
.log-entry.mouse {
color: #3498db;
}
.log-entry.keyboard {
color: #e74c3c;
}
.log-entry.click {
color: #f39c12;
}
@media (max-width: 768px) {
.controls-panel {
grid-template-columns: 1fr;
}
}
</style>
</head>
<body>
<div class="container">
<h1>Sterowanie Kamerą w Parku Jurajskim</h1>
<div class="instructions">
<strong>Sterowanie:</strong> Strzałki <kbd>↑</kbd> <kbd>↓</kbd> <kbd>←</kbd> <kbd>→</kbd> |
<strong>Pauza:</strong> <kbd>Space</kbd> |
<strong>Zoom:</strong> Podwójne kliknięcie |
<strong>Zamknij:</strong> <kbd>Escape</kbd>
</div>
<div class="camera-viewport" id="viewport">
<div class="camera-content" id="camera">
<div class="dinosaur" style="top: 50px; left: 100px;" data-name="T-Rex">T</div>
<div class="dinosaur" style="top: 150px; left: 400px;" data-name="Velociraptor">V</div>
<div class="dinosaur" style="top: 300px; left: 200px;" data-name="Triceratops">Tr</div>
<div class="dinosaur" style="top: 100px; left: 600px;" data-name="Brachiosaurus">B</div>
<div class="dinosaur" style="top: 250px; left: 700px;" data-name="Stegosaurus">S</div>
</div>
</div>
<div class="controls-panel">
<div class="control-box">
<h3>Statystyki</h3>
<div class="stats">
<div class="stat-item">
<div class="stat-label">Pozycja myszy</div>
<div class="stat-value" id="mouse-pos">0, 0</div>
</div>
<div class="stat-item">
<div class="stat-label">Kliknięcia</div>
<div class="stat-value" id="click-count">0</div>
</div>
<div class="stat-item">
<div class="stat-label">Pozycja kamery</div>
<div class="stat-value" id="camera-pos">0, 0</div>
</div>
<div class="stat-item">
<div class="stat-label">Ostatni klawisz</div>
<div class="stat-value" id="last-key">-</div>
</div>
</div>
</div>
<div class="control-box">
<h3>Sterowanie kamerą</h3>
<div class="arrow-buttons">
<button class="arrow-btn up" data-direction="up">↑</button>
<button class="arrow-btn left" data-direction="left">←</button>
<button class="arrow-btn right" data-direction="right">→</button>
<button class="arrow-btn down" data-direction="down">↓</button>
</div>
</div>
</div>
<div class="control-box">
<h3>Log wydarzeń</h3>
<div class="event-log" id="event-log"></div>
</div>
</div>
<script>
// Referencje do elementów
const camera = document.getElementById('camera');
const viewport = document.getElementById('viewport');
const mousePosDisplay = document.getElementById('mouse-pos');
const clickCountDisplay = document.getElementById('click-count');
const cameraPosDisplay = document.getElementById('camera-pos');
const lastKeyDisplay = document.getElementById('last-key');
const eventLog = document.getElementById('event-log');
// Stan kamery
let cameraX = 0;
let cameraY = 0;
let clickCount = 0;
let isPaused = false;
const moveSpeed = 50;
// Funkcja logowania wydarzeń
function logEvent(message, type = 'mouse') {
const logEntry = document.createElement('div');
logEntry.className = `log-entry ${type}`;
logEntry.textContent = `[${new Date().toLocaleTimeString()}] ${message}`;
eventLog.insertBefore(logEntry, eventLog.firstChild);
// Ograniczamy liczbę wpisów
if (eventLog.children.length > 20) {
eventLog.removeChild(eventLog.lastChild);
}
}
// Funkcja przesuwania kamery
function moveCamera(direction) {
if (isPaused) {
logEvent('Kamera wstrzymana! Naciśnij Space aby wznowić', 'keyboard');
return;
}
switch(direction) {
case 'up':
cameraY = Math.max(cameraY - moveSpeed, -200);
break;
case 'down':
cameraY = Math.min(cameraY + moveSpeed, 200);
break;
case 'left':
cameraX = Math.max(cameraX - moveSpeed, -200);
break;
case 'right':
cameraX = Math.min(cameraX + moveSpeed, 200);
break;
}
camera.style.transform = `translate(${cameraX}px, ${cameraY}px)`;
cameraPosDisplay.textContent = `${cameraX}, ${cameraY}`;
logEvent(`Przesunięcie kamery: ${direction}`, 'keyboard');
}
// OBSŁUGA MYSZY
// Mousemove - śledzenie pozycji myszy
viewport.addEventListener('mousemove', function(e) {
const rect = viewport.getBoundingClientRect();
const x = Math.floor(e.clientX - rect.left);
const y = Math.floor(e.clientY - rect.top);
mousePosDisplay.textContent = `${x}, ${y}`;
});
// Click - pojedyncze kliknięcie
viewport.addEventListener('click', function(e) {
clickCount++;
clickCountDisplay.textContent = clickCount;
const rect = viewport.getBoundingClientRect();
const x = Math.floor(e.clientX - rect.left);
const y = Math.floor(e.clientY - rect.top);
logEvent(`Kliknięcie w pozycji: (${x}, ${y})`, 'click');
});
// Double click - podwójne kliknięcie (zoom)
viewport.addEventListener('dblclick', function(e) {
const currentScale = camera.style.transform.includes('scale') ? 1 : 1.5;
const newScale = currentScale === 1 ? 1.5 : 1;
camera.style.transform = `translate(${cameraX}px, ${cameraY}px) scale(${newScale})`;
logEvent(`Zoom: ${newScale === 1 ? 'Wyłączony' : 'Włączony'}`, 'click');
});
// Mouseenter/mouseleave - najechanie na viewport
viewport.addEventListener('mouseenter', function() {
viewport.style.borderColor = '#3498db';
logEvent('Mysz weszła w obszar kamery', 'mouse');
});
viewport.addEventListener('mouseleave', function() {
viewport.style.borderColor = '#7f8c8d';
logEvent('Mysz opuściła obszar kamery', 'mouse');
});
// Kliknięcie na dinozaura
document.querySelectorAll('.dinosaur').forEach(dino => {
dino.addEventListener('click', function(e) {
e.stopPropagation(); // Zatrzymujemy propagację do viewport
const name = this.dataset.name;
this.classList.add('clicked');
setTimeout(() => {
this.classList.remove('clicked');
}, 500);
logEvent(`Kliknięto dinozaura: ${name}`, 'click');
console.log(`Obserwacja: ${name}`);
});
dino.addEventListener('mouseenter', function() {
const name = this.dataset.name;
logEvent(`Najechano na: ${name}`, 'mouse');
});
});
// OBSŁUGA KLAWIATURY
// Keydown - naciśnięcie klawisza
document.addEventListener('keydown', function(e) {
lastKeyDisplay.textContent = e.key;
switch(e.key) {
case 'ArrowUp':
e.preventDefault();
moveCamera('up');
break;
case 'ArrowDown':
e.preventDefault();
moveCamera('down');
break;
case 'ArrowLeft':
e.preventDefault();
moveCamera('left');
break;
case 'ArrowRight':
e.preventDefault();
moveCamera('right');
break;
case ' ':
e.preventDefault();
isPaused = !isPaused;
logEvent(`Pauza: ${isPaused ? 'WŁĄCZONA' : 'WYŁĄCZONA'}`, 'keyboard');
viewport.style.opacity = isPaused ? '0.5' : '1';
break;
case 'Escape':
logEvent('Naciśnięto Escape - zamykanie widoku', 'keyboard');
alert('Widok kamery zostanie zamknięty');
break;
case 'r':
case 'R':
// Reset kamery
cameraX = 0;
cameraY = 0;
camera.style.transform = 'translate(0px, 0px)';
cameraPosDisplay.textContent = '0, 0';
logEvent('Reset pozycji kamery', 'keyboard');
break;
default:
logEvent(`Naciśnięto klawisz: ${e.key}`, 'keyboard');
}
});
// Obsługa przycisków strzałek
document.querySelectorAll('.arrow-btn').forEach(btn => {
btn.addEventListener('click', function() {
const direction = this.dataset.direction;
moveCamera(direction);
});
});
// Inicjalizacja
logEvent('System kamery uruchomiony', 'keyboard');
console.log('System monitoringu Parku Jurajskiego - ONLINE');
console.log('Użyj strzałek do poruszania kamerą');
console.log('Kliknij na dinozaury, aby je obserwować');
</script>
</body>
</html>Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Które zdarzenie klawiatury przeglądarka wysyła po wciśnięciu każdego klawisza (także Shift, Ctrl czy strzałek) i powtarza, dopóki klawisz jest przytrzymany?
2. Które wydarzenie wywoływane jest po całkowitym załadowaniu strony?
Zadania praktyczne w grze
- Edytor kodu
W pliku index.html są dwie zagrody (.enclosure) i karty dinozaurów z atrybutem draggable="true". Przy dragstart karta zapisuje swoje id w dataTransfer. Uzupełnij luki: ___BLANK1___ to zdarzenie, które zagroda dostaje, gdy przeciągana karta jest nad nią (w nim preventDefault() zezwala na upuszczenie), a ___BLANK2___ to metoda dataTransfer, która w drop odczytuje zapisane id. Upuszczona karta ma trafić do zagrody, nad którą ją upuszczono.
- Układanie w pionie
Ułóż wydarzenia myszy w kolejności ich następowania podczas kliknięcia:
- Klikanie w kolejności
Ułóż kod sprawdzający kombinację Ctrl+S.
- Układanie w pionie
Ułóż wydarzenia dotykowe w kolejności ich występowania: