leo/tetris
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
9c85eb7f98
tetris/html/main.js

1057 lines
29 KiB
JavaScript
Raw Normal View History

crlf fix, add README.md
2024-08-03 05:32:52 +05:00
//Leo Tetris Version 0.1
//http://rozenlab.com/tetris
const idCanvas = "screen";
const canvasWidth = 500;
const canvasHeight = 640;
const gameFieldWidth = 300;
const gameFieldHeight = 600;
const widthCellQuantity = 10;
const heightCellQuantity = 20;
const frameColor = '#000';
const gridColor = '#ddd';
const multicoloredFigures = false;
let mainTetris;
let mainField;
let clueField;
let gameField;
let SoundPlay;
let vibrateOn = true;
let enableGrid = true;
let enableSound = true;
let score = 0;
let hiScore = 0;
let gameSpeed = 1000;
let refreshIntervalId;
let speedLabel = 1;
let speedStep = 100;
let goalStep = 0;
let goalTarget = 10;
const soundVolume = 0.3;
const buttonVibratePattern = 30;
let blockControl = false;
let pause = false;
document.onkeydown = handle;
let ScreenContext = createScreen(idCanvas, canvasWidth, canvasHeight);
//Test params:
const stepMode = false;
const testFigure = 'no'; // 'no', 0-4
const bgFigure = false;
const manualPlace = false;
//https://colorscheme.ru/color-harmony-pastels/color-wheel.html
const palette = [
'#ec1b24',
'#ee2c38',
'#f47115',
'#f79c0e',
'#dcd100',
'#65c42f',
'#00a65f',
'#00aaaf',
'#1b62b7',
'#293d9b',
'#542790',
'#a0138e'
];
function createScreen(idCanvas, canvasWidth, canvasHeight) {
const canvas = document.getElementById(idCanvas);
canvas.width = canvasWidth;
canvas.height = canvasHeight;
return canvas.getContext('2d');
}
class Field {
constructor(
ScreenContext,
zeroPointOnCanvasX,
zeroPointOnCanvasY,
width,
height,
widthCellQuantity,
heightCellQuantity
) {
this.ctx = ScreenContext;
this.x = zeroPointOnCanvasX;
this.y = zeroPointOnCanvasY;
this.width = width;
this.height = height;
this.widthCellQuantity = widthCellQuantity;
this.heightCellQuantity = heightCellQuantity;
this.pixelWidth = width / widthCellQuantity;
this.pixelHeight = height / heightCellQuantity;
this.fX = width / widthCellQuantity - zeroPointOnCanvasX;
this.fY = height / heightCellQuantity - zeroPointOnCanvasY;
}
drawPixel(x, y, color) {
if(!(x < 1 || y < 1 || x > widthCellQuantity || y > heightCellQuantity)) {
this.ctx.fillStyle = color;
this.ctx.fill();
this.ctx.fillRect(
this.pixelWidth * x - this.fX,
this.pixelHeight * y - this.fY,
this.pixelWidth,
this.pixelHeight
);
}
}
drawFigure(x, y, figure, bg, color = '#000') {
let pixelColor;
for (let fx = 0; fx < figure[0].length; fx++) {
for (let fy = 0; fy < figure.length; fy++) {
if (figure[fy][fx] !== 0) {
if (figure[fy][fx] !== 1) {
pixelColor = figure[fy][fx];
} else pixelColor = color;
this.drawPixel (x + fx, y + fy, pixelColor);
} else {
if(bg) {
this.drawPixel(x + fx, y + fy, '#eae8e8');
}
}
}
}
}
mirrorFigure (figure) {
const mirrorFigure = [];
for (let y = 0; y < figure.length; y++ ) {
mirrorFigure[y] = figure[y].reverse();
}
return mirrorFigure;
}
rotateFigure (figure) {
let n, m;
n = m = figure.length;
let rotatedFigure = [];
for (let i = 0; i < m; i++){
rotatedFigure[i] = [];
for (let j = 0; j < n; j++){
rotatedFigure[i][j] = 0;
}}
for (let y = 0; y < figure.length; y++) {
for (let x = 0; x < figure[y].length; x++) {
rotatedFigure[x][figure.length - 1 - y] = figure[y][x];
}
}
return rotatedFigure;
}
figureColoring(figure, color = '#000') {
let pixelColor;
for (let x = 0; x < figure[0].length; x++) {
for (let y = 0; y < figure.length; y++) {
if (figure[y][x] !== 0) {
if(color === 'random') {
pixelColor = randomStaticColor(palette);
} else pixelColor = color;
figure[y][x] = pixelColor;
}
}
}
return figure;
}
drawLine(x, y, toX, toY, color) {
this.ctx.beginPath();
this.ctx.lineWidth = 1;
this.ctx.moveTo(this.x + 0.5 + x,this.y + y + 0.5);
this.ctx.lineTo(this.x + 0.5 + toX,this.y + toY + 0.5);
this.ctx.strokeStyle = color;
this.ctx.stroke();
}
drawGrid(color) {
if(enableGrid === true) {
for (let x = 0; x <= this.heightCellQuantity - 1; x++) {
this.drawLine(
0,
this.pixelHeight + x * this.pixelHeight,
this.width,
this.pixelHeight + x * this.pixelHeight,
color
);
}
for (let y = 0; y < this.widthCellQuantity; y++) {
this.drawLine(
this.pixelWidth + y * this.pixelWidth,
this.height,
this.pixelWidth + y * this.pixelWidth,
0,
color
);
}
}
}
drawFrame(color, lineWidth = 1) {
this.ctx.lineWidth = lineWidth;
this.ctx.strokeStyle = color;
this.ctx.strokeRect(this.x, this.y, this.width, this.height);
}
drawText(text, size, x, y) {
this.ctx.fillStyle = '#3636a5';
this.ctx.font = size + "px digital-7-italic";
this.ctx.fillText(text, x, y);
}
clearScreen() {
this.ctx.clearRect(0, 0, canvasWidth, canvasHeight);
}
}
function randomInteger(min, max) {
const rand = min + Math.random() * (max + 1 - min);
return Math.floor(rand);
}
function randomStaticColor(palette) {
let colors = [];
if(palette === undefined) { //Default palette
colors = ['Fuchsia', 'Purple', 'Red', 'Maroon', 'Yellow', 'Olive', 'Lime', 'Green', 'Blue', 'Navy'];
} else colors = palette;
return colors[randomInteger(0, colors.length - 1)];
}
class Tetris {
screenMatrix = [];
I = [
[0,0,0,0],
[1,1,1,1],
[0,0,0,0],
[0,0,0,0]
];
L = [ //+mirror
[0,0,0,0],
[0,0,1,0],
[1,1,1,0],
[0,0,0,0]
];
O = [
[0,0,0,0],
[0,1,1,0],
[0,1,1,0],
[0,0,0,0]
];
T = [
[0,0,0,0],
[0,1,0,0],
[1,1,1,0],
[0,0,0,0]
];
Z = [ //+mirror
[0,0,0,0],
[1,1,0,0],
[0,1,1,0],
[0,0,0,0]
];
figures = [this.I, this.L, this.O, this.T, this.Z];
releasePoint = { //!!!!!!!!!!!
x: 4,
y: 0
};
activeFigure = {
buffer: [],
x: 0,
y: 0
};
emptyField = [
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
];
constructor() {
this.screenMatrix = this.emptyField;
this.nextFigure = this.createFigure(this.figures);
this.createActiveFigure();
this.nextFigure = this.createFigure(this.figures);
}
createFigure(figures) {
let figure = figures[randomInteger(0, figures.length - 1)];
if(testFigure !== 'no') {
figure = figures[testFigure];
}
if(randomInteger(0, 1) === 1) {
figure = mainField.mirrorFigure(figure);
}
const figureRotation = randomInteger(0, 3);
for (let i = 0; i < figureRotation; i++) {
figure = mainField.rotateFigure(figure);
}
const color = multicoloredFigures ? 'random' : randomStaticColor(palette);
return mainField.figureColoring(figure, color);
}
createActiveFigure() {
this.activeFigure.buffer = this.nextFigure;
this.activeFigure.status = 1;
}
placeFigure(field, figure, x, y, mode = 's') {
let pixelColor;
for (let fx = 0; fx < figure[0].length; fx++) {
for (let fy = 0; fy < figure.length; fy++) {
if (figure[fy][fx] !== 0) {
if (figure[fy][fx] !== 1) {
pixelColor = figure[fy][fx];
} else pixelColor = color;
if(mode === 's') {
field[y + fy - 1][x + fx + 3] = figure[fy][fx]; //for S or Auto
}
if(mode === 'a') {
field[y + fy][x + fx + 3] = figure[fy][fx]; //for A
}
if(mode === 'd') {
field[y + fy][x + fx + 1] = figure[fy][fx]; //for D
}
}
}
}
return field;
}
rowsDeleter(field) {
let pixelCounter = 0;
const emptyRow = new Array (widthCellQuantity).fill(0);
for (let fy = 0; fy < field.length; fy++) {
for (let fx = 0; fx < field[0].length; fx++) {
if (field[fy][fx] !== 0) {
pixelCounter++;
}
}
if(pixelCounter === widthCellQuantity) {
let fieldCleaned = field.slice();
fieldCleaned.splice(fy, 1);
fieldCleaned.splice(0, 0, emptyRow);
return fieldCleaned;
}
pixelCounter = 0;
}
return false;
}
checkCollision(figure, x, y, field) {
field[-1] = new Array (widthCellQuantity).fill(0);
for (let fy = 0; fy < figure.length; fy++) {
for (let fx = 0; fx < figure[0].length; fx++) {
if (figure[fy][fx] !== 0) {
if((y + fy) > heightCellQuantity) {
//console.log('bottom');
return "bottom";
}
if((x + fx) < -3) {
//console.log('wallL');
return "wallL";
}
if((x + fx) > widthCellQuantity - 4) {
//console.log('wallR');
return "wallR";
}
if (field[y + fy - 1][x + fx + 3] !== 0) {
//console.log('field');
return "field";
}
}
}
}
}
endFigureEvent(mode, key = false) {
let f; // 0 - for dev only E key. For game: 1
if(key === true) {
f = 0;
} else f = 1;
this.screenMatrix = this.placeFigure(
this.screenMatrix,
this.activeFigure.buffer,
this.activeFigure.x,
this.activeFigure.y - f,
mode
);
let cleanedField;
for(let i = 0; i < heightCellQuantity; i++) {
cleanedField = this.rowsDeleter(this.screenMatrix);
if(cleanedField !== false) {
this.screenMatrix = cleanedField;
score += 100; //Добавить бонусы за несколько рядов за раз. 2 ряда: +100, ...
goalStep++;
SoundPlay.playSound15(); //Deleting row
if(goalStep === goalTarget) {
goalStep = 0;
speedLabel++;
gameSpeed -= speedStep;
clearInterval(refreshIntervalId);
refreshIntervalId = setInterval(main, gameSpeed);
SoundPlay.playSound4(); //Goal
}
} else break;
}
this.createActiveFigure();
this.nextFigure = this.createFigure(this.figures);
this.activeFigure.x = 0;
this.activeFigure.y = 0;
SoundPlay.playSound13();
clearInterval(mainTetris.quickKeyInterval);
}
vibrate(pattern) {
if(vibrateOn) {
window.navigator.vibrate(pattern);
}
}
//------------------------------------------------------------------------------------------------------------------
//Control
leftKey(silent = false) {
const mode = 'a';
if(!blockControl) {
this.activeFigure.x--;
main(mode,true);
if(!silent) {
SoundPlay.playSound14();
this.vibrate(buttonVibratePattern);
}
}
}
rightKey(silent = false) {
const mode = 'd';
if(!blockControl) {
this.activeFigure.x++;
main(mode,true);
if(!silent) {
SoundPlay.playSound14();
this.vibrate(buttonVibratePattern);
}
}
}
quickKey() {
let mode;
if(!blockControl) {
clearInterval(this.quickKeyInterval);
this.quickKeyInterval = setInterval(() => {
this.activeFigure.y++;
main(mode,true);
},1);
SoundPlay.playSound14();
this.vibrate(buttonVibratePattern);
}
}
downKey(silent = false) {
let mode;
if(!blockControl) {
this.activeFigure.y++;
main(mode,true);
if(!silent) {
SoundPlay.playSound14();
this.vibrate(buttonVibratePattern);
}
}
}
rotateKey() {
let mode;
if(!blockControl) {
this.activeFigure.buffer = mainField.rotateFigure(this.activeFigure.buffer);
main(mode,true);
SoundPlay.playSound5();
this.vibrate(buttonVibratePattern);
}
}
pauseKey() {
let mode;
if(pause) {
refreshIntervalId = setInterval(main, gameSpeed);
blockControl = false;
pause = false;
SoundPlay.playSound2();
this.vibrate(buttonVibratePattern);
} else {
clearInterval(refreshIntervalId);
blockControl = true;
pause = true;
mainTetris.drawPause();
SoundPlay.playSound1();
this.vibrate(buttonVibratePattern);
}
main(mode,true);
}
muteSoundKey() {
if(!pause) {
let mode;
//enableSound = !enableSound;
if (enableSound) {
SoundPlay.playSound1();
this.vibrate(buttonVibratePattern);
enableSound = false;
} else {
enableSound = true;
SoundPlay.playSound2();
this.vibrate(buttonVibratePattern);
}
main(mode, true);
}
}
newGameKey() {
let mode;
newGameTetris();
main(mode,true);
SoundPlay.playSound14();
this.vibrate(buttonVibratePattern);
}
stepModeKey() {
if(stepMode) {
if (!blockControl) {
main('s');
}
}
}
manualPlaceKey() {
if(!blockControl) {
if(manualPlace) {
mainTetris.endFigureEvent('s', true);
}
}
}
//------------------------------------------------------------------------------------------------------------------
//Draw
drawScore() {
mainField.drawText('score: ' + score, 25, 350, 50);
}
drawSpeed() {
mainField.drawText('speed: ' + speedLabel, 25, 350, 300);
}
drawPause() {
if(pause) {
mainField.drawText('pause', 25, 350, 330);
}
}
drawGoal() {
mainField.drawText('goal', 25, 350, 90);
mainField.drawText(goalStep + '/' + goalTarget, 25, 350, 120);
}
drawHiScore() {
mainField.drawText('hi-score', 25, 350, 420);
mainField.drawText(hiScore, 25, 350, 450);
}
drawSoundOff() {
if(enableSound === false) {
mainField.drawText('sound off', 25, 350, 600);
}
}
//------------------------------------------------------------------------------------------------------------------
endGame() {
clearInterval(refreshIntervalId);
blockControl = true;
SoundPlay.playSound9();
}
} //End Tetris class
function drawElements() {
clueField.drawGrid(gridColor);
clueField.drawFrame(frameColor, 0.5);
mainField.drawGrid(gridColor);
mainField.drawFrame(frameColor);
mainTetris.drawScore();
mainTetris.drawGoal();
mainTetris.drawSpeed();
mainTetris.drawPause()
mainTetris.drawSoundOff();
//mainTetris.drawHiScore();
}
function newGameTetris() {
pause = false;
clearInterval(refreshIntervalId);
if(stepMode === false) {
refreshIntervalId = setInterval(main, gameSpeed);
}
enableSound = true;
blockControl = false;
gameField = new Field(
10,
10,
200,
400,
10,
20
);
SoundPlay = new Sound();
mainField = new Field(
ScreenContext,
20,
20,
gameFieldWidth,
gameFieldHeight,
widthCellQuantity,
heightCellQuantity
);
const clueSize = 4;
clueField = new Field(
ScreenContext,
350,
140,
gameFieldWidth / widthCellQuantity * clueSize,
gameFieldHeight / heightCellQuantity * clueSize,
clueSize,
clueSize
);
mainTetris = new Tetris();
drawElements();
score = 0;
goalStep = 0;
speedLabel = 1;
gameSpeed = 1000;
}
function scaleFix() {
const zeroWidth = 432;
const zeroScale = 0.79;
const scaleStep = 0.0018;
let widthScreen = window.innerWidth;
let factor = zeroScale - (zeroWidth - widthScreen) * scaleStep;
document.getElementById('container').style.zoom = factor;
}
function main(mode, key = false) {
scaleFix();
if(key === false) {
mainTetris.activeFigure.y++;
}
let collision = mainTetris.checkCollision(
mainTetris.activeFigure.buffer,
mainTetris.activeFigure.x,
mainTetris.activeFigure.y,
mainTetris.screenMatrix
);
if(collision === 'bottom') {
mainTetris.endFigureEvent(mode);
}
if(collision === 'wallL') {
mainTetris.activeFigure.x++;
}
if(collision === 'wallR') {
mainTetris.activeFigure.x--;
}
if(collision === 'field') {
if(mode === 'a') {
mainTetris.activeFigure.x++;
} else
if(mode === 'd') {
mainTetris.activeFigure.x--;
} else
mainTetris.endFigureEvent(mode);
}
mainField.clearScreen();
clueField.drawFigure(1,1, mainTetris.nextFigure, false); //Draw next figure
mainField.drawFigure(1,1, mainTetris.screenMatrix, false); //Draw field
let collisionDraw = mainTetris.checkCollision(
mainTetris.activeFigure.buffer,
mainTetris.activeFigure.x,
mainTetris.activeFigure.y,
mainTetris.screenMatrix
);
if(collisionDraw === 'field') {
mainTetris.endGame();
} else {
mainField.drawFigure( //Draw active figure
mainTetris.releasePoint.x + mainTetris.activeFigure.x,
mainTetris.releasePoint.y + mainTetris.activeFigure.y,
mainTetris.activeFigure.buffer,
bgFigure,
mainTetris.activeFigure.color
);
}
drawElements();
}
function handle(e) {
if (e.keyCode === 65 || e.keyCode === 37) { mainTetris.leftKey(); } //A
if (e.keyCode === 68 || e.keyCode === 39) { mainTetris.rightKey(); } //D
if (e.keyCode === 87 || e.keyCode === 38) { mainTetris.rotateKey(); } //W
if (e.keyCode === 83 || e.keyCode === 40) { mainTetris.downKey(); } //S
if (e.keyCode === 77) { mainTetris.muteSoundKey(); } //M
if (e.keyCode === 80) { mainTetris.pauseKey(); } //P
if (e.keyCode === 78) { mainTetris.newGameKey(); } //N
if (e.keyCode === 13) { mainTetris.stepModeKey(); } //Enter
if (e.keyCode === 69) { mainTetris.manualPlaceKey(); } //E
//console.log(e.keyCode);
}
class Sound {
constructor() {
this.sound0 = new Audio('Sounds/mr_9999_00.wav'); //Music no
this.sound1 = new Audio('Sounds/mr_9999_01.wav'); //Switch ok
this.sound2 = new Audio('Sounds/mr_9999_02.wav'); //Switch x2 ok
this.sound3 = new Audio('Sounds/mr_9999_03.wav'); //Switch x2 slow no
this.sound4 = new Audio('Sounds/mr_9999_04.wav'); //Goal ok ok
this.sound5 = new Audio('Sounds/mr_9999_05.wav'); //Figure flip ok
this.sound6 = new Audio('Sounds/mr_9999_06.wav'); //Error no
this.sound7 = new Audio('Sounds/mr_9999_07.wav'); //Error+ no
this.sound8 = new Audio('Sounds/mr_9999_08.wav'); //Error x3 no
this.sound9 = new Audio('Sounds/mr_9999_09.wav'); //Losing ok
this.sound10 = new Audio('Sounds/mr_9999_10.wav'); //Korobeiniki no
this.sound11 = new Audio('Sounds/mr_9999_11.wav'); //Error 2 no
this.sound12 = new Audio('Sounds/mr_9999_12.wav'); //Error 3 no
this.sound13 = new Audio('Sounds/mr_9999_13.wav'); //Adding figure ok
this.sound14 = new Audio('Sounds/mr_9999_14.wav'); //Keys ok
this.sound15 = new Audio('Sounds/mr_9999_15.wav'); //Deleting row ок
}
playSound0() {
if(enableSound === true) {
this.sound0.currentTime = 0.0;
this.sound0.volume = soundVolume;
this.sound0.play();
}
}
playSound1() {
if(enableSound === true) {
this.sound1.currentTime = 0.0;
this.sound1.volume = soundVolume;
this.sound1.play();
}
}
playSound2() {
if(enableSound === true) {
this.sound2.currentTime = 0.0;
this.sound2.volume = soundVolume;
this.sound2.play();
}
}
playSound3() {
if(enableSound === true) {
this.sound3.currentTime = 0.0;
this.sound3.volume = soundVolume;
this.sound3.play();
}
}
playSound4() {
if(enableSound === true) {
this.sound4.currentTime = 0.0;
this.sound4.volume = soundVolume;
this.sound4.play();
}
}
playSound5() {
if(enableSound === true) {
this.sound5.currentTime = 0.0;
this.sound5.volume = soundVolume;
this.sound5.play();
}
}
playSound6() {
if(enableSound === true) {
this.sound6.currentTime = 0.0;
this.sound6.volume = soundVolume;
this.sound6.play();
}
}
playSound7() {
if(enableSound === true) {
this.sound7.currentTime = 0.0;
this.sound7.volume = soundVolume;
this.sound7.play();
}
}
playSound8() {
if(enableSound === true) {
this.sound8.currentTime = 0.0;
this.sound8.volume = soundVolume;
this.sound8.play();
}
}
playSound9() {
if(enableSound === true) {
this.sound9.currentTime = 0.0;
this.sound9.volume = soundVolume;
this.sound9.play();
}
}
playSound10() {
if(enableSound === true) {
this.sound10.currentTime = 0.0;
this.sound10.volume = soundVolume;
this.sound10.play();
}
}
playSound11() {
if(enableSound === true) {
this.sound11.currentTime = 0.0;
this.sound11.volume = soundVolume;
this.sound11.play();
}
}
playSound12() {
if(enableSound === true) {
this.sound12.currentTime = 0.0;
this.sound12.volume = soundVolume;
this.sound12.play();
}
}
playSound13() {
if(enableSound === true) {
this.sound13.currentTime = 0.0;
this.sound13.volume = soundVolume;
this.sound13.play();
}
}
playSound14() {
if(enableSound === true) {
this.sound14.currentTime = 0.0;
this.sound14.volume = soundVolume;
this.sound14.play();
}
}
playSound15() {
if(enableSound === true) {
this.sound15.currentTime = 0.0;
this.sound15.volume = soundVolume;
this.sound15.play();
}
}
}
/* Get the documentElement (<html>) to display the page in fullscreen */
const elem = document.documentElement;
/* View in fullscreen */
function openFullscreen() {
if (elem.requestFullscreen) {
elem.requestFullscreen();
} else if (elem.webkitRequestFullscreen) { /* Safari */
elem.webkitRequestFullscreen();
} else if (elem.msRequestFullscreen) { /* IE11 */
elem.msRequestFullscreen();
}
}
/* Close fullscreen */
function closeFullscreen() {
if (document.exitFullscreen) {
document.exitFullscreen();
} else if (document.webkitExitFullscreen) { /* Safari */
document.webkitExitFullscreen();
} else if (document.msExitFullscreen) { /* IE11 */
document.msExitFullscreen();
}
}
const leftKeyId = document.getElementById('leftKeyEvent');
const rightKeyId = document.getElementById('rightKeyEvent');
const quickKeyId = document.getElementById('quickKeyEvent');
const downKeyId = document.getElementById('downKeyEvent');
const rotateKeyId = document.getElementById('rotateKeyEvent');
const resetKeyId = document.getElementById('resetKeyEvent');
const muteSoundId = document.getElementById('muteSoundKeyEvent');
const pauseKeyId = document.getElementById('pauseKeyEvent');
const optionsKeyId = document.getElementById('optionsKeyEvent');
const scrRes = document.getElementById('scrRes');
let leftKeyEventInterval;
function leftKeyEventDown() {
mainTetris.leftKey();
leftKeyEventInterval = setInterval (() => mainTetris.leftKey(true), 100);
}
function leftKeyEventUp() {
clearInterval(leftKeyEventInterval);
}
let rightKeyEventInterval;
function rightKeyEventDown() {
mainTetris.rightKey();
rightKeyEventInterval = setInterval (() => mainTetris.rightKey(true), 100);
}
function rightKeyEventUp() {
clearInterval(rightKeyEventInterval);
}
function quickKeyEventDown() {
mainTetris.quickKey();
}
let downKeyEventInterval;
function downKeyEventDown() {
mainTetris.downKey();
downKeyEventInterval = setInterval (() => mainTetris.downKey(true), 50);
}
function downKeyEventUp() {
clearInterval(downKeyEventInterval);
}
function rotateKeyEventDown() {
mainTetris.rotateKey();
}
function rotateKeyEventUp() {
//mainTetris.rotateKey();
}
function resetKeyEventDown() {
mainTetris.newGameKey();
}
function muteSoundKeyEventDown() {
mainTetris.muteSoundKey();
}
function pauseKeyEventDown() {
mainTetris.pauseKey();
}
function optionsKeyEventDown() {
//optionsKey
}
document.body.oncontextmenu = function (e) { return false; };
leftKeyId.addEventListener("touchstart", leftKeyEventDown);
rightKeyId.addEventListener("touchstart", rightKeyEventDown);
quickKeyId.addEventListener("touchstart", quickKeyEventDown);
downKeyId.addEventListener("touchstart", downKeyEventDown);
rotateKeyId.addEventListener("touchstart", rotateKeyEventDown);
resetKeyId.addEventListener("touchstart", resetKeyEventDown);
muteSoundId.addEventListener("touchstart", muteSoundKeyEventDown);
pauseKeyId.addEventListener("touchstart", pauseKeyEventDown);
optionsKeyId.addEventListener("touchstart", optionsKeyEventDown);
leftKeyId.addEventListener("touchend", leftKeyEventUp);
rightKeyId.addEventListener("touchend", rightKeyEventUp);
//quickKeyId.addEventListener("mouseup", quickKeyEventUp);
downKeyId.addEventListener("touchend", downKeyEventUp);
rotateKeyId.addEventListener("touchend", rotateKeyEventUp);
//resetKeyId.addEventListener("mouseup", resetKeyEventUp);
//muteSoundId.addEventListener("mouseup", muteSoundKeyEventUp);
//pauseKeyId.addEventListener("mouseup", pauseKeyEventUp);
//optionsKeyId.addEventListener("mouseup", optionsKeyEventUp);
scrRes.addEventListener("touchstart", () => {
document.getElementById('scrRes').innerHTML = window.innerWidth + ' x ' + window.innerHeight;
Tetris v0.1
2023-06-29 04:11:19 +05:00
});
Reference in New Issue Copy Permalink