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

Get rid of item ejector / acceptor layers and new wires buildings for now

Browse Source
This commit is contained in:
tobspr
2020-08-10 21:24:58 +02:00
parent 89294c7072
commit 93975df4d5
83 changed files with 847 additions and 3189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
src/js/game/systems/belt.js
View File

@@ -13,9 +13,6 @@ import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { MapChunkView } from "../map_chunk_view";
import { defaultBuildingVariant } from "../meta_building";
import { enumLayer } from "../root";
import { MetaWireBaseBuilding } from "../buildings/wire_base";
import { enumItemType } from "../base_item";
export const BELT_ANIM_COUNT = 28;
@@ -320,14 +317,10 @@ export class BeltSystem extends GameSystemWithFilter {
/**
* Draws all belt paths
* @param {DrawParameters} parameters
* @param {enumLayer} layer
*/
drawLayerBeltItems(parameters, layer) {
drawBeltItems(parameters) {
for (let i = 0; i < this.beltPaths.length; ++i) {
const path = this.beltPaths[i];
if (path.layer === layer) {
path.draw(parameters);
}
this.beltPaths[i].draw(parameters);
}
}
@@ -497,13 +490,13 @@ export class BeltSystem extends GameSystemWithFilter {
}
// Limit speed to avoid belts going backwards
const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed(enumLayer.regular), 10);
const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed(), 10);
// SYNC with systems/item_acceptor.js:drawEntityUnderlays!
// 126 / 42 is the exact animation speed of the png animation
const animationIndex = Math.floor(
((this.root.time.realtimeNow() * speedMultiplier * BELT_ANIM_COUNT * 126) / 42) *
globalConfig.beltItemSpacingByLayer[enumLayer.regular]
globalConfig.itemSpacingOnBelts
);
const contents = chunk.contents;
for (let y = 0; y < globalConfig.mapChunkSize; ++y) {
@@ -526,35 +519,6 @@ export class BeltSystem extends GameSystemWithFilter {
1;
}
/**
* Draws a given chunk
* @param {DrawParameters} parameters
* @param {MapChunkView} chunk
*/
drawWiresChunk(parameters, chunk) {
if (parameters.zoomLevel < globalConfig.mapChunkOverviewMinZoom) {
return;
}
const contents = chunk.wireContents;
for (let y = 0; y < globalConfig.mapChunkSize; ++y) {
for (let x = 0; x < globalConfig.mapChunkSize; ++x) {
const entity = contents[x][y];
if (entity && entity.components.Belt) {
const direction = entity.components.Belt.direction;
const sprite = this.wireSprites[direction];
entity.components.StaticMapEntity.drawSpriteOnFullEntityBounds(
parameters,
sprite,
0,
false
);
}
}
}
}
/**
* Draws the belt path debug overlays
* @param {DrawParameters} parameters

30
src/js/game/systems/belt_underlays.js
View File

@@ -1,12 +1,11 @@
import { GameSystemWithFilter } from "../game_system_with_filter";
import { BeltUnderlaysComponent } from "../components/belt_underlays";
import { BELT_ANIM_COUNT } from "./belt";
import { Loader } from "../../core/loader";
import { enumLayer } from "../root";
import { Entity } from "../entity";
import { enumDirectionToAngle } from "../../core/vector";
import { globalConfig } from "../../core/config";
import { drawRotatedSprite } from "../../core/draw_utils";
import { Loader } from "../../core/loader";
import { enumDirectionToAngle } from "../../core/vector";
import { BeltUnderlaysComponent } from "../components/belt_underlays";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { BELT_ANIM_COUNT } from "./belt";
export class BeltUnderlaysSystem extends GameSystemWithFilter {
constructor(root) {
@@ -22,32 +21,25 @@ export class BeltUnderlaysSystem extends GameSystemWithFilter {
/**
* Draws the acceptor underlays
* @param {import("../../core/draw_utils").DrawParameters} parameters
* @param {enumLayer} layer
*/
drawUnderlays(parameters, layer) {
this.forEachMatchingEntityOnScreen(parameters, this.drawEntityUnderlays.bind(this, layer));
drawUnderlays(parameters) {
this.forEachMatchingEntityOnScreen(parameters, this.drawEntityUnderlays.bind(this));
}
/**
* @param {enumLayer} layer
* @param {import("../../core/draw_utils").DrawParameters} parameters
* @param {Entity} entity
*/
drawEntityUnderlays(layer, parameters, entity) {
drawEntityUnderlays(parameters, entity) {
const staticComp = entity.components.StaticMapEntity;
const underlayComp = entity.components.BeltUnderlays;
if (entity.layer !== layer) {
// Not our layer
return;
}
if (!staticComp.shouldBeDrawn(parameters)) {
return;
}
// Limit speed to avoid belts going backwards
const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed(layer), 10);
const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed(), 10);
const underlays = underlayComp.underlays;
for (let i = 0; i < underlays.length; ++i) {
@@ -59,7 +51,7 @@ export class BeltUnderlaysSystem extends GameSystemWithFilter {
// SYNC with systems/belt.js:drawSingleEntity!
const animationIndex = Math.floor(
((this.root.time.realtimeNow() * speedMultiplier * BELT_ANIM_COUNT * 126) / 42) *
globalConfig.beltItemSpacingByLayer[layer]
globalConfig.itemSpacingOnBelts
);
drawRotatedSprite({

90
src/js/game/systems/energy_consumer.js
View File

@@ -1,90 +0,0 @@
import { DrawParameters } from "../../core/draw_parameters";
import { Loader } from "../../core/loader";
import { clamp } from "../../core/utils";
import { enumItemType } from "../base_item";
import { EnergyConsumerComponent } from "../components/energy_consumer";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { NEGATIVE_ENERGY_ITEM_SINGLETON } from "../items/negative_energy_item";
import { POSITIVE_ENERGY_ITEM_SINGLETON } from "../items/positive_energy_item";
export class EnergyConsumerSystem extends GameSystemWithFilter {
constructor(root) {
super(root, [EnergyConsumerComponent]);
this.batterySprites = [
Loader.getSprite("sprites/wires/battery_empty.png"),
Loader.getSprite("sprites/wires/battery_low.png"),
Loader.getSprite("sprites/wires/battery_medium.png"),
Loader.getSprite("sprites/wires/battery_full.png"),
];
this.piledWasteSprite = Loader.getSprite("sprites/wires/waste_piled.png");
}
update() {
for (let i = 0; i < this.allEntities.length; ++i) {
const entity = this.allEntities[i];
const energyConsumerComp = entity.components.EnergyConsumer;
if (energyConsumerComp.piledOutput >= 1.0) {
// Try to get rid of waste
const ejectorComp = entity.components.ItemEjector;
const item = this.getItemSingletonByType(energyConsumerComp.wasteType);
if (ejectorComp.tryEject(energyConsumerComp.ejectorSlotIndex, item)) {
// Got rid of waste
energyConsumerComp.reduceWaste(1.0);
}
}
}
}
/**
*
* @param {enumItemType} itemType
*/
getItemSingletonByType(itemType) {
switch (itemType) {
case enumItemType.positiveEnergy:
return POSITIVE_ENERGY_ITEM_SINGLETON;
case enumItemType.negativeEnergy:
return NEGATIVE_ENERGY_ITEM_SINGLETON;
default:
assertAlways(false, "Bad item type: " + itemType);
}
}
/**
* Draws everything
* @param {DrawParameters} parameters
*/
draw(parameters) {
this.forEachMatchingEntityOnScreen(parameters, this.drawSingleEntity.bind(this));
}
/**
* Draws a given entity
* @param {DrawParameters} parameters
* @param {Entity} entity
*/
drawSingleEntity(parameters, entity) {
const staticComp = entity.components.StaticMapEntity;
const consumerComp = entity.components.EnergyConsumer;
const position = staticComp.localTileToWorld(consumerComp.batteryPosition).toWorldSpaceCenterOfTile();
if (consumerComp.hasTooMuchWastePiled()) {
this.piledWasteSprite.drawCachedCentered(parameters, position.x, position.y, 12);
} else {
const percentage = consumerComp.stored / consumerComp.bufferSize;
const index = clamp(
Math.round(percentage * this.batterySprites.length),
0,
this.batterySprites.length - 1
);
this.batterySprites[index].drawCachedCentered(parameters, position.x, position.y, 12);
}
}
}

97
src/js/game/systems/energy_generator.js
View File

@@ -1,97 +0,0 @@
import { DrawParameters } from "../../core/draw_parameters";
import { formatBigNumber } from "../../core/utils";
import { T } from "../../translations";
import { EnergyGeneratorComponent } from "../components/energy_generator";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { POSITIVE_ENERGY_ITEM_SINGLETON } from "../items/positive_energy_item";
import { ShapeDefinition } from "../shape_definition";
import { Loader } from "../../core/loader";
import { globalConfig } from "../../core/config";
export class EnergyGeneratorSystem extends GameSystemWithFilter {
constructor(root) {
super(root, [EnergyGeneratorComponent]);
this.energyGeneratorOverlay = Loader.getSprite("sprites/misc/energy_generator_overlay.png");
}
draw(parameters) {
this.forEachMatchingEntityOnScreen(parameters, this.drawEntity.bind(this));
}
/**
* Returns which shape is required for a given generator
* @param {Entity} entity
*/
getShapeRequiredForGenerator(entity) {
return "CuCuCuCu";
}
update() {
for (let i = 0; i < this.allEntities.length; ++i) {
const entity = this.allEntities[i];
const energyGenComp = entity.components.EnergyGenerator;
const ejectorComp = entity.components.ItemEjector;
if (!energyGenComp.requiredKey) {
// Compute required key for this generator
energyGenComp.requiredKey = this.getShapeRequiredForGenerator(entity);
}
if (energyGenComp.itemsInQueue > 0) {
// FIXME: Find slot dynamically
if (ejectorComp.tryEject(0, POSITIVE_ENERGY_ITEM_SINGLETON)) {
energyGenComp.itemsInQueue -= 1;
}
}
}
}
/**
* @param {DrawParameters} parameters
* @param {Entity} entity
*/
drawEntity(parameters, entity) {
const context = parameters.context;
const staticComp = entity.components.StaticMapEntity;
if (!staticComp.shouldBeDrawn(parameters)) {
return;
}
const energyGenComp = entity.components.EnergyGenerator;
if (!energyGenComp.requiredKey) {
// Not initialized yet
return;
}
const pos = staticComp.getTileSpaceBounds().getCenter().toWorldSpace();
const definition = ShapeDefinition.fromShortKey(energyGenComp.requiredKey);
definition.draw(pos.x, pos.y, parameters, 30);
// Draw background
this.energyGeneratorOverlay.drawCachedCentered(
parameters,
pos.x,
pos.y,
globalConfig.tileSize * 2 + 8
);
// TODO
const energyGenerated = 5;
// deliver: Deliver
// toGenerateEnergy: For <x> energy
context.font = "bold 9px GameFont";
context.fillStyle = "#64666e";
context.textAlign = "left";
context.fillText(T.buildings.energy_generator.deliver.toUpperCase(), pos.x - 25, pos.y - 18);
context.fillText(T.buildings.energy_generator.toGenerateEnergy.toUpperCase(), pos.x - 25, pos.y + 27);
context.font = "700 9px GameFont";
context.fillStyle = "#dee1ea";
context.fillText("" + formatBigNumber(energyGenerated), pos.x + 1, pos.y + 27);
}
}

17
src/js/game/systems/item_acceptor.js
View File

@@ -23,11 +23,8 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
// Process item consumption animations to avoid items popping from the belts
for (let animIndex = 0; animIndex < animations.length; ++animIndex) {
const anim = animations[animIndex];
const layer = aceptorComp.slots[anim.slotIndex].layer;
anim.animProgress +=
progress *
this.root.hubGoals.getBeltBaseSpeed(layer) *
globalConfig.beltItemSpacingByLayer[layer];
progress * this.root.hubGoals.getBeltBaseSpeed() * globalConfig.itemSpacingOnBelts;
if (anim.animProgress > 1) {
// Original
// animations.splice(animIndex, 1);
@@ -44,18 +41,16 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
/**
* Draws the acceptor items
* @param {DrawParameters} parameters
* @param {enumLayer} layer
*/
drawLayer(parameters, layer) {
this.forEachMatchingEntityOnScreen(parameters, this.drawEntityRegularLayer.bind(this, layer));
draw(parameters) {
this.forEachMatchingEntityOnScreen(parameters, this.drawEntityRegularLayer.bind(this));
}
/**
* @param {enumLayer} layer
* @param {DrawParameters} parameters
* @param {Entity} entity
*/
drawEntityRegularLayer(layer, parameters, entity) {
drawEntityRegularLayer(parameters, entity) {
const staticComp = entity.components.StaticMapEntity;
const acceptorComp = entity.components.ItemAcceptor;
@@ -69,10 +64,6 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
];
const slotData = acceptorComp.slots[slotIndex];
if (slotData.layer !== layer) {
// Don't draw non-regular slots for now
continue;
}
const slotWorldPos = staticComp.applyRotationToVector(slotData.pos).add(staticComp.origin);
const fadeOutDirection = enumDirectionToVector[staticComp.localDirectionToWorld(direction)];

51
src/js/game/systems/item_ejector.js
View File

@@ -3,11 +3,10 @@ import { DrawParameters } from "../../core/draw_parameters";
import { createLogger } from "../../core/logging";
import { Rectangle } from "../../core/rectangle";
import { enumDirection, enumDirectionToVector, Vector } from "../../core/vector";
import { BaseItem, enumItemTypeToLayer } from "../base_item";
import { BaseItem } from "../base_item";
import { ItemEjectorComponent } from "../components/item_ejector";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { enumLayer } from "../root";
const logger = createLogger("systems/ejector");
@@ -166,8 +165,7 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
const matchingSlot = targetAcceptorComp.findMatchingSlot(
targetStaticComp.worldToLocalTile(ejectSlotTargetWsTile),
targetStaticComp.worldDirectionToLocal(ejectSlotWsDirection),
ejectorSlot.layer
targetStaticComp.worldDirectionToLocal(ejectSlotWsDirection)
);
if (!matchingSlot) {
@@ -219,8 +217,8 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
1,
sourceSlot.progress +
progressGrowth *
this.root.hubGoals.getBeltBaseSpeed(sourceSlot.layer) *
globalConfig.beltItemSpacingByLayer[sourceSlot.layer]
this.root.hubGoals.getBeltBaseSpeed() *
globalConfig.itemSpacingOnBelts
);
// Check if we are still in the process of ejecting, can't proceed then
@@ -272,8 +270,6 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
// TODO: Kinda hacky. How to solve this properly? Don't want to go through inheritance hell.
// Also its just a few cases (hope it stays like this .. :x).
const itemLayer = enumItemTypeToLayer[item.getItemType()];
const beltComp = receiver.components.Belt;
if (beltComp) {
const path = beltComp.assignedPath;
@@ -297,15 +293,12 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
const itemProcessorComp = receiver.components.ItemProcessor;
if (itemProcessorComp) {
// Make sure its the same layer
if (itemLayer === receiver.layer) {
// Its an item processor ..
if (itemProcessorComp.tryTakeItem(item, slotIndex)) {
return true;
}
// Item processor can have nothing else
return false;
// Its an item processor ..
if (itemProcessorComp.tryTakeItem(item, slotIndex)) {
return true;
}
// Item processor can have nothing else
return false;
}
const undergroundBeltComp = receiver.components.UndergroundBelt;
@@ -336,35 +329,22 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
return false;
}
const energyGeneratorComp = receiver.components.EnergyGenerator;
if (energyGeneratorComp) {
if (energyGeneratorComp.tryTakeItem(item, slotIndex)) {
// Passed it over
return true;
}
// Energy generator comp can't have anything else
return false;
}
return false;
}
/**
* Draws the given layer
* Draws everything
* @param {DrawParameters} parameters
* @param {enumLayer} layer
*/
drawLayer(parameters, layer) {
this.forEachMatchingEntityOnScreen(parameters, this.drawSingleEntity.bind(this, layer));
draw(parameters) {
this.forEachMatchingEntityOnScreen(parameters, this.drawSingleEntity.bind(this));
}
/**
* @param {enumLayer} layer
* @param {DrawParameters} parameters
* @param {Entity} entity
*/
drawSingleEntity(layer, parameters, entity) {
drawSingleEntity(parameters, entity) {
const ejectorComp = entity.components.ItemEjector;
const staticComp = entity.components.StaticMapEntity;
@@ -381,11 +361,6 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
continue;
}
if (slot.layer !== layer) {
// Not our layer
continue;
}
const realPosition = slot.pos.rotateFastMultipleOf90(staticComp.rotation);
const realDirection = Vector.transformDirectionFromMultipleOf90(
slot.direction,

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

@@ -1,6 +1,6 @@
import { globalConfig } from "../../core/config";
import { BaseItem, enumItemType } from "../base_item";
import { enumColorMixingResults, enumInvertedColors } from "../colors";
import { enumColorMixingResults } from "../colors";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
@@ -48,11 +48,11 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
if (ejectorComp.canEjectOnSlot(preferredSlot)) {
slot = preferredSlot;
} else {
slot = ejectorComp.getFirstFreeSlot(entity.layer);
slot = ejectorComp.getFirstFreeSlot();
}
} else {
// We can eject on any slot
slot = ejectorComp.getFirstFreeSlot(entity.layer);
slot = ejectorComp.getFirstFreeSlot();
}
if (slot !== null) {
@@ -354,35 +354,6 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
break;
}
// ADVANCED PROCESSING
case enumItemProcessorTypes.advancedProcessor: {
const item = items[0].item;
if (item.getItemType() === enumItemType.color) {
const colorItem = /** @type {ColorItem} */ (items[0].item);
const newColor = enumInvertedColors[colorItem.color];
outItems.push({
item: new ColorItem(newColor),
requiredSlot: 0,
});
} else if (item.getItemType() === enumItemType.shape) {
const shapeItem = /** @type {ShapeItem} */ (items[0].item);
const newItem = this.root.shapeDefinitionMgr.shapeActionInvertColors(
shapeItem.definition
);
outItems.push({
item: new ShapeItem(newItem),
requiredSlot: 0,
});
} else {
assertAlways(false, "Bad item type: " + item.getItemType() + " for advanced processor.");
}
break;
}
default:
assertAlways(false, "Unkown item processor type: " + processorComp.type);
}

7
src/js/game/systems/static_map_entity.js
View File

@@ -1,10 +1,9 @@
import { GameSystem } from "../game_system";
import { DrawParameters } from "../../core/draw_parameters";
import { globalConfig } from "../../core/config";
import { MapChunkView } from "../map_chunk_view";
import { DrawParameters } from "../../core/draw_parameters";
import { Loader } from "../../core/loader";
import { enumDirection } from "../../core/vector";
import { enumLayer } from "../root";
import { GameSystem } from "../game_system";
import { MapChunkView } from "../map_chunk_view";
export class StaticMapEntitySystem extends GameSystem {
constructor(root) {

3
src/js/game/systems/storage.js
View File

@@ -22,8 +22,7 @@ export class StorageSystem extends GameSystemWithFilter {
if (storageComp.storedItem && storageComp.storedCount > 0) {
const ejectorComp = entity.components.ItemEjector;
/* FIXME: WIRES */
const nextSlot = ejectorComp.getFirstFreeSlot(enumLayer.regular);
const nextSlot = ejectorComp.getFirstFreeSlot();
if (nextSlot !== null) {
if (ejectorComp.tryEject(nextSlot, storageComp.storedItem)) {
storageComp.storedCount--;

2
src/js/game/systems/underground_belt.js
View File

@@ -395,7 +395,7 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
if (remainingTime <= 0) {
const ejectorComp = entity.components.ItemEjector;
const nextSlotIndex = ejectorComp.getFirstFreeSlot(entity.layer);
const nextSlotIndex = ejectorComp.getFirstFreeSlot();
if (nextSlotIndex !== null) {
if (ejectorComp.tryEject(nextSlotIndex, nextItem)) {
items.shift();

8
src/js/game/systems/wired_pins.js
View File

@@ -14,14 +14,6 @@ export class WiredPinsSystem extends GameSystemWithFilter {
super(root, [WiredPinsComponent]);
this.pinSprites = {
[enumPinSlotType.positiveEnergyEjector]: Loader.getSprite("sprites/wires/pin_positive_eject.png"),
[enumPinSlotType.positiveEnergyAcceptor]: Loader.getSprite(
"sprites/wires/pin_positive_accept.png"
),
[enumPinSlotType.negativeEnergyEjector]: Loader.getSprite("sprites/wires/pin_negative_eject.png"),
[enumPinSlotType.negativeEnergyAcceptor]: Loader.getSprite(
"sprites/wires/pin_negative_accept.png"
),
[enumPinSlotType.logicalEjector]: Loader.getSprite("sprites/wires/pin_negative_eject.png"),
[enumPinSlotType.logicalAcceptor]: Loader.getSprite("sprites/wires/pin_negative_accept.png"),
};