BOOMOP

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 abbreviations 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 as well. 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
# 0E1S2L (new, ID 0)
# 0E2S1L (new, ID 1)
# 1E1S1L (new, ID 2)
# 3E0S0L (new, ID 3)
==== Four-cornered polygon ====
Aka. tetragon
# 0E1S3L (ID 0)
# 0E2S2L (ID 1)
# 0E3S1L (new, ID 4)
# 1E1S2L (new, ID 5)
# 1E2S1L (new, ID 6)
# 2E1S1L (ID 2)
# 4E0S0L (ID 3)
==== Five-cornered polygon ====
Aka. pentagon
# 0E1S4L (ID 0)
# 0E2S3L (ID 1)
# 0E3S2L (ID 4)
# 0E4S1L (new, ID 7)
# 1E1S3L (ID 5)
# 1E2S2L (ID 6)
# 1E3S1L (new, ID 8)
# 2E1S2L (new, ID 9)
# 2E2S1L (new, ID 10)
# 3E1S1L (ID 2)
# 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:
# It's area
# It's dot count (= it's edge count)
# It's edge lengths
# It's angles
# It's color
# (and more, e.g. orientation, coordinates, center of mass, the force...)
=== How to interpret what makes a polygon? ===
Some of OP's thoughts while creating BOOMOP.
# 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?
# 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 e.g. 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.
# 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.
# Angles are a whole different topic. 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, e.g. 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.
# The color we know and love in today's computers comes in all different representations and formats. E.g. 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 physically 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 ==
* :Category:Cell-based
* :Category:Stack-based
* :Category:Usability unknown or yet to be discovered
* :Category:Unknown computational class
* :Category:Multi-dimensional languages
* :Category:Unimplemented
* :Category:Non-textual
* :Category:Low-level
== External resources ==
* OEIS The On-Line Encyclopedia of Integer Sequences® (OEIS®).
* OEIS:A000124 The sequence touched upon in section: More on edge lengths
Category:Cell-based
Category:Stack-based
Category:Usability unknown
Category:Unknown computational class
Category:Multi-dimensional languages
Category:Unimplemented
Category:Non-textual
Category:Low-level
Category:Languages
Category:2021