Archives/tobspr_shapez.io
1
0
Fork 0
mirror of https://github.com/tobspr/shapez.io.git synced 2026-03-02 03:39:21 +00:00
Code Issues Projects Releases Wiki Activity

Add belt reader building

Browse Source
This commit is contained in:
tobspr
2020-08-29 10:38:23 +02:00
parent bb739c80fa
commit 06e276f021
28 changed files with 1397 additions and 1069 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/js/game/buildings/filter.js
View File

@@ -1,16 +1,15 @@
import { enumDirection, Vector } from "../../core/vector";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector";
import {
enumItemProcessorRequirements,
enumItemProcessorTypes,
ItemProcessorComponent,
} from "../components/item_processor";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { LeverComponent } from "../components/lever";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector";
import {
ItemProcessorComponent,
enumItemProcessorTypes,
enumItemProcessorRequirements,
} from "../components/item_processor";
export class MetaFilterBuilding extends MetaBuilding {
constructor() {

101
src/js/game/buildings/reader.js Normal file
View File

@@ -0,0 +1,101 @@
import { enumDirection, Vector } from "../../core/vector";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { BeltUnderlaysComponent } from "../components/belt_underlays";
import { BeltReaderComponent } from "../components/belt_reader";
export class MetaReaderBuilding extends MetaBuilding {
constructor() {
super("reader");
}
getSilhouetteColor() {
return "#25fff2";
}
/**
* @param {GameRoot} root
*/
getIsUnlocked(root) {
// @todo
return true;
}
getDimensions() {
return new Vector(1, 1);
}
getShowWiresLayerPreview() {
return true;
}
/**
* Creates the entity at the given location
* @param {Entity} entity
*/
setupEntityComponents(entity) {
entity.addComponent(
new WiredPinsComponent({
slots: [
{
pos: new Vector(0, 0),
direction: enumDirection.right,
type: enumPinSlotType.logicalEjector,
},
{
pos: new Vector(0, 0),
direction: enumDirection.left,
type: enumPinSlotType.logicalEjector,
},
],
})
);
entity.addComponent(
new ItemAcceptorComponent({
slots: [
{
pos: new Vector(0, 0),
directions: [enumDirection.bottom],
},
],
})
);
entity.addComponent(
new ItemEjectorComponent({
slots: [
{
pos: new Vector(0, 0),
direction: enumDirection.top,
},
],
})
);
entity.addComponent(
new ItemProcessorComponent({
processorType: enumItemProcessorTypes.reader,
inputsPerCharge: 1,
})
);
entity.addComponent(
new BeltUnderlaysComponent({
underlays: [
{
pos: new Vector(0, 0),
direction: enumDirection.top,
},
],
})
);
entity.addComponent(new BeltReaderComponent());
}
}

2
src/js/game/component_registry.js
View File

@@ -16,6 +16,7 @@ import { LogicGateComponent } from "./components/logic_gate";
import { LeverComponent } from "./components/lever";
import { WireTunnelComponent } from "./components/wire_tunnel";
import { DisplayComponent } from "./components/display";
import { BeltReaderComponent } from "./components/belt_reader";
export function initComponentRegistry() {
gComponentRegistry.register(StaticMapEntityComponent);
@@ -35,6 +36,7 @@ export function initComponentRegistry() {
gComponentRegistry.register(LeverComponent);
gComponentRegistry.register(WireTunnelComponent);
gComponentRegistry.register(DisplayComponent);
gComponentRegistry.register(BeltReaderComponent);
// IMPORTANT ^^^^^ UPDATE ENTITY COMPONENT STORAGE AFTERWARDS

40
src/js/game/components/belt_reader.js Normal file
View File

@@ -0,0 +1,40 @@
import { Component } from "../component";
import { BaseItem } from "../base_item";
export class BeltReaderComponent extends Component {
static getId() {
return "BeltReader";
}
duplicateWithoutContents() {
return new BeltReaderComponent();
}
constructor() {
super();
/**
* Which items went through the reader, we only store the time
* @type {Array<number>}
*/
this.lastItemTimes = [];
/**
* Which item passed the reader last
* @type {BaseItem}
*/
this.lastItem = null;
/**
* Stores the last throughput we computed
* @type {number}
*/
this.lastThroughput = 0;
/**
* Stores when we last computed the throughput
* @type {number}
*/
this.lastThroughputComputation = 0;
}
}

1
src/js/game/components/item_processor.js
View File

@@ -20,6 +20,7 @@ export const enumItemProcessorTypes = {
painterQuad: "painterQuad",
hub: "hub",
filter: "filter",
reader: "reader",
};
/** @enum {string} */

168
src/js/game/entity_components.js
View File

@@ -1,82 +1,86 @@
/* typehints:start */
import { BeltComponent } from "./components/belt";
import { BeltUnderlaysComponent } from "./components/belt_underlays";
import { HubComponent } from "./components/hub";
import { ItemAcceptorComponent } from "./components/item_acceptor";
import { ItemEjectorComponent } from "./components/item_ejector";
import { ItemProcessorComponent } from "./components/item_processor";
import { MinerComponent } from "./components/miner";
import { StaticMapEntityComponent } from "./components/static_map_entity";
import { StorageComponent } from "./components/storage";
import { UndergroundBeltComponent } from "./components/underground_belt";
import { WiredPinsComponent } from "./components/wired_pins";
import { WireComponent } from "./components/wire";
import { ConstantSignalComponent } from "./components/constant_signal";
import { LogicGateComponent } from "./components/logic_gate";
import { LeverComponent } from "./components/lever";
import { WireTunnelComponent } from "./components/wire_tunnel";
import { DisplayComponent } from "./components/display";
/* typehints:end */
/**
* Typedefs for all entity components. These are not actually present on the entity,
* thus they are undefined by default
*/
export class EntityComponentStorage {
constructor() {
/* typehints:start */
/** @type {StaticMapEntityComponent} */
this.StaticMapEntity;
/** @type {BeltComponent} */
this.Belt;
/** @type {ItemEjectorComponent} */
this.ItemEjector;
/** @type {ItemAcceptorComponent} */
this.ItemAcceptor;
/** @type {MinerComponent} */
this.Miner;
/** @type {ItemProcessorComponent} */
this.ItemProcessor;
/** @type {UndergroundBeltComponent} */
this.UndergroundBelt;
/** @type {HubComponent} */
this.Hub;
/** @type {StorageComponent} */
this.Storage;
/** @type {WiredPinsComponent} */
this.WiredPins;
/** @type {BeltUnderlaysComponent} */
this.BeltUnderlays;
/** @type {WireComponent} */
this.Wire;
/** @type {ConstantSignalComponent} */
this.ConstantSignal;
/** @type {LogicGateComponent} */
this.LogicGate;
/** @type {LeverComponent} */
this.Lever;
/** @type {WireTunnelComponent} */
this.WireTunnel;
/** @type {DisplayComponent} */
this.Display;
/* typehints:end */
}
}
/* typehints:start */
import { BeltComponent } from "./components/belt";
import { BeltUnderlaysComponent } from "./components/belt_underlays";
import { HubComponent } from "./components/hub";
import { ItemAcceptorComponent } from "./components/item_acceptor";
import { ItemEjectorComponent } from "./components/item_ejector";
import { ItemProcessorComponent } from "./components/item_processor";
import { MinerComponent } from "./components/miner";
import { StaticMapEntityComponent } from "./components/static_map_entity";
import { StorageComponent } from "./components/storage";
import { UndergroundBeltComponent } from "./components/underground_belt";
import { WiredPinsComponent } from "./components/wired_pins";
import { WireComponent } from "./components/wire";
import { ConstantSignalComponent } from "./components/constant_signal";
import { LogicGateComponent } from "./components/logic_gate";
import { LeverComponent } from "./components/lever";
import { WireTunnelComponent } from "./components/wire_tunnel";
import { DisplayComponent } from "./components/display";
import { BeltReaderComponent } from "./components/belt_reader";
/* typehints:end */
/**
* Typedefs for all entity components. These are not actually present on the entity,
* thus they are undefined by default
*/
export class EntityComponentStorage {
constructor() {
/* typehints:start */
/** @type {StaticMapEntityComponent} */
this.StaticMapEntity;
/** @type {BeltComponent} */
this.Belt;
/** @type {ItemEjectorComponent} */
this.ItemEjector;
/** @type {ItemAcceptorComponent} */
this.ItemAcceptor;
/** @type {MinerComponent} */
this.Miner;
/** @type {ItemProcessorComponent} */
this.ItemProcessor;
/** @type {UndergroundBeltComponent} */
this.UndergroundBelt;
/** @type {HubComponent} */
this.Hub;
/** @type {StorageComponent} */
this.Storage;
/** @type {WiredPinsComponent} */
this.WiredPins;
/** @type {BeltUnderlaysComponent} */
this.BeltUnderlays;
/** @type {WireComponent} */
this.Wire;
/** @type {ConstantSignalComponent} */
this.ConstantSignal;
/** @type {LogicGateComponent} */
this.LogicGate;
/** @type {LeverComponent} */
this.Lever;
/** @type {WireTunnelComponent} */
this.WireTunnel;
/** @type {DisplayComponent} */
this.Display;
/** @type {BeltReaderComponent} */
this.BeltReader;
/* typehints:end */
}
}

5
src/js/game/game_system_manager.js
View File

@@ -21,6 +21,7 @@ import { LogicGateSystem } from "./systems/logic_gate";
import { LeverSystem } from "./systems/lever";
import { DisplaySystem } from "./systems/display";
import { ItemProcessorOverlaysSystem } from "./systems/item_processor_overlays";
import { BeltReaderSystem } from "./systems/belt_reader";
const logger = createLogger("game_system_manager");
@@ -88,6 +89,9 @@ export class GameSystemManager {
/** @type {ItemProcessorOverlaysSystem} */
itemProcessorOverlays: null,
/** @type {BeltReaderSystem} */
beltReader: null,
/* typehints:end */
};
this.systemUpdateOrder = [];
@@ -141,6 +145,7 @@ export class GameSystemManager {
// IMPORTANT: We have 2 phases: In phase 1 we compute the output values of all gates,
// processors etc. In phase 2 we propagate it through the wires network
add("logicGate", LogicGateSystem);
add("beltReader", BeltReaderSystem);
// Wires must be after all gate, signal etc logic!
add("wire", WireSystem);

895
src/js/game/hub_goals.js
View File

@@ -1,447 +1,448 @@
import { globalConfig } from "../core/config";
import { clamp, findNiceIntegerValue, randomChoice, randomInt } from "../core/utils";
import { BasicSerializableObject, types } from "../savegame/serialization";
import { enumColors } from "./colors";
import { enumItemProcessorTypes } from "./components/item_processor";
import { GameRoot } from "./root";
import { enumSubShape, ShapeDefinition } from "./shape_definition";
import { enumHubGoalRewards, tutorialGoals } from "./tutorial_goals";
import { UPGRADES } from "./upgrades";
export class HubGoals extends BasicSerializableObject {
static getId() {
return "HubGoals";
}
static getSchema() {
return {
level: types.uint,
storedShapes: types.keyValueMap(types.uint),
upgradeLevels: types.keyValueMap(types.uint),
currentGoal: types.structured({
definition: types.knownType(ShapeDefinition),
required: types.uint,
reward: types.nullable(types.enum(enumHubGoalRewards)),
}),
};
}
deserialize(data) {
const errorCode = super.deserialize(data);
if (errorCode) {
return errorCode;
}
// Compute gained rewards
for (let i = 0; i < this.level - 1; ++i) {
if (i < tutorialGoals.length) {
const reward = tutorialGoals[i].reward;
this.gainedRewards[reward] = (this.gainedRewards[reward] || 0) + 1;
}
}
// Compute upgrade improvements
for (const upgradeId in UPGRADES) {
const upgradeHandle = UPGRADES[upgradeId];
const level = this.upgradeLevels[upgradeId] || 0;
let totalImprovement = upgradeHandle.baseValue || 1;
for (let i = 0; i < level; ++i) {
totalImprovement += upgradeHandle.tiers[i].improvement;
}
this.upgradeImprovements[upgradeId] = totalImprovement;
}
// Compute current goal
const goal = tutorialGoals[this.level - 1];
if (goal) {
this.currentGoal = {
/** @type {ShapeDefinition} */
definition: this.root.shapeDefinitionMgr.getShapeFromShortKey(goal.shape),
required: goal.required,
reward: goal.reward,
};
}
}
/**
* @param {GameRoot} root
*/
constructor(root) {
super();
this.root = root;
this.level = 1;
/**
* Which story rewards we already gained
* @type {Object.<string, number>}
*/
this.gainedRewards = {};
/**
* Mapping from shape hash -> amount
* @type {Object<string, number>}
*/
this.storedShapes = {};
/**
* Stores the levels for all upgrades
* @type {Object<string, number>}
*/
this.upgradeLevels = {};
/**
* Stores the improvements for all upgrades
* @type {Object<string, number>}
*/
this.upgradeImprovements = {};
for (const key in UPGRADES) {
this.upgradeImprovements[key] = UPGRADES[key].baseValue || 1;
}
this.createNextGoal();
// Allow quickly switching goals in dev mode
if (G_IS_DEV) {
window.addEventListener("keydown", ev => {
if (ev.key === "b") {
// root is not guaranteed to exist within ~0.5s after loading in
if (this.root && this.root.app && this.root.app.gameAnalytics) {
this.onGoalCompleted();
}
}
});
}
}
/**
* Returns how much of the current shape is stored
* @param {ShapeDefinition} definition
* @returns {number}
*/
getShapesStored(definition) {
return this.storedShapes[definition.getHash()] || 0;
}
/**
* @param {string} key
* @param {number} amount
*/
takeShapeByKey(key, amount) {
assert(this.getShapesStoredByKey(key) >= amount, "Can not afford: " + key + " x " + amount);
assert(amount >= 0, "Amount < 0 for " + key);
assert(Number.isInteger(amount), "Invalid amount: " + amount);
this.storedShapes[key] = (this.storedShapes[key] || 0) - amount;
return;
}
/**
* Returns how much of the current shape is stored
* @param {string} key
* @returns {number}
*/
getShapesStoredByKey(key) {
return this.storedShapes[key] || 0;
}
/**
* Returns how much of the current goal was already delivered
*/
getCurrentGoalDelivered() {
return this.getShapesStored(this.currentGoal.definition);
}
/**
* Returns the current level of a given upgrade
* @param {string} upgradeId
*/
getUpgradeLevel(upgradeId) {
return this.upgradeLevels[upgradeId] || 0;
}
/**
* Returns whether the given reward is already unlocked
* @param {enumHubGoalRewards} reward
*/
isRewardUnlocked(reward) {
if (G_IS_DEV && globalConfig.debug.allBuildingsUnlocked) {
return true;
}
return !!this.gainedRewards[reward];
}
/**
* Handles the given definition, by either accounting it towards the
* goal or otherwise granting some points
* @param {ShapeDefinition} definition
*/
handleDefinitionDelivered(definition) {
const hash = definition.getHash();
this.storedShapes[hash] = (this.storedShapes[hash] || 0) + 1;
this.root.signals.shapeDelivered.dispatch(definition);
// Check if we have enough for the next level
const targetHash = this.currentGoal.definition.getHash();
if (
this.storedShapes[targetHash] >= this.currentGoal.required ||
(G_IS_DEV && globalConfig.debug.rewardsInstant)
) {
this.onGoalCompleted();
}
}
/**
* Creates the next goal
*/
createNextGoal() {
const storyIndex = this.level - 1;
if (storyIndex < tutorialGoals.length) {
const { shape, required, reward } = tutorialGoals[storyIndex];
this.currentGoal = {
/** @type {ShapeDefinition} */
definition: this.root.shapeDefinitionMgr.getShapeFromShortKey(shape),
required,
reward,
};
return;
}
this.currentGoal = {
/** @type {ShapeDefinition} */
definition: this.createRandomShape(),
required: 10000 + findNiceIntegerValue(this.level * 2000),
reward: enumHubGoalRewards.no_reward_freeplay,
};
}
/**
* Called when the level was completed
*/
onGoalCompleted() {
const reward = this.currentGoal.reward;
this.gainedRewards[reward] = (this.gainedRewards[reward] || 0) + 1;
this.root.app.gameAnalytics.handleLevelCompleted(this.level);
++this.level;
this.createNextGoal();
this.root.signals.storyGoalCompleted.dispatch(this.level - 1, reward);
}
/**
* Returns whether we are playing in free-play
*/
isFreePlay() {
return this.level >= tutorialGoals.length;
}
/**
* Returns whether a given upgrade can be unlocked
* @param {string} upgradeId
*/
canUnlockUpgrade(upgradeId) {
const handle = UPGRADES[upgradeId];
const currentLevel = this.getUpgradeLevel(upgradeId);
if (currentLevel >= handle.tiers.length) {
// Max level
return false;
}
if (G_IS_DEV && globalConfig.debug.upgradesNoCost) {
return true;
}
const tierData = handle.tiers[currentLevel];
for (let i = 0; i < tierData.required.length; ++i) {
const requirement = tierData.required[i];
if ((this.storedShapes[requirement.shape] || 0) < requirement.amount) {
return false;
}
}
return true;
}
/**
* Returns the number of available upgrades
* @returns {number}
*/
getAvailableUpgradeCount() {
let count = 0;
for (const upgradeId in UPGRADES) {
if (this.canUnlockUpgrade(upgradeId)) {
++count;
}
}
return count;
}
/**
* Tries to unlock the given upgrade
* @param {string} upgradeId
* @returns {boolean}
*/
tryUnlockUpgrade(upgradeId) {
if (!this.canUnlockUpgrade(upgradeId)) {
return false;
}
const handle = UPGRADES[upgradeId];
const currentLevel = this.getUpgradeLevel(upgradeId);
const tierData = handle.tiers[currentLevel];
if (!tierData) {
return false;
}
if (G_IS_DEV && globalConfig.debug.upgradesNoCost) {
// Dont take resources
} else {
for (let i = 0; i < tierData.required.length; ++i) {
const requirement = tierData.required[i];
// Notice: Don't have to check for hash here
this.storedShapes[requirement.shape] -= requirement.amount;
}
}
this.upgradeLevels[upgradeId] = (this.upgradeLevels[upgradeId] || 0) + 1;
this.upgradeImprovements[upgradeId] += tierData.improvement;
this.root.signals.upgradePurchased.dispatch(upgradeId);
this.root.app.gameAnalytics.handleUpgradeUnlocked(upgradeId, currentLevel);
return true;
}
/**
* @returns {ShapeDefinition}
*/
createRandomShape() {
const layerCount = clamp(this.level / 25, 2, 4);
/** @type {Array<import("./shape_definition").ShapeLayer>} */
let layers = [];
const randomColor = () => randomChoice(Object.values(enumColors));
const randomShape = () => randomChoice(Object.values(enumSubShape));
let anyIsMissingTwo = false;
for (let i = 0; i < layerCount; ++i) {
/** @type {import("./shape_definition").ShapeLayer} */
const layer = [null, null, null, null];
for (let quad = 0; quad < 4; ++quad) {
layer[quad] = {
subShape: randomShape(),
color: randomColor(),
};
}
// Sometimes shapes are missing
if (Math.random() > 0.85) {
layer[randomInt(0, 3)] = null;
}
// Sometimes they actually are missing *two* ones!
// Make sure at max only one layer is missing it though, otherwise we could
// create an uncreateable shape
if (Math.random() > 0.95 && !anyIsMissingTwo) {
layer[randomInt(0, 3)] = null;
anyIsMissingTwo = true;
}
layers.push(layer);
}
const definition = new ShapeDefinition({ layers });
return this.root.shapeDefinitionMgr.registerOrReturnHandle(definition);
}
////////////// HELPERS
/**
* Belt speed
* @returns {number} items / sec
*/
getBeltBaseSpeed() {
return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt;
}
/**
* Underground belt speed
* @returns {number} items / sec
*/
getUndergroundBeltBaseSpeed() {
return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt;
}
/**
* Miner speed
* @returns {number} items / sec
*/
getMinerBaseSpeed() {
return globalConfig.minerSpeedItemsPerSecond * this.upgradeImprovements.miner;
}
/**
* Processor speed
* @param {enumItemProcessorTypes} processorType
* @returns {number} items / sec
*/
getProcessorBaseSpeed(processorType) {
switch (processorType) {
case enumItemProcessorTypes.splitterWires:
return globalConfig.wiresSpeedItemsPerSecond * 2;
case enumItemProcessorTypes.trash:
case enumItemProcessorTypes.hub:
return 1e30;
case enumItemProcessorTypes.splitter:
return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt * 2;
case enumItemProcessorTypes.filter:
return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt;
case enumItemProcessorTypes.mixer:
case enumItemProcessorTypes.painter:
case enumItemProcessorTypes.painterDouble:
case enumItemProcessorTypes.painterQuad: {
assert(
globalConfig.buildingSpeeds[processorType],
"Processor type has no speed set in globalConfig.buildingSpeeds: " + processorType
);
return (
globalConfig.beltSpeedItemsPerSecond *
this.upgradeImprovements.painting *
globalConfig.buildingSpeeds[processorType]
);
}
case enumItemProcessorTypes.cutter:
case enumItemProcessorTypes.cutterQuad:
case enumItemProcessorTypes.rotater:
case enumItemProcessorTypes.rotaterCCW:
case enumItemProcessorTypes.rotaterFL:
case enumItemProcessorTypes.stacker: {
assert(
globalConfig.buildingSpeeds[processorType],
"Processor type has no speed set in globalConfig.buildingSpeeds: " + processorType
);
return (
globalConfig.beltSpeedItemsPerSecond *
this.upgradeImprovements.processors *
globalConfig.buildingSpeeds[processorType]
);
}
default:
assertAlways(false, "invalid processor type: " + processorType);
}
return 1 / globalConfig.beltSpeedItemsPerSecond;
}
}
import { globalConfig } from "../core/config";
import { clamp, findNiceIntegerValue, randomChoice, randomInt } from "../core/utils";
import { BasicSerializableObject, types } from "../savegame/serialization";
import { enumColors } from "./colors";
import { enumItemProcessorTypes } from "./components/item_processor";
import { GameRoot } from "./root";
import { enumSubShape, ShapeDefinition } from "./shape_definition";
import { enumHubGoalRewards, tutorialGoals } from "./tutorial_goals";
import { UPGRADES } from "./upgrades";
export class HubGoals extends BasicSerializableObject {
static getId() {
return "HubGoals";
}
static getSchema() {
return {
level: types.uint,
storedShapes: types.keyValueMap(types.uint),
upgradeLevels: types.keyValueMap(types.uint),
currentGoal: types.structured({
definition: types.knownType(ShapeDefinition),
required: types.uint,
reward: types.nullable(types.enum(enumHubGoalRewards)),
}),
};
}
deserialize(data) {
const errorCode = super.deserialize(data);
if (errorCode) {
return errorCode;
}
// Compute gained rewards
for (let i = 0; i < this.level - 1; ++i) {
if (i < tutorialGoals.length) {
const reward = tutorialGoals[i].reward;
this.gainedRewards[reward] = (this.gainedRewards[reward] || 0) + 1;
}
}
// Compute upgrade improvements
for (const upgradeId in UPGRADES) {
const upgradeHandle = UPGRADES[upgradeId];
const level = this.upgradeLevels[upgradeId] || 0;
let totalImprovement = upgradeHandle.baseValue || 1;
for (let i = 0; i < level; ++i) {
totalImprovement += upgradeHandle.tiers[i].improvement;
}
this.upgradeImprovements[upgradeId] = totalImprovement;
}
// Compute current goal
const goal = tutorialGoals[this.level - 1];
if (goal) {
this.currentGoal = {
/** @type {ShapeDefinition} */
definition: this.root.shapeDefinitionMgr.getShapeFromShortKey(goal.shape),
required: goal.required,
reward: goal.reward,
};
}
}
/**
* @param {GameRoot} root
*/
constructor(root) {
super();
this.root = root;
this.level = 1;
/**
* Which story rewards we already gained
* @type {Object.<string, number>}
*/
this.gainedRewards = {};
/**
* Mapping from shape hash -> amount
* @type {Object<string, number>}
*/
this.storedShapes = {};
/**
* Stores the levels for all upgrades
* @type {Object<string, number>}
*/
this.upgradeLevels = {};
/**
* Stores the improvements for all upgrades
* @type {Object<string, number>}
*/
this.upgradeImprovements = {};
for (const key in UPGRADES) {
this.upgradeImprovements[key] = UPGRADES[key].baseValue || 1;
}
this.createNextGoal();
// Allow quickly switching goals in dev mode
if (G_IS_DEV) {
window.addEventListener("keydown", ev => {
if (ev.key === "b") {
// root is not guaranteed to exist within ~0.5s after loading in
if (this.root && this.root.app && this.root.app.gameAnalytics) {
this.onGoalCompleted();
}
}
});
}
}
/**
* Returns how much of the current shape is stored
* @param {ShapeDefinition} definition
* @returns {number}
*/
getShapesStored(definition) {
return this.storedShapes[definition.getHash()] || 0;
}
/**
* @param {string} key
* @param {number} amount
*/
takeShapeByKey(key, amount) {
assert(this.getShapesStoredByKey(key) >= amount, "Can not afford: " + key + " x " + amount);
assert(amount >= 0, "Amount < 0 for " + key);
assert(Number.isInteger(amount), "Invalid amount: " + amount);
this.storedShapes[key] = (this.storedShapes[key] || 0) - amount;
return;
}
/**
* Returns how much of the current shape is stored
* @param {string} key
* @returns {number}
*/
getShapesStoredByKey(key) {
return this.storedShapes[key] || 0;
}
/**
* Returns how much of the current goal was already delivered
*/
getCurrentGoalDelivered() {
return this.getShapesStored(this.currentGoal.definition);
}
/**
* Returns the current level of a given upgrade
* @param {string} upgradeId
*/
getUpgradeLevel(upgradeId) {
return this.upgradeLevels[upgradeId] || 0;
}
/**
* Returns whether the given reward is already unlocked
* @param {enumHubGoalRewards} reward
*/
isRewardUnlocked(reward) {
if (G_IS_DEV && globalConfig.debug.allBuildingsUnlocked) {
return true;
}
return !!this.gainedRewards[reward];
}
/**
* Handles the given definition, by either accounting it towards the
* goal or otherwise granting some points
* @param {ShapeDefinition} definition
*/
handleDefinitionDelivered(definition) {
const hash = definition.getHash();
this.storedShapes[hash] = (this.storedShapes[hash] || 0) + 1;
this.root.signals.shapeDelivered.dispatch(definition);
// Check if we have enough for the next level
const targetHash = this.currentGoal.definition.getHash();
if (
this.storedShapes[targetHash] >= this.currentGoal.required ||
(G_IS_DEV && globalConfig.debug.rewardsInstant)
) {
this.onGoalCompleted();
}
}
/**
* Creates the next goal
*/
createNextGoal() {
const storyIndex = this.level - 1;
if (storyIndex < tutorialGoals.length) {
const { shape, required, reward } = tutorialGoals[storyIndex];
this.currentGoal = {
/** @type {ShapeDefinition} */
definition: this.root.shapeDefinitionMgr.getShapeFromShortKey(shape),
required,
reward,
};
return;
}
this.currentGoal = {
/** @type {ShapeDefinition} */
definition: this.createRandomShape(),
required: 10000 + findNiceIntegerValue(this.level * 2000),
reward: enumHubGoalRewards.no_reward_freeplay,
};
}
/**
* Called when the level was completed
*/
onGoalCompleted() {
const reward = this.currentGoal.reward;
this.gainedRewards[reward] = (this.gainedRewards[reward] || 0) + 1;
this.root.app.gameAnalytics.handleLevelCompleted(this.level);
++this.level;
this.createNextGoal();
this.root.signals.storyGoalCompleted.dispatch(this.level - 1, reward);
}
/**
* Returns whether we are playing in free-play
*/
isFreePlay() {
return this.level >= tutorialGoals.length;
}
/**
* Returns whether a given upgrade can be unlocked
* @param {string} upgradeId
*/
canUnlockUpgrade(upgradeId) {
const handle = UPGRADES[upgradeId];
const currentLevel = this.getUpgradeLevel(upgradeId);
if (currentLevel >= handle.tiers.length) {
// Max level
return false;
}
if (G_IS_DEV && globalConfig.debug.upgradesNoCost) {
return true;
}
const tierData = handle.tiers[currentLevel];
for (let i = 0; i < tierData.required.length; ++i) {
const requirement = tierData.required[i];
if ((this.storedShapes[requirement.shape] || 0) < requirement.amount) {
return false;
}
}
return true;
}
/**
* Returns the number of available upgrades
* @returns {number}
*/
getAvailableUpgradeCount() {
let count = 0;
for (const upgradeId in UPGRADES) {
if (this.canUnlockUpgrade(upgradeId)) {
++count;
}
}
return count;
}
/**
* Tries to unlock the given upgrade
* @param {string} upgradeId
* @returns {boolean}
*/
tryUnlockUpgrade(upgradeId) {
if (!this.canUnlockUpgrade(upgradeId)) {
return false;
}
const handle = UPGRADES[upgradeId];
const currentLevel = this.getUpgradeLevel(upgradeId);
const tierData = handle.tiers[currentLevel];
if (!tierData) {
return false;
}
if (G_IS_DEV && globalConfig.debug.upgradesNoCost) {
// Dont take resources
} else {
for (let i = 0; i < tierData.required.length; ++i) {
const requirement = tierData.required[i];
// Notice: Don't have to check for hash here
this.storedShapes[requirement.shape] -= requirement.amount;
}
}
this.upgradeLevels[upgradeId] = (this.upgradeLevels[upgradeId] || 0) + 1;
this.upgradeImprovements[upgradeId] += tierData.improvement;
this.root.signals.upgradePurchased.dispatch(upgradeId);
this.root.app.gameAnalytics.handleUpgradeUnlocked(upgradeId, currentLevel);
return true;
}
/**
* @returns {ShapeDefinition}
*/
createRandomShape() {
const layerCount = clamp(this.level / 25, 2, 4);
/** @type {Array<import("./shape_definition").ShapeLayer>} */
let layers = [];
const randomColor = () => randomChoice(Object.values(enumColors));
const randomShape = () => randomChoice(Object.values(enumSubShape));
let anyIsMissingTwo = false;
for (let i = 0; i < layerCount; ++i) {
/** @type {import("./shape_definition").ShapeLayer} */
const layer = [null, null, null, null];
for (let quad = 0; quad < 4; ++quad) {
layer[quad] = {
subShape: randomShape(),
color: randomColor(),
};
}
// Sometimes shapes are missing
if (Math.random() > 0.85) {
layer[randomInt(0, 3)] = null;
}
// Sometimes they actually are missing *two* ones!
// Make sure at max only one layer is missing it though, otherwise we could
// create an uncreateable shape
if (Math.random() > 0.95 && !anyIsMissingTwo) {
layer[randomInt(0, 3)] = null;
anyIsMissingTwo = true;
}
layers.push(layer);
}
const definition = new ShapeDefinition({ layers });
return this.root.shapeDefinitionMgr.registerOrReturnHandle(definition);
}
////////////// HELPERS
/**
* Belt speed
* @returns {number} items / sec
*/
getBeltBaseSpeed() {
return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt;
}
/**
* Underground belt speed
* @returns {number} items / sec
*/
getUndergroundBeltBaseSpeed() {
return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt;
}
/**
* Miner speed
* @returns {number} items / sec
*/
getMinerBaseSpeed() {
return globalConfig.minerSpeedItemsPerSecond * this.upgradeImprovements.miner;
}
/**
* Processor speed
* @param {enumItemProcessorTypes} processorType
* @returns {number} items / sec
*/
getProcessorBaseSpeed(processorType) {
switch (processorType) {
case enumItemProcessorTypes.splitterWires:
return globalConfig.wiresSpeedItemsPerSecond * 2;
case enumItemProcessorTypes.trash:
case enumItemProcessorTypes.hub:
return 1e30;
case enumItemProcessorTypes.splitter:
return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt * 2;
case enumItemProcessorTypes.filter:
case enumItemProcessorTypes.reader:
return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt;
case enumItemProcessorTypes.mixer:
case enumItemProcessorTypes.painter:
case enumItemProcessorTypes.painterDouble:
case enumItemProcessorTypes.painterQuad: {
assert(
globalConfig.buildingSpeeds[processorType],
"Processor type has no speed set in globalConfig.buildingSpeeds: " + processorType
);
return (
globalConfig.beltSpeedItemsPerSecond *
this.upgradeImprovements.painting *
globalConfig.buildingSpeeds[processorType]
);
}
case enumItemProcessorTypes.cutter:
case enumItemProcessorTypes.cutterQuad:
case enumItemProcessorTypes.rotater:
case enumItemProcessorTypes.rotaterCCW:
case enumItemProcessorTypes.rotaterFL:
case enumItemProcessorTypes.stacker: {
assert(
globalConfig.buildingSpeeds[processorType],
"Processor type has no speed set in globalConfig.buildingSpeeds: " + processorType
);
return (
globalConfig.beltSpeedItemsPerSecond *
this.upgradeImprovements.processors *
globalConfig.buildingSpeeds[processorType]
);
}
default:
assertAlways(false, "invalid processor type: " + processorType);
}
return 1 / globalConfig.beltSpeedItemsPerSecond;
}
}

84
src/js/game/hud/parts/buildings_toolbar.js
View File

@@ -1,41 +1,43 @@
import { MetaBeltBaseBuilding } from "../../buildings/belt_base";
import { MetaCutterBuilding } from "../../buildings/cutter";
import { MetaMinerBuilding } from "../../buildings/miner";
import { MetaMixerBuilding } from "../../buildings/mixer";
import { MetaPainterBuilding } from "../../buildings/painter";
import { MetaRotaterBuilding } from "../../buildings/rotater";
import { MetaSplitterBuilding } from "../../buildings/splitter";
import { MetaStackerBuilding } from "../../buildings/stacker";
import { MetaTrashBuilding } from "../../buildings/trash";
import { MetaUndergroundBeltBuilding } from "../../buildings/underground_belt";
import { HUDBaseToolbar } from "./base_toolbar";
import { MetaLeverBuilding } from "../../buildings/lever";
import { MetaFilterBuilding } from "../../buildings/filter";
import { MetaDisplayBuilding } from "../../buildings/display";
const supportedBuildings = [
MetaBeltBaseBuilding,
MetaSplitterBuilding,
MetaUndergroundBeltBuilding,
MetaMinerBuilding,
MetaCutterBuilding,
MetaRotaterBuilding,
MetaStackerBuilding,
MetaMixerBuilding,
MetaPainterBuilding,
MetaTrashBuilding,
MetaLeverBuilding,
MetaFilterBuilding,
MetaDisplayBuilding,
];
export class HUDBuildingsToolbar extends HUDBaseToolbar {
constructor(root) {
super(root, {
supportedBuildings,
visibilityCondition: () =>
!this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === "regular",
htmlElementId: "ingame_HUD_buildings_toolbar",
});
}
}
import { MetaBeltBaseBuilding } from "../../buildings/belt_base";
import { MetaCutterBuilding } from "../../buildings/cutter";
import { MetaMinerBuilding } from "../../buildings/miner";
import { MetaMixerBuilding } from "../../buildings/mixer";
import { MetaPainterBuilding } from "../../buildings/painter";
import { MetaRotaterBuilding } from "../../buildings/rotater";
import { MetaSplitterBuilding } from "../../buildings/splitter";
import { MetaStackerBuilding } from "../../buildings/stacker";
import { MetaTrashBuilding } from "../../buildings/trash";
import { MetaUndergroundBeltBuilding } from "../../buildings/underground_belt";
import { HUDBaseToolbar } from "./base_toolbar";
import { MetaLeverBuilding } from "../../buildings/lever";
import { MetaFilterBuilding } from "../../buildings/filter";
import { MetaDisplayBuilding } from "../../buildings/display";
import { MetaReaderBuilding } from "../../buildings/reader";
const supportedBuildings = [
MetaBeltBaseBuilding,
MetaSplitterBuilding,
MetaUndergroundBeltBuilding,
MetaMinerBuilding,
MetaCutterBuilding,
MetaRotaterBuilding,
MetaStackerBuilding,
MetaMixerBuilding,
MetaPainterBuilding,
MetaTrashBuilding,
MetaLeverBuilding,
MetaFilterBuilding,
MetaDisplayBuilding,
MetaReaderBuilding,
];
export class HUDBuildingsToolbar extends HUDBaseToolbar {
constructor(root) {
super(root, {
supportedBuildings,
visibilityCondition: () =>
!this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === "regular",
htmlElementId: "ingame_HUD_buildings_toolbar",
});
}
}

1
src/js/game/key_action_mapper.js
View File

@@ -58,6 +58,7 @@ export const KEYMAPPINGS = {
lever: { keyCode: key("L") },
filter: { keyCode: key("B") },
display: { keyCode: key("N") },
reader: { keyCode: key("J") },
wire: { keyCode: key("1") },
wire_tunnel: { keyCode: key("2") },

5
src/js/game/meta_building_registry.js
View File

@@ -22,6 +22,7 @@ import { MetaFilterBuilding } from "./buildings/filter";
import { MetaWireTunnelBuilding, enumWireTunnelVariants } from "./buildings/wire_tunnel";
import { MetaDisplayBuilding } from "./buildings/display";
import { MetaVirtualProcessorBuilding, enumVirtualProcessorVariants } from "./buildings/virtual_processor";
import { MetaReaderBuilding } from "./buildings/reader";
const logger = createLogger("building_registry");
@@ -45,6 +46,7 @@ export function initMetaBuildingRegistry() {
gMetaBuildingRegistry.register(MetaWireTunnelBuilding);
gMetaBuildingRegistry.register(MetaDisplayBuilding);
gMetaBuildingRegistry.register(MetaVirtualProcessorBuilding);
gMetaBuildingRegistry.register(MetaReaderBuilding);
// Belt
registerBuildingVariant(1, MetaBeltBaseBuilding, defaultBuildingVariant, 0);
@@ -132,6 +134,9 @@ export function initMetaBuildingRegistry() {
registerBuildingVariant(45, MetaVirtualProcessorBuilding, enumVirtualProcessorVariants.unstacker);
registerBuildingVariant(46, MetaVirtualProcessorBuilding, enumVirtualProcessorVariants.shapecompare);
// Reader
registerBuildingVariant(49, MetaReaderBuilding);
// Propagate instances
for (const key in gBuildingVariants) {
gBuildingVariants[key].metaInstance = gMetaBuildingRegistry.findByClass(

40
src/js/game/systems/belt_reader.js Normal file
View File

@@ -0,0 +1,40 @@
import { GameSystemWithFilter } from "../game_system_with_filter";
import { BeltReaderComponent } from "../components/belt_reader";
import { globalConfig } from "../../core/config";
import { BOOL_TRUE_SINGLETON, BOOL_FALSE_SINGLETON } from "../items/boolean_item";
export class BeltReaderSystem extends GameSystemWithFilter {
constructor(root) {
super(root, [BeltReaderComponent]);
}
update() {
const now = this.root.time.now();
const minimumTime = now - globalConfig.readerAnalyzeIntervalSeconds;
const minimumTimeForThroughput = now - 1;
for (let i = 0; i < this.allEntities.length; ++i) {
const entity = this.allEntities[i];
const readerComp = entity.components.BeltReader;
const pinsComp = entity.components.WiredPins;
// Remove outdated items
while (readerComp.lastItemTimes[0] < minimumTime) {
readerComp.lastItemTimes.shift();
}
pinsComp.slots[1].value = readerComp.lastItem;
pinsComp.slots[0].value =
(readerComp.lastItemTimes[readerComp.lastItemTimes.length - 1] || 0) >
minimumTimeForThroughput
? BOOL_TRUE_SINGLETON
: BOOL_FALSE_SINGLETON;
if (now - readerComp.lastThroughputComputation > 0.5) {
readerComp.lastThroughputComputation = now;
readerComp.lastThroughput =
readerComp.lastItemTimes.length / globalConfig.readerAnalyzeIntervalSeconds;
}
}
}
}

16
src/js/game/systems/item_processor.js
View File

@@ -8,7 +8,7 @@ import {
} from "../components/item_processor";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { BOOL_TRUE_SINGLETON, isTrueItem } from "../items/boolean_item";
import { BOOL_TRUE_SINGLETON, isTrueItem, BooleanItem } from "../items/boolean_item";
import { ColorItem, COLOR_ITEM_SINGLETONS } from "../items/color_item";
import { ShapeItem } from "../items/shape_item";
@@ -506,8 +506,20 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
break;
}
// HUB
// READER
case enumItemProcessorTypes.reader: {
// Pass through the item
const item = itemsBySlot[0].item;
outItems.push({ item });
// Track the item
const readerComp = entity.components.BeltReader;
readerComp.lastItemTimes.push(this.root.time.now());
readerComp.lastItem = item;
break;
}
// HUB
case enumItemProcessorTypes.hub: {
trackProduction = false;

47
src/js/game/systems/item_processor_overlays.js
View File

@@ -1,11 +1,11 @@
import { GameSystem } from "../game_system";
import { MapChunkView } from "../map_chunk_view";
import { enumItemProcessorRequirements } from "../components/item_processor";
import { Entity } from "../entity";
import { isTrueItem } from "../items/boolean_item";
import { globalConfig } from "../../core/config";
import { Loader } from "../../core/loader";
import { smoothPulse } from "../../core/utils";
import { enumItemProcessorRequirements, enumItemProcessorTypes } from "../components/item_processor";
import { Entity } from "../entity";
import { GameSystem } from "../game_system";
import { isTrueItem } from "../items/boolean_item";
import { MapChunkView } from "../map_chunk_view";
export class ItemProcessorOverlaysSystem extends GameSystem {
constructor(root) {
@@ -14,6 +14,8 @@ export class ItemProcessorOverlaysSystem extends GameSystem {
this.spriteDisabled = Loader.getSprite("sprites/misc/processor_disabled.png");
this.spriteDisconnected = Loader.getSprite("sprites/misc/processor_disconnected.png");
this.readerOverlaySprite = Loader.getSprite("sprites/misc/reader_overlay.png");
this.drawnUids = new Set();
this.root.signals.gameFrameStarted.add(this.clearDrawnUids, this);
@@ -38,7 +40,8 @@ export class ItemProcessorOverlaysSystem extends GameSystem {
}
const requirement = processorComp.processingRequirement;
if (!requirement) {
if (!requirement && processorComp.type !== enumItemProcessorTypes.reader) {
continue;
}
@@ -58,9 +61,41 @@ export class ItemProcessorOverlaysSystem extends GameSystem {
break;
}
}
if (processorComp.type === enumItemProcessorTypes.reader) {
this.drawReaderOverlays(parameters, entity);
}
}
}
/**
*
* @param {import("../../core/draw_utils").DrawParameters} parameters
* @param {Entity} entity
*/
drawReaderOverlays(parameters, entity) {
const staticComp = entity.components.StaticMapEntity;
const readerComp = entity.components.BeltReader;
this.readerOverlaySprite.drawCachedCentered(
parameters,
(staticComp.origin.x + 0.5) * globalConfig.tileSize,
(staticComp.origin.y + 0.5) * globalConfig.tileSize,
globalConfig.tileSize
);
parameters.context.fillStyle = "#333439";
parameters.context.textAlign = "center";
parameters.context.font = "bold 10px GameFont";
parameters.context.fillText(
"" + Math.round(readerComp.lastThroughput * 10) / 10,
(staticComp.origin.x + 0.5) * globalConfig.tileSize,
(staticComp.origin.y + 0.62) * globalConfig.tileSize
);
parameters.context.textAlign = "left";
}
/**
*
* @param {import("../../core/draw_utils").DrawParameters} parameters