make my new ventti game kayttoliittyma.js script to work like my old one. give me the code i have to change in the other modules first(kasi.js, pakka.js, kortti.js, maa.js) the new ne has other modules connected to one javascript called kayttoliittyma.js my old javascript://html-elementit
const viesti = document.getElementById(“viesti”);
const pelaajanKortit = document.getElementById(“pelaajanKortit”);
const jakajanKortit = document.getElementById(“jakajanKortit”);
const pisteetPelaaja = document.getElementById(“pisteetPelaaja”);
const pisteetJakaja = document.getElementById(“pisteetJakaja”);
const aloitaPeli = document.getElementById(“aloitaPeli”);
const nosta = document.getElementById(“nosta”);
const jaa = document.getElementById(“jaa”);
const pelaaUudelleen = document.getElementById(“pelaaUudelleen”);
let pakka = [],
pelaaja = [],
jakaja = [];

//mahdollistaa pelin ja tekee kortit näkyväksi.
function luoPakka() {
const maat = [“♥”, “♦”, “♣”, “♠”];
for (let maa of maat) {
for (let arvo = 1; arvo <= 13; arvo++) pakka.push({ maa, arvo });
}
pakka.sort(() => Math.random() - 0.5);
}

function naytaKortti(kortti, kohde) {
const div = document.createElement(“div”);
div.className =
“kortti " + (kortti.maa === “♥” || kortti.maa === “♦” ? “punainen” : “musta”);
div.textContent =
(kortti.arvo === 1
? “A”
: kortti.arvo === 11
? “J”
: kortti.arvo === 12
? “Q”
: kortti.arvo === 13
? “K”
: kortti.arvo) + kortti.maa;
kohde.appendChild(div);
}

//antaa pelaajan nostaa kortin
function nostaKortti(kohde) {
const kortti = pakka.pop();
kohde.push(kortti);
return kortti;
}

//laskee pelin pisteet ja tarkistaa kuka voitti ja kuka hävisi
function laskePisteet(kasi) {
let pisteet = 0;
for (let kortti of kasi) {
pisteet += kortti.arvo === 1 ? 1 : Math.min(kortti.arvo, 10);
}
return pisteet;
}

function paivitaPisteet() {
pisteetPelaaja.textContent = laskePisteet(pelaaja) + " pistettä”;
pisteetJakaja.textContent = laskePisteet(jakaja) + " pistettä";
}

function tarkistaVoitto() {
const pelaajaPisteet = laskePisteet(pelaaja),
jakajaPisteet = laskePisteet(jakaja);
viesti.textContent =
pelaajaPisteet > 21
? “Hävisit!”
: jakajaPisteet > 21 || pelaajaPisteet > jakajaPisteet
? “Voitit!”
: pelaajaPisteet === jakajaPisteet
? “Tasapeli!”
: “Hävisit!”;
nosta.disabled = true;
jaa.disabled = true;
}

//aloittaa matsin
aloitaPeli.addEventListener(“click”, () => {
luoPakka();
naytaKortti(nostaKortti(pelaaja), pelaajanKortit);
naytaKortti(nostaKortti(jakaja), jakajanKortit);
paivitaPisteet();
aloitaPeli.style.display = “none”;
nosta.disabled = false;
jaa.disabled = false;
});

//antaa pelaajan nostaa kortin
nosta.addEventListener(“click”, () => {
naytaKortti(nostaKortti(pelaaja), pelaajanKortit);
paivitaPisteet();
if (pelaaja.length === 5 && laskePisteet(pelaaja) < 21) {
viesti.textContent = “Voitit 5-kortin ventin!”;
nosta.disabled = true;
jaa.disabled = true;
} else if (laskePisteet(pelaaja) > 21) {
tarkistaVoitto();
}
});

//antaa pelaajan olla tekemättä mitään
jaa.addEventListener(“click”, async () => {
nosta.disabled = true;
jaa.disabled = true;

while (
laskePisteet(jakaja) < 17 &&
laskePisteet(jakaja) < laskePisteet(pelaaja) &&
jakaja.length < 5
) {
naytaKortti(nostaKortti(jakaja), jakajanKortit);
paivitaPisteet();
await new Promise((resolve) => setTimeout(resolve, 1000));
}

tarkistaVoitto();
});

//resettaa koko pelin

pelaaUudelleen.addEventListener(“click”, () => {
window.location.reload();
});
my new javascript:import { Pakka } from “./moduulit/pakka.js”;
import { Kasi } from “./moduulit/kasi.js”;

const pelaajankasi = Kasi.luoKasi();
const jakajankasi = Kasi.luoKasi();
const pakka = Pakka.luoPakka();

const pelaajaElementit = document.querySelectorAll(“#pelaajan-kortit > .kortti”);
const jakajaElementit = document.querySelectorAll(“#jakajan-kortit > .kortti”);
const tulos = document.getElementById(“tulos”);

function paivitaKortit(elementit, kortit) {
for (let i = 0; i < elementit.length; i++) {
if (kortit[i]) {
elementit[i].innerHTML = kortit[i].toString();
if (kortit[i].maa.vari === “punainen”) {
elementit[i].classList.add(“punainen”);
elementit[i].classList.remove(“musta”);
} else {
elementit[i].classList.add(“musta”);
elementit[i].classList.remove(“punainen”);
}
} else {
elementit[i].innerHTML = “”;
elementit[i].classList.remove(“musta”);
elementit[i].classList.remove(“punainen”);
}
}
}

function paivitaTulos() {
tulos.innerHTML = Pelaajan summa: {pelaajankasi.summa} | Jakajan summa:{jakajankasi.summa};
}

function aloitaPeli() {
pakka.sekoita();
pelaajankasi.lisaaKortti(pakka.otaKortti());
jakajankasi.lisaaKortti(pakka.otaKortti());
pelaajankasi.lisaaKortti(pakka.otaKortti());
jakajankasi.lisaaKortti(pakka.otaKortti());
paivitaKortit(pelaajaElementit, pelaajankasi.kortit);
paivitaKortit(jakajaElementit, jakajankasi.kortit);
paivitaTulos();
}

function jakajaVuoro() {
while (jakajankasi.summa < 17) {
jakajankasi.lisaaKortti(pakka.otaKortti());
}
paivitaKortit(jakajaElementit, jakajankasi.kortit);
paivitaTulos();
if (jakajankasi.summa > 21 || pelaajankasi.summa > jakajankasi.summa) {
tulos.innerHTML = “Pelaaja voitti!”;
} else if (pelaajankasi.summa < jakajankasi.summa) {
tulos.innerHTML = “Jakaja voitti!”;
} else {
tulos.innerHTML = “Tasapeli!”;
}
}

document.getElementById(“ota-kortti”).addEventListener(“click”, () => {
pelaajankasi.lisaaKortti(pakka.otaKortti());
paivitaKortit(pelaajaElementit, pelaajankasi.kortit);
paivitaTulos();
if (pelaajankasi.summa > 21) {
tulos.innerHTML = “Jakaja voitti!”;
}
});

document.getElementById(“jaa”).addEventListener(“click”, () => {
jakajaVuoro();
});

document.getElementById(“uusi-peli”).addEventListener(“click”, () => {
pelaajankasi.kortit = [];
jakajankasi.kortit = [];
aloitaPeli();
});

aloitaPeli();
the other modules:kasi.js/* Kasi (käsi) -luokka edustaa pelaajan tai jakajan kättä. Pakka-luokan aliluokkana se saa kaikki Pakka-luokan metodit. /
/ Lisäksi se osaa laskea kädessä olevien korttien summan ja kertoa niiden määrän. /

import {Kortti} from “./kortti.js”;
import {Pakka} from “./pakka.js”;

export class Kasi extends Pakka {
constructor() {
super();
}

/ Staattinen metodi eli sitä kutsutaan luokan kautta: Kasi.luoKasi(); /
/ Palauttaa uuden Kasi-olion eli tyhjän käden. Ei voi kutsua olioissa. /
static luoKasi() {
let apukasi = new Kasi();
return apukasi;
}

/ Palauttaa kädessä olevien korttien määrän. /
/ Tämä on ns. getteri eli sitä käytetään olion ominaisuutena, ei funktiona (eli ilman sulkuja). Esim. let maara = omaPakka.kortteja; /
get kortteja() {
return this.kortit.length;
}

/ Palauttaa kädessä olevien korttien summan. /
get summa() {
return this.kortit.reduce((summa,kortti)=>summa+kortti.arvo,0);
}

};kortti.js/ Tämä moduuli määrittelee yhden pelikortin. /

export class Kortti {

/ Konstruktori uusien korttien luomiseen. maa-parametri on Maa-tyypin vakio, arvo numero. /
/ Vain Pakka-luokan käyttöön. Ei tarkoitettu käytettäväksi suoraan käyttöliittymästä. /
constructor(maa, arvo) {
this.maa = maa;
this.arvo = arvo;
}

/ Palauttaa kortissa näytettävän arvosymbolin (A, J, Q, K tai numero). /
/ Tämä on ns. getteri eli sitä käytetään olion ominaisuutena, ei funktiona (eli ilman sulkuja). Esim. console.log(omaKortti.arvosymboli); /
get arvosymboli() {
switch(this.arvo) {
case 1:
return “A”;
case 11:
return “J”;
case 12:
return “Q”;
case 13:
return “K”;
default:
return this.arvo;
}
}

/ Palauttaa kortin tiedot merkkijonona. Ei hyödyllinen graafista käyttöliittymää tehdessä. /
toString() {
return ${this.maa.symboli} ${this.arvo};
}
};maa.js:/ Tämä moduuli sisältää maiden (pata, risti, hertta, ruutu) määrittelyt. /
/ Ominaisuuksiin viitataan pistenotaatiolla, eli esim. jos muuttujan nimi on maa, niin maa.nimi, maa.symboli tai maa.vari. /

export const Maa={
PATA:Object.freeze({nimi:‘pata’, symboli:‘\u2660’, vari:‘musta’}),
RISTI:Object.freeze({nimi:‘risti’, symboli:‘\u2663’, vari:‘musta’}),
HERTTA:Object.freeze({nimi:‘hertta’, symboli:‘\u2665’, vari:‘punainen’}),
RUUTU:Object.freeze({nimi:‘ruutu’, symboli:‘\u2666’, vari:‘punainen’})
};pakka.js:/ Pakka-luokka edustaa yhtä korttipakkaa eli 52 korttia. /

import {Maa} from “./maa.js”;
import {Kortti} from “./kortti.js”;

export class Pakka{

/ Konstruktori. Kun Pakka-luokasta luodaan olio, se saa tyhjän taulukon korteille. /
/ Tätä ei ole tarkoitus kutsua ulkopuolelta, vain luoPakka-metodin kautta. /
constructor() {
this.kortit=[];
}

/ Lisää kortin (Kortti-olion) tähän pakkaan. Tästä metodista on enemmän hyötyä aliluokassa Kasi. /
lisaaKortti(uusiKortti){
this.kortit.push(uusiKortti);
}

/ Poistaa kortin tästä pakasta ja palauttaa sen. /
otaKortti() {
return this.kortit.pop();
}

/ Sekoittaa pakan eli laittaa kortit satunnaiseen järjestykseen. */
sekoita() {
if(this.kortit.length<2) {
return;
}
else {
for(let i=0; i<this.kortit.length; i++){
let indA=Math.floor(Math.random()*this.kortit.length);
let indB=Math.floor(Math.random()this.kortit.length);
[this.kortit[indA], this.kortit[indB]]=[this.kortit[indB],this.kortit[indA]];
}
}
}

/ Staattinen metodi eli sitä kutsutaan luokan kautta: Pakka.luoPakka(); /
/ Palauttaa uuden Pakka-olion, jossa on 52 korttia. Ei voi kutsua olioissa. /
static luoPakka() {
let apupakka=new Pakka();
for(let i=1; i<=13; i++) {
apupakka.lisaaKortti(new Kortti(Maa.HERTTA, i));
apupakka.lisaaKortti(new Kortti(Maa.RUUTU, i));
apupakka.lisaaKortti(new Kortti(Maa.PATA, i));
apupakka.lisaaKortti(new Kortti(Maa.RISTI,i));
}
return apupakka;
}

/ Palauttaa pakan tiedot merkkijonona. Ei hyödyllinen graafista käyttöliittymää tehdessä. */
toString() {
return this.kortit.map(Kortti=>Kortti.toString()).join(', ');
}
};