BOOMOP

From Esolang
Jump to navigation Jump to search

Based On Objects Made Of Polygons or short BOOMOP is an an esoteric programming language created by User:rphii in 2021.

Idea

It is BOOMOP (get it?) whose faces/polygons have different attributes that directly translate to different commands. BOOMOP won't accept objects that are not fully enclosed.

Abbreviations

To make explanations more concise and simple, refer to the abbrevations below. References to the table are always in code format.

Abbr. Description c-equivalent type
i Color of a polygon (hexadecimal format: 0xRRGGBB/) uint32_t
j i interpreted as an index to a cell uint32_t *
@j j whose value is interpreted as an index to another cell uint32_t **
k i interpreted as a value uint32_t

Objects

BOOMOP commands are 3D-objects, per say. Those objects are made up of polygons with different attributes, like edges count or color. With this we're already jumping into the next point: BOOMOP objects are intended to be colorful. Each BOOMOP program has to be a fully enclosed object. With this rule, each edge of a polygon always touches another edge of a different polygon.

Execution

BOOMOP is a set of command-flow instructions, made of polygons. It first executes a command, defined by the shape of the polygon and then takes a specific route to the next polygon. This process is started on an entry point and then repeated until it hits a termination point. In BOOMOP, object can have "dead polygons" that are never actually touched.

Entry and termination point

Type Description
Entry Point A BOOMOP program starts on a brightest polygon that is not a termination polygon. Continue with the normal flow. If there are multiple brightest polygons that have the same brightness (and are no termination points), BOOMOP shall randomly choose on which polygon it wants to start.
Termination Point A BOOMOP program ends on a brightest polygon that has all edges the same lengths. (ID 3)

Memory

BOOMOP's memory is zero initialized at program start. It is accessible through i, meaning one can use the full range of a 32 bit unsigned integer. To make additional operations, such as adding and subracting, we make use of a stack. Check the next section: commands for further details.

Commands

ID Description Flow Category Minimum Polygon Edges
0 If @j is zero, flow abnormal. Else, flow alternate abnormal, alternate Flow control 3
9 If @j is zero, flow teleport. Else, flow alternate teleport, alternate Flow control 5
7 Output a character from @j normal Input/Output 5
8 Input a character, store it @j normal Input/Output 5
10 Push k to the stack normal Math (kinda) 5
4 Push j to the stack normal Math (kinda) 4
3 Push @j to the stack normal Math (kinda) 3
5 Add two stack entries, store result to j and pop the two values normal Math 4
1 Add two stack entries, store result to @j and pop the two values normal Math 3
6 Subtract topmost from underlying stack entry, store result to j and pop the two values normal Math 4
2 Subtract topmost from underlying stack entry, store result to @j and pop the two values normal Math 3

The ID is taken from the section: More on edge lengths. This also defines the minimum polygon edge lengths, for convenience it was put into the table aswell. After a command is executed, we will flow towards the next polygon, next section: Flow.

Flow

As touched on in the section: Execution.

Flow type Description
normal Draw the center perpendicular of the polygon plane going through the center of mass of the active polygon facing inwards (into the object). The polygon it hits first will be the next one to be executed.
abnormal Draw a line inside the object, going through the center of mass of the active polygon and the center of mass of the object. The polygon it hits first will be the next one to be executed.
alternate The neighboring polygon touching the longest edge will be the next one to be executed. If there are multiple longest edges, choose randomly between the normal or abnormal flow.
teleport Draw an expanding sphere around the center of mass of the active polygon. Any joint of two edges of an equal colored polygon with the same ID that gets found first, will be the anchor for normal flow from there instead. If there is no such thing as two equal colored polygons with the same ID, take the normal flow instead.

Further thoughts

More on edge lengths

Refer to the following table to understand the subsections.

Letter Explanation
E count of equal edge lengths that match the average length of all edges of that polygon
S count of shorter edge lengths than the average length of all edges of that polygon
L count of longer edge lengths than the average length of all edges of that polygon

Upon comparing edges with each other, we find that there are the following combinations. Also, we write down the number of combination that have similarities within the parenthesis, also used to identify the command ID.

Three-cornered polygon

Aka. trigon

  1. 0E1S2L (new, ID 0)
  2. 0E2S1L (new, ID 1)
  3. 1E1S1L (new, ID 2)
  4. 3E0S0L (new, ID 3)

Four-cornered polygon

Aka. tetragon

  1. 0E1S3L (ID 0)
  2. 0E2S2L (ID 1)
  3. 0E3S1L (new, ID 4)
  4. 1E1S2L (new, ID 5)
  5. 1E2S1L (new, ID 6)
  6. 2E1S1L (ID 2)
  7. 4E0S0L (ID 3)

Five-cornered polygon

Aka. pentagon

  1. 0E1S4L (ID 0)
  2. 0E2S3L (ID 1)
  3. 0E3S2L (ID 4)
  4. 0E4S1L (new, ID 7)
  5. 1E1S3L (ID 5)
  6. 1E2S2L (ID 6)
  7. 1E3S1L (new, ID 8)
  8. 2E1S2L (new, ID 9)
  9. 2E2S1L (new, ID 10)
  10. 3E1S1L (ID 2)
  11. 5E0S0L (ID 3)

n-cornered polygon

Using OEIS, we find the sequence A000124 that just satisfies the number of possible distinct polygons, depending on the number of edges a polygon has. (When compared with the given rules). BOOMOP however only supports commands shaped as a trigon, tetragon or pentagon. Any polygon with more edges is regarded as an error within the object and BOOMOP won't run.

Similar (esoteric) programming languages

After everything about BOOMOP was specified, the OP searched the wiki for pages containing "polygon" and "face". The only programming language that could barely come close to the idea of BOOMOP is Wumpus (at the point of creation). But that is only a 2-dimensional variant, with only triangles. BOOMOP makes use of more than just that.

What makes a polygon?

A polygon is a flat two-dimensional shape that is fully enclosed. Each polygon has at least three edges. Furthermore, the following things make a polygon:

  1. It's area
  2. It's dot count (= it's edge count)
  3. It's edge lengths
  4. It's angles
  5. It's color
  6. (and more, eg. orientation, coordinates, center of mass, the force...)

How to interpret what makes a polygon?

Some of OP's thoughts while creating BOOMOP.

  1. An Area can represent a real number. Use that for whatever real numbers can be used for. Shhh, mind checking out )0,1( if we're already talking about it?
  2. The dot count automatically also defines it's edge count. This represents a natural number (to OP's knowledge there is no such thing as a polygon with eg. 1.5 points, less one with -1.5 points). Use that for whatever you can use a natural number, maybe an index, a command, a variable, a constant. You name it.
  3. The edge lengths can also represent natural numbers. Use that for the same you would use an area for. Additionally, since a polygon always has at least three edges with different lengths, you can compare the lengths with each other. This results in additional states, like binary for example, making it another measurement of natural numbers.
  4. Angles are a whole different topig. Short rant: While designing BOOMOP, the OP figured out how we measure the angle of triangles is just... weird. Every shape, no matter how many dots it has, ends up with a total of 360° or 2π. Proof: Stand on ANY polygon's edges and trace around it once. How much did you turn? Yes, you turned 360° or 2π and not 180° or π, no matter what shape! If you inspect the angles you turned on, eg. a paper, you find yourself calculating with the adjacent angle of the inner angle, instead of just the inner angle... Anyways, angles are, depending on how you view it, always made up of 360° or 2π. Also, because you can turn both directions, an angle can be somewhere in the range of -360° or -2π up to 360° or 2π. At this point, it is is most likely some real number with a possible negative range.
  5. The color we know and love in todays computers comes in all different representations and formats. Eg. RGB, HSV, HSL (OP is no expert at this, so fill in the rest for yourselves...), etc. So, it is some natural number. Again, use that for whatever you'd use natural numbers for. Many esoteric programming languages already make use of that concept, see BSoD, Befunk, Brainloller and many more. However, in BOOMOP it is used as an index or value, depending on the command.

Future proofness?

If you read everything and understood most of it, you will realize: "My program can follow a super duper complicated flow and to make it even more confusing, I'll maybe even swap the ID's of the commands around at run time or on launch so no one understands what actually is going on. Let's even expand and add more commands... Oh hey, while I'm at it, why not print out the object made of polygons with a 3D printer or similar and actually touch my program." As such, BOOMOP is very special, because you can literally print out your program and physicaly touch it, as a 3D-object (!). One might also think by now: "Whoah, calm down there, buddy!" but it gets even better: You can to anything with it, like sleep, eat, party, or even learn together. Isn't that cool? In OP's opinion, this is a long awaited and hidden dream of any passionate programmer. Now THIS is what we should call real object oriented programming and it is obviously way cooler than traditional OOP. Together, let's make programming great again!

"Wait, was it ever bad?--"

--Shhhhh...

Computational class

Probably Turing Complete--since it has not been proven we don't know yet.

See also

External resources

  • OEIS The On-Line Encyclopedia of Integer Sequences® (OEIS®).
  • OEIS:A000124 The sequence touched upon in section: More on edge lengths