Source: classes.js

  1. /**
  2.  * Overrides the default set methods to use `JSON.stringify`. This allows it to
  3.  * work with objects and arrays. See the docs for the built in [Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set).
  4.  * @extends {Set}
  5.  */
  6. export class _Set extends Set {
  7. 	/**
  8. 	 * Creates a new set. Can also be done with {@link constructors.S}.
  9. 	 * @param {Iterable.<*>} iterable Optional iterable to initialize the set with
  10. 	 * @returns {_Set}
  11. 	 */
  12. 	constructor(iterable = []) {
  13. 		super()
  14. 		for (const element of iterable) {
  15. 			this.add(element)
  16. 		}
  17. 	}
  19. 	add(item) {
  20. 		return super.add(JSON.stringify(item))
  21. 	}
  23. 	has(item) {
  24. 		return super.has(JSON.stringify(item))
  25. 	}
  27. 	delete(item) {
  28. 		super.delete(JSON.stringify(item))
  29. 		return item
  30. 	}
  32. 	/**
  33. 	 * Makes a copy of the set
  34. 	 * @returns {_Set}
  35. 	 */
  36. 	clone() {
  37. 		return new _Set(this)
  38. 	}
  40. 	/**
  41. 	 * Creates set union in place with `other` and returns this set
  42. 	 * @param {_Set} other
  43. 	 * @returns {_Set}
  44. 	 * @example S([1, 2, 3]).union(S([3, 4, 5])) // { 1, 2, 3, 4, 5 }
  45. 	 */
  46. 	union(other) {
  47. 		for (const item of other) this.add(item)
  48. 		return this
  49. 	}
  51. 	/**
  52. 	 * Creates set intersection in place with `other` and returns this set
  53. 	 * @param {_Set} other
  54. 	 * @returns {_Set}
  55. 	 * @example S([1, 2, 3]).intersect(S([3, 4, 5])) // { 3 }
  56. 	 */
  57. 	intersect(other) {
  58. 		for (const item of this)
  59. 			if (!other.has(item))
  60. 				this.delete(item)
  61. 		return this
  62. 	}
  64. 	/**
  65. 	 * Creates set difference in place with `other` and returns this set
  66. 	 * @param {_Set} other
  67. 	 * @returns {_Set}
  68. 	 * @example S([1, 2, 3]).diff(S([3, 4, 5])) // { 1, 2 }
  69. 	 */
  70. 	diff(other) {
  71. 		for (const item of other) this.delete(item)
  72. 		return this
  73. 	}
  75. 	/**
  76. 	 * Creates symmetric set difference in place with `other` and returns this set
  77. 	 * @param {_Set} other
  78. 	 * @returns {_Set}
  79. 	 * @example S([1, 2, 3]).symdiff(S([3, 4, 5])) // { 1, 2, 4, 5 }
  80. 	 */
  81. 	symdiff(other) {
  82. 		for (const item of other)
  83. 			if (this.has(item)) this.delete(item)
  84. 			else this.add(item)
  85. 		return this
  86. 	}
  88. 	*[Symbol.iterator]() {
  89. 		for (const item of super[Symbol.iterator]()) {
  90. 			yield JSON.parse(item)
  91. 		}
  92. 	}
  94. 	values() {
  95. 		return super.values().map(JSON.parse)
  96. 	}
  97. }
  99. /** Represents a 2D vector. */
  100. export class Vec {
  101. 	/**
  102. 	 * Creates a new vector. Can also be done with {@link constructors.V}.
  103. 	 * @param {number} x The x component
  104. 	 * @param {number} y The y component
  105. 	 * @returns {Vec}
  106. 	 */
  107. 	constructor(x, y) {
  108. 		if (Array.isArray(x)) {
  109. 			[x, y] = x
  110. 		} if (typeof x === "object") {
  111. 			y = x.y
  112. 			x = x.x
  113. 		}
  115. 		if (typeof x !== "number" || typeof y !== "number") {
  116. 			throw new TypeError(`Vec constructor must be given two numbers (not ${x} and ${y})`)
  117. 		}
  119. 		this.x = x
  120. 		this.y = y
  121. 	}
  123. 	/**
  124. 	 * Moves the vector up by `n` units (decreases `y`), in place.
  125. 	 * @param {number} n The number of units to move
  126. 	 * @returns {Vec} The new vector
  127. 	 */
  128. 	upn(n) { this.y -= n; return this }
  130. 	/**
  131. 	 * Moves the vector down by `n` units (increases `y`), in place.
  132. 	 * @param {number} n The number of units to move
  133. 	 * @returns {Vec} The new vector
  134. 	 */
  135. 	downn(n) { this.y += n; return this }
  137. 	/**
  138. 	 * Moves the vector left by `n` units (decreases `x`), in place.
  139. 	 * @param {number} n The number of units to move
  140. 	 * @returns {Vec} The new vector
  141. 	 */
  142. 	leftn(n) { this.x -= n; return this }
  144. 	/**
  145. 	 * Moves the vector right by `n` units (increases `x`), in place.
  146. 	 * @param {number} n The number of units to move
  147. 	 * @returns {Vec} The new vector
  148. 	 */
  149. 	rightn(n) { this.x += n; return this }
  151. 	/**
  152. 	 * Moves the vector up by 1 unit using {@link Vec.upn}
  153. 	 * @returns {Vec} The new vector
  154. 	 */
  155. 	up() { return this.upn(1) }
  157. 	/**
  158. 	 * Moves the vector down by 1 unit using {@link Vec.downn}
  159. 	 * @returns {Vec} The new vector
  160. 	 */
  161. 	down() { return this.downn(1) }
  163. 	/**
  164. 	 * Moves the vector left by 1 unit using {@link Vec.leftn}
  165. 	 * @returns {Vec} The new vector
  166. 	 */
  167. 	left() { return this.leftn(1) }
  169. 	/**
  170. 	 * Moves the vector right by 1 unit using {@link Vec.rightn}
  171. 	 * @returns {Vec} The new vector
  172. 	 */
  173. 	right() { return this.rightn(1) }
  175. 	/**
  176. 	 * Add another vector to this one
  177. 	 * @param {Vec} other The other vector
  178. 	 * @returns {Vec} A new vector
  179. 	 */
  180. 	add(other) {
  181. 		return new Vec(this.x + other.x, this.y + other.y)
  182. 	}
  184. 	/**
  185. 	 * Subtract another vector from this one
  186. 	 * @param {Vec} other The other vector
  187. 	 * @returns {Vec} A new vector
  188. 	 */
  189. 	sub(other) {
  190. 		return new Vec(this.x - other.x, this.y - other.y)
  191. 	}
  193. 	/**
  194. 	 * Multiplies this vector by `factor`
  195. 	 * @param {number} factor The factor to multiply by
  196. 	 * @returns {Vec} A new vector
  197. 	 */
  198. 	mul(factor) {
  199. 		return new Vec(this.x * factor, this.y * factor)
  200. 	}
  202. 	/**
  203. 	 * Divides this vector by `factor`
  204. 	 * @param {number} factor The factor to divide by
  205. 	 * @returns {Vec} A new vector
  206. 	 */
  207. 	div(factor) {
  208. 		return new Vec(this.x / factor, this.y / factor)
  209. 	}
  211. 	/**
  212. 	 * Gets a list of the four adjacent vectors to this one
  213. 	 * @returns {Vec[]}
  214. 	 */
  215. 	adj() {
  216. 		return [
  217. 			this.add(new Vec(0, -1)),
  218. 			this.add(new Vec(0, 1)),
  219. 			this.add(new Vec(-1, 0)),
  220. 			this.add(new Vec(1, 0))
  221. 		]
  222. 	}
  224. 	inrect(a, b) {
  225. 		if (b === undefined) {
  226. 			b = a
  227. 			a = new Vec(0, 0)
  228. 		}
  230. 		if (typeof b === "number") b = new Vec(b - 1, b - 1)
  232. 		return this.x >= a.x && this.x <= b.x && this.y >= a.y && this.y <= b.y
  233. 	}
  235. 	/**
  236. 	 * Gets the cell at this vector on `grid`
  237. 	 * @template T
  238. 	 * @param {T[][]} grid The grid to get the cell from
  239. 	 * @returns {T}
  240. 	 */
  241. 	on(grid) {
  242. 		return grid[this.y]?.[this.x]
  243. 	}
  245. 	/**
  246. 	 * Gets the size of the vector
  247. 	 * @returns {number}
  248. 	 */
  249. 	get size() {
  250. 		return Math.hypot(this.x, this.y)
  251. 	}
  253. 	/**
  254. 	 * Clones the vector
  255. 	 * @returns {Vec}
  256. 	 */
  257. 	clone() {
  258. 		return new Vec(this.x, this.y)
  259. 	}
  261. 	*[Symbol.iterator]() {
  262. 		yield this.x
  263. 		yield this.y
  264. 	}
  266. 	[Symbol.toPrimitive](hint) {
  267. 		// if (hint === "string") return this.toString()
  268. 		return this.size
  269. 	}
  270. }