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 support for different building variants

Browse Source
This commit is contained in:
tobspr
2020-05-16 22:45:40 +02:00
parent 436f700606
commit 5e3c28c150
66 changed files with 1196 additions and 466 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
src/js/game/buildings/miner.js
View File

@@ -2,7 +2,11 @@ import { enumDirection, Vector } from "../../core/vector";
import { ItemEjectorComponent } from "../components/item_ejector";
import { MinerComponent } from "../components/miner";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
import { GameRoot } from "../root";
/** @enum {string} */
export const enumMinerVariants = { chainable: "chainable" };
export class MetaMinerBuilding extends MetaBuilding {
constructor() {
@@ -21,16 +25,46 @@ export class MetaMinerBuilding extends MetaBuilding {
return "Place over a shape or color to extract it. Six extractors fill exactly one belt.";
}
getAvailableVariants(root) {
return [defaultBuildingVariant, enumMinerVariants.chainable];
}
/**
* @param {GameRoot} root
* @param {object} param0
* @param {Vector} param0.origin
* @param {number} param0.rotation
* @param {number} param0.rotationVariant
* @param {string} param0.variant
*/
performAdditionalPlacementChecks(root, { origin, rotation, rotationVariant, variant }) {
// Make sure its placed above a resource
const lowerLayer = root.map.getLowerLayerContentXY(origin.x, origin.y);
if (!lowerLayer) {
return false;
}
return true;
}
/**
* Creates the entity at the given location
* @param {Entity} entity
*/
setupEntityComponents(entity) {
entity.addComponent(new MinerComponent());
entity.addComponent(new MinerComponent({}));
entity.addComponent(
new ItemEjectorComponent({
slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }],
})
);
}
/**
*
* @param {Entity} entity
* @param {*} variant
*/
updateVariant(entity, variant) {
entity.components.Miner.chainable = variant === enumMinerVariants.chainable;
}
}

86
src/js/game/buildings/painter.js
View File

@@ -4,17 +4,27 @@ import { enumItemAcceptorItemFilter, ItemAcceptorComponent } from "../components
import { ItemEjectorComponent } from "../components/item_ejector";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
import { enumHubGoalRewards } from "../tutorial_goals";
import { GameRoot } from "../root";
/** @enum {string} */
export const enumPainterVariants = { double: "double" };
export class MetaPainterBuilding extends MetaBuilding {
constructor() {
super("painter");
}
getDimensions() {
return new Vector(2, 1);
getDimensions(variant) {
switch (variant) {
case defaultBuildingVariant:
return new Vector(2, 1);
case enumPainterVariants.double:
return new Vector(2, 2);
default:
assertAlways(false, "Unknown painter variant: " + variant);
}
}
getName() {
@@ -29,6 +39,10 @@ export class MetaPainterBuilding extends MetaBuilding {
return "#cd9b7d";
}
getAvailableVariants(root) {
return [defaultBuildingVariant, enumPainterVariants.double];
}
/**
* @param {GameRoot} root
*/
@@ -41,16 +55,11 @@ export class MetaPainterBuilding extends MetaBuilding {
* @param {Entity} entity
*/
setupEntityComponents(entity) {
entity.addComponent(
new ItemProcessorComponent({
inputsPerCharge: 2,
processorType: enumItemProcessorTypes.painter,
})
);
entity.addComponent(new ItemProcessorComponent({}));
entity.addComponent(
new ItemEjectorComponent({
slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }],
slots: [{ pos: new Vector(1, 0), direction: enumDirection.right }],
})
);
entity.addComponent(
@@ -58,16 +67,69 @@ export class MetaPainterBuilding extends MetaBuilding {
slots: [
{
pos: new Vector(0, 0),
directions: [enumDirection.bottom],
directions: [enumDirection.left],
filter: enumItemAcceptorItemFilter.shape,
},
{
pos: new Vector(1, 0),
directions: [enumDirection.bottom],
directions: [enumDirection.top],
filter: enumItemAcceptorItemFilter.color,
},
],
})
);
}
/**
*
* @param {Entity} entity
* @param {string} variant
*/
updateVariant(entity, variant) {
switch (variant) {
case defaultBuildingVariant: {
entity.components.ItemAcceptor.setSlots([
{
pos: new Vector(0, 0),
directions: [enumDirection.left],
filter: enumItemAcceptorItemFilter.shape,
},
{
pos: new Vector(1, 0),
directions: [enumDirection.top],
filter: enumItemAcceptorItemFilter.color,
},
]);
entity.components.ItemProcessor.type = enumItemProcessorTypes.painter;
entity.components.ItemProcessor.inputsPerCharge = 2;
break;
}
case enumPainterVariants.double: {
entity.components.ItemAcceptor.setSlots([
{
pos: new Vector(0, 0),
directions: [enumDirection.left],
filter: enumItemAcceptorItemFilter.shape,
},
{
pos: new Vector(0, 1),
directions: [enumDirection.left],
filter: enumItemAcceptorItemFilter.shape,
},
{
pos: new Vector(1, 0),
directions: [enumDirection.top],
filter: enumItemAcceptorItemFilter.color,
},
]);
entity.components.ItemProcessor.type = enumItemProcessorTypes.painterDouble;
entity.components.ItemProcessor.inputsPerCharge = 3;
break;
}
default:
assertAlways(false, "Unknown painter variant: " + variant);
}
}
}

83
src/js/game/buildings/splitter.js
View File

@@ -4,17 +4,27 @@ import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
/** @enum {string} */
export const enumSplitterVariants = { compact: "compact" };
export class MetaSplitterBuilding extends MetaBuilding {
constructor() {
super("splitter");
}
getDimensions() {
return new Vector(2, 1);
getDimensions(variant) {
switch (variant) {
case defaultBuildingVariant:
return new Vector(2, 1);
case enumSplitterVariants.compact:
return new Vector(1, 1);
default:
assertAlways(false, "Unknown splitter variant: " + variant);
}
}
getName() {
@@ -29,6 +39,10 @@ export class MetaSplitterBuilding extends MetaBuilding {
return "Multifunctional - Evenly distributes all inputs onto all outputs.";
}
getAvailableVariants(root) {
return [defaultBuildingVariant, enumSplitterVariants.compact];
}
/**
* @param {GameRoot} root
*/
@@ -60,11 +74,6 @@ export class MetaSplitterBuilding extends MetaBuilding {
new ItemProcessorComponent({
inputsPerCharge: 1,
processorType: enumItemProcessorTypes.splitter,
beltUnderlays: [
{ pos: new Vector(0, 0), direction: enumDirection.top },
{ pos: new Vector(1, 0), direction: enumDirection.top },
],
})
);
@@ -77,4 +86,62 @@ export class MetaSplitterBuilding extends MetaBuilding {
})
);
}
/**
*
* @param {Entity} entity
* @param {string} variant
*/
updateVariant(entity, variant) {
switch (variant) {
case defaultBuildingVariant: {
entity.components.ItemAcceptor.setSlots([
{
pos: new Vector(0, 0),
directions: [enumDirection.bottom],
},
{
pos: new Vector(1, 0),
directions: [enumDirection.bottom],
},
]);
entity.components.ItemEjector.setSlots([
{ pos: new Vector(0, 0), direction: enumDirection.top },
{ pos: new Vector(1, 0), direction: enumDirection.top },
]);
entity.components.ItemProcessor.beltUnderlays = [
{ pos: new Vector(0, 0), direction: enumDirection.top },
{ pos: new Vector(1, 0), direction: enumDirection.top },
];
break;
}
case enumSplitterVariants.compact: {
entity.components.ItemAcceptor.setSlots([
{
pos: new Vector(0, 0),
directions: [enumDirection.bottom],
},
{
pos: new Vector(0, 0),
directions: [enumDirection.right],
},
]);
entity.components.ItemEjector.setSlots([
{ pos: new Vector(0, 0), direction: enumDirection.top },
]);
entity.components.ItemProcessor.beltUnderlays = [
{ pos: new Vector(0, 0), direction: enumDirection.top },
];
break;
}
default:
assertAlways(false, "Unknown painter variant: " + variant);
}
}
}