Change game state: pauseGame()}> Pause unpauseGame()}> Unpause
<${Heading} title="Whitelist players" />
setWhitelistAddress((e.target as HTMLInputElement).value)}
placeholder="Address to whitelist"
> addAddressToWhitelist(whitelistAddress)}>
Whitelist Address
<${Heading} title="Give Planets" />
Planet: <${PlanetLink} planetId=${(selectedPlanet as Planet)?.locationId} /> to
<${Select}
style=${{ flex: '1' }}
value=${targetAccount}
onChange=${(e: InputEvent) => setTargetAccount((e.target as HTMLSelectElement).value)}
items=${accountOptions(allPlayers)}
/>
takeOwnership(selectedPlanet, targetAccount)}>
Give Planet
<${Heading} title="Give Spaceships" />
<${Select}
style=${{ flex: '1' }}
value=${selectedShip}
onChange=${(e: InputEvent) => setSelectedShip((e.target as HTMLSelectElement).value)}
items=${shipOptions()}
/>
to
<${Select}
style=${{ flex: '1' }}
value=${targetAccount}
onChange=${(e: InputEvent) => setTargetAccount((e.target as HTMLSelectElement).value)}
items=${accountOptions(allPlayers)}
/>
${'On planet: '}
<${PlanetLink} planetId=${(selectedPlanet as Planet)?.locationId} />
createArtifact(
targetAccount,
selectedArtifact,
selectedPlanet,
artifactRarity,
artifactBiome
)}
>
Give Artifact
<${PlanetCreator} />
`;
}
class Plugin implements DFPlugin {
async render(container: HTMLDivElement) {
container.style.width = '525px';
render(html`<${App} />`, container);
}
}
export default Plugin;
================================================
FILE: embedded_plugins/Getting-Started.ts
================================================
/**
* Hi there!
*
* Looks like you've found the Dark Forest plugins system.
* Read through this script to learn how to write plugins!
*
* Most importantly, you have access these globals:
* 1. df - Just like the df object in your console.
* 2. ui - For interacting with the game's user interface.
*
* Let's log these to the console when you run your plugin!
*/
console.log(df, ui);
/**
* Plugins are just TypeScript (or modern JavaScript, if you prefer), so you can use imports, too!
*/
// @ts-ignore
import confetti from 'https://cdn.skypack.dev/canvas-confetti';
/**
* A plugin is a Class with render and destroy methods.
* Other than that, you are free to do whatever, so be careful!
*/
class Readme implements DFPlugin {
private canvas: HTMLCanvasElement;
/**
* A constructor can be used to keep track of information.
*/
constructor() {
this.canvas = document.createElement('canvas');
this.canvas.width = 400;
this.canvas.height = 150;
}
/**
* A plugin's render function is called once.
* Here, you can insert custom html into a game modal.
* You render any sort of UI that makes sense for the plugin!
*/
async render(div: HTMLDivElement) {
div.style.width = '400px';
const firstTextDiv = document.createElement('div');
firstTextDiv.innerText =
'This is an example plugin. Check out its source by' +
' clicking "edit" button that is to the right of the' +
' README plugin in the Plugin Manager modal! ';
const secondTextDiv = document.createElement('div');
secondTextDiv.innerText = '... Or, click the button below to get a free artifact!';
const myButton = document.createElement('df-button');
myButton.innerText = 'give me an artifact';
myButton.addEventListener('click', async () => {
await confetti.create(this.canvas)({
origin: { x: 0.5, y: 1 },
});
const ctx = this.canvas.getContext('2d');
if (ctx) {
ctx.fillStyle = 'white';
ctx.font = '20px Sans-serif';
ctx.fillText('Gotcha!', 150, 60);
}
});
div.appendChild(firstTextDiv);
div.appendChild(document.createElement('br'));
div.appendChild(secondTextDiv);
div.appendChild(document.createElement('br'));
div.appendChild(this.canvas);
div.appendChild(myButton);
}
/**
* When this is unloaded, the game calls the destroy method.
* So you can clean up everything nicely!
*/
destroy() {
const ctx = this.canvas.getContext('2d');
if (ctx) {
ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
}
}
}
/**
* For the game to know about your plugin, you must export it!
*
* Use `export default` to expose your plugin Class.
*/
export default Readme;
================================================
FILE: embedded_plugins/Locate-Artifacts.ts
================================================
/**
* Remember, you have access these globals:
* 1. df - Just like the df object in your console.
* 2. ui - For interacting with the game's user interface.
*
* Let's log these to the console when you run your plugin!
*/
console.log(df, ui);
class ArtifactsFinder implements DFPlugin {
private planetList: HTMLDivElement;
renderPlanets = () => {
this.planetList.innerHTML = '';
// keep track of how many we have found
let count = 0;
const countText = document.createElement('div');
this.planetList.appendChild(countText);
for (const planet of df.getAllPlanets()) {
// @ts-ignore
if (planet.location) {
if (df.isPlanetMineable(planet)) {
// is there any other filtering you'd want to do?
// sometimes planets have artifacts deposited on them!
// somtimes a planet's artifact has already been mined.
// see if you can modify this plugin to make it do what
// you want!
const planetEntry = document.createElement('div');
this.planetList.appendChild(planetEntry);
// hint: have a hard time finding planets?
// ui.centerCoords might help...
planetEntry.innerText =
'(' +
// @ts-ignore
planet.location.coords.x +
', ' +
// @ts-ignore
planet.location.coords.y +
')';
count++;
}
}
}
if (count === 0) {
countText.innerText = 'you have not found any artifacts yet';
} else {
countText.innerText = 'you have found ' + count + ' artifacts';
}
};
async render(container: HTMLDivElement) {
console.log('rendered 1 artifacts finder');
const findArtifactsButton = document.createElement('df-button');
findArtifactsButton.innerText = 'find me some artifacts!';
container.appendChild(findArtifactsButton);
container.appendChild(document.createElement('br'));
container.appendChild(document.createElement('br'));
findArtifactsButton.addEventListener('click', this.renderPlanets);
this.planetList = document.createElement('div');
container.appendChild(this.planetList);
this.planetList.style.maxHeight = '300px';
this.planetList.style.width = '400px';
this.planetList.style.overflowX = 'hidden';
this.planetList.style.overflowY = 'scroll';
console.log('rendered artifacts finder');
}
}
/**
* And don't forget to export it!
*/
export default ArtifactsFinder;
================================================
FILE: embedded_plugins/Rage-Cage.ts
================================================
class RageCage implements DFPlugin {
private img: HTMLImageElement;
private loaded: boolean;
/**
* As you saw in the README plugin, you can render
* arbitrary HTML UI into a Dark Forest modal.
*/
async render(div: HTMLDivElement) {
// once this plugin is run, let's load a nice image
// from the internet, in order to draw it on top of
// planets
this.img = document.createElement('img');
this.loaded = false;
div.appendChild(this.img);
this.img.addEventListener('load', () => {
// we should only use the image once
// it actually loads.
this.loaded = true;
div.innerText = 'welcome to nicolas cage world';
});
this.img.src =
'https://upload.wikimedia.org/wikipedia/' + 'commons/c/c0/Nicolas_Cage_Deauville_2013.jpg';
// hide the image, it doesn't need to show up
// in the modal, we only need this img element
// to load the image.
this.img.style.display = 'none';
div.style.width = '100px';
div.style.height = '100px';
div.innerText = 'loading, please wait!';
// check out the helpful functions that appear
// in the Viewport class!
console.log(ui.getViewport());
}
/**
* In addition to rendering HTML UI into a div, plugins
* can draw directly onto the game UI. This function is
* optional, but if it exists, it is called in sync with
* the rest of the game, and allows you to draw onto an
* HTML5 canvas that lays on top of the rest of the game.
*
* In the example below, we render an image on top of every
* planet.
*
* ctx is an instance of CanvasRenderingContext2D.
*/
draw(ctx: CanvasRenderingContext2D) {
// don't draw anything until nic cage loads
if (!this.loaded) return;
// the viewport class provides helpful functions for
// interacting with the currently-visible area of the
// game
const viewport = ui.getViewport();
const planets = ui.getPlanetsInViewport();
for (const p of planets) {
// use the Viewport class to determine the pixel
// coordinates of the planet on the screen
const pixelCenter = viewport.worldToCanvasCoords(
// @ts-ignore
p.location.coords
);
// how many pixels is the radius of the planet?
const trueRadius = viewport.worldToCanvasDist(ui.getRadiusOfPlanetLevel(p.planetLevel));
// draw nicolas cage on top of the planet
ctx.drawImage(
this.img,
50,
50,
400,
400,
pixelCenter.x - trueRadius,
pixelCenter.y - trueRadius,
trueRadius * 2,
trueRadius * 2
);
}
}
}
export default RageCage;
================================================
FILE: embedded_plugins/Remote-Explorer.ts
================================================
// organize-imports-ignore
import type { Chunk, WorldCoords } from '@darkforest_eth/types';
//@ts-ignore
import { locationIdFromDecStr } from 'https://cdn.skypack.dev/@darkforest_eth/serde';
import {
html,
render,
useEffect,
useState,
//@ts-ignore
} from 'https://unpkg.com/htm/preact/standalone.module.js';
import type MinerManager from '../src/Backend/Miner/MinerManager';
import type { MinerWorkerMessage } from '../src/_types/global/GlobalTypes';
type ExtendedMinerManager = MinerManager & {
url: string;
id: number;
chunkSize: number;
patternType: string;
};
const {
MinerManager: Miner,
SwissCheesePattern,
SpiralPattern,
TowardsCenterPattern,
TowardsCenterPatternV2,
} = df.getConstructors();
const NEW_CHUNK = 'DiscoveredNewChunk';
function getPattern(coords: WorldCoords, patternType: string, chunkSize: number) {
if (patternType === 'swiss') {
return new SwissCheesePattern(coords, chunkSize);
} else if (patternType === 'spiral') {
return new SpiralPattern(coords, chunkSize);
} else if (patternType === 'towardsCenter') {
return new TowardsCenterPattern(coords, chunkSize);
} else {
return new TowardsCenterPatternV2(coords, chunkSize);
}
}
class RemoteWorker implements Worker {
private url: string;
constructor(url: string) {
this.url = url;
}
async postMessage(msg: string) {
const msgJson: MinerWorkerMessage = JSON.parse(msg);
const resp = await fetch(this.url, {
method: 'POST',
body: JSON.stringify({
chunkFootprint: msgJson.chunkFootprint,
planetRarity: msgJson.planetRarity,
planetHashKey: msgJson.planetHashKey,
}),
headers: {
'Content-Type': 'application/json',
},
});
const exploredChunk = await resp.json();
const chunkCenter = {
x: exploredChunk.chunkFootprint.bottomLeft.x + exploredChunk.chunkFootprint.sideLength / 2,
y: exploredChunk.chunkFootprint.bottomLeft.y + exploredChunk.chunkFootprint.sideLength / 2,
};
exploredChunk.perlin = df.spaceTypePerlin(chunkCenter, false);
for (const planetLoc of exploredChunk.planetLocations) {
planetLoc.hash = locationIdFromDecStr(planetLoc.hash);
planetLoc.perlin = df.spaceTypePerlin({ x: planetLoc.coords.x, y: planetLoc.coords.y }, true);
planetLoc.biomebase = df.biomebasePerlin(
{ x: planetLoc.coords.x, y: planetLoc.coords.y },
true
);
}
this.onmessage({ data: JSON.stringify([exploredChunk, msgJson.jobId]) });
}
onmessage(_a: { data: string }) {
console.warn('Unimplemented: onmessage');
}
terminate() {
console.warn('Unimplemented: terminate');
}
onmessageerror() {
console.warn('Unimplemented: onmessageerror');
}
addEventListener() {
console.warn('Unimplemented: addEventListener');
}
removeEventListener() {
console.warn('Unimplemented: removeEventListener');
}
dispatchEvent(_event: Event): boolean {
return false;
}
onerror() {
console.warn('Unimplemented: onerror');
}
}
function Target() {
const wrapper = {
width: '1em',
height: '1em',
display: 'inline-block',
position: 'relative',
verticalAlign: 'text-bottom',
};
const svg = {
width: '100%',
height: '100%',
};
const path = {
fill: 'white',
};
return html`
`;
}
function MinerUI({
miner,
onRemove,
}: {
miner: ExtendedMinerManager;
onRemove: (miner: ExtendedMinerManager) => void;
}) {
const [hashRate, setHashRate] = useState(0);
useEffect(() => {
const calcHash = (chunk: Chunk, miningTimeMillis: number) => {
df.addNewChunk(chunk);
const hashRate = chunk.chunkFootprint.sideLength ** 2 / (miningTimeMillis / 1000);
setHashRate(Math.floor(hashRate));
const res = miner.getCurrentlyExploringChunk();
if (res) {
const { bottomLeft, sideLength } = res;
ui?.setExtraMinerLocation?.(miner.id, {
x: bottomLeft.x + sideLength / 2,
y: bottomLeft.y + sideLength / 2,
});
} else {
ui?.removeExtraMinerLocation?.(miner.id);
}
};
miner.on(NEW_CHUNK, calcHash);
return () => {
miner.off(NEW_CHUNK, calcHash);
};
}, [miner]);
const wrapper = {
paddingBottom: '10px',
display: 'flex',
justifyContent: 'space-between',
whiteSpace: 'nowrap',
};
const buttonWrapper = {
width: '50px',
display: 'flex',
justifyContent: 'space-between',
};
const remove = () => {
onRemove(miner);
};
const [targeting, setTargeting] = useState(false);
const target = () => setTargeting(true);
useEffect(() => {
const hover = () => {
const coords = ui.getHoveringOverCoords();
if (coords) {
ui?.setExtraMinerLocation?.(miner.id, coords);
}
};
const click = () => {
window.removeEventListener('mousemove', hover);
window.removeEventListener('click', click);
const coords = ui.getHoveringOverCoords();
if (coords) {
const pattern = getPattern(coords, miner.patternType, miner.chunkSize);
miner.setMiningPattern(pattern);
}
miner.startExplore();
setTargeting(false);
};
if (targeting) {
miner.stopExplore();
window.addEventListener('mousemove', hover);
window.addEventListener('click', click);
}
return () => {
window.removeEventListener('mousemove', hover);
window.removeEventListener('click', click);
};
}, [targeting, miner]);
return html`
`;
}
class RemoteExplorerPlugin implements DFPlugin {
private miners: ExtendedMinerManager[];
private id: number;
constructor() {
this.miners = [];
this.id = 0;
this.addMiner('http://0.0.0.0:8000/mine', 'spiral', 256);
}
addMiner = (url: string, patternType = 'spiral', chunkSize = 256) => {
// TODO: Somehow set a default coords
const pattern = getPattern({ x: 0, y: 0 }, patternType, chunkSize);
const miner = Miner.create(
df.getChunkStore(),
pattern,
df.getWorldRadius(),
df.planetRarity,
df.getHashConfig(),
false,
() => new RemoteWorker(url)
) as ExtendedMinerManager;
miner.url = url;
miner.id = this.id++;
miner.chunkSize = chunkSize;
miner.patternType = patternType;
miner.startExplore();
this.miners.push(miner);
return this.miners;
};
removeMiner = (miner: ExtendedMinerManager) => {
this.miners = this.miners.filter((m) => {
if (m === miner) {
ui?.removeExtraMinerLocation?.(m.id);
m.stopExplore();
m.destroy();
return false;
} else {
return true;
}
});
return this.miners;
};
async render(container: HTMLDivElement) {
container.style.minWidth = '450px';
container.style.width = 'auto';
render(
html`
<${App}
initialMiners=${this.miners}
addMiner=${this.addMiner}
removeMiner=${this.removeMiner}
/>
`,
container
);
}
destroy() {
for (const miner of this.miners) {
ui?.removeExtraMinerLocation?.(miner.id);
miner.stopExplore();
miner.destroy();
}
}
}
export default RemoteExplorerPlugin;
================================================
FILE: embedded_plugins/Renderer-Showcase.ts
================================================
/* eslint-disable */
/**
* Below is a list of class definitions for renderers.
* These are blank renderers as they have no functionality.
* The result of using these renderers is the same as disabling the renderer.
*/
import {
engineConsts,
EngineUtils,
GameGLManager,
GenericRenderer,
glsl,
//@ts-ignore
} from 'https://cdn.skypack.dev/@darkforest_eth/renderer';
import {
AsteroidRendererType,
AttribType,
BackgroundRendererType,
BeltRendererType,
BlackDomainRendererType,
CaptureZoneRendererType,
CanvasCoords,
Chunk,
CircleRendererType,
GameViewport,
LineRendererType,
LocatablePlanet,
LocationId,
MineBodyRendererType,
MineRendererType,
PerlinRendererType,
Planet,
PlanetRendererType,
PlanetRenderInfo,
PlanetRenderManagerType,
QuasarBodyRendererType,
QuasarRayRendererType,
QuasarRendererType,
RectRendererType,
RenderedArtifact,
RendererType,
RGBAVec,
RGBVec,
RingRendererType,
RuinsRendererType,
SpaceRendererType,
SpacetimeRipRendererType,
SpriteRendererType,
TextAlign,
TextAnchor,
TextRendererType,
UIRendererType,
UniformType,
UnminedRendererType,
VoyageRendererType,
WorldCoords,
WormholeRendererType,
//@ts-ignore
} from 'https://cdn.skypack.dev/@darkforest_eth/types';
//@ts-ignore
import { html, render } from 'https://unpkg.com/htm/preact/standalone.module.js';
// Line 78 - 350: Blank Renderer
// Line 350 - 651: Circle Renderer
// Line 626 - End: Plugin
// Line 78 - 376
// "Blank" renderer class definitions
// When passing in these renderers into the Dark Forest API, the result would be the same as disabling that type of renderer.
class PlanetRenderer implements PlanetRendererType {
rendererType = RendererType.Planet;
queuePlanetBody(planet: Planet, centerW: WorldCoords, radiusW: number): void {}
flush(): void {}
}
class MineRenderer implements MineRendererType {
rendererType = RendererType.Mine;
queueMine(planet: Planet, centerW: WorldCoords, radiusW: number): void {}
flush(): void {}
}
class SpacetimeRipRenderer implements SpacetimeRipRendererType {
rendererType = RendererType.SpacetimeRip;
queueRip(planet: Planet, centerW: WorldCoords, radiusW: number): void {}
flush(): void {}
}
class QuasarRenderer implements QuasarRendererType {
rendererType = RendererType.Quasar;
queueQuasar(planet: Planet, centerW: WorldCoords, radiusW: number): void {}
flush(): void {}
}
class RuinsRenderer implements RuinsRendererType {
rendererType = RendererType.Ruins;
queueRuins(planet: Planet, centerW: WorldCoords, radiusW: number): void {}
flush(): void {}
}
class AsteroidRenderer implements AsteroidRendererType {
rendererType = RendererType.Asteroid;
queueAsteroid(planet: Planet, centerW: CanvasCoords, radiusW: number, color?: RGBVec): void {}
flush(): void {}
}
class RingRenderer implements RingRendererType {
rendererType = RendererType.Ring;
queueRingAtIdx(
planet: Planet,
centerW: WorldCoords,
radiusW: number,
color?: RGBVec,
beltIdx?: number,
angle?: number
): void {}
flush(): void {}
}
class SpriteRenderer implements SpriteRendererType {
rendererType = RendererType.Sprite;
//drawing artifacts around world
queueArtifactWorld(
artifact: RenderedArtifact,
posW: CanvasCoords,
widthW: number,
alpha?: number,
atFrame?: number | undefined,
color?: RGBVec | undefined,
theta?: number | undefined,
viewport?: GameViewport
): void {}
//drawing artifacts when traveling with voyagers
queueArtifact(
artifact: RenderedArtifact,
pos: CanvasCoords,
width?: number,
alpha?: number,
atFrame?: number | undefined,
color?: RGBVec | undefined,
theta?: number | undefined
): void {}
flush(): void {}
}
class BlackDomainRenderer implements BlackDomainRendererType {
rendererType = RendererType.BlackDomain;
queueBlackDomain(planet: Planet, centerW: WorldCoords, radiusW: number): void {}
flush(): void {}
}
class TextRenderer implements TextRendererType {
rendererType = RendererType.Text;
queueTextWorld(
text: string,
coords: WorldCoords,
color?: RGBAVec,
offY?: number, // measured in text units - constant screen-coord offset that it useful for drawing nice things
align?: TextAlign,
anchor?: TextAnchor,
zIdx?: number
): void {}
flush(): void {}
}
class VoyageRenderer implements VoyageRendererType {
rendererType = RendererType.Voyager;
queueVoyages(): void {}
flush(): void {}
}
class WormholeRenderer implements WormholeRendererType {
rendererType = RendererType.Wormhole;
queueWormholes(): void {}
flush(): void {}
}
class MineBodyRenderer implements MineBodyRendererType {
rendererType = RendererType.MineBody;
queueMineScreen(planet: Planet, center: WorldCoords, radius: number, z: number): void {}
flush(): void {}
setUniforms(): void {}
}
class BeltRenderer implements BeltRendererType {
rendererType = RendererType.Belt;
queueBeltAtIdx(
planet: Planet,
center: WorldCoords | CanvasCoords,
radius?: number,
color?: RGBVec,
beltIdx?: number,
angle?: number,
screen?: boolean
): void {}
flush(): void {}
setUniforms(): void {}
}
class BackgroundRenderer implements BackgroundRendererType {
rendererType = RendererType.Background;
queueChunks(
exploredChunks: Iterable,
highPerfMode: boolean,
drawChunkBorders: boolean,
disableFancySpaceEffect: boolean,
innerNebulaColor?: string,
nebulaColor?: string,
spaceColor?: string,
deepSpaceColor?: string,
deadSpaceColor?: string
): void {}
flush(): void {}
}
class SpaceRenderer implements SpaceRendererType {
rendererType = RendererType.Space;
queueChunk(chunk: Chunk): void {}
setColorConfiguration(
innerNebulaColor: string,
nebulaColor: string,
spaceColor: string,
deepSpaceColor: string,
deadSpaceColor: string
): void {}
flush(): void {}
}
class UnminedRenderer implements UnminedRendererType {
rendererType = RendererType.Unmined;
queueRect(
{ x, y }: CanvasCoords,
width: number,
height: number,
color: RGBVec,
zIdx: number
): void {}
flush(): void {}
}
class PerlinRenderer implements PerlinRendererType {
rendererType = RendererType.Perlin;
queueChunk(chunk: Chunk): void {}
flush(): void {}
}
class LineRenderer implements LineRendererType {
rendererType = RendererType.Line;
queueLineWorld(
start: WorldCoords,
end: WorldCoords,
color?: RGBAVec,
width?: number,
zIdx?: number,
dashed?: boolean
): void {}
flush(): void {}
}
class RectRenderer implements RectRendererType {
rendererType = RendererType.Rect;
queueRectCenterWorld(
center: WorldCoords,
width: number,
height: number,
color?: RGBVec,
stroke?: number,
zIdx?: number
): void {}
flush(): void {}
}
class CircleRenderer implements CircleRendererType {
rendererType = RendererType.Circle;
queueCircleWorld(
center: CanvasCoords,
radius: number,
color?: RGBAVec,
stroke?: number,
angle?: number, // percent of arc to render
dashed?: boolean
): void {}
queueCircleWorldCenterOnly(
center: WorldCoords,
radius: number, // canvas coords
color?: RGBAVec
): void {}
flush(): void {}
}
class UIRenderer implements UIRendererType {
rendererType = RendererType.UI;
queueBorders(): void {}
queueSelectedRangeRing(): void {}
queueSelectedRect(): void {}
queueHoveringRect(): void {}
queueMousePath(): void {}
drawMiner(): void {}
flush(): void {}
}
class PlanetRenderManager implements PlanetRenderManagerType {
rendererType = RendererType.PlanetManager;
queueRangeRings(planet: LocatablePlanet): void {}
queuePlanets(
cachedPlanets: Map,
now: number,
highPerfMode: boolean,
disableEmojis: boolean,
disableHats: boolean
): void {}
flush(): void {}
}
class QuasarBodyRenderer implements QuasarBodyRendererType {
rendererType = RendererType.QuasarBody;
queueQuasarBody(
planet: Planet,
centerW: WorldCoords,
radiusW: number,
z?: number,
angle?: number
): void {}
flush(): void {}
}
class QuasarRayRenderer implements QuasarRayRendererType {
rendererType = RendererType.QuasarRay;
queueQuasarRay(
planet: Planet,
centerW: WorldCoords,
radiusW: number,
z?: number,
top?: boolean,
angle?: number
): void {}
flush(): void {}
}
class CaptureZoneRenderer implements CaptureZoneRendererType{
rendererType = RendererType.CaptureZone;
queueCaptureZones(): void {}
flush(): void {}
}
// line 350 - 351
// Circle Renderer Definitions using WebGl
// Program Definition
// A program is what we use to organizie the attributes and shaders of WebGl Programs
const u = {
matrix: 'u_matrix', // matrix to convert from world coords to clipspace
};
const a = {
position: 'a_position', // as [posx, posy, rectposx, rectposy]
color: 'a_color',
props: 'a_props', // as [stroke, angle, dash]
eps: 'a_eps',
planetInfo: 'a_planetInfo', //as [planetlevel, radius]
PlanetUpgrades: 'a_planetUpgrades', //as [defense:number , range: number, speed: number]
PlanetResources: 'a_planetResources', //as [energy:number , energy cap: number, silver: number, silver cap: number]
};
const GENERIC_PLANET_PROGRAM_DEFINITION = {
uniforms: {
matrix: { name: u.matrix, type: UniformType.Mat4 },
},
attribs: {
position: {
dim: 4,
type: AttribType.Float,
normalize: false,
name: a.position,
},
eps: {
dim: 1,
type: AttribType.Float,
normalize: false,
name: a.eps,
},
color: {
dim: 4,
type: AttribType.UByte,
normalize: true,
name: a.color,
},
props: {
dim: 2,
type: AttribType.Float,
normalize: false,
name: a.props,
},
planetInfo: {
dim: 2,
type: AttribType.UByte,
normalize: false,
name: a.planetInfo,
},
planetUpgrades: {
dim: 3,
type: AttribType.UByte,
normalize: false,
name: a.PlanetUpgrades,
},
planetResources: {
dim: 4,
type: AttribType.UByte,
normalize: false,
name: a.PlanetResources,
},
},
vertexShader: glsl`
in vec4 a_position;
in vec4 a_color;
in vec2 a_props;
in float a_eps;
in vec2 a_planetInfo;
in vec4 a_planetResources;
uniform mat4 u_matrix;
out float v_planetLevel;
out vec4 v_color;
out vec2 v_rectPos;
out float v_angle;
out float v_dash;
out float v_eps;
out float energy;
out float energy_cap;
void main() {
gl_Position = u_matrix * vec4(a_position.xy, 0.0, 1.0);
v_rectPos = a_position.zw;
v_color = a_color;
v_angle = a_props.x;
v_dash = a_props.y;
v_eps = a_eps;
v_planetLevel = a_planetInfo[0];
energy = a_planetResources[0];
energy_cap = a_planetResources[1];
}
`,
fragmentShader: glsl`
#define PI 3.1415926535
precision highp float;
out vec4 outColor;
in vec4 v_color;
in vec2 v_rectPos;
in float v_angle;
in float v_dash;
in float v_eps;
in float v_planetLevel;
in float energy;
in float energy_cap;
void main() {
vec4 color = v_color;
float dist = length(v_rectPos);
if (dist > 1.0) discard; // if it's outside the circle
// anti-aliasing if barely in the circle
float ratio = (1.0 - dist) / v_eps;
if (ratio < 1.) {
color.a *= ratio;
}
/* get angle for both angle + dash checks */
float angle = atan(v_rectPos.y, v_rectPos.x);
// add 5pi/2 to translate it to [-PI/2, 3PI / 2]
float check = angle + (5.0 * PI / 2.0);
check -= (check > 2.0 * PI ? 2.0 * PI : 0.0);
float pct = check / (2.0 * PI);
/* do angle check */
if (v_angle != 1.0 && pct > v_angle) discard;
/* do dash check */
bool isDash = v_dash > 0.0;
float interval = angle / v_dash;
float modulo = interval - 2.0 * floor(interval / 2.0);
bool isGap = modulo > 1.0;
if (isDash && isGap) discard;
/* now draw it */
outColor = vec4(1,1.0/energy_cap*energy,0,1);
}
`,
};
class CirclePlanetRenderer extends GenericRenderer<
typeof GENERIC_PLANET_PROGRAM_DEFINITION,
GameGLManager
> {
quadBuffer: number[];
viewport: GameViewport;
rendererType: number;
vertexShader: string;
fragmentShader: string;
manager: GameGLManager;
constructor(glManager: GameGLManager, n: number) {
super(glManager, GENERIC_PLANET_PROGRAM_DEFINITION);
//@ts-ignore
this.verts = 0; //found in generic renderer
this.manager = glManager;
const { vertexShader: vert, fragmentShader: frag } = GENERIC_PLANET_PROGRAM_DEFINITION;
this.vertexShader = vert;
this.fragmentShader = frag;
this.rendererType = n;
this.viewport = this.manager.renderer.getViewport();
this.quadBuffer = EngineUtils.makeEmptyDoubleQuad();
}
public queuePlanet(
center: CanvasCoords,
radius: number,
planet: Planet,
angle = 1, // percent of arc to render
dashed = false
): void {
const color = [255, 255, 255, 255] as RGBAVec;
const {
position: posA,
color: colorA,
props: propsA,
eps: epsA,
planetInfo: planetInfoA,
planetUpgrades: planetUpgradesA,
planetResources: planetResourcesA,
//@ts-ignore
} = this.attribManagers;
const { x, y } = center;
// 1 on either side for antialiasing
const r = radius + 1;
const { x1, y1 } = { x1: x - r, y1: y - r };
const { x2, y2 } = { x2: x + r, y2: y + r };
// prettier-ignore
EngineUtils.makeDoubleQuadBuffered(
this.quadBuffer,
x1, y1, x2, y2, -1, -1, 1, 1
);
//@ts-ignore
posA.setVertex(this.quadBuffer, this.verts);
// convert pixels to radians
const interval = engineConsts.dashLength;
const pixPerRad = radius;
const dashRad = interval / pixPerRad;
const dash = dashed ? dashRad : -1;
const eps = 1 / radius;
const resources = [planet.energy, planet.energyCap, planet.silver, planet.silverCap];
for (let i = 0; i < 6; i++) {
//@ts-ignore
colorA.setVertex(color, this.verts + i);
//@ts-ignore
propsA.setVertex([angle, dash], this.verts + i);
//@ts-ignore
planetInfoA.setVertex([planet.planetLevel, radius], this.verts + i);
//@ts-ignore
planetUpgradesA.setVertex(planet.upgradeState, this.verts + i);
//@ts-ignore
planetResourcesA.setVertex(resources, this.verts + i);
//@ts-ignore
epsA.setVertex([eps], this.verts + i);
}
//@ts-ignore
this.verts += 6;
}
public queueGenericPlanet(
planet: Planet,
center: WorldCoords,
radius: number, // world coords
stroke = -1,
angle = 1,
dashed = false
) {
const centerCanvas = this.viewport.worldToCanvasCoords(center);
const rCanvas = this.viewport.worldToCanvasDist(radius);
this.queuePlanet(centerCanvas, rCanvas, planet, angle, dashed);
}
public setUniforms() {
//@ts-ignore
this.uniformSetters.matrix(this.manager.projectionMatrix);
}
public queuePlanetBody(planet: Planet, centerW: WorldCoords, radiusW: number): void {
this.queueGenericPlanet(planet, centerW, radiusW);
}
public queueMine(planet: Planet, centerW: WorldCoords, radiusW: number): void {
this.queueGenericPlanet(planet, centerW, radiusW);
}
public queueRip(planet: Planet, centerW: WorldCoords, radiusW: number): void {
this.queueGenericPlanet(planet, centerW, radiusW);
}
public queueQuasar(planet: Planet, centerW: WorldCoords, radiusW: number): void {
this.queueGenericPlanet(planet, centerW, radiusW);
}
public queueRuins(planet: Planet, centerW: WorldCoords, radiusW: number): void {
this.queueGenericPlanet(planet, centerW, radiusW);
}
public queueAsteroid(planet: Planet, centerW: CanvasCoords, radiusW: number): void {
this.queueGenericPlanet(planet, centerW, radiusW);
}
}
/**
* 626-END: Plugin
*/
export default class EmbeddedRendererShowcase implements DFPlugin {
CirclePlanetLibrary: { [key: string]: any };
circleSelector: string;
circleChecker: { [key: string]: boolean };
constructor() {
let glMan = ui.getGlManager();
this.circleSelector = 'Planet';
if (glMan) {
this.CirclePlanetLibrary = {
Planet: new CirclePlanetRenderer(glMan, RendererType.Planet),
Mine: new CirclePlanetRenderer(glMan, RendererType.Mine),
SpacetimeRip: new CirclePlanetRenderer(glMan, RendererType.SpacetimeRip),
Quasar: new CirclePlanetRenderer(glMan, RendererType.Quasar),
Ruins: new CirclePlanetRenderer(glMan, RendererType.Ruins),
};
}
this.circleChecker = {};
for (let key in this.CirclePlanetLibrary) {
this.circleChecker[key] = false;
}
}
async render(div: HTMLDivElement) {
div.style.width = '500px';
render(
html`
Disabling Renderers
Whats actually happening here is that the current renderer is being replaced with a
'blank' renderer. A blank renderer is a renderer who's flush function has no
functionality. So the behavior is similar to disabling the current renderer.
{
disable();
}}
>
Disable
Circle Planets
This replaces the current planet renderer with a renderer that uses WebGL to create a
circle where the color of the circle changes on the percentage of energy on the planet.
{
const btn = document.getElementById('CirclePlanetBtn');
if (this.circleChecker[this.circleSelector] === false) {
ui.setCustomRenderer(this.CirclePlanetLibrary[this.circleSelector]);
this.circleChecker[this.circleSelector] = true;
btn!.innerText = 'Disable';
} else {
ui.disableCustomRenderer(this.CirclePlanetLibrary[this.circleSelector]);
this.circleChecker[this.circleSelector] = false;
btn!.innerText = 'Enable';
}
}}
>
Enable
Renderer Descriptions
`,
div
);
}
destroy(): void {
currentPlanet = 'Planet';
for (let key in rendererLibrary) {
ui.disableCustomRenderer(rendererLibrary[key]);
}
for (let key in this.CirclePlanetLibrary) {
ui.disableCustomRenderer(this.CirclePlanetLibrary[key]);
}
}
}
let selectStyle = {
outline: 'none',
background: '#151515',
color: '#838383',
borderRadius: '4px',
border: '1px solid #777',
width: '100px',
padding: '2px 6px',
cursor: 'pointer',
margin: '10px',
};
let inputStyle = {
background: 'rgb(8,8,8)',
width: '400px',
padding: '3px 5px',
};
let buttonStyle = { height: '25px', padding: '3px 5px', margin: '10px', 'text-align': 'center' };
let rendererLibrary: { [key: string]: any } = {
Planet: new PlanetRenderer(),
Mine: new MineRenderer(),
SpacetimeRip: new SpacetimeRipRenderer(),
Ruins: new RuinsRenderer(),
Quasar: new QuasarRenderer(),
Asteroid: new AsteroidRenderer(),
MineBody: new MineBodyRenderer(),
MineBelt: new BeltRenderer(),
Background: new BackgroundRenderer(),
UnminedBackground: new UnminedRenderer(),
SpaceBackground: new SpaceRenderer(),
Artifact: new SpriteRenderer(),
AllPlanets: new PlanetRenderManager(),
Text: new TextRenderer(),
Voyager: new VoyageRenderer(),
Perlin: new PerlinRenderer(),
Wormhole: new WormholeRenderer(),
BlackDomain: new BlackDomainRenderer(),
Rectangles: new RectRenderer(),
Line: new LineRenderer(),
Circle: new CircleRenderer(),
Ring: new RingRenderer(),
UI: new UIRenderer(),
QuasarBody: new QuasarBodyRenderer(),
QuasarRay: new QuasarRayRenderer(),
CaptureZone: new CaptureZoneRenderer(),
};
let disabled: { [key: string]: boolean } = {};
for (let key in rendererLibrary) {
disabled[key] = false;
}
let currentPlanet: string = 'Planet';
function disable() {
const btn = document.getElementById('RegPlanetBtn');
if (disabled[currentPlanet] === false) {
ui.setCustomRenderer(rendererLibrary[currentPlanet]);
disabled[currentPlanet] = true;
btn!.innerText = 'Enable';
} else {
ui.disableCustomRenderer(rendererLibrary[currentPlanet]);
disabled[currentPlanet] = false;
btn!.innerText = 'Disable';
}
}
const cellStyle = {
width: '25%',
float: 'left',
};
const discriptionStyle = {
TextAlign: 'justify',
};
// Used for discription of each type of renderer
let rendererDescription: { [key: string]: any } = {
Blank: '',
Planet: 'basic planets',
Mine: 'asteroid fields',
SpacetimeRip: 'Spacetime Rips',
Ruins: 'foundries',
Quasar: 'quasars',
Asteroid: 'asteroid that hover around different planets',
MineBody: 'the body/asteroids of asteroid fields',
MineBelt: 'the belts/rings around asteroid fields',
Background: 'the background of the game',
UnminedBackground: 'unmined space chunks (part of the background)',
SpaceBackground: 'mined space chunks (part of the background)',
Artifact: 'artifacts',
AllPlanets: 'All planet types',
Text: 'text that are displayed on the game canvas',
Voyager: 'Voyages. The transfer of energy between planets.',
Perlin:
'the game background. Perlin is the method in which we generate the location of space biomes.',
Wormhole: 'visual effects of wormholes. Wormholes are generated by a special type of artifact.',
BlackDomain:
'visual effects of black domains. Black Domains are created by a special type of artifact',
Rectangles: 'all rectangles drawn in game: indicators for selection of planet, ',
Line: ' all lines drawn in game: The line that connect planets during voyages and wormholes ',
Circle:
'all circles drawn in the game: The voyager(circle) in voyages, Circles used to indicate the range a planets has, The boarder of the game world. ',
Ring: 'rings that indicate the level of a planet',
UI: 'in game user interface: game borders, range indicators, selection indicators, mouse path, miner',
QuasarBody: 'the body of the Quasar',
QuasarRay: 'the ray of the Quasar',
CaptureZone: 'the capture zones'
};
/* eslint-enable */
================================================
FILE: index.html
================================================
Dark Forest
================================================
FILE: last_updated.txt
================================================
last updated: Mon Apr 11 18:20:58 UTC 2022
================================================
FILE: netlify.toml
================================================
[build]
command = "yarn build"
functions = "functions"
publish = "dist"
[[redirects]]
from = "/*"
to = "/index.html"
status = 200
[[redirects]]
from = "/archive/8d8a7d2a/*"
to = "https://6247dc3ca1de3b6ce0c8e184--df-prod.netlify.app/:splat"
status = 200
## (optional) Settings for Netlify Dev
## https://github.com/netlify/cli/blob/master/docs/netlify-dev.md#project-detection
#[dev]
# command = "yarn start" # Command to start your dev server
# port = 3000 # Port that the dev server will be listening on
# publish = "dist" # Folder with the static content for _redirect file
## more info on configuring this file: https://www.netlify.com/docs/netlify-toml-reference/
================================================
FILE: package.json
================================================
{
"name": "client",
"version": "6.7.29",
"private": true,
"license": "GPL-3.0",
"author": "0xPARC ",
"dependencies": {
"@darkforest_eth/constants": "6.7.29",
"@darkforest_eth/contracts": "6.7.29",
"@darkforest_eth/events": "6.7.29",
"@darkforest_eth/gamelogic": "6.7.29",
"@darkforest_eth/hashing": "6.7.29",
"@darkforest_eth/hexgen": "6.7.29",
"@darkforest_eth/network": "6.7.29",
"@darkforest_eth/procedural": "6.7.29",
"@darkforest_eth/renderer": "6.7.29",
"@darkforest_eth/serde": "6.7.29",
"@darkforest_eth/settings": "6.7.29",
"@darkforest_eth/snarks": "6.7.29",
"@darkforest_eth/types": "6.7.29",
"@darkforest_eth/ui": "6.7.29",
"@darkforest_eth/whitelist": "6.7.29",
"@lit-labs/react": "^1.0.0",
"animejs": "^3.2.1",
"auto-bind": "^4.0.0",
"bad-words": "^3.0.4",
"big-integer": "^1.6.48",
"canvas-confetti": "^1.4.0",
"color": "^3.0.2",
"delay": "^5.0.0",
"email-validator": "^2.0.4",
"emoji-picker-react": "^3.4.8",
"ethers": "^5.5.1",
"events": "^3.0.0",
"fastq": "^1.10.0",
"file-saver": "^2.0.5",
"gl-matrix": "^3.3.0",
"htm": "^3.0.4",
"idb": "^5.0.1",
"js-quadtree": "^3.3.5",
"json-stable-stringify": "^1.0.1",
"jszip": "^3.5.0",
"lodash": "^4.17.15",
"mnemonist": "^0.38.1",
"p-defer": "^3.0.0",
"p-timeout": "^4.0.0",
"preact": "^10.5.13",
"prismjs": "^1.22.0",
"react": "^17.0.2",
"react-dom": "^17.0.2",
"react-loader-spinner": "^4.0.0",
"react-router-dom": "^5.3.0",
"react-simple-code-editor": "^0.11.0",
"react-sortablejs": "^6.0.0",
"react-timeago": "^6.2.1",
"sortablejs": "^1.10.2",
"styled-components": "^5.3.3",
"ts-dedent": "^2.0.0",
"uuid": "^8.3.2"
},
"scripts": {
"declarations": "tsc -p tsconfig.decs.json",
"test": "exit 0",
"lint": "eslint .",
"format": "prettier --write .",
"start": "webpack-dev-server --mode development --hot",
"build": "webpack --mode production",
"clean": "del-cli dist node_modules declarations public/contracts tsconfig.ref.tsbuildinfo",
"docs": "typedoc && yarn format",
"deploy": "netlify build && netlify deploy",
"deploy:prod": "netlify build && netlify deploy --prod"
},
"browserslist": {
"production": [
"last 1 chrome version",
"last 1 firefox version"
],
"development": [
"last 1 chrome version",
"last 1 firefox version"
]
},
"engines": {
"node": ">=16"
},
"devDependencies": {
"@babel/core": "^7.17.5",
"@babel/preset-env": "^7.16.11",
"@babel/preset-react": "^7.16.7",
"@babel/preset-typescript": "^7.16.7",
"@types/animejs": "^3.1.3",
"@types/color": "^3.0.2",
"@types/gl-matrix": "^3.2.0",
"@types/json-stable-stringify": "^1.0.32",
"@types/lodash": "^4.14.160",
"@types/prismjs": "^1.16.2",
"@types/react": "^17.0.34",
"@types/react-dom": "^17.0.11",
"@types/react-router-dom": "^5.3.2",
"@types/react-timeago": "^4.1.3",
"@types/sortablejs": "^1.10.6",
"@types/styled-components": "^5.1.15",
"@types/uuid": "^8.3.0",
"@types/webpack-env": "^1.16.3",
"babel-loader": "^8.2.3",
"babel-plugin-styled-components": "^2.0.5",
"copy-webpack-plugin": "^9.0.1",
"css-loader": "^6.5.1",
"del-cli": "^4.0.1",
"dotenv": "^10.0.0",
"eslint": "^7.30.0",
"fork-ts-checker-webpack-plugin": "^7.2.1",
"html-webpack-plugin": "^5.5.0",
"netlify-cli": "^3.8.5",
"prettier": "^2.3.0",
"raw-loader": "^4.0.2",
"resolve-package-path": "^4.0.3",
"source-map-loader": "^3.0.0",
"style-loader": "^3.3.1",
"typedoc": "^0.22.8",
"typedoc-plugin-markdown": "3.11.x",
"typescript": "4.5.x",
"webpack": "^5.62.1",
"webpack-bundle-analyzer": "^4.5.0",
"webpack-cli": "^4.9.1",
"webpack-dev-server": "^4.4.0"
}
}
================================================
FILE: plugins/PluginTemplate.ts
================================================
/**
* Remember, you have access these globals:
* 1. df - Just like the df object in your console.
* 2. ui - For interacting with the game's user interface.
*
* Let's log these to the console when you run your plugin!
*/
console.log(df, ui);
class PluginTemplate implements DFPlugin {
constructor() {}
/**
* Called when plugin is launched with the "run" button.
*/
async render(container: HTMLDivElement) {}
/**
* Called when plugin modal is closed.
*/
destroy() {}
}
/**
* And don't forget to export it!
*/
export default PluginTemplate;
================================================
FILE: plugins/README.md
================================================
# Plugins
TypeScript or JavaScript files in this directory will automatically be bundled and served as plugins when running `df-plugin-dev-server` in the root of the game `client`!
Check out [Plugin Development](../README.md#plugin-development) in the main README for the steps to set it up.
================================================
FILE: plugins/RendererPlugin.md
================================================
# Pluginnable Renderers
This article is about creating custom renderers for Dark Forest through the use of our plugin system.
# Background
Dark Forest uses WebGL to visualize the game. WebGL is a JavaScript API that is used for rendering high-performance 3D graphics.
Only certain browsers support WebGL. Click here to check: https://get.webgl.org/WebGL/.
Click here to Learn more about WebGL: https://WebGLfundamentals.org/webgl/lessons/webgl-getting-WebGL.html
# What is a Renderer
Renderers are classes that are used to draw specific types of entities such as planets or asteroids onto the Dark Forest game canvas. Custom made renderers can be passed into the Dark Forest API to replace the current renderer for that entity type.
Renderers have two main methods:
- Queue (a method that starts with `queue` followed by the name of the object it's rendering): The game calls the queue method for each instance of an object specified by the renderer type and accepts as an input any information relevant to the object. This information is then added to some implementation of a queue within the renderer for later use in the flush method.
- Flush: Flush is called every frame in the game. When called, the entities in the queue should be rendered onto the game canvas and the queue cleared.
For the game to recognize if the class is a renderer, it has to follow one of the renderer interfaces that can be found in `@darkforest_eth/types`
For instance `MineRendererType` is an interface for mine renderers. Mine renderers are used to draw Asteroid Fields which is a type of planet (not to be confused with Asteroids).
The `MineRendererType` has 2 abstract methods:
- `queueMine` is called by the game to queue an Asteroid Field to be drawn. The method has 3 parameters:
- `planet`: A Planet object that contains information about the current Asteroid Field
- `centerW`: a set of x and y coordinates that represent the position of the center of the Asteroid Field relative to the game world.
- `radiusW`: the size of the Asteroid Field relative to the game world.
- `flush` called by the game to draw all queued up Asteroid Field.
Here is Dark Forest's current implementation of its mine renderer: https://github.com/darkforest-eth/packages/blob/master/renderer/src/Entities/MineRenderer.ts
## Draw Order
### The Order in Which Renderer Managers and Renderers Are Flushed
1. Background
- Unmined
- Space
2. Capture Zones
3. Line Renderer
4. Planet Manager
- Planet
- Asteroid
- Mine
- Spacetime Rip
- Ruins
- Ring
- Quasar
- Black Domain
5. UI
6. Voyager
7. Wormhole
8. Circle
9. Rect
10. Text
11. Sprite (Artifacts)
### When Multiple Renderers Implementing the Same Interface Are Passed Into the API:
When you replace a renderer in the game, the renderer is then put on our rendering stack. The rendering stack is used to determine which renderer to use if multiple renderers loaded for the same entity at the same time. The game will use the top most renderer. A renderer at any position in the stack can be popped.
# Example Plugin
We will run through the creation of a renderer that will replace the renderer for Asteroid Fields.
To create a renderer it has to follow one of the renderer interfaces that can be found in `@darkforest_eth/types`. For the Asteroid Fields, we will be using the `MineRendererType`.
```javascript
import { RendererType } from 'https://cdn.skypack.dev/@darkforest_eth/types';
class GenericMineRenderer {
constructor() {
this.rendererType = RendererType.Mine;
}
queueMine(planet, centerW, radiusW) {}
flush() {}
}
```
After implementing the interface the code should look similar to the code above. The code above can be considered a fully functional renderer. The resulting behavior would be as if you were disabling the renderer for the Asteroid Renderer.
Before:
After:
If you noticed in the queue function, the coordinate of the planet and the size of planet is relative to the game world. However when drawn on the canvas, the size and location of planet change based on the position of the players camera. We provide developers a way to easily transform between coordinate systems via the viewport class. You can get the viewport from the global ui class. `ui.getViewport()`. An example of the use of the viewport can be seen in the code of the `queueMine` function below.
```javascript
import { RendererType } from 'https://cdn.skypack.dev/@darkforest_eth/types';
class GenericMineRenderer {
constructor() {
this.viewport = ui.getViewport();
this.rendererType = RendererType.Mine;
}
queueMine(planet, centerW, radiusW) {
const centerCanvas = this.viewport.worldToCanvasCoords(centerW);
const rCanvas = this.viewport.worldToCanvasDist(radiusW);
}
flush() {}
}
```
The `Viewport` class is used to translate between game world and canvas for distances and coordinates: https://github.com/darkforest-eth/packages/blob/master/types/interfaces/GameViewport.md
These are the 2 functions used above.
- `worldToCanvasCoords` will translate from game world coordinates to canvas coordinates. In the code above we are translating the location of the Asteroid Field to its location relative to the canvas.
- `worldToCanvasDist` will translate a distance relative to the game world to the pixel distance on the canvas.
After implementing the above code you should be ready to start implementing code that will draw on the game canvas.
To do this you will need to be able to access the `WebGLRenderingContext`.
## WebGL Code
The next few sections will be about writing the WebGL Code.
We will be creating WebGL code that renders a circle instead of the original asteroid field. The color of the asteroid field while change based on the current energy level of the planet. The RGB value of the color is determined by this equation `red: 255 green: 255/(energy cap) \*(current energy) blue: 0`.
The goal of this section is to give you a basic understanding of how the WebGL code works. If you want to dive deeper into WebGL check out this website:
https://WebGLfundamentals.org/webgl/lessons/webgl-how-it-works.html
## Definitions
Clip space: The 3D coordinate system used by WebGL for its canvas. All coordinates range fro`m -1 to 1.
Vertex shader: The vertex shader is used to determine the location of a vertex on the WebGL clip space. WebGL will draw a shape onto the canvas based on the passed in vertices. For instance, the triangle draw mode will connect every 3 consecutive vertices to create a triangle.
Fragment Shader: Once a shape is created, the fragment shader is used to determine the color of each individual pixel in the shape.
Attribute Variables: The attributes are values that are passed in from outside the shader program to the vertex shader. Each vertex has its on set of attribute variables.
Uniform Variables: The uniforms are effectively global variables you set before the execution of the program. All vertices share the same uniform variables.
Varying Variables: Variables that will be transferred to be used in the fragment shader
The code below contains all of the objects that we will explore to demonstrate WebGL rendering. The two shaders are wrapped into a RendererProgram class. The RendererProgram is how the Dark Forest team structures our code. You do not have to follow this structure to create a working WebGL Program.
## Fragment and Vertex Shaders
```javascript
import { glsl } from 'https://cdn.skypack.dev/@darkforest_eth/renderer';
import {
RendererProgram,
AttribeType,
UniformType,
} from 'https://cdn.skypack.dev/@darkforest_eth/types';
const program = {
uniforms: {
matrix: { name: 'u_matrix', type: UniformType.Mat4 },
},
attribs: {
position: {
dim: 4,
type: AttribType.Float,
normalize: false,
name: 'a_position', //the name of the attribute variable
},
energyInfo: {
dim: 2,
type: AttribType.Float,
normalize: false,
name: 'a_energy',
},
},
vertexShader: glsl`
in vec4 a_position;
in vec2 a_energy;
uniform mat4 u_matrix;
out vec2 v_rectPos;
out float v_energy;
out float v_energy_cap;
void main() {
// converting from canvas coordinates too clip space
gl_Position = u_matrix * vec4(a_position.xy, 0.0, 1.0);
//setting the varrying variables for use in the fragment shader
v_energy = a_energy.x;
v_energy_cap = a_energy.y;
v_rectPos = a_position.zw;
}
`,
fragmentShader: glsl`
#define PI 3.1415926535
precision highp float;
out vec4 outColor;
in vec2 v_rectPos;
in float v_energy;
in float v_energy_cap;
void main() {
float dist = length(v_rectPos);
// if it's outside the circle
if (dist > 1.0) discard;
//determine the color of the pixel using rgb values
//[red,green,blue,opacity] the range of the numbers is from 0 to 1
outColor = vec4(1,1.0/v_energy_cap*v_energy,0,1);
}
`,
};
```
For the both the Vertex and Fragment shader `glsl` is used. `glsl` formats the string to be readable by the shader compiler.
### Vertex Shader
`a_position` and `a_energy` are attributes and `u_matrix` is a uniform for this shader program.
- `a_position` is a vector that contains the location of the vertex being drawn
- `a_energy` is a vector that contains information about the energy of the Asteroid Field.
The `u_matrix` is a projection matrix. It is used to do some fancy math in line 10:
`gl_Position = u_matrix * vec4(a_position.xy, 0.0, 1.0);`
This is transforming coordinates from the canvas into clip space coordinates. If you want to read more about how this math done, checkout this link: https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/WebGL_model_view_projection.
With the combination of some code we will write later, the vertex shader will draw a square at the coordinates we decide.
### Fragment Shader
The fragment shader is called for every pixel in the square. The `outColor` is the color of the pixel. This fragment draw a circle with a clip space radius of 1. The fragment shader checks if the pixel is one unit away from the center of the square by use of the length function and `discard`s the pixel away if it is not.
## Renderer Code
```javascript
import { EngineUtils, GenericRenderer, glsl } from 'https://cdn.skypack.dev/@darkforest_eth/renderer';
import { AttribType, RendererType, UniformType,
} from 'https://cdn.skypack.dev/@darkforest_eth/types';
class GenericMineRenderer extends GenericRenderer {
constructor(gl, vp) {
super(gl, program);
this.rendererType = RendererType.Mine;
this.gl = gl;
this.viewport = vp;
this.quadBuffer = EngineUtils.makeEmptyDoubleQuad();
}
```
The `GameGLManager` is a wrapper class that contains the WebGLRenderingContext: https://github.com/darkforest-eth/packages/blob/master/renderer/classes/GameGLManager.md
`GenericRenderer` is a class that was created by the Dark Forest team for the purposes of organization. `GenericRenderer` sets up a lot of the commonly used WebGL code. You do not have to use this to create functioning WebGL Code. You can look at the `GenericRenderer` Code here: https://github.com/darkforest-eth/packages/blob/master/renderer/src/WebGL/GenericRenderer.ts
The `quadBuffer` is an array that will contain the vertices of the square being drawn.
`EngineUtils` is a tool the Dark Forest team created for commonly used WebGL operations: https://github.com/darkforest-eth/packages/blob/master/renderer/src/EngineUtils.ts
```typescript
public flush(drawMode: DrawMode = DrawMode.Triangles) {
if (this.verts === 0) return;
const { gl } = this.manager;
gl.useProgram(this.program);
this.setUniforms();
for (const attrib in this.attribManagers) {
this.attribManagers[attrib].bufferData(this.verts);
}
// draw
gl.drawArrays(drawMode, 0, this.verts);
this.verts = 0;
}
```
This is the flush function which was inherited by `GenericRenderer`.
The default `DrawMode` is to use triangles. This means whenever 3 vertices are put into the vertex shader it will draw a triangle.
As stated above the goal of the vertex shader was to draw a square. To do that with triangle we need to draw 2 triangles connected by one their sides. The result of this will require us to import 6 vertices.
Square:
```javascript
queueMine(planet: Planet, centerW: WorldCoords, radiusW: number): void {
//converting from game coordinates to canvas coordinates
const centerCanvas = this.viewport.worldToCanvasCoords(centerW);
const rCanvas = this.viewport.worldToCanvasDist(radiusW);
this.queueCircle(planet, centerCanvas, rCanvas);
}
queueCircle(planet: Planet, center: CanvasCoords, radius: number) {
const { position: posA, energyInfo: energyA } = this.attribManagers;
const r = radius + 1;
const { x, y } = center;
//calculating the top left and bottom right of the bounding square.
const { x1, y1 } = { x1: x - r, y1: y - r };
const { x2, y2 } = { x2: x + r, y2: y + r };
//creating an array of all the vertices for the triangle 14
EngineUtils.makeDoubleQuadBuffered(
this.quadBuffer,
x1, y1, x2, y2, -1, -1, 1, 1
);
//passing in the vertices to the vertex shader
posA.setVertex(this.quadBuffer, this.verts);
//passing in the energy information. 6 times because we passed in 6 vertices.
for (let i = 0; i < 6; i++) {
energyA.setVertex([planet.energy, planet.energyCap], this.verts + i);
}
this.verts += 6;
}
setUniforms() {
if (!this.gl) return;
this.uniformSetters.matrix(this.gl.projectionMatrix);
}
```
The `makeDoubleQuadBuffered` code creates an array of size 24. We are then inserting the array to be imported into fragment shader through `a_position` attribute.
Since `a_position` is imported as a `vec4` the `quadbuffer` is split evenly into 6 vectors of size 4, one for each vertex. Each vector is formatted like this:
[canvas x, canvas y, clip space x, clip space y]
In relation to the square, the coordinates of the 6 vertices are the top left, top right, bottom left, bottom right of the square. Where the top right and bottom left repeat twice.
```javascript
for (let i = 0; i < 6; i++) {
energyA.setVertex([planet.energy, planet.energyCap], this.verts + i);
}
this.verts += 6;
```
For each vertex we are importing the information about the planet's energy to the `a_energy` attribute.
## Final Renderer Code
The final code for the renderer looks like this:
```javascript
import {
EngineUtils,
GenericRenderer,
glsl,
} from 'https://cdn.skypack.dev/@darkforest_eth/renderer';
import {
AttribType,
RendererType,
UniformType,
} from 'https://cdn.skypack.dev/@darkforest_eth/types';
class GenericMineRenderer extends GenericRenderer {
constructor(gl, vp) {
super(gl, program);
this.rendererType = RendererType.Mine;
this.gl = gl;
this.viewport = vp;
this.quadBuffer = EngineUtils.makeEmptyDoubleQuad();
}
queueMine(planet, centerW, radiusW) {
//converting from game coordinates to canvas coordinates
const centerCanvas = this.viewport.worldToCanvasCoords(centerW);
const rCanvas = this.viewport.worldToCanvasDist(radiusW);
this.queueCircle(planet, centerCanvas, rCanvas);
}
queueCircle(planet, center, radius) {
const { position: posA, energyInfo: energyA } = this.attribManagers;
const r = radius + 1;
const { x, y } = center;
//calculating the top left and bottom right of the bounding square.
const { x1, y1 } = { x1: x - r, y1: y - r };
const { x2, y2 } = { x2: x + r, y2: y + r };
//creating an array of all the vertices for the triangle 14
EngineUtils.makeDoubleQuadBuffered(this.quadBuffer, x1, y1, x2, y2, -1, -1, 1, 1);
//passing in the vertices to the vertex shader
posA.setVertex(this.quadBuffer, this.verts);
//passing in the energy information. 6 times because we passed in 6 vertices.
for (let i = 0; i < 6; i++) {
energyA.setVertex([planet.energy, planet.energyCap], this.verts + i);
}
this.verts += 6;
}
setUniforms() {
if (!this.gl) return;
this.uniformSetters.matrix(this.gl.projectionMatrix);
}
}
const program = {
uniforms: {
matrix: { name: 'u_matrix', type: UniformType.Mat4 },
},
attribs: {
position: {
dim: 4,
type: AttribType.Float,
normalize: false,
name: 'a_position', //the name of the attribute variable
},
energyInfo: {
dim: 2,
type: AttribType.Float,
normalize: false,
name: 'a_energy',
},
},
vertexShader: glsl`
in vec4 a_position;
in vec2 a_energy;
uniform mat4 u_matrix;
out vec2 v_rectPos;
out float v_energy;
out float v_energy_cap;
void main() {
// converting from canvas coordinates too clip space
gl_Position = u_matrix * vec4(a_position.xy, 0.0, 1.0);
//setting the varrying variables for use in the fragment shader
v_energy = a_energy.x;
v_energy_cap = a_energy.y;
v_rectPos = a_position.zw;
}
`,
fragmentShader: glsl`
#define PI 3.1415926535
precision highp float;
out vec4 outColor;
in vec2 v_rectPos;
in float v_energy;
in float v_energy_cap;
void main() {
float dist = length(v_rectPos);
// if it's outside the circle
if (dist > 1.0) discard;
//determine the color of the pixel using rgb values
//[red,green,blue,opacity] the range of the numbers is from 0 to 1
outColor = vec4(1,1.0/v_energy_cap*v_energy,0,1);
}
`,
};
```
Once we are done implementing the renderer we can call `ui.setCustomRenderer` to start rendering our own Asteroid Field Renderer.
```javascript
export default class ExamplePlugin {
constructor() {
const gl = ui.getGlManager();
if (!gl) return;
this.mineRenderer = new GenericMineRenderer(gl, ui.getViewport());
ui.setCustomRenderer(this.mineRenderer);
}
async render(div) {}
destroy() {
console.log('destroying renderer plugin');
ui.disableCustomRenderer(this.mineRenderer);
}
}
```
The code above is an example of implementing the renderer with plugins. When the plugin is started it creates a new instance of our custom Asteroid Field Renderer and then uses `setCustomRenderer` to activate it. When the plugin is destroyed we disable the renderer by using `disableCustomRenderer`.
The result of running the plugin can be seen below.
Before:
After:
# Documentation Links
## Renderer Types
All renderer types can be found here: https://github.com/darkforest-eth/packages/tree/master/types#type-declaration-27
To find the interface for each renderer go to the link below. The name of the interface is the entity name followed by `RendererType`: https://github.com/darkforest-eth/packages/tree/master/types#interfaces
## Dark Forest Renderers
Below are examples of Dark Forest renderers
Basic Planets
- Renderer Code: https://github.com/darkforest-eth/packages/blob/master/renderer/src/Entities/PlanetRenderer.ts
- WebGL Code: https://github.com/darkforest-eth/packages/blob/master/renderer/src/Programs/PlanetProgram.ts
Background Renderer:
- Background Renderer is a renderer manager that contains multiple renderer used to draw different sections of the background.
- Renderer Code: https://github.com/darkforest-eth/packages/blob/master/renderer/src/Entities/BackgroundRenderer.ts
- Unmined Renderer:
- Renderer Code: https://github.com/darkforest-eth/packages/blob/master/renderer/src/Entities/UnminedRenderer.ts
- WebGL Code: https://github.com/darkforest-eth/packages/blob/master/renderer/src/Programs/UnminedProgram.ts
- Space Renderer:
- Renderer Code: https://github.com/darkforest-eth/packages/blob/master/renderer/src/Entities/SpaceRenderer.ts
- WebGL Code: https://github.com/darkforest-eth/packages/blob/master/renderer/src/Programs/SpaceProgram.ts
If you want to look at more renderers, you can find all the Dark Forest renderers here:
https://github.com/darkforest-eth/packages/tree/master/renderer/src/Entities
The WebGl Code for those renderers can be found here: https://github.com/darkforest-eth/packages/tree/master/renderer/src/Programs
## Rendering Tools
Generic Renderer is base class that Dark Forest team created for all of its renderers: https://github.com/darkforest-eth/packages/blob/master/renderer/src/WebGL/GenericRenderer.ts
Engine Utils contains function for common WebGl Operations : https://github.com/darkforest-eth/packages/blob/master/renderer/classes/EngineUtils.md
https://github.com/darkforest-eth/packages/blob/master/renderer/src/EngineUtils.ts
The viewport class is used to translate between game and canvas coordinate systems: https://github.com/darkforest-eth/packages/blob/master/types/interfaces/GameViewport.md
Our Wrapper class for the WebGL2RenderingContext
GameGlManager: https://github.com/darkforest-eth/packages/blob/master/renderer/classes/GameGLManager.md
If you want to mess with canvas 2D rendering you can access a `CanvasRenderingContext2D` by calling `ui.get2dRenderer()` WARNING: all images drawn with the `CanvasRenderingContext2D` will all be on top of WebGl
================================================
FILE: public/manifest.json
================================================
{
"name": "Dark Forest",
"short_name": "Dark Forest",
"background_color": "#080808",
"theme_color": "#080808",
"icons": [
{
"src": "/favicons.ico/android-icon-36x36.png",
"sizes": "36x36",
"type": "image/png",
"density": "0.75"
},
{
"src": "/favicons.ico/android-icon-48x48.png",
"sizes": "48x48",
"type": "image/png",
"density": "1.0"
},
{
"src": "/favicons.ico/android-icon-72x72.png",
"sizes": "72x72",
"type": "image/png",
"density": "1.5"
},
{
"src": "/favicons.ico/android-icon-96x96.png",
"sizes": "96x96",
"type": "image/png",
"density": "2.0"
},
{
"src": "/favicons.ico/android-icon-144x144.png",
"sizes": "144x144",
"type": "image/png",
"density": "3.0"
},
{
"src": "/favicons.ico/android-icon-192x192.png",
"sizes": "192x192",
"type": "image/png",
"density": "4.0"
},
{
"src": "/favicons.ico/favicon-96x96.png",
"sizes": "96x96",
"type": "image/png",
"density": "2.0"
}
]
}
================================================
FILE: public/robots.txt
================================================
# https://www.robotstxt.org/robotstxt.html
User-agent: *
================================================
FILE: src/Backend/GameLogic/ArrivalUtils.ts
================================================
import { CONTRACT_PRECISION } from '@darkforest_eth/constants';
import { hasOwner, isActivated, isEmojiFlagMessage } from '@darkforest_eth/gamelogic';
import {
ArrivalType,
Artifact,
ArtifactType,
EmojiFlagBody,
Planet,
PlanetMessage,
PlanetType,
QueuedArrival,
Upgrade,
} from '@darkforest_eth/types';
import _ from 'lodash';
import { ContractConstants } from '../../_types/darkforest/api/ContractsAPITypes';
// TODO: planet class, cmon, let's go
export const blocksLeftToProspectExpiration = (
currentBlockNumber: number,
prospectedBlockNumber?: number
) => {
return (prospectedBlockNumber || 0) + 255 - currentBlockNumber;
};
// TODO: Planet. Class.
export const prospectExpired = (currentBlockNumber: number, prospectedBlockNumber: number) => {
return blocksLeftToProspectExpiration(currentBlockNumber, prospectedBlockNumber) <= 0;
};
export const isFindable = (planet: Planet, currentBlockNumber?: number): boolean => {
return (
currentBlockNumber !== undefined &&
planet.planetType === PlanetType.RUINS &&
planet.prospectedBlockNumber !== undefined &&
!planet.hasTriedFindingArtifact &&
!prospectExpired(currentBlockNumber, planet.prospectedBlockNumber)
);
};
export const isProspectable = (planet: Planet): boolean => {
return planet.planetType === PlanetType.RUINS && planet.prospectedBlockNumber === undefined;
};
const getSilverOverTime = (
planet: Planet,
startTimeMillis: number,
endTimeMillis: number
): number => {
if (!hasOwner(planet)) {
return planet.silver;
}
if (planet.silver > planet.silverCap) {
return planet.silverCap;
}
const timeElapsed = endTimeMillis / 1000 - startTimeMillis / 1000;
return Math.min(timeElapsed * planet.silverGrowth + planet.silver, planet.silverCap);
};
const getEnergyAtTime = (planet: Planet, atTimeMillis: number): number => {
if (planet.energy === 0) {
return 0;
}
if (!hasOwner(planet)) {
return planet.energy;
}
if (planet.planetType === PlanetType.SILVER_BANK) {
if (planet.energy > planet.energyCap) {
return planet.energyCap;
}
}
const timeElapsed = atTimeMillis / 1000 - planet.lastUpdated;
const denominator =
Math.exp((-4 * planet.energyGrowth * timeElapsed) / planet.energyCap) *
(planet.energyCap / planet.energy - 1) +
1;
return planet.energyCap / denominator;
};
export const updatePlanetToTime = (
planet: Planet,
planetArtifacts: Artifact[],
atTimeMillis: number,
contractConstants: ContractConstants,
setPlanet: (p: Planet) => void = () => {}
): void => {
if (atTimeMillis < planet.lastUpdated * 1000) {
return;
}
if (planet.pausers === 0) {
planet.silver = getSilverOverTime(planet, planet.lastUpdated * 1000, atTimeMillis);
planet.energy = getEnergyAtTime(planet, atTimeMillis);
}
planet.lastUpdated = atTimeMillis / 1000;
const photoidActivationTime = contractConstants.PHOTOID_ACTIVATION_DELAY * 1000;
const activePhotoid = planetArtifacts.find(
(a) =>
a.artifactType === ArtifactType.PhotoidCannon &&
isActivated(a) &&
atTimeMillis - a.lastActivated * 1000 >= photoidActivationTime
);
if (activePhotoid && !planet.localPhotoidUpgrade) {
planet.localPhotoidUpgrade = activePhotoid.timeDelayedUpgrade;
applyUpgrade(planet, activePhotoid.timeDelayedUpgrade);
}
setPlanet(planet);
};
export const applyUpgrade = (planet: Planet, upgrade: Upgrade, unApply = false) => {
if (unApply) {
planet.speed /= upgrade.energyCapMultiplier / 100;
planet.energyGrowth /= upgrade.energyGroMultiplier / 100;
planet.range /= upgrade.rangeMultiplier / 100;
planet.speed /= upgrade.speedMultiplier / 100;
planet.defense /= upgrade.defMultiplier / 100;
} else {
planet.speed *= upgrade.energyCapMultiplier / 100;
planet.energyGrowth *= upgrade.energyGroMultiplier / 100;
planet.range *= upgrade.rangeMultiplier / 100;
planet.speed *= upgrade.speedMultiplier / 100;
planet.defense *= upgrade.defMultiplier / 100;
}
};
/**
* @param previous The previously calculated state of a planet
* @param current The current calculated state of the planet
* @param arrival The Arrival that caused the state change
*/
export interface PlanetDiff {
previous: Planet;
current: Planet;
arrival: QueuedArrival;
}
export const arrive = (
toPlanet: Planet,
artifactsOnPlanet: Artifact[],
arrival: QueuedArrival,
arrivingArtifact: Artifact | undefined,
contractConstants: ContractConstants
): PlanetDiff => {
// this function optimistically simulates an arrival
if (toPlanet.locationId !== arrival.toPlanet) {
throw new Error(`attempted to apply arrival for wrong toPlanet ${toPlanet.locationId}`);
}
// update toPlanet energy and silver right before arrival
updatePlanetToTime(toPlanet, artifactsOnPlanet, arrival.arrivalTime * 1000, contractConstants);
const prevPlanet = _.cloneDeep(toPlanet);
if (toPlanet.destroyed) {
return { arrival: arrival, previous: toPlanet, current: toPlanet };
}
// apply energy
const { energyArriving } = arrival;
if (arrival.player !== toPlanet.owner) {
if (arrival.arrivalType === ArrivalType.Wormhole) {
// if this is a wormhole arrival to a planet that isn't owned by the initiator of
// the move, then don't move any energy
}
// attacking enemy - includes emptyAddress
else if (
toPlanet.energy >
Math.floor((energyArriving * CONTRACT_PRECISION * 100) / toPlanet.defense) /
CONTRACT_PRECISION
) {
// attack reduces target planet's garrison but doesn't conquer it
toPlanet.energy -=
Math.floor((energyArriving * CONTRACT_PRECISION * 100) / toPlanet.defense) /
CONTRACT_PRECISION;
} else {
// conquers planet
toPlanet.owner = arrival.player;
toPlanet.energy =
energyArriving -
Math.floor((toPlanet.energy * CONTRACT_PRECISION * toPlanet.defense) / 100) /
CONTRACT_PRECISION;
}
} else {
// moving between my own planets
toPlanet.energy += energyArriving;
}
if (toPlanet.planetType === PlanetType.SILVER_BANK || toPlanet.pausers !== 0) {
if (toPlanet.energy > toPlanet.energyCap) {
toPlanet.energy = toPlanet.energyCap;
}
}
// apply silver
if (toPlanet.silver + arrival.silverMoved > toPlanet.silverCap) {
toPlanet.silver = toPlanet.silverCap;
} else {
toPlanet.silver += arrival.silverMoved;
}
// transfer artifact if necessary
if (arrival.artifactId) {
toPlanet.heldArtifactIds.push(arrival.artifactId);
}
if (arrivingArtifact) {
if (arrivingArtifact.artifactType === ArtifactType.ShipMothership) {
toPlanet.energyGrowth *= 2;
} else if (arrivingArtifact.artifactType === ArtifactType.ShipWhale) {
toPlanet.silverGrowth *= 2;
} else if (arrivingArtifact.artifactType === ArtifactType.ShipTitan) {
toPlanet.pausers++;
}
arrivingArtifact.onPlanetId = toPlanet.locationId;
}
return { arrival, current: toPlanet, previous: prevPlanet };
};
/**
* @todo ArrivalUtils has become a dumping ground for functions that should just live inside of a
* `Planet` class.
*/
export function getEmojiMessage(
planet: Planet | undefined
): PlanetMessage | undefined {
return planet?.messages?.find(isEmojiFlagMessage);
}
================================================
FILE: src/Backend/GameLogic/CaptureZoneGenerator.ts
================================================
import { monomitter, Monomitter } from '@darkforest_eth/events';
import { CaptureZone, Chunk, LocationId } from '@darkforest_eth/types';
import bigInt from 'big-integer';
import { utils } from 'ethers';
import GameManager, { GameManagerEvent } from './GameManager';
export type CaptureZonesGeneratedEvent = {
changeBlock: number;
nextChangeBlock: number;
zones: CaptureZone[];
};
/**
* Given a game start block and a zone change block interval, decide when to generate new Capture Zones.
*/
export class CaptureZoneGenerator {
private gameManager: GameManager;
private zones: Set;
private capturablePlanets: Set;
private lastChangeBlock: number;
private nextChangeBlock: number;
private changeInterval: number;
public readonly generated$: Monomitter;
constructor(gameManager: GameManager, gameStartBlock: number, changeInterval: number) {
this.gameManager = gameManager;
this.changeInterval = changeInterval;
this.nextChangeBlock = gameStartBlock;
this.generated$ = monomitter();
this.capturablePlanets = new Set();
this.zones = new Set();
gameManager.on(GameManagerEvent.DiscoveredNewChunk, this.onNewChunk.bind(this));
}
/**
* Call when a new block is received to check if generation is needed.
* @param blockNumber Current block number.
*/
async generate(blockNumber: number) {
this.setNextGenerationBlock(blockNumber);
const newZones = await this._generate(this.nextChangeBlock - this.changeInterval);
this.zones = newZones;
this.updateCapturablePlanets();
this.generated$.publish({
changeBlock: this.lastChangeBlock,
nextChangeBlock: this.nextChangeBlock,
zones: Array.from(this.zones),
});
}
private setNextGenerationBlock(blockNumber: number) {
const totalGameBlocks = blockNumber - this.gameManager.getContractConstants().GAME_START_BLOCK;
const numPastIntervals = Math.floor(totalGameBlocks / this.changeInterval);
this.nextChangeBlock =
this.gameManager.getContractConstants().GAME_START_BLOCK +
(numPastIntervals + 1) * this.changeInterval;
}
private async _generate(blockNumber: number) {
const block = await this.gameManager.getEthConnection().getProvider().getBlock(blockNumber);
const worldRadius = await this.gameManager.getContractAPI().getWorldRadius();
const captureZones = new Set();
const ringSize = 5000;
const ringCount = Math.floor(worldRadius / ringSize);
const zonesPerRing =
this.gameManager.getContractConstants().CAPTURE_ZONES_PER_5000_WORLD_RADIUS;
for (let ring = 0; ring < ringCount; ring++) {
const nonceBase = ring * zonesPerRing;
for (let j = 0; j < zonesPerRing; j++) {
const nonce = nonceBase + j;
const blockAndNonceHash = utils.solidityKeccak256(
['bytes32', 'uint256'],
[block.hash, nonce]
);
// Chop off 0x and convert to BigInt
const seed = bigInt(blockAndNonceHash.substring(2, blockAndNonceHash.length), 16);
// Last 3 hex characters
const angleSeed = seed.mod(0xfff);
// Max value of 0xfff is 4095
// 4095 / 651 is max radians in circle
// Mult by 1e18 to convert to big number math
const angleRads = angleSeed.multiply(1e18).divide(651);
// Next 6 hex characters
const distanceSeed = seed.minus(angleSeed).divide(4096).mod(0xffffff);
// 16777215 is value of FFFFFF
// Clamp distance within ring radius
const divisor = Math.floor(16777215 / ringSize);
// Add in distance from origin point
const distance = distanceSeed.divide(divisor).add(ring * ringSize);
// Bring it back down to number
const angleNumber = Number(angleRads) / 1e18;
const distanceNumber = Number(distance);
const coords = {
x: Math.floor(distanceNumber * Math.cos(angleNumber)),
y: Math.floor(distanceNumber * Math.sin(angleNumber)),
};
captureZones.add({
coords,
radius: this.gameManager.getContractConstants().CAPTURE_ZONE_RADIUS,
});
}
}
this.lastChangeBlock = blockNumber;
return captureZones;
}
private updateCapturablePlanets() {
this.capturablePlanets = new Set();
for (const zone of this.getZones()) {
const planetsInZone = this.gameObjects.getPlanetsInWorldCircle(zone.coords, zone.radius);
for (const planet of planetsInZone) {
this.capturablePlanets.add(planet.locationId);
}
}
}
private get gameObjects() {
return this.gameManager.getGameObjects();
}
private onNewChunk(chunk: Chunk) {
for (const worldLocation of chunk.planetLocations) {
for (const zone of this.getZones()) {
const { x: planetX, y: planetY } = worldLocation.coords;
const { x: zoneX, y: zoneY } = zone.coords;
const distance = Math.sqrt((planetX - zoneX) ** 2 + (planetY - zoneY) ** 2);
if (distance <= zone.radius) {
this.capturablePlanets.add(worldLocation.hash);
}
}
}
}
/**
* Is the given planet inside of a Capture Zone.
*/
public isInZone(locationId: LocationId) {
return this.capturablePlanets.has(locationId);
}
/**
* The next block that will trigger a Capture Zone generation.
*/
public getNextChangeBlock() {
return this.nextChangeBlock;
}
public getZones() {
return this.zones;
}
}
================================================
FILE: src/Backend/GameLogic/ContractsAPI.ts
================================================
import { EMPTY_LOCATION_ID } from '@darkforest_eth/constants';
import { DarkForest } from '@darkforest_eth/contracts/typechain';
import {
aggregateBulkGetter,
ContractCaller,
EthConnection,
ethToWei,
TxCollection,
TxExecutor,
} from '@darkforest_eth/network';
import {
address,
artifactIdFromEthersBN,
artifactIdToDecStr,
decodeArrival,
decodeArtifact,
decodeArtifactPointValues,
decodePlanet,
decodePlanetDefaults,
decodePlayer,
decodeRevealedCoords,
decodeUpgradeBranches,
locationIdFromEthersBN,
locationIdToDecStr,
} from '@darkforest_eth/serde';
import {
Artifact,
ArtifactId,
ArtifactType,
AutoGasSetting,
DiagnosticUpdater,
EthAddress,
LocationId,
Planet,
Player,
QueuedArrival,
RevealedCoords,
Setting,
Transaction,
TransactionId,
TxIntent,
VoyageId,
} from '@darkforest_eth/types';
import { BigNumber as EthersBN, ContractFunction, Event, providers } from 'ethers';
import { EventEmitter } from 'events';
import _ from 'lodash';
import NotificationManager from '../../Frontend/Game/NotificationManager';
import { openConfirmationWindowForTransaction } from '../../Frontend/Game/Popups';
import { getSetting } from '../../Frontend/Utils/SettingsHooks';
import {
ContractConstants,
ContractEvent,
ContractsAPIEvent,
PlanetTypeWeightsBySpaceType,
} from '../../_types/darkforest/api/ContractsAPITypes';
import { loadDiamondContract } from '../Network/Blockchain';
import { eventLogger, EventType } from '../Network/EventLogger';
interface ContractsApiConfig {
connection: EthConnection;
contractAddress: EthAddress;
}
/**
* Roughly contains methods that map 1:1 with functions that live in the contract. Responsible for
* reading and writing to and from the blockchain.
*
* @todo don't inherit from {@link EventEmitter}. instead use {@link Monomitter}
*/
export class ContractsAPI extends EventEmitter {
/**
* Don't allow users to submit txs if balance falls below this amount/
*/
private static readonly MIN_BALANCE = ethToWei(0.002);
/**
* Instrumented {@link ThrottledConcurrentQueue} for blockchain reads.
*/
private readonly contractCaller: ContractCaller;
/**
* Instrumented {@link ThrottledConcurrentQueue} for blockchain writes.
*/
public readonly txExecutor: TxExecutor;
/**
* Our connection to the blockchain. In charge of low level networking, and also of the burner
* wallet.
*/
public readonly ethConnection: EthConnection;
/**
* The contract address is saved on the object upon construction
*/
private contractAddress: EthAddress;
get contract() {
return this.ethConnection.getContract(this.contractAddress);
}
public constructor({ connection, contractAddress }: ContractsApiConfig) {
super();
this.contractCaller = new ContractCaller();
this.ethConnection = connection;
this.contractAddress = contractAddress;
this.txExecutor = new TxExecutor(
connection,
this.getGasFeeForTransaction.bind(this),
this.beforeQueued.bind(this),
this.beforeTransaction.bind(this),
this.afterTransaction.bind(this)
);
this.setupEventListeners();
}
/**
* We pass this function into {@link TxExecutor} to calculate what gas fee we should use for the
* given transaction. The result is either a number, measured in gwei, represented as a string, or
* a string representing that we want to use an auto gas setting.
*/
private getGasFeeForTransaction(tx: Transaction): AutoGasSetting | string {
if (
(tx.intent.methodName === 'initializePlayer' || tx.intent.methodName === 'getSpaceShips') &&
tx.intent.contract.address === this.contract.address
) {
return '50';
}
const config = {
contractAddress: this.contractAddress,
account: this.ethConnection.getAddress(),
};
return getSetting(config, Setting.GasFeeGwei);
}
/**
* This function is called by {@link TxExecutor} before a transaction is queued.
* It gives the client an opportunity to prevent a transaction from being queued based
* on business logic or user interaction.
*
* Reject the promise to prevent the queued transaction from being queued.
*/
private async beforeQueued(
id: TransactionId,
intent: TxIntent,
overrides?: providers.TransactionRequest
): Promise {
const address = this.ethConnection.getAddress();
if (!address) throw new Error("can't send a transaction, no signer");
const balance = await this.ethConnection.loadBalance(address);
if (balance.lt(ContractsAPI.MIN_BALANCE)) {
const notifsManager = NotificationManager.getInstance();
notifsManager.balanceEmpty();
throw new Error('xDAI balance too low!');
}
const gasFeeGwei = EthersBN.from(overrides?.gasPrice || '1000000000');
await openConfirmationWindowForTransaction({
contractAddress: this.contractAddress,
connection: this.ethConnection,
id,
intent,
overrides,
from: address,
gasFeeGwei,
});
}
/**
* This function is called by {@link TxExecutor} before each transaction. It gives the client an
* opportunity to prevent a transaction from going through based on business logic or user
* interaction. To prevent the queued transaction from being submitted, throw an Error.
*/
private async beforeTransaction(tx: Transaction): Promise {
this.emit(ContractsAPIEvent.TxProcessing, tx);
}
private async afterTransaction(_txRequest: Transaction, txDiagnosticInfo: unknown) {
eventLogger.logEvent(EventType.Transaction, txDiagnosticInfo);
}
public destroy(): void {
this.removeEventListeners();
}
private makeCall(contractViewFunction: ContractFunction, args: unknown[] = []): Promise {
return this.contractCaller.makeCall(contractViewFunction, args);
}
public async setupEventListeners(): Promise {
const { contract } = this;
const filter = {
address: contract.address,
topics: [
[
contract.filters.ArrivalQueued(null, null, null, null, null).topics,
contract.filters.ArtifactActivated(null, null, null).topics,
contract.filters.ArtifactDeactivated(null, null, null).topics,
contract.filters.ArtifactDeposited(null, null, null).topics,
contract.filters.ArtifactFound(null, null, null).topics,
contract.filters.ArtifactWithdrawn(null, null, null).topics,
contract.filters.LocationRevealed(null, null, null, null).topics,
contract.filters.PlanetHatBought(null, null, null).topics,
contract.filters.PlanetProspected(null, null).topics,
contract.filters.PlanetSilverWithdrawn(null, null, null).topics,
contract.filters.PlanetTransferred(null, null, null).topics,
contract.filters.PlanetInvaded(null, null).topics,
contract.filters.PlanetCaptured(null, null).topics,
contract.filters.PlayerInitialized(null, null).topics,
contract.filters.AdminOwnershipChanged(null, null).topics,
contract.filters.AdminGiveSpaceship(null, null).topics,
contract.filters.PauseStateChanged(null).topics,
contract.filters.LobbyCreated(null, null).topics,
].map((topicsOrUndefined) => (topicsOrUndefined || [])[0]),
] as Array>,
};
const eventHandlers = {
[ContractEvent.PauseStateChanged]: (paused: boolean) => {
this.emit(ContractsAPIEvent.PauseStateChanged, paused);
},
[ContractEvent.AdminOwnershipChanged]: (location: EthersBN, _newOwner: string) => {
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(location));
},
[ContractEvent.AdminGiveSpaceship]: (
location: EthersBN,
_newOwner: string,
_type: ArtifactType
) => {
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(location));
},
[ContractEvent.ArtifactFound]: (
_playerAddr: string,
rawArtifactId: EthersBN,
loc: EthersBN
) => {
const artifactId = artifactIdFromEthersBN(rawArtifactId);
this.emit(ContractsAPIEvent.ArtifactUpdate, artifactId);
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(loc));
},
[ContractEvent.ArtifactDeposited]: (
_playerAddr: string,
rawArtifactId: EthersBN,
loc: EthersBN
) => {
const artifactId = artifactIdFromEthersBN(rawArtifactId);
this.emit(ContractsAPIEvent.ArtifactUpdate, artifactId);
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(loc));
},
[ContractEvent.ArtifactWithdrawn]: (
_playerAddr: string,
rawArtifactId: EthersBN,
loc: EthersBN
) => {
const artifactId = artifactIdFromEthersBN(rawArtifactId);
this.emit(ContractsAPIEvent.ArtifactUpdate, artifactId);
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(loc));
},
[ContractEvent.ArtifactActivated]: (
_playerAddr: string,
rawArtifactId: EthersBN,
loc: EthersBN
) => {
const artifactId = artifactIdFromEthersBN(rawArtifactId);
this.emit(ContractsAPIEvent.ArtifactUpdate, artifactId);
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(loc));
},
[ContractEvent.ArtifactDeactivated]: (
_playerAddr: string,
rawArtifactId: EthersBN,
loc: EthersBN
) => {
const artifactId = artifactIdFromEthersBN(rawArtifactId);
this.emit(ContractsAPIEvent.ArtifactUpdate, artifactId);
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(loc));
},
[ContractEvent.PlayerInitialized]: async (player: string, locRaw: EthersBN, _: Event) => {
this.emit(ContractsAPIEvent.PlayerUpdate, address(player));
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(locRaw));
this.emit(ContractsAPIEvent.RadiusUpdated);
},
[ContractEvent.PlanetTransferred]: async (
_senderAddress: string,
planetId: EthersBN,
receiverAddress: string,
_: Event
) => {
this.emit(
ContractsAPIEvent.PlanetTransferred,
locationIdFromEthersBN(planetId),
address(receiverAddress)
);
},
[ContractEvent.ArrivalQueued]: async (
playerAddr: string,
arrivalId: EthersBN,
fromLocRaw: EthersBN,
toLocRaw: EthersBN,
_artifactIdRaw: EthersBN,
_: Event
) => {
this.emit(
ContractsAPIEvent.ArrivalQueued,
arrivalId.toString() as VoyageId,
locationIdFromEthersBN(fromLocRaw),
locationIdFromEthersBN(toLocRaw)
);
this.emit(ContractsAPIEvent.PlayerUpdate, address(playerAddr));
this.emit(ContractsAPIEvent.RadiusUpdated);
},
[ContractEvent.PlanetUpgraded]: async (
_playerAddr: string,
location: EthersBN,
_branch: EthersBN,
_toBranchLevel: EthersBN,
_: Event
) => {
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(location));
},
[ContractEvent.PlanetInvaded]: async (_playerAddr: string, location: EthersBN, _: Event) => {
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(location));
},
[ContractEvent.PlanetCaptured]: async (_playerAddr: string, location: EthersBN, _: Event) => {
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(location));
},
[ContractEvent.PlanetHatBought]: async (
_playerAddress: string,
location: EthersBN,
_: Event
) => this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(location)),
[ContractEvent.LocationRevealed]: async (
revealerAddr: string,
location: EthersBN,
_x: EthersBN,
_y: EthersBN,
_: Event
) => {
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(location));
this.emit(
ContractsAPIEvent.LocationRevealed,
locationIdFromEthersBN(location),
address(revealerAddr.toLowerCase())
);
this.emit(ContractsAPIEvent.PlayerUpdate, address(revealerAddr));
},
[ContractEvent.PlanetSilverWithdrawn]: async (
player: string,
location: EthersBN,
_amount: EthersBN,
_: Event
) => {
this.emit(ContractsAPIEvent.PlanetUpdate, locationIdFromEthersBN(location));
this.emit(ContractsAPIEvent.PlayerUpdate, address(player));
},
[ContractEvent.LobbyCreated]: (ownerAddr: string, lobbyAddr: string) => {
this.emit(ContractsAPIEvent.LobbyCreated, address(ownerAddr), address(lobbyAddr));
},
};
this.ethConnection.subscribeToContractEvents(contract, eventHandlers, filter);
}
public removeEventListeners(): void {
const { contract } = this;
contract.removeAllListeners(ContractEvent.PlayerInitialized);
contract.removeAllListeners(ContractEvent.ArrivalQueued);
contract.removeAllListeners(ContractEvent.PlanetUpgraded);
contract.removeAllListeners(ContractEvent.PlanetHatBought);
contract.removeAllListeners(ContractEvent.PlanetTransferred);
contract.removeAllListeners(ContractEvent.ArtifactFound);
contract.removeAllListeners(ContractEvent.ArtifactDeposited);
contract.removeAllListeners(ContractEvent.ArtifactWithdrawn);
contract.removeAllListeners(ContractEvent.ArtifactActivated);
contract.removeAllListeners(ContractEvent.ArtifactDeactivated);
contract.removeAllListeners(ContractEvent.LocationRevealed);
contract.removeAllListeners(ContractEvent.PlanetSilverWithdrawn);
contract.removeAllListeners(ContractEvent.PlanetInvaded);
contract.removeAllListeners(ContractEvent.PlanetCaptured);
}
public getContractAddress(): EthAddress {
return this.contractAddress;
}
async getConstants(): Promise {
const {
DISABLE_ZK_CHECKS,
PLANETHASH_KEY,
SPACETYPE_KEY,
BIOMEBASE_KEY,
PERLIN_LENGTH_SCALE,
PERLIN_MIRROR_X,
PERLIN_MIRROR_Y,
} = await this.makeCall(this.contract.getSnarkConstants);
const {
ADMIN_CAN_ADD_PLANETS,
WORLD_RADIUS_LOCKED,
WORLD_RADIUS_MIN,
MAX_NATURAL_PLANET_LEVEL,
TIME_FACTOR_HUNDREDTHS,
PERLIN_THRESHOLD_1,
PERLIN_THRESHOLD_2,
PERLIN_THRESHOLD_3,
INIT_PERLIN_MIN,
INIT_PERLIN_MAX,
SPAWN_RIM_AREA,
BIOME_THRESHOLD_1,
BIOME_THRESHOLD_2,
SILVER_SCORE_VALUE,
// TODO: Actually put this in game constants
// PLANET_LEVEL_THRESHOLDS,
PLANET_RARITY,
PLANET_TRANSFER_ENABLED,
PHOTOID_ACTIVATION_DELAY,
LOCATION_REVEAL_COOLDOWN,
SPACE_JUNK_ENABLED,
SPACE_JUNK_LIMIT,
PLANET_LEVEL_JUNK,
ABANDON_SPEED_CHANGE_PERCENT,
ABANDON_RANGE_CHANGE_PERCENT,
// Capture Zones
GAME_START_BLOCK,
CAPTURE_ZONES_ENABLED,
CAPTURE_ZONE_COUNT,
CAPTURE_ZONE_CHANGE_BLOCK_INTERVAL,
CAPTURE_ZONE_RADIUS,
CAPTURE_ZONE_PLANET_LEVEL_SCORE,
CAPTURE_ZONE_HOLD_BLOCKS_REQUIRED,
CAPTURE_ZONES_PER_5000_WORLD_RADIUS,
} = await this.makeCall(this.contract.getGameConstants);
const TOKEN_MINT_END_SECONDS = (
await this.makeCall(this.contract.TOKEN_MINT_END_TIMESTAMP)
).toNumber();
const adminAddress = address(await this.makeCall(this.contract.adminAddress));
const upgrades = decodeUpgradeBranches(await this.makeCall(this.contract.getUpgrades));
const PLANET_TYPE_WEIGHTS: PlanetTypeWeightsBySpaceType =
await this.makeCall(this.contract.getTypeWeights);
const rawPointValues = await this.makeCall(this.contract.getArtifactPointValues);
const ARTIFACT_POINT_VALUES = decodeArtifactPointValues(rawPointValues);
const planetDefaults = decodePlanetDefaults(await this.makeCall(this.contract.getDefaultStats));
const planetLevelThresholds = (
await this.makeCall(this.contract.getPlanetLevelThresholds)
).map((x: EthersBN) => x.toNumber());
const planetCumulativeRarities = (
await this.makeCall(this.contract.getCumulativeRarities)
).map((x: EthersBN) => x.toNumber());
const constants: ContractConstants = {
ADMIN_CAN_ADD_PLANETS,
WORLD_RADIUS_LOCKED,
WORLD_RADIUS_MIN: WORLD_RADIUS_MIN.toNumber(),
DISABLE_ZK_CHECKS,
PLANETHASH_KEY: PLANETHASH_KEY.toNumber(),
SPACETYPE_KEY: SPACETYPE_KEY.toNumber(),
BIOMEBASE_KEY: BIOMEBASE_KEY.toNumber(),
PERLIN_LENGTH_SCALE: PERLIN_LENGTH_SCALE.toNumber(),
PERLIN_MIRROR_X,
PERLIN_MIRROR_Y,
CLAIM_PLANET_COOLDOWN: 0,
TOKEN_MINT_END_SECONDS,
MAX_NATURAL_PLANET_LEVEL: MAX_NATURAL_PLANET_LEVEL.toNumber(),
TIME_FACTOR_HUNDREDTHS: TIME_FACTOR_HUNDREDTHS.toNumber(),
PERLIN_THRESHOLD_1: PERLIN_THRESHOLD_1.toNumber(),
PERLIN_THRESHOLD_2: PERLIN_THRESHOLD_2.toNumber(),
PERLIN_THRESHOLD_3: PERLIN_THRESHOLD_3.toNumber(),
INIT_PERLIN_MIN: INIT_PERLIN_MIN.toNumber(),
INIT_PERLIN_MAX: INIT_PERLIN_MAX.toNumber(),
BIOME_THRESHOLD_1: BIOME_THRESHOLD_1.toNumber(),
BIOME_THRESHOLD_2: BIOME_THRESHOLD_2.toNumber(),
SILVER_SCORE_VALUE: SILVER_SCORE_VALUE.toNumber(),
PLANET_LEVEL_THRESHOLDS: [
planetLevelThresholds[0],
planetLevelThresholds[1],
planetLevelThresholds[2],
planetLevelThresholds[3],
planetLevelThresholds[4],
planetLevelThresholds[5],
planetLevelThresholds[6],
planetLevelThresholds[7],
planetLevelThresholds[8],
planetLevelThresholds[9],
],
PLANET_RARITY: PLANET_RARITY.toNumber(),
PLANET_TRANSFER_ENABLED,
PLANET_TYPE_WEIGHTS,
ARTIFACT_POINT_VALUES,
SPACE_JUNK_ENABLED,
SPACE_JUNK_LIMIT: SPACE_JUNK_LIMIT.toNumber(),
PLANET_LEVEL_JUNK: [
PLANET_LEVEL_JUNK[0].toNumber(),
PLANET_LEVEL_JUNK[1].toNumber(),
PLANET_LEVEL_JUNK[2].toNumber(),
PLANET_LEVEL_JUNK[3].toNumber(),
PLANET_LEVEL_JUNK[4].toNumber(),
PLANET_LEVEL_JUNK[5].toNumber(),
PLANET_LEVEL_JUNK[6].toNumber(),
PLANET_LEVEL_JUNK[7].toNumber(),
PLANET_LEVEL_JUNK[8].toNumber(),
PLANET_LEVEL_JUNK[9].toNumber(),
],
ABANDON_SPEED_CHANGE_PERCENT: ABANDON_RANGE_CHANGE_PERCENT.toNumber(),
ABANDON_RANGE_CHANGE_PERCENT: ABANDON_SPEED_CHANGE_PERCENT.toNumber(),
PHOTOID_ACTIVATION_DELAY: PHOTOID_ACTIVATION_DELAY.toNumber(),
SPAWN_RIM_AREA: SPAWN_RIM_AREA.toNumber(),
LOCATION_REVEAL_COOLDOWN: LOCATION_REVEAL_COOLDOWN.toNumber(),
defaultPopulationCap: planetDefaults.populationCap,
defaultPopulationGrowth: planetDefaults.populationGrowth,
defaultRange: planetDefaults.range,
defaultSpeed: planetDefaults.speed,
defaultDefense: planetDefaults.defense,
defaultSilverGrowth: planetDefaults.silverGrowth,
defaultSilverCap: planetDefaults.silverCap,
defaultBarbarianPercentage: planetDefaults.barbarianPercentage,
planetLevelThresholds,
planetCumulativeRarities,
upgrades,
adminAddress,
// Capture Zones
GAME_START_BLOCK: GAME_START_BLOCK.toNumber(),
CAPTURE_ZONES_ENABLED,
CAPTURE_ZONE_COUNT: CAPTURE_ZONE_COUNT.toNumber(),
CAPTURE_ZONE_CHANGE_BLOCK_INTERVAL: CAPTURE_ZONE_CHANGE_BLOCK_INTERVAL.toNumber(),
CAPTURE_ZONE_RADIUS: CAPTURE_ZONE_RADIUS.toNumber(),
CAPTURE_ZONE_PLANET_LEVEL_SCORE: [
CAPTURE_ZONE_PLANET_LEVEL_SCORE[0].toNumber(),
CAPTURE_ZONE_PLANET_LEVEL_SCORE[1].toNumber(),
CAPTURE_ZONE_PLANET_LEVEL_SCORE[2].toNumber(),
CAPTURE_ZONE_PLANET_LEVEL_SCORE[3].toNumber(),
CAPTURE_ZONE_PLANET_LEVEL_SCORE[4].toNumber(),
CAPTURE_ZONE_PLANET_LEVEL_SCORE[5].toNumber(),
CAPTURE_ZONE_PLANET_LEVEL_SCORE[6].toNumber(),
CAPTURE_ZONE_PLANET_LEVEL_SCORE[7].toNumber(),
CAPTURE_ZONE_PLANET_LEVEL_SCORE[8].toNumber(),
CAPTURE_ZONE_PLANET_LEVEL_SCORE[9].toNumber(),
],
CAPTURE_ZONE_HOLD_BLOCKS_REQUIRED: CAPTURE_ZONE_HOLD_BLOCKS_REQUIRED.toNumber(),
CAPTURE_ZONES_PER_5000_WORLD_RADIUS: CAPTURE_ZONES_PER_5000_WORLD_RADIUS.toNumber(),
};
return constants;
}
public async getPlayers(
onProgress?: (fractionCompleted: number) => void
): Promise> {
const nPlayers: number = (await this.makeCall(this.contract.getNPlayers)).toNumber();
const players = await aggregateBulkGetter(
nPlayers,
200,
async (start, end) =>
(await this.makeCall(this.contract.bulkGetPlayers, [start, end])).map(decodePlayer),
onProgress
);
const playerMap: Map = new Map();
for (const player of players) {
playerMap.set(player.address, player);
}
return playerMap;
}
public async getPlayerById(playerId: EthAddress): Promise {
const rawPlayer = await this.makeCall(this.contract.players, [playerId]);
if (!rawPlayer.isInitialized) return undefined;
const player = decodePlayer(rawPlayer);
return player;
}
public async getWorldRadius(): Promise {
const radius = (await this.makeCall(this.contract.worldRadius)).toNumber();
return radius;
}
// timestamp since epoch (in seconds)
public async getTokenMintEndTimestamp(): Promise {
const timestamp = (
await this.makeCall(this.contract.TOKEN_MINT_END_TIMESTAMP)
).toNumber();
return timestamp;
}
public async getArrival(arrivalId: number): Promise {
const rawArrival = await this.makeCall(this.contract.planetArrivals, [arrivalId]);
return decodeArrival(rawArrival);
}
public async getArrivalsForPlanet(planetId: LocationId): Promise {
const events = (
await this.makeCall(this.contract.getPlanetArrivals, [locationIdToDecStr(planetId)])
).map(decodeArrival);
return events;
}
public async getAllArrivals(
planetsToLoad: LocationId[],
onProgress?: (fractionCompleted: number) => void
): Promise {
const arrivalsUnflattened = await aggregateBulkGetter(
planetsToLoad.length,
200,
async (start, end) => {
return (
await this.makeCall(this.contract.bulkGetPlanetArrivalsByIds, [
planetsToLoad.slice(start, end).map(locationIdToDecStr),
])
).map((arrivals) => arrivals.map(decodeArrival));
},
onProgress
);
return _.flatten(arrivalsUnflattened);
}
public async getTouchedPlanetIds(
startingAt: number,
onProgress?: (fractionCompleted: number) => void
): Promise {
const nPlanets: number = (await this.makeCall(this.contract.getNPlanets)).toNumber();
const planetIds = await aggregateBulkGetter(
nPlanets - startingAt,
1000,
async (start, end) =>
await this.makeCall(this.contract.bulkGetPlanetIds, [start + startingAt, end + startingAt]),
onProgress
);
return planetIds.map(locationIdFromEthersBN);
}
public async getRevealedCoordsByIdIfExists(
planetId: LocationId
): Promise {
const decStrId = locationIdToDecStr(planetId);
const rawRevealedCoords = await this.makeCall(this.contract.revealedCoords, [decStrId]);
const ret = decodeRevealedCoords(rawRevealedCoords);
if (ret.hash === EMPTY_LOCATION_ID) {
return undefined;
}
return ret;
}
public async getIsPaused(): Promise {
return this.makeCall(this.contract.paused);
}
public async getRevealedPlanetsCoords(
startingAt: number,
onProgressIds?: (fractionCompleted: number) => void,
onProgressCoords?: (fractionCompleted: number) => void
): Promise {
const nRevealedPlanets: number = (
await this.makeCall(this.contract.getNRevealedPlanets)
).toNumber();
const rawRevealedPlanetIds = await aggregateBulkGetter(
nRevealedPlanets - startingAt,
500,
async (start, end) =>
await this.makeCall(this.contract.bulkGetRevealedPlanetIds, [
start + startingAt,
end + startingAt,
]),
onProgressIds
);
const rawRevealedCoords = await aggregateBulkGetter(
rawRevealedPlanetIds.length,
500,
async (start, end) =>
await this.makeCall(this.contract.bulkGetRevealedCoordsByIds, [
rawRevealedPlanetIds.slice(start, end),
]),
onProgressCoords
);
return rawRevealedCoords.map(decodeRevealedCoords);
}
public async bulkGetPlanets(
toLoadPlanets: LocationId[],
onProgressPlanet?: (fractionCompleted: number) => void,
onProgressMetadata?: (fractionCompleted: number) => void
): Promise> {
const rawPlanets = await aggregateBulkGetter(
toLoadPlanets.length,
200,
async (start, end) =>
await this.makeCall(this.contract.bulkGetPlanetsByIds, [
toLoadPlanets.slice(start, end).map(locationIdToDecStr),
]),
onProgressPlanet
);
const rawPlanetsExtendedInfo = await aggregateBulkGetter(
toLoadPlanets.length,
200,
async (start, end) =>
await this.makeCall(this.contract.bulkGetPlanetsExtendedInfoByIds, [
toLoadPlanets.slice(start, end).map(locationIdToDecStr),
]),
(fractionCompleted) => {
if (!onProgressMetadata) return;
onProgressMetadata(fractionCompleted / 2);
}
);
const rawPlanetsExtendedInfo2 = await aggregateBulkGetter(
toLoadPlanets.length,
200,
async (start, end) =>
await this.makeCall(this.contract.bulkGetPlanetsExtendedInfo2ByIds, [
toLoadPlanets.slice(start, end).map(locationIdToDecStr),
]),
(fractionCompleted) => {
if (!onProgressMetadata) return;
onProgressMetadata(0.5 + fractionCompleted / 2);
}
);
const planets: Map = new Map();
for (let i = 0; i < toLoadPlanets.length; i += 1) {
if (!!rawPlanets[i] && !!rawPlanetsExtendedInfo[i]) {
const planet = decodePlanet(
locationIdToDecStr(toLoadPlanets[i]),
rawPlanets[i],
rawPlanetsExtendedInfo[i],
rawPlanetsExtendedInfo2[i]
);
planet.transactions = new TxCollection();
planets.set(planet.locationId, planet);
}
}
return planets;
}
public async getPlanetById(planetId: LocationId): Promise {
const decStrId = locationIdToDecStr(planetId);
const rawExtendedInfo = await this.makeCall(this.contract.planetsExtendedInfo, [decStrId]);
const rawExtendedInfo2 = await this.makeCall(this.contract.planetsExtendedInfo2, [decStrId]);
if (!rawExtendedInfo[0]) return undefined; // planetExtendedInfo.isInitialized is false
if (!rawExtendedInfo2[0]) return undefined; // planetExtendedInfo.isInitialized is false
const rawPlanet = await this.makeCall(this.contract.planets, [decStrId]);
return decodePlanet(decStrId, rawPlanet, rawExtendedInfo, rawExtendedInfo2);
}
public async getArtifactById(artifactId: ArtifactId): Promise {
const exists = await this.makeCall(this.contract.doesArtifactExist, [
artifactIdToDecStr(artifactId),
]);
if (!exists) return undefined;
const rawArtifact = await this.makeCall(this.contract.getArtifactById, [
artifactIdToDecStr(artifactId),
]);
const artifact = decodeArtifact(rawArtifact);
artifact.transactions = new TxCollection();
return artifact;
}
public async bulkGetArtifactsOnPlanets(
locationIds: LocationId[],
onProgress?: (fractionCompleted: number) => void
): Promise {
const rawArtifacts = await aggregateBulkGetter(
locationIds.length,
200,
async (start, end) =>
await this.makeCall(this.contract.bulkGetPlanetArtifacts, [
locationIds.slice(start, end).map(locationIdToDecStr),
]),
onProgress
);
return rawArtifacts.map((rawArtifactArray) => {
return rawArtifactArray.map(decodeArtifact);
});
}
public async bulkGetArtifacts(
artifactIds: ArtifactId[],
onProgress?: (fractionCompleted: number) => void
): Promise {
const rawArtifacts = await aggregateBulkGetter(
artifactIds.length,
200,
async (start, end) =>
await this.makeCall(this.contract.bulkGetArtifactsByIds, [
artifactIds.slice(start, end).map(artifactIdToDecStr),
]),
onProgress
);
const ret: Artifact[] = rawArtifacts.map(decodeArtifact);
ret.forEach((a) => (a.transactions = new TxCollection()));
return ret;
}
public async getPlayerArtifacts(
playerId?: EthAddress,
onProgress?: (percent: number) => void
): Promise {
if (playerId === undefined) return [];
const myArtifactIds = (await this.makeCall(this.contract.getPlayerArtifactIds, [playerId])).map(
artifactIdFromEthersBN
);
return this.bulkGetArtifacts(myArtifactIds, onProgress);
}
public setDiagnosticUpdater(diagnosticUpdater?: DiagnosticUpdater) {
this.contractCaller.setDiagnosticUpdater(diagnosticUpdater);
this.txExecutor?.setDiagnosticUpdater(diagnosticUpdater);
this.ethConnection.setDiagnosticUpdater(diagnosticUpdater);
}
public async submitTransaction(
txIntent: T,
overrides?: providers.TransactionRequest
): Promise> {
const queuedTx = await this.txExecutor.queueTransaction(txIntent, overrides);
this.emit(ContractsAPIEvent.TxQueued, queuedTx);
// TODO: Why is this setTimeout here? Can it be removed?
setTimeout(() => this.emitTransactionEvents(queuedTx), 0);
return queuedTx;
}
/**
* Remove a transaction from the queue.
*/
public cancelTransaction(tx: Transaction): void {
this.txExecutor.dequeueTransction(tx);
this.emit(ContractsAPIEvent.TxCancelled, tx);
}
/**
* Make sure this transaction is the next to be executed.
*/
public prioritizeTransaction(tx: Transaction): void {
this.txExecutor.prioritizeTransaction(tx);
this.emit(ContractsAPIEvent.TxPrioritized, tx);
}
/**
* This is a strange interface between the transaction queue system and the rest of the game. The
* strange thing about it is that introduces another way by which transactions are pushed into the
* game - these {@code ContractsAPIEvent} events.
*/
public emitTransactionEvents(tx: Transaction): void {
tx.submittedPromise
.then(() => {
this.emit(ContractsAPIEvent.TxSubmitted, tx);
})
.catch(() => {
this.emit(ContractsAPIEvent.TxErrored, tx);
});
tx.confirmedPromise
.then(() => {
this.emit(ContractsAPIEvent.TxConfirmed, tx);
})
.catch(() => {
this.emit(ContractsAPIEvent.TxErrored, tx);
});
}
public getAddress() {
return this.ethConnection.getAddress();
}
}
export async function makeContractsAPI({
connection,
contractAddress,
}: ContractsApiConfig): Promise {
await connection.loadContract(contractAddress, loadDiamondContract);
return new ContractsAPI({ connection, contractAddress });
}
================================================
FILE: src/Backend/GameLogic/GameManager.ts
================================================
import {
BLOCK_EXPLORER_URL,
CONTRACT_PRECISION,
EMPTY_ADDRESS,
MIN_PLANET_LEVEL,
} from '@darkforest_eth/constants';
import type { DarkForest } from '@darkforest_eth/contracts/typechain';
import { monomitter, Monomitter, Subscription } from '@darkforest_eth/events';
import {
getRange,
isActivated,
isLocatable,
isSpaceShip,
timeUntilNextBroadcastAvailable,
} from '@darkforest_eth/gamelogic';
import { fakeHash, mimcHash, perlin } from '@darkforest_eth/hashing';
import {
createContract,
EthConnection,
ThrottledConcurrentQueue,
verifySignature,
weiToEth,
} from '@darkforest_eth/network';
import { getPlanetName } from '@darkforest_eth/procedural';
import {
artifactIdToDecStr,
isUnconfirmedActivateArtifactTx,
isUnconfirmedBuyHatTx,
isUnconfirmedCapturePlanetTx,
isUnconfirmedDeactivateArtifactTx,
isUnconfirmedDepositArtifactTx,
isUnconfirmedFindArtifactTx,
isUnconfirmedInitTx,
isUnconfirmedInvadePlanetTx,
isUnconfirmedMoveTx,
isUnconfirmedProspectPlanetTx,
isUnconfirmedRevealTx,
isUnconfirmedUpgradeTx,
isUnconfirmedWithdrawArtifactTx,
isUnconfirmedWithdrawSilverTx,
locationIdFromBigInt,
locationIdToDecStr,
} from '@darkforest_eth/serde';
import {
Artifact,
ArtifactId,
ArtifactRarity,
ArtifactType,
CaptureZone,
Chunk,
ClaimedCoords,
ClaimedLocation,
Diagnostics,
EthAddress,
LocatablePlanet,
LocationId,
NetworkHealthSummary,
Planet,
PlanetLevel,
PlanetMessageType,
PlanetType,
Player,
QueuedArrival,
Radii,
Rectangle,
RevealedCoords,
RevealedLocation,
Setting,
SignedMessage,
SpaceType,
Transaction,
TxIntent,
UnconfirmedActivateArtifact,
UnconfirmedBuyHat,
UnconfirmedCapturePlanet,
UnconfirmedDeactivateArtifact,
UnconfirmedDepositArtifact,
UnconfirmedFindArtifact,
UnconfirmedInit,
UnconfirmedInvadePlanet,
UnconfirmedMove,
UnconfirmedPlanetTransfer,
UnconfirmedProspectPlanet,
UnconfirmedReveal,
UnconfirmedUpgrade,
UnconfirmedWithdrawArtifact,
UnconfirmedWithdrawSilver,
Upgrade,
VoyageId,
WorldCoords,
WorldLocation,
Wormhole,
} from '@darkforest_eth/types';
import bigInt, { BigInteger } from 'big-integer';
import delay from 'delay';
import { BigNumber, Contract, ContractInterface, providers } from 'ethers';
import { EventEmitter } from 'events';
import NotificationManager from '../../Frontend/Game/NotificationManager';
import { MIN_CHUNK_SIZE } from '../../Frontend/Utils/constants';
import { Diff, generateDiffEmitter, getDisposableEmitter } from '../../Frontend/Utils/EmitterUtils';
import {
getBooleanSetting,
getNumberSetting,
pollSetting,
setBooleanSetting,
setSetting,
settingChanged$,
} from '../../Frontend/Utils/SettingsHooks';
import { TerminalTextStyle } from '../../Frontend/Utils/TerminalTypes';
import UIEmitter from '../../Frontend/Utils/UIEmitter';
import { TerminalHandle } from '../../Frontend/Views/Terminal';
import {
ContractConstants,
ContractsAPIEvent,
MoveArgIdxs,
MoveArgs,
ZKArgIdx,
} from '../../_types/darkforest/api/ContractsAPITypes';
import { AddressTwitterMap } from '../../_types/darkforest/api/UtilityServerAPITypes';
import { HashConfig, RevealCountdownInfo } from '../../_types/global/GlobalTypes';
import MinerManager, { HomePlanetMinerChunkStore, MinerManagerEvent } from '../Miner/MinerManager';
import {
MiningPattern,
SpiralPattern,
SwissCheesePattern,
TowardsCenterPattern,
TowardsCenterPatternV2,
} from '../Miner/MiningPatterns';
import { eventLogger, EventType } from '../Network/EventLogger';
import { loadLeaderboard } from '../Network/LeaderboardApi';
import { addMessage, deleteMessages, getMessagesOnPlanets } from '../Network/MessageAPI';
import { loadNetworkHealth } from '../Network/NetworkHealthApi';
import {
disconnectTwitter,
getAllTwitters,
verifyTwitterHandle,
} from '../Network/UtilityServerAPI';
import { SerializedPlugin } from '../Plugins/SerializedPlugin';
import PersistentChunkStore from '../Storage/PersistentChunkStore';
import { easeInAnimation, emojiEaseOutAnimation } from '../Utils/Animation';
import SnarkArgsHelper from '../Utils/SnarkArgsHelper';
import { hexifyBigIntNestedArray } from '../Utils/Utils';
import { getEmojiMessage } from './ArrivalUtils';
import { CaptureZoneGenerator, CaptureZonesGeneratedEvent } from './CaptureZoneGenerator';
import { ContractsAPI, makeContractsAPI } from './ContractsAPI';
import { GameObjects } from './GameObjects';
import { InitialGameStateDownloader } from './InitialGameStateDownloader';
export enum GameManagerEvent {
PlanetUpdate = 'PlanetUpdate',
DiscoveredNewChunk = 'DiscoveredNewChunk',
InitializedPlayer = 'InitializedPlayer',
InitializedPlayerError = 'InitializedPlayerError',
ArtifactUpdate = 'ArtifactUpdate',
Moved = 'Moved',
}
class GameManager extends EventEmitter {
/**
* This variable contains the internal state of objects that live in the game world.
*/
private readonly entityStore: GameObjects;
/**
* Kind of hacky, but we store a reference to the terminal that the player sees when the initially
* load into the game. This is the same exact terminal that appears inside the collapsable right
* bar of the game.
*/
private readonly terminal: React.MutableRefObject;
/**
* The ethereum address of the player who is currently logged in. We support 'no account',
* represented by `undefined` in the case when you want to simply load the game state from the
* contract and view it without be able to make any moves.
*/
private readonly account: EthAddress | undefined;
/**
* Map from ethereum addresses to player objects. This isn't stored in {@link GameObjects},
* because it's not techincally an entity that exists in the world. A player just controls planets
* and artifacts that do exist in the world.
*
* @todo move this into a new `Players` class.
*/
private readonly players: Map;
/**
* Allows us to make contract calls, and execute transactions. Be careful about how you use this
* guy. You don't want to cause your client to send an excessive amount of traffic to whatever
* node you're connected to.
*
* Interacting with the blockchain isn't free, and we need to be mindful about about the way our
* application interacts with the blockchain. The current rate limiting strategy consists of three
* points:
*
* - data that needs to be fetched often should be fetched in bulk.
* - rate limit smart contract calls (reads from the blockchain), implemented by
* {@link ContractCaller} and transactions (writes to the blockchain on behalf of the player),
* implemented by {@link TxExecutor} via two separately tuned {@link ThrottledConcurrentQueue}s.
*/
private readonly contractsAPI: ContractsAPI;
/**
* An object that syncs any newly added or deleted chunks to the player's IndexedDB.
*
* @todo it also persists other game data to IndexedDB. This class needs to be renamed `GameSaver`
* or something like that.
*/
private readonly persistentChunkStore: PersistentChunkStore;
/**
* Responsible for generating snark proofs.
*/
private readonly snarkHelper: SnarkArgsHelper;
/**
* In debug builds of the game, we can connect to a set of contracts deployed to a local
* blockchain, which are tweaked to not verify planet hashes, meaning we can use a faster hash
* function with similar properties to mimc. This allows us to mine the map faster in debug mode.
*
* @todo move this into a separate `GameConfiguration` class.
*/
private readonly useMockHash: boolean;
/**
* Game parameters set by the contract. Stuff like perlin keys, which are important for mining the
* correct universe, or the time multiplier, which allows us to tune how quickly voyages go.
*
* @todo move this into a separate `GameConfiguration` class.
*/
private readonly contractConstants: ContractConstants;
private paused: boolean;
/**
* @todo change this to the correct timestamp each round.
*/
private readonly endTimeSeconds: number = 1948939200; // new Date("2031-10-05T04:00:00.000Z").getTime() / 1000
/**
* An interface to the blockchain that is a little bit lower-level than {@link ContractsAPI}. It
* allows us to do basic operations such as wait for a transaction to complete, check the player's
* address and balance, etc.
*/
private readonly ethConnection: EthConnection;
/**
* Each round we change the hash configuration of the game. The hash configuration is download
* from the blockchain, and essentially acts as a salt, permuting the universe into a unique
* configuration for each new round.
*
* @todo deduplicate this and `useMockHash` somehow.
*/
private readonly hashConfig: HashConfig;
/**
* The aforementioned hash function. In debug mode where `DISABLE_ZK_CHECKS` is on, we use a
* faster hash function. Othewise, in production mode, use MiMC hash (https://byt3bit.github.io/primesym/).
*/
private readonly planetHashMimc: (...inputs: number[]) => BigInteger;
/**
* Whenever we refresh the players twitter accounts or scores, we publish an event here.
*/
public readonly playersUpdated$: Monomitter;
/**
* Handle to an interval that periodically uploads diagnostic information from this client.
*/
private diagnosticsInterval: ReturnType;
/**
* Handle to an interval that periodically refreshes some information about the player from the
* blockchain.
*
* @todo move this into a new `PlayerState` class.
*/
private playerInterval: ReturnType;
/**
* Handle to an interval that periodically refreshes the scoreboard from our webserver.
*/
private scoreboardInterval: ReturnType;
/**
* Handle to an interval that periodically refreshes the network's health from our webserver.
*/
private networkHealthInterval: ReturnType;
/**
* Manages the process of mining new space territory.
*/
private minerManager?: MinerManager;
/**
* Continuously updated value representing the total hashes per second that the game is currently
* mining the universe at.
*
* @todo keep this in {@link MinerManager}
*/
private hashRate: number;
/**
* The spawn location of the current player.
*
* @todo, make this smarter somehow. It's really annoying to have to import world coordinates, and
* get them wrong or something. Maybe we need to mark a planet, once it's been initialized
* contract-side, as the homeworld of the user who initialized on it. That way, when you import a
* new account into the game, and you import map data that contains your home planet, the client
* would be able to automatically detect which planet is the player's home planet.
*
* @todo move this into a new `PlayerState` class.
*/
private homeLocation: WorldLocation | undefined;
/**
* Sometimes the universe gets bigger... Sometimes it doesn't.
*
* @todo move this into a new `GameConfiguration` class.
*/
private worldRadius: number;
/**
* Emits whenever we load the network health summary from the webserver, which is derived from
* diagnostics that the client sends up to the webserver as well.
*/
public networkHealth$: Monomitter;
public paused$: Monomitter;
/**
* Diagnostic information about the game.
*/
private diagnostics: Diagnostics;
/**
* Subscription to act on setting changes
*/
private settingsSubscription: Subscription | undefined;
/**
* Setting to allow players to start game without plugins that were running during the previous
* run of the game client. By default, the game launches plugins that were running that were
* running when the game was last closed.
*/
private safeMode: boolean;
public get planetRarity(): number {
return this.contractConstants.PLANET_RARITY;
}
/**
* Generates capture zones.
*/
private captureZoneGenerator: CaptureZoneGenerator | undefined;
private constructor(
terminal: React.MutableRefObject,
account: EthAddress | undefined,
players: Map,
touchedPlanets: Map,
allTouchedPlanetIds: Set,
revealedCoords: Map,
claimedCoords: Map,
worldRadius: number,
unprocessedArrivals: Map,
unprocessedPlanetArrivalIds: Map,
contractsAPI: ContractsAPI,
contractConstants: ContractConstants,
persistentChunkStore: PersistentChunkStore,
snarkHelper: SnarkArgsHelper,
homeLocation: WorldLocation | undefined,
useMockHash: boolean,
artifacts: Map,
ethConnection: EthConnection,
paused: boolean
) {
super();
this.diagnostics = {
rpcUrl: 'unknown',
totalPlanets: 0,
visiblePlanets: 0,
visibleChunks: 0,
fps: 0,
chunkUpdates: 0,
callsInQueue: 0,
totalCalls: 0,
totalTransactions: 0,
transactionsInQueue: 0,
totalChunks: 0,
width: 0,
height: 0,
};
this.terminal = terminal;
this.account = account;
this.players = players;
this.worldRadius = worldRadius;
this.networkHealth$ = monomitter(true);
this.paused$ = monomitter(true);
this.playersUpdated$ = monomitter();
if (contractConstants.CAPTURE_ZONES_ENABLED) {
this.captureZoneGenerator = new CaptureZoneGenerator(
this,
contractConstants.GAME_START_BLOCK,
contractConstants.CAPTURE_ZONE_CHANGE_BLOCK_INTERVAL
);
}
this.hashConfig = {
planetHashKey: contractConstants.PLANETHASH_KEY,
spaceTypeKey: contractConstants.SPACETYPE_KEY,
biomebaseKey: contractConstants.BIOMEBASE_KEY,
perlinLengthScale: contractConstants.PERLIN_LENGTH_SCALE,
perlinMirrorX: contractConstants.PERLIN_MIRROR_X,
perlinMirrorY: contractConstants.PERLIN_MIRROR_Y,
planetRarity: contractConstants.PLANET_RARITY,
};
this.planetHashMimc = useMockHash
? fakeHash(this.hashConfig.planetRarity)
: mimcHash(this.hashConfig.planetHashKey);
this.contractConstants = contractConstants;
this.homeLocation = homeLocation;
const revealedLocations = new Map();
for (const [locationId, coords] of revealedCoords) {
const planet = touchedPlanets.get(locationId);
if (planet) {
const location: WorldLocation = {
hash: locationId,
coords,
perlin: planet.perlin,
biomebase: this.biomebasePerlin(coords, true),
};
revealedLocations.set(locationId, { ...location, revealer: coords.revealer });
}
}
const claimedLocations = new Map();
for (const [locationId, coords] of claimedCoords) {
const planet = touchedPlanets.get(locationId);
if (planet) {
const location: WorldLocation = {
hash: locationId,
coords,
perlin: planet.perlin,
biomebase: this.biomebasePerlin(coords, true),
};
const revealedLocation = { ...location, revealer: coords.revealer };
revealedLocations.set(locationId, revealedLocation);
claimedLocations.set(locationId, revealedLocation);
}
}
this.entityStore = new GameObjects(
account,
touchedPlanets,
allTouchedPlanetIds,
revealedLocations,
claimedLocations,
artifacts,
persistentChunkStore.allChunks(),
unprocessedArrivals,
unprocessedPlanetArrivalIds,
contractConstants,
worldRadius
);
this.contractsAPI = contractsAPI;
this.persistentChunkStore = persistentChunkStore;
this.snarkHelper = snarkHelper;
this.useMockHash = useMockHash;
this.paused = paused;
this.ethConnection = ethConnection;
this.diagnosticsInterval = setInterval(this.uploadDiagnostics.bind(this), 10_000);
this.scoreboardInterval = setInterval(this.refreshScoreboard.bind(this), 10_000);
this.networkHealthInterval = setInterval(this.refreshNetworkHealth.bind(this), 10_000);
this.playerInterval = setInterval(() => {
if (this.account) {
this.hardRefreshPlayer(this.account);
}
}, 5000);
this.hashRate = 0;
this.settingsSubscription = settingChanged$.subscribe((setting: Setting) => {
if (setting === Setting.MiningCores) {
if (this.minerManager) {
const config = {
contractAddress: this.getContractAddress(),
account: this.account,
};
const cores = getNumberSetting(config, Setting.MiningCores);
this.minerManager.setCores(cores);
}
}
});
this.refreshScoreboard();
this.refreshNetworkHealth();
this.getSpaceships();
this.safeMode = false;
}
private async uploadDiagnostics() {
eventLogger.logEvent(EventType.Diagnostics, this.diagnostics);
}
private async refreshNetworkHealth() {
try {
this.networkHealth$.publish(await loadNetworkHealth());
} catch (e) {
// @todo - what do we do if we can't connect to the webserver
}
}
private async refreshScoreboard() {
try {
const leaderboard = await loadLeaderboard();
for (const entry of leaderboard.entries) {
const player = this.players.get(entry.ethAddress);
if (player) {
// current player's score is updated via `this.playerInterval`
if (player.address !== this.account && entry.score !== undefined) {
player.score = entry.score;
}
}
}
this.playersUpdated$.publish();
} catch (e) {
// @todo - what do we do if we can't connect to the webserver? in general this should be a
// valid state of affairs because arenas is a thing.
}
}
public getEthConnection() {
return this.ethConnection;
}
public destroy(): void {
// removes singletons of ContractsAPI, LocalStorageManager, MinerManager
if (this.minerManager) {
this.minerManager.removeAllListeners(MinerManagerEvent.DiscoveredNewChunk);
this.minerManager.destroy();
}
this.contractsAPI.destroy();
this.persistentChunkStore.destroy();
clearInterval(this.playerInterval);
clearInterval(this.diagnosticsInterval);
clearInterval(this.scoreboardInterval);
clearInterval(this.networkHealthInterval);
this.settingsSubscription?.unsubscribe();
}
static async create({
connection,
terminal,
contractAddress,
}: {
connection: EthConnection;
terminal: React.MutableRefObject;
contractAddress: EthAddress;
}): Promise {
if (!terminal.current) {
throw new Error('you must pass in a handle to a terminal');
}
const account = connection.getAddress();
if (!account) {
throw new Error('no account on eth connection');
}
const gameStateDownloader = new InitialGameStateDownloader(terminal.current);
const contractsAPI = await makeContractsAPI({ connection, contractAddress });
terminal.current?.println('Loading game data from disk...');
const persistentChunkStore = await PersistentChunkStore.create({ account, contractAddress });
terminal.current?.println('Downloading data from Ethereum blockchain...');
terminal.current?.println('(the contract is very big. this may take a while)');
terminal.current?.newline();
const initialState = await gameStateDownloader.download(contractsAPI, persistentChunkStore);
const possibleHomes = await persistentChunkStore.getHomeLocations();
terminal.current?.println('');
terminal.current?.println('Building Index...');
await persistentChunkStore.saveTouchedPlanetIds(initialState.allTouchedPlanetIds);
await persistentChunkStore.saveRevealedCoords(initialState.allRevealedCoords);
const knownArtifacts: Map = new Map();
for (let i = 0; i < initialState.loadedPlanets.length; i++) {
const planet = initialState.touchedAndLocatedPlanets.get(initialState.loadedPlanets[i]);
if (!planet) {
continue;
}
planet.heldArtifactIds = initialState.heldArtifacts[i].map((a) => a.id);
for (const heldArtifact of initialState.heldArtifacts[i]) {
knownArtifacts.set(heldArtifact.id, heldArtifact);
}
}
for (const myArtifact of initialState.myArtifacts) {
knownArtifacts.set(myArtifact.id, myArtifact);
}
for (const artifact of initialState.artifactsOnVoyages) {
knownArtifacts.set(artifact.id, artifact);
}
// figure out what's my home planet
let homeLocation: WorldLocation | undefined = undefined;
for (const loc of possibleHomes) {
if (initialState.allTouchedPlanetIds.includes(loc.hash)) {
homeLocation = loc;
await persistentChunkStore.confirmHomeLocation(loc);
break;
}
}
const hashConfig: HashConfig = {
planetHashKey: initialState.contractConstants.PLANETHASH_KEY,
spaceTypeKey: initialState.contractConstants.SPACETYPE_KEY,
biomebaseKey: initialState.contractConstants.BIOMEBASE_KEY,
perlinLengthScale: initialState.contractConstants.PERLIN_LENGTH_SCALE,
perlinMirrorX: initialState.contractConstants.PERLIN_MIRROR_X,
perlinMirrorY: initialState.contractConstants.PERLIN_MIRROR_Y,
planetRarity: initialState.contractConstants.PLANET_RARITY,
};
const useMockHash = initialState.contractConstants.DISABLE_ZK_CHECKS;
const snarkHelper = SnarkArgsHelper.create(hashConfig, terminal, useMockHash);
const gameManager = new GameManager(
terminal,
account,
initialState.players,
initialState.touchedAndLocatedPlanets,
new Set(Array.from(initialState.allTouchedPlanetIds)),
initialState.revealedCoordsMap,
initialState.claimedCoordsMap
? initialState.claimedCoordsMap
: new Map(),
initialState.worldRadius,
initialState.arrivals,
initialState.planetVoyageIdMap,
contractsAPI,
initialState.contractConstants,
persistentChunkStore,
snarkHelper,
homeLocation,
useMockHash,
knownArtifacts,
connection,
initialState.paused
);
gameManager.setPlayerTwitters(initialState.twitters);
const config = {
contractAddress,
account: gameManager.getAccount(),
};
pollSetting(config, Setting.AutoApproveNonPurchaseTransactions);
persistentChunkStore.setDiagnosticUpdater(gameManager);
contractsAPI.setDiagnosticUpdater(gameManager);
// important that this happens AFTER we load the game state from the blockchain. Otherwise our
// 'loading game state' contract calls will be competing with events from the blockchain that
// are happening now, which makes no sense.
contractsAPI.setupEventListeners();
// get twitter handles
gameManager.refreshTwitters();
gameManager.listenForNewBlock();
// set up listeners: whenever ContractsAPI reports some game state update, do some logic
gameManager.contractsAPI
.on(ContractsAPIEvent.ArtifactUpdate, async (artifactId: ArtifactId) => {
await gameManager.hardRefreshArtifact(artifactId);
gameManager.emit(GameManagerEvent.ArtifactUpdate, artifactId);
})
.on(
ContractsAPIEvent.PlanetTransferred,
async (planetId: LocationId, newOwner: EthAddress) => {
await gameManager.hardRefreshPlanet(planetId);
const planetAfter = gameManager.getPlanetWithId(planetId);
if (planetAfter && newOwner === gameManager.account) {
NotificationManager.getInstance().receivedPlanet(planetAfter);
}
}
)
.on(ContractsAPIEvent.PlayerUpdate, async (playerId: EthAddress) => {
await gameManager.hardRefreshPlayer(playerId);
})
.on(ContractsAPIEvent.PauseStateChanged, async (paused: boolean) => {
gameManager.paused = paused;
gameManager.paused$.publish(paused);
})
.on(ContractsAPIEvent.PlanetUpdate, async (planetId: LocationId) => {
// don't reload planets that you don't have in your map. once a planet
// is in your map it will be loaded from the contract.
const localPlanet = gameManager.entityStore.getPlanetWithId(planetId);
if (localPlanet && isLocatable(localPlanet)) {
await gameManager.hardRefreshPlanet(planetId);
gameManager.emit(GameManagerEvent.PlanetUpdate);
}
})
.on(
ContractsAPIEvent.ArrivalQueued,
async (_arrivalId: VoyageId, fromId: LocationId, toId: LocationId) => {
// only reload planets if the toPlanet is in the map
const localToPlanet = gameManager.entityStore.getPlanetWithId(toId);
if (localToPlanet && isLocatable(localToPlanet)) {
await gameManager.bulkHardRefreshPlanets([fromId, toId]);
gameManager.emit(GameManagerEvent.PlanetUpdate);
}
}
)
.on(
ContractsAPIEvent.LocationRevealed,
async (planetId: LocationId, _revealer: EthAddress) => {
// TODO: hook notifs or emit event to UI if you want
await gameManager.hardRefreshPlanet(planetId);
gameManager.emit(GameManagerEvent.PlanetUpdate);
}
)
.on(ContractsAPIEvent.TxQueued, (tx: Transaction) => {
gameManager.entityStore.onTxIntent(tx);
})
.on(ContractsAPIEvent.TxSubmitted, (tx: Transaction) => {
gameManager.persistentChunkStore.onEthTxSubmit(tx);
gameManager.onTxSubmit(tx);
})
.on(ContractsAPIEvent.TxConfirmed, async (tx: Transaction) => {
if (!tx.hash) return; // this should never happen
gameManager.persistentChunkStore.onEthTxComplete(tx.hash);
if (isUnconfirmedRevealTx(tx)) {
await gameManager.hardRefreshPlanet(tx.intent.locationId);
} else if (isUnconfirmedInitTx(tx)) {
terminal.current?.println('Loading Home Planet from Blockchain...');
const retries = 5;
for (let i = 0; i < retries; i++) {
const planet = await gameManager.contractsAPI.getPlanetById(tx.intent.locationId);
if (planet) {
break;
} else if (i === retries - 1) {
console.error("couldn't load player's home planet");
} else {
await delay(2000);
}
}
await gameManager.hardRefreshPlanet(tx.intent.locationId);
// mining manager should be initialized already via joinGame, but just in case...
gameManager.initMiningManager(tx.intent.location.coords, 4);
} else if (isUnconfirmedMoveTx(tx)) {
const promises = [gameManager.bulkHardRefreshPlanets([tx.intent.from, tx.intent.to])];
if (tx.intent.artifact) {
promises.push(gameManager.hardRefreshArtifact(tx.intent.artifact));
}
await Promise.all(promises);
} else if (isUnconfirmedUpgradeTx(tx)) {
await gameManager.hardRefreshPlanet(tx.intent.locationId);
} else if (isUnconfirmedBuyHatTx(tx)) {
await gameManager.hardRefreshPlanet(tx.intent.locationId);
} else if (isUnconfirmedInitTx(tx)) {
await gameManager.hardRefreshPlanet(tx.intent.locationId);
} else if (isUnconfirmedFindArtifactTx(tx)) {
await gameManager.hardRefreshPlanet(tx.intent.planetId);
} else if (isUnconfirmedDepositArtifactTx(tx)) {
await Promise.all([
gameManager.hardRefreshPlanet(tx.intent.locationId),
gameManager.hardRefreshArtifact(tx.intent.artifactId),
]);
} else if (isUnconfirmedWithdrawArtifactTx(tx)) {
await Promise.all([
await gameManager.hardRefreshPlanet(tx.intent.locationId),
await gameManager.hardRefreshArtifact(tx.intent.artifactId),
]);
} else if (isUnconfirmedProspectPlanetTx(tx)) {
await gameManager.softRefreshPlanet(tx.intent.planetId);
} else if (isUnconfirmedActivateArtifactTx(tx)) {
await Promise.all([
gameManager.hardRefreshPlanet(tx.intent.locationId),
gameManager.hardRefreshArtifact(tx.intent.artifactId),
]);
} else if (isUnconfirmedDeactivateArtifactTx(tx)) {
await Promise.all([
gameManager.hardRefreshPlanet(tx.intent.locationId),
gameManager.hardRefreshArtifact(tx.intent.artifactId),
]);
} else if (isUnconfirmedWithdrawSilverTx(tx)) {
await gameManager.softRefreshPlanet(tx.intent.locationId);
} else if (isUnconfirmedCapturePlanetTx(tx)) {
await Promise.all([
gameManager.hardRefreshPlayer(gameManager.getAccount()),
gameManager.hardRefreshPlanet(tx.intent.locationId),
]);
} else if (isUnconfirmedInvadePlanetTx(tx)) {
await Promise.all([
gameManager.hardRefreshPlayer(gameManager.getAccount()),
gameManager.hardRefreshPlanet(tx.intent.locationId),
]);
}
gameManager.entityStore.clearUnconfirmedTxIntent(tx);
gameManager.onTxConfirmed(tx);
})
.on(ContractsAPIEvent.TxErrored, async (tx: Transaction) => {
gameManager.entityStore.clearUnconfirmedTxIntent(tx);
if (tx.hash) {
gameManager.persistentChunkStore.onEthTxComplete(tx.hash);
}
gameManager.onTxReverted(tx);
})
.on(ContractsAPIEvent.TxCancelled, async (tx: Transaction) => {
gameManager.onTxCancelled(tx);
})
.on(ContractsAPIEvent.RadiusUpdated, async () => {
const newRadius = await gameManager.contractsAPI.getWorldRadius();
gameManager.setRadius(newRadius);
});
const unconfirmedTxs = await persistentChunkStore.getUnconfirmedSubmittedEthTxs();
const confirmationQueue = new ThrottledConcurrentQueue({
invocationIntervalMs: 1000,
maxInvocationsPerIntervalMs: 10,
maxConcurrency: 1,
});
for (const unconfirmedTx of unconfirmedTxs) {
confirmationQueue.add(async () => {
const tx = gameManager.contractsAPI.txExecutor.waitForTransaction(unconfirmedTx);
gameManager.contractsAPI.emitTransactionEvents(tx);
return tx.confirmedPromise;
});
}
// we only want to initialize the mining manager if the player has already joined the game
// if they haven't, we'll do this once the player has joined the game
if (!!homeLocation && initialState.players.has(account as string)) {
gameManager.initMiningManager(homeLocation.coords);
}
return gameManager;
}
private async hardRefreshPlayer(address?: EthAddress): Promise {
if (!address) return;
const playerFromBlockchain = await this.contractsAPI.getPlayerById(address);
if (!playerFromBlockchain) return;
const localPlayer = this.getPlayer(address);
if (localPlayer?.twitter) {
playerFromBlockchain.twitter = localPlayer.twitter;
}
this.players.set(address, playerFromBlockchain);
this.playersUpdated$.publish();
}
// Dirty hack for only refreshing properties on a planet and nothing else
private async softRefreshPlanet(planetId: LocationId): Promise {
const planet = await this.contractsAPI.getPlanetById(planetId);
if (!planet) return;
this.entityStore.replacePlanetFromContractData(planet);
}
public async hardRefreshPlanet(planetId: LocationId): Promise {
const planet = await this.contractsAPI.getPlanetById(planetId);
if (!planet) return;
const arrivals = await this.contractsAPI.getArrivalsForPlanet(planetId);
const artifactsOnPlanets = await this.contractsAPI.bulkGetArtifactsOnPlanets([planetId]);
const artifactsOnPlanet = artifactsOnPlanets[0];
const revealedCoords = await this.contractsAPI.getRevealedCoordsByIdIfExists(planetId);
let revealedLocation: RevealedLocation | undefined;
let claimedCoords: ClaimedCoords | undefined;
if (revealedCoords) {
revealedLocation = {
...this.locationFromCoords(revealedCoords),
revealer: revealedCoords.revealer,
};
}
this.entityStore.replacePlanetFromContractData(
planet,
arrivals,
artifactsOnPlanet.map((a) => a.id),
revealedLocation,
claimedCoords?.revealer
);
// it's important that we reload the artifacts that are on the planet after the move
// completes because this move could have been a photoid canon move. one of the side
// effects of this type of move is that the active photoid canon deactivates upon a move
// meaning we need to reload its data from the blockchain.
artifactsOnPlanet.forEach((a) => this.entityStore.replaceArtifactFromContractData(a));
}
private async bulkHardRefreshPlanets(planetIds: LocationId[]): Promise {
const planetVoyageMap: Map = new Map();
const allVoyages = await this.contractsAPI.getAllArrivals(planetIds);
const planetsToUpdateMap = await this.contractsAPI.bulkGetPlanets(planetIds);
const artifactsOnPlanets = await this.contractsAPI.bulkGetArtifactsOnPlanets(planetIds);
planetsToUpdateMap.forEach((planet, locId) => {
if (planetsToUpdateMap.has(locId)) {
planetVoyageMap.set(locId, []);
}
});
for (const voyage of allVoyages) {
const voyagesForToPlanet = planetVoyageMap.get(voyage.toPlanet);
if (voyagesForToPlanet) {
voyagesForToPlanet.push(voyage);
planetVoyageMap.set(voyage.toPlanet, voyagesForToPlanet);
}
}
for (let i = 0; i < planetIds.length; i++) {
const planetId = planetIds[i];
const planet = planetsToUpdateMap.get(planetId);
// This shouldn't really happen, but we are better off being safe - opposed to throwing
if (!planet) {
continue;
}
const voyagesForPlanet = planetVoyageMap.get(planet.locationId);
if (voyagesForPlanet) {
this.entityStore.replacePlanetFromContractData(
planet,
voyagesForPlanet,
artifactsOnPlanets[i].map((a) => a.id)
);
}
}
for (const artifacts of artifactsOnPlanets) {
this.entityStore.replaceArtifactsFromContractData(artifacts);
}
}
public async hardRefreshArtifact(artifactId: ArtifactId): Promise {
const artifact = await this.contractsAPI.getArtifactById(artifactId);
if (!artifact) return;
this.entityStore.replaceArtifactFromContractData(artifact);
}
private onTxSubmit(tx: Transaction): void {
this.terminal.current?.print(`${tx.intent.methodName} transaction (`, TerminalTextStyle.Blue);
this.terminal.current?.printLink(
`${tx.hash?.slice(0, 6) ?? ''}`,
() => {
window.open(`${BLOCK_EXPLORER_URL}/${tx.hash ?? ''}`);
},
TerminalTextStyle.White
);
this.terminal.current?.println(`) submitted`, TerminalTextStyle.Blue);
}
private onTxConfirmed(tx: Transaction) {
this.terminal.current?.print(`${tx.intent.methodName} transaction (`, TerminalTextStyle.Green);
this.terminal.current?.printLink(
`${tx.hash?.slice(0, 6) ?? ''}`,
() => {
window.open(`${BLOCK_EXPLORER_URL}/${tx.hash ?? ''}`);
},
TerminalTextStyle.White
);
this.terminal.current?.println(`) confirmed`, TerminalTextStyle.Green);
}
private onTxReverted(tx: Transaction) {
this.terminal.current?.print(`${tx.intent.methodName} transaction (`, TerminalTextStyle.Red);
this.terminal.current?.printLink(
`${tx.hash?.slice(0, 6) ?? ''}`,
() => {
window.open(`${BLOCK_EXPLORER_URL}/${tx.hash ?? ''}`);
},
TerminalTextStyle.White
);
this.terminal.current?.println(`) reverted`, TerminalTextStyle.Red);
}
private onTxCancelled(tx: Transaction) {
this.entityStore.clearUnconfirmedTxIntent(tx);
this.terminal.current?.print(`${tx.intent.methodName} transaction (`, TerminalTextStyle.Red);
this.terminal.current?.printLink(
`${tx.hash?.slice(0, 6) ?? ''}`,
() => {
window.open(`${BLOCK_EXPLORER_URL}/${tx.hash ?? ''}`);
},
TerminalTextStyle.White
);
this.terminal.current?.println(`) cancelled`, TerminalTextStyle.Red);
}
/**
* Gets the address of the player logged into this game manager.
*/
public getAccount(): EthAddress | undefined {
return this.account;
}
/**
* Get the thing that handles contract interaction.
*/
public getContractAPI(): ContractsAPI {
return this.contractsAPI;
}
/**
* Gets the address of the `DarkForest` contract, which is the 'backend' of the game.
*/
public getContractAddress(): EthAddress {
return this.contractsAPI.getContractAddress();
}
/**
* Gets the twitter handle of the given ethereum account which is associated
* with Dark Forest.
*/
public getTwitter(address: EthAddress | undefined): string | undefined {
let myAddress;
if (!address) myAddress = this.getAccount();
else myAddress = address;
if (!myAddress) {
return undefined;
}
const twitter = this.players.get(myAddress)?.twitter;
return twitter;
}
/**
* The game ends at a particular time in the future - get this time measured
* in seconds from the epoch.
*/
public getEndTimeSeconds(): number {
return this.endTimeSeconds;
}
/**
* Dark Forest tokens can only be minted up to a certain time - get this time measured in seconds from epoch.
*/
public getTokenMintEndTimeSeconds(): number {
return this.contractConstants.TOKEN_MINT_END_SECONDS;
}
/**
* Gets the rarity of planets in the universe
*/
public getPlanetRarity(): number {
return this.contractConstants.PLANET_RARITY;
}
/**
* returns timestamp (seconds) that planet will reach percent% of energycap
* time may be in the past
*/
public getEnergyCurveAtPercent(planet: Planet, percent: number): number {
return this.entityStore.getEnergyCurveAtPercent(planet, percent);
}
/**
* returns timestamp (seconds) that planet will reach percent% of silcap if
* doesn't produce silver, returns undefined if already over percent% of silcap,
*/
public getSilverCurveAtPercent(planet: Planet, percent: number): number | undefined {
return this.entityStore.getSilverCurveAtPercent(planet, percent);
}
/**
* Returns the upgrade that would be applied to a planet given a particular
* upgrade branch (defense, range, speed) and level of upgrade.
*/
public getUpgrade(branch: number, level: number): Upgrade {
return this.contractConstants.upgrades[branch][level];
}
/**
* Gets a list of all the players in the game (not just the ones you've
* encounterd)
*/
public getAllPlayers(): Player[] {
return Array.from(this.players.values());
}
/**
* Gets either the given player, or if no address was provided, gets the player that is logged
* this client.
*/
public getPlayer(address?: EthAddress): Player | undefined {
address = address || this.account;
if (!address) {
return undefined;
}
return this.players.get(address);
}
/**
* Gets all the map chunks that this client is aware of. Chunks may have come from
* mining, or from importing map data.
*/
public getExploredChunks(): Iterable {
return this.persistentChunkStore.allChunks();
}
/**
* Gets the ids of all the planets that are both within the given bounding box (defined by its bottom
* left coordinate, width, and height) in the world and of a level that was passed in via the
* `planetLevels` parameter.
*/
public getPlanetsInWorldRectangle(
worldX: number,
worldY: number,
worldWidth: number,
worldHeight: number,
levels: number[],
planetLevelToRadii: Map,
updateIfStale = true
): LocatablePlanet[] {
return this.entityStore.getPlanetsInWorldRectangle(
worldX,
worldY,
worldWidth,
worldHeight,
levels,
planetLevelToRadii,
updateIfStale
);
}
/**
* Returns whether or not the current round has ended.
*/
public isRoundOver(): boolean {
return Date.now() / 1000 > this.getTokenMintEndTimeSeconds();
}
/**
* Gets the radius of the playable area of the universe.
*/
public getWorldRadius(): number {
return this.worldRadius;
}
/**
* Gets the total amount of silver that lives on a planet that somebody owns.
*/
public getWorldSilver(): number {
return this.getAllOwnedPlanets().reduce(
(totalSoFar: number, nextPlanet: Planet) => totalSoFar + nextPlanet.silver,
0
);
}
/**
* Gets the total amount of energy that lives on a planet that somebody owns.
*/
public getUniverseTotalEnergy(): number {
return this.getAllOwnedPlanets().reduce(
(totalSoFar: number, nextPlanet: Planet) => totalSoFar + nextPlanet.energy,
0
);
}
/**
* Gets the total amount of silver that lives on planets that the given player owns.
*/
public getSilverOfPlayer(player: EthAddress): number {
return this.getAllOwnedPlanets()
.filter((planet) => planet.owner === player)
.reduce((totalSoFar: number, nextPlanet: Planet) => totalSoFar + nextPlanet.silver, 0);
}
/**
* Gets the total amount of energy that lives on planets that the given player owns.
*/
public getEnergyOfPlayer(player: EthAddress): number {
return this.getAllOwnedPlanets()
.filter((planet) => planet.owner === player)
.reduce((totalSoFar: number, nextPlanet: Planet) => totalSoFar + nextPlanet.energy, 0);
}
public getPlayerScore(addr: EthAddress): number | undefined {
const player = this.players.get(addr);
return player?.score;
}
public getPlayerSpaceJunk(addr: EthAddress): number | undefined {
const player = this.players.get(addr);
return player?.spaceJunk;
}
public getPlayerSpaceJunkLimit(addr: EthAddress): number | undefined {
const player = this.players.get(addr);
return player?.spaceJunkLimit;
}
public getDefaultSpaceJunkForPlanetLevel(level: number) {
return this.contractConstants.PLANET_LEVEL_JUNK[level];
}
private initMiningManager(homeCoords: WorldCoords, cores?: number): void {
if (this.minerManager) return;
const myPattern: MiningPattern = new SpiralPattern(homeCoords, MIN_CHUNK_SIZE);
this.minerManager = MinerManager.create(
this.persistentChunkStore,
myPattern,
this.worldRadius,
this.planetRarity,
this.hashConfig,
this.useMockHash
);
const config = {
contractAddress: this.getContractAddress(),
account: this.account,
};
this.minerManager.setCores(cores || getNumberSetting(config, Setting.MiningCores));
this.minerManager.on(
MinerManagerEvent.DiscoveredNewChunk,
(chunk: Chunk, miningTimeMillis: number) => {
this.addNewChunk(chunk);
this.hashRate = chunk.chunkFootprint.sideLength ** 2 / (miningTimeMillis / 1000);
this.emit(GameManagerEvent.DiscoveredNewChunk, chunk);
}
);
const isMining = getBooleanSetting(config, Setting.IsMining);
if (isMining) {
this.minerManager.startExplore();
}
}
/**
* Sets the mining pattern of the miner. This kills the old miner and starts this one.
*/
setMiningPattern(pattern: MiningPattern): void {
if (this.minerManager) {
this.minerManager.setMiningPattern(pattern);
}
}
/**
* Gets the mining pattern that the miner is currently using.
*/
getMiningPattern(): MiningPattern | undefined {
if (this.minerManager) return this.minerManager.getMiningPattern();
else return undefined;
}
/**
* Set the amount of cores to mine the universe with. More cores equals faster!
*/
setMinerCores(nCores: number): void {
const config = {
contractAddress: this.getContractAddress(),
account: this.account,
};
setSetting(config, Setting.MiningCores, nCores + '');
}
/**
* Whether or not the miner is currently exploring space.
*/
isMining(): boolean {
return this.minerManager?.isMining() || false;
}
/**
* Changes the amount of move snark proofs that are cached.
*/
setSnarkCacheSize(size: number): void {
this.snarkHelper.setSnarkCacheSize(size);
}
/**
* Gets the rectangle bounding the chunk that the miner is currently in the process
* of hashing.
*/
getCurrentlyExploringChunk(): Rectangle | undefined {
if (this.minerManager) {
return this.minerManager.getCurrentlyExploringChunk();
}
return undefined;
}
/**
* Whether or not this client has successfully found and landed on a home planet.
*/
hasJoinedGame(): boolean {
return this.players.has(this.account as string);
}
/**
* Returns info about the next time you can broadcast coordinates
*/
getNextRevealCountdownInfo(): RevealCountdownInfo {
if (!this.account) {
throw new Error('no account set');
}
const myLastRevealTimestamp = this.players.get(this.account)?.lastRevealTimestamp;
return {
myLastRevealTimestamp: myLastRevealTimestamp || undefined,
currentlyRevealing: this.entityStore.transactions.hasTransaction(isUnconfirmedRevealTx),
revealCooldownTime: this.contractConstants.LOCATION_REVEAL_COOLDOWN,
};
}
/**
* gets both deposited artifacts that are on planets i own as well as artifacts i own
*/
getMyArtifacts(): Artifact[] {
if (!this.account) return [];
const ownedByMe = this.entityStore.getArtifactsOwnedBy(this.account);
const onPlanetsOwnedByMe = this.entityStore
.getArtifactsOnPlanetsOwnedBy(this.account)
// filter out space ships because they always show up
// in the `ownedByMe` array.
.filter((a) => !isSpaceShip(a.artifactType));
return [...ownedByMe, ...onPlanetsOwnedByMe];
}
/**
* Gets the planet that is located at the given coordinates. Returns undefined if not a valid
* location or if no planet exists at location. If the planet needs to be updated (because
* some time has passed since we last updated the planet), then updates that planet first.
*/
getPlanetWithCoords(coords: WorldCoords): LocatablePlanet | undefined {
return this.entityStore.getPlanetWithCoords(coords);
}
/**
* Gets the planet with the given hash. Returns undefined if the planet is neither in the contract
* nor has been discovered locally. If the planet needs to be updated (because some time has
* passed since we last updated the planet), then updates that planet first.
*/
getPlanetWithId(planetId: LocationId | undefined): Planet | undefined {
return planetId && this.entityStore.getPlanetWithId(planetId);
}
/**
* Gets a list of planets in the client's memory with the given ids. If a planet with the given id
* doesn't exist, no entry for that planet will be returned in the result.
*/
getPlanetsWithIds(planetId: LocationId[]): Planet[] {
return planetId.map((id) => this.getPlanetWithId(id)).filter((p) => !!p) as Planet[];
}
getStalePlanetWithId(planetId: LocationId): Planet | undefined {
return this.entityStore.getPlanetWithId(planetId, false);
}
/**
* Get the score of the currently logged-in account.
*/
getMyScore(): number | undefined {
if (!this.account) {
return undefined;
}
const player = this.players.get(this.account);
return player?.score;
}
/**
* Gets the artifact with the given id. Null if no artifact with id exists.
*/
getArtifactWithId(artifactId?: ArtifactId): Artifact | undefined {
return this.entityStore.getArtifactById(artifactId);
}
/**
* Gets the artifacts with the given ids, including ones we know exist but haven't been loaded,
* represented by `undefined`.
*/
getArtifactsWithIds(artifactIds: ArtifactId[] = []): Array {
return artifactIds.map((id) => this.getArtifactWithId(id));
}
/**
* Gets the level of the given planet. Returns undefined if the planet does not exist. Does
* NOT update the planet if the planet is stale, which means this function is fast.
*/
getPlanetLevel(planetId: LocationId): PlanetLevel | undefined {
return this.entityStore.getPlanetLevel(planetId);
}
/**
* Gets the location of the given planet. Returns undefined if the planet does not exist, or if
* we do not know the location of this planet NOT update the planet if the planet is stale,
* which means this function is fast.
*/
getLocationOfPlanet(planetId: LocationId): WorldLocation | undefined {
return this.entityStore.getLocationOfPlanet(planetId);
}
/**
* Gets all voyages that have not completed.
*/
getAllVoyages(): QueuedArrival[] {
return this.entityStore.getAllVoyages();
}
/**
* Gets all planets. This means all planets that are in the contract, and also all
* planets that have been mined locally. Does not update planets if they are stale.
* NOT PERFORMANT - for scripting only.
*/
getAllPlanets(): Iterable {
return this.entityStore.getAllPlanets();
}
/**
* Gets a list of planets that have an owner.
*/
getAllOwnedPlanets(): Planet[] {
return this.entityStore.getAllOwnedPlanets();
}
/**
* Gets a list of the planets that the player logged into this `GameManager` owns.
*/
getMyPlanets(): Planet[] {
return this.getAllOwnedPlanets().filter((planet) => planet.owner === this.account);
}
/**
* Gets a map of all location IDs whose coords have been publically revealed
*/
getRevealedLocations(): Map {
return this.entityStore.getRevealedLocations();
}
/**
* Gets a map of all location IDs which have been claimed.
*/
getClaimedLocations(): Map {
return this.entityStore.getClaimedLocations();
}
/**
* Each coordinate lives in a particular type of space, determined by a smooth random
* function called 'perlin noise.
*/
spaceTypeFromPerlin(perlin: number): SpaceType {
return this.entityStore.spaceTypeFromPerlin(perlin);
}
/**
* Gets the amount of hashes per second that the miner manager is calculating.
*/
getHashesPerSec(): number {
return this.hashRate;
}
/**
* Signs the given twitter handle with the private key of the current user. Used to
* verify that the person who owns the Dark Forest account was the one that attempted
* to link a twitter to their account.
*/
async getSignedTwitter(twitter: string): Promise {
return this.ethConnection.signMessage(twitter);
}
/**
* Gets the private key of the burner wallet used by this account.
*/
getPrivateKey(): string | undefined {
return this.ethConnection.getPrivateKey();
}
/**
* Gets the balance of the account measured in Eth (i.e. in full units of the chain).
*/
getMyBalanceEth(): number {
if (!this.account) return 0;
return weiToEth(this.getMyBalance());
}
/**
* Gets the balance of the account
*/
getMyBalance(): BigNumber {
return this.ethConnection.getMyBalance() || BigNumber.from('0');
}
/**
* Returns the monomitter which publishes events whenever the player's balance changes.
*/
getMyBalance$(): Monomitter {
return this.ethConnection.myBalance$;
}
/**
* Gets all moves that this client has queued to be uploaded to the contract, but
* have not been successfully confirmed yet.
*/
getUnconfirmedMoves(): Transaction[] {
return this.entityStore.transactions.getTransactions(isUnconfirmedMoveTx);
}
/**
* Gets all upgrades that this client has queued to be uploaded to the contract, but
* have not been successfully confirmed yet.
*/
getUnconfirmedUpgrades(): Transaction[] {
return this.entityStore.transactions.getTransactions(isUnconfirmedUpgradeTx);
}
getUnconfirmedWormholeActivations(): Transaction[] {
return this.entityStore.transactions
.getTransactions(isUnconfirmedActivateArtifactTx)
.filter((tx) => tx.intent.wormholeTo !== undefined);
}
/**
* Gets the location of your home planet.
*/
getHomeCoords(): WorldCoords | undefined {
if (!this.homeLocation) return undefined;
return {
x: this.homeLocation.coords.x,
y: this.homeLocation.coords.y,
};
}
/**
* Gets the hash of the location of your home planet.
*/
getHomeHash(): LocationId | undefined {
return this.homeLocation?.hash;
}
/**
* Gets the HASH CONFIG
*/
getHashConfig(): HashConfig {
return { ...this.hashConfig };
}
/**
* Whether or not the given rectangle has been mined.
*/
hasMinedChunk(chunkLocation: Rectangle): boolean {
return this.persistentChunkStore.hasMinedChunk(chunkLocation);
}
getChunk(chunkFootprint: Rectangle): Chunk | undefined {
return this.persistentChunkStore.getChunkByFootprint(chunkFootprint);
}
getChunkStore(): PersistentChunkStore {
return this.persistentChunkStore;
}
/**
* The perlin value at each coordinate determines the space type. There are four space
* types, which means there are four ranges on the number line that correspond to
* each space type. This function returns the boundary values between each of these
* four ranges: `PERLIN_THRESHOLD_1`, `PERLIN_THRESHOLD_2`, `PERLIN_THRESHOLD_3`.
*/
getPerlinThresholds(): [number, number, number] {
return [
this.contractConstants.PERLIN_THRESHOLD_1,
this.contractConstants.PERLIN_THRESHOLD_2,
this.contractConstants.PERLIN_THRESHOLD_3,
];
}
/**
* Starts the miner.
*/
startExplore(): void {
if (this.minerManager) {
const config = {
contractAddress: this.getContractAddress(),
account: this.account,
};
setBooleanSetting(config, Setting.IsMining, true);
this.minerManager.startExplore();
}
}
/**
* Stops the miner.
*/
stopExplore(): void {
if (this.minerManager) {
const config = {
contractAddress: this.getContractAddress(),
account: this.account,
};
setBooleanSetting(config, Setting.IsMining, false);
this.hashRate = 0;
this.minerManager.stopExplore();
}
}
private setRadius(worldRadius: number) {
this.worldRadius = worldRadius;
if (this.minerManager) {
this.minerManager.setRadius(this.worldRadius);
}
}
private async refreshTwitters(): Promise {
const addressTwitters = await getAllTwitters();
this.setPlayerTwitters(addressTwitters);
}
private setPlayerTwitters(twitters: AddressTwitterMap): void {
for (const [address, player] of this.players.entries()) {
const newPlayerTwitter = twitters[address];
player.twitter = newPlayerTwitter;
}
this.playersUpdated$.publish();
}
/**
* Once you have posted the verification tweet - complete the twitter-account-linking
* process by telling the Dark Forest webserver to look at that tweet.
*/
async submitVerifyTwitter(twitter: string): Promise {
if (!this.account) return Promise.resolve(false);
const success = await verifyTwitterHandle(
await this.ethConnection.signMessageObject({ twitter })
);
await this.refreshTwitters();
return success;
}
private checkGameHasEnded(): boolean {
if (Date.now() / 1000 > this.endTimeSeconds) {
this.terminal.current?.println('[ERROR] Game has ended.');
return true;
}
return false;
}
/**
* Gets the timestamp (ms) of the next time that we can broadcast the coordinates of a planet.
*/
public getNextBroadcastAvailableTimestamp() {
return Date.now() + this.timeUntilNextBroadcastAvailable();
}
/**
* Gets the amount of time (ms) until the next time the current player can broadcast a planet.
*/
public timeUntilNextBroadcastAvailable() {
if (!this.account) {
throw new Error('no account set');
}
const myLastRevealTimestamp = this.players.get(this.account)?.lastRevealTimestamp;
return timeUntilNextBroadcastAvailable(
myLastRevealTimestamp,
this.contractConstants.LOCATION_REVEAL_COOLDOWN
);
}
/**
* Gets the timestamp (ms) of the next time that we can claim a planet.
*/
public getNextClaimAvailableTimestamp() {
if (!this.account) {
throw new Error('no account set');
}
const myLastClaimTimestamp = this.players.get(this.account)?.lastClaimTimestamp;
if (!myLastClaimTimestamp) {
return Date.now();
}
if (!this.contractConstants.CLAIM_PLANET_COOLDOWN) {
return 0;
}
// both the variables in the next line are denominated in seconds
return (myLastClaimTimestamp + this.contractConstants.CLAIM_PLANET_COOLDOWN) * 1000;
}
public getCaptureZones(): Set {
return this.captureZoneGenerator?.getZones() || new Set();
}
/**
* Reveals a planet's location on-chain.
*/
public async revealLocation(planetId: LocationId): Promise> {
try {
if (!this.account) {
throw new Error('no account set');
}
const planet = this.entityStore.getPlanetWithId(planetId);
if (!planet) {
throw new Error("you can't reveal a planet you haven't discovered");
}
if (!isLocatable(planet)) {
throw new Error("you can't reveal a planet whose coordinates you don't know");
}
if (planet.coordsRevealed) {
throw new Error("this planet's location is already revealed");
}
if (planet.transactions?.hasTransaction(isUnconfirmedRevealTx)) {
throw new Error("you're already revealing this planet's location");
}
if (this.entityStore.transactions.hasTransaction(isUnconfirmedRevealTx)) {
throw new Error("you're already broadcasting coordinates");
}
const myLastRevealTimestamp = this.players.get(this.account)?.lastRevealTimestamp;
if (myLastRevealTimestamp && Date.now() < this.getNextBroadcastAvailableTimestamp()) {
throw new Error('still on cooldown for broadcasting');
}
// this is shitty. used for the popup window
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-revealLocationId`, planetId);
const getArgs = async () => {
const revealArgs = await this.snarkHelper.getRevealArgs(
planet.location.coords.x,
planet.location.coords.y
);
this.terminal.current?.println(
'REVEAL: calculated SNARK with args:',
TerminalTextStyle.Sub
);
this.terminal.current?.println(
JSON.stringify(hexifyBigIntNestedArray(revealArgs.slice(0, 3))),
TerminalTextStyle.Sub
);
this.terminal.current?.newline();
return revealArgs;
};
const txIntent: UnconfirmedReveal = {
methodName: 'revealLocation',
contract: this.contractsAPI.contract,
locationId: planetId,
location: planet.location,
args: getArgs(),
};
// Always await the submitTransaction so we can catch rejections
const tx = await this.contractsAPI.submitTransaction(txIntent);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('revealLocation', e.message);
throw e;
}
}
public async invadePlanet(locationId: LocationId) {
try {
if (!this.captureZoneGenerator) {
throw new Error('Capture zones are not enabled in this game');
}
const planet = this.entityStore.getPlanetWithId(locationId);
if (!planet || !isLocatable(planet)) {
throw new Error("you can't invade a planet you haven't discovered");
}
if (planet.destroyed) {
throw new Error("you can't invade destroyed planets");
}
if (planet.invader !== EMPTY_ADDRESS) {
throw new Error("you can't invade planets that have already been invaded");
}
if (planet.owner !== this.account) {
throw new Error('you can only invade planets you own');
}
if (!this.captureZoneGenerator.isInZone(planet.locationId)) {
throw new Error("you can't invade planets that are not in a capture zone");
}
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-invadePlanet`, locationId);
const getArgs = async () => {
const revealArgs = await this.snarkHelper.getRevealArgs(
planet.location.coords.x,
planet.location.coords.y
);
this.terminal.current?.println(
'REVEAL: calculated SNARK with args:',
TerminalTextStyle.Sub
);
this.terminal.current?.println(
JSON.stringify(hexifyBigIntNestedArray(revealArgs.slice(0, 3))),
TerminalTextStyle.Sub
);
this.terminal.current?.newline();
return revealArgs;
};
const txIntent: UnconfirmedInvadePlanet = {
methodName: 'invadePlanet',
contract: this.contractsAPI.contract,
locationId,
args: getArgs(),
};
const tx = await this.contractsAPI.submitTransaction(txIntent);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('invadePlanet', e.message);
throw e;
}
}
public async capturePlanet(locationId: LocationId) {
try {
const planet = this.entityStore.getPlanetWithId(locationId);
if (!planet) {
throw new Error('planet is not loaded');
}
if (planet.destroyed) {
throw new Error("you can't capture destroyed planets");
}
if (planet.capturer !== EMPTY_ADDRESS) {
throw new Error("you can't capture planets that have already been captured");
}
if (planet.owner !== this.account) {
throw new Error('you can only capture planets you own');
}
if (planet.energy < planet.energyCap * 0.8) {
throw new Error('the planet needs >80% energy before capturing');
}
if (
!planet.invadeStartBlock ||
this.ethConnection.getCurrentBlockNumber() <
planet.invadeStartBlock + this.contractConstants.CAPTURE_ZONE_HOLD_BLOCKS_REQUIRED
) {
throw new Error(
`you need to hold a planet for ${this.contractConstants.CAPTURE_ZONE_HOLD_BLOCKS_REQUIRED} blocks before capturing`
);
}
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-capturePlanet`, locationId);
const txIntent: UnconfirmedCapturePlanet = {
methodName: 'capturePlanet',
contract: this.contractsAPI.contract,
locationId,
args: Promise.resolve([locationIdToDecStr(locationId)]),
};
const tx = await this.contractsAPI.submitTransaction(txIntent);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('capturePlanet', e.message);
throw e;
}
}
/**
* Attempts to join the game. Should not be called once you've already joined.
*/
public async joinGame(beforeRetry: (e: Error) => Promise): Promise {
try {
if (this.checkGameHasEnded()) {
throw new Error('game has ended');
}
const planet = await this.findRandomHomePlanet();
this.homeLocation = planet.location;
this.terminal.current?.println('');
this.terminal.current?.println(`Found Suitable Home Planet: ${getPlanetName(planet)} `);
this.terminal.current?.println(
`Its coordinates are: (${planet.location.coords.x}, ${planet.location.coords.y})`
);
this.terminal.current?.println('');
await this.persistentChunkStore.addHomeLocation(planet.location);
const getArgs = async () => {
const args = await this.snarkHelper.getInitArgs(
planet.location.coords.x,
planet.location.coords.y,
Math.floor(Math.sqrt(planet.location.coords.x ** 2 + planet.location.coords.y ** 2)) + 1 // floor(sqrt(x^2 + y^2)) + 1
);
this.terminal.current?.println('INIT: calculated SNARK with args:', TerminalTextStyle.Sub);
this.terminal.current?.println(
JSON.stringify(hexifyBigIntNestedArray(args.slice(0, 3) as unknown as string[])),
TerminalTextStyle.Sub
);
this.terminal.current?.newline();
return args;
};
const txIntent: UnconfirmedInit = {
methodName: 'initializePlayer',
contract: this.contractsAPI.contract,
locationId: planet.location.hash,
location: planet.location,
args: getArgs(),
};
this.terminal.current?.println('INIT: proving that planet exists', TerminalTextStyle.Sub);
this.initMiningManager(planet.location.coords); // get an early start
// if player initialization causes an error, give the caller an opportunity
// to resolve that error. if the asynchronous `beforeRetry` function returns
// true, retry initializing the player. if it returns false, or if the
// `beforeRetry` is undefined, then don't retry and throw an exception.
while (true) {
try {
const tx = await this.contractsAPI.submitTransaction(txIntent);
await tx.confirmedPromise;
break;
} catch (e) {
if (beforeRetry) {
if (await beforeRetry(e)) {
continue;
}
} else {
throw e;
}
}
}
await this.getSpaceships();
await this.hardRefreshPlanet(planet.locationId);
this.emit(GameManagerEvent.InitializedPlayer);
} catch (e) {
this.getNotificationsManager().txInitError('initializePlayer', e.message);
throw e;
}
}
private async getSpaceships() {
if (!this.account || !this.homeLocation?.hash) return;
const player = await this.contractsAPI.getPlayerById(this.account);
if (player?.claimedShips) return;
if (this.getGameObjects().isGettingSpaceships()) return;
const tx = await this.contractsAPI.submitTransaction({
methodName: 'giveSpaceShips',
contract: this.contractsAPI.contract,
args: Promise.resolve(['0x' + this.homeLocation?.hash]),
});
await tx.confirmedPromise;
this.hardRefreshPlanet(this.homeLocation?.hash);
}
// this is slow, do not call in i.e. render/draw loop
/**
*
* computes the WorldLocation object corresponding to a set of coordinates
* very slow since it actually calculates the hash; do not use in render loop
*/
private locationFromCoords(coords: WorldCoords): WorldLocation {
return {
coords,
hash: locationIdFromBigInt(this.planetHashMimc(coords.x, coords.y)),
perlin: this.spaceTypePerlin(coords, true),
biomebase: this.biomebasePerlin(coords, true),
};
}
/**
* Initializes a new player's game to start at the given home planet. Must have already
* initialized the player on the contract.
*/
async addAccount(coords: WorldCoords): Promise {
const loc: WorldLocation = this.locationFromCoords(coords);
await this.persistentChunkStore.addHomeLocation(loc);
this.initMiningManager(coords);
this.homeLocation = loc;
return true;
}
private async findRandomHomePlanet(): Promise {
return new Promise((resolve, reject) => {
const initPerlinMin = this.contractConstants.INIT_PERLIN_MIN;
const initPerlinMax = this.contractConstants.INIT_PERLIN_MAX;
let minedChunksCount = 0;
let x: number;
let y: number;
let d: number;
let p: number;
// if this.contractConstants.SPAWN_RIM_AREA is non-zero, then players must spawn in that
// area, distributed evenly in the inner perimeter of the world
let spawnInnerRadius = Math.sqrt(
Math.max(Math.PI * this.worldRadius ** 2 - this.contractConstants.SPAWN_RIM_AREA, 0) /
Math.PI
);
if (this.contractConstants.SPAWN_RIM_AREA === 0) {
spawnInnerRadius = 0;
}
do {
// sample from square
x = Math.random() * this.worldRadius * 2 - this.worldRadius;
y = Math.random() * this.worldRadius * 2 - this.worldRadius;
d = Math.sqrt(x ** 2 + y ** 2);
p = this.spaceTypePerlin({ x, y }, false);
} while (
p >= initPerlinMax || // keep searching if above or equal to the max
p < initPerlinMin || // keep searching if below the minimum
d >= this.worldRadius || // can't be out of bound
d <= spawnInnerRadius // can't be inside spawn area ring
);
// when setting up a new account in development mode, you can tell
// the game where to start searching for planets using this query
// string parameter. for example:
//
// ?searchCenter=2866,5627
//
const params = new URLSearchParams(window.location.search);
if (params.has('searchCenter')) {
const parts = params.get('searchCenter')?.split(',');
if (parts) {
x = parseInt(parts[0], 10);
y = parseInt(parts[1], 10);
}
}
const pattern: MiningPattern = new SpiralPattern({ x, y }, MIN_CHUNK_SIZE);
const chunkStore = new HomePlanetMinerChunkStore(
initPerlinMin,
initPerlinMax,
this.hashConfig
);
const homePlanetFinder = MinerManager.create(
chunkStore,
pattern,
this.worldRadius,
this.planetRarity,
this.hashConfig,
this.useMockHash
);
this.terminal.current?.println(``);
this.terminal.current?.println(`Initializing Home Planet Search...`);
this.terminal.current?.println(``);
this.terminal.current?.println(`Chunked explorer: start!`);
this.terminal.current?.println(
`Each chunk contains ${MIN_CHUNK_SIZE}x${MIN_CHUNK_SIZE} coordinates.`
);
const percentSpawn = (1 / this.contractConstants.PLANET_RARITY) * 100;
const printProgress = 8;
this.terminal.current?.print(`Each coordinate has a`);
this.terminal.current?.print(` ${percentSpawn}%`, TerminalTextStyle.Text);
this.terminal.current?.print(` chance of spawning a planet.`);
this.terminal.current?.println('');
this.terminal.current?.println(
`Hashing first ${MIN_CHUNK_SIZE ** 2 * printProgress} potential home planets...`
);
homePlanetFinder.on(MinerManagerEvent.DiscoveredNewChunk, (chunk: Chunk) => {
chunkStore.addChunk(chunk);
minedChunksCount++;
if (minedChunksCount % printProgress === 0) {
this.terminal.current?.println(
`Hashed ${minedChunksCount * MIN_CHUNK_SIZE ** 2} potential home planets...`
);
}
for (const homePlanetLocation of chunk.planetLocations) {
const planetPerlin = homePlanetLocation.perlin;
const planetX = homePlanetLocation.coords.x;
const planetY = homePlanetLocation.coords.y;
const planetLevel = this.entityStore.planetLevelFromHexPerlin(
homePlanetLocation.hash,
homePlanetLocation.perlin
);
const planetType = this.entityStore.planetTypeFromHexPerlin(
homePlanetLocation.hash,
homePlanetLocation.perlin
);
const planet = this.getPlanetWithId(homePlanetLocation.hash);
const distFromOrigin = Math.sqrt(planetX ** 2 + planetY ** 2);
if (
planetPerlin < initPerlinMax &&
planetPerlin >= initPerlinMin &&
distFromOrigin < this.worldRadius &&
distFromOrigin > spawnInnerRadius &&
planetLevel === MIN_PLANET_LEVEL &&
planetType === PlanetType.PLANET &&
(!planet || !planet.isInContract) // init will fail if planet has been initialized in contract already
) {
// valid home planet
homePlanetFinder.stopExplore();
homePlanetFinder.destroy();
const homePlanet = this.getGameObjects().getPlanetWithLocation(homePlanetLocation);
if (!homePlanet) {
reject(new Error("Unable to create default planet for your home planet's location."));
} else {
// can cast to `LocatablePlanet` because we know its location, as we just mined it.
resolve(homePlanet as LocatablePlanet);
}
break;
}
}
});
homePlanetFinder.startExplore();
});
}
public async prospectPlanet(
planetId: LocationId,
bypassChecks = false
): Promise> {
const planet = this.entityStore.getPlanetWithId(planetId);
try {
if (!planet || !isLocatable(planet)) {
throw new Error("you can't prospect a planet you haven't discovered");
}
if (!bypassChecks) {
if (this.checkGameHasEnded()) throw new Error('game ended');
if (!planet) {
throw new Error("you can't prospect a planet you haven't discovered");
}
if (planet.owner !== this.getAccount()) {
throw new Error("you can't prospect a planet you don't own");
}
if (!isLocatable(planet)) {
throw new Error("you don't know this planet's location");
}
if (planet.prospectedBlockNumber !== undefined) {
throw new Error('someone already prospected this planet');
}
if (planet.transactions?.hasTransaction(isUnconfirmedProspectPlanetTx)) {
throw new Error("you're already looking bro...");
}
if (planet.planetType !== PlanetType.RUINS) {
throw new Error("this planet doesn't have an artifact on it.");
}
}
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-prospectPlanet`, planetId);
const txIntent: UnconfirmedProspectPlanet = {
methodName: 'prospectPlanet',
contract: this.contractsAPI.contract,
planetId: planetId,
args: Promise.resolve([locationIdToDecStr(planetId)]),
};
const tx = await this.contractsAPI.submitTransaction(txIntent);
tx.confirmedPromise.then(() =>
NotificationManager.getInstance().artifactProspected(planet as LocatablePlanet)
);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('prospectPlanet', e.message);
throw e;
}
}
/**
* Calls the contract to find an artifact on the given planet.
*/
public async findArtifact(
planetId: LocationId,
bypassChecks = false
): Promise> {
const planet = this.entityStore.getPlanetWithId(planetId);
try {
if (!planet) {
throw new Error("you can't find artifacts on a planet you haven't discovered");
}
if (!isLocatable(planet)) {
throw new Error("you don't know the biome of this planet");
}
if (!bypassChecks) {
if (this.checkGameHasEnded()) {
throw new Error('game has ended');
}
if (planet.owner !== this.getAccount()) {
throw new Error("you can't find artifacts on planets you don't own");
}
if (planet.hasTriedFindingArtifact) {
throw new Error('someone already tried finding an artifact on this planet');
}
if (planet.transactions?.hasTransaction(isUnconfirmedFindArtifactTx)) {
throw new Error("you're already looking bro...");
}
if (planet.planetType !== PlanetType.RUINS) {
throw new Error("this planet doesn't have an artifact on it.");
}
}
// this is shitty. used for the popup window
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-findArtifactOnPlanet`, planetId);
const txIntent: UnconfirmedFindArtifact = {
methodName: 'findArtifact',
contract: this.contractsAPI.contract,
planetId: planet.locationId,
args: this.snarkHelper.getFindArtifactArgs(
planet.location.coords.x,
planet.location.coords.y
),
};
const tx = await this.contractsAPI.submitTransaction(txIntent);
tx.confirmedPromise
.then(() => {
return this.waitForPlanet(planet.locationId, ({ current }: Diff) => {
return current.heldArtifactIds
.map(this.getArtifactWithId.bind(this))
.find((a: Artifact) => a?.planetDiscoveredOn === planet.locationId) as Artifact;
}).then((foundArtifact) => {
if (!foundArtifact) throw new Error('Artifact not found?');
const notifManager = NotificationManager.getInstance();
notifManager.artifactFound(planet as LocatablePlanet, foundArtifact);
});
})
.catch(console.log);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('findArtifact', e.message);
throw e;
}
}
getContractConstants(): ContractConstants {
return this.contractConstants;
}
/**
* Submits a transaction to the blockchain to deposit an artifact on a given planet.
* You must own the planet and you must own the artifact directly (can't be locked in contract)
*/
public async depositArtifact(
locationId: LocationId,
artifactId: ArtifactId
): Promise> {
try {
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-depositPlanet`, locationId);
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-depositArtifact`, artifactId);
if (this.checkGameHasEnded()) {
const error = new Error('game has ended');
this.getNotificationsManager().txInitError('depositArtifact', error.message);
throw error;
}
const txIntent: UnconfirmedDepositArtifact = {
methodName: 'depositArtifact',
contract: this.contractsAPI.contract,
locationId,
artifactId,
args: Promise.resolve([locationIdToDecStr(locationId), artifactIdToDecStr(artifactId)]),
};
const tx = await this.contractsAPI.submitTransaction(txIntent);
tx.confirmedPromise.then(() =>
this.getGameObjects().updateArtifact(artifactId, (a) => (a.onPlanetId = locationId))
);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('depositArtifact', e.message);
throw e;
}
}
/**
* Withdraws the artifact that is locked up on the given planet.
*/
public async withdrawArtifact(
locationId: LocationId,
artifactId: ArtifactId,
bypassChecks = true
): Promise> {
try {
if (!bypassChecks) {
if (this.checkGameHasEnded()) {
throw new Error('game has ended');
}
const planet = this.entityStore.getPlanetWithId(locationId);
if (!planet) {
throw new Error('tried to withdraw from unknown planet');
}
if (!artifactId) {
throw new Error('must supply an artifact id');
}
}
// this is shitty. used for the popup window
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-withdrawPlanet`, locationId);
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-withdrawArtifact`, artifactId);
const txIntent: UnconfirmedWithdrawArtifact = {
methodName: 'withdrawArtifact',
contract: this.contractsAPI.contract,
args: Promise.resolve([locationIdToDecStr(locationId), artifactIdToDecStr(artifactId)]),
locationId,
artifactId,
};
this.terminal.current?.println(
'WITHDRAW_ARTIFACT: sending withdrawal to blockchain',
TerminalTextStyle.Sub
);
this.terminal.current?.newline();
const tx = await this.contractsAPI.submitTransaction(txIntent);
tx.confirmedPromise.then(() =>
this.getGameObjects().updateArtifact(artifactId, (a) => (a.onPlanetId = undefined))
);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('withdrawArtifact', e.message);
throw e;
}
}
public async activateArtifact(
locationId: LocationId,
artifactId: ArtifactId,
wormholeTo: LocationId | undefined,
bypassChecks = false
): Promise> {
try {
if (this.checkGameHasEnded()) {
throw new Error('game has ended');
}
if (!bypassChecks) {
const planet = this.entityStore.getPlanetWithId(locationId);
if (this.checkGameHasEnded()) {
throw new Error('game has ended');
}
if (!planet) {
throw new Error('tried to activate on an unknown planet');
}
if (!artifactId) {
throw new Error('must supply an artifact id');
}
}
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-activatePlanet`, locationId);
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-activateArtifact`, artifactId);
const txIntent: UnconfirmedActivateArtifact = {
methodName: 'activateArtifact',
contract: this.contractsAPI.contract,
args: Promise.resolve([
locationIdToDecStr(locationId),
artifactIdToDecStr(artifactId),
wormholeTo ? locationIdToDecStr(wormholeTo) : '0',
]),
locationId,
artifactId,
wormholeTo,
};
// Always await the submitTransaction so we can catch rejections
const tx = await this.contractsAPI.submitTransaction(txIntent);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('activateArtifact', e.message);
throw e;
}
}
public async deactivateArtifact(
locationId: LocationId,
artifactId: ArtifactId,
bypassChecks = false
): Promise> {
try {
if (!bypassChecks) {
const planet = this.entityStore.getPlanetWithId(locationId);
if (!planet) {
throw new Error('tried to deactivate on an unknown planet');
}
}
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-deactivatePlanet`, locationId);
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-deactivateArtifact`, artifactId);
const txIntent: UnconfirmedDeactivateArtifact = {
methodName: 'deactivateArtifact',
contract: this.contractsAPI.contract,
args: Promise.resolve([locationIdToDecStr(locationId)]),
locationId,
artifactId,
};
// Always await the submitTransaction so we can catch rejections
const tx = await this.contractsAPI.submitTransaction(txIntent);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('deactivateArtifact', e.message);
throw e;
}
}
public async withdrawSilver(
locationId: LocationId,
amount: number,
bypassChecks = false
): Promise> {
try {
if (!bypassChecks) {
if (!this.account) throw new Error('no account');
if (this.checkGameHasEnded()) {
throw new Error('game has ended');
}
const planet = this.entityStore.getPlanetWithId(locationId);
if (!planet) {
throw new Error('tried to withdraw silver from an unknown planet');
}
if (planet.planetType !== PlanetType.TRADING_POST) {
throw new Error('can only withdraw silver from spacetime rips');
}
if (planet.owner !== this.account) {
throw new Error('can only withdraw silver from a planet you own');
}
if (planet.transactions?.hasTransaction(isUnconfirmedWithdrawSilverTx)) {
throw new Error('a withdraw silver action is already in progress for this planet');
}
if (amount > planet.silver) {
throw new Error('not enough silver to withdraw!');
}
if (amount === 0) {
throw new Error('must withdraw more than 0 silver!');
}
if (planet.destroyed) {
throw new Error("can't withdraw silver from a destroyed planet");
}
}
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-withdrawSilverPlanet`, locationId);
const txIntent: UnconfirmedWithdrawSilver = {
methodName: 'withdrawSilver',
contract: this.contractsAPI.contract,
args: Promise.resolve([locationIdToDecStr(locationId), amount * CONTRACT_PRECISION]),
locationId,
amount,
};
// Always await the submitTransaction so we can catch rejections
const tx = await this.contractsAPI.submitTransaction(txIntent);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('withdrawSilver', e.message);
throw e;
}
}
/**
* We have two locations which planet state can live: on the server, and on the blockchain. We use
* the blockchain for the 'physics' of the universe, and the webserver for optional 'add-on'
* features, which are cryptographically secure, but live off-chain.
*
* This function loads the planet states which live on the server. Plays nicely with our
* notifications system and sets the appropriate loading state values on the planet.
*/
public async refreshServerPlanetStates(planetIds: LocationId[]) {
const planets = this.getPlanetsWithIds(planetIds);
planetIds.forEach((id) =>
this.getGameObjects().updatePlanet(id, (p) => {
p.loadingServerState = true;
})
);
const messages = await getMessagesOnPlanets({ planets: planetIds });
planets.forEach((planet) => {
const previousPlanetEmoji = getEmojiMessage(planet);
planet.messages = messages[planet.locationId];
const nowPlanetEmoji = getEmojiMessage(planet);
// an emoji was added
if (previousPlanetEmoji === undefined && nowPlanetEmoji !== undefined) {
planet.emojiZoopAnimation = easeInAnimation(2000);
// an emoji was removed
} else if (nowPlanetEmoji === undefined && previousPlanetEmoji !== undefined) {
planet.emojiZoopAnimation = undefined;
planet.emojiZoopOutAnimation = emojiEaseOutAnimation(3000, previousPlanetEmoji.body.emoji);
}
});
planetIds.forEach((id) =>
this.getGameObjects().updatePlanet(id, (p) => {
p.loadingServerState = false;
p.needsServerRefresh = false;
})
);
}
/**
* If you are the owner of this planet, you can set an 'emoji' to hover above the planet.
* `emojiStr` must be a string that contains a single emoji, otherwise this function will throw an
* error.
*
* The emoji is stored off-chain in a postgres database. We verify planet ownership via a contract
* call from the webserver, and by verifying that the request to add (or remove) an emoji from a
* planet was signed by the owner.
*/
public setPlanetEmoji(locationId: LocationId, emojiStr: string) {
return this.submitPlanetMessage(locationId, PlanetMessageType.EmojiFlag, {
emoji: emojiStr,
});
}
/**
* If you are the owner of this planet, you can delete the emoji that is hovering above the
* planet.
*/
public async clearEmoji(locationId: LocationId) {
if (this.account === undefined) {
throw new Error("can't clear emoji: not logged in");
}
if (this.getPlanetWithId(locationId)?.unconfirmedClearEmoji) {
throw new Error(`can't clear emoji: alreading clearing emoji from ${locationId}`);
}
this.getGameObjects().updatePlanet(locationId, (p) => {
p.unconfirmedClearEmoji = true;
});
const request = await this.ethConnection.signMessageObject({
locationId,
ids: this.getPlanetWithId(locationId)?.messages?.map((m) => m.id) || [],
});
try {
await deleteMessages(request);
} catch (e) {
throw e;
} finally {
this.getGameObjects().updatePlanet(locationId, (p) => {
p.needsServerRefresh = true;
p.unconfirmedClearEmoji = false;
});
}
await this.refreshServerPlanetStates([locationId]);
}
public async submitDisconnectTwitter(twitter: string) {
await disconnectTwitter(await this.ethConnection.signMessageObject({ twitter }));
await this.refreshTwitters();
}
/**
* The planet emoji feature is built on top of a more general 'Planet Message' system, which
* allows players to upload pieces of data called 'Message's to planets that they own. Emojis are
* just one type of message. Their implementation leaves the door open to more off-chain data.
*/
private async submitPlanetMessage(
locationId: LocationId,
type: PlanetMessageType,
body: unknown
) {
if (this.account === undefined) {
throw new Error("can't submit planet message not logged in");
}
if (this.getPlanetWithId(locationId)?.unconfirmedAddEmoji) {
throw new Error(`can't submit planet message: already submitting for planet ${locationId}`);
}
this.getGameObjects().updatePlanet(locationId, (p) => {
p.unconfirmedAddEmoji = true;
});
const request = await this.ethConnection.signMessageObject({
locationId,
sender: this.account,
type,
body,
});
try {
await addMessage(request);
} catch (e) {
throw e;
} finally {
this.getGameObjects().updatePlanet(locationId, (p) => {
p.unconfirmedAddEmoji = false;
p.needsServerRefresh = true;
});
}
await this.refreshServerPlanetStates([locationId]);
}
/**
* Checks that a message signed by {@link GameManager#signMessage} was signed by the address that
* it claims it was signed by.
*/
private async verifyMessage(message: SignedMessage): Promise {
const preSigned = JSON.stringify(message.message);
return verifySignature(preSigned, message.signature as string, message.sender);
}
/**
* Submits a transaction to the blockchain to move the given amount of resources from
* the given planet to the given planet.
*/
public async move(
from: LocationId,
to: LocationId,
forces: number,
silver: number,
artifactMoved?: ArtifactId,
abandoning = false,
bypassChecks = false
): Promise> {
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-fromPlanet`, from);
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-toPlanet`, to);
try {
if (!bypassChecks && this.checkGameHasEnded()) {
throw new Error('game has ended');
}
const arrivalsToOriginPlanet = this.entityStore.getArrivalIdsForLocation(from);
const hasIncomingVoyage = arrivalsToOriginPlanet && arrivalsToOriginPlanet.length > 0;
if (abandoning && hasIncomingVoyage) {
throw new Error('cannot abandon a planet that has incoming voyages');
}
const oldLocation = this.entityStore.getLocationOfPlanet(from);
const newLocation = this.entityStore.getLocationOfPlanet(to);
if (!oldLocation) {
throw new Error('tried to move from planet that does not exist');
}
if (!newLocation) {
throw new Error('tried to move from planet that does not exist');
}
const oldX = oldLocation.coords.x;
const oldY = oldLocation.coords.y;
const newX = newLocation.coords.x;
const newY = newLocation.coords.y;
const xDiff = newX - oldX;
const yDiff = newY - oldY;
const distMax = Math.ceil(Math.sqrt(xDiff ** 2 + yDiff ** 2));
// Contract will automatically send full forces/silver on abandon
const shipsMoved = !abandoning ? forces : 0;
const silverMoved = !abandoning ? silver : 0;
if (newX ** 2 + newY ** 2 >= this.worldRadius ** 2) {
throw new Error('attempted to move out of bounds');
}
const oldPlanet = this.entityStore.getPlanetWithLocation(oldLocation);
if (
((!bypassChecks && !this.account) || !oldPlanet || oldPlanet.owner !== this.account) &&
!isSpaceShip(this.getArtifactWithId(artifactMoved)?.artifactType)
) {
throw new Error('attempted to move from a planet not owned by player');
}
const getArgs = async (): Promise => {
const snarkArgs = await this.snarkHelper.getMoveArgs(
oldX,
oldY,
newX,
newY,
this.worldRadius,
distMax
);
const args: MoveArgs = [
snarkArgs[ZKArgIdx.PROOF_A],
snarkArgs[ZKArgIdx.PROOF_B],
snarkArgs[ZKArgIdx.PROOF_C],
[
...snarkArgs[ZKArgIdx.DATA],
(shipsMoved * CONTRACT_PRECISION).toString(),
(silverMoved * CONTRACT_PRECISION).toString(),
'0',
abandoning ? '1' : '0',
],
] as MoveArgs;
this.terminal.current?.println('MOVE: calculated SNARK with args:', TerminalTextStyle.Sub);
this.terminal.current?.println(
JSON.stringify(hexifyBigIntNestedArray(args)),
TerminalTextStyle.Sub
);
this.terminal.current?.newline();
if (artifactMoved) {
args[ZKArgIdx.DATA][MoveArgIdxs.ARTIFACT_SENT] = artifactIdToDecStr(artifactMoved);
}
return args;
};
const txIntent: UnconfirmedMove = {
methodName: 'move',
contract: this.contractsAPI.contract,
args: getArgs(),
from: oldLocation.hash,
to: newLocation.hash,
forces: shipsMoved,
silver: silverMoved,
artifact: artifactMoved,
abandoning,
};
if (artifactMoved) {
const artifact = this.entityStore.getArtifactById(artifactMoved);
if (!bypassChecks) {
if (!artifact) {
throw new Error("couldn't find this artifact");
}
if (isActivated(artifact)) {
throw new Error("can't move an activated artifact");
}
if (!oldPlanet?.heldArtifactIds?.includes(artifactMoved)) {
throw new Error("that artifact isn't on this planet!");
}
}
}
// Always await the submitTransaction so we can catch rejections
const tx = await this.contractsAPI.submitTransaction(txIntent);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('move', e.message);
throw e;
}
}
/**
* Submits a transaction to the blockchain to upgrade the given planet with the given
* upgrade branch. You must own the planet, and have enough silver on it to complete
* the upgrade.
*/
public async upgrade(
planetId: LocationId,
branch: number,
_bypassChecks = false
): Promise> {
try {
// this is shitty
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-upPlanet`, planetId);
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-branch`, branch.toString());
const txIntent: UnconfirmedUpgrade = {
methodName: 'upgradePlanet',
contract: this.contractsAPI.contract,
args: Promise.resolve([locationIdToDecStr(planetId), branch.toString()]),
locationId: planetId,
upgradeBranch: branch,
};
// Always await the submitTransaction so we can catch rejections
const tx = await this.contractsAPI.submitTransaction(txIntent);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('upgradePlanet', e.message);
throw e;
}
}
/**
* Submits a transaction to the blockchain to buy a hat for the given planet. You must own the
* planet. Warning costs real xdai. Hats are permanently locked to a planet. They are purely
* cosmetic and a great way to BM your opponents or just look your best. Just like in the real
* world, more money means more hat.
*/
public async buyHat(
planetId: LocationId,
_bypassChecks = false
): Promise> {
const planetLoc = this.entityStore.getLocationOfPlanet(planetId);
const planet = this.entityStore.getPlanetWithLocation(planetLoc);
try {
if (!planetLoc) {
console.error('planet not found');
throw new Error('[TX ERROR] Planet not found');
}
if (!planet) {
console.error('planet not found');
throw new Error('[TX ERROR] Planet not found');
}
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-hatPlanet`, planetId);
localStorage.setItem(
`${this.getAccount()?.toLowerCase()}-hatLevel`,
planet.hatLevel.toString()
);
const txIntent: UnconfirmedBuyHat = {
methodName: 'buyHat',
contract: this.contractsAPI.contract,
args: Promise.resolve([locationIdToDecStr(planetId)]),
locationId: planetId,
};
// Always await the submitTransaction so we can catch rejections
const tx = await this.contractsAPI.submitTransaction(txIntent, {
gasLimit: 500000,
value: bigInt(1000000000000000000)
.multiply(2 ** planet.hatLevel)
.toString(),
});
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('buyHat', e.message);
throw e;
}
}
// TODO: Change this to transferPlanet in a breaking release
public async transferOwnership(
planetId: LocationId,
newOwner: EthAddress,
bypassChecks = false
): Promise> {
try {
if (!bypassChecks) {
if (this.checkGameHasEnded()) {
throw new Error('game has ended');
}
const planetLoc = this.entityStore.getLocationOfPlanet(planetId);
if (!planetLoc) {
console.error('planet not found');
throw new Error('[TX ERROR] Planet not found');
}
const planet = this.entityStore.getPlanetWithLocation(planetLoc);
if (!planet) {
console.error('planet not found');
throw new Error('[TX ERROR] Planet not found');
}
}
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-transferPlanet`, planetId);
localStorage.setItem(`${this.getAccount()?.toLowerCase()}-transferOwner`, newOwner);
const txIntent: UnconfirmedPlanetTransfer = {
methodName: 'transferPlanet',
contract: this.contractsAPI.contract,
args: Promise.resolve([locationIdToDecStr(planetId), newOwner]),
planetId,
newOwner,
};
// Always await the submitTransaction so we can catch rejections
const tx = await this.contractsAPI.submitTransaction(txIntent);
return tx;
} catch (e) {
this.getNotificationsManager().txInitError('transferPlanet', e.message);
throw e;
}
}
/**
* Makes this game manager aware of a new chunk - which includes its location, size,
* as well as all of the planets contained in that chunk. Causes the client to load
* all of the information about those planets from the blockchain.
*/
addNewChunk(chunk: Chunk): GameManager {
this.persistentChunkStore.addChunk(chunk, true);
for (const planetLocation of chunk.planetLocations) {
this.entityStore.addPlanetLocation(planetLocation);
if (this.entityStore.isPlanetInContract(planetLocation.hash)) {
this.hardRefreshPlanet(planetLocation.hash); // don't need to await, just start the process of hard refreshing
}
}
return this;
}
listenForNewBlock() {
this.getEthConnection().blockNumber$.subscribe((blockNumber) => {
if (this.captureZoneGenerator) {
this.captureZoneGenerator.generate(blockNumber);
}
});
}
/**
* To add multiple chunks at once, use this function rather than `addNewChunk`, in order
* to load all of the associated planet data in an efficient manner.
*/
async bulkAddNewChunks(chunks: Chunk[]): Promise {
this.terminal.current?.println(
'IMPORTING MAP: if you are importing a large map, this may take a while...'
);
const planetIdsToUpdate: LocationId[] = [];
for (const chunk of chunks) {
this.persistentChunkStore.addChunk(chunk, true);
for (const planetLocation of chunk.planetLocations) {
this.entityStore.addPlanetLocation(planetLocation);
if (this.entityStore.isPlanetInContract(planetLocation.hash)) {
// Await this so we don't crash the game
planetIdsToUpdate.push(planetLocation.hash);
}
}
}
this.terminal.current?.println(
`downloading data for ${planetIdsToUpdate.length} planets...`,
TerminalTextStyle.Sub
);
this.bulkHardRefreshPlanets(planetIdsToUpdate);
}
// utils - scripting only
/**
* Gets the maximuim distance that you can send your energy from the given planet,
* using the given percentage of that planet's current silver.
*/
getMaxMoveDist(planetId: LocationId, sendingPercent: number, abandoning: boolean): number {
const planet = this.getPlanetWithId(planetId);
if (!planet) throw new Error('origin planet unknown');
return getRange(planet, sendingPercent, this.getRangeBuff(abandoning));
}
/**
* Gets the distance between two planets. Throws an exception if you don't
* know the location of either planet. Takes into account wormholes.
*/
getDist(fromId: LocationId, toId: LocationId): number {
const from = this.entityStore.getPlanetWithId(fromId);
const to = this.entityStore.getPlanetWithId(toId);
if (!from) throw new Error('origin planet unknown');
if (!to) throw new Error('destination planet unknown');
if (!isLocatable(from)) throw new Error('origin location unknown');
if (!isLocatable(to)) throw new Error('destination location unknown');
const wormholeFactors = this.getWormholeFactors(from, to);
let distance = this.getDistCoords(from.location.coords, to.location.coords);
if (wormholeFactors) {
distance /= wormholeFactors.distanceFactor;
}
return distance;
}
/**
* Gets the distance between two coordinates in space.
*/
getDistCoords(fromCoords: WorldCoords, toCoords: WorldCoords) {
return Math.sqrt((fromCoords.x - toCoords.x) ** 2 + (fromCoords.y - toCoords.y) ** 2);
}
/**
* Gets all the planets that you can reach with at least 1 energy from
* the given planet. Does not take into account wormholes.
*/
getPlanetsInRange(planetId: LocationId, sendingPercent: number, abandoning: boolean): Planet[] {
const planet = this.entityStore.getPlanetWithId(planetId);
if (!planet) throw new Error('planet unknown');
if (!isLocatable(planet)) throw new Error('planet location unknown');
// Performance improvements originally suggested by [@modokon](https://github.com/modukon)
// at https://github.com/darkforest-eth/client/issues/15
// Improved by using `planetMap` by [@phated](https://github.com/phated)
const result = [];
const range = getRange(planet, sendingPercent, this.getRangeBuff(abandoning));
for (const p of this.getPlanetMap().values()) {
if (isLocatable(p)) {
if (this.getDistCoords(planet.location.coords, p.location.coords) < range) {
result.push(p);
}
}
}
return result;
}
/**
* Gets the amount of energy needed in order for a voyage from the given to the given
* planet to arrive with your desired amount of energy.
*/
getEnergyNeededForMove(
fromId: LocationId,
toId: LocationId,
arrivingEnergy: number,
abandoning = false
): number {
const from = this.getPlanetWithId(fromId);
if (!from) throw new Error('origin planet unknown');
const dist = this.getDist(fromId, toId);
const range = from.range * this.getRangeBuff(abandoning);
const rangeSteps = dist / range;
const arrivingProp = arrivingEnergy / from.energyCap + 0.05;
return arrivingProp * Math.pow(2, rangeSteps) * from.energyCap;
}
/**
* Gets the amount of energy that would arrive if a voyage with the given parameters
* was to occur. The toPlanet is optional, in case you want an estimate that doesn't include
* wormhole speedups.
*/
getEnergyArrivingForMove(
fromId: LocationId,
toId: LocationId | undefined,
distance: number | undefined,
sentEnergy: number,
abandoning: boolean
) {
const from = this.getPlanetWithId(fromId);
const to = this.getPlanetWithId(toId);
if (!from) throw new Error(`unknown planet`);
if (distance === undefined && toId === undefined)
throw new Error(`you must provide either a target planet or a distance`);
const dist = (toId && this.getDist(fromId, toId)) || (distance as number);
if (to && toId) {
const wormholeFactors = this.getWormholeFactors(from, to);
if (wormholeFactors !== undefined) {
if (to.owner !== from.owner) {
return 0;
}
}
}
const range = from.range * this.getRangeBuff(abandoning);
const scale = (1 / 2) ** (dist / range);
let ret = scale * sentEnergy - 0.05 * from.energyCap;
if (ret < 0) ret = 0;
return ret;
}
/**
* Gets the active artifact on this planet, if one exists.
*/
getActiveArtifact(planet: Planet): Artifact | undefined {
const artifacts = this.getArtifactsWithIds(planet.heldArtifactIds);
const active = artifacts.find((a) => a && isActivated(a));
return active;
}
/**
* If there's an active artifact on either of these planets which happens to be a wormhole which
* is active and targetting the other planet, return the wormhole boost which is greater. Values
* represent a multiplier.
*/
getWormholeFactors(
fromPlanet: Planet,
toPlanet: Planet
): { distanceFactor: number; speedFactor: number } | undefined {
const fromActiveArtifact = this.getActiveArtifact(fromPlanet);
const toActiveArtifact = this.getActiveArtifact(toPlanet);
let greaterRarity: ArtifactRarity | undefined;
if (
fromActiveArtifact?.artifactType === ArtifactType.Wormhole &&
fromActiveArtifact.wormholeTo === toPlanet.locationId
) {
greaterRarity = fromActiveArtifact.rarity;
}
if (
toActiveArtifact?.artifactType === ArtifactType.Wormhole &&
toActiveArtifact.wormholeTo === fromPlanet.locationId
) {
if (greaterRarity === undefined) {
greaterRarity = toActiveArtifact.rarity;
} else {
greaterRarity = Math.max(greaterRarity, toActiveArtifact.rarity) as ArtifactRarity;
}
}
const rangeUpgradesPerRarity = [0, 2, 4, 6, 8, 10];
const speedUpgradesPerRarity = [0, 10, 20, 30, 40, 50];
if (!greaterRarity || greaterRarity <= ArtifactRarity.Unknown) {
return undefined;
}
return {
distanceFactor: rangeUpgradesPerRarity[greaterRarity],
speedFactor: speedUpgradesPerRarity[greaterRarity],
};
}
/**
* Gets the amount of time, in seconds that a voyage between from the first to the
* second planet would take.
*/
getTimeForMove(fromId: LocationId, toId: LocationId, abandoning = false): number {
const from = this.getPlanetWithId(fromId);
if (!from) throw new Error('origin planet unknown');
const dist = this.getDist(fromId, toId);
const speed = from.speed * this.getSpeedBuff(abandoning);
return dist / (speed / 100);
}
/**
* Gets the temperature of a given location.
*/
getTemperature(coords: WorldCoords): number {
const p = this.spaceTypePerlin(coords, false);
return (16 - p) * 16;
}
/**
* Load the serialized versions of all the plugins that this player has.
*/
public async loadPlugins(): Promise {
return this.persistentChunkStore.loadPlugins();
}
/**
* Overwrites all the saved plugins to equal the given array of plugins.
*/
public async savePlugins(savedPlugins: SerializedPlugin[]): Promise {
await this.persistentChunkStore.savePlugins(savedPlugins);
}
/**
* Whether or not the given planet is capable of minting an artifact.
*/
public isPlanetMineable(p: Planet): boolean {
return p.planetType === PlanetType.RUINS;
}
/**
* Returns constructors of classes that may be useful for developing plugins.
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
public getConstructors() {
return {
MinerManager,
SpiralPattern,
SwissCheesePattern,
TowardsCenterPattern,
TowardsCenterPatternV2,
};
}
/**
* Gets the perlin value at the given location in the world. SpaceType is based
* on this value.
*/
public spaceTypePerlin(coords: WorldCoords, floor: boolean): number {
return perlin(coords, {
key: this.hashConfig.spaceTypeKey,
scale: this.hashConfig.perlinLengthScale,
mirrorX: this.hashConfig.perlinMirrorX,
mirrorY: this.hashConfig.perlinMirrorY,
floor,
});
}
/**
* Gets the biome perlin valie at the given location in the world.
*/
public biomebasePerlin(coords: WorldCoords, floor: boolean): number {
return perlin(coords, {
key: this.hashConfig.biomebaseKey,
scale: this.hashConfig.perlinLengthScale,
mirrorX: this.hashConfig.perlinMirrorX,
mirrorY: this.hashConfig.perlinMirrorY,
floor,
});
}
public locationBigIntFromCoords(coords: WorldCoords): BigInteger {
return this.planetHashMimc(coords.x, coords.y);
}
/**
* Helpful for listening to user input events.
*/
public getUIEventEmitter() {
return UIEmitter.getInstance();
}
public getCaptureZoneGenerator() {
return this.captureZoneGenerator;
}
/**
* Emits when new capture zones are generated.
*/
public get captureZoneGeneratedEmitter(): Monomitter | undefined {
return this.captureZoneGenerator?.generated$;
}
public getNotificationsManager() {
return NotificationManager.getInstance();
}
getWormholes(): Iterable {
return this.entityStore.getWormholes();
}
/** Return a reference to the planet map */
public getPlanetMap(): Map {
return this.entityStore.getPlanetMap();
}
/** Return a reference to the artifact map */
public getArtifactMap(): Map {
return this.entityStore.getArtifactMap();
}
/** Return a reference to the map of my planets */
public getMyPlanetMap(): Map {
return this.entityStore.getMyPlanetMap();
}
/** Return a reference to the map of my artifacts */
public getMyArtifactMap(): Map {
return this.entityStore.getMyArtifactMap();
}
public getPlanetUpdated$(): Monomitter {
return this.entityStore.planetUpdated$;
}
public getArtifactUpdated$(): Monomitter {
return this.entityStore.artifactUpdated$;
}
public getMyPlanetsUpdated$(): Monomitter> {
return this.entityStore.myPlanetsUpdated$;
}
public getMyArtifactsUpdated$(): Monomitter> {
return this.entityStore.myArtifactsUpdated$;
}
/**
* Returns an instance of a `Contract` from the ethersjs library. This is the library we use to
* connect to the blockchain. For documentation about how `Contract` works, see:
* https://docs.ethers.io/v5/api/contract/contract/
*
* Also, registers your contract in the system to make calls against it and to reload it when
* necessary (such as the RPC endpoint changing).
*/
public loadContract(
contractAddress: string,
contractABI: ContractInterface
): Promise {
return this.ethConnection.loadContract(contractAddress, async (address, provider, signer) =>
createContract(address, contractABI, provider, signer)
);
}
public testNotification() {
NotificationManager.getInstance().reallyLongNotification();
}
/**
* Gets a reference to the game's internal representation of the world state. This includes
* voyages, planets, artifacts, and active wormholes,
*/
public getGameObjects(): GameObjects {
return this.entityStore;
}
public forceTick(locationId: LocationId) {
this.getGameObjects().forceTick(locationId);
}
/**
* Gets some diagnostic information about the game. Returns a copy, you can't modify it.
*/
public getDiagnostics(): Diagnostics {
return { ...this.diagnostics };
}
/**
* Updates the diagnostic info of the game using the supplied function. Ideally, each spot in the
* codebase that would like to record a metric is able to update its specific metric in a
* convenient manner.
*/
public updateDiagnostics(updateFn: (d: Diagnostics) => void): void {
updateFn(this.diagnostics);
}
/**
* Listen for changes to a planet take action,
* eg.
* waitForPlanet("yourAsteroidId", ({current}) => current.silverCap / current.silver > 90)
* .then(() => {
* // Send Silver to nearby planet
* })
*
* @param locationId A locationId to watch for updates
* @param predicate a function that accepts a Diff and should return a truth-y value, value will be passed to promise.resolve()
* @returns a promise that will resolve with results returned from the predicate function
*/
public waitForPlanet(
locationId: LocationId,
predicate: ({ current, previous }: Diff) => T | undefined
): Promise {
const disposableEmitter = getDisposableEmitter(
this.getPlanetMap(),
locationId,
this.getPlanetUpdated$()
);
const diffEmitter = generateDiffEmitter(disposableEmitter);
return new Promise((resolve, reject) => {
diffEmitter.subscribe(({ current, previous }: Diff) => {
try {
const predicateResults = predicate({ current, previous });
if (!!predicateResults) {
disposableEmitter.clear();
diffEmitter.clear();
resolve(predicateResults);
}
} catch (err) {
disposableEmitter.clear();
diffEmitter.clear();
reject(err);
}
});
});
}
public getSafeMode() {
return this.safeMode;
}
public setSafeMode(safeMode: boolean) {
this.safeMode = safeMode;
}
public getAddress() {
return this.ethConnection.getAddress();
}
public isAdmin(): boolean {
return this.getAddress() === this.contractConstants.adminAddress;
}
/**
* Right now the only buffs supported in this way are
* speed/range buffs from Abandoning a planet.
*
* The abandoning argument is used when interacting with
* this function programmatically.
*/
public getSpeedBuff(abandoning: boolean): number {
const { SPACE_JUNK_ENABLED, ABANDON_SPEED_CHANGE_PERCENT } = this.contractConstants;
if (SPACE_JUNK_ENABLED && abandoning) {
return ABANDON_SPEED_CHANGE_PERCENT / 100;
}
return 1;
}
public getRangeBuff(abandoning: boolean): number {
const { SPACE_JUNK_ENABLED, ABANDON_RANGE_CHANGE_PERCENT } = this.contractConstants;
if (SPACE_JUNK_ENABLED && abandoning) {
return ABANDON_RANGE_CHANGE_PERCENT / 100;
}
return 1;
}
public getSnarkHelper(): SnarkArgsHelper {
return this.snarkHelper;
}
public async submitTransaction(
txIntent: T,
overrides?: providers.TransactionRequest
): Promise> {
return this.contractsAPI.submitTransaction(txIntent, overrides);
}
public getContract(): DarkForest {
return this.contractsAPI.contract;
}
public getPaused(): boolean {
return this.paused;
}
public getPaused$(): Monomitter {
return this.paused$;
}
}
export default GameManager;
================================================
FILE: src/Backend/GameLogic/GameObjects.ts
================================================
import { EMPTY_ADDRESS, MAX_PLANET_LEVEL, MIN_PLANET_LEVEL } from '@darkforest_eth/constants';
import { Monomitter, monomitter } from '@darkforest_eth/events';
import { hasOwner, isActivated, isLocatable } from '@darkforest_eth/gamelogic';
import { bonusFromHex, getBytesFromHex } from '@darkforest_eth/hexgen';
import { TxCollection } from '@darkforest_eth/network';
import {
isUnconfirmedActivateArtifact,
isUnconfirmedActivateArtifactTx,
isUnconfirmedBuyHat,
isUnconfirmedBuyHatTx,
isUnconfirmedCapturePlanetTx,
isUnconfirmedDeactivateArtifact,
isUnconfirmedDeactivateArtifactTx,
isUnconfirmedDepositArtifact,
isUnconfirmedDepositArtifactTx,
isUnconfirmedFindArtifact,
isUnconfirmedFindArtifactTx,
isUnconfirmedGetShipsTx,
isUnconfirmedInvadePlanetTx,
isUnconfirmedMove,
isUnconfirmedMoveTx,
isUnconfirmedProspectPlanet,
isUnconfirmedProspectPlanetTx,
isUnconfirmedReveal,
isUnconfirmedRevealTx,
isUnconfirmedTransfer,
isUnconfirmedTransferTx,
isUnconfirmedUpgrade,
isUnconfirmedUpgradeTx,
isUnconfirmedWithdrawArtifact,
isUnconfirmedWithdrawArtifactTx,
isUnconfirmedWithdrawSilver,
isUnconfirmedWithdrawSilverTx,
} from '@darkforest_eth/serde';
import {
Abstract,
ArrivalWithTimer,
Artifact,
ArtifactId,
ArtifactType,
Biome,
Chunk,
ClaimedLocation,
EthAddress,
LocatablePlanet,
LocationId,
Planet,
PlanetLevel,
PlanetType,
QueuedArrival,
Radii,
RevealedLocation,
SpaceType,
Transaction,
TransactionCollection,
VoyageId,
WorldCoords,
WorldLocation,
Wormhole,
} from '@darkforest_eth/types';
import autoBind from 'auto-bind';
import bigInt from 'big-integer';
import { ethers } from 'ethers';
import _ from 'lodash';
import NotificationManager from '../../Frontend/Game/NotificationManager';
import {
getArtifactId,
getArtifactOwner,
getPlanetId,
getPlanetOwner,
setObjectSyncState,
} from '../../Frontend/Utils/EmitterUtils';
import { ContractConstants } from '../../_types/darkforest/api/ContractsAPITypes';
import { arrive, PlanetDiff, updatePlanetToTime } from './ArrivalUtils';
import { LayeredMap } from './LayeredMap';
type CoordsString = Abstract;
const getCoordsString = (coords: WorldCoords): CoordsString => {
return `${coords.x},${coords.y}` as CoordsString;
};
/**
* Representation of the objects which exist in the world.
*/
export class GameObjects {
/**
* This is a data structure that allows us to efficiently calculate which planets are visible on
* the player's screen given the viewport's position and size.
*/
private readonly layeredMap: LayeredMap;
/**
* This address of the player that is currently logged in.
*
* @todo move this, along with all other objects relating to the currently logged-on player into a
* new field: {@code player: PlayerInfo}
*/
private readonly address: EthAddress | undefined;
/**
* Cached index of all known planet data.
*
* Warning!
*
* This should NEVER be set to directly! Any time you want to update a planet, you must call the
* {@link GameObjects#setPlanet()} function. Following this rule enables us to reliably notify
* other parts of the client when a particular object has been updated. TODO: what is the best way
* to do this?
*
* @todo extract the pattern we're using for the field tuples
* - {planets, myPlanets, myPlanetsUpdated, planetUpdated$}
* - {artifacts, myArtifacts, myArtifactsUpdated, artifactUpdated$}
*
* into some sort of class.
*/
private readonly planets: Map;
/**
* Cached index of planets owned by the player.
*
* @see The same warning applys as the one on {@link GameObjects.planets}
*/
private readonly myPlanets: Map;
/**
* Cached index of all known artifact data.
*
* @see The same warning applys as the one on {@link GameObjects.planets}
*/
private readonly artifacts: Map;
/**
* Cached index of artifacts owned by the player.
*
* @see The same warning applys as the one on {@link GameObjects.planets}
*/
private readonly myArtifacts: Map;
/**
* Map from artifact ids to wormholes.
*/
private readonly wormholes: Map;
/**
* Set of all planet ids that we know have been interacted-with on-chain.
*/
private readonly touchedPlanetIds: Set;
/**
* Map of arrivals to timers that fire when an arrival arrives, in case that handler needs to be
* cancelled for whatever reason.
*/
private readonly arrivals: Map;
/**
* Map from a location id (think of it as the unique id of each planet) to all the ids of the
* voyages that are arriving on that planet. These include both the player's own voyages, and also
* any potential invader's voyages.
*/
private readonly planetArrivalIds: Map;
/**
* Map from location id (unique id of each planet) to some information about the location at which
* this planet is located, if this client happens to know the coordinates of this planet.
*/
private readonly planetLocationMap: Map;
/**
* Map from location ids to, if that location id has been revealed on-chain, the world coordinates
* of that location id, as well as some extra information regarding the circumstances of the
* revealing of this planet.
*/
private readonly revealedLocations: Map;
/**
* Map from location ids to, if that location id has been claimed on-chain, the world coordinates
* of that location id, as well as some extra information regarding the circumstances of the
* revealing of this planet.
*/
private readonly claimedLocations: Map;
/**
* Some of the game's parameters are downloaded from the blockchain. This allows the client to be
* flexible, and connect to any compatible set of Dark Forest contracts, download the parameters,
* and join the game, taking into account the unique configuration of those specific Dark Forest
* contracts.
*/
private readonly contractConstants: ContractConstants;
/**
* Map from a stringified representation of an x-y coordinate to an object that contains some more
* information about the world at that location.
*/
private readonly coordsToLocation: Map;
/**
* Transactions that are currently in flight.
*/
public readonly transactions: TransactionCollection;
/**
* Event emitter which publishes whenever a planet is updated.
*/
public readonly planetUpdated$: Monomitter;
/**
* Event emitter which publishes whenever an artifact has been updated.
*/
public readonly artifactUpdated$: Monomitter;
/**
* Whenever a planet is updated, we publish to this event with a reference to a map from location
* id to planet. We need to rethink this event emitter because it currently publishes every time
* that any planet is updated, and if a lot of them are updated at once (which i think is the case
* once every two minutes) then this event emitter will publish a shitton of events.
* TODO: rethink this
*/
public readonly myPlanetsUpdated$: Monomitter>;
/**
* Whenever one of the player's artifacts are updated, this event emitter publishes. See
* {@link GameObjects.myPlanetsUpdated$} for more info.
*/
public readonly myArtifactsUpdated$: Monomitter>;
constructor(
address: EthAddress | undefined,
touchedPlanets: Map,
allTouchedPlanetIds: Set,
revealedLocations: Map,
claimedLocations: Map,
artifacts: Map,
allChunks: Iterable,
unprocessedArrivals: Map,
unprocessedPlanetArrivalIds: Map,
contractConstants: ContractConstants,
worldRadius: number
) {
autoBind(this);
this.address = address;
this.planets = touchedPlanets;
this.myPlanets = new Map();
this.touchedPlanetIds = allTouchedPlanetIds;
this.revealedLocations = revealedLocations;
this.claimedLocations = claimedLocations;
this.artifacts = artifacts;
this.myArtifacts = new Map();
this.contractConstants = contractConstants;
this.coordsToLocation = new Map();
this.planetLocationMap = new Map();
const planetArrivalIds = new Map();
const arrivals = new Map();
this.transactions = new TxCollection();
this.wormholes = new Map();
this.layeredMap = new LayeredMap(worldRadius);
this.planetUpdated$ = monomitter();
this.artifactUpdated$ = monomitter();
this.myArtifactsUpdated$ = monomitter();
this.myPlanetsUpdated$ = monomitter();
for (const chunk of allChunks) {
for (const planetLocation of chunk.planetLocations) {
this.addPlanetLocation(planetLocation);
}
}
for (const location of revealedLocations.values()) {
this.markLocationRevealed(location);
this.addPlanetLocation(location);
}
this.replaceArtifactsFromContractData(artifacts.values());
touchedPlanets.forEach((planet, planetId) => {
const arrivalIds = unprocessedPlanetArrivalIds.get(planetId);
if (planet && arrivalIds) {
const arrivalsForPlanetNull: (QueuedArrival | undefined)[] = arrivalIds.map((arrivalId) =>
unprocessedArrivals.get(arrivalId)
);
const arrivalsForPlanet: QueuedArrival[] = arrivalsForPlanetNull.filter(
(x) => !!x
) as QueuedArrival[];
const revealedLocation = revealedLocations.get(planetId);
if (revealedLocation) {
planet.coordsRevealed = true;
planet.revealer = revealedLocation.revealer;
}
const arrivalsWithTimers = this.processArrivalsForPlanet(
planet.locationId,
arrivalsForPlanet
);
planetArrivalIds.set(
planetId,
arrivalsWithTimers.map((arrival) => arrival.arrivalData.eventId)
);
for (const arrivalWithTimer of arrivalsWithTimers) {
const arrivalId = arrivalWithTimer.arrivalData.eventId;
arrivals.set(arrivalId, arrivalWithTimer);
}
const planetLocation = this.planetLocationMap.get(planetId);
if (planet && planetLocation) {
(planet as LocatablePlanet).location = planetLocation;
(planet as LocatablePlanet).biome = this.getBiome(planetLocation);
}
this.setPlanet(planet);
}
});
this.arrivals = arrivals;
this.planetArrivalIds = planetArrivalIds;
for (const [_locId, claimedLoc] of claimedLocations) {
this.updatePlanet(claimedLoc.hash, (p) => {
p.claimer = claimedLoc.revealer;
});
}
// TODO: do this better...
// set interval to update all planets every 120s
setInterval(() => {
this.planets.forEach((planet) => {
if (planet && hasOwner(planet)) {
updatePlanetToTime(
planet,
this.getPlanetArtifacts(planet.locationId),
Date.now(),
this.contractConstants
);
}
});
}, 120 * 1000);
}
public getWormholes(): Iterable {
return this.wormholes.values();
}
public getArtifactById(artifactId?: ArtifactId): Artifact | undefined {
return artifactId ? this.artifacts.get(artifactId) : undefined;
}
public getArtifactsOwnedBy(addr: EthAddress): Artifact[] {
const ret: Artifact[] = [];
this.artifacts.forEach((artifact) => {
if (artifact.currentOwner === addr || artifact.controller === addr) {
ret.push(artifact);
}
});
return ret;
}
public getPlanetArtifacts(planetId: LocationId): Artifact[] {
return (this.planets.get(planetId)?.heldArtifactIds || [])
.map((id) => this.artifacts.get(id))
.filter((a) => !!a) as Artifact[];
}
public getArtifactsOnPlanetsOwnedBy(addr: EthAddress): Artifact[] {
const ret: Artifact[] = [];
this.artifacts.forEach((artifact) => {
if (artifact.onPlanetId) {
const planet = this.getPlanetWithId(artifact.onPlanetId, false);
if (planet && planet.owner === addr) {
ret.push(artifact);
}
}
});
return ret;
}
// get planet by ID - must be in contract or known chunks
public getPlanetWithId(planetId: LocationId, updateIfStale = true): Planet | undefined {
const planet = this.planets.get(planetId);
if (planet) {
if (updateIfStale) {
this.updatePlanetIfStale(planet);
}
return planet;
}
const loc = this.getLocationOfPlanet(planetId);
if (!loc) return undefined;
return this.getPlanetWithLocation(loc);
}
// returns undefined if this planet is neither in contract nor in known chunks
// fast query that doesn't update planet if stale
public getPlanetLevel(planetId: LocationId): PlanetLevel | undefined {
const planet = this.planets.get(planetId);
if (planet) {
return planet.planetLevel;
}
return undefined;
}
// returns undefined if this planet is neither in contract nor in known chunks
// fast query that doesn't update planet if stale
public getPlanetDetailLevel(planetId: LocationId): number | undefined {
const planet = this.planets.get(planetId);
if (planet) {
let detailLevel = planet.planetLevel as number;
if (hasOwner(planet)) {
detailLevel += 1;
}
return detailLevel;
} else {
return undefined;
}
}
/**
* received some artifact data from the contract. update our stores
*/
public replaceArtifactFromContractData(artifact: Artifact): void {
const localArtifact = this.artifacts.get(artifact.id);
if (localArtifact) {
artifact.transactions = localArtifact.transactions;
artifact.onPlanetId = localArtifact.onPlanetId;
}
this.setArtifact(artifact);
}
public replaceArtifactsFromContractData(artifacts: Iterable) {
for (const artifact of artifacts) {
this.replaceArtifactFromContractData(artifact);
}
}
/**
* Given a planet id, update the state of the given planet by calling the given update function.
* If the planet was updated, then also publish the appropriate event.
*/
public updatePlanet(id: LocationId, updateFn: (p: Planet) => void) {
const planet = this.getPlanetWithId(id);
if (planet !== undefined) {
updateFn(planet);
this.setPlanet(planet);
}
}
/**
* Given a planet id, update the state of the given planet by calling the given update function.
* If the planet was updated, then also publish the appropriate event.
*/
public updateArtifact(id: ArtifactId | undefined, updateFn: (p: Artifact) => void) {
const artifact = this.getArtifactById(id);
if (artifact !== undefined) {
updateFn(artifact);
this.setArtifact(artifact);
}
}
/**
* received some planet data from the contract. update our stores
*/
public replacePlanetFromContractData(
planet: Planet,
updatedArrivals?: QueuedArrival[],
updatedArtifactsOnPlanet?: ArtifactId[],
revealedLocation?: RevealedLocation,
claimerEthAddress?: EthAddress // TODO: Remove this
): void {
this.touchedPlanetIds.add(planet.locationId);
// does not modify unconfirmed txs
// that is handled by onTxConfirm
const localPlanet = this.planets.get(planet.locationId);
if (localPlanet) {
const {
transactions,
loadingServerState,
needsServerRefresh,
lastLoadedServerState,
emojiBobAnimation,
emojiZoopAnimation,
emojiZoopOutAnimation,
messages,
} = localPlanet;
planet.transactions = transactions;
planet.loadingServerState = loadingServerState;
planet.needsServerRefresh = needsServerRefresh;
planet.lastLoadedServerState = lastLoadedServerState;
planet.emojiBobAnimation = emojiBobAnimation;
planet.emojiZoopAnimation = emojiZoopAnimation;
planet.emojiZoopOutAnimation = emojiZoopOutAnimation;
planet.messages = messages;
// Possibly non updated props
planet.heldArtifactIds = localPlanet.heldArtifactIds;
} else {
this.planets.set(planet.locationId, planet);
}
if (updatedArtifactsOnPlanet) {
planet.heldArtifactIds = updatedArtifactsOnPlanet;
}
// make planet Locatable if we know its location
const loc = this.planetLocationMap.get(planet.locationId) || revealedLocation;
if (loc) {
(planet as LocatablePlanet).location = loc;
(planet as LocatablePlanet).biome = this.getBiome(loc);
}
if (revealedLocation) {
this.markLocationRevealed(revealedLocation);
this.addPlanetLocation(revealedLocation);
planet.coordsRevealed = true;
planet.revealer = revealedLocation.revealer;
}
if (claimerEthAddress) {
planet.claimer = claimerEthAddress;
}
this.setPlanet(planet);
if (updatedArrivals) {
// apply arrivals
this.clearOldArrivals(planet);
const updatedAwts = this.processArrivalsForPlanet(planet.locationId, updatedArrivals);
for (const awt of updatedAwts) {
const arrivalId = awt.arrivalData.eventId;
this.arrivals.set(arrivalId, awt);
const arrivalIds = this.planetArrivalIds.get(planet.locationId);
if (arrivalIds) {
arrivalIds.push(arrivalId);
this.planetArrivalIds.set(planet.locationId, arrivalIds);
}
}
}
}
// returns an empty planet if planet is not in contract
// returns undefined if this isn't a planet, according to hash and coords
public getPlanetWithCoords(coords: WorldCoords): LocatablePlanet | undefined {
const str = getCoordsString(coords);
const location = this.coordsToLocation.get(str);
if (!location) {
return undefined;
}
return this.getPlanetWithLocation(location) as LocatablePlanet;
}
// - returns an empty planet if planet is not in contract
// - returns undefined if this isn't a planet, according to hash and coords
// - if this planet hasn't been initialized in the client yet, initializes it
public getPlanetWithLocation(location: WorldLocation | undefined): Planet | undefined {
if (!location) return undefined;
const planet = this.planets.get(location.hash);
if (planet) {
this.updatePlanetIfStale(planet);
return planet;
}
// return a default unowned planet
const defaultPlanet = this.defaultPlanetFromLocation(location);
this.setPlanet(defaultPlanet);
return defaultPlanet;
}
public isPlanetInContract(planetId: LocationId): boolean {
return this.touchedPlanetIds.has(planetId);
}
/**
* Called when we load chunk data into memory (on startup), when we're loading all revealed locations (on startup),
* when miner has mined a new chunk while exploring, and when a planet's location is revealed onchain during the course of play
* Adds a WorldLocation to the planetLocationMap, making it known to the player locally
* Sets an unsynced default planet in the PlanetMap this.planets
* IMPORTANT: This is the only way a LocatablePlanet gets constructed
* IMPORTANT: Idempotent
*/
public addPlanetLocation(planetLocation: WorldLocation): void {
this.layeredMap.insertPlanet(
planetLocation,
this.getPlanetWithId(planetLocation.hash, false)?.planetLevel ??
this.planetLevelFromHexPerlin(planetLocation.hash, planetLocation.perlin)
);
this.planetLocationMap.set(planetLocation.hash, planetLocation);
const str = getCoordsString(planetLocation.coords);
if (!this.coordsToLocation.has(str)) {
this.coordsToLocation.set(str, planetLocation);
}
if (!this.planets.get(planetLocation.hash)) {
this.setPlanet(this.defaultPlanetFromLocation(planetLocation));
}
const planet = this.planets.get(planetLocation.hash);
if (planet) {
(planet as LocatablePlanet).location = planetLocation;
(planet as LocatablePlanet).biome = this.getBiome(planetLocation);
}
}
// marks that a location is revealed on-chain
public markLocationRevealed(revealedLocation: RevealedLocation): void {
this.revealedLocations.set(revealedLocation.hash, revealedLocation);
}
public getLocationOfPlanet(planetId: LocationId): WorldLocation | undefined {
return this.planetLocationMap.get(planetId) || undefined;
}
/**
* Returns all planets in the game.
*
* Warning! Simply iterating over this is not performant, and is meant for scripting.
*
* @tutorial For plugin developers!
*/
public getAllPlanets(): Iterable {
return this.planets.values();
}
/**
* Returns all planets in the game, as a map from their location id to the planet.
*
* @tutorial For plugin developers!
* @see Warning in {@link GameObjects.getAllPlanets()}
*/
public getAllPlanetsMap(): Map {
return this.planets;
}
/**
* Returns all the planets in the game which this client is aware of that have an owner, as a map
* from their id to the planet
*
* @tutorial For plugin developers!
* @see Warning in {@link GameObjects.getAllPlanets()}
*/
public getAllOwnedPlanets(): Planet[] {
return Array.from(this.planets.values()).filter(hasOwner);
}
/**
* Returns all voyages that are scheduled to arrive at some point in the future.
*
* @tutorial For plugin developers!
* @see Warning in {@link GameObjects.getAllPlanets()}
*/
public getAllVoyages(): QueuedArrival[] {
return Array.from(this.arrivals.values()).map((awt) => awt.arrivalData);
}
/**
* We call this function whenever the user requests that we send a transaction to the blockchain
* with their localstorage wallet. You can think of it as one of the hubs which connects
* `GameObjects` to the rest of the world.
*
* Inside this function, we update the relevant internal game objects to reflect that the user has
* requested a particular action. Additionally, we publish the appropriate events to the relevant
* {@link Monomitter} instances that are stored in this class.
*
* In the case of something like prospecting for an artifact, this allows us to display a spinner
* text which says "Prospecting..."
*
* In the case of the user sending energy from one planet to another planet, this allows us to
* display a dashed line between the two planets in their new voyage.
*
* Whenever we update an entity, we must do it via that entity's type's corresponding
* `set` function, in order for us to publish these events.
*
* @todo: this entire function could be automated by implementing a new interface called
* {@code TxFilter}.
*/
public onTxIntent(tx: Transaction) {
this.transactions.addTransaction(tx);
if (isUnconfirmedRevealTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedMoveTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.from);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
if (tx.intent.artifact) {
const artifact = this.getArtifactById(tx.intent.artifact);
if (artifact) {
artifact.transactions?.addTransaction(tx);
this.setArtifact(artifact);
}
}
} else if (isUnconfirmedUpgradeTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedBuyHatTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedTransferTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.planetId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedProspectPlanetTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.planetId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedFindArtifactTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.planetId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedDepositArtifactTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
const artifact = this.getArtifactById(tx.intent.artifactId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
if (artifact) {
artifact.transactions?.addTransaction(tx);
this.setArtifact(artifact);
}
} else if (isUnconfirmedWithdrawArtifactTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
const artifact = this.getArtifactById(tx.intent.artifactId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
if (artifact) {
artifact.transactions?.addTransaction(tx);
this.setArtifact(artifact);
}
} else if (isUnconfirmedActivateArtifactTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
const artifact = this.getArtifactById(tx.intent.artifactId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
if (artifact) {
artifact.transactions?.addTransaction(tx);
this.setArtifact(artifact);
}
} else if (isUnconfirmedDeactivateArtifactTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
const artifact = this.getArtifactById(tx.intent.artifactId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
if (artifact) {
artifact.transactions?.addTransaction(tx);
this.setArtifact(artifact);
}
} else if (isUnconfirmedWithdrawSilverTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedCapturePlanetTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedInvadePlanetTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.addTransaction(tx);
this.setPlanet(planet);
}
}
}
/**
* Whenever a transaction that the user initiated either succeeds or fails, we need to clear the
* fact that it was in progress from the event's corresponding entities. For example, whenever a
* transaction that sends a voyage from one planet to another either succeeds or fails, we need to
* remove the dashed line that connected them.
*
* Making sure that we never miss something here is very tedious.
*
* @todo Make this less tedious.
*/
public clearUnconfirmedTxIntent(tx: Transaction) {
this.transactions.removeTransaction(tx);
if (isUnconfirmedReveal(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedMove(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.from);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
if (tx.intent.artifact) {
const artifact = this.getArtifactById(tx.intent.artifact);
if (artifact) {
artifact.transactions?.removeTransaction(tx);
this.setArtifact(artifact);
}
}
} else if (isUnconfirmedUpgrade(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedBuyHat(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedFindArtifact(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.planetId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedDepositArtifact(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
const artifact = this.getArtifactById(tx.intent.artifactId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
if (artifact) {
artifact.transactions?.removeTransaction(tx);
this.setArtifact(artifact);
}
} else if (isUnconfirmedWithdrawArtifact(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
const artifact = this.getArtifactById(tx.intent.artifactId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
if (artifact) {
artifact.transactions?.removeTransaction(tx);
this.setArtifact(artifact);
}
} else if (isUnconfirmedTransfer(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.planetId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedProspectPlanet(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.planetId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedActivateArtifact(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
const artifact = this.getArtifactById(tx.intent.artifactId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
if (artifact) {
artifact.transactions?.removeTransaction(tx);
this.setArtifact(artifact);
}
} else if (isUnconfirmedDeactivateArtifact(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
const artifact = this.getArtifactById(tx.intent.artifactId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
if (artifact) {
artifact.transactions?.removeTransaction(tx);
this.setArtifact(artifact);
}
} else if (isUnconfirmedWithdrawSilver(tx.intent)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedCapturePlanetTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
} else if (isUnconfirmedInvadePlanetTx(tx)) {
const planet = this.getPlanetWithId(tx.intent.locationId);
if (planet) {
planet.transactions?.removeTransaction(tx);
this.setPlanet(planet);
}
}
}
public getPlanetMap(): Map {
return this.planets;
}
public getArtifactMap(): Map {
return this.artifacts;
}
public getMyPlanetMap(): Map {
return this.myPlanets;
}
public getMyArtifactMap(): Map {
return this.myArtifacts;
}
public getRevealedLocations(): Map {
return this.revealedLocations;
}
public getClaimedLocations(): Map {
return this.claimedLocations;
}
public setClaimedLocation(claimedLocation: ClaimedLocation) {
this.claimedLocations.set(claimedLocation.hash, claimedLocation);
}
/**
* Gets all the planets with the given ids, giltering out the ones that we don't have.
*/
public getPlanetsWithIds(locationIds: LocationId[], updateIfStale = true): Planet[] {
return locationIds
.map((id) => this.getPlanetWithId(id, updateIfStale))
.filter((p) => p !== undefined) as Planet[];
}
/**
* Gets all the planets that are within {@code radius} world units from the given coordinate. Fast
* because it uses {@link LayeredMap}.
*/
public getPlanetsInWorldCircle(coords: WorldCoords, radius: number): LocatablePlanet[] {
const locationIds = this.layeredMap.getPlanetsInCircle(coords, radius);
return this.getPlanetsWithIds(locationIds) as LocatablePlanet[];
}
/**
* Gets the ids of all the planets that are both within the given bounding box (defined by its
* bottom left coordinate, width, and height) in the world and of a level that was passed in via
* the `planetLevels` parameter. Fast because it uses {@link LayeredMap}.
*/
public getPlanetsInWorldRectangle(
worldX: number,
worldY: number,
worldWidth: number,
worldHeight: number,
levels: number[],
planetLevelToRadii: Map,
updateIfStale = true
): LocatablePlanet[] {
const locationIds = this.layeredMap.getPlanets(
worldX,
worldY,
worldWidth,
worldHeight,
levels,
planetLevelToRadii
);
return this.getPlanetsWithIds(locationIds, updateIfStale) as LocatablePlanet[];
}
public forceTick(locationId: LocationId) {
const planet = this.getPlanetWithId(locationId);
if (planet) {
this.setPlanet(planet);
}
}
/**
* Set a planet into our cached store. Should ALWAYS call this when setting a planet.
* `this.planets` and `this.myPlanets` should NEVER be accessed directly!
* This function also handles managing planet update messages and indexing the map of owned planets.
* @param planet the planet to set
*/
private setPlanet(planet: Planet) {
if (isLocatable(planet)) {
this.layeredMap.insertPlanet(planet.location, planet.planetLevel);
}
setObjectSyncState(
this.planets,
this.myPlanets,
this.address,
this.planetUpdated$,
this.myPlanetsUpdated$,
getPlanetId,
getPlanetOwner,
planet
);
}
/**
* Set an artifact into our cached store. Should ALWAYS call this when setting an artifact.
* `this.artifacts` and `this.myArtifacts` should NEVER be accessed directly!
* This function also handles managing artifact update messages and indexing the map of owned artifacts.
* @param artifact the artifact to set
*/
private setArtifact(artifact: Artifact) {
if (artifact.artifactType === ArtifactType.Wormhole && artifact.onPlanetId) {
if (artifact.wormholeTo && isActivated(artifact)) {
this.wormholes.set(artifact.id, {
from: artifact.onPlanetId,
to: artifact.wormholeTo,
});
} else {
this.wormholes.delete(artifact.id);
}
}
setObjectSyncState(
this.artifacts,
this.myArtifacts,
this.address,
this.artifactUpdated$,
this.myArtifactsUpdated$,
getArtifactId,
getArtifactOwner,
artifact
);
}
/**
* Emit notifications based on a planet's state change
*/
private emitArrivalNotifications({ previous, current, arrival }: PlanetDiff) {
const notifManager = NotificationManager.getInstance();
if (
!GameObjects.planetCanUpgrade(previous) &&
GameObjects.planetCanUpgrade(current) &&
current.owner === this.address
) {
notifManager.planetCanUpgrade(current);
}
if (
previous.owner !== this.address &&
previous.owner !== ethers.constants.AddressZero &&
current.owner === this.address
) {
notifManager.planetConquered(current as LocatablePlanet);
}
if (previous.owner === this.address && current.owner !== this.address) {
notifManager.planetLost(current as LocatablePlanet);
}
if (
arrival.player !== this.address &&
current.owner === this.address &&
arrival.energyArriving !== 0
) {
notifManager.planetAttacked(current as LocatablePlanet);
}
}
private removeArrival(planetId: LocationId, arrivalId: VoyageId) {
this.arrivals?.delete(arrivalId);
const planetArrivalIds = this.planetArrivalIds?.get(planetId) ?? [];
_.remove(planetArrivalIds, (id) => id === arrivalId);
}
private processArrivalsForPlanet(
planetId: LocationId,
arrivals: QueuedArrival[]
): ArrivalWithTimer[] {
const planet = this.planets.get(planetId);
if (!planet) {
console.error(`attempted to process arrivals for planet not in memory: ${planetId}`);
return [];
}
// process the QueuedArrival[] for a single planet
const arrivalsWithTimers: ArrivalWithTimer[] = [];
// sort arrivals by timestamp
arrivals.sort((a, b) => a.arrivalTime - b.arrivalTime);
const nowInSeconds = Date.now() / 1000;
for (const arrival of arrivals) {
try {
if (nowInSeconds - arrival.arrivalTime > 0) {
// if arrival happened in the past, run this arrival
const update = arrive(
planet,
this.getPlanetArtifacts(planet.locationId),
arrival,
this.getArtifactById(arrival.artifactId),
this.contractConstants
);
this.removeArrival(planetId, update.arrival.eventId);
this.emitArrivalNotifications(update);
} else {
// otherwise, set a timer to do this arrival in the future
// and append it to arrivalsWithTimers
const applyFutureArrival = setTimeout(() => {
const update = arrive(
planet,
this.getPlanetArtifacts(planet.locationId),
arrival,
this.getArtifactById(arrival.artifactId),
this.contractConstants
);
this.emitArrivalNotifications(update);
this.removeArrival(planetId, update.arrival.eventId);
}, arrival.arrivalTime * 1000 - Date.now());
const arrivalWithTimer = {
arrivalData: arrival,
timer: applyFutureArrival,
};
arrivalsWithTimers.push(arrivalWithTimer);
}
} catch (e) {
console.error(`error occurred processing arrival for updated planet ${planetId}: ${e}`);
}
}
return arrivalsWithTimers;
}
private clearOldArrivals(planet: Planet): void {
const planetId = planet.locationId;
// clear old timeouts
const arrivalIds = this.planetArrivalIds.get(planetId);
if (arrivalIds) {
// clear if the planet already had stored arrivals
for (const arrivalId of arrivalIds) {
const arrivalWithTimer = this.arrivals.get(arrivalId);
if (arrivalWithTimer) {
clearTimeout(arrivalWithTimer.timer);
} else {
console.error(`arrival with id ${arrivalId} wasn't found`);
}
this.arrivals.delete(arrivalId);
}
}
this.planetArrivalIds.set(planetId, []);
}
public planetLevelFromHexPerlin(hex: LocationId, perlin: number): PlanetLevel {
const spaceType = this.spaceTypeFromPerlin(perlin);
const levelBigInt = getBytesFromHex(hex, 4, 7);
let ret = MIN_PLANET_LEVEL;
for (let type = MAX_PLANET_LEVEL; type >= MIN_PLANET_LEVEL; type--) {
if (levelBigInt < bigInt(this.contractConstants.planetLevelThresholds[type])) {
ret = type;
break;
}
}
if (spaceType === SpaceType.NEBULA && ret > PlanetLevel.FOUR) {
ret = PlanetLevel.FOUR;
}
if (spaceType === SpaceType.SPACE && ret > PlanetLevel.FIVE) {
ret = PlanetLevel.FIVE;
}
if (ret > this.contractConstants.MAX_NATURAL_PLANET_LEVEL) {
ret = this.contractConstants.MAX_NATURAL_PLANET_LEVEL as PlanetLevel;
}
return ret;
}
public spaceTypeFromPerlin(perlin: number): SpaceType {
if (perlin < this.contractConstants.PERLIN_THRESHOLD_1) {
return SpaceType.NEBULA;
} else if (perlin < this.contractConstants.PERLIN_THRESHOLD_2) {
return SpaceType.SPACE;
} else if (perlin < this.contractConstants.PERLIN_THRESHOLD_3) {
return SpaceType.DEEP_SPACE;
} else {
return SpaceType.DEAD_SPACE;
}
}
public static getSilverNeeded(planet: Planet): number {
const totalLevel = planet.upgradeState.reduce((a, b) => a + b);
return (totalLevel + 1) * 0.2 * planet.silverCap;
}
public static planetCanUpgrade(planet: Planet): boolean {
const totalRank = planet.upgradeState.reduce((a, b) => a + b);
if (planet.spaceType === SpaceType.NEBULA && totalRank >= 3) return false;
if (planet.spaceType === SpaceType.SPACE && totalRank >= 4) return false;
if (planet.spaceType === SpaceType.DEEP_SPACE && totalRank >= 5) return false;
if (planet.spaceType === SpaceType.DEAD_SPACE && totalRank >= 5) return false;
return (
planet.planetLevel !== 0 &&
planet.planetType === PlanetType.PLANET &&
planet.silver >= this.getSilverNeeded(planet)
);
}
public planetTypeFromHexPerlin(hex: LocationId, perlin: number): PlanetType {
// level must be sufficient - too low level planets have 0 silver growth
const planetLevel = this.planetLevelFromHexPerlin(hex, perlin);
const spaceType = this.spaceTypeFromPerlin(perlin);
const weights = this.contractConstants.PLANET_TYPE_WEIGHTS[spaceType][planetLevel];
const weightSum = weights.reduce((x, y) => x + y);
let thresholds = [weightSum - weights[0]];
for (let i = 1; i < weights.length; i++) {
thresholds.push(thresholds[i - 1] - weights[i]);
}
thresholds = thresholds.map((x) => Math.floor((x * 256) / weightSum));
const typeByte = Number(getBytesFromHex(hex, 8, 9));
for (let i = 0; i < thresholds.length; i++) {
if (typeByte >= thresholds[i]) {
return i as PlanetType;
}
}
// this should never happen
return PlanetType.PLANET;
}
private getBiome(loc: WorldLocation): Biome {
const { perlin, biomebase } = loc;
const spaceType = this.spaceTypeFromPerlin(perlin);
if (spaceType === SpaceType.DEAD_SPACE) return Biome.CORRUPTED;
let biome = 3 * spaceType;
if (biomebase < this.contractConstants.BIOME_THRESHOLD_1) biome += 1;
else if (biomebase < this.contractConstants.BIOME_THRESHOLD_2) biome += 2;
else biome += 3;
return biome as Biome;
}
/**
* returns the data for an unowned, untouched planet at location
* most planets in the game are untouched and not stored in the contract,
* so we need to generate their data optimistically in the client
*/
private defaultPlanetFromLocation(location: WorldLocation): LocatablePlanet {
const { perlin } = location;
const hex = location.hash;
const planetLevel = this.planetLevelFromHexPerlin(hex, perlin);
const planetType = this.planetTypeFromHexPerlin(hex, perlin);
const spaceType = this.spaceTypeFromPerlin(perlin);
const [energyCapBonus, energyGroBonus, rangeBonus, speedBonus, defBonus, spaceJunkBonus] =
bonusFromHex(hex);
let energyCap = this.contractConstants.defaultPopulationCap[planetLevel];
let energyGro = this.contractConstants.defaultPopulationGrowth[planetLevel];
let range = this.contractConstants.defaultRange[planetLevel];
let speed = this.contractConstants.defaultSpeed[planetLevel];
let defense = this.contractConstants.defaultDefense[planetLevel];
let silCap = this.contractConstants.defaultSilverCap[planetLevel];
let spaceJunk = this.contractConstants.PLANET_LEVEL_JUNK[planetLevel];
let silGro = 0;
if (planetType === PlanetType.SILVER_MINE) {
silGro = this.contractConstants.defaultSilverGrowth[planetLevel];
}
energyCap *= energyCapBonus ? 2 : 1;
energyGro *= energyGroBonus ? 2 : 1;
range *= rangeBonus ? 2 : 1;
speed *= speedBonus ? 2 : 1;
defense *= defBonus ? 2 : 1;
spaceJunk = Math.floor(spaceJunk / (spaceJunkBonus ? 2 : 1));
if (spaceType === SpaceType.DEAD_SPACE) {
range *= 2;
speed *= 2;
energyCap *= 2;
energyGro *= 2;
silCap *= 2;
silGro *= 2;
defense = Math.floor((defense * 3) / 20);
} else if (spaceType === SpaceType.DEEP_SPACE) {
range *= 1.5;
speed *= 1.5;
energyCap *= 1.5;
energyGro *= 1.5;
silCap *= 1.5;
silGro *= 1.5;
defense *= 0.25;
} else if (spaceType === SpaceType.SPACE) {
range *= 1.25;
speed *= 1.25;
energyCap *= 1.25;
energyGro *= 1.25;
silCap *= 1.25;
silGro *= 1.25;
defense *= 0.5;
}
// apply stat modifiers for special planet types
if (planetType === PlanetType.SILVER_MINE) {
silCap *= 2;
defense *= 0.5;
} else if (planetType === PlanetType.SILVER_BANK) {
speed /= 2;
silCap *= 10;
energyGro = 0;
energyCap *= 5;
} else if (planetType === PlanetType.TRADING_POST) {
defense *= 0.5;
silCap *= 2;
}
let pirates =
(energyCap * this.contractConstants.defaultBarbarianPercentage[planetLevel]) / 100;
// increase pirates
if (spaceType === SpaceType.DEAD_SPACE) pirates *= 20;
else if (spaceType === SpaceType.DEEP_SPACE) pirates *= 10;
else if (spaceType === SpaceType.SPACE) pirates *= 4;
if (planetType === PlanetType.SILVER_BANK) pirates /= 2;
const silver = planetType === PlanetType.SILVER_MINE ? silCap / 2 : 0;
speed *= this.contractConstants.TIME_FACTOR_HUNDREDTHS / 100;
energyGro *= this.contractConstants.TIME_FACTOR_HUNDREDTHS / 100;
silGro *= this.contractConstants.TIME_FACTOR_HUNDREDTHS / 100;
const biome = this.getBiome(location);
return {
locationId: hex,
perlin,
spaceType,
owner: EMPTY_ADDRESS,
hatLevel: 0,
bonus: bonusFromHex(hex),
planetLevel,
planetType,
isHomePlanet: false,
energyCap: energyCap,
energyGrowth: energyGro,
silverCap: silCap,
silverGrowth: silGro,
range,
speed,
defense,
energy: pirates,
silver,
spaceJunk,
lastUpdated: Math.floor(Date.now() / 1000),
upgradeState: [0, 0, 0],
transactions: new TxCollection(),
unconfirmedClearEmoji: false,
unconfirmedAddEmoji: false,
loadingServerState: false,
silverSpent: 0,
prospectedBlockNumber: undefined,
heldArtifactIds: [],
destroyed: false,
isInContract: this.touchedPlanetIds.has(hex),
syncedWithContract: false,
needsServerRefresh: false,
coordsRevealed: false,
location,
biome,
hasTriedFindingArtifact: false,
messages: undefined,
pausers: 0,
invader: EMPTY_ADDRESS,
capturer: EMPTY_ADDRESS,
};
}
private updatePlanetIfStale(planet: Planet): void {
const now = Date.now();
if (now / 1000 - planet.lastUpdated > 1) {
updatePlanetToTime(
planet,
this.getPlanetArtifacts(planet.locationId),
now,
this.contractConstants,
this.setPlanet
);
}
}
/**
* returns timestamp (seconds) that planet will reach percent% of energycap
* time may be in the past
*/
public getEnergyCurveAtPercent(planet: Planet, percent: number): number {
const p1 = (percent / 100) * planet.energyCap;
const c = planet.energyCap;
const p0 = planet.energy;
const g = planet.energyGrowth;
const t0 = planet.lastUpdated;
const t1 = (c / (4 * g)) * Math.log((p1 * (c - p0)) / (p0 * (c - p1))) + t0;
return t1;
}
/**
* returns timestamp (seconds) that planet will reach percent% of silcap if
* doesn't produce silver, returns undefined if already over percent% of silcap,
* returns undefined
*/
public getSilverCurveAtPercent(planet: Planet, percent: number): number | undefined {
if (planet.silverGrowth <= 0) {
return undefined;
}
const silverTarget = (percent / 100) * planet.silverCap;
const silverDiff = silverTarget - planet.silver;
if (silverDiff <= 0) {
return undefined;
}
let timeToTarget = 0;
timeToTarget += silverDiff / planet.silverGrowth;
return planet.lastUpdated + timeToTarget;
}
/**
* Returns the EthAddress of the player who can control the owner:
* if the artifact is on a planet, this is the owner of the planet
* if the artifact is on a voyage, this is the initiator of the voyage
* if the artifact is not on either, then it is the owner of the artifact NFT
*/
public getArtifactController(artifactId: ArtifactId): EthAddress | undefined {
const artifact = this.getArtifactById(artifactId);
if (!artifact) {
return undefined;
}
if (artifact.onPlanetId) {
const planet = this.getPlanetWithId(artifact.onPlanetId);
if (!planet) {
return undefined;
}
return planet.owner === EMPTY_ADDRESS ? undefined : planet.owner;
} else if (artifact.onVoyageId) {
const arrival = this.arrivals.get(artifact.onVoyageId);
return arrival?.arrivalData.player || undefined;
} else {
return artifact.currentOwner === EMPTY_ADDRESS ? undefined : artifact.currentOwner;
}
}
/**
* Get all of the incoming voyages for a given location.
*/
public getArrivalIdsForLocation(location: LocationId | undefined): VoyageId[] | undefined {
if (!location) return [];
return this.planetArrivalIds.get(location);
}
/**
* Whether or not we're already asking the game to give us spaceships.
*/
public isGettingSpaceships(): boolean {
return this.transactions.hasTransaction(isUnconfirmedGetShipsTx);
}
}
================================================
FILE: src/Backend/GameLogic/GameUIManager.ts
================================================
import { EMPTY_ADDRESS } from '@darkforest_eth/constants';
import { Monomitter, monomitter } from '@darkforest_eth/events';
import { biomeName, isLocatable, isSpaceShip } from '@darkforest_eth/gamelogic';
import { planetHasBonus } from '@darkforest_eth/hexgen';
import { EthConnection } from '@darkforest_eth/network';
import { GameGLManager, Renderer } from '@darkforest_eth/renderer';
import { isUnconfirmedMoveTx } from '@darkforest_eth/serde';
import {
Artifact,
ArtifactId,
BaseRenderer,
Biome,
Chunk,
CursorState,
Diagnostics,
EthAddress,
LocatablePlanet,
LocationId,
PerlinConfig,
Planet,
PlanetLevel,
PlanetType,
Player,
QueuedArrival,
Rectangle,
Setting,
SpaceType,
Transaction,
UnconfirmedActivateArtifact,
UnconfirmedMove,
UnconfirmedUpgrade,
Upgrade,
UpgradeBranchName,
WorldCoords,
WorldLocation,
Wormhole,
} from '@darkforest_eth/types';
import autoBind from 'auto-bind';
import { BigNumber } from 'ethers';
import EventEmitter from 'events';
import deferred from 'p-defer';
import React from 'react';
import ModalManager from '../../Frontend/Game/ModalManager';
import NotificationManager from '../../Frontend/Game/NotificationManager';
import Viewport from '../../Frontend/Game/Viewport';
import { getObjectWithIdFromMap } from '../../Frontend/Utils/EmitterUtils';
import { listenForKeyboardEvents, unlinkKeyboardEvents } from '../../Frontend/Utils/KeyEmitters';
import {
getBooleanSetting,
getSetting,
setBooleanSetting,
} from '../../Frontend/Utils/SettingsHooks';
import UIEmitter, { UIEmitterEvent } from '../../Frontend/Utils/UIEmitter';
import { TerminalHandle } from '../../Frontend/Views/Terminal';
import { ContractConstants } from '../../_types/darkforest/api/ContractsAPITypes';
import { HashConfig } from '../../_types/global/GlobalTypes';
import { MiningPattern } from '../Miner/MiningPatterns';
import { coordsEqual } from '../Utils/Coordinates';
import GameManager, { GameManagerEvent } from './GameManager';
import { GameObjects } from './GameObjects';
import { PluginManager } from './PluginManager';
import TutorialManager, { TutorialState } from './TutorialManager';
import { ViewportEntities } from './ViewportEntities';
export const enum GameUIManagerEvent {
InitializedPlayer = 'InitializedPlayer',
InitializedPlayerError = 'InitializedPlayerError',
}
class GameUIManager extends EventEmitter {
private readonly radiusMap: { [PlanetLevel: number]: number };
private readonly gameManager: GameManager;
private modalManager: ModalManager;
private terminal: React.MutableRefObject;
/**
* In order to render React on top of the game, we need to insert React nodes into an overlay
* container. We keep a reference to this container, so that our React components can optionally
* choose to render themselves into this overlay container using React Portals.
*/
private overlayContainer?: HTMLDivElement;
private previousSelectedPlanetId: LocationId | undefined;
private selectedPlanetId: LocationId | undefined;
private selectedCoords: WorldCoords | undefined;
private mouseDownOverPlanet: LocatablePlanet | undefined;
private mouseDownOverCoords: WorldCoords | undefined;
private mouseHoveringOverPlanet: LocatablePlanet | undefined;
private mouseHoveringOverCoords: WorldCoords | undefined;
private sendingPlanet: LocatablePlanet | undefined;
private sendingCoords: WorldCoords | undefined;
private isSending = false;
private abandoning = false;
private viewportEntities: ViewportEntities;
/**
* The Wormhole artifact requires you to choose a target planet. This value
* indicates whether or not the player is currently selecting a target planet.
*/
private isChoosingTargetPlanet = false;
private onChooseTargetPlanet?: (planet: LocatablePlanet | undefined) => void;
// TODO: Remove later and just use minerLocations array
private minerLocation: WorldCoords | undefined;
private extraMinerLocations: WorldCoords[] = [];
private forcesSending: { [key: string]: number } = {}; // this is a percentage
private silverSending: { [key: string]: number } = {}; // this is a percentage
private artifactSending: { [key: string]: Artifact | undefined } = {};
private plugins: PluginManager;
public readonly selectedPlanetId$: Monomitter;
public readonly hoverPlanetId$: Monomitter;
public readonly hoverPlanet$: Monomitter;
public readonly hoverArtifactId$: Monomitter;
public readonly hoverArtifact$: Monomitter;
public readonly myArtifacts$: Monomitter>;
public readonly isSending$: Monomitter;
public readonly isAbandoning$: Monomitter;
private planetHoveringInRenderer = false;
// lifecycle methods
private constructor(
gameManager: GameManager,
terminalHandle: React.MutableRefObject
) {
super();
this.gameManager = gameManager;
this.terminal = terminalHandle;
// if planets are more dense, make radii smaller
// if planets are less dense, make radii larger
// the default radii are tuned for a default planet rarity of 16384
const scaleFactor = Math.sqrt(this.gameManager.getPlanetRarity() / 16384);
// TODO: will radii this large degrade performance?
this.radiusMap = {
[PlanetLevel.ZERO]: 1 * scaleFactor,
[PlanetLevel.ONE]: 3 * scaleFactor,
[PlanetLevel.TWO]: 9 * scaleFactor,
[PlanetLevel.THREE]: 27 * scaleFactor,
[PlanetLevel.FOUR]: 81 * scaleFactor,
[PlanetLevel.FIVE]: 243 * scaleFactor,
[PlanetLevel.SIX]: 486 * scaleFactor,
[PlanetLevel.SEVEN]: 729 * scaleFactor,
[PlanetLevel.EIGHT]: 972 * scaleFactor,
[PlanetLevel.NINE]: 1215 * scaleFactor,
} as const;
this.plugins = new PluginManager(gameManager);
this.selectedPlanetId$ = monomitter(true);
this.hoverPlanetId$ = monomitter();
this.hoverPlanet$ = getObjectWithIdFromMap(
this.getPlanetMap(),
this.hoverPlanetId$,
this.gameManager.getPlanetUpdated$()
);
this.hoverArtifactId$ = monomitter();
this.hoverArtifact$ = getObjectWithIdFromMap(
this.getArtifactMap(),
this.hoverArtifactId$,
this.gameManager.getArtifactUpdated$()
);
this.myArtifacts$ = this.gameManager.getMyArtifactsUpdated$();
this.viewportEntities = new ViewportEntities(this.gameManager, this);
this.isSending$ = monomitter(true);
this.isAbandoning$ = monomitter(true);
autoBind(this);
}
/**
* Sets the overlay container. See {@link GameUIManger.overlayContainer} for more information
* about what the overlay container is.
*/
public setOverlayContainer(randomContainer?: HTMLDivElement) {
this.overlayContainer = randomContainer;
}
/**
* Gets the overlay container. See {@link GameUIManger.overlayContainer} for more information
* about what the overlay container is.
*/
public getOverlayContainer(): HTMLDivElement | undefined {
return this.overlayContainer;
}
public static async create(
gameManager: GameManager,
terminalHandle: React.MutableRefObject
) {
listenForKeyboardEvents();
const uiEmitter = UIEmitter.getInstance();
const uiManager = new GameUIManager(gameManager, terminalHandle);
const modalManager = await ModalManager.create(gameManager.getChunkStore());
uiManager.setModalManager(modalManager);
uiEmitter.on(UIEmitterEvent.WorldMouseDown, uiManager.onMouseDown);
uiEmitter.on(UIEmitterEvent.WorldMouseClick, uiManager.onMouseClick);
uiEmitter.on(UIEmitterEvent.WorldMouseMove, uiManager.onMouseMove);
uiEmitter.on(UIEmitterEvent.WorldMouseUp, uiManager.onMouseUp);
uiEmitter.on(UIEmitterEvent.WorldMouseOut, uiManager.onMouseOut);
uiEmitter.on(UIEmitterEvent.SendInitiated, uiManager.onSendInit);
uiEmitter.on(UIEmitterEvent.SendCancelled, uiManager.onSendCancel);
uiEmitter.on(UIEmitterEvent.SendCompleted, uiManager.onSendComplete);
gameManager.on(GameManagerEvent.PlanetUpdate, uiManager.updatePlanets);
gameManager.on(GameManagerEvent.DiscoveredNewChunk, uiManager.onDiscoveredChunk);
return uiManager;
}
public destroy(): void {
unlinkKeyboardEvents();
const uiEmitter = UIEmitter.getInstance();
uiEmitter.removeListener(UIEmitterEvent.WorldMouseDown, this.onMouseDown);
uiEmitter.removeListener(UIEmitterEvent.WorldMouseClick, this.onMouseClick);
uiEmitter.removeListener(UIEmitterEvent.WorldMouseMove, this.onMouseMove);
uiEmitter.removeListener(UIEmitterEvent.WorldMouseUp, this.onMouseUp);
uiEmitter.removeListener(UIEmitterEvent.WorldMouseOut, this.onMouseOut);
uiEmitter.removeListener(UIEmitterEvent.SendInitiated, this.onSendInit);
uiEmitter.removeListener(UIEmitterEvent.SendCancelled, this.onSendCancel);
uiEmitter.removeListener(UIEmitterEvent.SendCompleted, this.onSendComplete);
this.gameManager.removeListener(GameManagerEvent.PlanetUpdate, this.updatePlanets);
this.gameManager.removeListener(
GameManagerEvent.InitializedPlayer,
this.onEmitInitializedPlayer
);
this.gameManager.removeListener(
GameManagerEvent.InitializedPlayerError,
this.onEmitInitializedPlayerError
);
this.gameManager.removeListener(GameManagerEvent.DiscoveredNewChunk, this.onDiscoveredChunk);
this.gameManager.destroy();
this.selectedPlanetId$.clear();
this.hoverArtifactId$.clear();
}
public getStringSetting(setting: Setting): string | undefined {
const account = this.getAccount();
const config = {
contractAddress: this.getContractAddress(),
account,
};
return account && getSetting(config, setting);
}
public getBooleanSetting(setting: Setting): boolean {
const account = this.getAccount();
if (!account) {
return false;
}
const config = { contractAddress: this.getContractAddress(), account };
return getBooleanSetting(config, setting);
}
public getDiagnostics(): Diagnostics {
return this.gameManager.getDiagnostics();
}
public updateDiagnostics(updateFn: (d: Diagnostics) => void) {
this.gameManager.updateDiagnostics(updateFn);
}
public getEthConnection(): EthConnection {
return this.gameManager.getEthConnection();
}
public getContractAddress(): EthAddress {
return this.gameManager.getContractAddress();
}
// actions
public centerPlanet(planet: LocatablePlanet | undefined) {
if (planet) {
Viewport.getInstance().centerPlanet(planet);
this.setSelectedPlanet(planet);
}
}
public centerCoords(coords: WorldCoords) {
const planet = this.gameManager.getPlanetWithCoords(coords);
if (planet && isLocatable(planet)) {
this.centerPlanet(planet);
} else {
Viewport.getInstance().centerCoords(coords);
}
}
public centerLocationId(planetId: LocationId) {
const planet = this.getPlanetWithId(planetId);
if (planet && isLocatable(planet)) {
this.centerPlanet(planet);
}
}
public joinGame(beforeRetry: (e: Error) => Promise): Promise {
return this.gameManager.joinGame(beforeRetry);
}
public addAccount(coords: WorldCoords): Promise {
return this.gameManager.addAccount(coords);
}
public verifyTwitter(twitter: string): Promise {
return this.gameManager.submitVerifyTwitter(twitter);
}
public disconnectTwitter(twitter: string) {
return this.gameManager.submitDisconnectTwitter(twitter);
}
public getPluginManager(): PluginManager {
return this.plugins;
}
public getPrivateKey(): string | undefined {
return this.gameManager.getPrivateKey();
}
public getMyBalance(): number {
return this.gameManager.getMyBalanceEth();
}
public getMyBalanceBn(): BigNumber {
return this.gameManager.getMyBalance();
}
public getMyBalance$(): Monomitter {
return this.gameManager.getMyBalance$();
}
public findArtifact(planetId: LocationId) {
if (this.gameManager.isRoundOver()) {
alert('This round has ended, and you can no longer find artifacts!');
return;
}
this.gameManager.findArtifact(planetId);
}
public prospectPlanet(planetId: LocationId) {
if (this.gameManager.isRoundOver()) {
alert('This round has ended, and you can no longer find artifacts!');
return;
}
this.gameManager.prospectPlanet(planetId);
}
public withdrawArtifact(locationId: LocationId, artifactId: ArtifactId) {
this.gameManager.withdrawArtifact(locationId, artifactId);
}
public depositArtifact(locationId: LocationId, artifactId: ArtifactId) {
this.gameManager.depositArtifact(locationId, artifactId);
}
public drawAllRunningPlugins(ctx: CanvasRenderingContext2D) {
this.getPluginManager().drawAllRunningPlugins(ctx);
}
public activateArtifact(locationId: LocationId, id: ArtifactId, wormholeTo?: LocationId) {
const confirmationText =
`Are you sure you want to activate this artifact? ` +
`You can only have one artifact active at time. After` +
` deactivation, you must wait for a long cooldown` +
` before you can activate it again. Some artifacts (bloom filter, black domain, photoid cannon) are consumed on usage.`;
if (!confirm(confirmationText)) return;
this.gameManager.activateArtifact(locationId, id, wormholeTo);
}
public deactivateArtifact(locationId: LocationId, artifactId: ArtifactId) {
const confirmationText =
`Are you sure you want to deactivate this artifact? ` +
`After deactivation, you must wait for a long cooldown` +
` before you can activate it again. Some artifacts (planetary shields) are consumed on deactivation.`;
if (!confirm(confirmationText)) return;
this.gameManager.deactivateArtifact(locationId, artifactId);
}
public withdrawSilver(locationId: LocationId, amount: number) {
const dontShowWarningStorageKey = `${this.getAccount()?.toLowerCase()}-withdrawnWarningAcked`;
if (localStorage.getItem(dontShowWarningStorageKey) !== 'true') {
localStorage.setItem(dontShowWarningStorageKey, 'true');
const confirmationText =
`Are you sure you want withdraw this silver? Once you withdraw it, you ` +
`cannot deposit it again. Your withdrawn silver amount will be added to your score. You'll only see this warning once!`;
if (!confirm(confirmationText)) return;
}
this.gameManager.withdrawSilver(locationId, amount);
}
public startWormholeFrom(planet: LocatablePlanet): Promise {
this.isChoosingTargetPlanet = true;
this.mouseDownOverCoords = planet.location.coords;
this.mouseDownOverPlanet = planet;
const { resolve, promise } = deferred();
this.onChooseTargetPlanet = resolve;
return promise;
}
public revealLocation(locationId: LocationId) {
this.gameManager.revealLocation(locationId);
}
public getNextBroadcastAvailableTimestamp() {
return this.gameManager.getNextBroadcastAvailableTimestamp();
}
public timeUntilNextBroadcastAvailable() {
return this.gameManager.timeUntilNextBroadcastAvailable();
}
public getEnergyArrivingForMove(
from: LocationId,
to: LocationId | undefined,
dist: number | undefined,
energy: number
) {
return this.gameManager.getEnergyArrivingForMove(from, to, dist, energy, this.abandoning);
}
getIsChoosingTargetPlanet() {
return this.isChoosingTargetPlanet;
}
public onMouseDown(coords: WorldCoords) {
if (this.sendingPlanet) return;
const hoveringOverCoords = this.updateMouseHoveringOverCoords(coords);
const hoveringOverPlanet = this.gameManager.getPlanetWithCoords(hoveringOverCoords);
if (this.getIsChoosingTargetPlanet()) {
this.isChoosingTargetPlanet = false;
if (this.onChooseTargetPlanet) {
this.onChooseTargetPlanet(hoveringOverPlanet as LocatablePlanet);
this.mouseDownOverPlanet = undefined;
this.mouseDownOverCoords = undefined;
}
} else {
this.mouseDownOverPlanet = hoveringOverPlanet;
this.mouseDownOverCoords = this.mouseHoveringOverCoords;
}
}
public onMouseClick(_coords: WorldCoords) {
if (!this.mouseDownOverPlanet && !this.mouseHoveringOverPlanet) {
this.setSelectedPlanet(undefined);
this.selectedCoords = undefined;
}
}
public onMouseMove(coords: WorldCoords) {
this.updateMouseHoveringOverCoords(coords);
}
public onMouseUp(coords: WorldCoords) {
const mouseUpOverCoords = this.updateMouseHoveringOverCoords(coords);
const mouseUpOverPlanet = this.gameManager.getPlanetWithCoords(mouseUpOverCoords);
const mouseDownPlanet = this.getMouseDownPlanet();
const tutorialManager = TutorialManager.getInstance(this);
const uiEmitter = UIEmitter.getInstance();
if (mouseUpOverPlanet) {
if (
this.mouseDownOverPlanet &&
mouseUpOverPlanet.locationId === this.mouseDownOverPlanet.locationId
) {
// select planet
this.setSelectedPlanet(mouseUpOverPlanet);
this.selectedCoords = mouseUpOverCoords;
this.terminal.current?.println(`Selected: ${mouseUpOverPlanet.locationId}`);
this.terminal.current?.println(``);
} else if (
mouseDownPlanet &&
(mouseDownPlanet.owner === this.gameManager.getAccount() ||
this.isSendingShip(mouseDownPlanet.locationId))
) {
// move initiated if enough forces
const from = mouseDownPlanet;
const to = mouseUpOverPlanet;
// TODO: the following code block needs to be in a Planet class
let effectiveEnergy = from.energy;
for (const unconfirmedMove of from.transactions?.getTransactions(isUnconfirmedMoveTx) ??
[]) {
effectiveEnergy -= unconfirmedMove.intent.forces;
}
const effPercent = Math.min(this.getForcesSending(from.locationId), 98);
let forces = Math.floor((effectiveEnergy * effPercent) / 100);
// make it so you leave one force behind
if (this.isSendingShip(mouseDownPlanet.locationId)) {
tutorialManager.acceptInput(TutorialState.Spaceship);
forces = 0;
} else if (forces >= from.energy) {
forces = from.energy - 1;
if (forces < 1) return;
}
const dist = this.gameManager.getDist(from.locationId, to.locationId);
const myAtk: number = this.gameManager.getEnergyArrivingForMove(
from.locationId,
to.locationId,
dist,
forces,
this.abandoning
);
let effPercentSilver = this.getSilverSending(from.locationId);
if (
effPercentSilver > 98 &&
from.planetType === PlanetType.SILVER_MINE &&
from.silver < from.silverCap
) {
// player is trying to send 100% silver from a silver mine that is not at cap
// Date.now() and block.timestamp are occasionally a bit out of sync, so clip
effPercentSilver = 98;
}
if (myAtk > 0 || this.isSendingShip(from.locationId)) {
const abandoning = this.isAbandoning();
const silver = Math.floor((from.silver * effPercentSilver) / 100);
// TODO: do something like JSON.stringify(args) so we know formatting is correct
this.terminal.current?.printShellLn(
`df.move('${from.locationId}', '${to.locationId}', ${forces}, ${silver})`
);
const artifact = this.getArtifactSending(from.locationId);
this.gameManager.move(
from.locationId,
to.locationId,
forces,
silver,
artifact?.id,
abandoning
);
tutorialManager.acceptInput(TutorialState.SendFleet);
}
uiEmitter.emit(UIEmitterEvent.SendCompleted, from.locationId);
}
this.isChoosingTargetPlanet = false;
} else {
uiEmitter.emit(UIEmitterEvent.SendCancelled);
}
this.mouseDownOverPlanet = undefined;
this.mouseDownOverCoords = undefined;
}
public onMouseOut() {
this.mouseDownOverPlanet = undefined;
this.mouseDownOverCoords = undefined;
this.setHoveringOverPlanet(undefined, true);
this.mouseHoveringOverCoords = undefined;
}
public startExplore() {
this.gameManager.startExplore();
}
public stopExplore() {
this.gameManager.stopExplore();
this.minerLocation = undefined;
}
public toggleExplore() {
if (this.isMining()) {
this?.stopExplore();
TutorialManager.getInstance(this).acceptInput(TutorialState.MinerPause);
} else {
this?.startExplore();
}
}
public toggleTargettingExplorer() {
const modalManager = this.modalManager;
if (modalManager.getCursorState() === CursorState.TargetingExplorer)
modalManager.setCursorState(CursorState.Normal);
else modalManager.setCursorState(CursorState.TargetingExplorer);
}
public setForcesSending(planetId: LocationId, percentage: number) {
if (percentage < 0) percentage = 0;
if (percentage > 100) percentage = 100;
this.forcesSending[planetId] = percentage;
this.gameManager.getGameObjects().forceTick(planetId);
}
public setSilverSending(planetId: LocationId, percentage: number) {
if (percentage < 0) percentage = 0;
if (percentage > 100) percentage = 100;
this.silverSending[planetId] = percentage;
this.gameManager.getGameObjects().forceTick(planetId);
}
public setSending(sending: boolean): void {
this.isSending = sending;
this.isSending$.publish(sending);
}
public setAbandoning(abandoning: boolean): void {
if (!this.gameManager.getContractConstants().SPACE_JUNK_ENABLED) return;
const planet = this.getSelectedPlanet();
if (planet?.isHomePlanet) return;
if (this.isSendingShip(planet?.locationId)) return;
// An abandon is always a send
this.isSending = abandoning;
this.abandoning = abandoning;
this.isSending$.publish(abandoning);
this.isAbandoning$.publish(abandoning);
}
public setArtifactSending(planetId: LocationId, artifact?: Artifact) {
this.artifactSending[planetId] = artifact;
if (this.isSendingShip(planetId)) {
this.abandoning = false;
this.isAbandoning$.publish(false);
}
this.gameManager.getGameObjects().forceTick(planetId);
}
public isOwnedByMe(planet: Planet): boolean {
return planet.owner === this.gameManager.getAccount();
}
public addNewChunk(chunk: Chunk) {
this.gameManager.addNewChunk(chunk);
}
public bulkAddNewChunks(chunks: Chunk[]): Promise {
return this.gameManager.bulkAddNewChunks(chunks);
}
// mining stuff
public setMiningPattern(pattern: MiningPattern) {
this.gameManager.setMiningPattern(pattern);
}
public getMiningPattern(): MiningPattern | undefined {
return this.gameManager.getMiningPattern();
}
public isMining(): boolean {
return this.gameManager.isMining();
}
// getters
public getAccount(): EthAddress | undefined {
return this.gameManager.getAccount();
}
public isAdmin(): boolean {
return this.gameManager.isAdmin();
}
public getTwitter(address: EthAddress | undefined): string | undefined {
return this.gameManager.getTwitter(address);
}
public getEndTimeSeconds(): number {
return this.gameManager.getEndTimeSeconds();
}
public isRoundOver(): boolean {
return this.gameManager.isRoundOver();
}
public getUpgrade(branch: UpgradeBranchName, level: number): Upgrade {
return this.gameManager.getUpgrade(branch, level);
}
private getBiomeKey(biome: Biome) {
return `${this.getAccount()}-${this.gameManager.getContractAddress()}-biome-${biome}`;
}
public getDiscoverBiomeName(biome: Biome): string {
const item = localStorage.getItem(this.getBiomeKey(biome));
if (item === 'true') {
return biomeName(biome);
}
return 'Undiscovered';
}
public getDistCoords(from: WorldCoords, to: WorldCoords) {
return this.gameManager.getDistCoords(from, to);
}
public discoverBiome(planet: LocatablePlanet): void {
const key = this.getBiomeKey(planet.biome);
const item = localStorage.getItem(key);
if (item !== 'true') {
const notifManager = NotificationManager.getInstance();
localStorage.setItem(key, 'true');
notifManager.foundBiome(planet);
}
}
public getAllPlayers(): Player[] {
return this.gameManager.getAllPlayers();
}
public getSelectedPlanet(): LocatablePlanet | undefined {
const planet = this.getPlanetWithId(this.selectedPlanetId);
if (isLocatable(planet)) {
return planet;
}
return undefined;
}
public getPreviousSelectedPlanet(): Planet | undefined {
return this.getPlanetWithId(this.previousSelectedPlanetId);
}
public setSelectedId(id: LocationId): void {
const planet = this.getPlanetWithId(id);
if (planet && isLocatable(planet)) this.setSelectedPlanet(planet);
}
public setSelectedPlanet(planet: LocatablePlanet | undefined): void {
this.previousSelectedPlanetId = this.selectedPlanetId;
if (!planet) {
const tutorialManager = TutorialManager.getInstance(this);
tutorialManager.acceptInput(TutorialState.Deselect);
}
const uiEmitter = UIEmitter.getInstance();
this.selectedPlanetId = planet?.locationId;
if (!planet) {
this.selectedCoords = undefined;
} else {
const loc = this.getLocationOfPlanet(planet.locationId);
if (!loc) this.selectedCoords = undefined;
else {
// loc is not undefined
this.selectedCoords = loc.coords;
if (coordsEqual(loc.coords, this.getHomeCoords())) {
const tutorialManager = TutorialManager.getInstance(this);
tutorialManager.acceptInput(TutorialState.HomePlanet);
}
}
}
uiEmitter.emit(UIEmitterEvent.GamePlanetSelected);
this.selectedPlanetId$.publish(planet?.locationId);
}
public getSelectedCoords(): WorldCoords | undefined {
return this.selectedCoords;
}
public getMouseDownPlanet(): LocatablePlanet | undefined {
if (this.isSending && this.sendingPlanet) return this.sendingPlanet;
return this.mouseDownOverPlanet;
}
public onSendInit(planet: LocatablePlanet | undefined): void {
this.modalManager.setCursorState(CursorState.TargetingForces);
this.isSending = true;
this.sendingPlanet = planet;
const loc = planet && this.getLocationOfPlanet(planet.locationId);
this.sendingCoords = loc ? loc.coords : { x: 0, y: 0 };
}
public onSendComplete(locationId: LocationId): void {
this.modalManager.setCursorState(CursorState.Normal);
// Set to undefined after SendComplete so it can send another one
this.artifactSending[locationId] = undefined;
this.sendingPlanet = undefined;
// Done at the end so they clear the artifact
this.setSending(false);
this.setAbandoning(false);
}
public onSendCancel(): void {
this.modalManager.setCursorState(CursorState.Normal);
this.sendingPlanet = undefined;
this.sendingCoords = undefined;
this.setSending(false);
this.setAbandoning(false);
}
public hasMinedChunk(chunkLocation: Rectangle): boolean {
return this.gameManager.hasMinedChunk(chunkLocation);
}
public getChunk(chunkFootprint: Rectangle): Chunk | undefined {
return this.gameManager.getChunk(chunkFootprint);
}
public spaceTypeFromPerlin(perlin: number): SpaceType {
return this.gameManager.spaceTypeFromPerlin(perlin);
}
public getSpaceTypePerlin(coords: WorldCoords, floor: boolean): number {
return this.gameManager.spaceTypePerlin(coords, floor);
}
public getBiomePerlin(coords: WorldCoords, floor: boolean): number {
return this.gameManager.biomebasePerlin(coords, floor);
}
public onDiscoveredChunk(chunk: Chunk): void {
const res = this.gameManager.getCurrentlyExploringChunk();
const account = this.getAccount();
const config = {
contractAddress: this.getContractAddress(),
account,
};
if (res) {
const { bottomLeft, sideLength } = res;
this.minerLocation = {
x: bottomLeft.x + sideLength / 2,
y: bottomLeft.y + sideLength / 2,
};
} else {
this.minerLocation = undefined;
}
const notifManager = NotificationManager.getInstance();
for (const loc of chunk.planetLocations) {
const planet = this.getPlanetWithId(loc.hash);
if (!planet || !account) break;
if (planet.owner === EMPTY_ADDRESS && planet.energy > 0) {
if (
!this.getBooleanSetting(Setting.FoundPirates) &&
this.getBooleanSetting(Setting.TutorialCompleted)
) {
notifManager.foundPirates(planet);
setBooleanSetting(config, Setting.FoundPirates, true);
}
}
if (planet.planetType === PlanetType.SILVER_MINE) {
if (
!this.getBooleanSetting(Setting.FoundSilver) &&
this.getBooleanSetting(Setting.TutorialCompleted)
) {
notifManager.foundSilver(planet);
setBooleanSetting(config, Setting.FoundSilver, true);
}
}
if (planet.planetType === PlanetType.SILVER_BANK) {
if (
!this.getBooleanSetting(Setting.FoundSilverBank) &&
this.getBooleanSetting(Setting.TutorialCompleted)
) {
notifManager.foundSilverBank(planet);
setBooleanSetting(config, Setting.FoundSilverBank, true);
}
}
if (planet.planetType === PlanetType.TRADING_POST) {
if (
!this.getBooleanSetting(Setting.FoundTradingPost) &&
this.getBooleanSetting(Setting.TutorialCompleted)
) {
notifManager.foundTradingPost(planet);
setBooleanSetting(config, Setting.FoundTradingPost, true);
}
}
if (planetHasBonus(planet)) {
if (
!this.getBooleanSetting(Setting.FoundComet) &&
this.getBooleanSetting(Setting.TutorialCompleted)
) {
notifManager.foundComet(planet);
setBooleanSetting(config, Setting.FoundComet, true);
}
}
if (isLocatable(planet) && planet.planetType === PlanetType.PLANET) {
this.discoverBiome(planet);
}
if (isLocatable(planet) && planet.planetType === PlanetType.RUINS) {
if (
!this.getBooleanSetting(Setting.FoundArtifact) &&
this.getBooleanSetting(Setting.TutorialCompleted)
) {
notifManager.foundFoundry(planet);
setBooleanSetting(config, Setting.FoundArtifact, true);
}
}
}
if (account !== undefined) {
if (this.spaceTypeFromPerlin(chunk.perlin) === SpaceType.DEEP_SPACE) {
if (
!this.getBooleanSetting(Setting.FoundDeepSpace) &&
this.getBooleanSetting(Setting.TutorialCompleted)
) {
notifManager.foundDeepSpace(chunk);
setBooleanSetting(config, Setting.FoundDeepSpace, true);
}
} else if (this.spaceTypeFromPerlin(chunk.perlin) === SpaceType.SPACE) {
if (
!this.getBooleanSetting(Setting.FoundSpace) &&
this.getBooleanSetting(Setting.TutorialCompleted)
) {
notifManager.foundSpace(chunk);
setBooleanSetting(config, Setting.FoundSpace, true);
}
} else if (this.spaceTypeFromPerlin(chunk.perlin) === SpaceType.DEAD_SPACE) {
if (
!this.getBooleanSetting(Setting.FoundDeepSpace) &&
this.getBooleanSetting(Setting.TutorialCompleted)
) {
notifManager.foundDeadSpace(chunk);
setBooleanSetting(config, Setting.FoundDeepSpace, true);
}
}
}
}
public getMinerLocation(): WorldCoords | undefined {
return this.minerLocation;
}
public setExtraMinerLocation(idx: number, coords: WorldCoords): void {
this.extraMinerLocations[idx] = coords;
}
public removeExtraMinerLocation(idx: number): void {
this.extraMinerLocations.splice(idx, 1);
}
public getAllMinerLocations(): WorldCoords[] {
if (this.minerLocation) {
return [this.minerLocation, ...this.extraMinerLocations];
} else {
return this.extraMinerLocations;
}
}
public getMouseDownCoords(): WorldCoords | undefined {
if (this.isSending && this.sendingPlanet) return this.sendingCoords;
return this.mouseDownOverCoords;
}
public setHoveringOverPlanet(planet: LocatablePlanet | undefined, inRenderer: boolean) {
const lastHover = this.mouseHoveringOverPlanet;
this.mouseHoveringOverPlanet = planet;
if (lastHover?.locationId !== planet?.locationId) {
this.hoverPlanetId$.publish(planet?.locationId);
this.planetHoveringInRenderer = inRenderer;
}
}
public setHoveringOverArtifact(artifactId?: ArtifactId) {
this.hoverArtifactId$.publish(artifactId);
this.hoverArtifact$.publish(artifactId ? this.getArtifactWithId(artifactId) : undefined);
}
public getHoveringOverPlanet(): Planet | undefined {
return this.mouseHoveringOverPlanet;
}
public getHoveringOverCoords(): WorldCoords | undefined {
return this.mouseHoveringOverCoords;
}
public isSendingForces(): boolean {
return this.isSending;
}
/**
* Percent from 0 to 100.
*/
public getForcesSending(planetId?: LocationId): number {
const defaultSending = 50;
if (!planetId) return defaultSending;
if (this.isAbandoning()) return 100;
if (this.isSendingShip(planetId)) return 0;
const forces = this.forcesSending[planetId];
return forces ?? defaultSending;
}
/**
* Percent from 0 to 100.
*/
public getSilverSending(planetId?: LocationId): number {
const defaultSending = 0;
if (!planetId) return defaultSending;
if (this.isAbandoning()) return 100;
if (this.isSendingShip(planetId)) return 0;
return this.silverSending[planetId] ?? defaultSending;
}
public isAbandoning(): boolean {
return this.abandoning;
}
public getArtifactSending(planetId?: LocationId): Artifact | undefined {
if (!planetId) return undefined;
return this.artifactSending[planetId];
}
public getAbandonSpeedChangePercent(): number {
const { SPACE_JUNK_ENABLED, ABANDON_SPEED_CHANGE_PERCENT } = this.contractConstants;
if (SPACE_JUNK_ENABLED) {
return ABANDON_SPEED_CHANGE_PERCENT;
} else {
return 100;
}
}
public getAbandonRangeChangePercent(): number {
const { SPACE_JUNK_ENABLED, ABANDON_RANGE_CHANGE_PERCENT } = this.contractConstants;
if (SPACE_JUNK_ENABLED) {
return ABANDON_RANGE_CHANGE_PERCENT;
} else {
return 100;
}
}
public isSendingShip(planetId?: LocationId): boolean {
if (!planetId) return false;
return isSpaceShip(this.artifactSending[planetId]?.artifactType);
}
public isOverOwnPlanet(coords: WorldCoords): Planet | undefined {
const res = this.viewportEntities.getNearestVisiblePlanet(coords);
const planet: LocatablePlanet | undefined = res;
if (!planet) {
return undefined;
}
return planet.owner === this.gameManager.getAccount() ? planet : undefined;
}
public getMyArtifacts(): Artifact[] {
return this.gameManager.getMyArtifacts();
}
public getMyArtifactsNotOnPlanet(): Artifact[] {
return this.getMyArtifacts().filter((a) => !a.onPlanetId);
}
public getPlanetWithId(planetId: LocationId | undefined): Planet | undefined {
return this.gameManager.getPlanetWithId(planetId);
}
public getMyScore(): number | undefined {
return this.gameManager.getMyScore();
}
public getPlayer(address?: EthAddress): Player | undefined {
return this.gameManager.getPlayer(address);
}
public getArtifactWithId(artifactId: ArtifactId | undefined): Artifact | undefined {
return this.gameManager.getArtifactWithId(artifactId);
}
public getPlanetWithCoords(coords: WorldCoords | undefined): Planet | undefined {
return coords && this.gameManager.getPlanetWithCoords(coords);
}
public getArtifactsWithIds(artifactIds?: ArtifactId[]): Array {
return this.gameManager.getArtifactsWithIds(artifactIds);
}
public getArtifactPlanet(artifact: Artifact): Planet | undefined {
if (!artifact.onPlanetId) return undefined;
return this.getPlanetWithId(artifact.onPlanetId);
}
public getPlanetLevel(planetId: LocationId): PlanetLevel | undefined {
return this.gameManager.getPlanetLevel(planetId);
}
public getAllOwnedPlanets(): Planet[] {
return this.gameManager.getAllOwnedPlanets();
}
public getAllVoyages(): QueuedArrival[] {
return this.gameManager.getAllVoyages();
}
public getSpeedBuff(): number {
return this.gameManager.getSpeedBuff(this.abandoning);
}
public getRangeBuff(): number {
return this.gameManager.getRangeBuff(this.abandoning);
}
/**
* @todo delete this. now that {@link GameObjects} is publically accessible, we shouldn't need to
* drill fields like this anymore.
* @tutorial Plugin developers, please access fields like this with something like {@code df.getGameObjects().}
* @deprecated
*/
public getUnconfirmedMoves(): Transaction[] {
return this.gameManager.getUnconfirmedMoves();
}
public getUnconfirmedUpgrades(): Transaction[] {
return this.gameManager.getUnconfirmedUpgrades();
}
public isCurrentlyRevealing(): boolean {
return this.gameManager.getNextRevealCountdownInfo().currentlyRevealing;
}
public getUnconfirmedWormholeActivations(): Transaction[] {
return this.gameManager.getUnconfirmedWormholeActivations();
}
public getWormholes(): Iterable {
return this.gameManager.getWormholes();
}
public getLocationOfPlanet(planetId: LocationId): WorldLocation | undefined {
return this.gameManager.getLocationOfPlanet(planetId);
}
public getExploredChunks(): Iterable {
return this.gameManager.getExploredChunks();
}
public getLocationsAndChunks() {
return this.viewportEntities.getPlanetsAndChunks();
}
public getCaptureZones() {
return this.gameManager.getCaptureZones();
}
public getCaptureZoneGenerator() {
return this.gameManager.getCaptureZoneGenerator();
}
public getIsHighPerfMode(): boolean {
const account = this.getAccount();
if (account === undefined) {
return false;
}
return this.getBooleanSetting(Setting.HighPerformanceRendering);
}
public getPlanetsInViewport(): Planet[] {
return Array.from(this.viewportEntities.getPlanetsAndChunks().cachedPlanets.values()).map(
(p) => p.planet
);
}
public getWorldRadius(): number {
return this.gameManager.getWorldRadius();
}
public getWorldSilver(): number {
return this.gameManager.getWorldSilver();
}
public getUniverseTotalEnergy(): number {
return this.gameManager.getUniverseTotalEnergy();
}
public getSilverOfPlayer(player: EthAddress): number {
return this.gameManager.getSilverOfPlayer(player);
}
public getEnergyOfPlayer(player: EthAddress): number {
return this.gameManager.getEnergyOfPlayer(player);
}
public getPlayerScore(player: EthAddress): number | undefined {
return this.gameManager.getPlayerScore(player);
}
public upgrade(planet: Planet, branch: number): void {
// TODO: do something like JSON.stringify(args) so we know formatting is correct
this.terminal.current?.printShellLn(`df.upgrade('${planet.locationId}', ${branch})`);
this.gameManager.upgrade(planet.locationId, branch);
}
public buyHat(planet: Planet): void {
// TODO: do something like JSON.stringify(args) so we know formatting is correct
this.terminal.current?.printShellLn(`df.buyHat('${planet.locationId}')`);
this.gameManager.buyHat(planet.locationId);
}
// non-nullable
public getHomeCoords(): WorldCoords {
return this.gameManager.getHomeCoords() || { x: 0, y: 0 };
}
public getHomeHash(): LocationId | undefined {
return this.gameManager.getHomeHash();
}
public getHomePlanet(): Planet | undefined {
const homeHash = this.getHomeHash();
if (!homeHash) return undefined;
return this.getPlanetWithId(homeHash);
}
public getRadiusOfPlanetLevel(planetRarity: PlanetLevel): number {
return this.radiusMap[planetRarity];
}
public getEnergyCurveAtPercent(planet: Planet, percent: number): number {
return this.gameManager.getEnergyCurveAtPercent(planet, percent);
}
public getSilverCurveAtPercent(planet: Planet, percent: number): number | undefined {
return this.gameManager.getSilverCurveAtPercent(planet, percent);
}
public getHashesPerSec(): number {
return this.gameManager.getHashesPerSec();
}
public generateVerificationTweet(twitter: string): Promise {
return this.gameManager.getSignedTwitter(twitter);
}
public getPerlinThresholds(): [number, number, number] {
return this.gameManager.getPerlinThresholds();
}
public getHashConfig(): HashConfig {
return this.gameManager.getHashConfig();
}
public getViewport(): Viewport {
return Viewport.getInstance();
}
public getPlanetMap(): Map {
return this.gameManager.getPlanetMap();
}
public getArtifactMap(): Map {
return this.gameManager.getArtifactMap();
}
public getMyPlanetMap(): Map {
return this.gameManager.getMyPlanetMap();
}
public getMyArtifactMap(): Map {
return this.gameManager.getMyArtifactMap();
}
public getTerminal(): TerminalHandle | undefined {
return this.terminal.current;
}
public get contractConstants(): ContractConstants {
return this.gameManager.getContractConstants();
}
public getSpaceJunkEnabled(): boolean {
return this.contractConstants.SPACE_JUNK_ENABLED;
}
public get captureZonesEnabled(): boolean {
return this.contractConstants.CAPTURE_ZONES_ENABLED;
}
public potentialCaptureScore(planetLevel: number): number {
return this.contractConstants.CAPTURE_ZONE_PLANET_LEVEL_SCORE[planetLevel];
}
public getDefaultSpaceJunkForPlanetLevel(level: number): number {
return this.contractConstants.PLANET_LEVEL_JUNK[level];
}
public getPerlinConfig(isBiome = false): PerlinConfig {
const hashConfig = this.gameManager.getHashConfig();
const key = isBiome ? hashConfig.biomebaseKey : hashConfig.spaceTypeKey;
return {
key,
scale: hashConfig.perlinLengthScale,
mirrorX: hashConfig.perlinMirrorX,
mirrorY: hashConfig.perlinMirrorY,
floor: false,
};
}
/**
* Gets a reference to the game's internal representation of the world state. Beware! Use this for
* reading only, otherwise you might mess up the state of the game. You can try modifying the game
* state in some way
*/
public getGameObjects(): GameObjects {
return this.gameManager.getGameObjects();
}
// internal utils
private updatePlanets() {
if (this.mouseDownOverPlanet) {
this.mouseDownOverPlanet = this.gameManager.getPlanetWithId(
this.mouseDownOverPlanet.locationId
) as LocatablePlanet;
}
if (this.mouseHoveringOverPlanet) {
this.setHoveringOverPlanet(
this.gameManager.getPlanetWithId(
this.mouseHoveringOverPlanet.locationId
) as LocatablePlanet,
true
);
}
}
private updateMouseHoveringOverCoords(coords: WorldCoords): WorldCoords {
// if the mouse is inside hitbox of a planet, snaps the mouse to center of planet
this.mouseHoveringOverCoords = coords;
let hoveringPlanet = undefined;
const res = this.viewportEntities.getNearestVisiblePlanet(coords);
if (res) {
hoveringPlanet = res;
this.mouseHoveringOverCoords = res.location.coords;
}
this.setHoveringOverPlanet(hoveringPlanet, true);
this.mouseHoveringOverCoords = {
x: Math.round(this.mouseHoveringOverCoords.x),
y: Math.round(this.mouseHoveringOverCoords.y),
};
return this.mouseHoveringOverCoords;
}
private onEmitInitializedPlayer() {
this.emit(GameUIManagerEvent.InitializedPlayer);
}
private onEmitInitializedPlayerError(err: React.ReactNode) {
this.emit(GameUIManagerEvent.InitializedPlayerError, err);
}
public getGameManager(): GameManager {
return this.gameManager;
}
private setModalManager(modalManager: ModalManager) {
this.modalManager = modalManager;
}
public getModalManager(): ModalManager {
return this.modalManager;
}
/**
* If there is a planet being hovered over, returns whether or not it's being hovered
* over in the renderer.
*/
public getPlanetHoveringInRenderer() {
return this.planetHoveringInRenderer;
}
public getRenderer(): Renderer | null {
return Renderer.instance;
}
getPaused(): boolean {
return this.gameManager.getPaused();
}
getPaused$(): Monomitter {
return this.gameManager.getPaused$();
}
public getSilverScoreValue(): number {
return this.contractConstants.SILVER_SCORE_VALUE;
}
public getArtifactPointValues() {
return this.contractConstants.ARTIFACT_POINT_VALUES;
}
public getCaptureZonePointValues() {
return this.contractConstants.CAPTURE_ZONE_PLANET_LEVEL_SCORE;
}
public getArtifactUpdated$() {
return this.gameManager.getArtifactUpdated$();
}
public getUIEmitter() {
return UIEmitter.getInstance();
}
/**
* @returns - A wrapper class for the WebGL2RenderingContext.
*/
public getGlManager(): GameGLManager | null {
const renderer = this.getRenderer();
if (renderer) return renderer.glManager;
return null;
}
/**
* @returns the CanvasRenderingContext2D for the game canvas.
*/
public get2dRenderer(): CanvasRenderingContext2D | null {
const renderer = this.getRenderer();
if (renderer) return renderer.get2DRenderer();
return null;
}
/**
* Replaces the current renderer with the passed in custom renderer and adds the renderer
* to the rendering stack. The function will automatically determine which renderer it is
* by the rendererType and the methods in the renderer.
* @param customRenderer - a Renderer that follows one of the 23 renderer tempaltes
*/
public setCustomRenderer(customRenderer: BaseRenderer) {
const renderer = this.getRenderer();
if (renderer) renderer.addCustomRenderer(customRenderer);
}
/**
* This function will remove the passed in renderer from the renderering stack. If the
* renderer is on top of the renderering stack the next renderer will be the one bellow it.
* @param customRenderer - a Renderer that follows one of the 23 renderer tempaltes
*/
public disableCustomRenderer(customRenderer: BaseRenderer) {
const renderer = this.getRenderer();
if (renderer) renderer.removeCustomRenderer(customRenderer);
}
}
export default GameUIManager;
================================================
FILE: src/Backend/GameLogic/InitialGameStateDownloader.tsx
================================================
import {
Artifact,
ArtifactId,
ClaimedCoords,
LocationId,
Planet,
Player,
QueuedArrival,
RevealedCoords,
VoyageId,
} from '@darkforest_eth/types';
import _ from 'lodash';
import React from 'react';
import { Link } from '../../Frontend/Components/CoreUI';
import { LoadingBarHandle } from '../../Frontend/Components/TextLoadingBar';
import { DarkForestTips } from '../../Frontend/Views/DarkForestTips';
import { TerminalHandle } from '../../Frontend/Views/Terminal';
import { ContractConstants } from '../../_types/darkforest/api/ContractsAPITypes';
import { AddressTwitterMap } from '../../_types/darkforest/api/UtilityServerAPITypes';
import { tryGetAllTwitters } from '../Network/UtilityServerAPI';
import PersistentChunkStore from '../Storage/PersistentChunkStore';
import { ContractsAPI } from './ContractsAPI';
export interface InitialGameState {
contractConstants: ContractConstants;
players: Map;
worldRadius: number;
allTouchedPlanetIds: LocationId[];
allRevealedCoords: RevealedCoords[];
allClaimedCoords?: ClaimedCoords[];
pendingMoves: QueuedArrival[];
touchedAndLocatedPlanets: Map;
artifactsOnVoyages: Artifact[];
myArtifacts: Artifact[];
heldArtifacts: Artifact[][];
loadedPlanets: LocationId[];
revealedCoordsMap: Map;
claimedCoordsMap?: Map;
planetVoyageIdMap: Map;
arrivals: Map;
twitters: AddressTwitterMap;
paused: boolean;
}
export class InitialGameStateDownloader {
private terminal: TerminalHandle;
public constructor(terminal: TerminalHandle) {
this.terminal = terminal;
}
private makeProgressListener(prettyEntityName: string) {
const ref = React.createRef();
this.terminal.printLoadingBar(prettyEntityName, ref);
this.terminal.newline();
return (percent: number) => {
ref.current?.setFractionCompleted(percent);
};
}
async download(
contractsAPI: ContractsAPI,
persistentChunkStore: PersistentChunkStore
): Promise {
const isDev = process.env.NODE_ENV !== 'production';
/**
* In development we use the same contract address every time we deploy,
* so storage is polluted with the IDs of old universes.
*/
const storedTouchedPlanetIds = isDev
? []
: await persistentChunkStore.getSavedTouchedPlanetIds();
const storedRevealedCoords = isDev ? [] : await persistentChunkStore.getSavedRevealedCoords();
this.terminal.printElement();
this.terminal.newline();
const planetIdsLoadingBar = this.makeProgressListener('Planet IDs');
const playersLoadingBar = this.makeProgressListener('Players');
const revealedPlanetsLoadingBar = this.makeProgressListener('Revealed Planet IDs');
const revealedPlanetsCoordsLoadingBar = this.makeProgressListener(
'Revealed Planet Coordinates'
);
const pendingMovesLoadingBar = this.makeProgressListener('Pending Moves');
const planetsLoadingBar = this.makeProgressListener('Planets');
const planetsMetadataLoadingBar = this.makeProgressListener('Planet Metadatas');
const artifactsOnPlanetsLoadingBar = this.makeProgressListener('Artifacts On Planets');
const artifactsInFlightLoadingBar = this.makeProgressListener('Artifacts On Moves');
const yourArtifactsLoadingBar = this.makeProgressListener('Your Artifacts');
const contractConstants = contractsAPI.getConstants();
const worldRadius = contractsAPI.getWorldRadius();
const players = contractsAPI.getPlayers(playersLoadingBar);
const arrivals: Map = new Map();
const planetVoyageIdMap: Map = new Map();
const minedChunks = Array.from(await persistentChunkStore.allChunks());
const minedPlanetIds = new Set(
_.flatMap(minedChunks, (c) => c.planetLocations).map((l) => l.hash)
);
const loadedTouchedPlanetIds = contractsAPI.getTouchedPlanetIds(
storedTouchedPlanetIds.length,
planetIdsLoadingBar
);
const loadedRevealedCoords = contractsAPI.getRevealedPlanetsCoords(
storedRevealedCoords.length,
revealedPlanetsLoadingBar,
revealedPlanetsCoordsLoadingBar
);
const claimedCoordsMap = new Map