mirror of
https://github.com/tobspr/shapez.io.git
synced 2026-03-02 03:39:21 +00:00
Proper belt underlays for splitters
This commit is contained in:
tobspr
@@ -96,6 +96,7 @@ export class MetaSplitterBuilding extends MetaBuilding {
|
||||
entity.addComponent(
|
||||
new ItemEjectorComponent({
|
||||
slots: [], // set later
|
||||
renderFloatingItems: false,
|
||||
})
|
||||
);
|
||||
|
||||
|
||||
@@ -1,33 +1,56 @@
|
||||
import { Component } from "../component";
|
||||
import { types } from "../../savegame/serialization";
|
||||
import { enumDirection, Vector } from "../../core/vector";
|
||||
|
||||
export class BeltUnderlaysComponent extends Component {
|
||||
static getId() {
|
||||
return "BeltUnderlays";
|
||||
}
|
||||
|
||||
duplicateWithoutContents() {
|
||||
const beltUnderlaysCopy = [];
|
||||
for (let i = 0; i < this.underlays.length; ++i) {
|
||||
const underlay = this.underlays[i];
|
||||
beltUnderlaysCopy.push({
|
||||
pos: underlay.pos.copy(),
|
||||
direction: underlay.direction,
|
||||
});
|
||||
}
|
||||
|
||||
return new BeltUnderlaysComponent({
|
||||
underlays: beltUnderlaysCopy,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {object} param0
|
||||
* @param {Array<{pos: Vector, direction: enumDirection}>=} param0.underlays Where to render belt underlays
|
||||
*/
|
||||
constructor({ underlays }) {
|
||||
super();
|
||||
this.underlays = underlays;
|
||||
}
|
||||
}
|
||||
import { enumDirection, Vector } from "../../core/vector";
|
||||
import { Component } from "../component";
|
||||
|
||||
/**
|
||||
* Store which type an underlay is, this is cached so we can easily
|
||||
* render it.
|
||||
*
|
||||
* Full: Render underlay at top and bottom of tile
|
||||
* Bottom Only: Only render underlay at the bottom half
|
||||
* Top Only:
|
||||
* @enum {string}
|
||||
*/
|
||||
export const enumClippedBeltUnderlayType = {
|
||||
full: "full",
|
||||
bottomOnly: "bottomOnly",
|
||||
topOnly: "topOnly",
|
||||
none: "none",
|
||||
};
|
||||
|
||||
/**
|
||||
* @typedef {{
|
||||
* pos: Vector,
|
||||
* direction: enumDirection,
|
||||
* cachedType?: enumClippedBeltUnderlayType
|
||||
* }} BeltUnderlayTile
|
||||
*/
|
||||
|
||||
export class BeltUnderlaysComponent extends Component {
|
||||
static getId() {
|
||||
return "BeltUnderlays";
|
||||
}
|
||||
|
||||
duplicateWithoutContents() {
|
||||
const beltUnderlaysCopy = [];
|
||||
for (let i = 0; i < this.underlays.length; ++i) {
|
||||
const underlay = this.underlays[i];
|
||||
beltUnderlaysCopy.push({
|
||||
pos: underlay.pos.copy(),
|
||||
direction: underlay.direction,
|
||||
});
|
||||
}
|
||||
|
||||
return new BeltUnderlaysComponent({
|
||||
underlays: beltUnderlaysCopy,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {object} param0
|
||||
* @param {Array<BeltUnderlayTile>=} param0.underlays Where to render belt underlays
|
||||
*/
|
||||
constructor({ underlays = [] }) {
|
||||
super();
|
||||
this.underlays = underlays;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,161 +1,159 @@
|
||||
import { enumDirection, enumDirectionToVector, Vector } from "../../core/vector";
|
||||
import { types } from "../../savegame/serialization";
|
||||
import { BaseItem } from "../base_item";
|
||||
import { BeltPath } from "../belt_path";
|
||||
import { Component } from "../component";
|
||||
import { Entity } from "../entity";
|
||||
import { typeItemSingleton } from "../item_resolver";
|
||||
|
||||
/**
|
||||
* @typedef {{
|
||||
* pos: Vector,
|
||||
* direction: enumDirection,
|
||||
* item: BaseItem,
|
||||
* progress: number?,
|
||||
* cachedDestSlot?: import("./item_acceptor").ItemAcceptorLocatedSlot,
|
||||
* cachedBeltPath?: BeltPath,
|
||||
* cachedTargetEntity?: Entity
|
||||
* }} ItemEjectorSlot
|
||||
*/
|
||||
|
||||
export class ItemEjectorComponent extends Component {
|
||||
static getId() {
|
||||
return "ItemEjector";
|
||||
}
|
||||
|
||||
static getSchema() {
|
||||
// The cachedDestSlot, cachedTargetEntity fields are not serialized.
|
||||
return {
|
||||
slots: types.array(
|
||||
types.structured({
|
||||
item: types.nullable(typeItemSingleton),
|
||||
progress: types.float,
|
||||
})
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
duplicateWithoutContents() {
|
||||
const slotsCopy = [];
|
||||
for (let i = 0; i < this.slots.length; ++i) {
|
||||
const slot = this.slots[i];
|
||||
slotsCopy.push({
|
||||
pos: slot.pos.copy(),
|
||||
direction: slot.direction,
|
||||
});
|
||||
}
|
||||
|
||||
return new ItemEjectorComponent({
|
||||
slots: slotsCopy,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param {object} param0
|
||||
* @param {Array<{pos: Vector, direction: enumDirection }>=} param0.slots The slots to eject on
|
||||
*/
|
||||
constructor({ slots = [] }) {
|
||||
super();
|
||||
|
||||
this.setSlots(slots);
|
||||
|
||||
/**
|
||||
* Whether this ejector slot is enabled
|
||||
*/
|
||||
this.enabled = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Array<{pos: Vector, direction: enumDirection }>} slots The slots to eject on
|
||||
*/
|
||||
setSlots(slots) {
|
||||
/** @type {Array<ItemEjectorSlot>} */
|
||||
this.slots = [];
|
||||
for (let i = 0; i < slots.length; ++i) {
|
||||
const slot = slots[i];
|
||||
this.slots.push({
|
||||
pos: slot.pos,
|
||||
direction: slot.direction,
|
||||
item: null,
|
||||
progress: 0,
|
||||
cachedDestSlot: null,
|
||||
cachedTargetEntity: null,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns where this slot ejects to
|
||||
* @param {ItemEjectorSlot} slot
|
||||
* @returns {Vector}
|
||||
*/
|
||||
getSlotTargetLocalTile(slot) {
|
||||
const directionVector = enumDirectionToVector[slot.direction];
|
||||
return slot.pos.add(directionVector);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether any slot ejects to the given local tile
|
||||
* @param {Vector} tile
|
||||
*/
|
||||
anySlotEjectsToLocalTile(tile) {
|
||||
for (let i = 0; i < this.slots.length; ++i) {
|
||||
if (this.getSlotTargetLocalTile(this.slots[i]).equals(tile)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns if we can eject on a given slot
|
||||
* @param {number} slotIndex
|
||||
* @returns {boolean}
|
||||
*/
|
||||
canEjectOnSlot(slotIndex) {
|
||||
assert(slotIndex >= 0 && slotIndex < this.slots.length, "Invalid ejector slot: " + slotIndex);
|
||||
return !this.slots[slotIndex].item;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the first free slot on this ejector or null if there is none
|
||||
* @returns {number?}
|
||||
*/
|
||||
getFirstFreeSlot() {
|
||||
for (let i = 0; i < this.slots.length; ++i) {
|
||||
if (this.canEjectOnSlot(i)) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tries to eject a given item
|
||||
* @param {number} slotIndex
|
||||
* @param {BaseItem} item
|
||||
* @returns {boolean}
|
||||
*/
|
||||
tryEject(slotIndex, item) {
|
||||
if (!this.canEjectOnSlot(slotIndex)) {
|
||||
return false;
|
||||
}
|
||||
this.slots[slotIndex].item = item;
|
||||
this.slots[slotIndex].progress = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears the given slot and returns the item it had
|
||||
* @param {number} slotIndex
|
||||
* @returns {BaseItem|null}
|
||||
*/
|
||||
takeSlotItem(slotIndex) {
|
||||
const slot = this.slots[slotIndex];
|
||||
const item = slot.item;
|
||||
slot.item = null;
|
||||
slot.progress = 0.0;
|
||||
return item;
|
||||
}
|
||||
}
|
||||
import { enumDirection, enumDirectionToVector, Vector } from "../../core/vector";
|
||||
import { types } from "../../savegame/serialization";
|
||||
import { BaseItem } from "../base_item";
|
||||
import { BeltPath } from "../belt_path";
|
||||
import { Component } from "../component";
|
||||
import { Entity } from "../entity";
|
||||
import { typeItemSingleton } from "../item_resolver";
|
||||
|
||||
/**
|
||||
* @typedef {{
|
||||
* pos: Vector,
|
||||
* direction: enumDirection,
|
||||
* item: BaseItem,
|
||||
* progress: number?,
|
||||
* cachedDestSlot?: import("./item_acceptor").ItemAcceptorLocatedSlot,
|
||||
* cachedBeltPath?: BeltPath,
|
||||
* cachedTargetEntity?: Entity
|
||||
* }} ItemEjectorSlot
|
||||
*/
|
||||
|
||||
export class ItemEjectorComponent extends Component {
|
||||
static getId() {
|
||||
return "ItemEjector";
|
||||
}
|
||||
|
||||
static getSchema() {
|
||||
// The cachedDestSlot, cachedTargetEntity fields are not serialized.
|
||||
return {
|
||||
slots: types.array(
|
||||
types.structured({
|
||||
item: types.nullable(typeItemSingleton),
|
||||
progress: types.float,
|
||||
})
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
duplicateWithoutContents() {
|
||||
const slotsCopy = [];
|
||||
for (let i = 0; i < this.slots.length; ++i) {
|
||||
const slot = this.slots[i];
|
||||
slotsCopy.push({
|
||||
pos: slot.pos.copy(),
|
||||
direction: slot.direction,
|
||||
});
|
||||
}
|
||||
|
||||
return new ItemEjectorComponent({
|
||||
slots: slotsCopy,
|
||||
renderFloatingItems: this.renderFloatingItems,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param {object} param0
|
||||
* @param {Array<{pos: Vector, direction: enumDirection }>=} param0.slots The slots to eject on
|
||||
* @param {boolean=} param0.renderFloatingItems Whether to render items even if they are not connected
|
||||
*/
|
||||
constructor({ slots = [], renderFloatingItems = true }) {
|
||||
super();
|
||||
|
||||
this.setSlots(slots);
|
||||
this.renderFloatingItems = renderFloatingItems;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Array<{pos: Vector, direction: enumDirection }>} slots The slots to eject on
|
||||
*/
|
||||
setSlots(slots) {
|
||||
/** @type {Array<ItemEjectorSlot>} */
|
||||
this.slots = [];
|
||||
for (let i = 0; i < slots.length; ++i) {
|
||||
const slot = slots[i];
|
||||
this.slots.push({
|
||||
pos: slot.pos,
|
||||
direction: slot.direction,
|
||||
item: null,
|
||||
progress: 0,
|
||||
cachedDestSlot: null,
|
||||
cachedTargetEntity: null,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns where this slot ejects to
|
||||
* @param {ItemEjectorSlot} slot
|
||||
* @returns {Vector}
|
||||
*/
|
||||
getSlotTargetLocalTile(slot) {
|
||||
const directionVector = enumDirectionToVector[slot.direction];
|
||||
return slot.pos.add(directionVector);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether any slot ejects to the given local tile
|
||||
* @param {Vector} tile
|
||||
*/
|
||||
anySlotEjectsToLocalTile(tile) {
|
||||
for (let i = 0; i < this.slots.length; ++i) {
|
||||
if (this.getSlotTargetLocalTile(this.slots[i]).equals(tile)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns if we can eject on a given slot
|
||||
* @param {number} slotIndex
|
||||
* @returns {boolean}
|
||||
*/
|
||||
canEjectOnSlot(slotIndex) {
|
||||
assert(slotIndex >= 0 && slotIndex < this.slots.length, "Invalid ejector slot: " + slotIndex);
|
||||
return !this.slots[slotIndex].item;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the first free slot on this ejector or null if there is none
|
||||
* @returns {number?}
|
||||
*/
|
||||
getFirstFreeSlot() {
|
||||
for (let i = 0; i < this.slots.length; ++i) {
|
||||
if (this.canEjectOnSlot(i)) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tries to eject a given item
|
||||
* @param {number} slotIndex
|
||||
* @param {BaseItem} item
|
||||
* @returns {boolean}
|
||||
*/
|
||||
tryEject(slotIndex, item) {
|
||||
if (!this.canEjectOnSlot(slotIndex)) {
|
||||
return false;
|
||||
}
|
||||
this.slots[slotIndex].item = item;
|
||||
this.slots[slotIndex].progress = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears the given slot and returns the item it had
|
||||
* @param {number} slotIndex
|
||||
* @returns {BaseItem|null}
|
||||
*/
|
||||
takeSlotItem(slotIndex) {
|
||||
const slot = this.slots[slotIndex];
|
||||
const item = slot.item;
|
||||
slot.item = null;
|
||||
slot.progress = 0.0;
|
||||
return item;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,84 +1,300 @@
|
||||
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 { GameSystemWithFilter } from "../game_system_with_filter";
|
||||
import { BELT_ANIM_COUNT } from "./belt";
|
||||
import { MapChunkView } from "../map_chunk_view";
|
||||
import { DrawParameters } from "../../core/draw_parameters";
|
||||
|
||||
export class BeltUnderlaysSystem extends GameSystemWithFilter {
|
||||
constructor(root) {
|
||||
super(root, [BeltUnderlaysComponent]);
|
||||
|
||||
this.underlayBeltSprites = [];
|
||||
|
||||
for (let i = 0; i < BELT_ANIM_COUNT; ++i) {
|
||||
this.underlayBeltSprites.push(Loader.getSprite("sprites/belt/built/forward_" + i + ".png"));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Draws a given chunk
|
||||
* @param {DrawParameters} parameters
|
||||
* @param {MapChunkView} chunk
|
||||
*/
|
||||
drawChunk(parameters, chunk) {
|
||||
// Limit speed to avoid belts going backwards
|
||||
const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed(), 10);
|
||||
|
||||
const contents = chunk.containedEntitiesByLayer.regular;
|
||||
for (let i = 0; i < contents.length; ++i) {
|
||||
const entity = contents[i];
|
||||
const underlayComp = entity.components.BeltUnderlays;
|
||||
if (!underlayComp) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const staticComp = entity.components.StaticMapEntity;
|
||||
const underlays = underlayComp.underlays;
|
||||
for (let i = 0; i < underlays.length; ++i) {
|
||||
const { pos, direction } = underlays[i];
|
||||
const transformedPos = staticComp.localTileToWorld(pos);
|
||||
|
||||
// Culling
|
||||
if (!chunk.tileSpaceRectangle.containsPoint(transformedPos.x, transformedPos.y)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const destX = transformedPos.x * globalConfig.tileSize;
|
||||
const destY = transformedPos.y * globalConfig.tileSize;
|
||||
|
||||
// Culling, #2
|
||||
if (
|
||||
!parameters.visibleRect.containsRect4Params(
|
||||
destX,
|
||||
destY,
|
||||
globalConfig.tileSize,
|
||||
globalConfig.tileSize
|
||||
)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const angle = enumDirectionToAngle[staticComp.localDirectionToWorld(direction)];
|
||||
|
||||
// SYNC with systems/belt.js:drawSingleEntity!
|
||||
const animationIndex = Math.floor(
|
||||
((this.root.time.realtimeNow() * speedMultiplier * BELT_ANIM_COUNT * 126) / 42) *
|
||||
globalConfig.itemSpacingOnBelts
|
||||
);
|
||||
|
||||
drawRotatedSprite({
|
||||
parameters,
|
||||
sprite: this.underlayBeltSprites[animationIndex % this.underlayBeltSprites.length],
|
||||
x: destX + globalConfig.halfTileSize,
|
||||
y: destY + globalConfig.halfTileSize,
|
||||
angle: Math.radians(angle),
|
||||
size: globalConfig.tileSize,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
import { globalConfig } from "../../core/config";
|
||||
import { DrawParameters } from "../../core/draw_parameters";
|
||||
import { Loader } from "../../core/loader";
|
||||
import { Rectangle } from "../../core/rectangle";
|
||||
import { FULL_CLIP_RECT } from "../../core/sprites";
|
||||
import { StaleAreaDetector } from "../../core/stale_area_detector";
|
||||
import {
|
||||
enumDirection,
|
||||
enumDirectionToAngle,
|
||||
enumDirectionToVector,
|
||||
enumInvertedDirections,
|
||||
Vector,
|
||||
} from "../../core/vector";
|
||||
import { BeltComponent } from "../components/belt";
|
||||
import { BeltUnderlaysComponent, enumClippedBeltUnderlayType } from "../components/belt_underlays";
|
||||
import { ItemAcceptorComponent } from "../components/item_acceptor";
|
||||
import { ItemEjectorComponent } from "../components/item_ejector";
|
||||
import { Entity } from "../entity";
|
||||
import { GameSystemWithFilter } from "../game_system_with_filter";
|
||||
import { MapChunkView } from "../map_chunk_view";
|
||||
import { BELT_ANIM_COUNT } from "./belt";
|
||||
|
||||
/**
|
||||
* Mapping from underlay type to clip rect
|
||||
* @type {Object<enumClippedBeltUnderlayType, Rectangle>}
|
||||
*/
|
||||
const enumUnderlayTypeToClipRect = {
|
||||
[enumClippedBeltUnderlayType.none]: null,
|
||||
[enumClippedBeltUnderlayType.full]: FULL_CLIP_RECT,
|
||||
[enumClippedBeltUnderlayType.topOnly]: new Rectangle(0, 0, 1, 0.5),
|
||||
[enumClippedBeltUnderlayType.bottomOnly]: new Rectangle(0, 0.5, 1, 0.5),
|
||||
};
|
||||
|
||||
export class BeltUnderlaysSystem extends GameSystemWithFilter {
|
||||
constructor(root) {
|
||||
super(root, [BeltUnderlaysComponent]);
|
||||
|
||||
this.underlayBeltSprites = [];
|
||||
|
||||
for (let i = 0; i < BELT_ANIM_COUNT; ++i) {
|
||||
this.underlayBeltSprites.push(Loader.getSprite("sprites/belt/built/forward_" + i + ".png"));
|
||||
}
|
||||
|
||||
// Automatically recompute areas
|
||||
this.staleArea = new StaleAreaDetector({
|
||||
root,
|
||||
name: "belt-underlay",
|
||||
recomputeMethod: this.recomputeStaleArea.bind(this),
|
||||
});
|
||||
|
||||
this.staleArea.recomputeOnComponentsChanged(
|
||||
[BeltUnderlaysComponent, BeltComponent, ItemAcceptorComponent, ItemEjectorComponent],
|
||||
1
|
||||
);
|
||||
}
|
||||
|
||||
update() {
|
||||
this.staleArea.update();
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when an area changed - Resets all caches in the given area
|
||||
* @param {Rectangle} area
|
||||
*/
|
||||
recomputeStaleArea(area) {
|
||||
for (let x = 0; x < area.w; ++x) {
|
||||
for (let y = 0; y < area.h; ++y) {
|
||||
const tileX = area.x + x;
|
||||
const tileY = area.y + y;
|
||||
const entity = this.root.map.getLayerContentXY(tileX, tileY, "regular");
|
||||
if (entity) {
|
||||
const underlayComp = entity.components.BeltUnderlays;
|
||||
if (underlayComp) {
|
||||
for (let i = 0; i < underlayComp.underlays.length; ++i) {
|
||||
underlayComp.underlays[i].cachedType = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if a given tile is connected and has an acceptor
|
||||
* @param {Vector} tile
|
||||
* @param {enumDirection} fromDirection
|
||||
* @returns {boolean}
|
||||
*/
|
||||
checkIsAcceptorConnected(tile, fromDirection) {
|
||||
const contents = this.root.map.getLayerContentXY(tile.x, tile.y, "regular");
|
||||
if (!contents) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const staticComp = contents.components.StaticMapEntity;
|
||||
|
||||
// Check if its a belt, since then its simple
|
||||
const beltComp = contents.components.Belt;
|
||||
if (beltComp) {
|
||||
return staticComp.localDirectionToWorld(enumDirection.bottom) === fromDirection;
|
||||
}
|
||||
|
||||
// Check if there's an item acceptor
|
||||
const acceptorComp = contents.components.ItemAcceptor;
|
||||
if (acceptorComp) {
|
||||
// Check each slot to see if its connected
|
||||
for (let i = 0; i < acceptorComp.slots.length; ++i) {
|
||||
const slot = acceptorComp.slots[i];
|
||||
const slotTile = staticComp.localTileToWorld(slot.pos);
|
||||
|
||||
// Step 1: Check if the tile matches
|
||||
if (!slotTile.equals(tile)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Step 2: Check if any of the directions matches
|
||||
for (let j = 0; j < slot.directions.length; ++j) {
|
||||
const slotDirection = staticComp.localDirectionToWorld(slot.directions[j]);
|
||||
if (slotDirection === fromDirection) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if a given tile is connected and has an ejector
|
||||
* @param {Vector} tile
|
||||
* @param {enumDirection} toDirection
|
||||
* @returns {boolean}
|
||||
*/
|
||||
checkIsEjectorConnected(tile, toDirection) {
|
||||
const contents = this.root.map.getLayerContentXY(tile.x, tile.y, "regular");
|
||||
if (!contents) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const staticComp = contents.components.StaticMapEntity;
|
||||
|
||||
// Check if its a belt, since then its simple
|
||||
const beltComp = contents.components.Belt;
|
||||
if (beltComp) {
|
||||
return staticComp.localDirectionToWorld(beltComp.direction) === toDirection;
|
||||
}
|
||||
|
||||
// Check for an ejector
|
||||
const ejectorComp = contents.components.ItemEjector;
|
||||
if (ejectorComp) {
|
||||
// Check each slot to see if its connected
|
||||
for (let i = 0; i < ejectorComp.slots.length; ++i) {
|
||||
const slot = ejectorComp.slots[i];
|
||||
const slotTile = staticComp.localTileToWorld(slot.pos);
|
||||
|
||||
// Step 1: Check if the tile matches
|
||||
if (!slotTile.equals(tile)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Step 2: Check if the direction matches
|
||||
const slotDirection = staticComp.localDirectionToWorld(slot.direction);
|
||||
if (slotDirection === toDirection) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Computes the flag for a given tile
|
||||
* @param {Entity} entity
|
||||
* @param {import("../components/belt_underlays").BeltUnderlayTile} underlayTile
|
||||
* @returns {enumClippedBeltUnderlayType} The type of the underlay
|
||||
*/
|
||||
computeBeltUnderlayType(entity, underlayTile) {
|
||||
if (underlayTile.cachedType) {
|
||||
return underlayTile.cachedType;
|
||||
}
|
||||
|
||||
const staticComp = entity.components.StaticMapEntity;
|
||||
|
||||
const transformedPos = staticComp.localTileToWorld(underlayTile.pos);
|
||||
const destX = transformedPos.x * globalConfig.tileSize;
|
||||
const destY = transformedPos.y * globalConfig.tileSize;
|
||||
|
||||
// Extract direction and angle
|
||||
const worldDirection = staticComp.localDirectionToWorld(underlayTile.direction);
|
||||
const worldDirectionVector = enumDirectionToVector[worldDirection];
|
||||
|
||||
// Figure out if there is anything connected at the top
|
||||
const connectedTop = this.checkIsAcceptorConnected(
|
||||
transformedPos.add(worldDirectionVector),
|
||||
enumInvertedDirections[worldDirection]
|
||||
);
|
||||
|
||||
// Figure out if there is anything connected at the bottom
|
||||
const connectedBottom = this.checkIsEjectorConnected(
|
||||
transformedPos.sub(worldDirectionVector),
|
||||
worldDirection
|
||||
);
|
||||
|
||||
let flag = enumClippedBeltUnderlayType.none;
|
||||
|
||||
if (connectedTop && connectedBottom) {
|
||||
flag = enumClippedBeltUnderlayType.full;
|
||||
} else if (connectedTop) {
|
||||
flag = enumClippedBeltUnderlayType.topOnly;
|
||||
} else if (connectedBottom) {
|
||||
flag = enumClippedBeltUnderlayType.bottomOnly;
|
||||
}
|
||||
|
||||
return (underlayTile.cachedType = flag);
|
||||
}
|
||||
|
||||
/**
|
||||
* Draws a given chunk
|
||||
* @param {DrawParameters} parameters
|
||||
* @param {MapChunkView} chunk
|
||||
*/
|
||||
drawChunk(parameters, chunk) {
|
||||
// Limit speed to avoid belts going backwards
|
||||
const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed(), 10);
|
||||
|
||||
const contents = chunk.containedEntitiesByLayer.regular;
|
||||
for (let i = 0; i < contents.length; ++i) {
|
||||
const entity = contents[i];
|
||||
const underlayComp = entity.components.BeltUnderlays;
|
||||
if (!underlayComp) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const staticComp = entity.components.StaticMapEntity;
|
||||
const underlays = underlayComp.underlays;
|
||||
for (let i = 0; i < underlays.length; ++i) {
|
||||
// Extract underlay parameters
|
||||
const { pos, direction } = underlays[i];
|
||||
const transformedPos = staticComp.localTileToWorld(pos);
|
||||
const destX = transformedPos.x * globalConfig.tileSize;
|
||||
const destY = transformedPos.y * globalConfig.tileSize;
|
||||
|
||||
// Culling, Part 1: Check if the chunk contains the tile
|
||||
if (!chunk.tileSpaceRectangle.containsPoint(transformedPos.x, transformedPos.y)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Culling, Part 2: Check if the overlay is visible
|
||||
if (
|
||||
!parameters.visibleRect.containsRect4Params(
|
||||
destX,
|
||||
destY,
|
||||
globalConfig.tileSize,
|
||||
globalConfig.tileSize
|
||||
)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Extract direction and angle
|
||||
const worldDirection = staticComp.localDirectionToWorld(direction);
|
||||
const angle = enumDirectionToAngle[worldDirection];
|
||||
|
||||
const underlayType = this.computeBeltUnderlayType(entity, underlays[i]);
|
||||
const clipRect = enumUnderlayTypeToClipRect[underlayType];
|
||||
if (!clipRect) {
|
||||
// Empty
|
||||
return;
|
||||
}
|
||||
|
||||
// Actually draw the sprite
|
||||
const x = destX + globalConfig.halfTileSize;
|
||||
const y = destY + globalConfig.halfTileSize;
|
||||
const angleRadians = Math.radians(angle);
|
||||
|
||||
// SYNC with systems/belt.js:drawSingleEntity!
|
||||
const animationIndex = Math.floor(
|
||||
((this.root.time.realtimeNow() * speedMultiplier * BELT_ANIM_COUNT * 126) / 42) *
|
||||
globalConfig.itemSpacingOnBelts
|
||||
);
|
||||
parameters.context.translate(x, y);
|
||||
parameters.context.rotate(angleRadians);
|
||||
this.underlayBeltSprites[
|
||||
animationIndex % this.underlayBeltSprites.length
|
||||
].drawCachedWithClipRect(
|
||||
parameters,
|
||||
-globalConfig.halfTileSize,
|
||||
-globalConfig.halfTileSize,
|
||||
globalConfig.tileSize,
|
||||
globalConfig.tileSize,
|
||||
clipRect
|
||||
);
|
||||
parameters.context.rotate(-angleRadians);
|
||||
parameters.context.translate(-x, -y);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -198,9 +198,6 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
|
||||
for (let i = 0; i < this.allEntities.length; ++i) {
|
||||
const sourceEntity = this.allEntities[i];
|
||||
const sourceEjectorComp = sourceEntity.components.ItemEjector;
|
||||
if (!sourceEjectorComp.enabled) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const slots = sourceEjectorComp.slots;
|
||||
for (let j = 0; j < slots.length; ++j) {
|
||||
@@ -211,8 +208,6 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
|
||||
continue;
|
||||
}
|
||||
|
||||
const targetEntity = sourceSlot.cachedTargetEntity;
|
||||
|
||||
// Advance items on the slot
|
||||
sourceSlot.progress = Math.min(
|
||||
1,
|
||||
@@ -245,15 +240,16 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
|
||||
}
|
||||
|
||||
// Check if the target acceptor can actually accept this item
|
||||
const destEntity = sourceSlot.cachedTargetEntity;
|
||||
const destSlot = sourceSlot.cachedDestSlot;
|
||||
if (destSlot) {
|
||||
const targetAcceptorComp = targetEntity.components.ItemAcceptor;
|
||||
const targetAcceptorComp = destEntity.components.ItemAcceptor;
|
||||
if (!targetAcceptorComp.canAcceptItem(destSlot.index, item)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Try to hand over the item
|
||||
if (this.tryPassOverItem(item, targetEntity, destSlot.index)) {
|
||||
if (this.tryPassOverItem(item, destEntity, destSlot.index)) {
|
||||
// Handover successful, clear slot
|
||||
targetAcceptorComp.onItemAccepted(destSlot.index, destSlot.acceptedDirection, item);
|
||||
sourceSlot.item = null;
|
||||
@@ -357,6 +353,11 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!ejectorComp.renderFloatingItems && !slot.cachedTargetEntity) {
|
||||
// Not connected to any building
|
||||
continue;
|
||||
}
|
||||
|
||||
const realPosition = staticComp.localTileToWorld(slot.pos);
|
||||
if (!chunk.tileSpaceRectangle.containsPoint(realPosition.x, realPosition.y)) {
|
||||
// Not within this chunk
|
||||
|
||||
Reference in New Issue
Block a user