Archives/tobspr_shapez.io
1
0
Fork 0
mirror of https://github.com/tobspr/shapez.io.git synced 2025-06-13 13:04:03 +00:00
Code Issues Projects Releases Wiki Activity

Changes to building variants

Browse Source
This commit is contained in:
Exund 2020-09-17 19:27:21 +02:00
parent 0377c6d58f
commit 9114c9e4c3
11 changed files with 219 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/js/game/building_codes.js
View File

@ -1,5 +1,5 @@
/* typehints:start */
import { MetaBuilding } from "./meta_building";
import { MetaBuilding, MetaBuildingVariant } from "./meta_building";
import { AtlasSprite } from "../core/sprites";
import { Vector } from "../core/vector";
/* typehints:end */
@ -8,7 +8,7 @@ import { Vector } from "../core/vector";
* @typedef {{
* metaClass: typeof MetaBuilding,
* metaInstance?: MetaBuilding,
* variant?: string,
* variant: typeof MetaBuildingVariant,
* rotationVariant?: number,
* tileSize?: Vector,
* sprite?: AtlasSprite,
@ -27,17 +27,12 @@ export const gBuildingVariants = {
/**
* Registers a new variant
* @param {number} id
* @param {number | string} id
* @param {typeof MetaBuilding} meta
* @param {string} variant
* @param {typeof MetaBuildingVariant} variant
* @param {number} rotationVariant
*/
export function registerBuildingVariant(
id,
meta,
variant = "default" /* FIXME: Circular dependency, actually its defaultBuildingVariant */,
rotationVariant = 0
) {
export function registerBuildingVariant(id, meta, variant, rotationVariant = 0) {
assert(!gBuildingVariants[id], "Duplicate id: " + id);
gBuildingVariants[id] = {
metaClass: meta,
@ -50,7 +45,7 @@ export function registerBuildingVariant(
/**
*
* @param {number} code
* @param {number | string} code
* @returns {BuildingVariantIdentifier}
*/
export function getBuildingDataFromCode(code) {
@ -61,7 +56,7 @@ export function getBuildingDataFromCode(code) {
/**
* Finds the code for a given variant
* @param {MetaBuilding} metaBuilding
* @param {string} variant
* @param {typeof MetaBuildingVariant} variant
* @param {number} rotationVariant
*/
export function getCodeFromBuildingData(metaBuilding, variant, rotationVariant) {
@ -77,7 +72,12 @@ export function getCodeFromBuildingData(metaBuilding, variant, rotationVariant)
}
assertAlways(
false,
"Building not found by data: " + metaBuilding.getId() + " / " + variant + " / " + rotationVariant
"Building not found by data: " +
metaBuilding.getId() +
" / " +
variant.getId() +
" / " +
rotationVariant
);
return 0;
}

6
src/js/game/components/static_map_entity.js
View File

@ -19,7 +19,7 @@ export class StaticMapEntityComponent extends Component {
originalRotation: types.float,
// See building_codes.js
code: types.uint,
code: types.string,
};
}
@ -79,14 +79,14 @@ export class StaticMapEntityComponent extends Component {
* @param {Vector=} param0.tileSize Size of the entity in tiles
* @param {number=} param0.rotation Rotation in degrees. Must be multiple of 90
* @param {number=} param0.originalRotation Original Rotation in degrees. Must be multiple of 90
* @param {number=} param0.code Building code
* @param {(number | string)=} param0.code Building code
*/
constructor({
origin = new Vector(),
tileSize = new Vector(1, 1),
rotation = 0,
originalRotation = 0,
code = 0,
code = "0",
}) {
super();
assert(

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

@ -155,13 +155,14 @@ export class GameCore {
this.root.map.seed = randomInt(0, 100000);
// Place the hub
const hub = gMetaBuildingRegistry.findByClass(MetaHubBuilding).createEntity({
const metaBuilding = gMetaBuildingRegistry.findByClass(MetaHubBuilding);
const hub = metaBuilding.createEntity({
root: this.root,
origin: new Vector(-2, -2),
rotation: 0,
originalRotation: 0,
rotationVariant: 0,
variant: defaultBuildingVariant,
variant: metaBuilding.getDefaultVariant(this.root),
});
this.root.map.placeStaticEntity(hub);
this.root.entityMgr.registerEntity(hub);

23
src/js/game/hud/parts/building_placer.js
View File

@ -116,8 +116,9 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
const variant = this.currentVariant.get();
this.buildingInfoElements.label.innerHTML = T.buildings[metaBuilding.id][variant].name;
this.buildingInfoElements.descText.innerHTML = T.buildings[metaBuilding.id][variant].description;
this.buildingInfoElements.label.innerHTML = T.buildings[metaBuilding.id][variant.getId()].name;
this.buildingInfoElements.descText.innerHTML =
T.buildings[metaBuilding.id][variant.getId()].description;
const binding = this.root.keyMapper.getBinding(KEYMAPPINGS.buildings[metaBuilding.getId()]);
this.buildingInfoElements.hotkey.innerHTML = T.ingame.buildingPlacement.hotkeyLabel.replace(
@ -129,12 +130,12 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
"data-icon",
"building_tutorials/" +
metaBuilding.getId() +
(variant === defaultBuildingVariant ? "" : "-" + variant) +
(variant === metaBuilding.getDefaultVariant(this.root) ? "" : "-" + variant.getId()) +
".png"
);
removeAllChildren(this.buildingInfoElements.additionalInfo);
const additionalInfo = metaBuilding.getAdditionalStatistics(this.root, this.currentVariant.get());
const additionalInfo = this.currentVariant.get().getAdditionalStatistics(this.root);
for (let i = 0; i < additionalInfo.length; ++i) {
const [label, contents] = additionalInfo[i];
this.buildingInfoElements.additionalInfo.innerHTML += `
@ -201,12 +202,12 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
const element = makeDiv(container, null, ["variant"]);
element.classList.toggle("active", variant === this.currentVariant.get());
makeDiv(element, null, ["label"], variant);
makeDiv(element, null, ["label"], variant.getId());
const iconSize = 64;
const dimensions = metaBuilding.getDimensions(variant);
const sprite = metaBuilding.getPreviewSprite(0, variant);
const dimensions = variant.getDimensions();
const sprite = variant.getPreviewSprite(0, metaBuilding);
const spriteWrapper = makeDiv(element, null, ["iconWrap"]);
spriteWrapper.setAttribute("data-tile-w", dimensions.x);
spriteWrapper.setAttribute("data-tile-h", dimensions.y);
@ -294,11 +295,10 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
rotation,
rotationVariant,
connectedEntities,
} = metaBuilding.computeOptimalDirectionAndRotationVariantAtTile({
} = this.currentVariant.get().computeOptimalDirectionAndRotationVariantAtTile({
root: this.root,
tile: mouseTile,
rotation: this.currentBaseRotation,
variant: this.currentVariant.get(),
layer: metaBuilding.getLayer(),
});
@ -338,7 +338,8 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
const staticComp = this.fakeEntity.components.StaticMapEntity;
staticComp.origin = mouseTile;
staticComp.rotation = rotation;
metaBuilding.updateVariants(this.fakeEntity, rotationVariant, this.currentVariant.get());
//metaBuilding.updateVariants(this.fakeEntity, rotationVariant, this.currentVariant.get());
this.currentVariant.get().updateEntityComponents(this.fakeEntity, rotationVariant, this.root);
staticComp.code = getCodeFromBuildingData(
this.currentMetaBuilding.get(),
this.currentVariant.get(),
@ -373,7 +374,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
parameters.context.globalAlpha = 1;
// HACK to draw the entity sprite
const previewSprite = metaBuilding.getBlueprintSprite(rotationVariant, this.currentVariant.get());
const previewSprite = this.currentVariant.get().getBlueprintSprite(rotationVariant, metaBuilding);
staticComp.origin = worldPos.divideScalar(globalConfig.tileSize).subScalars(0.5, 0.5);
staticComp.drawSpriteOnBoundsClipped(parameters, previewSprite);
staticComp.origin = mouseTile;

31
src/js/game/hud/parts/building_placer_logic.js
View File

@ -7,7 +7,7 @@ import { enumMouseButton } from "../../camera";
import { StaticMapEntityComponent } from "../../components/static_map_entity";
import { Entity } from "../../entity";
import { KEYMAPPINGS } from "../../key_action_mapper";
import { defaultBuildingVariant, MetaBuilding } from "../../meta_building";
import { defaultBuildingVariant, MetaBuilding, MetaBuildingVariant } from "../../meta_building";
import { BaseHUDPart } from "../base_hud_part";
import { SOUNDS } from "../../../platform/sound";
import { MetaMinerBuilding, enumMinerVariants } from "../../buildings/miner";
@ -64,7 +64,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
/**
* Current building variant
* @type {TypedTrackedState<string>}
* @type {TypedTrackedState<typeof MetaBuildingVariant>}
*/
this.currentVariant = new TrackedState(() => this.signals.variantChanged.dispatch());
@ -77,7 +77,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
/**
* Stores which variants for each building we prefer, this is based on what
* the user last selected
* @type {Object.<string, string>}
* @type {Object.<string, typeof MetaBuildingVariant>}
*/
this.preferredVariants = {};
@ -396,11 +396,13 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
}
const metaBuilding = this.currentMetaBuilding.get();
const { rotation, rotationVariant } = metaBuilding.computeOptimalDirectionAndRotationVariantAtTile({
const {
rotation,
rotationVariant,
} = this.currentVariant.get().computeOptimalDirectionAndRotationVariantAtTile({
root: this.root,
tile,
rotation: this.currentBaseRotation,
variant: this.currentVariant.get(),
layer: metaBuilding.getLayer(),
});
@ -448,13 +450,16 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
cycleVariants() {
const metaBuilding = this.currentMetaBuilding.get();
if (!metaBuilding) {
this.currentVariant.set(defaultBuildingVariant);
this.currentVariant.set(null);
} else {
const availableVariants = metaBuilding.getAvailableVariants(this.root);
const index = availableVariants.indexOf(this.currentVariant.get());
assert(
index >= 0,
"Current variant was invalid: " + this.currentVariant.get() + " out of " + availableVariants
"Current variant was invalid: " +
this.currentVariant.get().getId +
" out of " +
availableVariants
);
const newIndex = (index + 1) % availableVariants.length;
const newVariant = availableVariants[newIndex];
@ -464,7 +469,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
/**
* Sets the current variant to the given variant
* @param {string} variant
* @param {typeof MetaBuildingVariant} variant
*/
setVariant(variant) {
const metaBuilding = this.currentMetaBuilding.get();
@ -589,7 +594,8 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
this.abortDragging();
this.root.hud.signals.selectedPlacementBuildingChanged.dispatch(metaBuilding);
if (metaBuilding) {
const variant = this.preferredVariants[metaBuilding.getId()] || defaultBuildingVariant;
const variant =
this.preferredVariants[metaBuilding.getId()] || metaBuilding.getDefaultVariant(this.root);
this.currentVariant.set(variant);
this.fakeEntity = new Entity(null);
@ -599,11 +605,12 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
new StaticMapEntityComponent({
origin: new Vector(0, 0),
rotation: 0,
tileSize: metaBuilding.getDimensions(this.currentVariant.get()).copy(),
tileSize: variant.getDimensions().copy(),
code: getCodeFromBuildingData(metaBuilding, variant, 0),
})
);
metaBuilding.updateVariants(this.fakeEntity, 0, this.currentVariant.get());
variant.updateEntityComponents(this.fakeEntity, 0, this.root);
//metaBuilding.updateVariants(this.fakeEntity, 0, this.currentVariant.get());
} else {
this.fakeEntity = null;
}
@ -689,7 +696,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
// Automatic Direction
if (
metaBuilding &&
metaBuilding.getRotateAutomaticallyWhilePlacing(this.currentVariant.get()) &&
this.currentVariant.get().getRotateAutomaticallyWhilePlacing() &&
!this.root.keyMapper.getBinding(
KEYMAPPINGS.placementModifiers.placementDisableAutoOrientation
).pressed

7
src/js/game/logic.js
View File

@ -4,7 +4,7 @@ import { round2Digits } from "../core/utils";
import { enumDirection, enumDirectionToVector, enumInvertedDirections, Vector } from "../core/vector";
import { getBuildingDataFromCode } from "./building_codes";
import { Entity } from "./entity";
import { MetaBuilding } from "./meta_building";
import { MetaBuilding, MetaBuildingVariant } from "./meta_building";
import { GameRoot } from "./root";
import { WireNetwork } from "./systems/wire";
import { globalConfig } from "../core/config";
@ -98,7 +98,7 @@ export class GameLogic {
* @param {number} param0.rotation
* @param {number} param0.originalRotation
* @param {number} param0.rotationVariant
* @param {string} param0.variant
* @param {typeof MetaBuildingVariant} param0.variant
* @param {MetaBuilding} param0.building
* @returns {Entity}
*/
@ -283,10 +283,9 @@ export class GameLogic {
}
const data = getBuildingDataFromCode(staticComp.code);
const overlayMatrix = data.metaInstance.getSpecialOverlayRenderMatrix(
const overlayMatrix = data.variant.getSpecialOverlayRenderMatrix(
staticComp.rotation,
data.rotationVariant,
data.variant,
entity
);
// Always the same

6
src/js/game/map_chunk_view.js
View File

@ -149,10 +149,9 @@ export class MapChunkView extends MapChunk {
const data = getBuildingDataFromCode(staticComp.code);
const metaBuilding = data.metaInstance;
const overlayMatrix = metaBuilding.getSpecialOverlayRenderMatrix(
const overlayMatrix = data.variant.getSpecialOverlayRenderMatrix(
staticComp.rotation,
data.rotationVariant,
data.variant,
upperContent
);
@ -249,10 +248,9 @@ export class MapChunkView extends MapChunk {
const staticComp = entity.components.StaticMapEntity;
const data = getBuildingDataFromCode(staticComp.code);
const metaBuilding = data.metaInstance;
const overlayMatrix = metaBuilding.getSpecialOverlayRenderMatrix(
const overlayMatrix = data.variant.getSpecialOverlayRenderMatrix(
staticComp.rotation,
data.rotationVariant,
data.variant,
entity
);
context.fillStyle = overrideColor || metaBuilding.getSilhouetteColor();

269
src/js/game/meta_building.js
View File

@ -33,13 +33,6 @@ export class MetaBuilding {
return "regular";
}
/**
* Should return the dimensions of the building
*/
getDimensions(variant = defaultBuildingVariant) {
return new Vector(1, 1);
}
/**
* Returns whether the building has the direction lock switch available
*/
@ -54,28 +47,6 @@ export class MetaBuilding {
return false;
}
/**
* Can return a special interlaved 9 elements overlay matrix for rendering
* @param {number} rotation
* @param {number} rotationVariant
* @param {string} variant
* @param {Entity} entity
* @returns {Array<number>|null}
*/
getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
return null;
}
/**
* Should return additional statistics about this building
* @param {GameRoot} root
* @param {string} variant
* @returns {Array<[string, string]>}
*/
getAdditionalStatistics(root, variant) {
return [];
}
/**
* Returns whether this building can get replaced
*/
@ -98,14 +69,6 @@ export class MetaBuilding {
return false;
}
/**
* Whether to rotate automatically in the dragging direction while placing
* @param {string} variant
*/
getRotateAutomaticallyWhilePlacing(variant) {
return false;
}
/**
* Returns whether this building is removable
* @returns {boolean}
@ -124,44 +87,19 @@ export class MetaBuilding {
/**
* @param {GameRoot} root
* @returns {typeof MetaBuildingVariant}
*/
getDefaultVariant(root) {
return this.getAvailableVariants(root)[0];
}
/**
* @param {GameRoot} root
* @returns {Array<typeof MetaBuildingVariant>}
*/
getAvailableVariants(root) {
return [defaultBuildingVariant];
}
/**
* Returns a preview sprite
* @returns {AtlasSprite}
*/
getPreviewSprite(rotationVariant = 0, variant = defaultBuildingVariant) {
return Loader.getSprite(
"sprites/buildings/" +
this.id +
(variant === defaultBuildingVariant ? "" : "-" + variant) +
".png"
);
}
/**
* Returns a sprite for blueprints
* @returns {AtlasSprite}
*/
getBlueprintSprite(rotationVariant = 0, variant = defaultBuildingVariant) {
return Loader.getSprite(
"sprites/blueprints/" +
this.id +
(variant === defaultBuildingVariant ? "" : "-" + variant) +
".png"
);
}
/**
* Returns whether this building is rotateable
* @param {string} variant
* @returns {boolean}
*/
getIsRotateable(variant) {
return true;
abstract;
return [];
}
/**
@ -195,7 +133,7 @@ export class MetaBuilding {
* @param {number=} param0.rotation Rotation
* @param {number} param0.originalRotation Original Rotation
* @param {number} param0.rotationVariant Rotation variant
* @param {string} param0.variant
* @param {typeof MetaBuildingVariant} param0.variant
*/
createEntity({ root, origin, rotation, originalRotation, rotationVariant, variant }) {
const entity = new Entity(root);
@ -205,61 +143,15 @@ export class MetaBuilding {
origin: new Vector(origin.x, origin.y),
rotation,
originalRotation,
tileSize: this.getDimensions(variant).copy(),
tileSize: variant.getDimensions().copy(),
code: getCodeFromBuildingData(this, variant, rotationVariant),
})
);
this.setupEntityComponents(entity, root);
this.updateVariants(entity, rotationVariant, variant);
variant.updateEntityComponents(entity, rotationVariant, root);
return entity;
}
/**
* Returns the sprite for a given variant
* @param {number} rotationVariant
* @param {string} variant
* @returns {AtlasSprite}
*/
getSprite(rotationVariant, variant) {
return Loader.getSprite(
"sprites/buildings/" +
this.id +
(variant === defaultBuildingVariant ? "" : "-" + variant) +
".png"
);
}
/**
* Should compute the optimal rotation variant on the given tile
* @param {object} param0
* @param {GameRoot} param0.root
* @param {Vector} param0.tile
* @param {number} param0.rotation
* @param {string} param0.variant
* @param {Layer} param0.layer
* @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array<Entity> }}
*/
computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
if (!this.getIsRotateable(variant)) {
return {
rotation: 0,
rotationVariant: 0,
};
}
return {
rotation,
rotationVariant: 0,
};
}
/**
* Should update the entity to match the given variants
* @param {Entity} entity
* @param {number} rotationVariant
* @param {string} variant
*/
updateVariants(entity, rotationVariant, variant) {}
// PRIVATE INTERFACE
/**
@ -271,3 +163,136 @@ export class MetaBuilding {
abstract;
}
}
export class MetaBuildingVariant {
static toString() {
return this.getId();
}
/**
* @returns {string} Variant id
*/
static getId() {
abstract;
return "";
}
/**
* Should update the entity components
* @param {Entity} entity
* @param {number} rotationVariant
* @param {GameRoot} root
*/
static updateEntityComponents(entity, rotationVariant, root) {
abstract;
}
/**
* Returns whether this building is rotateable
* @returns {boolean}
*/
static getIsRotateable() {
return true;
}
/**
* Should compute the optimal rotation variant on the given tile
* @param {object} param0
* @param {GameRoot} param0.root
* @param {Vector} param0.tile
* @param {number} param0.rotation
* @param {Layer} param0.layer
* @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array<Entity> }}
*/
static computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, layer }) {
if (!this.getIsRotateable()) {
return {
rotation: 0,
rotationVariant: 0,
};
}
return {
rotation,
rotationVariant: 0,
};
}
/**
* Can return a special interlaved 9 elements overlay matrix for rendering
* @param {number} rotation
* @param {number} rotationVariant
* @param {Entity} entity
* @returns {Array<number>|null}
*/
static getSpecialOverlayRenderMatrix(rotation, rotationVariant, entity) {
return null;
}
/**
* Should return additional statistics about this building
* @param {GameRoot} root
* @returns {Array<[string, string]>}
*/
static getAdditionalStatistics(root) {
return [];
}
/**
* Returns the sprite for a given variant
* @param {number} rotationVariant
* @param {MetaBuilding} building
* @returns {AtlasSprite}
*/
static getSprite(rotationVariant, building) {
return Loader.getSprite(
"sprites/buildings/" +
building.id +
(this.getId() === defaultBuildingVariant ? "" : "-" + this.getId()) +
".png"
);
}
/**
* Returns the sprite for a given variant
* @param {number} rotationVariant
* @param {MetaBuilding} building
* @returns {AtlasSprite}
*/
static getBlueprintSprite(rotationVariant, building) {
return Loader.getSprite(
"sprites/blueprints/" +
building.id +
(this.getId() === defaultBuildingVariant ? "" : "-" + this.getId()) +
".png"
);
}
/**
* Returns the sprite for a given variant
* @param {number} rotationVariant
* @param {MetaBuilding} building
* @returns {AtlasSprite}
*/
static getPreviewSprite(rotationVariant, building) {
return Loader.getSprite(
"sprites/buildings/" +
building.id +
(this.getId() === defaultBuildingVariant ? "" : "-" + this.getId()) +
".png"
);
}
/**
* Whether to rotate automatically in the dragging direction while placing
*/
static getRotateAutomaticallyWhilePlacing() {
return false;
}
/**
* Should return the dimensions of the building
*/
static getDimensions() {
return new Vector(1, 1);
}
}

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

@ -151,9 +151,9 @@ export function initMetaBuildingRegistry() {
if (typeof variant.rotationVariant === "undefined") {
variant.rotationVariant = 0;
}
if (typeof variant.variant === "undefined") {
/*if (typeof variant.variant === "undefined") {
variant.variant = defaultBuildingVariant;
}
}*/
}
logger.log("Registered", gMetaBuildingRegistry.getNumEntries(), "buildings");
@ -168,10 +168,10 @@ export function initBuildingCodesAfterResourcesLoaded() {
for (const key in gBuildingVariants) {
const variant = gBuildingVariants[key];
variant.sprite = variant.metaInstance.getSprite(variant.rotationVariant, variant.variant);
variant.blueprintSprite = variant.metaInstance.getBlueprintSprite(
variant.sprite = variant.variant.getSprite(variant.rotationVariant, variant.metaInstance);
variant.blueprintSprite = variant.variant.getBlueprintSprite(
variant.rotationVariant,
variant.variant
variant.metaInstance
);
variant.silhouetteColor = variant.metaInstance.getSilhouetteColor();
}

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

@ -150,14 +150,15 @@ export class BeltSystem extends GameSystemWithFilter {
continue;
}
const defaultVariant = metaBelt.getDefaultVariant(this.root);
const {
rotation,
rotationVariant,
} = metaBelt.computeOptimalDirectionAndRotationVariantAtTile({
} = defaultVariant.computeOptimalDirectionAndRotationVariantAtTile({
root: this.root,
tile: new Vector(x, y),
rotation: targetStaticComp.originalRotation,
variant: defaultBuildingVariant,
layer: targetEntity.layer,
});
@ -170,12 +171,13 @@ export class BeltSystem extends GameSystemWithFilter {
// Change stuff
targetStaticComp.rotation = rotation;
metaBelt.updateVariants(targetEntity, rotationVariant, defaultBuildingVariant);
//metaBelt.updateVariants(targetEntity, rotationVariant, defaultBuildingVariant);
defaultVariant.updateEntityComponents(targetEntity, rotationVariant, this.root);
// Update code as well
targetStaticComp.code = getCodeFromBuildingData(
metaBelt,
defaultBuildingVariant,
defaultVariant,
rotationVariant
);

10
src/js/game/systems/wire.js
View File

@ -738,14 +738,15 @@ export class WireSystem extends GameSystemWithFilter {
continue;
}
const defaultVariant = metaWire.getDefaultVariant(this.root);
const {
rotation,
rotationVariant,
} = metaWire.computeOptimalDirectionAndRotationVariantAtTile({
} = defaultVariant.computeOptimalDirectionAndRotationVariantAtTile({
root: this.root,
tile: new Vector(x, y),
rotation: targetStaticComp.originalRotation,
variant: defaultBuildingVariant,
layer: targetEntity.layer,
});
@ -755,12 +756,13 @@ export class WireSystem extends GameSystemWithFilter {
if (targetStaticComp.rotation !== rotation || newType !== targetWireComp.type) {
// Change stuff
targetStaticComp.rotation = rotation;
metaWire.updateVariants(targetEntity, rotationVariant, defaultBuildingVariant);
//metaWire.updateVariants(targetEntity, rotationVariant, defaultBuildingVariant);
defaultVariant.updateEntityComponents(targetEntity, rotationVariant, this.root);
// Update code as well
targetStaticComp.code = getCodeFromBuildingData(
metaWire,
defaultBuildingVariant,
defaultVariant,
rotationVariant
);