diff --git a/BP/blueprint.ts b/BP/blueprint.ts index c2c518e..e4f0117 100644 --- a/BP/blueprint.ts +++ b/BP/blueprint.ts @@ -1,7 +1,5 @@ -import { time } from "console" -import { fstat } from "fs" import { Area } from "./area" -import { Building, BuildingList } from "./builiding/builiding" +import { Building } from "./building/building" const game_version = '0.9.24.11286' @@ -106,12 +104,8 @@ export class BluePrint { return building } - addBuildings(buildings:BuildingList):BuildingList { - buildings.forEach((building, index, buildings) => { - building.setIndex(this.data.building_count) - this.data.buildings.push(building) - this.data.building_count++ - }); + addBuildings(buildings:Array):Array { + buildings.forEach(building => this.addBuilding(building)) return buildings } } \ No newline at end of file diff --git a/BP/building/assembler.ts b/BP/building/assembler.ts new file mode 100644 index 0000000..525bd2c --- /dev/null +++ b/BP/building/assembler.ts @@ -0,0 +1,73 @@ +import { local_diff } from "../../util"; +import { Building } from "./building"; +import { InserterLocalParam } from "./inserter"; + +export class Assembler extends Building { + constructor( + area_index:number, + local:[number, number, number] | null, + level = 3) + { + let item_id: number, model_index: number + if (level == 1) { + item_id = 2303 + model_index = 65 + } + else if (level == 2) { + item_id = 2304 + model_index = 66 + } + else if (level == 3) { + item_id = 2305 + model_index = 67 + } + + super(area_index, local,local, item_id, model_index) + } + + getInserterLocal(slot: number, is_ingress: boolean): InserterLocalParam { + let param = new InserterLocalParam() + let local: [number, number, number][] + let local_base = this.getLocal() + + switch (slot) { + case 0: + case 1: + case 2: + local = [local_diff(local_base, [(1 - slot)*0.8, -0.8, 0]), local_diff(local_base, [(1 -slot)*0.8, -2, 0])] + break; + + case 3: + case 4: + case 5: + local = [local_diff(local_base, [-0.8, (slot - 5)*0.8, 0]), local_diff(local_base, [-2, (slot - 5)*0.8, 0])] + break; + + case 6: + case 7: + case 8: + local = [local_diff(local_base, [(slot - 7)*0.8, 0.8, 0]), local_diff(local_base, [(slot - 7)*0.8, 2, 0])] + break; + + case 9: + case 10: + case 11: + local = [local_diff(local_base, [0.8, (10 - slot)*0.8, 0]), local_diff(local_base, [2, (10 -slot)*0.8, 0])] + break; + } + + if (is_ingress) { + param.output_to_slot = slot + param.setOutputObject(this) + param.local2 = local[0] + param.local = local[1] + } + else { + param.input_from_slot = slot + param.setInputObject(this) + param.local2 = local[1] + param.local = local[0] + } + return param + } +} diff --git a/BP/builiding/belt.ts b/BP/building/belt.ts similarity index 54% rename from BP/builiding/belt.ts rename to BP/building/belt.ts index d9af32d..7de6f95 100644 --- a/BP/builiding/belt.ts +++ b/BP/building/belt.ts @@ -1,5 +1,5 @@ import { BluePrint } from "../blueprint"; -import { Building, BuildingList, BuilidingParam } from "./builiding"; +import { Building, BuilidingParam } from "./building"; class BeltParamLabel { label: number @@ -42,9 +42,7 @@ export class BeltBlueprintParam extends BuilidingParam { export class Belt extends Building { constructor( area_index:number, - local_offset_x:number, - local_offset_y:number, - local_offset_z:number, + local:[number, number, number] | null, level=3, ) { let item_id = 2003 @@ -55,25 +53,11 @@ export class Belt extends Building { model_index = 37 } - super(area_index, - local_offset_x, local_offset_y, local_offset_z, - local_offset_x, local_offset_y, local_offset_z, - item_id, model_index, false) + if (local === null) local = [0, 0, 0] + + super(area_index,local, undefined, item_id, model_index, false) this.param = new BeltBlueprintParam() this.header.parameter_count = 0 - } - - setLocal( - local_offset_x:number, - local_offset_y:number, - local_offset_z:number - ) { - this.header.local_offset_x = local_offset_x - this.header.local_offset_x2 = local_offset_x - this.header.local_offset_y = local_offset_y - this.header.local_offset_y2 = local_offset_y - this.header.local_offset_z = local_offset_z - this.header.local_offset_z2 = local_offset_z this.header.output_to_slot = 1 this.header.input_to_slot = 1 } @@ -104,12 +88,24 @@ export class Belt extends Building { } } } + + setLabel(label:number) { + this.header.parameter_count = this.param.setLabel(label) + } } -export function setBeltsLocalAndConnect(belts:Belt[], count: number, startLocal: [number, number, number], diff: [number, number, number]) { +export function connectBelts(belts:Array) { + belts.forEach((belt, index) => { + if (index < belts.length - 1) { + belt.connect(belts[index + 1]) + } + }); +} + +export function setBeltsLocalAndConnect(belts:Array, count: number, startLocal: [number, number, number], diff: [number, number, number]) { for (let index = 0; index < count; index++) { let belt = belts[index]; - belt.setLocal(startLocal[0] + diff[0] * index, startLocal[1] + diff[1] * index, startLocal[2] + diff[2] * index) + belt.setLocal([startLocal[0] + diff[0] * index, startLocal[1] + diff[1] * index, startLocal[2] + diff[2] * index]) if (index < count - 1) { belt.connect(belts[index + 1]) } @@ -123,7 +119,7 @@ export function appendBelts(bp: BluePrint, belts: Array, count: number, di let x = belt.header.local_offset_x, y = belt.header.local_offset_y, z = belt.header.local_offset_z if (diff === undefined) diff = [0, 0, 0] for (let i = 0; i < count; i++) { - let next_belt = new Belt(area_index, x + (i+1)*diff[0], y + (i+1)*diff[1], z + (i+1)*diff[2]) + let next_belt = new Belt(area_index, [x + (i+1)*diff[0], y + (i+1)*diff[1], z + (i+1)*diff[2]]) bp.addBuilding(next_belt) if (diff !== [0, 0, 0]) belt.connect(next_belt) belts.push(next_belt) @@ -135,66 +131,9 @@ export function prependBelts(bp: BluePrint, belts: Array, count: number) { let area_index = belts[0].header.area_index let tmp_belts = new Array() for (let i = 0; i < count; i++) { - let pre_belt = new Belt(area_index, 0, 0, 0) + let pre_belt = new Belt(area_index, [0, 0, 0]) bp.addBuilding(pre_belt) tmp_belts.push(pre_belt) } belts = tmp_belts.concat(belts) } - -export class BeltList extends BuildingList{ - lst:Array - - constructor( - area_index:number, count:number, - local:[number,number,number], - diff = [1, 0, 0], - level = 3 - ) { - super() - this.lst = new Array() - for (let index = 0; index < count; index++) { - this.lst.push(new Belt(area_index, local[0]+diff[0]*index, local[1]+diff[1]*index, local[2]+diff[2]*index, level)) - } - } - - getList() : Array { - return this.lst - } - - add( - area_index:number, - local_offset_x:number, - local_offset_y:number, - local_offset_z:number, - level=3 - ) - { - this.lst.push(new Belt( - area_index, - local_offset_x, local_offset_y, local_offset_z, - level - )) - } - - // Must after set belt index - // connect() { - // this.lst.forEach((belt, index, belt_list)=>{ - // if (index > 0 ) { - // belt.header.input_object_index = belt_list[index - 1].header.index - // } - // if (index + 1 < belt_list.length) { - // belt.header.output_object_index = belt_list[index + 1].header.index - // } - - // // Todo: how to set the input/output from/to slot? - // belt.header.output_to_slot = 1 - // belt.header.input_to_slot = 1 - // }) - // return this - // } - - // reverse() { - // // Todo - // } -} diff --git a/BP/building/building.ts b/BP/building/building.ts new file mode 100644 index 0000000..40a1db9 --- /dev/null +++ b/BP/building/building.ts @@ -0,0 +1,155 @@ +import { local_diff } from "../../util" +import { InserterLocalParam } from "./inserter" + +export class BuildingHeader { + index: number + area_index:number + local_offset_x:number + local_offset_y:number + local_offset_z:number + local_offset_x2:number + local_offset_y2:number + local_offset_z2:number + yaw:number + yaw2:number + item_id:number + model_index:number + output_object_index:number + input_object_index:number + output_to_slot:number + input_from_slot:number + output_from_slot:number + input_to_slot:number + output_offset:number + input_offset:number + recipe_id:number + filter_id:number + parameter_count:number +} + +export class BuilidingParam { + getCount(){} +} + +class BuilidingParamUnknown extends BuilidingParam { + Unknown:[number] + constructor() { + super() + this.Unknown = [0] + } + + getCount(): number { + return this.Unknown.length + } +} + +export class Building { + header: BuildingHeader + param: any + + constructor( + area_index:number, + local:[number, number, number] = null, + local2:[number, number, number] = null, + item_id:number, + model_index:number, + isDefault = true + ) { + this.header = new BuildingHeader() + let header = this.header + header.area_index = area_index + + if (local === null) { + local = [0, 0, 0] + } + if (local2 === null) { + local2 = local + } + + header.local_offset_x = local[0] + header.local_offset_y = local[1] + header.local_offset_z = local[2] + header.local_offset_x2 = local2[0] + header.local_offset_y2 = local2[1] + header.local_offset_z2 = local2[2] + + // how to calculate yaw? + header.yaw = 0 + header.yaw2 = 0 + + header.item_id = item_id + header.model_index = model_index + header.output_object_index = 4294967295 + header.input_object_index = 4294967295 + + header.output_to_slot = 0 + header.input_from_slot = 0 + header.output_from_slot = 0 + header.input_to_slot = 0 + + header.output_offset = 0 + header.input_offset = 0 + + header.recipe_id = 0 + header.filter_id = 0 + header.parameter_count = 0 + + if (isDefault) { + this.param = new BuilidingParamUnknown() + this.header.parameter_count = this.param.getCount() + } + } + + setIndex(index:number) {this.header.index = index} + + setLocal(local:[number, number, number], local2:[number,number,number] = null) { + if (local2 === null) { + local2 = local + } + + this.header.local_offset_x = local[0] + this.header.local_offset_y = local[1] + this.header.local_offset_z = local[2] + + this.header.local_offset_x2 = local2[0] + this.header.local_offset_y2 = local2[1] + this.header.local_offset_z2 = local2[2] + + this.autoSetYaw(local, local2) + } + + getLocal():[number, number, number] {return [this.header.local_offset_x, this.header.local_offset_y, this.header.local_offset_z]} + + setYaw(yaw:number, yaw2?:number) { + if (yaw2 === undefined) yaw2 = yaw + this.header.yaw = yaw + this.header.yaw2 = yaw2 + } + + autoSetYaw(local:[number, number, number], local2:[number, number, number]) { + // Todo: Support yaw calculate in next version + if (local[0] == local2[0]) { + if (local[1] < local2[1]){ + this.setYaw(0) + } + else { + this.setYaw(180) + } + } + else if (local[1] == local2[1]) { + // Todo: Confirm it + if (local[0] < local2[0]){ + this.setYaw(90) + } + else { + this.setYaw(270) + } + } + } + + setRecipe(recipe_id:number) { + this.header.recipe_id = recipe_id + } + + getInserterLocal(slot: number, is_ingress: boolean): InserterLocalParam {return null} +} diff --git a/BP/building/inserter.ts b/BP/building/inserter.ts new file mode 100644 index 0000000..e7b8d5b --- /dev/null +++ b/BP/building/inserter.ts @@ -0,0 +1,78 @@ +import { Building } from "./building"; + +export class InserterLocalParam { + local:[number, number, number] + local2:[number, number, number] + output_object_index: number + input_object_index: number + output_to_slot: number + input_from_slot: number + output_from_slot: number + input_to_slot: number + + constructor( + local:[number, number, number] = null, + local2:[number, number, number] = null, + output_object_index = 4294967295, + input_object_index = 4294967295, + output_to_slot = -1, + input_from_slot = -1, + output_from_slot = -1, + input_to_slot = -1, + ) { + this.local = local + this.local2 = local2 + this.output_object_index = output_object_index + this.input_object_index = input_object_index + this.output_to_slot = output_to_slot + this.input_from_slot = input_from_slot + this.output_from_slot = output_from_slot + this.input_to_slot = input_to_slot + } + + setInputObject(building:Building) { this.input_object_index = building.header.index } + setOutputObject(building:Building) { this.output_object_index = building.header.index } + setOutputToSlot(slot: number) {this.output_to_slot = slot} + setOutputFromSlot(slot: number) {this.output_from_slot = slot} + setInputToSlot(slot: number) {this.input_to_slot = slot} + setInputFromSlot(slot: number) {this.input_from_slot = slot} +} + +export class Inserter extends Building { + constructor( + area_index:number, + local_param:InserterLocalParam = new InserterLocalParam(), + level = 3 + ) { + let item_id: number, model_index: number + + if (level == 1 ) { + item_id = 2011 + model_index = 41 + } + else if (level == 2 ) { + item_id = 2012 + model_index = 42 + } + else { + item_id = 2013 + model_index = 43 + } + + super(area_index, local_param.local, local_param.local2, item_id, model_index) + this.setLocalParam(local_param) + } + + setLocalParam(local_param: InserterLocalParam) { + this.header.output_object_index = local_param.output_object_index + this.header.input_object_index = local_param.input_object_index + this.header.output_to_slot = local_param.output_to_slot + this.header.input_from_slot = local_param.input_from_slot + this.header.output_from_slot = local_param.output_from_slot + this.header.input_to_slot = local_param.input_to_slot + + if (local_param.local !== null && local_param.local2 !== null) { + this.setLocal(local_param.local, local_param.local2) + } + } +} \ No newline at end of file diff --git a/BP/building/lab.ts b/BP/building/lab.ts new file mode 100644 index 0000000..2576ce2 --- /dev/null +++ b/BP/building/lab.ts @@ -0,0 +1,126 @@ +import { local_diff } from "../../util"; +import { Building, BuilidingParam } from "./building"; +import { InserterLocalParam } from "./inserter"; + +class LabParams extends BuilidingParam { + Unknown:[number, number] + constructor(isResearch:boolean) { + super() + if (isResearch) { + this.Unknown = [2, 0] + } + else { + this.Unknown = [1, 0] + } + } + + getCount(): number { + return this.Unknown.length + } +} + +export class Lab extends Building { + constructor( + area_index:number, + local:[number, number, number] = null, + isResearch: boolean, + recipe_id?: number, + ) { + super(area_index, local, local, 2901, 70, false) + this.header.output_to_slot = 14 + this.header.input_from_slot = 15 + this.header.output_from_slot = 15 + this.header.input_to_slot = 14 + this.param = new LabParams(isResearch) + this.header.parameter_count = this.param.getCount() + if (!isResearch) { + this.header.recipe_id = recipe_id + } + } + + getInserterLocal(slot: number, is_ingress: boolean): InserterLocalParam { + let param = new InserterLocalParam() + let local: [number, number, number][] + let local_base = this.getLocal() + + switch (slot) { + case 0: + case 1: + case 2: + local = [local_diff(local_base, [(slot - 1)*0.8, -1.8, 0]), local_diff(local_base, [(slot - 1)*0.8, -3, 0])] + break; + + case 3: + case 4: + case 5: + local = [local_diff(local_base, [1.8, (slot - 4), 0]), local_diff(local_base, [2.8, (slot - 4), 0])] + break; + + case 6: + case 7: + case 8: + local = [local_diff(local_base, [(7 - slot)*0.8, 1.8, 0]), local_diff(local_base, [(7 - slot)*0.8, 2, 0])] + break; + + case 9: + case 10: + case 11: + local = [local_diff(local_base, [-1.8, (10 -slot), 0]), local_diff(local_base, [-2.8, (10 - slot), 0])] + break; + } + + if (is_ingress) { + param.output_to_slot = slot + param.setOutputObject(this) + param.local2 = local[0] + param.local = local[1] + } + else { + param.input_from_slot = slot + param.setInputObject(this) + param.local2 = local[1] + param.local = local[0] + } + return param + } +} + +export class LabStack { + labs: Array + + constructor( + area_index:number, + local:[number, number] = null, + isResearch: boolean, + stack = 15, + recipe_id?: number, + ) + { + if (local === null) local = [0, 0] + this.labs = new Array() + for (let index = 0; index < stack; index++) { + let lab = new Lab(area_index, [local[0], local[1], index*3], isResearch, recipe_id) + this.labs.push(lab) + } + } + + initLabStacks() { + this.labs.forEach((lab, index, labs)=> { + if(index > 0) { + lab.header.input_object_index = labs[index - 1].header.index + } + }) + } + + setLocal(local:[number, number] | Array) { + this.labs.forEach((lab, index) => lab.setLocal([local[0], local[1], index * 3])) + } + + getLabs() {return this.labs} + + getLocal() {return this.labs[0].getLocal()} + + getInserterLocal(slot: number, is_ingress: boolean): InserterLocalParam { + return this.labs[0].getInserterLocal(slot, is_ingress) + } +} diff --git a/BP/building/smelter.ts b/BP/building/smelter.ts new file mode 100644 index 0000000..4963b1a --- /dev/null +++ b/BP/building/smelter.ts @@ -0,0 +1,70 @@ +import { local_diff } from "../../util" +import { Building } from "./building" +import { InserterLocalParam } from "./inserter" + +export class Smelter extends Building{ + constructor( + area_index:number, + local:[number, number, number] | null, + level = 2) + { + let item_id = 2302 + let model_index = 62 + if (level == 2) { + item_id = 2315 + model_index = 194 + } + + if (local === null) { + local = [0, 0, 0] + } + + super(area_index, local, undefined, item_id, model_index) + } + + getInserterLocal(slot: number, is_ingress: boolean): InserterLocalParam { + let param = new InserterLocalParam() + let local: [number, number, number][] + let local_base = this.getLocal() + + switch (slot) { + case 0: + case 1: + case 2: + local = [local_diff(local_base, [(1 - slot)*0.8, -0.8, 0]), local_diff(local_base, [(1 -slot)*0.8, -2, 0])] + break; + + case 3: + case 4: + case 5: + local = [local_diff(local_base, [-0.8, (slot - 5)*0.8, 0]), local_diff(local_base, [-2, (slot - 5)*0.8, 0])] + break; + + case 6: + case 7: + case 8: + local = [local_diff(local_base, [(slot - 7)*0.8, 0.8, 0]), local_diff(local_base, [(slot - 7)*0.8, 2, 0])] + break; + + case 9: + case 10: + case 11: + local = [local_diff(local_base, [0.8, (10 - slot)*0.8, 0]), local_diff(local_base, [2, (10 -slot)*0.8, 0])] + break; + } + + if (is_ingress) { + param.output_to_slot = slot + param.setOutputObject(this) + param.local2 = local[0] + param.local = local[1] + } + else { + param.input_from_slot = slot + param.setInputObject(this) + param.local2 = local[1] + param.local = local[0] + } + return param + } +} diff --git a/BP/builiding/spray_coater.ts b/BP/building/spray_coater.ts similarity index 50% rename from BP/builiding/spray_coater.ts rename to BP/building/spray_coater.ts index 6bbfbc9..7320500 100644 --- a/BP/builiding/spray_coater.ts +++ b/BP/building/spray_coater.ts @@ -1,14 +1,13 @@ -import { Building } from "./builiding"; +import { Belt } from "./belt"; +import { Building } from "./building"; export class SprayCoater extends Building { constructor( area_index:number, - local_offset_x:number, - local_offset_y:number, - local_offset_z:number, - yaw: number + local:[number, number, number] = null, + yaw: number = 0 ) { - super(area_index, local_offset_x, local_offset_y, local_offset_z, local_offset_x, local_offset_y, local_offset_z, 2313, 120, true) + super(area_index, local, undefined, 2313, 120, true) this.header.output_to_slot = 14 this.header.input_from_slot = 15 this.header.output_from_slot = 15 @@ -16,4 +15,9 @@ export class SprayCoater extends Building { this.header.yaw = yaw this.header.yaw2 = yaw } + + setLocalByBelt(belt:Belt, yaw:number): void { + this.setLocal(belt.getLocal()) + this.setYaw(yaw) + } } \ No newline at end of file diff --git a/BP/building/tesla_coil.ts b/BP/building/tesla_coil.ts new file mode 100644 index 0000000..80d6184 --- /dev/null +++ b/BP/building/tesla_coil.ts @@ -0,0 +1,11 @@ +import { Building } from "./building" + +// 电力感觉塔 +export class TeslaCoil extends Building { + constructor( + area_index:number, + local:[number, number] = null + ) { + super(area_index, [local[0], local[1], 0], undefined, 2201, 44) + } +} \ No newline at end of file diff --git a/BP/builiding/assembler.ts b/BP/builiding/assembler.ts deleted file mode 100644 index 7a9c27b..0000000 --- a/BP/builiding/assembler.ts +++ /dev/null @@ -1,60 +0,0 @@ -import { Building, FactoryList } from "./builiding"; - -export class Assembler extends Building { - constructor( - area_index:number, - local_offset_x:number, - local_offset_y:number, - local_offset_z:number, - level = 3) - { - let item_id: number, model_index: number - if (level == 1) { - item_id = 2303 - model_index = 65 - } - else if (level == 2) { - item_id = 2304 - model_index = 66 - } - else if (level == 3) { - item_id = 2305 - model_index = 67 - } - - super(area_index, - local_offset_x, local_offset_y, local_offset_z, - local_offset_x, local_offset_y, local_offset_z, - item_id, model_index) - } -} - - -export class AssemblerList extends FactoryList { - lst: Assembler[] - constructor( - area_index:number, - local:[number, number, number], - recipe_id:number, - count=[1,1], - diff=[3.75,3.75], - level = 2 - ) { - let item_id: number, model_index: number - if (level == 1) { - item_id = 2303 - model_index = 65 - } - else if (level == 2) { - item_id = 2304 - model_index = 66 - } - else if (level == 3) { - item_id = 2305 - model_index = 67 - } - - super(area_index, item_id, model_index, [1.75, 1.75], count, local[0], local[1], local[2], recipe_id, diff) - } - -} \ No newline at end of file diff --git a/BP/builiding/builiding.ts b/BP/builiding/builiding.ts deleted file mode 100644 index a197a6a..0000000 --- a/BP/builiding/builiding.ts +++ /dev/null @@ -1,173 +0,0 @@ -export class BuildingHeader { - index: number - area_index:number - local_offset_x:number - local_offset_y:number - local_offset_z:number - local_offset_x2:number - local_offset_y2:number - local_offset_z2:number - yaw:number - yaw2:number - item_id:number - model_index:number - output_object_index:number - input_object_index:number - output_to_slot:number - input_from_slot:number - output_from_slot:number - input_to_slot:number - output_offset:number - input_offset:number - recipe_id:number - filter_id:number - parameter_count:number -} - -export class BuilidingParam { - getCount(){} -} - -class BuilidingParamUnknown extends BuilidingParam { - Unknown:[number] - constructor() { - super() - this.Unknown = [0] - } - - getCount(): number { - return this.Unknown.length - } -} - -export class Building { - header: BuildingHeader - param: any - - constructor( - area_index:number, - local_offset_x:number, - local_offset_y:number, - local_offset_z:number, - local_offset_x2:number, - local_offset_y2:number, - local_offset_z2:number, - item_id:number, - model_index:number, - isDefault = true - ) { - this.header = new BuildingHeader() - let header = this.header - header.area_index = area_index //current only support area 0? - header.local_offset_x = local_offset_x - header.local_offset_y = local_offset_y - header.local_offset_z = local_offset_z - header.local_offset_x2 = local_offset_x2 - header.local_offset_y2 = local_offset_y2 - header.local_offset_z2 = local_offset_z2 - - // how to calculate yaw? - header.yaw = 0 - header.yaw2 = 0 - - header.item_id = item_id - header.model_index = model_index - header.output_object_index = 4294967295 - header.input_object_index = 4294967295 - - header.output_to_slot = 0 - header.input_from_slot = 0 - header.output_from_slot = 0 - header.input_to_slot = 0 - - header.output_offset = 0 - header.input_offset = 0 - - header.recipe_id = 0 - header.filter_id = 0 - header.parameter_count = 0 - - if (isDefault) { - this.param = new BuilidingParamUnknown() - this.header.parameter_count = this.param.getCount() - } - } - - setIndex(index:number) {this.header.index = index} -} - -export class BuildingList { - lst:Array - - constructor() { - this.lst = new Array() - } - - forEach(cb: (value: Building, index: number, array: Building[]) => void, arg?: any) { - this.lst.forEach(cb, arg) - } - - concat(buildings:BuildingList) { - this.lst = this.lst.concat(buildings.lst) - } - - push(building:Building) { - this.lst.push(building) - } -} - -export class FactoryList extends BuildingList { - anti_collision:[number, number] - direct_positive:[boolean, boolean] - constructor( - area_index:number, item_id:number, model_index:number, anti_collision:[number, number], - count=[1,1], - x:number, y:number,z:number, - recipe_id:number, - diff=[0,0], - isDefault = true - ) { - super() - this.anti_collision = anti_collision - this.direct_positive = [diff[0]>0?true:false, diff[1]>0?true:false] - - for (let row = 0; row < count[0]; row++) { - for (let column = 0; column < count[1]; column++) { - this.lst.push( - new Building(area_index, - x+row*diff[0], y+column*diff[1],z, - x+row*diff[0], y+column*diff[1],z, - item_id, model_index, isDefault)) - } - } - this.setRecipe(recipe_id) - } - - setRecipe(recipe_id:number) { - this.forEach((building, index, buildings) => { - building.header.recipe_id = recipe_id - }) - } - - getFactoryArea() { - let x: number, y: number, x2: number, y2: number - if (this.direct_positive[0] == true) { - x = this.lst[0].header.local_offset_x - this.anti_collision[0] - x2 = this.lst[this.lst.length-1].header.local_offset_x - this.anti_collision[0] - } - else { - x = this.lst[this.lst.length-1].header.local_offset_x - this.anti_collision[0], - x2 = this.lst[0].header.local_offset_x - this.anti_collision[0] - } - - if (this.direct_positive[1] == true) { - y = this.lst[0].header.local_offset_y - this.anti_collision[1] - y2 = this.lst[this.lst.length-1].header.local_offset_y - this.anti_collision[1] - } - else { - y = this.lst[this.lst.length-1].header.local_offset_y - this.anti_collision[1], - y2 = this.lst[0].header.local_offset_y - this.anti_collision[1] - } - return [x, y, x2, y2] - } -} \ No newline at end of file diff --git a/BP/builiding/inserter.ts b/BP/builiding/inserter.ts deleted file mode 100644 index 457781b..0000000 --- a/BP/builiding/inserter.ts +++ /dev/null @@ -1,62 +0,0 @@ -import { Building } from "./builiding"; - -export class Inserter extends Building { - constructor( - area_index:number, - local:[number,number,number], - local2:[number,number,number], - output_object_index:number, - input_object_index:number, - output_to_slot:number, - input_from_slot:number, - output_from_slot:number, - input_to_slot:number, - level = 3 - ) { - let item_id: number, model_index: number - - if (level == 1 ) { - item_id = 2011 - model_index = 41 - } - else if (level == 2 ) { - item_id = 2012 - model_index = 42 - } - else { - item_id = 2013 - model_index = 43 - } - - super(area_index, local[0], local[1], local[2], local2[0], local2[1], local2[2], item_id, model_index) - this.header.output_object_index = output_object_index - this.header.input_object_index = input_object_index - this.header.output_to_slot = output_to_slot - this.header.input_from_slot = input_from_slot - this.header.output_from_slot = output_from_slot - this.header.input_to_slot = input_to_slot - - // Todo: Support yaw calculate in next version - if (local[0] == local2[0]) { - if (local[1] < local2[1]){ - this.header.yaw = 0 - this.header.yaw2 = 0 - } - else { - this.header.yaw = 180 - this.header.yaw2 = 180 - } - } - else if (local[1] == local2[1]) { - // Todo: Confirm it - if (local[0] < local2[0]){ - this.header.yaw = 90 - this.header.yaw2 = 90 - } - else { - this.header.yaw = 270 - this.header.yaw2 = 270 - } - } - } -} \ No newline at end of file diff --git a/BP/builiding/lab.ts b/BP/builiding/lab.ts deleted file mode 100644 index 1fc4540..0000000 --- a/BP/builiding/lab.ts +++ /dev/null @@ -1,66 +0,0 @@ -import { Building, BuildingList, BuilidingParam } from "./builiding"; - -class LabParams extends BuilidingParam { - Unknown:[number, number] - constructor(isResearch:boolean) { - super() - if (isResearch) { - this.Unknown = [2, 0] - } - else { - this.Unknown = [1, 0] - } - } - - getCount(): number { - return this.Unknown.length - } -} - -export class Lab extends Building { - constructor( - area_index:number, - local_offset_x:number, - local_offset_y:number, - local_offset_z:number, - isResearch: boolean, - recipe_id?: number, - ) { - super(area_index, local_offset_x, local_offset_y, local_offset_z, local_offset_x, local_offset_y, local_offset_z, 2901, 70, false) - this.header.output_to_slot = 14 - this.header.input_from_slot = 15 - this.header.output_from_slot = 15 - this.header.input_to_slot = 14 - this.param = new LabParams(isResearch) - this.header.parameter_count = this.param.getCount() - if (!isResearch) { - this.header.recipe_id = recipe_id - } - } -} - -export class LabStack extends BuildingList { - constructor( - area_index:number, - local_offset_x:number, - local_offset_y:number, - isResearch: boolean, - stack = 15, - recipe_id?: number, - ) - { - super() - for (let index = 0; index < stack; index++) { - let lab = new Lab(area_index, local_offset_x, local_offset_y, index*3, isResearch, recipe_id) - this.push(lab) - } - } - - initLabStacks() { - this.forEach((lab, index, labs)=> { - if(index > 0) { - lab.header.input_object_index = labs[index - 1].header.index - } - }) - } -} diff --git a/BP/builiding/smelter.ts b/BP/builiding/smelter.ts deleted file mode 100644 index 0140258..0000000 --- a/BP/builiding/smelter.ts +++ /dev/null @@ -1,45 +0,0 @@ -import { Building, BuildingList, FactoryList } from "./builiding" - -export class Smelter extends Building{ - constructor( - area_index:number, - local_offset_x:number, - local_offset_y:number, - local_offset_z:number, - level = 2) - { - let item_id = 2302 - let model_index = 62 - if (level == 2) { - item_id = 2303 - model_index = 194 - } - - super(area_index, - local_offset_x, local_offset_y, local_offset_z, - local_offset_x, local_offset_y, local_offset_z, - item_id, model_index) - } -} - -export class SmelterList extends FactoryList { - lst: Smelter[] - constructor( - area_index:number, - local:[number, number, number], - recipe_id:number, - count=[1,1], - diff=[3,3], - level = 2 - ) { - let item_id = 2302 - let model_index = 62 - if (level == 2) { - item_id = 2315 - model_index = 194 - } - - super(area_index, item_id, model_index, [1.25, 1.25], count, local[0], local[1], local[2], recipe_id, diff) - } - -} \ No newline at end of file diff --git a/BP/builiding/tesla_coil.ts b/BP/builiding/tesla_coil.ts deleted file mode 100644 index 639c82a..0000000 --- a/BP/builiding/tesla_coil.ts +++ /dev/null @@ -1,12 +0,0 @@ -import { Building } from "./builiding" - -// 电力感觉塔 -export class TeslaCoil extends Building { - constructor( - area_index:number, - local_offset_x:number, - local_offset_y:number, - ) { - super(area_index, local_offset_x, local_offset_y, 0, 0, 0, 0, 2201, 44) - } -} \ No newline at end of file diff --git a/building_group/7200_blue_array.ts b/building_group/7200_blue_array.ts index cdb214c..9c2a72e 100644 --- a/building_group/7200_blue_array.ts +++ b/building_group/7200_blue_array.ts @@ -1,237 +1,543 @@ import { BluePrint } from "../BP/blueprint"; -import { Belt, BeltList, BeltBlueprintParam, setBeltsLocalAndConnect, appendBelts } from "../BP/builiding/belt"; -import { BuildingList } from "../BP/builiding/builiding"; -import { LabStack } from "../BP/builiding/lab"; -import { SprayCoater } from "../BP/builiding/spray_coater"; -import { NearlyAssembler2In1Group } from "./assembler_group"; -import { NearlySmelterGroup } from "./smelter_groups"; +import { Assembler } from "../BP/building/assembler"; +import { Belt, connectBelts } from "../BP/building/belt"; +import { Inserter } from "../BP/building/inserter"; +import { LabStack } from "../BP/building/lab"; +import { Smelter } from "../BP/building/smelter"; +import { SprayCoater } from "../BP/building/spray_coater"; +import { TeslaCoil } from "../BP/building/tesla_coil"; +import { local_diff, local_diff_2 } from "../util"; +import { smelter_index, assembler_index, belt_index, ingress_inserter_index, building_num, belt_num, egress_inserter_index } from "./7200_blue_array_params"; +// import { NearlyAssembler2In1Group } from "./assembler_group"; /** - * 蓝糖： 288/增产 + * 蓝糖： 288/增产 (20 * 15) * 磁线圈：16/加速 * 磁铁：36/加速 * 铜块：24/加速 * 电路板：16/加速 * 铁块：24/加速 */ -export class BlueArray7200 extends BuildingList { - labs:BuildingList - - building_group_iron_plate_0:NearlySmelterGroup - building_group_iron_plate_1:NearlySmelterGroup - belt_iron_plate_ingress: Array - belt_iron_plate_ingress_z = 8 - belt_iron_plate_egress_z = 6 - belt_iron_plate_egress: Array - belts_iron_plate: Array> - iron_plate_local:[number, number] - belt_iron_plate_ingress_local: [number, number, number] - spray_coater_iron_ore_0:SprayCoater - spray_coater_iron_plate:Array - - building_group_magnet_plate_0:NearlySmelterGroup - building_group_magnet_plate_1:NearlySmelterGroup - building_group_magnet_plate_2:NearlySmelterGroup - belt_magnet_plate_ingress: Array - belt_magnet_plate_ingress_z = 5 - belt_magnet_plate_egress_z = 6 - belt_magnet_plate_egress: Array - belts_magnet_plate: Array> - magnet_plate_local:[number, number] - belt_magnet_plate_ingress_local:[number, number, number] - spray_coater_iron_ore_1:SprayCoater - spray_coater_magnet_plate:Array - - building_group_copper_0:NearlySmelterGroup - building_group_copper_1:NearlySmelterGroup - building_group_copper_2:NearlySmelterGroup - belt_copper_plate_ingress: Array - belt_copper_plate_ingress_z = 5 - belt_copper_plate_egress_z = 6 - belt_copper_plate_egress: Array - belts_copper_plate: Array> - copper_plate_local:[number, number] - belt_copper_plate_ingress_local:[number, number, number] - spray_coater_copper_ore:SprayCoater - spray_coater_copper_plate:Array +export class BlueArray7200 { + + bp: BluePrint + area_index: number + + labs: Array + smelters: Array> + assemblers: Array> + belts: Array> + spray_coaters: Array + inserters_ingress: Array> + inserters_egress: Array> + + tesla_coil: Array + + station:any + + private init_buildings(bp:BluePrint, area_index:number) { + this.smelters = new Array(smelter_index.max) + for(let i = 0; i < smelter_index.max; i++) this.smelters[i] = new Array() + for(let i = 0; i < building_num.iron_plate; i++) { + let smelter = new Smelter(area_index, null) + bp.addBuilding(smelter) + smelter.setRecipe(1) + this.smelters[smelter_index.iron_plate].push(smelter) + } + for(let i = 0; i < building_num.magnet_plate; i++) { + let smelter = new Smelter(area_index, null) + bp.addBuilding(smelter) + smelter.setRecipe(2) + this.smelters[smelter_index.magnet_plate].push(smelter) + } + for(let i = 0; i < building_num.copper_plate; i++) { + let smelter = new Smelter(area_index, null) + bp.addBuilding(smelter) + smelter.setRecipe(3) + this.smelters[smelter_index.copper_plate].push(smelter) + } + + this.assemblers = new Array(assembler_index.max) + for(let i = 0; i < assembler_index.max; i++) this.assemblers[i] = new Array() + for(let i = 0; i < building_num.circuit_board; i++) { + let assembler = new Assembler(area_index, null) + bp.addBuilding(assembler) + assembler.setRecipe(50) + this.assemblers[assembler_index.circuit_board].push(assembler) + } + for(let i = 0; i < building_num.magnetism_wire; i++) { + let assembler = new Assembler(area_index, null) + bp.addBuilding(assembler) + assembler.setRecipe(6) + this.assemblers[assembler_index.magnetism_wire].push(assembler) + } + + this.spray_coaters = new Array() + for(let i = 0; i <= belt_index.circuit_board_3; i++) { + let spray_coater = bp.addBuilding(new SprayCoater(area_index, null)) as SprayCoater + this.spray_coaters.push(spray_coater) + } + + this.labs = new Array() + for(let i = 0; i < building_num.blue_matrix; i++) { + let lab_stack:LabStack = new LabStack(area_index, null, false, undefined, 9) + lab_stack.getLabs().forEach(lab => bp.addBuilding(lab)) + lab_stack.initLabStacks() + this.labs.push(lab_stack) + } + + // Todo: station + + this.tesla_coil = new Array() + } + + private init_belts(bp:BluePrint, area_index:number) { + this.belts = new Array(belt_index.max) + for(let i = 0; i < belt_index.max; i++) this.belts[i] = new Array() + + for(let i = 0; i < belt_num.iron_ore_0; i++) this.belts[belt_index.iron_ore_0].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.iron_ore_1; i++) this.belts[belt_index.iron_ore_1].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.copper_ore; i++) this.belts[belt_index.copper_ore].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + + for(let i = 0; i < belt_num.iron_plate_0; i++) this.belts[belt_index.iron_plate_0].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.iron_plate_1; i++) this.belts[belt_index.iron_plate_1].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.iron_plate_2; i++) this.belts[belt_index.iron_plate_2].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.iron_plate_3; i++) this.belts[belt_index.iron_plate_3].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + + for(let i = 0; i < belt_num.magnet_plate_0; i++) this.belts[belt_index.magnet_plate_0].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.magnet_plate_1; i++) this.belts[belt_index.magnet_plate_1].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.magnet_plate_2; i++) this.belts[belt_index.magnet_plate_2].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.magnet_plate_3; i++) this.belts[belt_index.magnet_plate_3].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + + for(let i = 0; i < belt_num.copper_plate_0; i++) this.belts[belt_index.copper_plate_0].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.copper_plate_1; i++) this.belts[belt_index.copper_plate_1].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.copper_plate_2; i++) this.belts[belt_index.copper_plate_2].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.copper_plate_3; i++) this.belts[belt_index.copper_plate_3].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + + for(let i = 0; i < belt_num.magnetism_wire_0; i++) this.belts[belt_index.magnetism_wire_0].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.magnetism_wire_1; i++) this.belts[belt_index.magnetism_wire_1].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.magnetism_wire_2; i++) this.belts[belt_index.magnetism_wire_2].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.magnetism_wire_3; i++) this.belts[belt_index.magnetism_wire_3].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + + for(let i = 0; i < belt_num.circuit_board_0; i++) this.belts[belt_index.circuit_board_0].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.circuit_board_1; i++) this.belts[belt_index.circuit_board_1].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.circuit_board_2; i++) this.belts[belt_index.circuit_board_2].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.circuit_board_3; i++) this.belts[belt_index.circuit_board_3].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + + + for(let i = 0; i < belt_num.blue_array_0; i++) this.belts[belt_index.blue_matrix_0].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.blue_array_1; i++) this.belts[belt_index.blue_matrix_1].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.blue_array_2; i++) this.belts[belt_index.blue_matrix_2].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + for(let i = 0; i < belt_num.blue_array_3; i++) this.belts[belt_index.blue_matrix_3].push(bp.addBuilding(new Belt(area_index, null)) as Belt) + + + this.belts[belt_index.iron_ore_0][0].setLabel(1001) + this.belts[belt_index.iron_ore_1][0].setLabel(1001) + this.belts[belt_index.copper_ore][0].setLabel(1002) + + this.belts[belt_index.iron_plate_0][7].setLabel(1101) + this.belts[belt_index.iron_plate_1][7].setLabel(1101) + this.belts[belt_index.iron_plate_2][7].setLabel(1101) + this.belts[belt_index.iron_plate_3][7].setLabel(1101) + + this.belts[belt_index.magnet_plate_0][10].setLabel(1102) + this.belts[belt_index.magnet_plate_1][10].setLabel(1102) + this.belts[belt_index.magnet_plate_2][10].setLabel(1102) + this.belts[belt_index.magnet_plate_3][10].setLabel(1102) + + this.belts[belt_index.copper_plate_0][7].setLabel(1104) + this.belts[belt_index.copper_plate_1][7].setLabel(1104) + this.belts[belt_index.copper_plate_2][7].setLabel(1104) + this.belts[belt_index.copper_plate_3][7].setLabel(1104) + + this.belts[belt_index.magnetism_wire_0][5].setLabel(1202) + this.belts[belt_index.magnetism_wire_1][5].setLabel(1202) + this.belts[belt_index.magnetism_wire_2][5].setLabel(1202) + this.belts[belt_index.magnetism_wire_3][5].setLabel(1202) + + this.belts[belt_index.circuit_board_0][5].setLabel(1301) + this.belts[belt_index.circuit_board_1][5].setLabel(1301) + this.belts[belt_index.circuit_board_2][5].setLabel(1301) + this.belts[belt_index.circuit_board_3][5].setLabel(1301) + + this.belts[belt_index.blue_matrix_0][8].setLabel(6001) + this.belts[belt_index.blue_matrix_1][8].setLabel(6001) + this.belts[belt_index.blue_matrix_2][8].setLabel(6001) + this.belts[belt_index.blue_matrix_3][8].setLabel(6001) + + } + + private init_ingress_inserters(bp:BluePrint, area_index:number) { + // init inserter + this.inserters_ingress = new Array(ingress_inserter_index.max) + for(let i = 0; i < ingress_inserter_index.max; i++) this.inserters_ingress[i] = new Array() + for(let i = 0; i < building_num.iron_plate; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_ingress[ingress_inserter_index.iron_plate].push(inserter) + } + + for(let i = 0; i < building_num.magnet_plate; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_ingress[ingress_inserter_index.magnet_plate].push(inserter) + } + for(let i = 0; i < building_num.copper_plate; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_ingress[ingress_inserter_index.copper_plate].push(inserter) + } + for(let i = 0; i < building_num.circuit_board; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_ingress[ingress_inserter_index.circuit_board_0].push(inserter) + } + for(let i = 0; i < building_num.circuit_board; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_ingress[ingress_inserter_index.circuit_board_1].push(inserter) + } + for(let i = 0; i < building_num.magnetism_wire; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_ingress[ingress_inserter_index.magnetism_wire_0].push(inserter) + } + for(let i = 0; i < building_num.magnetism_wire; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_ingress[ingress_inserter_index.magnetism_wire_1].push(inserter) + } + for(let i = 0; i < building_num.blue_matrix; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_ingress[ingress_inserter_index.blue_matrix_0].push(inserter) + } + for(let i = 0; i < building_num.blue_matrix; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_ingress[ingress_inserter_index.blue_matrix_1].push(inserter) + } + } + + private init_egress_inserters(bp:BluePrint, area_index:number) { + this.inserters_egress = new Array(egress_inserter_index.max) + for(let i = 0; i < egress_inserter_index.max; i++) this.inserters_egress[i] = new Array() + for(let i = 0; i < building_num.iron_plate; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_egress[egress_inserter_index.iron_plate].push(inserter) + } + for(let i = 0; i < building_num.magnet_plate; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_egress[egress_inserter_index.magnet_plate].push(inserter) + } + for(let i = 0; i < building_num.copper_plate; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_egress[egress_inserter_index.copper_plate].push(inserter) + } + for(let i = 0; i < building_num.circuit_board; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_egress[egress_inserter_index.circuit_board].push(inserter) + } + for(let i = 0; i < building_num.magnetism_wire; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_egress[egress_inserter_index.magnetism_wire].push(inserter) + } + for(let i = 0; i < building_num.blue_matrix; i++) { + let inserter = new Inserter(area_index) + bp.addBuilding(inserter) + this.inserters_egress[egress_inserter_index.blue_matrix].push(inserter) + } + + } + + addTeslaCoil(local:[number, number]) { + let tesla_coil = new TeslaCoil(this.area_index, local) + this.bp.addBuilding(tesla_coil) + this.tesla_coil.push(tesla_coil) + } + + private setSmeltersLocal(local_base:[number, number, number]) { + let smelter_diff_12 = Array<[number, number,number]>() + smelter_diff_12[0] = [1, 1, 0] + + for (let i = 1; i < 6; i++) { + smelter_diff_12[i] = local_diff(smelter_diff_12[i - 1], [2.5, 0, 0]) + if (i == 3) smelter_diff_12[i] = local_diff(smelter_diff_12[i], [0.5, 0, 0]) + } + for (let i = 6; i < 12; i++) smelter_diff_12[i] = local_diff(smelter_diff_12[i - 6], [0, 2.5, 1.3]) + + let local_base_smelter_iron_plate = local_diff(local_base, [0, 0, 0]) + for (let i = 0; i < 12; i++) this.smelters[smelter_index.iron_plate][i].setLocal(local_diff(local_base_smelter_iron_plate, smelter_diff_12[i])) + this.addTeslaCoil(local_diff_2(local_base_smelter_iron_plate, [7.55, 2.5, 0])) + for (let i = 12; i < 24; i++) this.smelters[smelter_index.iron_plate][i].setLocal(local_diff(local_diff(local_base_smelter_iron_plate, [0, 5, 0]), smelter_diff_12[i - 12])) + this.addTeslaCoil(local_diff_2(local_base_smelter_iron_plate, [7.55, 7.5, 0])) + + let local_base_smelter_copper_plate = local_diff(local_base, [0, 10, 0]) + for (let i = 0; i < 12; i++) this.smelters[smelter_index.copper_plate][i].setLocal(local_diff(local_base_smelter_copper_plate, smelter_diff_12[i])) + this.addTeslaCoil(local_diff_2(local_base_smelter_copper_plate, [7.55, 2.5, 0])) + for (let i = 12; i < 24; i++) this.smelters[smelter_index.copper_plate][i].setLocal(local_diff(local_diff(local_base_smelter_copper_plate, [0, 5, 0]), smelter_diff_12[i - 12])) + this.addTeslaCoil(local_diff_2(local_base_smelter_copper_plate, [7.55, 7.5, 0])) + + let local_base_smelter_magnet_plate = local_diff(local_base, [0, 20, 0]) + for (let i = 0; i < 12; i++) this.smelters[smelter_index.magnet_plate][i].setLocal(local_diff(local_base_smelter_magnet_plate, smelter_diff_12[i])) + this.addTeslaCoil(local_diff_2(local_base_smelter_magnet_plate, [7.55, 2.5, 0])) + for (let i = 12; i < 24; i++) this.smelters[smelter_index.magnet_plate][i].setLocal(local_diff(local_diff(local_base_smelter_magnet_plate, [0, 5, 0]), smelter_diff_12[i - 12])) + this.addTeslaCoil(local_diff_2(local_base_smelter_magnet_plate, [7.55, 7.5, 0])) + for (let i = 24; i < 36; i++) this.smelters[smelter_index.magnet_plate][i].setLocal(local_diff(local_diff(local_base_smelter_magnet_plate, [0, 10, 0]), smelter_diff_12[i -24])) + this.addTeslaCoil(local_diff_2(local_base_smelter_magnet_plate, [7.55, 12.5, 0])) + } + + private setAssemblersLocal(local_base:[number, number, number]) { + let assembler_diff_8 = Array<[number, number, number]>() + assembler_diff_8[0] = [1.75, 0, 0] + assembler_diff_8[1] = [5.25, 0, 0] + assembler_diff_8[2] = [9.25, 0, 0] + assembler_diff_8[3] = [12.75, 0, 0] + for (let i = 4; i < 8; i ++) assembler_diff_8[i] = local_diff(assembler_diff_8[i - 4], [0, 3.5, 1.3]) + + let local_base_assembler_circuit_board = local_diff(local_base, [15.5, 1.5, 0]) + for (let i = 0; i < 8; i++) this.assemblers[assembler_index.circuit_board][i].setLocal(local_diff(local_base_assembler_circuit_board, assembler_diff_8[i])) + this.addTeslaCoil(local_diff_2(local_base_assembler_circuit_board, [7.25, 3.5, 0])) + for (let i = 8; i < 16; i++) this.assemblers[assembler_index.circuit_board][i].setLocal(local_diff(local_diff(local_base_assembler_circuit_board, [0,7,0]), assembler_diff_8[i - 8])) + this.addTeslaCoil(local_diff_2(local_base_assembler_circuit_board, [7.25, 7.0, 0])) + + let local_base_assembler_magnetism_wire = local_diff(local_base, [15.5, 15.5, 0]) + for (let i = 0; i < 8; i++) this.assemblers[assembler_index.magnetism_wire][i].setLocal(local_diff(local_base_assembler_magnetism_wire, assembler_diff_8[i])) + this.addTeslaCoil(local_diff_2(local_base_assembler_magnetism_wire, [7.25, 3.5, 0])) + for (let i = 8; i < 16; i++) this.assemblers[assembler_index.magnetism_wire][i].setLocal(local_diff(local_diff(local_base_assembler_magnetism_wire, [0,7,0]), assembler_diff_8[i - 8])) + this.addTeslaCoil(local_diff_2(local_base_assembler_magnetism_wire, [7.25, 7, 0])) + + } + + private setLabsLocal(local_base:[number, number, number]) { + let local_base_lab_1 = local_diff(local_base, [0, 38, 0]) + for (let i = 0; i < 7; i++) { + this.labs[i].setLocal(local_diff(local_diff(local_base_lab_1, [2.5, 0, 0]), [5 * i, 0, 0])) + if (i < 5) { + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_0, i, this.labs[i], 2, belt_index.magnetism_wire_0, i) + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_1, i, this.labs[i], 1, belt_index.circuit_board_0, i) + this.setEgressInserterWithLab(egress_inserter_index.blue_matrix, i, this.labs[i], 0, belt_index.blue_matrix_0, i) + } + else { + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_0, i, this.labs[i], 2, belt_index.magnetism_wire_1, i - 5) + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_1, i, this.labs[i], 1, belt_index.circuit_board_1, i - 5) + this.setEgressInserterWithLab(egress_inserter_index.blue_matrix, i, this.labs[i], 0, belt_index.blue_matrix_1, i - 5) + } + } + this.addTeslaCoil(local_diff_2(local_base_lab_1, [9.75, -3, 0])) + this.addTeslaCoil(local_diff_2(local_base_lab_1, [25.75, -3, 0])) + + let local_base_lab_2 = local_diff(local_base, [32.25,0,0]) + for (let i = 7; i < 12; i++) { + this.labs[i].setLocal(local_diff(local_diff(local_base_lab_2, [0, 2.5, 0]), [0, 5*(i - 7), 0])) + if (i < 10) { + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_0, i, this.labs[i], 3, belt_index.magnetism_wire_0, i - 5) + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_1, i, this.labs[i], 4, belt_index.circuit_board_0, i - 5) + this.setEgressInserterWithLab(egress_inserter_index.blue_matrix, i, this.labs[i], 5, belt_index.blue_matrix_0, i - 5) + } + else { + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_0, i, this.labs[i], 3, belt_index.magnetism_wire_1, i - 10) + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_1, i, this.labs[i], 4, belt_index.circuit_board_1, i - 10) + this.setEgressInserterWithLab(egress_inserter_index.blue_matrix, i, this.labs[i], 5, belt_index.blue_matrix_1, i - 10) + } + } + for (let i = 12; i < building_num.blue_matrix; i++) { + this.labs[i].setLocal(local_diff(local_diff(local_base_lab_2, [6.5, 2.5, 0]), [0, 5*(i - 12), 0])) + if (i < 15) { + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_0, i, this.labs[i], 9, belt_index.magnetism_wire_0, i - 10) + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_1, i, this.labs[i], 10, belt_index.circuit_board_0, i - 10) + this.setEgressInserterWithLab(egress_inserter_index.blue_matrix, i, this.labs[i], 11, belt_index.blue_matrix_0, i - 10) + } + else { + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_0, i, this.labs[i], 9, belt_index.magnetism_wire_1, i - 15) + this.setIngressInserterWithLab(ingress_inserter_index.blue_matrix_1, i, this.labs[i], 10, belt_index.circuit_board_1, i - 15) + this.setEgressInserterWithLab(egress_inserter_index.blue_matrix, i, this.labs[i], 11, belt_index.blue_matrix_1, i - 15) + } + } + this.addTeslaCoil(local_diff_2(local_base_lab_2, [3.5, 9.25, 0])) + this.addTeslaCoil(local_diff_2(local_base_lab_2, [3.5, 19.25, 0])) + this.addTeslaCoil(local_diff_2(local_base_lab_2, [3.5, 31.25, 0])) + } + + private setBeltsAndSprayCoaterLocal(local_base:[number, number, number]) { + // // set belts and spray roater + let local_base_copper_ore:[number, number, number] = [3, 31, 6] + this.belts[belt_index.copper_ore].forEach((belt, index) => {belt.setLocal(local_diff(local_base_copper_ore, [0, -1 * index, 0]))}) + this.spray_coaters[belt_index.copper_ore].setLocalByBelt(this.belts[belt_index.copper_ore][3], 180) + + let local_base_iron_ore_0:[number, number, number] = [4, 31, 6] + this.belts[belt_index.iron_ore_0].forEach((belt, index) => {belt.setLocal(local_diff(local_base_iron_ore_0, [0, -1 * index, 0]))}) + this.spray_coaters[belt_index.iron_ore_0].setLocalByBelt(this.belts[belt_index.iron_ore_0][3], 180) + + // 24 + 18 + let local_base_iron_ore_1_0:[number, number, number] = [5 + 17, 25, 6] + let local_base_iron_ore_1_1:[number, number, number] = [5, 25, 6] + this.belts[belt_index.iron_ore_1].forEach((belt, index) => { + if (index < 18) belt.setLocal(local_diff(local_base_iron_ore_1_0, [-1 * index, 0, 0])) + else belt.setLocal(local_diff(local_base_iron_ore_1_1, [0, -1 * (index - 18), 0])) + }) + this.spray_coaters[belt_index.iron_ore_1].setLocalByBelt(this.belts[belt_index.iron_ore_1][3], 90) + + let local_base_belt_iron_plate:[number, number, number] = [10, 1, 5] + for(let i = belt_index.iron_plate_0; i <= belt_index.iron_plate_3; i++) { + this.belts[i].forEach((belt, index) => {belt.setLocal(local_diff(local_diff(local_base_belt_iron_plate, [0, i - belt_index.iron_plate_0, 0]), [1 * index, 0, 0]))}) + this.spray_coaters[i].setLocalByBelt(this.belts[i][9], 90) + } + + let local_base_belt_magnet_plate:[number, number, number] = [7, 5, 5] + for(let i = belt_index.magnet_plate_0; i <= belt_index.magnet_plate_3; i++) { + this.belts[i].forEach((belt, index) => {belt.setLocal(local_diff(local_diff(local_base_belt_magnet_plate, [0, i - belt_index.magnet_plate_0, 0]), [1 * index, 0, 0]))}) + this.spray_coaters[i].setLocalByBelt(this.belts[i][12], 90) + } + + let local_base_belt_copper_plate:[number, number, number] = [2, 9, 5] + for(let i = belt_index.copper_plate_0; i <= belt_index.copper_plate_3; i++) { + this.belts[i].forEach((belt, index) => {belt.setLocal(local_diff(local_diff(local_base_belt_copper_plate, [0, i - belt_index.copper_plate_0, 0]), [1 * index, 0, 0]))}) + this.spray_coaters[i].setLocalByBelt(this.belts[i][9], 90) + } + + let local_base_belt_circuit_board:[number, number, number] = [12, 13, 5] + for(let i = belt_index.circuit_board_0; i <= belt_index.circuit_board_3; i++) { + this.belts[i].forEach((belt, index) => {belt.setLocal(local_diff(local_diff(local_base_belt_circuit_board, [0, i - belt_index.circuit_board_0, 0]), [1 * index, 0, 0]))}) + this.spray_coaters[i].setLocalByBelt(this.belts[i][7], 90) + } + + let local_base_belt_magnetism_wire:[number, number, number] = [12, 17, 5] + for(let i = belt_index.magnetism_wire_0; i <= belt_index.magnetism_wire_3; i++) { + this.belts[i].forEach((belt, index) => {belt.setLocal(local_diff(local_diff(local_base_belt_magnetism_wire, [0, i - belt_index.magnetism_wire_0, 0]), [1 * index, 0, 0]))}) + this.spray_coaters[i].setLocalByBelt(this.belts[i][7], 90) + } + + let local_base_belt_blue_array:[number, number, number] = [3, 21, 5] + for(let i = belt_index.blue_matrix_0; i <= belt_index.blue_matrix_3; i++) { + this.belts[i].forEach((belt, index) => {belt.setLocal(local_diff(local_diff(local_base_belt_blue_array, [0, i - belt_index.blue_matrix_0, 0]), [1 * index, 0, 0]))}) + } + + this.belts.forEach((belts, index) => { + connectBelts(belts) + }) + + } constructor( bp: BluePrint, area_index: number, local: [number, number] - ) - { - super() - this.labs = new BuildingList() - let belt_param:BeltBlueprintParam - let tmp_local:[number, number] - - //铁块 - this.iron_plate_local = [local[0], local[1]] - this.belt_iron_plate_egress = new Array() - this.belt_iron_plate_ingress = new Array() - tmp_local = this.iron_plate_local - this.building_group_iron_plate_0 = bp.addBuildings(new NearlySmelterGroup(bp, area_index, tmp_local, 1)) as NearlySmelterGroup - tmp_local = [tmp_local[0], tmp_local[1] + 5] - this.building_group_iron_plate_1 = bp.addBuildings(new NearlySmelterGroup(bp, area_index, tmp_local, 1)) as NearlySmelterGroup - this.belt_iron_plate_ingress = this.belt_iron_plate_ingress.concat(this.building_group_iron_plate_0.ingress_belts.getList()).concat(this.building_group_iron_plate_1.ingress_belts.getList()) - this.belt_iron_plate_egress = this.belt_iron_plate_egress.concat(this.building_group_iron_plate_0.egress_belts.getList()).concat(this.building_group_iron_plate_1.egress_belts.getList()) - - appendBelts(bp, this.belt_iron_plate_ingress, 7) - this.belt_iron_plate_ingress_local = [local[0] + 2, local[1] + 32, 8] - setBeltsLocalAndConnect(this.belt_iron_plate_ingress, this.belt_iron_plate_ingress.length, [this.belt_iron_plate_ingress_local[0], this.belt_iron_plate_ingress_local[1], this.belt_iron_plate_ingress_z], [0, -1, 0]) - this.spray_coater_iron_ore_0 = bp.addBuilding(new SprayCoater(area_index, this.belt_iron_plate_ingress[3].header.local_offset_x, this.belt_iron_plate_ingress[3].header.local_offset_y, this.belt_iron_plate_ingress_z, 180)) - this.belt_iron_plate_ingress[0].header.parameter_count = (this.belt_iron_plate_ingress[0].param as BeltBlueprintParam).setLabel(1001) - - this.belts_iron_plate = new Array(4) - this.belts_iron_plate.forEach(belts => belts = new Array()); - this.spray_coater_iron_plate = new Array() - let belt_iron_egress_local = [local[0] + 4, this.iron_plate_local[1] + 3 ] - for(let line = 0; line < 4; line ++) { - let y = belt_iron_egress_local[1] + line - this.belts_iron_plate[line] = this.belt_iron_plate_egress.slice(line * 6, line * 6 + 6) - appendBelts(bp, this.belts_iron_plate[line], 6) - setBeltsLocalAndConnect(this.belts_iron_plate[line], 12, [belt_iron_egress_local[0], y, this.belt_iron_plate_egress_z], [1, 0, 0]) - belt_param = this.belts_iron_plate[line][this.belts_iron_plate[line].length - 1].param as BeltBlueprintParam - this.belts_iron_plate[line][this.belts_iron_plate[line].length - 1].header.parameter_count = belt_param.setLabel(1101) - - let spray_coater = bp.addBuilding(new SprayCoater(area_index, this.belts_iron_plate[line][9].header.local_offset_x, y, this.belt_iron_plate_egress_z, 90)) - this.spray_coater_iron_plate.push(spray_coater) - } - - //磁铁 - this.magnet_plate_local = [local[0], local[1] + 10] - tmp_local = this.magnet_plate_local - this.belt_magnet_plate_egress = new Array() - this.belt_magnet_plate_ingress = new Array() - this.building_group_magnet_plate_0 = bp.addBuildings(new NearlySmelterGroup(bp, area_index, tmp_local, 2)) as NearlySmelterGroup - tmp_local = [tmp_local[0], tmp_local[1] + 5] - this.building_group_magnet_plate_1 = bp.addBuildings(new NearlySmelterGroup(bp, area_index, tmp_local, 2)) as NearlySmelterGroup - tmp_local = [tmp_local[0], tmp_local[1] + 5] - this.building_group_magnet_plate_2 = bp.addBuildings(new NearlySmelterGroup(bp, area_index, tmp_local, 2)) as NearlySmelterGroup - this.belt_magnet_plate_ingress = this.belt_magnet_plate_ingress.concat(this.building_group_magnet_plate_0.ingress_belts.getList()) - .concat(this.building_group_magnet_plate_1.ingress_belts.getList()) - .concat(this.building_group_magnet_plate_2.ingress_belts.getList()) - this.belt_magnet_plate_egress = this.belt_magnet_plate_egress.concat(this.building_group_magnet_plate_0.egress_belts.getList()) - .concat(this.building_group_magnet_plate_1.egress_belts.getList()) - .concat(this.building_group_magnet_plate_2.egress_belts.getList()) - - this.belt_magnet_plate_ingress_local = [local[0] - 34, local[1] + 1, 8] - appendBelts(bp, this.belt_magnet_plate_ingress, 7) - setBeltsLocalAndConnect(this.belt_magnet_plate_ingress, this.belt_magnet_plate_ingress.length, this.belt_magnet_plate_ingress_local, [1, 0, 0]) - this.belt_magnet_plate_ingress_local = [this.belt_magnet_plate_ingress_local[0] + 37, this.belt_magnet_plate_ingress_local[1] + 37, this.belt_magnet_plate_ingress_local[2]] - setBeltsLocalAndConnect(this.belt_magnet_plate_ingress, 37, this.belt_magnet_plate_ingress_local, [0, -1, 0]) - this.belt_magnet_plate_ingress_local = [this.belt_magnet_plate_ingress_local[0] + 12, this.belt_magnet_plate_ingress_local[1] - 12, this.belt_magnet_plate_ingress_local[2]] - setBeltsLocalAndConnect(this.belt_magnet_plate_ingress, 12, this.belt_magnet_plate_ingress_local, [-1, 0, 0]) - this.spray_coater_iron_ore_1 = bp.addBuilding(new SprayCoater(area_index, this.belt_magnet_plate_ingress[3].header.local_offset_x, this.belt_magnet_plate_ingress[3].header.local_offset_y, this.belt_magnet_plate_ingress_local[2], 90)) - this.belt_magnet_plate_ingress[0].header.parameter_count = (this.belt_magnet_plate_ingress[0].param as BeltBlueprintParam).setLabel(1001) - - this.belts_magnet_plate = new Array(4) - this.belts_magnet_plate.forEach(belts => { - belts = new Array() - }); - - this.spray_coater_magnet_plate = new Array() - let belt_magnet_egress_local = [local[0] + 1, local[1] + 7] - for(let line = 0; line < 4; line ++) { - let y = belt_magnet_egress_local[1] + line - this.belts_magnet_plate[line] = this.belt_magnet_plate_egress.slice(line * 9, line * 9 + 9) - appendBelts(bp, this.belts_magnet_plate[line], 6) - setBeltsLocalAndConnect(this.belts_magnet_plate[line], 15, [belt_magnet_egress_local[0], y, this.belt_magnet_plate_egress_z], [1, 0, 0]) - belt_param = this.belts_magnet_plate[line][this.belts_magnet_plate[line].length - 1].param as BeltBlueprintParam - this.belts_magnet_plate[line][this.belts_magnet_plate[line].length - 1].header.parameter_count = belt_param.setLabel(1102) - - let spray_coater = bp.addBuilding(new SprayCoater(area_index, this.belts_magnet_plate[line][12].header.local_offset_x, y, this.belt_magnet_plate_egress_z, 90)) - this.spray_coater_magnet_plate.push(spray_coater) - } - - //铜块 - this.copper_plate_local = [local[0], local[1] + 25] - this.belt_copper_plate_egress = new Array() - this.belt_copper_plate_ingress = new Array() - tmp_local = this.copper_plate_local - this.building_group_copper_0 = bp.addBuildings(new NearlySmelterGroup(bp, area_index, tmp_local, 3)) as NearlySmelterGroup - this.belt_copper_plate_ingress = this.belt_copper_plate_ingress.concat(this.building_group_copper_0.ingress_belts.getList()) - this.belt_copper_plate_egress = this.belt_copper_plate_egress.concat(this.building_group_copper_0.egress_belts.getList()) - - tmp_local = [tmp_local[0], tmp_local[1] + 5] - this.building_group_copper_1 = bp.addBuildings(new NearlySmelterGroup(bp, area_index, tmp_local, 3)) as NearlySmelterGroup - this.belt_copper_plate_ingress = this.belt_copper_plate_ingress.concat(this.building_group_copper_1.ingress_belts.getList()) - this.belt_copper_plate_egress = this.belt_copper_plate_egress.concat(this.building_group_copper_1.egress_belts.getList()) - - this.belts_copper_plate = new Array(4) - this.belts_copper_plate.forEach(belts => { - belts = new Array() - }); - - this.spray_coater_copper_plate = new Array() - let belt_copper_egress_local = [local[0] + 4, local[1] + 11] - for(let line = 0; line < 4; line ++) { - let y = belt_copper_egress_local[1] + line - this.belts_copper_plate[line] = this.belt_copper_plate_egress.slice(line * 6, line * 6 + 6) - appendBelts(bp, this.belts_copper_plate[line], 6) - setBeltsLocalAndConnect(this.belts_copper_plate[line], 12, [belt_copper_egress_local[0], y, this.belt_copper_plate_egress_z], [1, 0, 0]) - belt_param = this.belts_copper_plate[line][this.belts_copper_plate[line].length - 1].param as BeltBlueprintParam - this.belts_copper_plate[line][this.belts_copper_plate[line].length - 1].header.parameter_count = belt_param.setLabel(1104) - - let spray_coater = bp.addBuilding(new SprayCoater(area_index, this.belts_copper_plate[line][9].header.local_offset_x, y, this.belt_copper_plate_egress_z, 90)) - this.spray_coater_copper_plate.push(spray_coater) - } + ) { + this.bp = bp + this.area_index = area_index + + this.init_buildings(bp, area_index) + this.init_belts(bp, area_index) + this.init_ingress_inserters(bp, area_index) + this.init_egress_inserters(bp, area_index) + + // set local + // set building + let local_base:[number, number, number] = [local[0], local[1], 0] + this.setSmeltersLocal(local_base) + this.setAssemblersLocal(local_base) + this.setBeltsAndSprayCoaterLocal(local_base) + this.setLabsLocal(local_base) + + + this.setIngressInserterWithSmelter(ingress_inserter_index.iron_plate, smelter_index.iron_plate, belt_index.iron_ore_0) + this.setIngressInserterWithSmelter(ingress_inserter_index.magnet_plate, smelter_index.magnet_plate, belt_index.iron_ore_1) + this.setIngressInserterWithSmelter(ingress_inserter_index.copper_plate, smelter_index.copper_plate, belt_index.copper_ore) + this.setEgressInserterWithSmelter(egress_inserter_index.iron_plate, smelter_index.iron_plate, belt_index.iron_plate_0, 4) + this.setEgressInserterWithSmelter(egress_inserter_index.magnet_plate, smelter_index.magnet_plate, belt_index.magnet_plate_0, 4) + this.setEgressInserterWithSmelter(egress_inserter_index.copper_plate, smelter_index.copper_plate, belt_index.copper_plate_0, 4) + + this.setIngressInserterWithAssembler(ingress_inserter_index.magnetism_wire_0, 2, assembler_index.magnetism_wire, belt_index.magnet_plate_0, 4) + this.setIngressInserterWithAssembler(ingress_inserter_index.magnetism_wire_1, 1, assembler_index.magnetism_wire, belt_index.copper_plate_0, 2) + this.setEgressInserterWithAssembler(egress_inserter_index.magnetism_wire, 0, assembler_index.magnetism_wire, belt_index.magnetism_wire_0, 4) - appendBelts(bp, this.belt_copper_plate_ingress, 7) - this.belt_copper_plate_ingress_local = [local[0] + 1, local[1] + 32, 8] - setBeltsLocalAndConnect(this.belt_copper_plate_ingress, this.belt_copper_plate_ingress.length, [this.belt_copper_plate_ingress_local[0], this.belt_copper_plate_ingress_local[1], this.belt_copper_plate_ingress_local[2]], [0, -1, 0]) - this.spray_coater_copper_ore = bp.addBuilding(new SprayCoater(area_index, this.belt_copper_plate_ingress[3].header.local_offset_x, this.belt_copper_plate_ingress[3].header.local_offset_y, this.belt_copper_plate_ingress[3].header.local_offset_z, 180)) - this.belt_copper_plate_ingress[0].header.parameter_count = (this.belt_copper_plate_ingress[0].param as BeltBlueprintParam).setLabel(1002) - - //磁线圈 - tmp_local = [local[0] + 16, local[1] + 0.25] - bp.addBuildings(new NearlyAssembler2In1Group(bp, area_index, tmp_local, 6, -0.25, 0.75, 2.75)) as NearlyAssembler2In1Group - tmp_local = [tmp_local[0], tmp_local[1] + 7] - bp.addBuildings(new NearlyAssembler2In1Group(bp, area_index, tmp_local, 6, -0.25, 0.75, 2.75)) as NearlyAssembler2In1Group - //电路板 - tmp_local = [tmp_local[0], tmp_local[1] + 7] - bp.addBuildings(new NearlyAssembler2In1Group(bp, area_index, tmp_local, 50, -0.25, 0.75, 2.75)) as NearlyAssembler2In1Group - tmp_local = [tmp_local[0], tmp_local[1] + 7] - bp.addBuildings(new NearlyAssembler2In1Group(bp, area_index, tmp_local, 50, -0.25, 0.75, 2.75)) as NearlyAssembler2In1Group - - //蓝糖 - let lab:LabStack - tmp_local = [local[0] + 32, local[1] + 2.25] - lab = bp.addBuildings(new LabStack(area_index, tmp_local[0], tmp_local[1], false, undefined, 9)) as LabStack - lab.initLabStacks() - this.labs.concat(lab) - for(let i = 0; i < 6; i++) { - tmp_local = [tmp_local[0], tmp_local[1] + 4.5] - lab = bp.addBuildings(new LabStack(area_index, tmp_local[0], tmp_local[1], false, undefined, 9)) as LabStack - lab.initLabStacks() - this.labs.concat(lab) - } - - tmp_local = [local[0] + 38.5, local[1] + 2.25] - lab = bp.addBuildings(new LabStack(area_index, tmp_local[0], tmp_local[1], false, undefined, 9)) as LabStack - lab.initLabStacks() - this.labs.concat(lab) - for(let i = 0; i < 6; i++) { - tmp_local = [tmp_local[0], tmp_local[1] + 4.5] - lab = bp.addBuildings(new LabStack(area_index, tmp_local[0], tmp_local[1], false, undefined, 9)) as LabStack - lab.initLabStacks() - this.labs.concat(lab) - } - - tmp_local = [local[0] + 2.25, local[1] + 38.25] - lab = bp.addBuildings(new LabStack(area_index, tmp_local[0], tmp_local[1], false, undefined, 9)) as LabStack - lab.initLabStacks() - this.labs.concat(lab) - for(let i = 0; i < 5; i++) { - tmp_local = [tmp_local[0] + 5, tmp_local[1]] - lab = bp.addBuildings(new LabStack(area_index, tmp_local[0], tmp_local[1], false, undefined, 9)) as LabStack - lab.initLabStacks() - this.labs.concat(lab) - } + this.setIngressInserterWithAssembler(ingress_inserter_index.circuit_board_0, 2, assembler_index.circuit_board, belt_index.magnet_plate_0, 4) + this.setIngressInserterWithAssembler(ingress_inserter_index.circuit_board_1, 1, assembler_index.circuit_board, belt_index.copper_plate_2, 2) + this.setEgressInserterWithAssembler(egress_inserter_index.circuit_board, 0, assembler_index.circuit_board, belt_index.circuit_board_0, 4) + } + + private setIngressInserterWithSmelter(inserter_index:ingress_inserter_index, smelter_index:smelter_index, belt_index:belt_index) { + this.inserters_ingress[inserter_index].forEach((inserter, index) => { + let smelter = this.smelters[smelter_index][index] + let slot:number = smelter.getLocal()[2] == 0 ? 6 : 2 + let param = smelter.getInserterLocal(slot, true) + param.setInputObject(this.belts[belt_index][this.belts[belt_index].length - 1 - index]) + param.setOutputFromSlot(0) + param.setInputToSlot(1) + inserter.setLocalParam(param) + }) + } + + // private setIngressInserterWithSmelter1(inserter_index:ingress_inserter_index, inserter_offset:number, smelter:Smelter, slot:number, belt_index:belt_index, belt_offset:number) { + // let inserter = this.inserters_ingress[inserter_index][inserter_offset] + // let param = smelter.getInserterLocal(slot, true) + // param.setInputObject(this.belts[belt_index][belt_offset]) + // param.setOutputFromSlot(0) + // param.setInputToSlot(1) + // inserter.setLocalParam(param) + // } + + private setEgressInserterWithSmelter(inserter_index:egress_inserter_index, smelter_index:smelter_index, belt_index_begin:belt_index, count:number) { + this.inserters_egress[inserter_index].forEach((inserter, index) => { + let smelter = this.smelters[smelter_index][index] + let slot:number = smelter.getLocal()[2] == 0 ? 7 : 1 + let param = smelter.getInserterLocal(slot, false) + param.setOutputObject(this.belts[belt_index_begin + Math.floor(index/count)][Math.floor(index/count)]) + param.setOutputToSlot(-1) + param.setOutputFromSlot(0) + param.setInputToSlot(1) + inserter.setLocalParam(param) + }) + } + + private setIngressInserterWithAssembler(inserter_index:ingress_inserter_index, vslot:number, assembler_index:assembler_index, belt_index_begin:belt_index, count:number) { + this.inserters_ingress[inserter_index].forEach((inserter, index) => { + let assembler = this.assemblers[assembler_index][index] + let slot:number = assembler.getLocal()[2] == 0 ? 8 - vslot : vslot + let param = assembler.getInserterLocal(slot, true) + param.setInputObject(this.belts[belt_index_begin + Math.floor(index/count)][this.belts[belt_index_begin + Math.floor(index/count)].length - 1 - Math.floor(index/count)]) + param.setOutputFromSlot(0) + param.setInputToSlot(1) + inserter.setLocalParam(param) + }) + } + + private setEgressInserterWithAssembler(inserter_index:egress_inserter_index, vslot:number, assembler_index:assembler_index, belt_index_begin:belt_index, count:number) { + this.inserters_egress[inserter_index].forEach((inserter, index) => { + let assembler = this.assemblers[assembler_index][index] + let slot:number = assembler.getLocal()[2] == 0 ? 8 - vslot : vslot + let param = assembler.getInserterLocal(slot, false) + param.setOutputObject(this.belts[belt_index_begin + Math.floor(index/count)][Math.floor(index/count)]) + param.setOutputToSlot(-1) + param.setOutputFromSlot(0) + param.setInputToSlot(1) + inserter.setLocalParam(param) + }) + } + + private setIngressInserterWithLab(inserter_index:ingress_inserter_index, inserter_offset:number, labs:LabStack, slot:number, belt_index:belt_index, belt_offset:number) { + let inserter = this.inserters_ingress[inserter_index][inserter_offset] + let param = labs.getInserterLocal(slot, true) + param.setInputObject(this.belts[belt_index][belt_offset]) + param.setOutputFromSlot(0) + param.setInputToSlot(1) + inserter.setLocalParam(param) + } - tmp_local = [local[0] + 35.5, local[1] + 2.25]; - (bp.addBuildings(new BeltList(area_index, 16, [tmp_local[0], tmp_local[1], 2], [0,1,0])) as BeltList) + private setEgressInserterWithLab(inserter_index:egress_inserter_index, inserter_offset:number, labs:LabStack, slot:number, belt_index:belt_index, belt_offset:number) { + let inserter = this.inserters_egress[inserter_index][inserter_offset] + let param = labs.getInserterLocal(slot, false) + param.setOutputObject(this.belts[belt_index][belt_offset]) + param.setOutputToSlot(-1) + param.setOutputFromSlot(0) + param.setInputToSlot(1) + inserter.setLocalParam(param) } -} \ No newline at end of file +} diff --git a/building_group/7200_blue_array_params.ts b/building_group/7200_blue_array_params.ts new file mode 100644 index 0000000..938c62f --- /dev/null +++ b/building_group/7200_blue_array_params.ts @@ -0,0 +1,158 @@ +export enum spray_coater_index { + iron_ore_0 = 0, // for iron plate + iron_ore_1, // for magnet_plate + copper_ore, + + iron_plate_0, + iron_plate_1, + iron_plate_2, + iron_plate_3, + + magnet_plate_0, + magnet_plate_1, + magnet_plate_2, + magnet_plate_3, + + copper_plate_0, + copper_plate_1, + copper_plate_2, + copper_plate_3, + + magnetism_wire_0, + magnetism_wire_1, + magnetism_wire_2, + magnetism_wire_3, + + circuit_board_0, + circuit_board_1, + circuit_board_2, + circuit_board_3, + + max, +} + +export enum belt_index { + iron_ore_0, + iron_ore_1, + copper_ore, + + magnet_plate_0, + magnet_plate_1, + magnet_plate_2, + magnet_plate_3, + + iron_plate_0, + iron_plate_1, + iron_plate_2, + iron_plate_3, + + copper_plate_0, + copper_plate_1, + copper_plate_2, + copper_plate_3, + + magnetism_wire_0, + magnetism_wire_1, + magnetism_wire_2, + magnetism_wire_3, + + circuit_board_0, + circuit_board_1, + circuit_board_2, + circuit_board_3, + + blue_matrix_0, + blue_matrix_1, + blue_matrix_2, + blue_matrix_3, + + max, +} + +export enum smelter_index { + iron_plate, + magnet_plate, + copper_plate, + max +} + +export enum assembler_index { + magnetism_wire, + circuit_board, + max +} + +export enum ingress_inserter_index { + magnet_plate, + iron_plate, + copper_plate, + + magnetism_wire_0, + magnetism_wire_1, + circuit_board_0, + circuit_board_1, + + blue_matrix_0, + blue_matrix_1, + + max +} + +export enum egress_inserter_index { + magnet_plate, + iron_plate, + copper_plate, + + magnetism_wire, + circuit_board, + + blue_matrix, + + max +} + +export const building_num = { + iron_plate:24, + magnet_plate:36, + copper_plate:24, + circuit_board:16, + magnetism_wire:16, + blue_matrix:20, + spray_router: 27, +} + +export const belt_num = { + iron_ore_0: 30, // 24 + 6 + ? + iron_ore_1: 42, // 36 + 6 + ? + copper_ore:30, //24 + 6 + + iron_plate_0: 16, // 6 + 6 + 4 + iron_plate_1: 16, // 6 + 6 + 4 + iron_plate_2: 16, // 6 + 6 + 4 + iron_plate_3: 16, // 6 + 6 + 4 + + magnet_plate_0: 19, // 9 + 6 + 4 + magnet_plate_1: 19, // 9 + 6 + 4 + magnet_plate_2: 19, // 9 + 6 + 4 + magnet_plate_3: 19, // 9 + 6 + 4 + + copper_plate_0: 22, // 6 + 12 + 4 + copper_plate_1: 22, // 6 + 12 + 4 + copper_plate_2: 22, // 6 + 12 + 4 + copper_plate_3: 22, // 6 + 12 + 4 + + circuit_board_0: 18, // 4 + 6 + 8 + circuit_board_1: 18, // 4 + 6 + 8 + circuit_board_2: 18, // 4 + 6 + 8 + circuit_board_3: 18, // 4 + 6 + 8 + + magnetism_wire_0: 18, // 4 + 6 + 8 + magnetism_wire_1: 18, // 4 + 6 + 8 + magnetism_wire_2: 18, // 4 + 6 + 8 + magnetism_wire_3: 18, // 4 + 6 + 8 + + blue_array_0:10, // 8 + ? + blue_array_1:10, // 8 + ? + blue_array_2:10, // 8 + ? + blue_array_3:10, // 8 + ? +} diff --git a/building_group/assembler_group.ts b/building_group/assembler_group.ts deleted file mode 100644 index 28d1791..0000000 --- a/building_group/assembler_group.ts +++ /dev/null @@ -1,102 +0,0 @@ -import { BluePrint } from "../BP/blueprint"; -import { BeltList } from "../BP/builiding/belt"; -import { BuildingList } from "../BP/builiding/builiding"; -import { Inserter } from "../BP/builiding/inserter"; -import { AssemblerList } from "../BP/builiding/assembler"; -import { TeslaCoil } from "../BP/builiding/tesla_coil"; - -export class NearlyAssembler2In1Group extends BuildingList { - bp: BluePrint - assemblers_00: AssemblerList - assemblers_13: AssemblerList - ingress_belts1: BeltList - ingress_belts2: BeltList - egress_belts: BeltList - ingress_inserters1: Array - ingress_inserters2: Array - egress_inserters: Array - tesla_coil: TeslaCoil - - constructor( - bp: BluePrint, - area_index: number, - local: [number, number], - recipe_id:number, - ingress_belt1_offset = 0, - ingress_belt2_offset = 1, - egress_belt_offset = 3, - assembler_level = 3, - belt_level = 3, - inserter_level = 3 - ) { - super() - this.bp = bp - - let offset = [3.4, 0] - - this.assemblers_00 = bp.addBuildings(new AssemblerList(area_index, [local[0] + 1.0, local[1] + 1.0, 0.0], recipe_id, [2, 1], offset, assembler_level)) as AssemblerList - this.assemblers_00.concat(bp.addBuildings(new AssemblerList(area_index, [local[0] + 8.5, local[1] + 1.0, 0.0], recipe_id, [2, 1], offset, assembler_level)) as AssemblerList) - - this.assemblers_13 = bp.addBuildings(new AssemblerList(area_index, [local[0] + 1.0, local[1] + 4.5, 1.3], recipe_id, [2, 1], offset, assembler_level)) as AssemblerList - this.assemblers_13.concat(bp.addBuildings(new AssemblerList(area_index, [local[0] + 8.5, local[1] + 4.5, 1.3], recipe_id, [2, 1], offset, assembler_level)) as AssemblerList) - - this.ingress_belts1 = bp.addBuildings(new BeltList(area_index, 8, [local[0], local[1] + ingress_belt1_offset, 5], undefined, belt_level)) as BeltList - this.ingress_belts2 = bp.addBuildings(new BeltList(area_index, 8, [local[0], local[1] + ingress_belt2_offset, 5], undefined, belt_level)) as BeltList - this.egress_belts = bp.addBuildings(new BeltList(area_index, 8, [local[0], local[1] + egress_belt_offset, 5], undefined, belt_level)) as BeltList - - this.tesla_coil = bp.addBuilding(new TeslaCoil(area_index, local[0] + 6.5, local[1] + 3)) as TeslaCoil - - this.ingress_inserters1 = new Array() - this.ingress_inserters2 = new Array() - this.egress_inserters = new Array() - this.assemblers_00.forEach((assembler, index, array) => { - this.ingress_inserters1.push(bp.addBuilding( - new Inserter(area_index, - [assembler.header.local_offset_x - 1.0, assembler.header.local_offset_y + 1.0, 0], - [assembler.header.local_offset_x - 1.0, assembler.header.local_offset_y + 2.2, 0], - this.ingress_belts1.getList()[index*2].header.index, assembler.header.index, - -1, 0, 0, 1) - ) as Inserter ) - this.ingress_inserters2.push(bp.addBuilding( - new Inserter(area_index, - [assembler.header.local_offset_x, assembler.header.local_offset_y + 1.0, 0], - [assembler.header.local_offset_x, assembler.header.local_offset_y + 2.2, 0], - this.ingress_belts2.getList()[index*2].header.index, assembler.header.index, - -1, 1, 0, 1) - ) as Inserter ) - - this.egress_inserters.push(bp.addBuilding( - new Inserter(area_index, - [assembler.header.local_offset_x + 1.0, assembler.header.local_offset_y + 2.2, 0], - [assembler.header.local_offset_x + 1.0, assembler.header.local_offset_y + 1.0, 0], - assembler.header.index, this.egress_belts.getList()[index*2].header.index, - 2, -1, 0, 1) - ) as Inserter ) - }); - - this.assemblers_13.forEach((assembler, index, array) => { - this.ingress_inserters1.push(bp.addBuilding( - new Inserter(area_index, - [assembler.header.local_offset_x - 1.0, assembler.header.local_offset_y - 1.0, 1.3], - [assembler.header.local_offset_x - 1.0, assembler.header.local_offset_y - 2.2, 1.3], - this.ingress_belts1.getList()[index*2+1].header.index, assembler.header.index, - -1, 8, 0, 1) - ) as Inserter ) - this.ingress_inserters2.push(bp.addBuilding( - new Inserter(area_index, - [assembler.header.local_offset_x, assembler.header.local_offset_y - 1.0, 1.3], - [assembler.header.local_offset_x, assembler.header.local_offset_y - 2.2, 1.3], - this.ingress_belts1.getList()[index*2+1].header.index, assembler.header.index, - -1, 7, 0, 1) - ) as Inserter ) - - this.egress_inserters.push(bp.addBuilding( - new Inserter(area_index, - [assembler.header.local_offset_x + 1.0, assembler.header.local_offset_y - 2.2, 1.3], - [assembler.header.local_offset_x + 1.0, assembler.header.local_offset_y - 1.0, 1.3], - assembler.header.index, this.egress_belts.getList()[index*2+1].header.index, - 6, -1, 0, 1) - ) as Inserter ) - }); - } -} \ No newline at end of file diff --git a/building_group/smelter_groups.ts b/building_group/smelter_groups.ts deleted file mode 100644 index 7e2c307..0000000 --- a/building_group/smelter_groups.ts +++ /dev/null @@ -1,79 +0,0 @@ -import { BluePrint } from "../BP/blueprint"; -import { BeltList } from "../BP/builiding/belt"; -import { BuildingList } from "../BP/builiding/builiding"; -import { Inserter } from "../BP/builiding/inserter"; -import { SmelterList } from "../BP/builiding/smelter"; -import { TeslaCoil } from "../BP/builiding/tesla_coil"; - -export class NearlySmelterGroup extends BuildingList { - bp: BluePrint - smelters_00: SmelterList - smelters_13: SmelterList - ingress_belts: BeltList - egress_belts: BeltList - ingress_inserters: Array - egress_inserters: Array - tesla_coil: TeslaCoil - - constructor( - bp: BluePrint, - area_index: number, - local: [number, number], - recipe_id:number, - smelter_level = 2, - belt_level = 3, - inserter_level = 3 - ) { - super() - this.bp = bp - - this.smelters_00 = bp.addBuildings(new SmelterList(area_index, [local[0] + 1.0, local[1] + 1.0, 0.0], recipe_id, [3, 1], [2.5, 5], smelter_level)) as SmelterList - this.smelters_00.concat(bp.addBuildings(new SmelterList(area_index, [local[0] + 9.0, local[1] + 1.0, 0.0], recipe_id, [3, 1], [2.5, 5], smelter_level)) as SmelterList) - - this.smelters_13 = bp.addBuildings(new SmelterList(area_index, [local[0] + 1.0, local[1] + 3.5, 1.3], recipe_id, [3, 1], [2.5, 5], smelter_level)) as SmelterList - this.smelters_13.concat(bp.addBuildings(new SmelterList(area_index, [local[0] + 9.0, local[1] + 3.5, 1.3], recipe_id, [3, 1], [2.5, 5], smelter_level)) as SmelterList) - - this.ingress_belts = bp.addBuildings(new BeltList(area_index, 12, [local[0], local[1] + 1, 5], undefined, belt_level)) as BeltList - this.egress_belts = bp.addBuildings(new BeltList(area_index, 12, [local[0], local[1] + 3, 5], undefined, belt_level)) as BeltList - - this.tesla_coil = bp.addBuilding(new TeslaCoil(area_index, local[0] + 7.5, local[1] + 2.25)) as TeslaCoil - - this.ingress_inserters = new Array() - this.egress_inserters = new Array() - this.smelters_00.forEach((smelter, index, array) => { - this.egress_inserters.push(bp.addBuilding( - new Inserter(area_index, - [smelter.header.local_offset_x - 1.0, smelter.header.local_offset_y + 1.0, 0], - [smelter.header.local_offset_x - 1.0, smelter.header.local_offset_y + 2.2, 0], - this.egress_belts.getList()[index*2].header.index, smelter.header.index, - -1, 0, 0, 1) - ) as Inserter ) - - this.ingress_inserters.push(bp.addBuilding( - new Inserter(area_index, - [smelter.header.local_offset_x, smelter.header.local_offset_y + 2.2, 0], - [smelter.header.local_offset_x, smelter.header.local_offset_y + 1.0, 0], - smelter.header.index, this.ingress_belts.getList()[index*2].header.index, - 1, -1, 0, 1) - ) as Inserter ) - }); - - this.smelters_13.forEach((smelter, index, array) => { - this.egress_inserters.push(bp.addBuilding( - new Inserter(area_index, - [smelter.header.local_offset_x - 1.0, smelter.header.local_offset_y - 1.0, 1.3], - [smelter.header.local_offset_x - 1.0, smelter.header.local_offset_y - 2.2, 1.3], - this.egress_belts.getList()[index*2+1].header.index, smelter.header.index, - -1, 8, 0, 1) - ) as Inserter ) - - this.ingress_inserters.push(bp.addBuilding( - new Inserter(area_index, - [smelter.header.local_offset_x, smelter.header.local_offset_y - 2.2, 1.3], - [smelter.header.local_offset_x, smelter.header.local_offset_y - 1.0, 1.3], - smelter.header.index, this.ingress_belts.getList()[index*2+1].header.index, - 7, -1, 0, 1) - ) as Inserter ) - }); - } -} \ No newline at end of file diff --git a/main.ts b/main.ts index fb8971d..23e83fb 100644 --- a/main.ts +++ b/main.ts @@ -1,9 +1,5 @@ import { BluePrint } from "./BP/blueprint"; -import { BeltList } from "./BP/builiding/belt"; import * as fs from 'fs' -import { Building } from "./BP/builiding/builiding"; -import { Smelter, SmelterList } from "./BP/builiding/smelter"; -import { NearlySmelterGroup } from "./building_group/smelter_groups"; import { BlueArray7200 } from "./building_group/7200_blue_array"; // Todo: use system time @@ -26,6 +22,6 @@ let area_index = bp.addArea(parent_index, tropic_anchor, area_segments, anchor_local_offset_x, anchor_local_offset_y, width, height) let local:[number, number] = [0,0] -let smelter_group = bp.addBuildings(new BlueArray7200(bp, area_index, local)) as NearlySmelterGroup +new BlueArray7200(bp, area_index, local) fs.writeFileSync(process.env.npm_config_output, bp.export()) \ No newline at end of file diff --git a/util.ts b/util.ts new file mode 100644 index 0000000..c17b11e --- /dev/null +++ b/util.ts @@ -0,0 +1,30 @@ +import { assert } from "console" + +export function array_diff_multi(bases:Array, diff:Array, num = 0) : Array> { + let ret = new Array() + assert(bases.length == diff.length) + for (let i = 0; i < num; i++) { + let tmp = new Array(bases.length) + bases.forEach((base, index) => tmp[index] = base + diff[index] * i) + ret.push(tmp) + } + return ret +} + +export function array_diff(bases:Array, diff:Array) : Array { + let ret = new Array() + assert(bases.length == diff.length) + bases.forEach((base, index) => ret[index] = base + diff[index]) + return ret +} + +export function local_diff(base:[number, number, number], diff:[number, number, number]) :[number, number, number] { + return array_diff(base, diff) as [number, number, number] +} + +export function local_diff_2(base:[number, number, number], diff:[number, number, number]) :[number, number] { + let local = array_diff(base, diff) + return [local[0], local[1]] +} + +// console.log(array_diff([0, 1, 0], [1, 1, 0], 20)) \ No newline at end of file