Siloed

Very much based off the Bomb game we played at Bells, just want to explore the concept in a different direction.

I'm dropping the 'Silo' theme, instead, every player has a 'Win' panel, which is simply a label and a green LED. When all win panels are active (simultaneously) the game is won.

Terminology

• Char: a recognizable character (ascii 32-126)
• Glyph: an unrecognizable character, randomly generated
• Symbol: either a char or glyph
• Code: a string of random, chars
• Cipher: One or more glyphs that must be looked up in the correct cipher table to be interpreted
• ID: a meaningful string of chars ("Gimble-12", "+12v" or "Cancel"), every connection in the game has an ID
• Label: Either a code, cipher or ID displayed to the user, the inputs and outputs of every component is labeled.
• Sequence: User input to a keypad
• LED: A small light. They can be red, green, blue or yellow. They can be on, off or blinking.
• Indicator: A pair of leds, one red, one green. It will only be in one of three states - r, g, off. Indicators are not used for convolution, they always mean the same thing. A green light means the control is powered and active, a red light means the control is powered but locked and no indicator means the control is unpowered.
• Power: Ground, and various AC and DC voltage and current sources.
• Data: Any sort of data that gets moved around. Pulse, waveform or binary.
• Signal: power or data

Panels

Every panel will have a label and possibly and indicator. Each user will have some fixed number of panel. In the main view, they can see an icon for each panel (though not the state or label of the panels). Clicking on a panels zooms in on that panel and places a set of 5 buttons to the left - zoom out and arrow keys to move between panels without zooming.

Components

Components route signals. During convolution, all components can be powered and locked. This adds an indicator interface. All components have a direction, so unless otherwise noted, each component has a mux/demux bool. For instance a mux keypad has many inputs but a single output, where a demux keypad has many outputs to a single input.

• Keypads: Special one to many, automatically requires a data sheet to indicate what code does what thing
  • Symbol: A grid of symbols
  • Labels: A column of labels, each with a button and indicator
  • Colors: Grid of LED buttons (unlike normal, small, round LEDS, these are large, interactive squares).
• Control panels : semi-ordered collection of controls, any control may have a label or an indicator, every state may also have it's own label (but not indicator
  • Groups: a boarder around a set of controls
  • Buttons
• One to many:
  • switch 2 outputs
  • knob: 3-7 arrayed over 120° arc
• Plug board: many to many, labeled sockets with a fixed number of wires
  • Black: two plugs, general purpose
  • Green: two plugs, needed for "high voltage"
  • Blue: two plugs, needed for "high frequency" signals

Any of these can act as either an input or a router. Wiring something like "+12V" to "Close Doors" is like pushing a "Close Doors" button. But knobs and switches can also easily route, and entering the right sequence in a keypad could also route, generate or some combinations (entering "1234" in a certain keypad could produce a signal as output, produce a signal and route it to a specific place, or route a signal from one place to another place).

Output

• Console: Computer screen. Each player has one, this is where "information" lives. The console has pages that users can flip through with back/forward buttons. A console starts with some information, but if binary data is sent to a console, it will add pages to the log. When there are unseen pages in the log, there will be a notification.
• Light boards
  • Indicator: just a column of indicators.
  • Rows: rows of LEDs (so a grid, but each row may have a label)
  • Circle
• Timer
• Oscilloscope
• Needle Gauge

Hidden

These aren't actually panels

• Systems: silo components that react to inputs
• Tables: needs more thought... take data in, perform an action. Mostly for key pads, take in a sequence and either produce a signal or route a signal. But the concept could be broadly applicable.
• Time Velocity: changes the speed of the count down clock. In easier games, it can be used to buy more time. In more difficult games it will accelerate the clock. In very hard games, the clock can start in an accelerated state.

Information

Information appears on players consoles in a log. You'll never lose access to information and information is never incorrect (though it's not always useful).

• Procedure: An ordered set of instructions that, when completed, will trigger the stated action.
• Cipher Table: Maps glpyhs to either codes, chars or IDs. A glyph is always unique to one cipher table
• Codes: Maps a code to a label
  • code → label (id | code | cipher)
  • code → IF conditional THEN label OTHERWISE label
• Wiring Diagrams: Defines connections between some of the components

The combinations of labels and ciphers can be infinitely complex. Say we have the "Cancel" button. The base case is it's labeled "Cancel". It could also be labeled with a code or a glyph. The code could be a set of glyphs. Looking up a code or glyph can direct us to another code or glyph. But eventually, it will resolve to "Cancel". Also, a code can map to a procedure who's output will be the code value.

Instructions

These deserve their own section. An instruction always refers to completing a single action, but to complete that action, several other actions may be required. So there will never be an instruction like "Press the 'Cancel' button and then set the 'Mains-Power' to 12v", that's two instructions.

An atomic instruction will be

• Press a button
• Set a switch or knob to a state
• others...

But an instruction can also be something like "Power 'Vent Gas' with 12vDC". Which may require any number of other steps. As simple as wiring "12vDC" to "Vent Gas" on a plug board" or it could be very complex, requiring looking up ciphers to find the code to produce 12vDC on some panel, but that panel isn't active, so we look up the activate code, then we need to route the 12vDC through several panels because it's the only route from that panel to "Vent Gas".

And, a single instruction can reference another procedure.

Signals

• Simple Voltage
  • Ground
  • 5V
  • 12V
  • 110V
  • 1000V (high voltage)
• Waves
  • 10 Hz
  • 1000 Hz
  • 100000 hz (high frequency
• Information : will show up as a scramble on an oscilloscope, activates various devices
  • Data: displays information when directed to a terminal
  • Control: Required to unlock certain panels

Algorithm

Every player has a Win panel generated, that is a single indicator wired directly to power and signal. Every player is also given a terminal.

The game tracks 'critical' states. A state is a wiring pattern that achieves a goal and all the knowledge needed to achieve that pattern (know what each label means).

The key critical state is the win condition. This is the chosen wiring pattern that wins the game. Other win states may be possible. The other states are delivering a data to terminals to access information.

Convolution

A direct connection in a state is turned into an indirect connection via a component. This may mean adding a component, using the output of a component that's not being used or extending a component. It should be biased towards reusing components.

Obfuscation

This takes a piece of labeling information and adds a layer of coding. When the game starts, every label is a connection ID, so changing one label to code means knowing that code reduces it back to the original state.

A label is given a code and that code is either added to a code sheet, or a new code sheet is added (with that label). During generation, code sheets only have useful information, in the final phase, they are padded with useless information.

When a new code sheet is added, it is wired directly to a terminal, During convolution, it may be indirected.

Keypad

Adding a keypad is both a convolution and obfuscation. To add a keypad, we convolute a signal through the keypad and add that to a keycode data sheet. Keycode datasheets are different form code sheets. Code sheets convert a code to a label, key code sheets list a keypad ID and code and list the ID that maps to.

Red Herrings

Adds an input or output to component or adds a new component with useless inputs and outputs.

Finalize

During initialization, every player was assigned a win panel and a terminal. During finalization, the rest of the component panels are assigned. We go through the states and count up the number of actions that must be performed on each panel. Then we distribute the panels so that each player has approximately the same number of actions to perform.

Versions

1.0

The goal of 1.0 is the most basic playable, that will already require a lot of work. Users, game setup, drawing panels and panel navigation. To have a minimally playable game (though it may not be that much fun), the only two component types will be indicators and knobs.

2.0

The obfuscation version. Add terminals, codes and data signals.

3.0

Keypads, switches.

4.0

Oscilloscopes. This requires the obfuscation model to be reworked a little because a player can discover what type of signal it is by looking at it on an oscilloscope. They can deduce things like "this is data, so send it to a terminal" without explicit labeling.