chore: simplify away some small classes

src/common/Position.ts → src/common/TPosition.ts

@@ -15,4 +15,7 @@
  * along with this program.  If not, see https://www.gnu.org/licenses/ .
  */
 
-export type Position = readonly [number, number]
+/**
+ * Represents a position with [X, Y].
+ */
+export type TPosition = readonly [number, number]

src/common/ISize.ts → src/common/TSize.ts

@@ -18,9 +18,7 @@
 /**
  * Represents a size (width and height).
  */
-interface ISize {
-  width: number
-  height: number
+export type TSize = {
+  readonly width: number
+  readonly height: number
 }
-
-export type { ISize }

src/common/index.ts

@@ -28,8 +28,8 @@ import { isNil } from "./isNil"
 import { rearrange } from "./rearrange"
 import { waitForEvent } from "./waitForEvent"
 
-import type { ISize } from "./ISize"
-import type { Position } from "./Position"
+import type { TPosition } from "./TPosition"
+import type { TSize } from "./TSize"
 
 export {
   DefaultGameUpdateIntervalMilliseconds,
@@ -43,5 +43,4 @@ export {
   isNil,
   formatDuration,
 }
-
-export type { ISize, Position }
+export type { TSize, TPosition }

src/customization/map/IMap.ts

@@ -15,7 +15,7 @@
  * along with this program.  If not, see https://www.gnu.org/licenses/ .
  */
 
-import type { ISize } from "../../common"
+import type { TSize } from "../../common"
 
 export interface IMapCell {
   readonly atomicNumber: number
@@ -27,5 +27,5 @@ export type TMapRow = IMapCell[]
 export interface IMap {
   readonly map: TMapRow[]
   readonly totalAvailableBlocksCount: number
-  readonly playAreaSize: ISize
+  readonly playAreaSize: TSize
 }

src/model/Block.ts

@@ -17,15 +17,15 @@
 
 import { TetriminoKind } from "./TetriminoKind"
 
-import type { Position } from "../common"
+import type { TPosition } from "../common"
 
 /**
  * The block, the most basic unit of the game.
  */
 export class Block {
   public constructor(
     public readonly filledBy: TetriminoKind,
-    public readonly position: Position,
+    public readonly position: TPosition,
     public /* readonly */ atomicNumber = 0,
     public readonly id = 0
   ) {}

src/model/EventArgs.ts

@@ -17,9 +17,7 @@
 
 import { Block } from "./Block"
 
-export class BlocksChangedEventArgs {
-  public constructor(
-    public readonly blocks: Block[],
-    public readonly disappeared: boolean
-  ) {}
+export type TBlocksChangedEventArgs = {
+  readonly blocks: Block[]
+  readonly disappeared: boolean
 }

src/model/GameModel.ts

@@ -23,7 +23,6 @@ import { isNil, waitForEvent } from "../common"
 import { customizationFacade } from "../customization"
 import { Block } from "./Block"
 import { MoveDirection, RotationDirection } from "./Direction"
-import { BlocksChangedEventArgs } from "./EventArgs"
 import { GameState } from "./GameState"
 import { getPlayablePattern, MessageType } from "./generation"
 import { repairBrokenTetriminos, Tetrimino } from "./Tetrimino"
@@ -76,7 +75,7 @@ export class GameModel extends EventEmitter {
   public get gameState(): GameState {
     return this._gameState
   }
-  private set gameState(v: GameState) {
+  private set gameState(v) {
     this._gameState = v
     this.onGameStateChanged()
   }
@@ -345,7 +344,7 @@ export class GameModel extends EventEmitter {
    * @param disappeared Whether the block disappeared.
    */
   private onBlocksChanged(blocks: Block[], disappeared: boolean): void {
-    this.emit("blockschanged", new BlocksChangedEventArgs(blocks, disappeared))
+    this.emit("blockschanged", { blocks, disappeared })
   }
 
   /**

src/model/Tetrimino.ts

@@ -22,14 +22,14 @@ import { Direction, MoveDirection, RotationDirection } from "./Direction"
 import { createOffsetedBlocks, mapAtomicNumberInto } from "./TetriminoHelper"
 import { TetriminoKind } from "./TetriminoKind"
 
-import type { Position } from "../common"
+import type { TPosition } from "../common"
 
 /**
  * The type for block collision checker.
  *
  * @returns 'false' if no collision found. Otherwise 'true'.
  */
-export type TBlockCollisionChecker = (block: Block) => boolean
+export type TCollisionChecker = (block: Block) => boolean
 
 /**
  * The tetrimino.
@@ -46,18 +46,16 @@ export class Tetrimino {
    */
   public tryMove(
     direction: MoveDirection,
-    collisionChecker: TBlockCollisionChecker
+    collisionChecker: TCollisionChecker
   ): boolean {
     const deltaY = direction === MoveDirection.Down ? 1 : 0
     const deltaX =
       (direction === MoveDirection.Down ? 0 : 1) *
       (direction === MoveDirection.Right ? 1 : -1)
 
     const newBlocks = map(this.blocks, (b) => ({
-      filledBy: b.filledBy,
+      ...b,
       position: [b.position[0] + deltaX, b.position[1] + deltaY] as const,
-      atomicNumber: b.atomicNumber,
-      id: b.id,
     }))
 
     if (newBlocks.some(collisionChecker)) {
@@ -80,7 +78,7 @@ export class Tetrimino {
    */
   public tryRotate(
     rotationDirection: RotationDirection,
-    collisionChecker: TBlockCollisionChecker
+    collisionChecker: TCollisionChecker
   ): boolean {
     // Find the final direction
     const count = Object.keys(Direction).length / 2
@@ -118,7 +116,7 @@ export class Tetrimino {
    */
   public constructor(
     public kind: TetriminoKind,
-    public position: Position,
+    public position: TPosition,
     public facingDirection: Direction
   ) {
     this.blocks = createOffsetedBlocks(kind, position, facingDirection)
@@ -135,11 +133,7 @@ export class Tetrimino {
 export function repairBrokenTetriminos(
   brokenTetriminos: Tetrimino[]
 ): Tetrimino[] {
-  const repairedTetriminos = map(brokenTetriminos, (brokenTetrimino) =>
-    Object.create(
-      Tetrimino.prototype,
-      Object.getOwnPropertyDescriptors(brokenTetrimino)
-    )
+  return map(brokenTetriminos, (t) =>
+    Object.create(Tetrimino.prototype, Object.getOwnPropertyDescriptors(t))
   )
-  return repairedTetriminos
 }

src/model/TetriminoHelper.ts

@@ -19,7 +19,7 @@ import { Block } from "./Block"
 import { Direction } from "./Direction"
 import { TetriminoKind } from "./TetriminoKind"
 
-import type { ISize, Position } from "../common"
+import type { TPosition, TSize } from "../common"
 
 const CubicDownMask: number[][] = [
   [3, 4],
@@ -396,10 +396,10 @@ export function getFirstBlockCoordByType(
  * @returns The transformed position.
  */
 export function getPositionByFirstBlock(
-  position: Position,
+  position: TPosition,
   kind: TetriminoKind,
   facingDirection: Direction
-): Position {
+): TPosition {
   const firstBlockCoord = getFirstBlockCoordByType(kind, facingDirection)
   const firstBlockRow = firstBlockCoord.row
   const firstBlockCol = firstBlockCoord.col
@@ -408,8 +408,8 @@ export function getPositionByFirstBlock(
 
 export function getInitialPositionByKind(
   kind: TetriminoKind,
-  playAreaSize: ISize
-): Position {
+  playAreaSize: TSize
+): TPosition {
   let length: number
   switch (kind) {
     case TetriminoKind.Linear:
@@ -433,7 +433,7 @@ export function getInitialPositionByKind(
 
 export function createOffsetedBlocks(
   kind: TetriminoKind,
-  offset: Position,
+  offset: TPosition,
   direction: Direction = Direction.Up
 ): Block[] {
   const mask = getBlocksMask(kind, direction)

src/model/generation/internal/PatternGenerator.ts

@@ -20,15 +20,15 @@ import { map, shuffle } from "lodash"
 import { isNil } from "../../../common"
 import { Block } from "../../Block"
 import { Direction, RotationDirection } from "../../Direction"
-import { repairBrokenTetriminos, Tetrimino } from "../../Tetrimino"
+import { Tetrimino, repairBrokenTetriminos } from "../../Tetrimino"
 import {
   getInitialPositionByKind,
   getPositionByFirstBlock,
 } from "../../TetriminoHelper"
 import { TetriminoKind } from "../../TetriminoKind"
 import { sort } from "./TetriminoSorter"
 
-import type { ISize, Position } from "../../../common"
+import type { TPosition, TSize } from "../../../common"
 import type { IMap } from "../../../customization"
 
 function fastRandom(startInc: number, endExc: number): number {
@@ -60,9 +60,7 @@ export async function getPlayablePattern(gameMap: IMap): Promise<Tetrimino[]> {
   )
 
   const fixedTetriminos = repairBrokenTetriminos(ordered)
-
   primeTetriminos(fixedTetriminos, gameMap.playAreaSize)
-
   return fixedTetriminos
 }
 
@@ -196,7 +194,7 @@ function collisionChecker(
 
 function getFirstAvailableBlockCoord(
   occupationMap: TetriminoKind[][]
-): Position {
+): TPosition {
   for (let nRow = occupationMap.length - 1; nRow >= 0; nRow--) {
     const col = occupationMap[nRow]
     for (let nCol = col.length - 1; nCol >= 0; nCol--) {
@@ -235,7 +233,7 @@ class KindDirectionsPair {
  * @param tetriminos The tetriminos to prime.
  * @param playAreaSize Size of play area.
  */
-function primeTetriminos(tetriminos: Tetrimino[], playAreaSize: ISize) {
+function primeTetriminos(tetriminos: Tetrimino[], playAreaSize: TSize) {
   // Move to initial position and rotate randomly
   tetriminos.forEach((tetrimino) => {
     const originalPos = tetrimino.position

src/model/generation/internal/TetriminoSorter.ts

@@ -21,11 +21,11 @@ import toposort from "toposort"
 import { isNil, rearrange } from "../../../common"
 import { Tetrimino } from "../../Tetrimino"
 
-import type { ISize } from "../../../common"
+import type { TSize } from "../../../common"
 
 function getEdges(
   tetriminos: Tetrimino[],
-  playAreaSize: ISize
+  playAreaSize: TSize
 ): [number, number][] {
   // Create owners map
   const owners: number[][] = new Array(playAreaSize.height)
@@ -43,36 +43,34 @@ function getEdges(
 
   return uniq(
     flatten(
-      map(tetriminos, (tetrimino, index) => {
-        const singleTetriminoDeps: [number, number][] = []
-        for (let i = 0; i < tetrimino.blocks.length; i++) {
-          const block = tetrimino.blocks[i]
-          const dependedBlockRow = block.position[1] + 1
-          const dependedBlockCol = block.position[0]
-          const result = tryGetOccupiedTetriminoNode(
+      map(tetriminos, (t, index) => {
+        const deps: [number, number][] = []
+        for (let i = 0; i < t.blocks.length; i++) {
+          const block = t.blocks[i]
+          const result = tryGetOccupant(
             owners,
-            dependedBlockRow,
-            dependedBlockCol,
+            block.position[1] + 1 /* Lower row... */,
+            block.position[0] /* ...and same column */,
             playAreaSize
           )
           if (isNil(result) || result === index) {
             // Ignore self-dependency
             continue
           }
           // Found a result
-          singleTetriminoDeps.push([result, index])
+          deps.push([result, index])
         }
-        return singleTetriminoDeps
+        return deps
       })
     )
   )
 }
 
-function tryGetOccupiedTetriminoNode(
+function tryGetOccupant(
   map: number[][],
   row: number,
   col: number,
-  playAreaSize: ISize
+  playAreaSize: TSize
 ): number | null {
   if (
     row < 0 ||
@@ -83,21 +81,14 @@ function tryGetOccupiedTetriminoNode(
     return null
   }
 
-  const cell = map[row][col]
-  if (isNil(cell)) {
-    return null
-  }
-
-  return cell
+  return map[row][col] ?? null
 }
 
 export function sort(
   tetriminos: Tetrimino[],
-  playAreaSize: ISize
+  playAreaSize: TSize
 ): Tetrimino[] {
   const edges = getEdges(tetriminos, playAreaSize)
   const sortedIndices = toposort(edges)
-  const sortedTetriminos = rearrange(tetriminos, sortedIndices)
-
-  return sortedTetriminos
+  return rearrange(tetriminos, sortedIndices)
 }

src/model/index.ts

@@ -17,15 +17,15 @@
 
 import { Block } from "./Block"
 import { Direction, MoveDirection, RotationDirection } from "./Direction"
-import { BlocksChangedEventArgs } from "./EventArgs"
 import { GameModel } from "./GameModel"
 import { GameState } from "./GameState"
 import { Tetrimino } from "./Tetrimino"
 import { TetriminoKind } from "./TetriminoKind"
 
+import type { TBlocksChangedEventArgs } from "./EventArgs"
+
 export {
   Block,
-  BlocksChangedEventArgs,
   Direction,
   RotationDirection,
   MoveDirection,
@@ -34,3 +34,5 @@ export {
   Tetrimino,
   TetriminoKind,
 }
+
+export type { TBlocksChangedEventArgs }