View this post on logicworld.net

Welcome to the very first Logic World Wednesday! Each week, we will be sharing our progress on Logic World. This blog is going to be a mix of technical and non-technical discussion.

Jimmy

This week I added a feature I call multi-wire placing. In Logic World you create wires by clicking on two pegs to connect them. Often, however, you need to create many wires going in the same direction; think data busses. This can become tedious very easily.

One of our goals with Logic World is to make building as non-tedious as possible. That’s where multi-wire placing comes in. With MWP, you select two groups of pegs, and connections are created between the groups in the order you selected them.

This is kind of difficult to explain with text, so here’s a video showcasing the mechanic:

I also added Exclusive Inputs. Normally, inputs in Logic World can both receive and propagate signal. But this can be undesirable; if you have several wires feeding into an input, you might not want signal to travel between them.

Every input in Logic World can now be toggled between exclusive and non-exclusive mode. In exclusive mode, inputs can only receive signal - they cannot propagate it. This allows you to make complex circuits very space-efficient, since you no longer need to build special gates where you only want the signal to go one way.

If you’ve been following Logic World for a long time, you might remember me talking about Multi-Wire Placing and Exclusive Inputs in the past. I had both of these features working in October of last year. In November, however, we scrapped almost all of the code we’d already written for LW. The game was rebuilt from the ground up in a completely different way which is much more performant and which allows for multiplayer. So this week I re-implemented multi-wires and exclusive inputs under the new system.

Finally, I’ve been working on a longer form video that shows off the performance of the game. It’s called “Counting to a Billion in Binary” - look out for that later this week.

Felipe (aka pipe01)

I’d like to introduce you into some concepts of the modding system. For the first ever edition of LWW, I’ll give you a quick overview of how the modding system works and how it doesn’t. First of all, mods can contain both code (component logic, like what a component should do when one of its inputs gets turned on) and other assets (how a component looks like, etc). Inside the code part of the mod there is another separation: server and client code. Server code handles the aforementioned component logic, while client code controls how the component looks to the camera (Should it change color? Should it grow legs?). These two parts can also share some simple data structures, for example to store how many legs it has.

On a more technical remark for those of you that “do the code”, this data is represented as a POCO (Plain Old CLR Object) in both the client and the server, which means that the synchronization of this data between both sides is completely transparent to the modder, making it extremely easy to add custom states to components. Components declare their data through a C# interface, which gets implemented at runtime using a handy library I wrote specifically for this called ClassImpl.

Separate from the code and inside of the previously mentioned mod assets are the component definitions, contained in a SUCC file in the mod package. This format is the exact same one we use for the stock game components (like the inverter), so you can be sure that you’ll be able to do everything the existing components already do, and even more! Here you’ll define the shape of a component and the code behind them, as well as how many inputs and outputs it has and where they are positioned. This gives you flexibility to create cool and odd-looking components with as many inputs and outputs as you want and that behave exactly the way you want them to. For example, here’s the SUCC section for a regular inverter:

Tung.Inverter:
    column: "Logic"
    prefab:
        blocks:
            - Standard
        inputs:
            -
                position: (0, 1, 0)
        outputs:
            -
                position: (0, 0.5, 0.5)
                rotation: (90, 0, 0)
                startOn: true
        logicCode: Tung.LogicCode.Inverter
    placingRules:
        GridPlacingDimensions: (1, 2)

That’s all for this week. If you’d like to receive an email each time we post one of these blogs, you can sign up for our newsletter. Be sure also to join the official Discord and follow @LogicWorldGame on twitter.

See you next Wednesday!