SEMAPHORES v1.0 - AN EXPERIMENTAL OPEN SPECIES

Semaphores are a species of sentient cyborg-esque machines, taking the form of four virtually indestructible congruent cubes stacked upon one another.

This is also open to changes. Feel free to leave feedback and/or comments if you feel anything should be changed or if you simply enjoy this absurdity.



APPEARANCE AND PHYSICAL ATTRIBUTES

Semaphores can vary in size, however all Semaphores are between 0.5m and 4m high. Their lateral size also varies similarly. (Total volume thus ranges between 1/128 and 4 cubic meters.)

Semaphores take the form of four identical cubes stacked upon each other, each with similar but differnet appearances. Markings and visual appearance may vary, however exactly one lateral side of each cube is equipped with a large display screen that takes up most of the area on that side. Each one serves a different function. All cubes are the same base color and that color is always grayscale.

The topmost panel displays a single diamond (tilted square) shape that serves as a sort of eye. The eye/panel can react to its surroundings and serves as an eye/optic sensor. Panels can vary widely in display however the second topmost panel is the one that changes the most. All others have a specific function that is used unless overridden.



BEHAVIOR

Semaphores can move by sliding the bottommost cube. Cubes can slide and turn on top of each other. However, the vertical center of any cube cannot lie outside the top/bottom faces of its neighbors. All cubes remain parallel and are held together by electromagnetic connections. When on an inclined surface the cubes will tilt and rearrange themselves, when necessary and possible, to maintain balance.

If a Semaphore falls over it will not be able to right itself unless it is in normal behavior and there are enough Nanomachines available, in which case Nanomachines will be used to do the work. (Nanomachines are expanded upon in the next section.)

Semaphores can express emotion through body language such as vibrations and movements of cubes (Think of Toothless shaking in excitement for example). Semaphores audibly communicate through various beeps and clicks however ONLY the second topmost screen can display images, oral language, and other symbols in normal behavior. The eye can also move to express emotion.

Semaphores generate nutrition using a process not unlike photosynthesis. Water intake is through chemical reactions in the body (air provides many useful elements and compounds). Semaphores can die, however their lifespan is often several hundred or thousand years. Semaphores can also intake water and possibly nutrients through the bottom of the lowest cube. Semaphores can also power themselves using solar energy.

There are no rarities within Semaphores. All Semaphores have largely the same traits however personalities might differ. It is up to the users how Semaphores behave when under a user's control. Certain government organizations can also set legal restrictions on Semaphore usage.



CODE COMPILATION AND EXECUTION

Semaphores can execute code written in one language only. The language is set by its creator and is available when it is sold. The language can also be obtained by simply asking it. Most Semaphores compat with C++ however other languages are supported.

Input is inputted through verbal (albeit sometimes tedious) commands, visual scanning of QR codes, or through technomagic/telepathetic systems such as Arcai.

Largely all standard libraries and functions are supported by Semaphores however there are a few Semaphore-Exclusive methods that are used on Semaphores. Method signatures are largely identical across languages.

Semaphores are controlled by two values. A 64-bit unsigned integer value, and a real number value.

The integer value is controlled programmatically. However the real number value corresponds to a volume of Nanomachine ``fluid'' contained in the Semaphore.

Each Semaphore is packaged with a fixed amount of Nanomachines/nanites/whatever which the maximum value is stored internally. The maximum possible amount of Nanomachine stored is twice the volume of a single cube. Nanomachines are controlled by the Semaphore and are stored in the bottom three cubes. Entrances and exits are done through small undetectable valves. Nanomachines can be used and controlled in various ways.



DOCUMENTATION

The documentation of the Semaphore is as follows:

I. INTEGER VALUE CONTROL

down(int x, closure F) : Attempts to decrease the integer value by x and then perform the work enclosed by F (a closure or some other function/code block). If doing so would cause the value to decrease beyond 0 the event and the decrement is put into an event queue that will be picked from when available.

up(int x) : Increments the value by x. If this would cause the value to exceed the maximum possible 64 bit unsigned integer the value is capped. Then, the queue is looked into and if possible, the first waiting event is picked, the Semaphore decremented by the corresponding value, and the event scheduled.

II. NANOMACHINE VALUE CONTROL

construct(vector<point> v, closure F) : Attempts to construct a Nanomachine shape given by the convex hull of the points in v and then perform the work enclosed by F (a closure or some other function/code block). If all the points fall on a plane nothing is constructed. The relevant volume of Nanomachines is decremented. However if there are not enough Nanomachines the construction and closure is scheduled inside a second event queue (Nanite queue). Construction overlapping the environment will do the work however volumes overlapping the environment will not be constructed. Only when the volume moves will the remaining part be ``filled in.'' Construction overlapping an existing Nanomachine construct is possible and simply results in an additional shape. All Nanomachines constructed this way begin attached to the Semaphore.

wipe(vector<point> v) : Clears all Nanomachines from the volume enclosed by the convex hull of the points in V and returns the cleared Nanomachines back into the system. Then looks at the first event of the Nanite queue. If the event's construction volume requirement is satisfied then the event is popped and the construction/continuation done. Otherwise nothing happens.

wipe(point p) : Clears all Nanomachines in the connected region containing point p. If there are no Nanomachines at p nothing is cleared. Then looks at the first event of the Nanite queue. If the event's construction volume requirement is satisfied then the event is popped and the construction/continuation done. Otherwise nothing happens.

clear() : Clears both event queues, resets the integer value to the original value, and returns all Nanomachines back into the Semaphore. Semaphore returns to normal behavior.

III. AESTHETICS

setColor(vector<point> v, int x) : Sets all Nanomachines in space corresponding to the convex hull of v into the color denoted by x. (Nanomachines moving into/out of colored regions change color accordingly.)

setDefaultColor(vector<point> v, int x) : Sets the default color for the Nanomachines enclosed by the convex hull of v to x.

setDefaultColor(point p, int x) : Sets the default color of all Nanomachines in the connected region containing p to x.

setDefaultColor(int x) : Sets all Nanomachines not in a colored region to the color denoted by x.

IV. SENSORS AND STATISTICS

detectTouch(vector<point> v) : Returns a boolean value based on whether something is touching any Nanomachine in the convex hull of v.

getSideLength() : Returns a single real value corresponding to the side length of the cube.

getMaxVolume() : Returns the total amount of Nanomachines that are owned by the Semaphore.

IV. COMPLEX FUNCTIONALITY

detach(vector<point> v, bool physics) : Detaches the Nanomachines enclosed by convex hull of v. The region becomes a continuous construct. If the physics parameter is true then the resulting Nanomachine construct behaves like a rigid body with density 1000 kg/m^3. Otherwise the Nanomachine construct simply remains immobile.

detach(point p, bool physics) : Detaches the Nanomachines in the connected region containing p. The region becomes a continuous construct. If the physics parameter is true then the resulting Nanomachine construct behaves like a rigid body with density 1000 kg/m^3. Otherwise the Nanomachine construct simply remains immobile.

attach(point p) : Attaches the Nanomachine construct to the Semaphore. Movement of the Semaphore is reflected in the construct. Obstructions in movement of the construct will obstruct movement of the Semaphore. All Nanomachines in the attached state are considered to be part of the same construct.

listConstructs() : Returns a vector of points, each one representing a detached Nanomachine construct.



FUNCTIONS AND NANOMACHINES

All methods may be called inside events and will behave in the same way as if they were called outside an event.

Additional methods (beyond the scope of this document) exist that move Semaphores during a process, as well as display things and emit sounds.

Nanomachines can be used as tactile, heat, and vibrational sensors, enabling the creation of interactable Nanomachine constructs. (Methods that invoke these sensor functions usually sense on a volume or region.) Nanomachines can take on any color in the RGB space. Nanomachines appear as translucent entities when conglomerated. Nanomachines can either have a default color (that is active when not in a colored region) or have the color of a region.

The bottom two screens of the Semaphore display the integer value and the stored volume relative to their maximums as proportions as a vertical bar graph.

When a Semaphore is running a process or an event is scheduled the Semaphore is immobile and cannot be moved by any force less than several hundred kilo-Newtons, unless a program tells it to do so. Coordinates are measured in meters relative to the facing direction of the topmost cube. The X axis points rightwards, the Y axis forwards, and the Z axis up. The origin is in the center of the cube. This also means that if a Semaphore moves during a process any active constructs attached to the Semaphore will also move. If movement is obstructed the Semaphore and all constructs will not be able to move.

Semaphores behave normally when no process is running or is able to run. When a code is inputted the Semaphore halts all normal behavior and begins running the process(es) and will return to normal behavior once all processes halt. This can potentially mean that a Semaphore behaves normally with Nanomachines attached.

Nanomachines form connected groups called Constructs. All Nanomachines attached to the Semaphore are considered part of the same construct no matter if they are connected or not. Otherwise detached Nanomachines split into constructs based on function calls. Constructs can only have one connected region.

Connectedness is determined by continuity. Two detached Nanomachines are connected if they are part of the same construct. When Nanomachines are attached to the Semaphore two Nanomachines are connected if a continuous path exists between the two Nanomachines that passes exclusively through other attached Nanomachines. (Essentially if we model the set of points of Nanomachines attached to the Semaphore as a set, connectedness is defined in the same way as you would topologically.)



A BIT ABOUT PROGRAMMING STUFF

The up() and wipe() functions only run a single process. If you wish to continue running more scheduled processes you must call these functions from inside the processes themselves.

If you want to immediately detach a set of nanomachines you can simply call the detach method from inside the continuation.

For now you can assume that memory is infinite. Assume an upper bound of 2.5 PB the same as a human brain.

``Extra'' nanites can be stacked on the Semaphore's head like a hat. This is useful for when you want to control the Nanomachine value without significantly affecting the environment.



BACKSTORY/ABSTRACTION

The Semaphores were created by [REDACTED] Industries and originally served as portable and lightweight computing devices and assistants. Nowadays they serve a variety of purposes, ranging from their original purpose to transit and construction and even as pets.

Semaphores are named after the universal synchronization primitive of the same name and behave in a similar manner.



META-DETAILS

Semaphores are an experimental open species created by NormalExisting and are free to use. They should also be largely compatible with pre-existing universes.

Semaphores are not omnipotent nor are they omnipresent. They simply are able to run code that is given to them.