commit 491e5b97bb9343b3f210fcbc4df85edf76c1879e Author: tmont Date: Mon Jun 7 10:42:00 2021 -0700 tetris? diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6432642 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +node_modules +.idea + diff --git a/index.html b/index.html new file mode 100644 index 0000000..8ffe8e1 --- /dev/null +++ b/index.html @@ -0,0 +1,225 @@ + + + + + Tetrissimo + + + + +
+ + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + +
+
+ + + + + + + + diff --git a/package.json b/package.json new file mode 100644 index 0000000..3e3a544 --- /dev/null +++ b/package.json @@ -0,0 +1,14 @@ +{ + "name": "tetrissimo", + "version": "0.0.0", + "license": "WTFPL", + "scripts": { + "build": "tsc", + "watch": "tsc --watch --preserveWatchOutput", + "start": "serve -l 19000 ." + }, + "devDependencies": { + "serve": "*", + "typescript": "4.0.3" + } +} diff --git a/requirejs-polyfill.js b/requirejs-polyfill.js new file mode 100644 index 0000000..5542ff9 --- /dev/null +++ b/requirejs-polyfill.js @@ -0,0 +1,52 @@ +((window) => { + const moduleCache = {}; + const exportsCache = {}; + const exportsPlaceholder = '!exports'; + + function define(name, deps, fn) { + if (Array.isArray(name)) { + if (typeof (deps) === 'function') { + const resolvedDeps = require(name); + deps.apply(null, resolvedDeps); + } + return; + } + + moduleCache[name] = {deps, fn}; + } + + function require(names) { + return (names || []) + .map((name) => { + if (name in exportsCache) { + return exportsCache[name]; + } + if (name === 'exports') { + return exportsPlaceholder; + } + + const mod = moduleCache[name]; + if (!mod) { + throw new Error(`Unknown module "${name}"`); + } + + exportsCache[name] = {}; + const args = require(mod.deps); + const index = args.findIndex(x => x === exportsPlaceholder); + if (index !== -1) { + args[index] = exportsCache[name]; + } + mod.fn.apply(null, args); + const moduleKey = '__$module'; + if (exportsCache[name][moduleKey]) { + exportsCache[name] = exportsCache[name][moduleKey]; + } + return exportsCache[name]; + }); + } + + window.require = exportsCache.require = require; + window.define = define; + window.exportsCache = exportsCache; + window.moduleCache = moduleCache; +})(window); diff --git a/tetrissimo.js b/tetrissimo.js new file mode 100644 index 0000000..de3a766 --- /dev/null +++ b/tetrissimo.js @@ -0,0 +1,555 @@ +const nope = (x) => { }; +const getSize = (value, options) => value * options.pixelSize; +const drawBorderedRect = (position, context, options) => { + const borderWidth = options.borderWidth; + if (!borderWidth) { + return; + } + const actualLineWidth = getSize(borderWidth, options); + context.lineWidth = actualLineWidth; + context.strokeStyle = 'white'; + context.strokeRect(getSize(position.x, options) - Math.round(actualLineWidth / 2), getSize(position.y, options) - Math.round(actualLineWidth / 2), getSize(position.width, options) + actualLineWidth, getSize(position.height, options) + actualLineWidth); +}; +class TetrissimoLevel { + constructor(order, speed) { + this.order = order; + this.movementsPerSecond = speed; + } +} +TetrissimoLevel.level1 = new TetrissimoLevel(1, 0.5); +TetrissimoLevel.level2 = new TetrissimoLevel(2, 0.75); +TetrissimoLevel.level3 = new TetrissimoLevel(2, 1); +TetrissimoLevel.level4 = new TetrissimoLevel(2, 1.5); +TetrissimoLevel.level5 = new TetrissimoLevel(2, 2); +TetrissimoLevel.level6 = new TetrissimoLevel(2, 3); +TetrissimoLevel.level7 = new TetrissimoLevel(2, 4); +TetrissimoLevel.level8 = new TetrissimoLevel(2, 6); +TetrissimoLevel.level9 = new TetrissimoLevel(2, 8); +TetrissimoLevel.level10 = new TetrissimoLevel(2, 10); +class TetrissimoGame { + constructor(ui) { + this.startedAt = null; + this.pausedAt = null; + this.finishedAt = null; + this.state = 'not-started'; + this.fps = 60; + this.lastFrameTimes = []; + this.pieces = []; + this.currentLevel = TetrissimoLevel.level1; + this.msUntilNextTick = 0; + this.lastTick = new Date(); + this.lastUpdate = new Date(); + this.ui = ui; + } + getState() { + return this.state; + } + setTargetFps(fps) { + this.fps = fps; + } + setLevel(level) { + this.currentLevel = level; + } + getCurrentFps() { + switch (this.state) { + case 'running': + if (this.lastFrameTimes.length <= 1) { + return 0; + } + const firstFrame = this.lastFrameTimes[0]; + const lastFrame = this.lastFrameTimes[this.lastFrameTimes.length - 1]; + const elapsedMs = lastFrame - firstFrame; + const avgMsPerFrame = (elapsedMs / this.lastFrameTimes.length); + return 1000 / avgMsPerFrame; + case 'paused': + case 'not-started': + case 'finished': + return 0; + default: + nope(this.state); + throw new Error(`Invalid game state "${this.state}"`); + } + } + performPieceAction(action) { + if (this.state !== 'running') { + return; + } + const piece = this.pieces.filter(piece => piece.state === 'in-play')[0]; + if (!piece) { + // nothing to do, no pieces in play + return; + } + const movementIncrement = 1; + switch (action.type) { + case 'moveLeft': + this.moveIfValid(piece, -movementIncrement, 0); + break; + case 'moveRight': + this.moveIfValid(piece, movementIncrement, 0); + break; + case 'moveDown': + if (!this.moveIfValid(piece, 0, movementIncrement)) { + // make fixed to bottom of play area + piece.setFixed(); + } + break; + case 'rotateLeft': + // TODO ensure it's a valid move + piece.rotateLeft(); + break; + case 'rotateRight': + piece.rotateRight(); + break; + default: + nope(action.type); + throw new Error(`invalid action "${action.type}"`); + } + } + start() { + this.pausedAt = null; + switch (this.state) { + case 'running': + // no-op + break; + case 'paused': + case 'not-started': + this.lastTick = new Date(); + this.lastUpdate = new Date(); + this.startedAt = new Date(); + this.state = 'running'; + this.update(); + break; + case 'finished': + throw new Error('Cannot start a finished game'); + default: + nope(this.state); + throw new Error(`Invalid game state "${this.state}"`); + } + } + pause() { + switch (this.state) { + case 'running': + case 'paused': + this.pausedAt = new Date(); + this.state = 'paused'; + this.lastFrameTimes = []; + break; + case 'not-started': + case 'finished': + throw new Error(`Cannot pause game while it's in state "${this.state}"`); + default: + nope(this.state); + throw new Error(`Invalid game state "${this.state}"`); + } + } + update() { + const tickStart = Date.now(); + this.lastFrameTimes.push(tickStart); + if (this.lastFrameTimes.length > 20) { + this.lastFrameTimes.shift(); + } + switch (this.state) { + case 'running': + this.performUpdate(); + break; + case 'paused': + case 'not-started': + case 'finished': + throw new Error(`Cannot advance game while in state "${this.state}"`); + default: + nope(this.state); + throw new Error(`Invalid game state "${this.state}"`); + } + const elapsed = Date.now() - tickStart; + const nextTickTimeout = Math.max(0, (1000 / this.fps) - elapsed); + setTimeout(() => { + switch (this.state) { + case 'running': + this.update(); + break; + case 'paused': + case 'not-started': + case 'finished': + break; + default: + nope(this.state); + throw new Error(`Invalid game state "${this.state}"`); + } + }, nextTickTimeout); + } + performUpdate() { + const sinceLastUpdate = Date.now() - this.lastUpdate.getTime(); + this.msUntilNextTick -= sinceLastUpdate; + this.lastUpdate = new Date(); + if (this.msUntilNextTick <= 0) { + this.tick(); + } + // detect collision + // is every column filled? remove column + // is every row filled? end game + ui.update(); + } + moveIfValid(piece, xDelta, yDelta) { + const translation = { + xDelta, + yDelta, + }; + if (this.ui.canMovePiece(piece, translation)) { + piece.move(translation); + return true; + } + return false; + } + ; + tick() { + const inPlayPieces = this.pieces.filter(piece => piece.state === 'in-play'); + if (!inPlayPieces.length) { + const newPiece = TetrissimoPiece.T.clone(); + newPiece.state = 'in-play'; + this.pieces.push(newPiece); + this.ui.addPiece(newPiece); + } + else { + inPlayPieces.forEach((piece) => { + if (!this.moveIfValid(piece, 0, 1)) { + piece.setFixed(); + } + }); + } + this.msUntilNextTick = Math.round(1000 / this.currentLevel.movementsPerSecond); + this.lastTick = new Date(); + } +} +class TetrissimoUI { + constructor(canvas, playArea, + // nextBox: TetrissimoNextBox, + hud) { + this.pieces = []; + this.playArea = playArea; + // this.nextBox = nextBox; + this.hud = hud; + const context = canvas.getContext('2d'); + if (!context) { + throw new Error('failed to get 2d context'); + } + this.options = { + borderWidth: 1, + canvas: canvas, + context, + gridLines: 4, + hud: { + width: 32, + height: 12, + }, + playArea: { + width: 68, + height: 128, + }, + padding: 2, + pixelSize: 4, + }; + } + setOptions(options) { + Object.keys(options).forEach((key) => { + this.options[key] = options[key]; + }); + } + addPiece(piece) { + this.pieces.push(piece); + } + getPiecePosition(piece) { + const origin = this.getPieceOrigin(piece); + const offset = piece.getOffset(); + return { + x: origin.x + offset.x, + y: origin.y + offset.y, + }; + } + canMovePiece(piece, delta) { + // check each block in layout's edge to see if it's in a valid area?s + const layout = piece.getLayout(); + const position = this.getPiecePosition(piece); + for (let i = 0; i < layout.length; i++) { + const blockTopEdge = position.y + (i * TetrissimoPiece.blockLength) + (delta.yDelta * TetrissimoPiece.blockLength); + for (let j = 0; j < layout[i].length; j++) { + if (layout[i][j] === 0) { + continue; + } + const blockLeftEdge = position.x + (j * TetrissimoPiece.blockLength) + (delta.xDelta * TetrissimoPiece.blockLength); + const isCollision = this.hasCollision({ + x: blockLeftEdge, + y: blockTopEdge, + width: TetrissimoPiece.blockLength, + height: TetrissimoPiece.blockLength, + }); + if (isCollision) { + return false; + } + } + } + return true; + } + hasCollision(rect) { + const playAreaLeftEdge = this.options.padding; + const playAreaRightEdge = playAreaLeftEdge + this.options.playArea.width; + const playAreaTopEdge = this.options.padding; + const playAreaBottomEdge = playAreaTopEdge + this.options.playArea.height; + const leftEdge = rect.x; + const rightEdge = rect.x + rect.width; + const topEdge = rect.y; + const bottomEdge = rect.y + rect.height; + const isInPlayArea = leftEdge >= playAreaLeftEdge && + rightEdge <= playAreaRightEdge && + bottomEdge <= playAreaBottomEdge && + topEdge >= playAreaTopEdge; + if (!isInPlayArea) { + return true; + } + const fixedPieces = this.pieces.filter(piece => piece.state === 'fixed'); + for (const piece of fixedPieces) { + const position = this.getPiecePosition(piece); + const layout = piece.getLayout(); + for (let i = 0; i < layout.length; i++) { + const blockTopEdge = position.y + (i * TetrissimoPiece.blockLength); + const blockBottomEdge = blockTopEdge + TetrissimoPiece.blockLength; + for (let j = 0; j < layout[i].length; j++) { + if (layout[i][j] === 0) { + continue; + } + const blockLeftEdge = position.x + (j * TetrissimoPiece.blockLength); + const blockRightEdge = blockLeftEdge + TetrissimoPiece.blockLength; + const isCollision = leftEdge >= blockLeftEdge && + rightEdge <= blockRightEdge && + bottomEdge <= blockBottomEdge && + topEdge >= blockTopEdge; + if (isCollision) { + return true; + } + } + } + } + return false; + } + update() { + const options = this.options; + const context = this.options.context; + context.clearRect(0, 0, canvas.width, canvas.height); + // fill background + context.fillStyle = 'rgb(224,158,107)'; + context.fillRect(0, 0, canvas.width, canvas.height); + // draw some grid lines + if (typeof (options.gridLines) === 'number') { + context.strokeStyle = 'rgba(255, 255, 255, 0.25)'; + context.lineWidth = 1; + const increment = options.pixelSize * options.gridLines; + for (let i = 0; i < options.canvas.width; i += increment) { + // draw vertical line + context.beginPath(); + context.moveTo(i, 0); + context.lineTo(i, options.canvas.height); + context.stroke(); + } + for (let i = 0; i < options.canvas.height; i += increment) { + // draw horizontal lines + context.beginPath(); + context.moveTo(0, i); + context.lineTo(options.canvas.width, i); + context.stroke(); + } + } + const totalWidth = Math.floor(canvas.width / options.pixelSize); + const padding = options.padding; + // draw HUD in top right corner + this.hud.render(context, Object.assign(Object.assign({}, options), { x: totalWidth - padding - options.hud.width, y: padding })); + // draw play area + this.playArea.render(context, Object.assign(Object.assign({}, options), { x: padding, y: padding })); + this.pieces.forEach((piece, i) => { + piece.render(context, Object.assign(Object.assign({}, options), this.getPieceOrigin(piece))); + }); + } + getPieceOrigin(piece) { + const length = TetrissimoPiece.blockLength; + // TODO rotation will cause problems, need a "PieceDefinition" or something with a static layout + let translateX = Math.floor((piece.getBlockWidth() * length) / 2); + // we can only perform movements in multiples of the blockLength, so we must clamp it + // to ensure it's not offset + translateX -= (translateX % length); + const padding = this.options.padding; + return { + x: padding + Math.round(this.options.playArea.width / 2) - translateX, + y: padding, + }; + } +} +class TetrissimoNextBox { + render(context, options) { + } +} +class TetrissimoHUD { + render(context, options) { + const position = { + x: options.x, + y: options.y, + width: options.hud.width, + height: options.hud.height, + }; + drawBorderedRect(position, context, options); + } +} +class TetrissimoPlayArea { + render(context, options) { + const position = { + x: options.x, + y: options.y, + width: options.playArea.width, + height: options.playArea.height, + }; + drawBorderedRect(position, context, options); + } +} +class TetrissimoPiece { + constructor(name, layout, color) { + this.offset = { x: 0, y: 0 }; + this.state = 'in-play'; + this.name = name; + this.originalLayout = layout.map(row => row.concat([])); + this.layout = layout.concat([]); + this.color = color; + } + getOffset() { + return this.offset; + } + getLayout() { + return this.layout; + } + move(translation) { + if (this.state !== 'in-play') { + return; + } + this.offset.x += (translation.xDelta * TetrissimoPiece.blockLength); + this.offset.y += (translation.yDelta * TetrissimoPiece.blockLength); + } + rotateLeft() { + if (this.state !== 'in-play') { + return; + } + // clockwise turn + const newLayout = []; + for (let i = 0; i < this.layout.length; i++) { + const col = this.layout.length - 1 - i; + for (let j = 0; j < this.layout[i].length; j++) { + const row = j; + if (!newLayout[row]) { + newLayout[row] = []; + } + newLayout[row][col] = this.layout[i][j]; + } + } + this.layout = newLayout; + } + rotateRight() { + if (this.state !== 'in-play') { + return; + } + const newLayout = []; + for (let i = 0; i < this.layout.length; i++) { + const col = i; + for (let j = 0; j < this.layout[i].length; j++) { + const row = this.layout[i].length - 1 - j; + if (!newLayout[row]) { + newLayout[row] = []; + } + newLayout[row][col] = this.layout[i][j]; + } + } + this.layout = newLayout; + } + setFixed() { + this.state = 'fixed'; + } + getBlockWidth() { + return this.layout + .map(arr => arr.filter(value => value === 1).length) + .reduce((max, len) => Math.max(max, len), 0); + } + getBlockHeight() { + const cols = []; + for (let i = 0; i < this.layout.length; i++) { + for (let j = 0; j < this.layout[i].length; j++) { + if (!cols[j]) { + cols[j] = []; + } + cols[j].push(this.layout[i][j]); + } + } + return cols + .map(arr => arr.filter(value => value === 1).length) + .reduce((max, len) => Math.max(max, len), 0); + } + clone() { + return new TetrissimoPiece(this.name, this.layout, this.color); + } + render(context, options) { + this.layout.forEach((columns, rowNum) => { + columns.forEach((value, colNum) => { + switch (value) { + case 0: + break; + case 1: + context.fillStyle = this.color; + const length = TetrissimoPiece.blockLength; + const offsetX = this.offset.x; + const offsetY = this.offset.y; + const x = options.x + offsetX + (colNum * length); + const y = options.y + offsetY + (rowNum * length); + const actualLength = getSize(length, options); + context.fillRect(getSize(x, options), getSize(y, options), actualLength, actualLength); + break; + default: + nope(value); + throw new Error(`Invalid piece cell value "${value}"`); + } + }); + }); + } +} +TetrissimoPiece.blockLength = 4; +TetrissimoPiece.J = new TetrissimoPiece('J', [ + [0, 1], + [0, 1], + [1, 1], +], 'black'); +TetrissimoPiece.S = new TetrissimoPiece('S', [ + [0, 1, 1], + [1, 1, 0], +], 'green'); +TetrissimoPiece.T = new TetrissimoPiece('T', [ + [1, 1, 1], + [0, 1, 0], +], 'blue'); +TetrissimoPiece.Z = new TetrissimoPiece('Z', [ + [1, 1, 0,], + [0, 1, 1,], +], 'yellow'); +TetrissimoPiece.I = new TetrissimoPiece('I', [ + [1, 1, 1, 1], +], 'magenta'); +TetrissimoPiece.L = new TetrissimoPiece('L', [ + [1], + [1], + [1, 1], +], 'cyan'); +TetrissimoPiece.O = new TetrissimoPiece('O', [ + [1, 1], + [1, 1], +], 'red'); +// --------------------------------------------- +const hud = new TetrissimoHUD(); +const playArea = new TetrissimoPlayArea(); +const canvas = document.getElementsByTagName('canvas')[0]; +if (!canvas) { + throw new Error('no canvas'); +} +const ui = new TetrissimoUI(canvas, playArea, hud); +const game = new TetrissimoGame(ui); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tetrissimo.js","sourceRoot":"","sources":["tetrissimo.ts"],"names":[],"mappings":"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","sourcesContent":["type GameState = 'running' | 'paused' | 'not-started' | 'finished';\n\nconst nope = (x: never): void => {};\n\ntype PieceCell = 0 | 1;\ntype PieceLayout = PieceCell[][];\n\ninterface UIElement {\n\trender(context: CanvasRenderingContext2D, options: UIElementRenderOptions): void;\n}\n\ninterface Dimensions {\n\twidth: number;\n\theight: number;\n}\n\ninterface GlobalUIOptions {\n\tpixelSize: number;\n\tpadding: number;\n\tcanvas: HTMLCanvasElement;\n\tcontext: CanvasRenderingContext2D;\n\tgridLines: false | number;\n\tborderWidth: number;\n\thud: Dimensions;\n\tplayArea: Dimensions;\n}\n\ninterface UIElementRenderOptions extends GlobalUIOptions {\n\tx: number;\n\ty: number;\n}\n\ninterface PieceTranslation {\n\txDelta: number;\n\tyDelta: number;\n}\n\ninterface TetrissimoCoordinates {\n\tx: number;\n\ty: number;\n}\n\ninterface RectangleCoordinates extends TetrissimoCoordinates, Dimensions {}\n\ntype PieceActionType =\n\t'moveLeft' |\n\t'moveRight' |\n\t'moveDown' |\n\t'rotateLeft' |\n\t'rotateRight';\n\ninterface PieceAction {\n\ttype: PieceActionType;\n}\n\nconst getSize = (value: number, options: Pick<GlobalUIOptions, 'pixelSize'>): number => value * options.pixelSize;\n\nconst drawBorderedRect = (\n\tposition: Dimensions & TetrissimoCoordinates,\n\tcontext: CanvasRenderingContext2D,\n\toptions: UIElementRenderOptions,\n): void => {\n\tconst borderWidth = options.borderWidth;\n\tif (!borderWidth) {\n\t\treturn;\n\t}\n\n\tconst actualLineWidth = getSize(borderWidth, options);\n\tcontext.lineWidth = actualLineWidth;\n\tcontext.strokeStyle = 'white';\n\tcontext.strokeRect(\n\t\tgetSize(position.x, options) - Math.round(actualLineWidth / 2),\n\t\tgetSize(position.y, options) - Math.round(actualLineWidth / 2),\n\t\tgetSize(position.width, options) + actualLineWidth,\n\t\tgetSize(position.height, options) + actualLineWidth,\n\t);\n};\n\nclass TetrissimoLevel {\n\tpublic readonly order: number;\n\tpublic readonly movementsPerSecond: number;\n\n\tpublic static readonly level1 = new TetrissimoLevel(1, 0.5);\n\tpublic static readonly level2 = new TetrissimoLevel(2, 0.75);\n\tpublic static readonly level3 = new TetrissimoLevel(2, 1);\n\tpublic static readonly level4 = new TetrissimoLevel(2, 1.5);\n\tpublic static readonly level5 = new TetrissimoLevel(2, 2);\n\tpublic static readonly level6 = new TetrissimoLevel(2, 3);\n\tpublic static readonly level7 = new TetrissimoLevel(2, 4);\n\tpublic static readonly level8 = new TetrissimoLevel(2, 6);\n\tpublic static readonly level9 = new TetrissimoLevel(2, 8);\n\tpublic static readonly level10 = new TetrissimoLevel(2, 10);\n\n\tpublic constructor(order: number, speed: number) {\n\t\tthis.order = order;\n\t\tthis.movementsPerSecond = speed;\n\t}\n}\n\nclass TetrissimoGame {\n\tprivate startedAt: Date | null = null;\n\tprivate pausedAt: Date | null = null;\n\tprivate finishedAt: Date | null = null;\n\tprivate state: GameState = 'not-started';\n\tprivate fps = 60;\n\tprivate readonly ui: TetrissimoUI;\n\tprivate lastFrameTimes: number[] = [];\n\tprivate readonly pieces: TetrissimoPiece[] = [];\n\tpublic currentLevel: TetrissimoLevel = TetrissimoLevel.level1;\n\tprivate msUntilNextTick = 0;\n\tprivate lastTick = new Date();\n\tprivate lastUpdate = new Date();\n\n\tpublic constructor(ui: TetrissimoUI) {\n\t\tthis.ui = ui;\n\t}\n\n\tpublic getState(): GameState {\n\t\treturn this.state;\n\t}\n\n\tpublic setTargetFps(fps: number) {\n\t\tthis.fps = fps;\n\t}\n\n\tpublic setLevel(level: TetrissimoLevel) {\n\t\tthis.currentLevel = level;\n\t}\n\n\tpublic getCurrentFps(): number {\n\t\tswitch (this.state) {\n\t\t\tcase 'running':\n\t\t\t\tif (this.lastFrameTimes.length <= 1) {\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\n\t\t\t\tconst firstFrame = this.lastFrameTimes[0];\n\t\t\t\tconst lastFrame = this.lastFrameTimes[this.lastFrameTimes.length - 1];\n\t\t\t\tconst elapsedMs = lastFrame - firstFrame;\n\t\t\t\tconst avgMsPerFrame = (elapsedMs / this.lastFrameTimes.length);\n\t\t\t\treturn 1000 / avgMsPerFrame;\n\t\t\tcase 'paused':\n\t\t\tcase 'not-started':\n\t\t\tcase 'finished':\n\t\t\t\treturn 0;\n\t\t\tdefault:\n\t\t\t\tnope(this.state);\n\t\t\t\tthrow new Error(`Invalid game state \"${this.state}\"`);\n\t\t}\n\t}\n\n\tpublic performPieceAction(action: PieceAction) {\n\t\tif (this.state !== 'running') {\n\t\t\treturn;\n\t\t}\n\n\t\tconst piece = this.pieces.filter(piece => piece.state === 'in-play')[0];\n\t\tif (!piece) {\n\t\t\t// nothing to do, no pieces in play\n\t\t\treturn;\n\t\t}\n\n\t\tconst movementIncrement = 1;\n\n\t\tswitch (action.type) {\n\t\t\tcase 'moveLeft':\n\t\t\t\tthis.moveIfValid(piece, -movementIncrement, 0);\n\t\t\t\tbreak;\n\t\t\tcase 'moveRight':\n\t\t\t\tthis.moveIfValid(piece, movementIncrement, 0);\n\t\t\t\tbreak;\n\t\t\tcase 'moveDown':\n\t\t\t\tif (!this.moveIfValid(piece, 0, movementIncrement)) {\n\t\t\t\t\t// make fixed to bottom of play area\n\t\t\t\t\tpiece.setFixed();\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 'rotateLeft':\n\t\t\t\t// TODO ensure it's a valid move\n\t\t\t\tpiece.rotateLeft();\n\t\t\t\tbreak;\n\t\t\tcase 'rotateRight':\n\t\t\t\tpiece.rotateRight();\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tnope(action.type);\n\t\t\t\tthrow new Error(`invalid action \"${action.type}\"`);\n\t\t}\n\t}\n\n\tpublic start() {\n\t\tthis.pausedAt = null;\n\n\t\tswitch (this.state) {\n\t\t\tcase 'running':\n\t\t\t\t// no-op\n\t\t\t\tbreak;\n\t\t\tcase 'paused':\n\t\t\tcase 'not-started':\n\t\t\t\tthis.lastTick = new Date();\n\t\t\t\tthis.lastUpdate = new Date();\n\t\t\t\tthis.startedAt = new Date();\n\t\t\t\tthis.state = 'running';\n\t\t\t\tthis.update();\n\t\t\t\tbreak;\n\t\t\tcase 'finished':\n\t\t\t\tthrow new Error('Cannot start a finished game');\n\t\t\tdefault:\n\t\t\t\tnope(this.state);\n\t\t\t\tthrow new Error(`Invalid game state \"${this.state}\"`);\n\t\t}\n\t}\n\n\tpublic pause() {\n\t\tswitch (this.state) {\n\t\t\tcase 'running':\n\t\t\tcase 'paused':\n\t\t\t\tthis.pausedAt = new Date();\n\t\t\t\tthis.state = 'paused';\n\t\t\t\tthis.lastFrameTimes = [];\n\t\t\t\tbreak;\n\t\t\tcase 'not-started':\n\t\t\tcase 'finished':\n\t\t\t\tthrow new Error(`Cannot pause game while it's in state \"${this.state}\"`);\n\t\t\tdefault:\n\t\t\t\tnope(this.state);\n\t\t\t\tthrow new Error(`Invalid game state \"${this.state}\"`);\n\t\t}\n\t}\n\n\tpublic update(): void {\n\t\tconst tickStart = Date.now();\n\t\tthis.lastFrameTimes.push(tickStart);\n\t\tif (this.lastFrameTimes.length > 20) {\n\t\t\tthis.lastFrameTimes.shift();\n\t\t}\n\n\t\tswitch (this.state) {\n\t\t\tcase 'running':\n\t\t\t\tthis.performUpdate();\n\t\t\t\tbreak;\n\t\t\tcase 'paused':\n\t\t\tcase 'not-started':\n\t\t\tcase 'finished':\n\t\t\t\tthrow new Error(`Cannot advance game while in state \"${this.state}\"`);\n\t\t\tdefault:\n\t\t\t\tnope(this.state);\n\t\t\t\tthrow new Error(`Invalid game state \"${this.state}\"`);\n\t\t}\n\n\t\tconst elapsed = Date.now() - tickStart;\n\t\tconst nextTickTimeout = Math.max(0, (1000 / this.fps) - elapsed);\n\t\tsetTimeout(() => {\n\t\t\tswitch (this.state) {\n\t\t\t\tcase 'running':\n\t\t\t\t\tthis.update();\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'paused':\n\t\t\t\tcase 'not-started':\n\t\t\t\tcase 'finished':\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tnope(this.state);\n\t\t\t\t\tthrow new Error(`Invalid game state \"${this.state}\"`);\n\t\t\t}\n\t\t}, nextTickTimeout);\n\t}\n\n\tprivate performUpdate(): void {\n\t\tconst sinceLastUpdate = Date.now() - this.lastUpdate.getTime();\n\t\tthis.msUntilNextTick -= sinceLastUpdate;\n\t\tthis.lastUpdate = new Date();\n\n\t\tif (this.msUntilNextTick <= 0) {\n\t\t\tthis.tick();\n\t\t}\n\n\t\t// detect collision\n\t\t// is every column filled? remove column\n\t\t// is every row filled? end game\n\n\t\tui.update();\n\t}\n\n\tprivate moveIfValid(piece: TetrissimoPiece, xDelta: number, yDelta: number): boolean {\n\t\tconst translation: PieceTranslation = {\n\t\t\txDelta,\n\t\t\tyDelta,\n\t\t};\n\t\tif (this.ui.canMovePiece(piece, translation)) {\n\t\t\tpiece.move(translation);\n\t\t\treturn true;\n\t\t}\n\n\t\treturn false;\n\t};\n\n\tprivate tick(): void {\n\t\tconst inPlayPieces = this.pieces.filter(piece => piece.state === 'in-play');\n\t\tif (!inPlayPieces.length) {\n\t\t\tconst newPiece = TetrissimoPiece.T.clone();\n\t\t\tnewPiece.state = 'in-play';\n\t\t\tthis.pieces.push(newPiece);\n\t\t\tthis.ui.addPiece(newPiece);\n\t\t} else {\n\t\t\tinPlayPieces.forEach((piece) => {\n\t\t\t\tif (!this.moveIfValid(piece, 0, 1)) {\n\t\t\t\t\tpiece.setFixed();\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\tthis.msUntilNextTick = Math.round(1000 / this.currentLevel.movementsPerSecond);\n\t\tthis.lastTick = new Date();\n\t}\n}\n\nclass TetrissimoUI {\n\tpublic readonly playArea: TetrissimoPlayArea;\n\tprivate readonly pieces: Array<Readonly<TetrissimoPiece>> = [];\n\tpublic readonly nextBox: TetrissimoNextBox;\n\tpublic readonly hud: TetrissimoHUD;\n\tpublic readonly options: GlobalUIOptions;\n\n\tpublic constructor(\n\t\tcanvas: HTMLCanvasElement,\n\t\tplayArea: TetrissimoPlayArea,\n\t\t// nextBox: TetrissimoNextBox,\n\t\thud: TetrissimoHUD,\n\t) {\n\t\tthis.playArea = playArea;\n\t\t// this.nextBox = nextBox;\n\t\tthis.hud = hud;\n\n\t\tconst context = canvas.getContext('2d');\n\t\tif (!context) {\n\t\t\tthrow new Error('failed to get 2d context');\n\t\t}\n\t\tthis.options = {\n\t\t\tborderWidth: 1,\n\t\t\tcanvas: canvas,\n\t\t\tcontext,\n\t\t\tgridLines: 4,\n\t\t\thud: {\n\t\t\t\twidth: 32,\n\t\t\t\theight: 12,\n\t\t\t},\n\t\t\tplayArea: {\n\t\t\t\twidth: 68,\n\t\t\t\theight: 128,\n\t\t\t},\n\t\t\tpadding: 2,\n\t\t\tpixelSize: 4,\n\t\t};\n\t}\n\n\tpublic setOptions(options: Omit<GlobalUIOptions, 'canvas' | 'context'>) {\n\t\tObject.keys(options).forEach((key) => {\n\t\t\tthis.options[key] = options[key];\n\t\t});\n\t}\n\n\tpublic addPiece(piece: TetrissimoPiece) {\n\t\tthis.pieces.push(piece);\n\t}\n\n\tprivate getPiecePosition(piece: Readonly<TetrissimoPiece>): TetrissimoCoordinates {\n\t\tconst origin = this.getPieceOrigin(piece);\n\t\tconst offset = piece.getOffset();\n\n\t\treturn {\n\t\t\tx: origin.x + offset.x,\n\t\t\ty: origin.y + offset.y,\n\t\t};\n\t}\n\n\tpublic canMovePiece(piece: Readonly<TetrissimoPiece>, delta: PieceTranslation): boolean {\n\t\t// check each block in layout's edge to see if it's in a valid area?s\n\n\t\tconst layout = piece.getLayout();\n\t\tconst position = this.getPiecePosition(piece);\n\n\t\tfor (let i = 0; i < layout.length; i++) {\n\t\t\tconst blockTopEdge = position.y + (i * TetrissimoPiece.blockLength) + (delta.yDelta * TetrissimoPiece.blockLength);\n\t\t\tfor (let j = 0; j < layout[i].length; j++) {\n\t\t\t\tif (layout[i][j] === 0) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tconst blockLeftEdge = position.x + (j * TetrissimoPiece.blockLength) + (delta.xDelta * TetrissimoPiece.blockLength);\n\n\t\t\t\tconst isCollision = this.hasCollision({\n\t\t\t\t\tx: blockLeftEdge,\n\t\t\t\t\ty: blockTopEdge,\n\t\t\t\t\twidth: TetrissimoPiece.blockLength,\n\t\t\t\t\theight: TetrissimoPiece.blockLength,\n\t\t\t\t});\n\n\t\t\t\tif (isCollision) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t}\n\n\tprivate hasCollision(rect: RectangleCoordinates): boolean {\n\t\tconst playAreaLeftEdge = this.options.padding;\n\t\tconst playAreaRightEdge = playAreaLeftEdge + this.options.playArea.width;\n\t\tconst playAreaTopEdge = this.options.padding;\n\t\tconst playAreaBottomEdge = playAreaTopEdge + this.options.playArea.height;\n\n\t\tconst leftEdge = rect.x;\n\t\tconst rightEdge = rect.x + rect.width;\n\t\tconst topEdge = rect.y;\n\t\tconst bottomEdge = rect.y + rect.height;\n\n\t\tconst isInPlayArea =\n\t\t\tleftEdge >= playAreaLeftEdge &&\n\t\t\trightEdge <= playAreaRightEdge &&\n\t\t\tbottomEdge <= playAreaBottomEdge &&\n\t\t\ttopEdge >= playAreaTopEdge;\n\n\t\tif (!isInPlayArea) {\n\t\t\treturn true;\n\t\t}\n\n\t\tconst fixedPieces = this.pieces.filter(piece => piece.state === 'fixed');\n\t\tfor (const piece of fixedPieces) {\n\t\t\tconst position = this.getPiecePosition(piece);\n\t\t\tconst layout = piece.getLayout();\n\t\t\tfor (let i = 0; i < layout.length; i++) {\n\t\t\t\tconst blockTopEdge = position.y + (i * TetrissimoPiece.blockLength);\n\t\t\t\tconst blockBottomEdge = blockTopEdge + TetrissimoPiece.blockLength;\n\t\t\t\tfor (let j = 0; j < layout[i].length; j++) {\n\t\t\t\t\tif (layout[i][j] === 0) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\n\t\t\t\t\tconst blockLeftEdge = position.x + (j * TetrissimoPiece.blockLength);\n\t\t\t\t\tconst blockRightEdge = blockLeftEdge + TetrissimoPiece.blockLength;\n\n\t\t\t\t\tconst isCollision =\n\t\t\t\t\t\tleftEdge >= blockLeftEdge &&\n\t\t\t\t\t\trightEdge <= blockRightEdge &&\n\t\t\t\t\t\tbottomEdge <= blockBottomEdge &&\n\t\t\t\t\t\ttopEdge >= blockTopEdge;\n\n\t\t\t\t\tif (isCollision) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\tpublic update() {\n\t\tconst options = this.options;\n\t\tconst context = this.options.context;\n\n\t\tcontext.clearRect(0, 0, canvas.width, canvas.height);\n\n\t\t// fill background\n\t\tcontext.fillStyle = 'rgb(224,158,107)';\n\t\tcontext.fillRect(0, 0, canvas.width, canvas.height);\n\n\t\t// draw some grid lines\n\t\tif (typeof(options.gridLines) === 'number') {\n\t\t\tcontext.strokeStyle = 'rgba(255, 255, 255, 0.25)';\n\t\t\tcontext.lineWidth = 1;\n\t\t\tconst increment = options.pixelSize * options.gridLines;\n\t\t\tfor (let i = 0; i < options.canvas.width; i += increment) {\n\t\t\t\t// draw vertical line\n\t\t\t\tcontext.beginPath();\n\t\t\t\tcontext.moveTo(i, 0);\n\t\t\t\tcontext.lineTo(i, options.canvas.height);\n\t\t\t\tcontext.stroke();\n\t\t\t}\n\t\t\tfor (let i = 0; i < options.canvas.height; i += increment) {\n\t\t\t\t// draw horizontal lines\n\t\t\t\tcontext.beginPath();\n\t\t\t\tcontext.moveTo(0, i);\n\t\t\t\tcontext.lineTo(options.canvas.width, i);\n\t\t\t\tcontext.stroke();\n\t\t\t}\n\t\t}\n\n\t\tconst totalWidth = Math.floor(canvas.width / options.pixelSize);\n\t\tconst padding = options.padding;\n\n\t\t// draw HUD in top right corner\n\t\tthis.hud.render(context, {\n\t\t\t...options,\n\t\t\tx: totalWidth - padding - options.hud.width,\n\t\t\ty: padding,\n\t\t});\n\n\t\t// draw play area\n\t\tthis.playArea.render(context, {\n\t\t\t...options,\n\t\t\tx: padding,\n\t\t\ty: padding,\n\t\t});\n\n\t\tthis.pieces.forEach((piece, i) => {\n\t\t\tpiece.render(context, {\n\t\t\t\t...options,\n\t\t\t\t...this.getPieceOrigin(piece),\n\t\t\t});\n\t\t});\n\t}\n\n\tprivate getPieceOrigin(piece: Readonly<TetrissimoPiece>): TetrissimoCoordinates {\n\t\tconst length = TetrissimoPiece.blockLength;\n\t\t// TODO rotation will cause problems, need a \"PieceDefinition\" or something with a static layout\n\t\tlet translateX = Math.floor((piece.getBlockWidth() * length) / 2);\n\n\t\t// we can only perform movements in multiples of the blockLength, so we must clamp it\n\t\t// to ensure it's not offset\n\t\ttranslateX -= (translateX % length);\n\t\tconst padding = this.options.padding;\n\t\treturn {\n\t\t\tx: padding + Math.round(this.options.playArea.width / 2) - translateX,\n\t\t\ty: padding,\n\t\t};\n\t}\n}\n\nclass TetrissimoNextBox implements UIElement {\n\tpublic render(context: CanvasRenderingContext2D, options: UIElementRenderOptions) {\n\n\t}\n}\n\nclass TetrissimoHUD implements UIElement {\n\tpublic render(context: CanvasRenderingContext2D, options: UIElementRenderOptions) {\n\t\tconst position = {\n\t\t\tx: options.x,\n\t\t\ty: options.y,\n\t\t\twidth: options.hud.width,\n\t\t\theight: options.hud.height,\n\t\t};\n\t\tdrawBorderedRect(position, context, options);\n\t}\n}\n\nclass TetrissimoPlayArea implements UIElement {\n\tpublic render(context: CanvasRenderingContext2D, options: UIElementRenderOptions) {\n\t\tconst position = {\n\t\t\tx: options.x,\n\t\t\ty: options.y,\n\t\t\twidth: options.playArea.width,\n\t\t\theight: options.playArea.height,\n\t\t};\n\t\tdrawBorderedRect(position, context, options);\n\t}\n}\n\ntype PieceState = 'in-play' | 'fixed';\n\nclass TetrissimoPiece implements UIElement {\n\tpublic readonly name: string;\n\tprivate readonly originalLayout: Readonly<PieceLayout>;\n\tprivate layout: PieceLayout;\n\tprivate offset: TetrissimoCoordinates = { x: 0, y: 0 };\n\tprivate readonly color: string;\n\tpublic static readonly blockLength = 4;\n\tpublic state: PieceState = 'in-play';\n\n\tpublic static readonly J = new TetrissimoPiece(\n\t\t'J',\n\t\t[\n\t\t\t[0, 1],\n\t\t\t[0, 1],\n\t\t\t[1, 1],\n\t\t],\n\t\t'black',\n\t);\n\tpublic static readonly S: TetrissimoPiece = new TetrissimoPiece(\n\t\t'S',\n\t\t[\n\t\t\t[0, 1, 1],\n\t\t\t[1, 1, 0],\n\t\t],\n\t\t'green',\n\t);\n\tpublic static readonly T: TetrissimoPiece = new TetrissimoPiece(\n\t\t'T',\n\t\t[\n\t\t\t[1, 1, 1],\n\t\t\t[0, 1, 0],\n\t\t],\n\t\t'blue',\n\t);\n\tpublic static readonly Z: TetrissimoPiece = new TetrissimoPiece(\n\t\t'Z',\n\t\t[\n\t\t\t[1, 1, 0,],\n\t\t\t[0, 1, 1,],\n\t\t],\n\t\t'yellow',\n\t);\n\tpublic static readonly I: TetrissimoPiece = new TetrissimoPiece(\n\t\t'I',\n\t\t[\n\t\t\t[1, 1, 1, 1],\n\t\t],\n\t\t'magenta',\n\t);\n\tpublic static readonly L: TetrissimoPiece = new TetrissimoPiece(\n\t\t'L',\n\t\t[\n\t\t\t[1],\n\t\t\t[1],\n\t\t\t[1, 1],\n\t\t],\n\t\t'cyan',\n\t);\n\tpublic static readonly O: TetrissimoPiece = new TetrissimoPiece(\n\t\t'O',\n\t\t[\n\t\t\t[1, 1],\n\t\t\t[1, 1],\n\t\t],\n\t\t'red',\n\t);\n\n\tpublic constructor(name: string, layout: PieceLayout, color: string) {\n\t\tthis.name = name;\n\t\tthis.originalLayout = layout.map(row => row.concat([]));\n\t\tthis.layout = layout.concat([]);\n\t\tthis.color = color;\n\t}\n\n\tpublic getOffset(): Readonly<TetrissimoCoordinates> {\n\t\treturn this.offset;\n\t}\n\n\tpublic getLayout(): Readonly<PieceLayout> {\n\t\treturn this.layout;\n\t}\n\n\tpublic move(translation: PieceTranslation) {\n\t\tif (this.state !== 'in-play') {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.offset.x += (translation.xDelta * TetrissimoPiece.blockLength);\n\t\tthis.offset.y += (translation.yDelta * TetrissimoPiece.blockLength);\n\t}\n\n\tpublic rotateLeft() {\n\t\tif (this.state !== 'in-play') {\n\t\t\treturn;\n\t\t}\n\n\t\t// clockwise turn\n\t\tconst newLayout: PieceLayout = [];\n\t\tfor (let i = 0; i < this.layout.length; i++) {\n\t\t\tconst col = this.layout.length - 1 - i;\n\t\t\tfor (let j = 0; j < this.layout[i].length; j++) {\n\t\t\t\tconst row = j;\n\t\t\t\tif (!newLayout[row]) {\n\t\t\t\t\tnewLayout[row] = [];\n\t\t\t\t}\n\t\t\t\tnewLayout[row][col] = this.layout[i][j];\n\t\t\t}\n\t\t}\n\n\t\tthis.layout = newLayout;\n\t}\n\n\tpublic rotateRight() {\n\t\tif (this.state !== 'in-play') {\n\t\t\treturn;\n\t\t}\n\n\t\tconst newLayout: PieceLayout = [];\n\t\tfor (let i = 0; i < this.layout.length; i++) {\n\t\t\tconst col = i;\n\t\t\tfor (let j = 0; j < this.layout[i].length; j++) {\n\t\t\t\tconst row = this.layout[i].length - 1 - j;\n\t\t\t\tif (!newLayout[row]) {\n\t\t\t\t\tnewLayout[row] = [];\n\t\t\t\t}\n\t\t\t\tnewLayout[row][col] = this.layout[i][j];\n\t\t\t}\n\t\t}\n\n\t\tthis.layout = newLayout;\n\t}\n\n\tpublic setFixed() {\n\t\tthis.state = 'fixed';\n\t}\n\n\tpublic getBlockWidth(): number {\n\t\treturn this.layout\n\t\t\t.map(arr => arr.filter(value => value === 1).length)\n\t\t\t.reduce((max, len) => Math.max(max, len), 0);\n\t}\n\n\tpublic getBlockHeight(): number {\n\t\tconst cols: PieceCell[][] = [];\n\t\tfor (let i = 0; i < this.layout.length; i++) {\n\t\t\tfor (let j = 0; j < this.layout[i].length; j++) {\n\t\t\t\tif (!cols[j]) {\n\t\t\t\t\tcols[j] = [];\n\t\t\t\t}\n\t\t\t\tcols[j].push(this.layout[i][j]);\n\t\t\t}\n\t\t}\n\n\t\treturn cols\n\t\t\t.map(arr => arr.filter(value => value === 1).length)\n\t\t\t.reduce((max, len) => Math.max(max, len), 0);\n\t}\n\n\tpublic clone(): TetrissimoPiece {\n\t\treturn new TetrissimoPiece(this.name, this.layout, this.color);\n\t}\n\n\tpublic render(context: CanvasRenderingContext2D, options: UIElementRenderOptions) {\n\t\tthis.layout.forEach((columns, rowNum) => {\n\t\t\tcolumns.forEach((value, colNum) => {\n\t\t\t\tswitch (value) {\n\t\t\t\t\tcase 0:\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 1:\n\t\t\t\t\t\tcontext.fillStyle = this.color;\n\t\t\t\t\t\tconst length = TetrissimoPiece.blockLength;\n\t\t\t\t\t\tconst offsetX = this.offset.x;\n\t\t\t\t\t\tconst offsetY = this.offset.y;\n\n\t\t\t\t\t\tconst x = options.x + offsetX + (colNum * length);\n\t\t\t\t\t\tconst y = options.y + offsetY + (rowNum * length);\n\t\t\t\t\t\tconst actualLength = getSize(length, options);\n\t\t\t\t\t\tcontext.fillRect(getSize(x, options), getSize(y, options), actualLength, actualLength);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tnope(value);\n\t\t\t\t\t\tthrow new Error(`Invalid piece cell value \"${value}\"`);\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t}\n}\n\n// ---------------------------------------------\n\nconst hud = new TetrissimoHUD();\nconst playArea = new TetrissimoPlayArea();\n\nconst canvas = document.getElementsByTagName('canvas')[0];\nif (!canvas) {\n\tthrow new Error('no canvas');\n}\n\nconst ui = new TetrissimoUI(canvas, playArea, hud);\nconst game = new TetrissimoGame(ui);\n\n"]} \ No newline at end of file diff --git a/tetrissimo.ts b/tetrissimo.ts new file mode 100644 index 0000000..6abf483 --- /dev/null +++ b/tetrissimo.ts @@ -0,0 +1,764 @@ +type GameState = 'running' | 'paused' | 'not-started' | 'finished'; + +const nope = (x: never): void => {}; + +type PieceCell = 0 | 1; +type PieceLayout = PieceCell[][]; + +interface UIElement { + render(context: CanvasRenderingContext2D, options: UIElementRenderOptions): void; +} + +interface Dimensions { + width: number; + height: number; +} + +interface GlobalUIOptions { + pixelSize: number; + padding: number; + canvas: HTMLCanvasElement; + context: CanvasRenderingContext2D; + gridLines: false | number; + borderWidth: number; + hud: Dimensions; + playArea: Dimensions; +} + +interface UIElementRenderOptions extends GlobalUIOptions { + x: number; + y: number; +} + +interface PieceTranslation { + xDelta: number; + yDelta: number; +} + +interface TetrissimoCoordinates { + x: number; + y: number; +} + +interface RectangleCoordinates extends TetrissimoCoordinates, Dimensions {} + +type PieceActionType = + 'moveLeft' | + 'moveRight' | + 'moveDown' | + 'rotateLeft' | + 'rotateRight'; + +interface PieceAction { + type: PieceActionType; +} + +const getSize = (value: number, options: Pick): number => value * options.pixelSize; + +const drawBorderedRect = ( + position: Dimensions & TetrissimoCoordinates, + context: CanvasRenderingContext2D, + options: UIElementRenderOptions, +): void => { + const borderWidth = options.borderWidth; + if (!borderWidth) { + return; + } + + const actualLineWidth = getSize(borderWidth, options); + context.lineWidth = actualLineWidth; + context.strokeStyle = 'white'; + context.strokeRect( + getSize(position.x, options) - Math.round(actualLineWidth / 2), + getSize(position.y, options) - Math.round(actualLineWidth / 2), + getSize(position.width, options) + actualLineWidth, + getSize(position.height, options) + actualLineWidth, + ); +}; + +class TetrissimoLevel { + public readonly order: number; + public readonly movementsPerSecond: number; + + public static readonly level1 = new TetrissimoLevel(1, 0.5); + public static readonly level2 = new TetrissimoLevel(2, 0.75); + public static readonly level3 = new TetrissimoLevel(2, 1); + public static readonly level4 = new TetrissimoLevel(2, 1.5); + public static readonly level5 = new TetrissimoLevel(2, 2); + public static readonly level6 = new TetrissimoLevel(2, 3); + public static readonly level7 = new TetrissimoLevel(2, 4); + public static readonly level8 = new TetrissimoLevel(2, 6); + public static readonly level9 = new TetrissimoLevel(2, 8); + public static readonly level10 = new TetrissimoLevel(2, 10); + + public constructor(order: number, speed: number) { + this.order = order; + this.movementsPerSecond = speed; + } +} + +class TetrissimoGame { + private startedAt: Date | null = null; + private pausedAt: Date | null = null; + private finishedAt: Date | null = null; + private state: GameState = 'not-started'; + private fps = 60; + private readonly ui: TetrissimoUI; + private lastFrameTimes: number[] = []; + private readonly pieces: TetrissimoPiece[] = []; + public currentLevel: TetrissimoLevel = TetrissimoLevel.level1; + private msUntilNextTick = 0; + private lastTick = new Date(); + private lastUpdate = new Date(); + + public constructor(ui: TetrissimoUI) { + this.ui = ui; + } + + public getState(): GameState { + return this.state; + } + + public setTargetFps(fps: number) { + this.fps = fps; + } + + public setLevel(level: TetrissimoLevel) { + this.currentLevel = level; + } + + public getCurrentFps(): number { + switch (this.state) { + case 'running': + if (this.lastFrameTimes.length <= 1) { + return 0; + } + + const firstFrame = this.lastFrameTimes[0]; + const lastFrame = this.lastFrameTimes[this.lastFrameTimes.length - 1]; + const elapsedMs = lastFrame - firstFrame; + const avgMsPerFrame = (elapsedMs / this.lastFrameTimes.length); + return 1000 / avgMsPerFrame; + case 'paused': + case 'not-started': + case 'finished': + return 0; + default: + nope(this.state); + throw new Error(`Invalid game state "${this.state}"`); + } + } + + public performPieceAction(action: PieceAction) { + if (this.state !== 'running') { + return; + } + + const piece = this.pieces.filter(piece => piece.state === 'in-play')[0]; + if (!piece) { + // nothing to do, no pieces in play + return; + } + + const movementIncrement = 1; + + switch (action.type) { + case 'moveLeft': + this.moveIfValid(piece, -movementIncrement, 0); + break; + case 'moveRight': + this.moveIfValid(piece, movementIncrement, 0); + break; + case 'moveDown': + if (!this.moveIfValid(piece, 0, movementIncrement)) { + // make fixed to bottom of play area + piece.setFixed(); + } + break; + case 'rotateLeft': + // TODO ensure it's a valid move + piece.rotateLeft(); + break; + case 'rotateRight': + piece.rotateRight(); + break; + default: + nope(action.type); + throw new Error(`invalid action "${action.type}"`); + } + } + + public start() { + this.pausedAt = null; + + switch (this.state) { + case 'running': + // no-op + break; + case 'paused': + case 'not-started': + this.lastTick = new Date(); + this.lastUpdate = new Date(); + this.startedAt = new Date(); + this.state = 'running'; + this.update(); + break; + case 'finished': + throw new Error('Cannot start a finished game'); + default: + nope(this.state); + throw new Error(`Invalid game state "${this.state}"`); + } + } + + public pause() { + switch (this.state) { + case 'running': + case 'paused': + this.pausedAt = new Date(); + this.state = 'paused'; + this.lastFrameTimes = []; + break; + case 'not-started': + case 'finished': + throw new Error(`Cannot pause game while it's in state "${this.state}"`); + default: + nope(this.state); + throw new Error(`Invalid game state "${this.state}"`); + } + } + + public update(): void { + const tickStart = Date.now(); + this.lastFrameTimes.push(tickStart); + if (this.lastFrameTimes.length > 20) { + this.lastFrameTimes.shift(); + } + + switch (this.state) { + case 'running': + this.performUpdate(); + break; + case 'paused': + case 'not-started': + case 'finished': + throw new Error(`Cannot advance game while in state "${this.state}"`); + default: + nope(this.state); + throw new Error(`Invalid game state "${this.state}"`); + } + + const elapsed = Date.now() - tickStart; + const nextTickTimeout = Math.max(0, (1000 / this.fps) - elapsed); + setTimeout(() => { + switch (this.state) { + case 'running': + this.update(); + break; + case 'paused': + case 'not-started': + case 'finished': + break; + default: + nope(this.state); + throw new Error(`Invalid game state "${this.state}"`); + } + }, nextTickTimeout); + } + + private performUpdate(): void { + const sinceLastUpdate = Date.now() - this.lastUpdate.getTime(); + this.msUntilNextTick -= sinceLastUpdate; + this.lastUpdate = new Date(); + + if (this.msUntilNextTick <= 0) { + this.tick(); + } + + // detect collision + // is every column filled? remove column + // is every row filled? end game + + ui.update(); + } + + private moveIfValid(piece: TetrissimoPiece, xDelta: number, yDelta: number): boolean { + const translation: PieceTranslation = { + xDelta, + yDelta, + }; + if (this.ui.canMovePiece(piece, translation)) { + piece.move(translation); + return true; + } + + return false; + }; + + private tick(): void { + const inPlayPieces = this.pieces.filter(piece => piece.state === 'in-play'); + if (!inPlayPieces.length) { + const newPiece = TetrissimoPiece.T.clone(); + newPiece.state = 'in-play'; + this.pieces.push(newPiece); + this.ui.addPiece(newPiece); + } else { + inPlayPieces.forEach((piece) => { + if (!this.moveIfValid(piece, 0, 1)) { + piece.setFixed(); + } + }); + } + + this.msUntilNextTick = Math.round(1000 / this.currentLevel.movementsPerSecond); + this.lastTick = new Date(); + } +} + +class TetrissimoUI { + public readonly playArea: TetrissimoPlayArea; + private readonly pieces: Array> = []; + public readonly nextBox: TetrissimoNextBox; + public readonly hud: TetrissimoHUD; + public readonly options: GlobalUIOptions; + + public constructor( + canvas: HTMLCanvasElement, + playArea: TetrissimoPlayArea, + // nextBox: TetrissimoNextBox, + hud: TetrissimoHUD, + ) { + this.playArea = playArea; + // this.nextBox = nextBox; + this.hud = hud; + + const context = canvas.getContext('2d'); + if (!context) { + throw new Error('failed to get 2d context'); + } + this.options = { + borderWidth: 1, + canvas: canvas, + context, + gridLines: 4, + hud: { + width: 32, + height: 12, + }, + playArea: { + width: 68, + height: 128, + }, + padding: 2, + pixelSize: 4, + }; + } + + public setOptions(options: Omit) { + Object.keys(options).forEach((key) => { + this.options[key] = options[key]; + }); + } + + public addPiece(piece: TetrissimoPiece) { + this.pieces.push(piece); + } + + private getPiecePosition(piece: Readonly): TetrissimoCoordinates { + const origin = this.getPieceOrigin(piece); + const offset = piece.getOffset(); + + return { + x: origin.x + offset.x, + y: origin.y + offset.y, + }; + } + + public canMovePiece(piece: Readonly, delta: PieceTranslation): boolean { + // check each block in layout's edge to see if it's in a valid area?s + + const layout = piece.getLayout(); + const position = this.getPiecePosition(piece); + + for (let i = 0; i < layout.length; i++) { + const blockTopEdge = position.y + (i * TetrissimoPiece.blockLength) + (delta.yDelta * TetrissimoPiece.blockLength); + for (let j = 0; j < layout[i].length; j++) { + if (layout[i][j] === 0) { + continue; + } + + const blockLeftEdge = position.x + (j * TetrissimoPiece.blockLength) + (delta.xDelta * TetrissimoPiece.blockLength); + + const isCollision = this.hasCollision({ + x: blockLeftEdge, + y: blockTopEdge, + width: TetrissimoPiece.blockLength, + height: TetrissimoPiece.blockLength, + }); + + if (isCollision) { + return false; + } + } + } + + return true; + } + + private hasCollision(rect: RectangleCoordinates): boolean { + const playAreaLeftEdge = this.options.padding; + const playAreaRightEdge = playAreaLeftEdge + this.options.playArea.width; + const playAreaTopEdge = this.options.padding; + const playAreaBottomEdge = playAreaTopEdge + this.options.playArea.height; + + const leftEdge = rect.x; + const rightEdge = rect.x + rect.width; + const topEdge = rect.y; + const bottomEdge = rect.y + rect.height; + + const isInPlayArea = + leftEdge >= playAreaLeftEdge && + rightEdge <= playAreaRightEdge && + bottomEdge <= playAreaBottomEdge && + topEdge >= playAreaTopEdge; + + if (!isInPlayArea) { + return true; + } + + const fixedPieces = this.pieces.filter(piece => piece.state === 'fixed'); + for (const piece of fixedPieces) { + const position = this.getPiecePosition(piece); + const layout = piece.getLayout(); + for (let i = 0; i < layout.length; i++) { + const blockTopEdge = position.y + (i * TetrissimoPiece.blockLength); + const blockBottomEdge = blockTopEdge + TetrissimoPiece.blockLength; + for (let j = 0; j < layout[i].length; j++) { + if (layout[i][j] === 0) { + continue; + } + + const blockLeftEdge = position.x + (j * TetrissimoPiece.blockLength); + const blockRightEdge = blockLeftEdge + TetrissimoPiece.blockLength; + + const isCollision = + leftEdge >= blockLeftEdge && + rightEdge <= blockRightEdge && + bottomEdge <= blockBottomEdge && + topEdge >= blockTopEdge; + + if (isCollision) { + return true; + } + } + } + } + + return false; + } + + public update() { + const options = this.options; + const context = this.options.context; + + context.clearRect(0, 0, canvas.width, canvas.height); + + // fill background + context.fillStyle = 'rgb(224,158,107)'; + context.fillRect(0, 0, canvas.width, canvas.height); + + // draw some grid lines + if (typeof(options.gridLines) === 'number') { + context.strokeStyle = 'rgba(255, 255, 255, 0.25)'; + context.lineWidth = 1; + const increment = options.pixelSize * options.gridLines; + for (let i = 0; i < options.canvas.width; i += increment) { + // draw vertical line + context.beginPath(); + context.moveTo(i, 0); + context.lineTo(i, options.canvas.height); + context.stroke(); + } + for (let i = 0; i < options.canvas.height; i += increment) { + // draw horizontal lines + context.beginPath(); + context.moveTo(0, i); + context.lineTo(options.canvas.width, i); + context.stroke(); + } + } + + const totalWidth = Math.floor(canvas.width / options.pixelSize); + const padding = options.padding; + + // draw HUD in top right corner + this.hud.render(context, { + ...options, + x: totalWidth - padding - options.hud.width, + y: padding, + }); + + // draw play area + this.playArea.render(context, { + ...options, + x: padding, + y: padding, + }); + + this.pieces.forEach((piece, i) => { + piece.render(context, { + ...options, + ...this.getPieceOrigin(piece), + }); + }); + } + + private getPieceOrigin(piece: Readonly): TetrissimoCoordinates { + const length = TetrissimoPiece.blockLength; + // TODO rotation will cause problems, need a "PieceDefinition" or something with a static layout + let translateX = Math.floor((piece.getBlockWidth() * length) / 2); + + // we can only perform movements in multiples of the blockLength, so we must clamp it + // to ensure it's not offset + translateX -= (translateX % length); + const padding = this.options.padding; + return { + x: padding + Math.round(this.options.playArea.width / 2) - translateX, + y: padding, + }; + } +} + +class TetrissimoNextBox implements UIElement { + public render(context: CanvasRenderingContext2D, options: UIElementRenderOptions) { + + } +} + +class TetrissimoHUD implements UIElement { + public render(context: CanvasRenderingContext2D, options: UIElementRenderOptions) { + const position = { + x: options.x, + y: options.y, + width: options.hud.width, + height: options.hud.height, + }; + drawBorderedRect(position, context, options); + } +} + +class TetrissimoPlayArea implements UIElement { + public render(context: CanvasRenderingContext2D, options: UIElementRenderOptions) { + const position = { + x: options.x, + y: options.y, + width: options.playArea.width, + height: options.playArea.height, + }; + drawBorderedRect(position, context, options); + } +} + +type PieceState = 'in-play' | 'fixed'; + +class TetrissimoPiece implements UIElement { + public readonly name: string; + private readonly originalLayout: Readonly; + private layout: PieceLayout; + private offset: TetrissimoCoordinates = { x: 0, y: 0 }; + private readonly color: string; + public static readonly blockLength = 4; + public state: PieceState = 'in-play'; + + public static readonly J = new TetrissimoPiece( + 'J', + [ + [0, 1], + [0, 1], + [1, 1], + ], + 'black', + ); + public static readonly S: TetrissimoPiece = new TetrissimoPiece( + 'S', + [ + [0, 1, 1], + [1, 1, 0], + ], + 'green', + ); + public static readonly T: TetrissimoPiece = new TetrissimoPiece( + 'T', + [ + [1, 1, 1], + [0, 1, 0], + ], + 'blue', + ); + public static readonly Z: TetrissimoPiece = new TetrissimoPiece( + 'Z', + [ + [1, 1, 0,], + [0, 1, 1,], + ], + 'yellow', + ); + public static readonly I: TetrissimoPiece = new TetrissimoPiece( + 'I', + [ + [1, 1, 1, 1], + ], + 'magenta', + ); + public static readonly L: TetrissimoPiece = new TetrissimoPiece( + 'L', + [ + [1], + [1], + [1, 1], + ], + 'cyan', + ); + public static readonly O: TetrissimoPiece = new TetrissimoPiece( + 'O', + [ + [1, 1], + [1, 1], + ], + 'red', + ); + + public constructor(name: string, layout: PieceLayout, color: string) { + this.name = name; + this.originalLayout = layout.map(row => row.concat([])); + this.layout = layout.concat([]); + this.color = color; + } + + public getOffset(): Readonly { + return this.offset; + } + + public getLayout(): Readonly { + return this.layout; + } + + public move(translation: PieceTranslation) { + if (this.state !== 'in-play') { + return; + } + + this.offset.x += (translation.xDelta * TetrissimoPiece.blockLength); + this.offset.y += (translation.yDelta * TetrissimoPiece.blockLength); + } + + public rotateLeft() { + if (this.state !== 'in-play') { + return; + } + + // clockwise turn + const newLayout: PieceLayout = []; + for (let i = 0; i < this.layout.length; i++) { + const col = this.layout.length - 1 - i; + for (let j = 0; j < this.layout[i].length; j++) { + const row = j; + if (!newLayout[row]) { + newLayout[row] = []; + } + newLayout[row][col] = this.layout[i][j]; + } + } + + this.layout = newLayout; + } + + public rotateRight() { + if (this.state !== 'in-play') { + return; + } + + const newLayout: PieceLayout = []; + for (let i = 0; i < this.layout.length; i++) { + const col = i; + for (let j = 0; j < this.layout[i].length; j++) { + const row = this.layout[i].length - 1 - j; + if (!newLayout[row]) { + newLayout[row] = []; + } + newLayout[row][col] = this.layout[i][j]; + } + } + + this.layout = newLayout; + } + + public setFixed() { + this.state = 'fixed'; + } + + public getBlockWidth(): number { + return this.layout + .map(arr => arr.filter(value => value === 1).length) + .reduce((max, len) => Math.max(max, len), 0); + } + + public getBlockHeight(): number { + const cols: PieceCell[][] = []; + for (let i = 0; i < this.layout.length; i++) { + for (let j = 0; j < this.layout[i].length; j++) { + if (!cols[j]) { + cols[j] = []; + } + cols[j].push(this.layout[i][j]); + } + } + + return cols + .map(arr => arr.filter(value => value === 1).length) + .reduce((max, len) => Math.max(max, len), 0); + } + + public clone(): TetrissimoPiece { + return new TetrissimoPiece(this.name, this.layout, this.color); + } + + public render(context: CanvasRenderingContext2D, options: UIElementRenderOptions) { + this.layout.forEach((columns, rowNum) => { + columns.forEach((value, colNum) => { + switch (value) { + case 0: + break; + case 1: + context.fillStyle = this.color; + const length = TetrissimoPiece.blockLength; + const offsetX = this.offset.x; + const offsetY = this.offset.y; + + const x = options.x + offsetX + (colNum * length); + const y = options.y + offsetY + (rowNum * length); + const actualLength = getSize(length, options); + context.fillRect(getSize(x, options), getSize(y, options), actualLength, actualLength); + break; + default: + nope(value); + throw new Error(`Invalid piece cell value "${value}"`); + } + }); + }); + } +} + +// --------------------------------------------- + +const hud = new TetrissimoHUD(); +const playArea = new TetrissimoPlayArea(); + +const canvas = document.getElementsByTagName('canvas')[0]; +if (!canvas) { + throw new Error('no canvas'); +} + +const ui = new TetrissimoUI(canvas, playArea, hud); +const game = new TetrissimoGame(ui); + diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..c1c34ef --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,24 @@ +{ + "compileOnSave": false, + "compilerOptions": { + "target": "es6", + "module": "amd", + "lib": [ + "es6", + "dom" + ], + "moduleResolution": "node", + "noImplicitAny": false, + "allowJs": false, + "inlineSourceMap": true, + "inlineSources": true, + "allowSyntheticDefaultImports": true, + "allowUnreachableCode": true, + "noImplicitReturns": false, + "preserveConstEnums": true, + "strictNullChecks": true, + "noUnusedLocals": false, + "noUnusedParameters": false, + "forceConsistentCasingInFileNames": true + } +}