This is the method which initializes each game scene when the scene is changed/the page is loaded. Depending on the index, there are different mathematical formulas used for generating the scene. Depends on some utility methods such as getRandomInt and a scene-related method getPalette (which returns a color based on the index of the scene and what index of the palette to get)

/**
 * Gets a SceneObject from a requested index
 * @param   {number} index The index of the scene to laod
 * @returns {SceneObject} The scene requested
 */
function getScene(index) {
	let breakables = [];
	let count;
	switch(index) {
		case "0":
			count = 30;
			for (let i = 0; i < count; i++) {
				let theta = ((i + 1) / count) * Math.PI * 2;
				breakables.push(new Breakable(CONSTANTS.LAYERS.ENEMY, new Vec2(900/(count + 5) * i + ((i + 1) * 40), Math.sin(theta) * 50 + 250), new Vec2(40, 20), getPalette(index, 0)));
				breakables.push(new Breakable(CONSTANTS.LAYERS.ENEMY, new Vec2(900/(count + 5) * i + ((i + 1) * 40), Math.sin(theta) * 25 + 350), new Vec2(40, 20), getPalette(index, 0)));
				breakables.push(new Breakable(CONSTANTS.LAYERS.PLAYER, new Vec2(900/(count + 5) * i + ((i + 1) * 40), -Math.sin(theta) * 50 + 750), new Vec2(40, 20), getPalette(index, 1)));
				breakables.push(new Breakable(CONSTANTS.LAYERS.PLAYER, new Vec2(900/(count + 5) * i + ((i + 1) * 40), -Math.sin(theta) * 25 + 650), new Vec2(40, 20), getPalette(index, 1)));
			}
			return new SceneObject(breakables);
		case "1":
			count = 50;
			for (let i = 0; i < count; i++) {
				let theta = ((i + 1) / count * Math.PI * 2);
				// center circle
				breakables.push(new Breakable(CONSTANTS.LAYERS.UNIVERSAL, new Vec2(CONSTANTS.CANVAS_SIZE / 2 + 350 * Math.cos(theta), CONSTANTS.CANVAS_SIZE / 2 + 350 * Math.sin(theta)), new Vec2(25 * Math.abs(Math.cos(theta / 2)) + 5, 25 * Math.abs(Math.cos(theta / 2)) + 5), getPalette(index, 0), new StrokeProperties(), Shapes.drawEllipse));
			}
			return new SceneObject(breakables);
		case "2":
			count = 50;
			for (let i = 0; i < count; i++) {
				breakables.push(new Breakable(CONSTANTS.LAYERS.ENEMY, new Vec2(getRandomInt(100, 900), getRandomInt(100, 900)), new Vec2(30, 30), getPalette(index, 0)));
				breakables.push(new Breakable(CONSTANTS.LAYERS.PLAYER, new Vec2(getRandomInt(100, 900), getRandomInt(100, 900)), new Vec2(30, 30), getPalette(index, 1)));
			}
			return new SceneObject(breakables);
	}
}

A projectile represents the circles which bounce around the game area. It inherits from GenericObject, which is a generic class used for the basic rendering and updating of the object. It uses classes defined in structs.js like Vec2, StrokeProperties, etc., and defaults to the drawEllipse shape method defined in shapes.js. It has methods for moving over time with a constant velocity, reflecting (complete 180-degree change in direction) when hitting a paddle, and bouncing (angle is determined by the difference of centers) when hitting the bounds or a brick.

class Projectile extends GenericObject {
	/**
	 * A typically circular object which is used for achieving the main objective (bypassing opponent) and destroying breakables
	 * @param {Vec2}             [position = new Vec2()]           The position of the object on the canvas
	 * @param {Vec2}             [size = new Vec2()]               The size of the object on the canvas
	 * @param {FillStyle}        [fill = new FillStyle()]          The fill of the object
	 * @param {StrokeProperties} [stroke = new StrokeProperties()] The stroke of the object
	 * @param {function}         [shape = Shapes.drawEllipse]      The shape rendering method for the object
	 * @param {number}           [shapeEdges = 3]                  The number of edges to render the shape with (only applies when drawing a polygon)
	 */
	constructor(position = new Vec2(), size = new Vec2(), fill = new FillStyle(), stroke = new StrokeProperties(), shape = Shapes.drawEllipse, shapeEdges = 3) {
		super(position, size, fill, stroke, shape, shapeEdges);
		this.velocity = new Vec2();
	}
	
	/**
	 * Updates projectile information over time
	 * @param {number} dt delta time in ms
	 */
	update(dt) {
		super.update(dt);
		this.move(dt);
	}
	
	/**
	 * Handle moving the projectile over time
	 * @param {number} dt delta time in ms
	 */
	move(dt) {
		let move = {x: this.velocity.x * dt, y: this.velocity.y * dt};
		this.position.add(move);
	}
	
	/**
	 * Handle reflection of the projectile when it bumps into something
	 * @param {string} axis The axis to apply a -1 modifier on; this is a string, which is used as a key for the velocity vector (velocity[axis])
	 * @param {number} dt delta time in ms
	 */
	reflect(axis, dt) {
		this.velocity[axis] *= -1;
		// adds an extra frame of move to prevent projectile getting stuck
		this.move(dt);
	}
	
	/**
	 * Bounces a projectile off of an object
	 * @param {string} axis      The axis of which to perform bounce on in regards to the projectile's velocity
	 * @param {Vec2} centerOther The center point of the other object the projectile is bouncing off of
	 * @param {number} dt delta  time in ms
	 */
	bounce(axis, centerOther, dt) {
		this.velocity[axis] += (this.bounds.center()[axis] - centerOther[axis]) / centerOther[axis] * CONSTANTS.PROJECTILE_BOUNCE_FACTOR;
		this.velocity = this.velocity.normalized();
		// adds an extra frame of move to prevent projectile getting stuck
		this.move(dt);
	}
}

This is the search method, which sets up and utilizes an AJAX request to TheNewsAPI. Each step has a comment; overall it first checks if the page passed validation (the UI repsonds to this.result being a number rather than an object by reporting the status of the UI and any errors if applicable), and if so, it then checks if the search parameters have changed since the last search button click (to limit requests; if it's the same, it just calls useResult again, as the button calls this "Refresh Search"). Finally, it forms the search URL and performs an XHR whose onload calls the callback passed in to the downloadFile method.

/**
 * (bound to search button) Performs search and result manipulation
 */
search() {
	if (this.validate()) {
		// update the current search params object
		this.searchParams = {
			query: this.query,
			count: this.count,
			page: this.page,
			from: this.from,
			to: this.to,
			genre: this.genre,
			category: this.category,
			newstype: this.newstype,
		}
		localStorage.setItem(lastSearchKey, JSON.stringify(this.searchParams));

		// only search if the search parameters haven't changed from lastSearchParams
		if (JSON.stringify(this.lastSearchParams) !== JSON.stringify(this.searchParams)) {
			// set result to -1 to update the computed resultHTML while search is occuring
			this.result = -1;
			this.resultUpdated = false;

			// set up the get url
			let get = `${url}${this.newstype}?api_token=${api}&language=en&limit=${this.count}&page=${this.page}&published_before=${this.to}&published_after=${this.from}&categories=${this.category}`;

			// ensure an empty string isn't sent, to allow for searching without a query (which is possible with the API)
			if (this.query.length > 0)
				get += `&search=${this.query}`;

			// perform AJAX request
			downloadFile(get, (jsonStr) => {
				// set the current newsResult object from parsed JSON, then use it with a random index
				this.newsResult = JSON.parse(jsonStr).data;
				this.useResult(getRandomInt(0, this.newsResult.length - 1));
			});
		}
		else
			this.useResult(getRandomInt(0, this.newsResult.length - 1));

		// update the lastSearchParams with the current searchParams
		this.lastSearchParams = this.searchParams;
	}
	else
		this.result = 400;
}

This is the useResult method, which uses the current result (as long as it's not a status code but rather an object) to form a manipulated result using the RiTa API and randomization from a defined WordDatabase organized by genre then by part-of-speech (POS).

/**
 * Uses the current newsResult to form the current Result class instance
 * @param {number} [index = 0] The index in the newsResult to manipulate
 */
useResult(index = 0) {
	// update lastIndex so that this.swap uses the same news result from the collection
	this.lastIndex = index;

	if (this.newsResult.length > 0) {
		// gets the title to work with...
		let title = this.newsResult[index].title;
		// ...gets a collection of words...
		let words = title.replace(/[.,\/#!$%\^&\*;:{}=\-_`~()]/g,'').trim().split(' ').filter(elem => elem);
		// ...and parts of speech...
		let pos = RiTa.pos(title.replace(/[.,\/#!$%\^&\*;:{}=\-_`~()]/g,'').trim().split(' ').filter(elem => elem));
		// ...in order to create changed words
		let changed = [];

		// loop through the collections to change valid words
		for (let i = 0; i < pos.length; i++) {
			let word;
			// replace nouns
			if (pos[i] == 'nn' || pos[i] == 'nns' || pos[i] == 'nnp' || pos[i] == 'nnps') {
				// replace with random word from current genre
				word = WordDatabase[this.genre].nn[getRandomInt(0, WordDatabase[this.genre].nn.length - 1)];
				// pluralize if the original was plural
				if (pos[i] == 'nns' || pos[i] == 'nnps')
					word = RiTa.pluralize(word);
			}
			// push to the changed array
			if (word)
				changed.push(new classes.ChangedWord(
					words[i], i,
					word,
					this.genre,
					this.swapSingleWord
				));
		}
		// set the current result to a new class instance of Result with the current working title and the changed words array
		this.result = new classes.Result({ title: title }, changed);
		this.resultUpdated = true;
	}
	else {
		this.resultUpdated = false;
		this.result = 404;
	}
}

Below are routing handlers for getting/saving characters along with the generic method for all responses (including routers for Not Found, Bad Request, etc, not shown due to simplicity/similarity). Note: characterUtils.* and responseUtils.* are imported custom utility modules

/**
 * General response writing method
 * @param {object} request XHR request object
 * @param {object} response XHR response object
 * @param {number} status HTML status code
 * @param {string} type HTML Content-Type
 * @param {object} data data to write
 */
const respond = (request, response, status, type, data) => {
  const validatedType = responseUtils.getValidType(type);
  response.writeHead(status, { 'Content-Type': validatedType });

  if (data) {
    let toWrite = data;
    if (validatedType === 'text/xml') {
      toWrite = responseUtils.toXML(data);
    } else {
      toWrite = JSON.stringify(data);
    }

    response.write(toWrite);
  }
  response.end();
};

/**
 * Routing handler for /getCharacter
 * @param {object} request XHR request object
 * @param {object} response XHR response object
 * @param {object} params GET/POST parameters, if any
 */
const getCharacter = (request, response, params) => {
  const indexOfCharacter = characterUtils.findCharacter(
    characters, { name: params.name },
  );

  if (indexOfCharacter > -1) {
    if (request.method === 'HEAD') {
      respond(request, response, 204, request.headers.accept);
    } else {
      respond(request, response, 200, request.headers.accept, characters[indexOfCharacter]);
    }
  } else {
    notFound(request, response);
  }
};

/**
 * Routing handler for /saveCharacter
 * @param {object} request XHR request object
 * @param {object} response XHR response object
 * @param {object} params POST parameters
 */
const saveCharacter = (request, response, params) => {
  const indexOfCharacter = characterUtils.findCharacter(
    characters, { name: params.charToAdd.name },
  );

  if (indexOfCharacter > -1) {
    characters[indexOfCharacter] = params.charToAdd;
    respond(request, response, 204, request.headers.accept);
  } else {
    characters.push(params.charToAdd);
    respond(request, response, 201, request.headers.accept);
  }
};