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

Fixed bug with Transistors and Formatted Code

Browse Source
This commit is contained in:
Christopher-Robin 2020-10-18 21:37:53 +11:00
parent c2983a9770
commit fbd8e2e7e7
No known key found for this signature in database
GPG Key ID: 39A83BF9D91CC108
4 changed files with 177 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
src/js/game/buildings/wire_tunnel.js
View File

@ -1,5 +1,11 @@
import { generateMatrixRotations } from "../../core/utils";
import { Vector } from "../../core/vector";
import {
arrayAllDirections,
enumDirection,
enumDirectionToVector,
enumInvertedDirections,
Vector,
} from "../../core/vector";
import { WireTunnelComponent } from "../components/wire_tunnel";
import { Entity } from "../entity";
import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
@ -21,13 +27,20 @@ const wireTunnelsOverlayMatrix = {
};
/**
* @enum {Array<Array<Vector>>}
* Enum of Objects containing the Tunnel Variant Connections
* @enum {Object.<string, Vector>}
*/
export const ConnectionDirections = {
[defaultBuildingVariant]: [[new Vector(0, 1), new Vector(0, 1)], [new Vector(1, 0), new Vector(1, 0)]],
[enumWireTunnelVariants.DoubleElbow]: [[new Vector(0, 1), new Vector(1, 0)], [new Vector(0, -1), new Vector(-1, 0)]],
[enumWireTunnelVariants.Elbow]: [[new Vector(0, 1), new Vector(1, 0)]],
[enumWireTunnelVariants.Straight]: [[new Vector(0, 1), new Vector(0, 1)]],
[defaultBuildingVariant]: BuildConnections([
[new Vector(0, 1), new Vector(0, 1)],
[new Vector(1, 0), new Vector(1, 0)],
]),
[enumWireTunnelVariants.DoubleElbow]: BuildConnections([
[new Vector(0, 1), new Vector(1, 0)],
[new Vector(0, -1), new Vector(-1, 0)],
]),
[enumWireTunnelVariants.Elbow]: BuildConnections([[new Vector(0, 1), new Vector(1, 0)]]),
[enumWireTunnelVariants.Straight]: BuildConnections([[new Vector(0, 1), new Vector(0, 1)]]),
};
export class MetaWireTunnelBuilding extends MetaBuilding {
@ -47,19 +60,18 @@ export class MetaWireTunnelBuilding extends MetaBuilding {
}
/**
*
* @param {GameRoot} root
*/
getAvailableVariants(root) {
return [defaultBuildingVariant, enumWireTunnelVariants.Elbow, enumWireTunnelVariants.Straight, enumWireTunnelVariants.DoubleElbow];
// if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_miner_chainable)) {
// return [enumMinerVariants.chainable];
// }
// return super.getAvailableVariants(root);
return [
defaultBuildingVariant,
enumWireTunnelVariants.Elbow,
enumWireTunnelVariants.Straight,
enumWireTunnelVariants.DoubleElbow,
];
}
/**
*
* @param {number} rotation
* @param {number} rotationVariant
* @param {string} variant
@ -91,7 +103,11 @@ export class MetaWireTunnelBuilding extends MetaBuilding {
* @param {Entity} entity
*/
setupEntityComponents(entity) {
entity.addComponent(new WireTunnelComponent({Variant: defaultBuildingVariant, Connections: ConnectionDirections[defaultBuildingVariant]}));
entity.addComponent(
new WireTunnelComponent({
Connections: ConnectionDirections[defaultBuildingVariant],
})
);
}
/**
@ -102,8 +118,35 @@ export class MetaWireTunnelBuilding extends MetaBuilding {
*/
updateVariants(entity, rotationVariant, variant) {
if (entity.components.WireTunnel) {
//a.rotateInplaceFastMultipleOf90(rotationVariant);
entity.components.WireTunnel.UpdateConnections(variant, ConnectionDirections[variant])
entity.components.WireTunnel.UpdateConnections(ConnectionDirections[variant]);
}
}
}
/**
* Builds the Connection Graph object from the input Array
* @param {Array<Array<Vector>>} Connections
* @returns {Object.<string, Vector>}
*/
function BuildConnections(Connections) {
/**
* @type {Object.<string, Vector>}
*/
let res = {};
for (let i = 0; i < Connections.length; ++i) {
assert(Connections[i].length == 2, "Connection Wasn't Continuos");
let [a, b] = Connections[i];
const ahash = a.toString();
if (!res[ahash]) {
res[ahash] = b;
}
let alta = a.rotateFastMultipleOf90(180);
let altb = b.rotateFastMultipleOf90(180);
const bhash = altb.toString();
if (!res[bhash]) {
res[bhash] = alta;
}
}
return res;
}

82
src/js/game/components/wire_tunnel.js
View File

@ -1,27 +1,28 @@
import { Vector } from "../../core/vector";
import {
arrayAllDirections,
enumDirection,
enumDirectionToVector,
enumInvertedDirections,
Vector,
} from "../../core/vector";
import { Component } from "../component";
import { defaultBuildingVariant } from "../meta_building";
export class WireTunnelComponent extends Component {
static getId() {
return "WireTunnel";
}
constructor({ Variant, Connections = [] }) {
/**
*
* @param {{Connections: Object.<string, Vector>}} Elements
*/
constructor({ Connections = {} }) {
super();
this.Variant = Variant;
// /**
// * All Connection Directions
// * @type {Object.<string, Array<Vector>>} Possibility for a T piece. Should be Irrelevant
// */
/**
* @type {Object.<string, Vector>}
*/
this.Connections = {};
this.RebuildConnections(Connections);
this.Connections = Connections;
/**
* Linked network, only if its not multiple directions
@ -31,55 +32,42 @@ export class WireTunnelComponent extends Component {
}
/**
* @param {import("../buildings/wire_tunnel").ConnectionDirections} Connections
* @param {Object.<string, Vector>} Connections
*/
RebuildConnections(Connections) {
this.Connections = {};
for(let i = 0; i < Connections.length; ++i) {
assert(Connections[i].length == 2, "Connection Wasn't Continuos");
let [a, b] = Connections[i];
const ahash = a.toString();
if(!this.Connections[ahash]) {
this.Connections[ahash] = b;
}
let alta = a.rotateFastMultipleOf90(180);
let altb = b.rotateFastMultipleOf90(180);
const bhash = altb.toString();
if(!this.Connections[bhash]) {
this.Connections[bhash] = alta;
}
}
console.log(this.Connections);
UpdateConnections(Connections) {
this.Connections = Connections;
}
/**
* @param {string} Variant
* @param {import("../buildings/wire_tunnel").ConnectionDirections} Connections
*/
UpdateConnections(Variant, Connections) {
if(this.Variant !== Variant){
this.Variant = Variant;
this.RebuildConnections(Connections)
}
}
/**
* Local Space Direction the connection is coming from
* Returns if the Tunnel accepts inputs from the given direction
* @param {Vector} dir
* Local Space Vector into the Tunnel
*/
CanConnect(dir) {
return !!this.Connections[dir.toString()];
}
/**
* Returns if the Tunnel accepts inputs from the given direction
* @param {import("./static_map_entity").StaticMapEntityComponent} staticComp
* @param {Vector} input
* LocalSpace Direction into the Tunnel
* Static Map Entity Component
* @param {Vector} dir
* World space Vector into the Tunnel
*/
CanConnectWorld(staticComp, dir) {
const inputDir = staticComp.unapplyRotationToVector(dir);
return !!this.Connections[inputDir.toString()];
}
/**
* Returns the Worldspace Vector out from the Tunnel or Null
* @param {import("./static_map_entity").StaticMapEntityComponent} staticComp
* Static Map Entity Component
* @param {Vector|null} input
* Worldspace Direction into the Tunnel
*/
GetOutputDirection(staticComp, input) {
const inputDir = staticComp.unapplyRotationToVector(input); //TODO: Fix the Wierd Shit
const inputDir = staticComp.unapplyRotationToVector(input);
if (this.CanConnect(inputDir)) {
let out = this.Connections[inputDir.toString()];
return staticComp.applyRotationToVector(out);

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

@ -246,8 +246,7 @@ export class GameLogic {
// Check if its a tunnel
const wireTunnelComp = targetEntity.components.WireTunnel;
if (wireTunnelComp) {
const inputDir = targetStaticComp.unapplyRotationToVector(offset);
return wireTunnelComp.CanConnect(inputDir);
return wireTunnelComp.CanConnectWorld(targetStaticComp, offset);
}
// Check if its a wire

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

@ -369,7 +369,7 @@ export class WireSystem extends GameSystemWithFilter {
* @param {Vector} initialTile
* @param {Array<enumDirection>} directions
* @param {WireNetwork} network
* @param {enumWireVariant=} variantMask Only accept connections to this mask
* @param {enumWireVariant} variantMask Only accept connections to this mask
* @returns {Array<any>}
*/
findSurroundingWireTargets(initialTile, directions, network, variantMask = null) {
@ -407,7 +407,7 @@ export class WireSystem extends GameSystemWithFilter {
contents.push({
entity: initialContents[j],
tile: initialSearchTile,
dir: offset
dir: offset,
});
}
@ -444,8 +444,17 @@ export class WireSystem extends GameSystemWithFilter {
}
// Check if the direction (inverted) matches
const pinDirection = staticComp.localDirectionToWorld(slot.direction);
if (pinDirection !== enumInvertedDirections[direction]) {
// const pinDirection = staticComp.localDirectionToWorld(slot.direction);
// if (pinDirection !== enumInvertedDirections[direction]) {
// continue;
// }
// /**
// * @type {Vector}
// */
const worldDir = staticComp.localDirectionToWorld(slot.direction);
const invDir = enumInvertedDirections[worldDir];
const pinDirection = enumDirectionToVector[invDir];
if (!pinDirection.equals(dir)) {
continue;
}
@ -503,7 +512,7 @@ export class WireSystem extends GameSystemWithFilter {
contents.push({
entity: connectedContents[h],
tile: forwardedTile,
dir: outputDir
dir: outputDir,
});
}