Hvordan endre JavaScript-timerverdien for et skrivespill ved hjelp av HTML-knapper

Dynamisk timerjustering for å skrive spill ved hjelp av knapper

I et skrivespill er det avgjørende å kontrollere tempoet i spillet for å sikre en engasjerende brukeropplevelse. En viktig faktor er timeren, som bestemmer hvor lang tid brukeren har på å fullføre spillet eller skriveutfordringen. Ved å la brukere justere spilltimeren gjennom enkle HTML-knapper, kan du gi dem mer kontroll over spillingen.

Denne artikkelen vil vise deg hvordan du lager en løsning i JavaScript som lar spillere velge mellom forskjellige timerinnstillinger ved hjelp av knapper. Hvis du for eksempel velger en '30s'-knapp, justeres timeren til 30 sekunder, mens et klikk på en '60s'-knapp endrer den til 60 sekunder.

JavaScript-funksjonen tar verdien fra den klikkede knappen og oppdaterer både tidtakeren og spillets tittel dynamisk. Denne typen fleksibilitet kan forbedre brukeropplevelsen, noe som gjør spillet mer tilpassbart og morsomt for ulike ferdighetsnivåer.

Ved slutten av denne veiledningen vil du ha en fullt funksjonell funksjon for timerjustering som bruker HTML og JavaScript. Vi vil også dekke hvordan du oppdaterer den viste timerverdien på sidens tittel for å gjenspeile den valgte tidtakervarigheten.

Kommando	Eksempel på bruk
document.querySelector()	Brukes til å velge HTML-elementet
addEventListener()	Binder en spesifikk hendelse (f.eks. klikk) til et knappeelement. I denne sammenhengen brukes den til å utløse changeTimer()-funksjonen når en bruker klikker på en knapp, noe som muliggjør dynamisk interaksjon med timerinnstillingene.
innerText	Denne egenskapen gjør det mulig å endre den synlige teksten i et HTML-element. I denne løsningen brukes den til å oppdatere timerverdien i sidens tittel når en knapp klikkes.
onClick	Et innebygd hendelsesbehandlerattributt som brukes i den alternative tilnærmingen for å knytte changeTimer()-funksjonen direkte til knappens klikkhendelse. Dette muliggjør en enklere, mindre modulær måte å oppdatere timeren dynamisk på.
test()	Denne metoden brukes i enhetstesting med Jest. Den definerer et testtilfelle der funksjonen som testes (f.eks. changeTimer()) evalueres for å sikre at timeren oppdateres riktig. Det sikrer at koden oppfører seg som forventet i forskjellige scenarier.
expect()	En Jest-kommando som sjekker om den faktiske verdien (som den oppdaterte tidtakeren) samsvarer med den forventede verdien. Den brukes i enhetstester for å bekrefte at gameTime og document.title er riktig oppdatert etter et knappeklikk.
toBe()	Nok en Jest-kommando som sjekker for streng likhet. Den sikrer at etter å ha kalt changeTimer(), er spilletid nøyaktig hva som forventes (f.eks. 30 000 ms i 30 sekunder).
getElementById()	Brukes til å velge spesifikke knapper etter ID-ene deres (f.eks. 'tretti', 'seksti'). Denne metoden er viktig for å knytte hendelseslyttere til knappene og utløse den dynamiske endringen av tidtakeren som svar på brukerinteraksjon.

Opprette dynamiske timere ved hjelp av JavaScript og HTML-knapper

Skriptene ovenfor er laget for å tillate en bruker dynamisk å justere spilltimeren i et skrivespill ved å klikke på HTML-knappene. Til å begynne med erklærer vi en variabel , som holder tiden i millisekunder (30 sekunder som standard, multiplisert med 1000 for å konvertere til millisekunder). Nøkkelfunksjonaliteten ligger i funksjon, som oppdaterer timerverdien basert på knappen som er klikket. Denne metoden mottar verdien av knappen (f.eks. 30, 60 eller 90) og oppdaterer spilletid variabel tilsvarende. I tillegg oppdaterer skriptet sidens tittel for å gjenspeile den valgte tidtakerens varighet, noe som gjør det klart for brukerne hvor mye tid de har.

For den dynamiske oppførselen bruker vi hendelseslyttere, spesielt kommando. Dette lar skriptet reagere når en bruker klikker på en av knappene. Hver knapp tildeles en ID og, når den klikkes, utløser den funksjon, passerer den respektive tidsverdien. Denne tilnærmingen er nyttig for å håndtere flere knapper effektivt uten å trenge repeterende innebygd JavaScript i HTML-strukturen. Skriptet inkluderer også et reservealternativ der du kan bruke innebygde hendelsesbehandlere som hvis enkelhet foretrekkes fremfor modularitet.

I den alternative løsningen binder vi direkte hendelse til knappene. Denne metoden utfører funksjon direkte når knappen klikkes. Det er en enkel tilnærming, men mangler fleksibiliteten til hendelseslyttermetoden. Enkelheten til denne metoden er nyttig for mindre, mindre komplekse applikasjoner. For mer skalerbar kode tilbyr imidlertid hendelseslyttere mer fleksibilitet og muliggjør enklere oppdateringer av skriptet uten å endre HTML-strukturen direkte. Begge metodene tar sikte på å løse det samme problemet, som er å justere timeren og oppdatere tittelen dynamisk basert på brukerens valg.

Til slutt implementerer vi enhetstester ved å bruke Jest, et JavaScript-testrammeverk. De funksjoner er avgjørende for å validere at tidtakeren oppdateres riktig. Ved å teste flere scenarier, for eksempel om tidtakeren justeres til 30 sekunder, 60 sekunder eller 90 sekunder, sikrer disse enhetstestene at skriptet er korrekt. Kommandoer som og brukes til å bekrefte at den faktiske timerverdien og sidetittelen samsvarer med de forventede resultatene. Denne testfasen sikrer at timerlogikken din fungerer som den skal på tvers av ulike brukstilfeller, noe som gir tillit til robustheten til løsningen din.

// Solution 1: Using event listeners to change timer value dynamically
let gameTime = 30 * 1000; // Default timer set to 30 seconds
const titleElement = document.querySelector('title');
function changeTimer(value) {
    gameTime = value * 1000; // Update timer to selected value
    titleElement.innerText = value + 's'; // Update the title
}
// Attach event listeners to buttons
document.getElementById('thirty').addEventListener('click', () => changeTimer(30));
document.getElementById('sixty').addEventListener('click', () => changeTimer(60));
document.getElementById('ninety').addEventListener('click', () => changeTimer(90));
// HTML Buttons:
// <button id="thirty" type="button">30s</button>
// <button id="sixty" type="button">60s</button>
// <button id="ninety" type="button">90s</button>

<script>
let gameTime = 30 * 1000;
function changeTimer(value) {
    gameTime = value * 1000;
    document.title = value + 's';
}
</script>
<button onClick="changeTimer(30)">30s</button>
<button onClick="changeTimer(60)">60s</button>
<button onClick="changeTimer(90)">90s</button>

// Jest Test Cases
test('Timer should update to 30 seconds', () => {
    changeTimer(30);
    expect(gameTime).toBe(30000);
    expect(document.title).toBe('30s');
});
test('Timer should update to 60 seconds', () => {
    changeTimer(60);
    expect(gameTime).toBe(60000);
    expect(document.title).toBe('60s');
});
test('Timer should update to 90 seconds', () => {
    changeTimer(90);
    expect(gameTime).toBe(90000);
    expect(document.title).toBe('90s');
});

Forbedre spillinteraksjon med tidtakertilpasning

Et annet aspekt å vurdere når du endrer tidtakeren i et skrivespill, er den generelle brukeropplevelsen og grensesnittet. I tillegg til å justere spilltimeren via knapper, er det viktig å gi spillerne visuell tilbakemelding på den valgte timeren. Dette kan oppnås ved å oppdatere andre elementer på siden, for eksempel en nedtellingsvisning. Etter at en knapp er klikket for å stille inn tidtakeren, skal nedtellingstidtakeren starte umiddelbart, og gi tilbakemelding i sanntid til brukeren. Dette sikrer at interaksjonen er jevn og intuitiv, noe som gjør spillet mer engasjerende.

For å implementere dette kan du bruke JavaScript funksjon. Når tidtakeren er stilt inn, settintervall kan brukes til å lage en nedtelling som reduserer timerverdien hvert sekund. Når tidtakeren når null, kan funksjonen enten stoppe spillet eller varsle brukeren om at tiden er ute. Denne funksjonaliteten, kombinert med muligheten til å dynamisk endre tidtakeren ved hjelp av knapper, forbedrer spillopplevelsen betydelig. Et responsivt grensesnitt er nøkkelen til å holde spillerne engasjert, og tilbakemeldinger i sanntid er en måte å oppnå det på.

Videre bør feilhåndtering vurderes. For eksempel, hvis en bruker prøver å starte spillet uten å stille inn en tidtaker, kan du be dem om å velge en gyldig tid. Ved å inkorporere valideringsmekanismer sikrer du at spillet fungerer jevnt og reduserer potensielle problemer. Denne typen validering forbedrer ikke bare brukeropplevelsen, men bidrar også til påliteligheten til spillet ditt, og sikrer at spillere ikke møter unødvendig forvirring.

1. Hvordan bruker jeg å lage en nedtelling?
2. Du kan bruke ved å sette den til å kjøre hvert 1000 millisekund (1 sekund) og redusere timerverdien hver gang. Når verdien når null, kan du stoppe nedtellingen ved å bruke .
3. Hva er hensikten med ?
4. brukes til å stoppe en nedtelling eller annen gjentakende handling startet av . Det er avgjørende å sørge for at nedtellingen stopper når den når null.
5. Hvordan kan jeg oppdatere HTML-tittelen dynamisk?
6. Bruk for å angi teksten til sidetittelen. Dette kan oppdateres i din funksjon basert på den valgte tidsverdien.
7. Kan jeg håndtere brukerfeil når jeg velger en tidtaker?
8. Ja, du kan legge til validering ved å sjekke om et gyldig timeralternativ er valgt før du starter nedtellingen. Hvis ingen gyldig tid er valgt, kan du vise et varsel eller en melding.
9. Hvordan utløser jeg en funksjon når en knapp trykkes?
10. Du kan knytte en funksjon til en knapp ved å bruke eller ved å bruke direkte i knappens HTML-element.

Å inkludere dynamiske timerjusteringer i et skrivespill forbedrer spilleropplevelsen betraktelig. Ved å la brukere endre tidtakeren ved hjelp av enkle HTML-knapper og oppdatere spillets grensesnitt i sanntid, kan utviklere gjøre spillene sine mer interaktive og fleksible. Denne typen kontroll bidrar til å imøtekomme ulike ferdighetsnivåer.

Bruk av beste fremgangsmåter som hendelseslyttere, feilhåndtering og enhetstester sikrer at spillet kjører jevnt og gir en pålitelig brukeropplevelse. Implementering av disse funksjonene vil ikke bare forbedre spillets funksjonalitet, men også holde spillerne mer engasjert med responsiv, brukervennlig mekanikk.