[GUIDE] Circular Placement via XML + "Bastion of Life" plan

[UnholyForager]

Following the 4.1 patch for X4 and my submission (https://imgur.com/a/dB0bhQr) to the station design contest, I would like to share the details of how I built my station design based on the DNA double helix structure. Additionally, I have attached the construction plan to my station here.

IMPORTANT: This is a fairly advanced guide that uses concepts beyond the scope of the game. In order to fully utilize this guide, it is highly recommended to have a basic knowledge of writing scripts in some kind of programming language (such as Python). While this is not absolutely necessary, it will be very tedious to attempt any complex structures without writing a script. I will not be going into the details of programming here. Additionally, you should be familiar with the structure of the xml files used by X4. Mathematically, you should understand how to use polar and cylindrical coordinate systems.

Basics of Construction Plan XMLs:
The XML files for your saved and imported/exported construction plans are located in the same directory as your save games. For Steam users this is \Documents\egosoft\X4\########## [Your Steam user ID number]\ by default. 'constructionplans.xml' contains your saved contruction plans. If you go into the constructionplan folder, you can find any plans you have imported/exported. You can work with either one of these but for the purposes of this guide, I would recommend exporting any station plan to a new xml file and working with that.

Each separate module will start with an <entry ...> line and end with </entry>. For example, the start of an entry for a terran docking station might look like <entry index="6" macro="dockarea_ter_m_station_01_hightech_macro">. For this guide, we will primarily be working with the <position x="###" y="###" z="###"/> and <rotation yaw="###" pitch="###" roll="###"/> lines (missing values default to zero). When constructing a station, be sure that each module has a unique index number.

Throughout this guide, variables that are GREEN are calculated values that are not used in the XML. Variables that are PURPLE directly refer to part of the construction plan XML.

NOTE: The position coordinate defines where the center of your module is located. Coordinates have units of [meters], thus a build site going 10 km in either direction has position values ranging from -10000 to 10000. This guide will use Y as the vertical coordinate and will refer to the XZ plane as 'horizontal'.

NOTE: All designs created by this guide will have every module free floating. None of them will be connected in the station editor, even if they are touching. It is possible to make them connected in the xml (even if they arent touching) but I have not tested this extensively and do not know if any problems will arise from doing so. Any reference to 'connected' modules in this guide means that the modules are physically touching, not that they are connected to each other in the station plan.

[UnholyForager]

Basic Circular Placement:
NOTE: The mathematical equations used here use radians for measuring angles. However, X4 uses degrees for values of yaw, pitch, and roll.

This section will cover how to place a series of station modules in a horizontal circular pattern, similar to a cyclic polygon. To start, you will need to find the length of your module which we will abbreviate as 'L'. To find this, place the module you are using in the station editor. Place another module of the same type connected to the first so that they form a line, then save or export your design (ideally these will be the only two modules). Open up the xml file containing your design and find the two modules you have placed. Find the distance between the position coordinates of the two modules (this is trivial if you did not rotate them, but if you did you can use the Pythagorean theorem). This distance is the length of your module. For example, the length of the 'Terran Base Connection Structure 01' module is 400. To place the modules in a circular pattern, I have found it is much easier to solve using a polar coordinate system.

Disconnected modules:
First, choose how many modules you want to make up your circle, we will abbreviate this as 'N'. Choose a radius, abbreviated 'R', which should give you a circumference larger than the length of all your modules.
R > N * L / (2 * pi)
Next, we calculate the change in angle between each module, abbreviated 'DT', using
DT = 2 * pi / N
Now we need to calculate the position and rotation of each module. The idea is we want to iterate through all the modules and place each one separated by an angle of DT. We first define 'Theta' as the current angle in the circle where we are placing a module. We start with Theta = 0 and place the first module, then add DT to Theta to find the next angle for the next module. We repeat this process until we have placed all our modules. The position (X and Z) and rotation (Yaw) values are calculated using the following equations:
X = R * cos(Theta)
Z = R * sin(Theta)
Yaw = - Theta * 180 / pi
Theta = Theta + DT

Connected Modules (Cyclical Polygon):
First, choose how many modules you want to make up your circle, we will abbreviate this as 'N'. Next, we calculate the change in angle between each module, abbreviated 'DT', using
DT = 2 * pi / N
Lastly, calculate the radius of your circle, abbreviated 'R', using
R = L / ( 2 * sin(DT / 2) )
Now we need to calculate the position and rotation of each module. The idea is we want to iterate through all the modules and place each one separated by an angle of DT. We first define Theta as the current angle in the circle where we are placing a module. We start with Theta = 0 and place the first module, then add DT to Theta to find the next angle for the next module. We repeat this process until we have placed all our modules. The position (X and Z) and rotation (Yaw) values are calculated using the following equations:
Xstart = R * cos(Theta - DT / 2)
Zstart = R * sin(Theta - DT / 2)
Xend = R * cos(Theta + DT / 2)
Zend = R * sin(Theta + DT / 2)
X = (Xstart + Xend) / 2
Z = (Zstart + Zend) / 2
Yaw = - Theta * 180 / pi
Theta = Theta + DT

Assuming you have managed to correctly input these values into an xml contruction plan, you should be able to load it in the station editor and see your modules arranged in a neat circle. Optionally, you can assign a value to 'Roll', this will not affect the calculation. Generally all your modules will have the same value for Roll.

[UnholyForager]

Basic Circle with modules of different lengths:
This section will extend the previous method to allow for placing modules with different lengths. If you do not want your modules to be touching, simply use the 'Disconnected modules' method described above, no further changes are needed. If you would like the modules to be touching end to end, refer below for the modified 'Cyclical Polygon' method.

Multiple Length Cyclical Polygon:
For the purposes of this guide, we will assume two different module lengths. However, this method can easily be extended to include more. First, find the lengths of your two modules, as described previously. These will be abbreviated 'L1' and 'L2', with L1 being the shortest of the two modules. Next, determine the number of each module you want in your circle, abbreviated 'N1' and 'N2' respectively. Calculate the angle subtended by each module, abbreviated 'DT1' and 'DT2', using
DT1 = 2 * pi / (N1 + N2 * (L2 / L1) )
DT2 = (L2 / L1) * DT1
NOTE: This is an approximation. For large circles you should not notice anything out of place, but if you are making very small circles, you may have to make adjustments to get a good fit.
Lastly, calculate the radius of the circle, abbreviated 'R', using
R = L1 / ( 2 * Sin(DT1 / 2) )
To calculate the position and rotation of each module, we use the same general idea as before with the 'Cyclical Polygon' but with a minor alteration. Determine which module you want to be placed first, for now let's say we want to place a module with length L1 first. Start at Theta = - DT1 / 2 and calculate the position (X and Z) and rotation (Yaw) values with the following equations:
Xstart = R * cos(Theta)
Zstart = R * sin(Theta)
Theta = Theta + DT1
Xend = R * cos(Theta)
Zend = R * sin(Theta)
X = (Xstart + Xend) / 2
Z = (Zstart + Zend) / 2
Yaw = - (Theta - DT1 / 2) * 180 / pi
Note, we add DT1 to Theta in between to calculation of the start and end coordinates. To place a module with length L2, simply replace DT1 with DT2 in the Theta and Yaw equations.

[UnholyForager]

Basic Helix:
Now things get interesting. This section will expand the previously described methods into a 3-dimensional helix. Any of the previous basic circle methods ca be used to construct a helix with only minor changes needed. Additionally, a helix does not necessarily have to follow the constraint that the start and end points are the same, thus several other options for calculating the radius are opened up. For the purposes of this guide, I will show how to modify the 'Cyclical Polygon' method to create a helix structure. The other methods discussed previously will not be shown explicitly but can be modified in a similar way to also create a helix.

Cyclical Polygon Helix:
First, choose a value for the Pitch (in radians), abbreviated 'P', of your helix. This is the angle of elevation between each of your modules and the horizontal axis and will remain constant for every module. Also choose a starting height, abbreviated 'Y0' (I typically use Y0 ~ -4500 for stations that go from -5km to 5km in all directions). Next, similar to before, choose how many modules you want to make up one revolution of the helix, abbreviated 'N', and find the length of your module, 'L'. Calculate the change in angle between each module, abbreviated 'DT', using
DT = 2 * pi / N
Additionally, we calculate the horizontal and vertical length of the now rotated module segment, abbreviated 'LH' and 'LV' respectively, using the following:
LH = L * cos(P)
LV = L * sin(P)
Lastly, calculate the radius of your helix, abbreviated 'R', using
R = LH / ( 2 * Sin(DT / 2) )
For brevity, we will additionally include phase shift, abbreviated 'Phi'. Including a phase shift is mostly used for constructing multiple helices along a single vertical axis. If you do not wish to use a phase shift, set Phi = 0, otherwise choose a value for Phi between 0 and 2 * pi radians. Now we need to calculate the position and rotation of each module. Placement is similar to the method described previously. We start with Theta = 0 + Phi and Y = Y0, then calculate the position (X, Y, and Z) and rotation (Yaw and Pitch) values using the following equations:
Xstart = R * cos(Theta - DT / 2)
Zstart = R * sin(Theta - DT / 2)
Xend = R * cos(Theta + DT / 2)
Zend = R * sin(Theta + DT / 2)
X = (Xstart + Xend) / 2
Y = Y + LV
Z = (Zstart + Zend) / 2
Yaw = - Theta * 180 / pi
Pitch = P * 180 / pi
Theta = Theta + DT
Note that again, the Pitch for all of your modules should be a constant value. Additionally, you can go beyond a single revolution when creating a helical structure by continuing to place modules using these equations.


Here is an example of a double helix structure. This was constructed by first creating a helix with Phi = 0, then creating a second helix with a phase shift of Phi = pi radians or 180 degrees:


NOTE: The 'Bastion of Life' station used a phase shift of Phi = 0.706 * pi to closely mimic the DNA structure.


Parallel Helices:
This section will explain how to place multiple Helices in parallel, stacked vertically. The methods described here will modify the previously described helix method. There are two different ways to do this which yield slightly different results. The first method simply introduces a vertical offset, each module in this helix will be slightly higher than the original helix. My preference is to instead have the helices aligned along an off-vertical axis. Thus, the second method creates a helix that lines up with the original along a vertical axis that has been rotated by the same angle as the pitch of the helix.

Vertically Aligned Helix:
First, choose a value for the vertical offset between your two helices, abbreviated 'YOffset'. Then follow the same procedure used to create your original helix, but start with Y0 = Y0 + YOffset.

Off-Vertical Aligned Helix:
First, choose a value for the total offset between your two helices, abbreviated 'Offset' Next, calculate the vertical, 'YOffset', and horizontal , 'XZOffset', offset values using
YOffset = Offset * cos(P)
XZOffset = Offset * sin(P)
where P is the pitch of your helix. Calculate the yaw offset, abbreviated 'YawOffset', using
YawOffset = (XZOffset / L) * DT * 180 / pi
where L is the length of the module and DT is the change in angle between each module as defined previously. Follow the same procedure used to create your original helix, but start with Y0 = Y0 + YOffset. For each module, additionally calculate the X and Z offset values, abbreviated 'XOffset' and 'ZOffset' respectively
XOffset = - XZOffset * sin(Theta)
ZOffset = - XZOffset * cos(Theta)
where Theta is the placement angle as described previously. Lastly, make the following corrections to the X, Z, and Yaw values for each module
X = X + XOffset
Z = Z + ZOffset
Yaw = Yaw + YawOffset
This will place an off-vertically aligned helix above the original. To instead place it below the original, subtract the X, Y, Z, and Yaw offset values instead of adding them.

Comparison of vertically aligned (left) and off-vertically aligned (right) parallel helices:

[UnholyForager]

Helix Struts:
This section explains how to add horizontal struts within a double helix. To start, choose what modules will comprise each of your struts. For the method shown in this guide, you should have an odd number of modules of equal length. However, the method can be adjusted to accommodate unequal length modules or even numbers of modules. Find the length of a module in the strut, abbreviated 'LStrut', and the total length of the strut, 'LStrutTotal'.

Helix construction:
Constructing a helix with struts will use the same method previously described but with different formulas. It will be very difficult to make this type of helix with a perfectly integer number of modules per revolution but as mentioned previously, this is largely unimportant as it is difficult to notice. To start, choose a phase shift , abbreviated 'Phi', a pitch value, 'P', and starting height, 'Y0', for your double helix. Find the length of each module in the helix, abbreviated 'L'. Calculate the radius of your helix, 'R', using
R = LStrutTotal / (2 * sin(Phi / 2))
Additionally, we calculate the horizontal and vertical length of the now rotated module segment, abbreviated 'LH' and 'LV' respectively, using the following:
LH = L * cos(Pitch)
LV = L * sin(Pitch)
Next, we calculate the change in angle between each module in the helix, 'DT', using
DT = 2 * arcsin(LH / (2 * R))
Placement is similar to the method described previously except we will be placing two helices simultaneously to construct a double helix. We start with Theta = 0, Y1 = Y0, and Y2 = Y0, then calculate the position (X1, X2, Y1, Y2, Z1, and Z2) and rotation (Yaw1, Yaw2, and Pitch) values using the following equations:
X1start = R * cos(Theta - DT / 2)
Z1start = R * sin(Theta - DT / 2)
X1end = R * cos(Theta + DT / 2)
Z1end = R * sin(Theta + DT / 2)
X2start = R * cos(Theta + Phi - DT / 2)
Z2start = R * sin(Theta + Phi - DT / 2)
X2end = R * cos(Theta + Phi + DT / 2)
Z2end = R * sin(Theta + Phi + DT / 2)
Helix 1 values:
X1 = (X1start + X1end) / 2
Y1 = Y1 + LV
Z1 = (Z1start + Z1end) / 2
Yaw1 = - Theta * 180 / pi
Pitch = P * 180 / pi
Helix 2 values:
X2 = (X2start + X2end) / 2
Y2 = Y2 + LV
Z2 = (Z2start + Z2end) / 2
Yaw2 = - (Theta + Phi) * 180 / pi
Pitch = P * 180 / pi
Theta = Theta + DT

Strut Placement:
Helix struts should be placed as the helix is being constructed. So if, for example, you decide to place a strut every 3 modules in the helix, you will go through the following steps immediately following the placement of the 1st, 4th, 7th, etc. module in the double helix. Thus if you are placing the strut for the 7th module in the double helix, the values 'X1', 'Y1', etc refer to the X1 and Y1 values for the 7th module. To construct the strut, we begin by placing the center module first and then work our way outwards. To start, calculate the central position between the two modules in the double helix that the strut will span between, abbreviated 'Cenx', 'CenY', and 'CenZ'. These will serve as the X, Y, and Z coordinates of the center module
X = CenX = (X1 + X2) / 2
Y = CenY = Y1
Z = CenZ = (Z1 + Z2) / 2
as well as the rotation of the strut, 'CenYaw', with
Yaw = CenYaw = (Yaw1 + Yaw2)/2
To place the modules on either side of the central module of the strut, we calculate the offset of the modules in the X and Z direction, abbreviated 'XOffset' and 'ZOffset' (remember the yaw values have been converted to degrees so we convert them back to radians)
XOffset = LStrut * sin(CenYaw * pi / 180)
ZOffset = LStrut * cos(CenYaw * pi / 180)
The modules can then be placed using
X = CenX +/- XOffset
Y = CenY
Z = CenZ +/- ZOffset
Yaw = CenYaw
Placing further modules (4th and 5th module of the strut),
X = CenX +/- 2 * XOffset
Y = CenY
Z = CenZ +/- 2 * ZOffset
Yaw = CenYaw
and so on...


Rotation of vertical circle around a ring:
In this section, we go over the method used to rotate vertical circles around a horizontal circle (i.e. hexagonal defense platform rings). This method will use many of the same methods as the basic circle placement. In order to differentiate between the vertical circles being rotated and the horizontal circle around which we are rotating them, the horizontal circle will be referred to as the 'ring'. To begin, choose the module which you will use to create each circle and find it's length, 'L'. Choose how many of these modules will be in each circle, 'N', and how many circles will be in the ring, 'NRing'. Next, we calculate the change in angle between each module in a vertical circle, 'DT', and the circle radius, 'R' with
DT = 2 * pi / N
R = L / ( 2 * Sin(DT / 2) )

Ring calculations:
Now, we switch to calculating the values we need to form the ring of circles. Decide whether you want the circles to be disconnected or connected, which will determine which basic circle method we will use. From here, follow the same steps for the basic circular placement described previously for either disconnected or connected modules using 'NRing' instead of 'N' and using 2*R instead of 'L'. Do not use the DT value we calculated above as that is for the vertical circle, you will need to calculate a new 'DTRing' value for the ring using the chosen method. Once you have calculated the X, Z, and Yaw values, you do not need to place a module at these positions but keep these coordinates for later. These will be referred to as 'XRing', 'ZRing', and 'YawRing' later on and you should have an NRing number of values for each of these (i.e. if NRing=7, you should have 7 values for XRing, ZRing, and YawRing).

Vertical circle placement:
Finally, we place the vertical circles using the cyclical polygon method with the DT and R values calculated above and Theta = 0 but using the following formulas (remember YawRing was converted to degrees but we perform calculations in radians)
ThetaRing = -YawRing * pi / 180
Xstart = R * cos(Theta - DT / 2) * sin(ThetaRing)
Ystart = R * sin(Theta - DT / 2)
Zstart = R * cos(Theta - DT / 2) * cos(ThetaRing)
Xend = R * cos(Theta + DT / 2) * sin(ThetaRing)
Yend = R * sin(Theta + DT / 2)
Zend = R * cos(Theta + DT / 2) * cos(ThetaRing)
X = XRing - (Xstart + Xend) / 2
Y = (Ystart + Yend) / 2
Z = ZRing + (Zstart + Zend) / 2
Yaw = YawRing
Pitch = Theta * 180 / pi + 90
Theta = Theta + DT
For the first vertical circle, you will use the first set of values of XRing, ZRing, and YawRing and place modules until the circle is complete. Then move on to the second set of XRing, ZRing, and YawRing values to place the second circle and so on until you have place all of the circles around the ring.

[UnholyForager]

Future plans: Spherical Stations???

TER Challenger forum post


Click here for full album

[net2000man]

I must say that your design was really inspiring, and it made me rethink some other designs I had in mind. I've just assumed that the linear style of module layout was the only way to make stations, but you raised station building to a new level or architecture altogether. Great job to you and to ALL the other finalists, the work you all put into your stations has really left a mark on the rest of us!

[UnholyForager]

Guide is complete now. I have also added a construction plan which only includes the hexagon defense rings around the 'bastion of life' for use as a starting point for other station designs.

[hairyhermit]

Man I hope you're a real life astrophysicist or something.

[nemo1887]

bonjour
j'ai fait un petit programme en delphi 6 et voila ce que j'obtient j'ai essayer dans un petit fichier d'essai xml constructionplans avec 10 modules mais en reportant les chiffres obtenu dans un sens ou dans un autre ca ne fonctionne pas sauf en affichant le résultat en traçant une ligne sur la fiche avec le petit programme delphi ,peut-etre que le c++ converti en pascal ne donne pas toujours les bon résultats j'ai déjà eu ce probleme ,il faudrait comparer avec vos résultat avec 10 modules et 400 de longueur ??

Capture d’écran (467).png

Capture d’écran (468).png

[nemo1887]

bonjour voila ca fontionne!!


procedure TForm1.Button1Click(Sender: TObject);
var
N:integer;//Nombres de Modules
DT:real; //calculons le changement d'angle
R,r2:real;//Rayon du cercle
L:real;//longueur du module;
Xstart,Zstart, Xend,Zend :real;
Theta:real;
X,Y,Z:real;
Yaw:real;
i,n2:integer;
begin


// z:=-343.897;
Theta:=0;
N:=60;
L:=400;
DT := 2 * (pi / N);
// if R2> (N * L / (2 * pi) then r
R := L / ( 2 * sin(DT / 2) );

// <position x="-2495.742" y="-7893.477" z="-343.897"/>
y:=-343;
n2:=0;
for i :=0 to N-1 do
begin


Xstart := R * cos(Theta - DT / 2);
Zstart := R * sin(Theta - DT / 2);

Xend := R * cos(Theta + DT / 2);
Zend := R * sin (Theta + DT / 2);

X := (Xstart + Xend) / 2 ;
Z := (Zstart + Zend) / 2 ;
Yaw :=- Theta * 180 / pi ;
Theta := Theta + DT ;
if z = 0 then
begin
form1.Canvas.MoveTo(700+round(x),700+round(z));
form1.Canvas.LineTo(700+round(x),700+round(z));
end;
form1.Canvas.LineTo(700+round(x),700+round(z));

// form1.Canvas.MoveTo(700+round(x),700+round(z));
form1.Canvas.TextOut(700+round(x),700+round(z),inttostr(n2));

inc(n2);
RichEdit1.Lines.Add(' <entry index="'+intToStr(n2)+'"'+' macro="struct_ter_base_01_macro"'+' '+' connection="connectionsnap002">');
RichEdit1.Lines.Add(' <offset>');
RichEdit1.Lines.Add(' <position x="'+RealToStr(X)+'"'+' y="'+RealToStr(z)+'"'+' z="'+RealToStr(Y)+'"'+'/>');
RichEdit1.Lines.Add(' <rotation yaw="90.0"'+' '+'pitch="'+RealToStr(90-yaw)+'"/>');
RichEdit1.Lines.Add(' </offset>');
RichEdit1.Lines.Add(' </entry>');
// RichEdit1.Lines.Add(' ');
edit1.Text:=inttostr(n2);

end;

end;
j'avais fait le code en cbuilder mais cela produit la même chose!
merci pour le tuto!!

Capture d’écran (469).png

[UnholyForager]

Sorry for the late reply. It seems in that first picture the rendering program is assuming you are drawing a line from the origin to a point. Looks like you have it figured out though, I'm glad you found this guide useful!