Read by Council Grid based logic computer system

[GRHayes]

If you want the biggest reason to condense stuff into a logic computer or terminal system and do something like the OP says or ladder logic as I suggested such as a PLC is it would get rid of most of the lagg caused by logic blocks. Talking 99% of it.

 

[Parameter]

I think Raisinbat and, to a lesser extent others, are missing how useful compacting logic into a smaller footprint is.

Take a couple of examples:
- I wanted to make something akin to a star wars speeder for kicking around planets. It was small, less than 200 blocks, but had seating for 3, overdrive, and a cool rotating forcefield fan underneath it. Because of the scale, I had to sacrifice looks to fit in the logic for automatically starting and stopping the fan, running lights, etc., when you got on and off the craft. Being able to condense even 3-4 blocks into one would have made the build much sleeker.

- I was making modular space station components based on 11x11x11 cubes. The EVA airlock module I was working on needed about half that volume for an astronaut walkway into the station. Laying out the logic for the airlock features (auto-open/close, delays, lighting changes, etc.) was a huge pain because I had to pack it into a fairly small space. I had to re-layout the logic blocks several times to avoid showing wires and ended up having to turn two portholes into "ventilation stacks" to hide the logic from the player. Having a computer block to lay the logic out in would have saved me 20 minutes of frustration.

- I'm working on a derelict ship "play set" that I can use to make spawnable interactive areas for astronauts to explore. The ship is a good size (~300m long), so I have room for logic. However, laying out the logic for zone-based control of lighting, boot sequences for power & shield generators, security lock-down, psuedo-random generators, etc. takes a _lot_ of space to keep organized, even apart from routing it through the ship. All that space for logic needs to be out of reach of the astronaut, which means a good-sized chunk of my ship isn't open for exploration. Being able to condense functions into a computer block would both free up additional space for exploration, and make it much easier to organize and maintain the logic systems themselves.

Compacting logic into circuit or computer blocks makes it easier to read follow, not harder, especially if you can name the circuit block like ship remotes. I would much rather look at a circuit block an see it's named Adder than have to trace the logic connections between blocks on my ship to figure it out.

Also, more than once I've fat-fingered logic connections and had to debug the entire logic tree I was in to make sure I hadn't screwed up a connection I had put in earlier. If I had been able to encapsulate different functions in circuit blocks it would have been a lot harder for me to mess up connections in unrelated but nearby logic circuits.

Regardless of how it's implemented from a player interface standpoint, being able condense logic into a computer block of some kind allows players to do more in the game. If you don't like them, you could continue to build sprawling logic systems on your ships. I think a lot of players, however, would appreciate an easier way of doing things.

 

[lilheartless]

I think Raisinbat and, to a lesser extent others, are missing how useful compacting logic into a smaller footprint is.

Take a couple of examples:
- I wanted to make something akin to a star wars speeder for kicking around planets. It was small, less than 200 blocks, but had seating for 3, overdrive, and a cool rotating forcefield fan underneath it. Because of the scale, I had to sacrifice looks to fit in the logic for automatically starting and stopping the fan, running lights, etc., when you got on and off the craft. Being able to condense even 3-4 blocks into one would have made the build much sleeker.

snip

Exactly this no one is saying that you just can't use the regular logic anymore if you want to keep doing that so be it but for the rest of us that like to include logic in lots of things it would be nice if we could just have a block that lets us condense it down.

 

[Valck]

Exactly this no one is saying that you just can't use the regular logic anymore [...]

except

[...] the tears of everyone with current awesome logic circuits when all their blocks are removed from the game eventually.

Now I may be misunderstanding this, but in that context I read "gj biddles brilliant as usual" as "replace the current system". Which I wouldn't vote for.

 

[lilheartless]

except

Now I may be misunderstanding this, but in that context I read "gj biddles brilliant as usual" as "replace the current system". Which I wouldn't vote for.

hmh ur right that that is what the op says now although i'm not entirely sure thats what it always said.... maybe i'm thinking of a different thread ... anyways i'm not for removing the logic blocks entirely we already have them they are already integrated into probably tens of thousands of designs and i don't want them removed i just would like a way ... moving forward to condense all my logic for future builds.

 

[Valck]

hmh ur right that that is what the op says now although i'm not entirely sure thats what it always said....

Considering that it hasn't been edited since it was first posted, I'm pretty certain it is what it always said.

 

[lilheartless]

Considering that it hasn't been edited since it was first posted, I'm pretty certain it is what it always said.

I followed it up with maybe i'm thinking of a different thread what do you even want from me......

 

[BDLS]

Always said that, no edit.

Also, I'd like to flip-flop (HEH) on my stance for removing the old system if this was introduced. Unless we REALLY needed those block IDs some day, I agree it would be pretty annoying for people's old logicstuffs to just disappear one update.

 

[Valiant70]

There is no need to remove the original logic blocks.

That said, there is every reason to implement this system or something similar as it would undeniably benefit a lot of players. There is also no reason NOT to implement such a system provided that current builds don't break.

 

[NeonSturm]

Spoiler: What I've read and agree with - the fruits of this thread!

You wouldn't be limited by the columns and rows. They are simply there for uniformity in the GUI. You can bind whatever/wherever to whatever/wherever. A circuit is easier to design in 2D.



1) Mass comes at a premium in starmade, especially on smaller ships. Having any sort of messy looking complicated circuit on a fighter cripples it/is impossible. It's kind of silly to add a bunch of mass with full sized blocks that should be a super small controller (like a bunch of delay blocks).
2) meh
3) It would at least look a lot cleaner and be easier to modify. Like looking at an automobile's wiring diagram.

edit:
You shouldn't have to have this (from another thread):

I didn't mean that the tiles would have to be right next to each other by "grid-based", I could see how that would be confusing. Just that the tiles would be aligned to a grid for organization purposes. You'd have lines connecting what you wanted, you could freely space stuff like a wiring diagram.

Building and wiring logic for very small or very large projects can be messy and very constraining on design. What if there was a general purpose compute block for combinatorial logic?

The idea bouncing around my head was to place a single block, skinned like a computer terminal. I could hit 'R' to enter the block like a ship core, only instead of a ship build mode, I would be in a "Compute-Space" where I could build logic. I could build as complicated logic as I'd like, using as much space for organization as I needed, and then designate one (or hopefully more!) blocks as 'Outputs'.

When I exited compute space, I could c-v the compute block to what I wanted to actuate (maybe hitting 'c' on the compute block would cycle through different outputs?)

This block would accomplish several things.

1. Logic would be more compact, making it easier to integrate into small craft or organize large project
2. You could potentially save precious block IDs. Some of today's logic blocks might only exist in Compute-Space. Compute-space blocks might not need blocks IDs, or have a different list of block IDs, or just be 2D tiles, etc. You could add as many new logic blocks as you'd like and not affect the world block ID count.
   
3. Compute blocks could optimize logic calculations. When a user exits compute mode, the game creates a BooleanLogic object under the hood to call instead of simulating logic blocks.
4. Provides a pathway for more complicated player automation. You could even add some higher-level logic or routines and let players write their own tiny programs or even AI

This is the future, not 1970. There's no reason a simple function should take a warehouse size PC to process.

You say that, yet people learned how to do the same thing with redstone. Redstone required ludicrous setups just to get the logic blocks we already have, which is a big upgrade. I would say something like this is entirely possible. At the least it would be moddable. The issue is allowing a single block to act as if it is multiple inputs and outputs. I have an elevator system that determines when doors open and close based on where the elevator is on the rail. That requires at least 2 inputs. That is where this system gets a bit confusing. Still it is entirely viable if you want to condense a circuit down to a single block, but only if the issues I brought fourth are addressed. I am sure schema would have some input as well.

Just as PLC programmers aren't likely to require a SPICE simulation of the systems they program, gamers desiring logic for their video games aren't likely to require the level of design knowledge even something like ladder logic would require. In Starmade, I think it's sufficient to provide high level logical functionality to players using Schine's existing system, but with some mechanism for compacting and/or encapsulating logical blocks for easier circuit layout and scalability.

From what i can tell the plus-points boils down to three reasons:

1. I want more logic on small builds
2. This makes logic easier to represent/read
3. It's realistic!

I think there are a lot of valid arguments here.

• My main wish is to have a smaller footprint for logic in my ships.
• I like the existing way we configure logic in 3D space, which is why I would like to continue using it in a mini game inside a computer block.
• A 2D view would be handy, but when thinking of existing circuit diagrams they can stretch out a fair bit. But this would make it much easier for electrical engineers and could be useful for quick diagnostic and analysis of a circuit layout. Lets face it, our logic is pretty much integrated circuitry. Starmade moves away from flat circuit boards an gives us the awesome freedom to build it in 3D space in real-time, which I absolutely love. And in reality, this is how people are going to print their DIY home made technology on their 3D printers, not to mention the manufacturing industry. Which has pretty much been doing that with Microprocessors, memory circuits and most cosumer products anyway.
• Having relay/in/out connectors on a computer block would allow for mechanical control of rails, switches and other computers like the weapons, effect and whatever else comes up in future.
• Scripting would indeed make it quicker to configure, and perhaps a compromise could be reached where we could change the meta-data for the computer logic at the XML file level.

I think Raisinbat and, to a lesser extent others, are missing how useful compacting logic into a smaller footprint is.

[...Examples...]

Compacting logic into circuit or computer blocks makes it easier to read follow, not harder, especially if you can name the circuit block like ship remotes. I would much rather look at a circuit block an see it's named Adder than have to trace the logic connections between blocks on my ship to figure it out.

Also, more than once I've fat-fingered logic connections and had to debug the entire logic tree I was in to make sure I hadn't screwed up a connection I had put in earlier. If I had been able to encapsulate different functions in circuit blocks it would have been a lot harder for me to mess up connections in unrelated but nearby logic circuits.

Regardless of how it's implemented from a player interface standpoint, being able condense logic into a computer block of some kind allows players to do more in the game. If you don't like them, you could continue to build sprawling logic systems on your ships. I think a lot of players, however, would appreciate an easier way of doing things.

One issue in programming is that you separate it into multiple files.

In StarMade's 3D-environment logic, you see these connections.​

The other is that the deeper code branches are hidden behind a function-name-hyperlink. They are not shown directly.

Today we are still writing "modern assembler".

The future belongs to documentations which are executed directly.
And the programmer only needs to specify the things the compiler is unsure about –cases that are not covered, ...– and check all the other code branches the compiler generated in a visual representation of what we today call programming language.​

We need a program editor which

• shows functions as blocks in 3D space
• shows contents of these blocks as easy as opening a folder in your file-browser - automatically show more content when you zoom in.
• parallelizes stuff like a RAM/Cache-module for an ingame computer or password storage.
• assists users (see below)

Also, we have 2016 soon and it is time for some better visualization of connections between code and documentation.

• Open the hangar door when a ship approaches. Background-work:
  • Open ... door -> definition how to open
  • the hangar door -> a selection of the hangar door to open
  • ... when ... -> #1=Event #2=EventTrigger
  • a ship approaches -> definition of Event "approaches" -> other program module.

Also, it is time for a better organisation of what exists.

Spoiler: Variable-aliases and searching for functions

ModulName

_search tags

MathRanges : range *math
TreeNode : tree /node, hierarchical /structure

+inclusive /redundant *specify -exclusive​

MathRanges

_variables

min : "lower", "low", "lo", ("n" +"v" +"m"), "min"
v : "value", "val", "v", /"x"
max : "higher", "upper", "hi", ("m" +"v" +"n"), "max"​

TreeNode

_variables

parent : "parent", "pa", "p" -"n"
previous : "previous", "prev", "pre", "p" +"n"
next : "next", "nx", "n" +"p"​

_before

pa ← this
pa → list →{..., this, ...}
pre ←→ this ←→ next​

_after

pa ← this
pa → list →{..., this, next, ...}
pre ←→ this ←→ next ←→ next​

Look at the variable name alias in the spoiler above! When this is spoiled into code from upper hierarchy levels, it could adapt variable names in it to the upper level's context without changing the functionality.

Instead of writing what should be done when 1 variable in a+b=c changes, we should write:

_variables

a, b, c​

_variable connections

a + b = c​

_functions *search inversions

(va + vb = vc) equals {(vc - va = vb), (vc - vb = va)}

'search *distance' increases by 2 'cpu cycles'​

 

[Raisinbat]

That said, there is every reason to implement this system or something similar as it would undeniably benefit a lot of players. There is also no reason NOT to implement such a system provided that current builds don't break.

Finite development time is a reason. There are more important things to add than a big, convoluted secondary logic system:

• lasers dont work
• no target leading
• ai doesnt work
• no world simulation yet
• no real point ingame, you just make cool ships

I still stand by keeping logic in the blocks and not as metadata; even if the 2D approach might be more convenient. Im sure its also more convenient to make ships in 3Dstudio max: No restrictions on shape, curves or tiny details, and yet you're playing starmade instead. Don't forget this is a game not a modelling tool.

 

[kiraen]

Since the engine will be using LUA for several things, I'm wondering why we don't just go straight to an actual programmable computer. All the logic blocks are fun to mess around with, to a point. But really, this is supposed to be futuristic. I like the grid based logic as a middle ground, but frankly I'd rather have something more like ComputerCraft.

 

[BDLS]

snip

Fam, this is the suggestions forum. Not the "complain about development time being used for features instead of fixing bugs forum." All the suggestions in here aren't saying DO THIS NOW (usually).

You can't use pretty 3ds max models in a game like starmade anyway, what's your point? Doesn't mean that logic shouldn't be compacted to make more sense, whether using this suggestion or the other ones suggested in here.

Using big ass blocks in your ship for logic functions is lame.

 

[Ithirahad]

Finite development time is a reason. There are more important things to add than a big, convoluted secondary logic system:

• lasers dont work

Fixed

• no target leading

Is this that important?

• ai doesnt work

Space AI will probably be fixed when Schema adds NPC piloting. BOBBY AI will probably continue to suck, but NPC pilot AI will probably be much better and more adaptable.

Ground/NPC AI will be worked on very soon.

• no world simulation yet

Not sure what you mean by this.

• no real point ingame, you just make cool ships

Will be addressed "relatively soon," from what I've heard, a faction update is planned which will include a lot more 'goal' for the game, and PvE will be improved with quests and better AI sometime soom as well.

I still stand by keeping logic in the blocks and not as metadata; even if the 2D approach might be more convenient. Im sure its also more convenient to make ships in 3Dstudio max: No restrictions on shape, curves or tiny details, and yet you're playing starmade instead. Don't forget this is a game not a modelling tool.

...And this is a reason why logic should remain in blocks... why? This is indeed a game, not a modelling tool, so instead of logic taking up tons of space, wouldn't it be great if we could have, y'know, actual game stuff in there? Like systems, or interior, or... maybe just a bit of space to trim down the hull?

 

[Gunseng]

Great idea, reminds me of a couple minecraft mods. It'd be nice if there were also premade "stamps" like a simple Clock you can stamp down on the grid to make it less "intimidating."

 

[Viridis00]

I still stand by keeping logic in the blocks and not as metadata

Why not both?

 

[the_Grey_Sky]

Since the engine will be using LUA for several things, I'm wondering why we don't just go straight to an actual programmable computer.

It has been stated many times the reason as to not go strait into a Programing language.

Rasinbat if you don't like progress go play a legacy build.

Also I see no reason to remove the curant system, allowing a simple compact addition can only improve the game.
Also all logic should be 0 mass, 0 hp.

1+ for compact logic.

 

[kiraen]

Yeah, necro.

 

[lupoCani]

Perhaps. Still, I would think it remains relevant.

I'll repeat what I said in the other thread about this on the front page right now- as long as we also get to program properly in a text interface, I'm fine with any middle-ground visual systems that are implemented to accommodate the less script-inclined majority. Text scripting has it's issues, but you ultimately just cannot compare the inherent potential. Logic, both in the form of blocks and the various graphics suggested, is certainly powerful, but the good stuff- mechas, centralized trading systems, automatic factory management, custom AI, single-degree precision with rail rotors, automated parking lots with guard drones and millitary action against ships that overstay their welcome, jump drive taxis, the McKay-Carter gate bridge, et cetera, remains with proper scripting.

So, give us logic for the simple stuff, give us single-block compact logic for the non-programmers, and give us programming for the true potential of automation.

 

[wanzer]

this grid like system allows another interesting thing
for people that understand class based programing

a set of logics in a encapsulated tile that can be used on its own in yet another tile

a class within a class within a class