// Use this for initialization
void Start()
{
bSys = GetComponent <BlockSystem>();
blockData = GetComponent <BlockData>();
blockSelectCounter = 0;
loadBlocks();
}
private void Awake()
{
blockSys = GetComponent <BlockSystem>();
buildSys = GetComponent <BuildSystem>();
ToggleInv(false);
}
public void Initialize(BlockSystem localBlockSystem, Int3 localLocation)
{
LocalBlockSystem = localBlockSystem;
LocalLocation = localLocation;
name = $"{LocalBlockSystem.gameObject.name}: {name} {LocalLocation.x} {LocalLocation.y} {LocalLocation.z}";
transform.parent = LocalBlockSystem.transform;
transform.position = LocalBlockSystem.GetBlockWorldPositionByLocation(LocalLocation);
}
private void Search()
{
BlockFilter <IMyTextPanel> block_filter = BlockFilter <IMyTextPanel> .Create(Me, MyProperty.lcd_filter);
lcds = BlockSystem <IMyTextPanel> .SearchByFilter(this, block_filter);
search = false;
}
private void Start()
{
instance = this;
peerToPeerManager = multiplayerWorlds.GetComponent <PeerToPeerManager>();
blockSystem = GetComponent <BlockSystem>();
playerMove = player.GetComponent <PlayerMove>();
Debug.Log("Building System Initialized!");
}
private void Search()
{
BlockFilter <IMyProductionBlock> block_filter = BlockFilter <IMyProductionBlock> .Create(DisplayLcd.lcd, filter);
producers = BlockSystem <IMyProductionBlock> .SearchByFilter(DisplayLcd.program, block_filter);
search = false;
}
private void Search()
{
BlockFilter <IMyShipDrill> block_filter = BlockFilter <IMyShipDrill> .Create(DisplayLcd.lcd, filter);
drill_inventories = BlockSystem <IMyShipDrill> .SearchByFilter(DisplayLcd.program, block_filter);
search = false;
}
private void Awake()
{
//store reference to block system script
blockSys = GetComponent <BlockSystem>();
//find player and store reference
playerObject = GameObject.Find("Player");
}
private void Search()
{
BlockFilter <IMyTerminalBlock> block_filter = BlockFilter <IMyTerminalBlock> .Create(DisplayLcd.lcd, filter);
block_filter.HasInventory = true;
inventories = BlockSystem <IMyTerminalBlock> .SearchByFilter(DisplayLcd.program, block_filter);
search = false;
}
private void Search()
{
BlockFilter <IMyDoor> block_filter1 = BlockFilter <IMyDoor> .Create(Me, "*");
doors = BlockSystem <IMyDoor> .SearchByFilter(this, block_filter1);
BlockFilter <IMySensorBlock> block_filter2 = BlockFilter <IMySensorBlock> .Create(Me, "*");
sensors = BlockSystem <IMySensorBlock> .SearchByFilter(this, block_filter2);
}
private void Init()
{
MyProperty = new KProperty(this);
MyProperty.Load();
Stage = 0;
bottom_pistons = BlockSystem <IMyPistonBase> .SearchByGroup(this, "Foreuse Bottom Pistons");
bottom_pistons.ForEach(delegate(IMyPistonBase block) {
block.MinLimit = MyProperty.locker_position_min;
block.MaxLimit = MyProperty.locker_position_max;
});
bottom_mergers = BlockSystem <IMyShipMergeBlock> .SearchByGroup(this, "Foreuse Bottom Mergers");
top_pistons = BlockSystem <IMyPistonBase> .SearchByGroup(this, "Foreuse Top Pistons");
top_pistons.ForEach(delegate(IMyPistonBase block) {
block.MinLimit = MyProperty.locker_position_min;
block.MaxLimit = MyProperty.locker_position_max;
});
top_mergers = BlockSystem <IMyShipMergeBlock> .SearchByGroup(this, "Foreuse Top Mergers");
connector = BlockSystem <IMyShipConnector> .SearchByName(this, "Foreuse Connector Drills");
levage_pistons = BlockSystem <IMyPistonBase> .SearchByGroup(this, "Foreuse Levage Pistons");
levage_pistons.ForEach(delegate(IMyPistonBase block) {
block.MinLimit = MyProperty.elevator_position_min;
block.MaxLimit = MyProperty.elevator_position_max;
});
grinder_stator = BlockSystem <IMyMotorStator> .SearchByName(this, "Foreuse Grinder Stator");
grinders = BlockSystem <IMyShipGrinder> .SearchByGroup(this, "Foreuse Grinders");
welder_stator = BlockSystem <IMyMotorStator> .SearchByName(this, "Foreuse Welder Stator");
welders = BlockSystem <IMyShipWelder> .SearchByGroup(this, "Foreuse Welders");
projector = BlockSystem <IMyProjector> .SearchByName(this, "Foreuse Projector Drill");
light = BlockSystem <IMyLightingBlock> .SearchByGroup(this, "Foreuse Rotating Light");
drills = BlockSystem <IMyShipDrill> .SearchByGroup(this, "Foreuse Drills");
control_lcds = BlockSystem <IMyTextPanel> .SearchByName(this, "Foreuse Control LCD");
control_lcds.ForEach(delegate(IMyTextPanel block)
{
block.ContentType = ContentType.TEXT_AND_IMAGE;
});
SequenceBlocks = new List <int>()
{
};
}
private void UnRenamePrefix(string tag)
{
BlockSystem <IMyTerminalBlock> blocks = BlockSystem <IMyTerminalBlock> .SearchBlocks(this);
blocks.ForEach(delegate(IMyTerminalBlock block)
{
if (block.CustomName.StartsWith(tag))
{
block.CustomName = block.CustomName.Replace(tag + " ", "");
}
});
}
private void Prepare()
{
stators = BlockSystem <IMyMotorStator> .SearchByTag(this, MyProperty.Search_Rotor);
pistonUp = BlockSystem <IMyPistonBase> .SearchByTag(this, MyProperty.Search_Piston_Up);
pistonDown = BlockSystem <IMyPistonBase> .SearchByTag(this, MyProperty.Search_Piston_Down);
pistonRayon = BlockSystem <IMyPistonBase> .SearchByTag(this, MyProperty.Search_Piston_Rayon);
drills = BlockSystem <IMyShipDrill> .SearchBlocks(this);
SetTargetValues();
}
private void Display()
{
WriteText($"Machine Mode:{Mode}", false);
WriteText($"Machine Cycle:{Cycle}", true);
if (Sequence != null && Sequence.Count > Stage)
{
WriteText($"Machine Action:{Sequence[Stage]}", true);
}
WriteText($"Machine Stage:{Stage}", true);
BlockSystem <IMyShipConnector> connectors = BlockSystem <IMyShipConnector> .SearchBlocks(this);
float deep = MyProperty.elevator_position_max * connectors.List.Count;
WriteText($"Machine Deep:{deep}", true);
}
private void Search()
{
BlockFilter <IMyBlockGroup> group_filter = BlockFilter <IMyBlockGroup> .Create(Me, MyProperty.filter);
Groups = BlockSystem <IMyBlockGroup> .SearchGroupFilter(this, group_filter);
Airlocks = new List <Airlock>();
if (Groups != null)
{
Groups.ForEach(delegate(IMyBlockGroup group)
{
Airlocks.Add(new Airlock(this, group.Name));
});
}
}
private void Start()
{
bSys = GetComponent <BlockSystem>();
blockData = GetComponent <BlockData>();
blockSelectCounter = 0;
buildModeOn = true;
destroyModeOn = false;
email = username_static.email;
mazeTitle = username_static.mazeTitle;
userId = username_static.userId;
database = GetComponent <DatabaseScript>();
if (!username_static.newMaze)
{
loadBlocks();
}
}
public override Block[,,] GenerateBlocks(BlockSystem localBlockSystem)
{
Block[,,] blocks = new Block[Size, Size, Size];
for (int x = 0; x < Size; x++)
{
for (int y = 0; y < Size; y++)
{
for (int z = 0; z < Size; z++)
{
Block block = Instantiate(BlockPrefab).GetComponent <Block>();
block.Initialize(localBlockSystem, new Int3(x, y, z));
blocks[x, y, z] = block;
}
}
}
return(blocks);
}
private void Search()
{
cockpit = BlockSystem <IMyCockpit> .SearchBlocks(DisplayLcd.program);
thrusts_up = BlockSystem <IMyThrust> .SearchByGroup(DisplayLcd.program, "Thrusters Up");
thrusts_down = BlockSystem <IMyThrust> .SearchByGroup(DisplayLcd.program, "Thrusters Down");
thrusts_left = BlockSystem <IMyThrust> .SearchByGroup(DisplayLcd.program, "Thrusters Left");
thrusts_right = BlockSystem <IMyThrust> .SearchByGroup(DisplayLcd.program, "Thrusters Right");
thrusts_forward = BlockSystem <IMyThrust> .SearchByGroup(DisplayLcd.program, "Thrusters Forward");
thrusts_backward = BlockSystem <IMyThrust> .SearchByGroup(DisplayLcd.program, "Thrusters Backward");
search = false;
}
private void Prepare()
{
BlockFilter <IMyRefinery> filterRefinery = new BlockFilter <IMyRefinery>()
{
CubeGrid = Me.CubeGrid
};
refinery = BlockSystem <IMyRefinery> .SearchByFilter(this, filterRefinery);
refinery.ForEach(delegate(IMyRefinery block)
{
block.UseConveyorSystem = false;
});
BlockFilter <IMyCargoContainer> filterContainer = new BlockFilter <IMyCargoContainer>()
{
Filter = "Ore",
CubeGrid = Me.CubeGrid
};
stock = BlockSystem <IMyCargoContainer> .SearchByFilter(this, filterContainer);
}
void RunContinuousLogic()
{
if (search)
{
Search();
}
WriteText($"LCD found: {(lcds != null ? lcds.List.Count : 0)}", false);
BlockFilter <IMyThrust> block_filter = BlockFilter <IMyThrust> .Create(Me, "C:Up");
BlockSystem <IMyThrust> thrust = BlockSystem <IMyThrust> .SearchByFilter(this, block_filter);
if (!thrust.IsEmpty)
{
ParserInfo parser = new ParserInfo(this);
IMyThrust block = thrust.First;
parser.ParserTitle(block);
parser.ParserTerminalBlock(block);
parser.ParserThrust(block);
parser.ParserCubeBlock(block);
}
}
public Program()
{
MyProperty = new KProperty(this);
MyProperty.Load();
drawingSurface = Me.GetSurface(0);
drawingSurface.ContentType = ContentType.TEXT_AND_IMAGE;
Runtime.UpdateFrequency = UpdateFrequency.Update100;
lat_stators = BlockSystem <IMyMotorStator> .SearchByName(this, MyProperty.Name);
if (!lat_stators.IsEmpty)
{
lon_stators = BlockSystem <IMyMotorStator> .SearchByGrid(this, lat_stators.First.Top.CubeGrid);
solar_panels = new BlockSystem <IMySolarPanel>();
foreach (IMyMotorStator lon_stator in lon_stators.List)
{
solar_panels.Merge(BlockSystem <IMySolarPanel> .SearchByGrid(this, lon_stator.Top.CubeGrid));
}
}
}
public void Search()
{
BlockFilter <IMyDoor> block_filter_doors = BlockFilter <IMyDoor> .Create(program.Me, $"G:{GroupFilter}");
doors = BlockSystem <IMyDoor> .SearchByFilter(program, block_filter_doors);
BlockFilter <IMyAirVent> block_filter_airvent = BlockFilter <IMyAirVent> .Create(program.Me, $"G:{GroupFilter}");
airvent = BlockSystem <IMyAirVent> .SearchByFilter(program, block_filter_airvent);
BlockFilter <IMyTextPanel> block_filter_control = BlockFilter <IMyTextPanel> .Create(program.Me, $"G:{GroupFilter}");
control_panel = BlockSystem <IMyTextPanel> .SearchByFilter(program, block_filter_control);
BlockFilter <IMyLightingBlock> block_filter_light = BlockFilter <IMyLightingBlock> .Create(program.Me, $"G:{GroupFilter}");
light = BlockSystem <IMyLightingBlock> .SearchByFilter(program, block_filter_light);
BlockFilter <IMySoundBlock> block_filter_sound = BlockFilter <IMySoundBlock> .Create(program.Me, $"G:{GroupFilter}");
sound = BlockSystem <IMySoundBlock> .SearchByFilter(program, block_filter_sound);
if (control_panel != null)
{
control_panel.ForEach(delegate(IMyTextPanel block)
{
block.ScriptBackgroundColor = Color.Black;
});
}
if (light != null)
{
light.ForEach(delegate(IMyLightingBlock block)
{
block.Color = program.MyProperty.GetColor("Airlock", "running_color");
});
light.Off();
}
}
/* public static void BreakHighestBlockAtRangeFromLocation(Int3 origin, Int3 direction, int range)
* {
* Int3 target = BlockSystemManager.Instance.AlignedSystem.GetLocationAtRange(origin, direction, range);
* Int3? highestSolidTarget = BlockSystemManager.Instance.AlignedSystem.GetHighestSolidLocation(target);
*
* if (highestSolidTarget)
* {
* BlockSystemManager.Instance.AlignedSystem.Break((Int3)highestSolidTarget);
* }
* } */
public static void RandomlyDissolveTopLayer(BlockSystem blocks, float percentage, float duration)
{
List <Int3> toBreak = new List <Int3>();
for (int x = 0; x < blocks.GetDimensions().x; x++)
{
for (int z = 0; z < blocks.GetDimensions().z; z++)
{
Int3?highest = blocks.GetHighestSolidLocation(x, z);
if (Random.value > percentage && highest)
{
toBreak.Add((Int3)highest);
}
}
}
foreach (Int3 block in toBreak)
{
CardEffectController.Instance.StartCoroutine(Coroutines.WaitThen(Random.value * duration, () =>
{
blocks.Break(block);
}));
}
}
public Vector2 Draw(Drawing drawing, Vector2 position)
{
if (!enable)
{
return(position);
}
List <string> types = new List <string>();
if (tank_h2)
{
types.Add("Hydrogen");
}
if (tank_o2)
{
types.Add("Oxygen");
}
if (types.Count > 0)
{
foreach (string type in types)
{
BlockSystem <IMyGasTank> tanks = BlockSystem <IMyGasTank> .SearchBlocks(DisplayLcd.program, block => block.BlockDefinition.SubtypeName.Contains(type));
float volumes = 0f;
float capacity = 0f;
float width = 50f;
StyleGauge style = new StyleGauge()
{
Orientation = SpriteOrientation.Horizontal,
Fullscreen = true,
Width = width,
Height = width,
Padding = new StylePadding(0),
Round = false,
RotationOrScale = 0.5f
};
MySprite text = new MySprite()
{
Type = SpriteType.TEXT,
Color = Color.DimGray,
Position = position + new Vector2(0, 0),
RotationOrScale = 1f,
FontId = drawing.Font,
Alignment = TextAlignment.LEFT
};
tanks.ForEach(delegate(IMyGasTank block)
{
volumes += (float)block.FilledRatio * block.Capacity;
capacity += block.Capacity;
});
drawing.DrawGauge(position, volumes, capacity, style);
position += new Vector2(0, 60);
switch (type)
{
case "Hydrogen":
text.Data = $"H2: {Math.Round(volumes, 2)}L / {Math.Round(capacity, 2)}L";
break;
case "Oxygen":
text.Data = $"O2: {Math.Round(volumes, 2)}L / {Math.Round(capacity, 2)}L";
break;
}
text.Position = position;
drawing.AddSprite(text);
position += new Vector2(0, 60);
}
}
return(position);
}
private void Search()
{
BlockFilter <IMyThrust> block_thrusters_filter = BlockFilter <IMyThrust> .Create(program.Me, thrusters_filter);
thrusters = BlockSystem <IMyThrust> .SearchByFilter(program, block_thrusters_filter);
}
public override Block[,,] GenerateBlocks(BlockSystem AlignedBlockSystem)
{
Transform smallerTransform = BlockSystemManager.Instance.PlayerSystem.GetDimensions().x < BlockSystemManager.Instance.EnemySystem.GetDimensions().x ? BlockSystemManager.Instance.PlayerSystem.transform : BlockSystemManager.Instance.EnemySystem.transform;
// Positive vs negative is a bit more generic than left/right or up/down
BlockSystem positiveSide = null;
BlockSystem negativeSide = null;
Int3 dimensions = new Int3(0, 0, 0);
Int3 positiveDimensions = new Int3(0, 0, 0);
Int3 negativeDimensions = new Int3(0, 0, 0);
int positiveAlignmentOffset = 0;
int negativeAlignmentOffset = 0;
switch (AlignmentEdge)
{
case Alignment.PlayerPositiveXToEnemyNegativeX:
positiveSide = BlockSystemManager.Instance.PlayerSystem;
negativeSide = BlockSystemManager.Instance.EnemySystem;
positiveDimensions = positiveSide.GetDimensions();
negativeDimensions = negativeSide.GetDimensions();
dimensions = new Int3(positiveDimensions.x + negativeDimensions.x,
Math.Max(positiveDimensions.y, negativeDimensions.y),
Math.Max(positiveDimensions.z, negativeDimensions.z));
if (positiveDimensions.z < negativeDimensions.z)
{
positiveAlignmentOffset = Mathf.FloorToInt(negativeDimensions.z / 2) - Mathf.FloorToInt(positiveDimensions.z / 2);
}
else if (positiveDimensions.z > negativeDimensions.z)
{
negativeAlignmentOffset = Mathf.FloorToInt(positiveDimensions.z / 2) - Mathf.FloorToInt(negativeDimensions.z / 2);
}
if (DrawDebugCubes)
{
smallerTransform.localPosition += new Vector3(-smallerTransform.GetComponent <BlockSystem>().GetDimensions().x, 0, 0);
transform.localPosition += new Vector3(-smallerTransform.GetComponent <BlockSystem>().GetDimensions().x, 0, 0);
}
break;
case Alignment.PlayerPositiveZToEnemyNegativeZ:
positiveSide = BlockSystemManager.Instance.PlayerSystem;
negativeSide = BlockSystemManager.Instance.EnemySystem;
positiveDimensions = positiveSide.GetDimensions();
negativeDimensions = negativeSide.GetDimensions();
dimensions = new Int3(Math.Max(positiveDimensions.x, negativeDimensions.x),
Math.Max(positiveDimensions.y, negativeDimensions.y),
positiveDimensions.z + negativeDimensions.z);
if (positiveDimensions.x < negativeDimensions.x)
{
positiveAlignmentOffset = Mathf.FloorToInt(negativeDimensions.x / 2) - Mathf.FloorToInt(positiveDimensions.x / 2);
}
else if (positiveDimensions.x > negativeDimensions.x)
{
negativeAlignmentOffset = Mathf.FloorToInt(positiveDimensions.x / 2) - Mathf.FloorToInt(negativeDimensions.x / 2);
}
if (DrawDebugCubes)
{
smallerTransform.localPosition += new Vector3(0, 0, -smallerTransform.GetComponent <BlockSystem>().GetDimensions().z);
transform.localPosition += new Vector3(0, 0, -smallerTransform.GetComponent <BlockSystem>().GetDimensions().z);
}
break;
case Alignment.EnemyPositiveXToPlayerNegativeX:
positiveSide = BlockSystemManager.Instance.EnemySystem;
negativeSide = BlockSystemManager.Instance.PlayerSystem;
positiveDimensions = positiveSide.GetDimensions();
negativeDimensions = negativeSide.GetDimensions();
dimensions = new Int3(positiveDimensions.x + negativeDimensions.x,
Math.Max(positiveDimensions.y, negativeDimensions.y),
Math.Max(positiveDimensions.z, negativeDimensions.z));
if (positiveDimensions.z < negativeDimensions.z)
{
positiveAlignmentOffset = Mathf.FloorToInt(negativeDimensions.z / 2) - Mathf.FloorToInt(positiveDimensions.z / 2);
}
else if (positiveDimensions.z > negativeDimensions.z)
{
negativeAlignmentOffset = Mathf.FloorToInt(positiveDimensions.z / 2) - Mathf.FloorToInt(negativeDimensions.z / 2);
}
if (DrawDebugCubes)
{
smallerTransform.localPosition += new Vector3(-smallerTransform.GetComponent <BlockSystem>().GetDimensions().x, 0, 0);
transform.localPosition += new Vector3(-smallerTransform.GetComponent <BlockSystem>().GetDimensions().x, 0, 0);
}
break;
case Alignment.EnemyPositiveZToPlayerNegativeZ:
positiveSide = BlockSystemManager.Instance.EnemySystem;
negativeSide = BlockSystemManager.Instance.PlayerSystem;
positiveDimensions = positiveSide.GetDimensions();
negativeDimensions = negativeSide.GetDimensions();
dimensions = new Int3(Math.Max(positiveDimensions.x, negativeDimensions.x),
Math.Max(positiveDimensions.y, negativeDimensions.y),
positiveDimensions.z + negativeDimensions.z);
if (positiveDimensions.x < negativeDimensions.x)
{
positiveAlignmentOffset = Mathf.FloorToInt(negativeDimensions.x / 2) - Mathf.FloorToInt(positiveDimensions.x / 2);
}
else if (positiveDimensions.x > negativeDimensions.x)
{
negativeAlignmentOffset = Mathf.FloorToInt(positiveDimensions.x / 2) - Mathf.FloorToInt(negativeDimensions.x / 2);
}
if (DrawDebugCubes)
{
smallerTransform.localPosition += new Vector3(0, 0, -smallerTransform.GetComponent <BlockSystem>().GetDimensions().z);
transform.localPosition += new Vector3(0, 0, -smallerTransform.GetComponent <BlockSystem>().GetDimensions().z);
}
break;
}
Block[,,] blocks = new Block[dimensions.x, dimensions.y, dimensions.z];
for (int x = 0; x < dimensions.x; x++)
{
for (int y = 0; y < dimensions.y; y++)
{
for (int z = 0; z < dimensions.z; z++)
{
if (x < positiveDimensions.x && y < positiveDimensions.y && z < positiveDimensions.z)
{
if ((AlignmentEdge == Alignment.PlayerPositiveXToEnemyNegativeX || AlignmentEdge == Alignment.EnemyPositiveXToPlayerNegativeX) &&
z + positiveAlignmentOffset < dimensions.z)
{
blocks[x, y, z + positiveAlignmentOffset] = positiveSide.GetBlockByLocation(x, y, z);
}
else if ((AlignmentEdge == Alignment.PlayerPositiveZToEnemyNegativeZ || AlignmentEdge == Alignment.EnemyPositiveZToPlayerNegativeZ) &&
x + positiveAlignmentOffset < dimensions.x)
{
blocks[x + positiveAlignmentOffset, y, z] = positiveSide.GetBlockByLocation(x, y, z);
}
}
else if (x >= positiveDimensions.x && y < negativeDimensions.y && z < negativeDimensions.z && (AlignmentEdge == Alignment.PlayerPositiveXToEnemyNegativeX || AlignmentEdge == Alignment.EnemyPositiveXToPlayerNegativeX))
{
if (z + negativeAlignmentOffset < dimensions.z)
{
blocks[x, y, z + negativeAlignmentOffset] = negativeSide.GetBlockByLocation(x - positiveDimensions.x, y, z);
}
}
else if (x < negativeDimensions.x && y < negativeDimensions.y && z >= positiveDimensions.z && (AlignmentEdge == Alignment.PlayerPositiveZToEnemyNegativeZ || AlignmentEdge == Alignment.EnemyPositiveZToPlayerNegativeZ))
{
if (x + negativeAlignmentOffset < dimensions.x)
{
blocks[x + negativeAlignmentOffset, y, z] = negativeSide.GetBlockByLocation(x, y, z - positiveDimensions.z);
}
}
if (blocks[x, y, z] != null)
{
blocks[x, y, z].AlignedLocation = new Int3(x, y, z);
}
else if (DrawDebugCubes)
{
Block block = Instantiate(DebugBlockPrefab).GetComponent <Block>();
block.Initialize(AlignedBlockSystem, new Int3(x, y, z));
block.AlignedLocation = new Int3(x, y, z);
blocks[x, y, z] = block;
}
}
}
}
return(blocks);
}
void Start()
{
instance = this;
Debug.Log("Initializing inventory");
buildingSystem = GameObject.FindGameObjectWithTag("BlockManager").GetComponent <BuildingSystem>();
//Debug.Log("got BuildingSystem");
blockSystem = GameObject.FindGameObjectWithTag("BlockManager").GetComponent <BlockSystem>();
//Debug.Log("got BuildingSystem");
numAvailableSlots = Math.Min(totalSlots, blockSystem.allBlocks.Count);
//numAvailableQuickSlots = Math.Min(totalQuickSlots, numAvailableSlots);
numAvailableQuickSlots = totalQuickSlots;
numOfCategories = categories.transform.childCount;
slots = new Slot[numOfCategories, numAvailableSlots];
quickSlots = new Slot[numAvailableQuickSlots];
Debug.Log("All slots = " + numAvailableSlots + " quick slots = " + numAvailableQuickSlots);
for (int i = 0; i < numAvailableSlots; i++)
{
slots[activeCategory, i] = slotHolder.transform.GetChild(i).GetComponent <Slot>();
slots[activeCategory, i].isQuickSlot = false;
if (i < blockSystem.allBlocks.Count)
{
slots[activeCategory, i].SetItem(blockSystem.allBlocks[i]);
}
}
/*
* for (int i = numAvailableSlots; i < totalSlots; i++)
* {
* GameObject go = slotHolder.transform.GetChild(i).gameObject;
* go.SetActive(false);
* }
*/
Debug.Log("post slotHolder");
for (int i = 0; i < numAvailableQuickSlots; i++)
{
quickSlots[i] = quickInventory.transform.GetChild(i).GetComponent <Slot>();
quickSlots[i].isQuickSlot = true;
quickSlots[i].slotIndex = i;
if (i < blockSystem.allBlocks.Count)
{
quickSlots[i].SetItem(blockSystem.allBlocks[i]);
}
}
/*
* for (int i = numAvailableQuickSlots; i < totalQuickSlots; i++)
* {
* GameObject go = quickInventory.transform.GetChild(i).gameObject;
* go.SetActive(false);
* }
*/
Debug.Log("post quickSlots");
activeQuickSlot = quickSlots[0];
Image anImage = activeQuickSlot.GetComponent <Image>();
unselectedColor = anImage.color;
anImage.color = selectedColor;
Debug.Log("Initialize Done");
}
private void Start()
{
blockSystem = GetComponent <BlockSystem>();
}
private void Start()
{
bSys = GetComponent <BlockSystem>();
blockSelectCounter = 0;
}
private void Search()
{
BlockFilter <IMyTextPanel> block_filter = BlockFilter <IMyTextPanel> .Create(program.Me, lcd_filter);
lcds = BlockSystem <IMyTextPanel> .SearchByFilter(program, block_filter);
}
