| [5333] | 1 | ---------------------------------------------------------------------------------------------------- |
|---|
| 2 | -- This lua script creates a totally random generated space station for the orxonox computer game!-- |
|---|
| 3 | -- (c) Wallah 2008, published under GPL licence! -- |
|---|
| 4 | ---------------------------------------------------------------------------------------------------- |
|---|
| 5 | |
|---|
| 6 | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 7 | -- IMPORTANT: If you need more parameters, do the following: copy the actual function (just the headline and the end statement) to the end of the file, -- |
|---|
| 8 | -- like I did with createSpaceStation() and let that function call the new function where you can modify the parameters. For all parameters which the old function-- |
|---|
| 9 | -- doesn't have you just give the standard default values, which I have defined. This is to make sure, that anyone else who uses the old function can still use it-- |
|---|
| 10 | -- the same way he/she always did. If you want a function with less parameters, just create a new one at the end of the file and call this function with some -- |
|---|
| 11 | -- default values. REMEMBER: Function overloading is not possible, be sure to call your function differently from others already existing ones. -- |
|---|
| 12 | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 13 | |
|---|
| 14 | -- This function creates a randomly generated space station. |
|---|
| [5341] | 15 | -- The first argument ranSeed, must be 0, or a positive Integer, if it is 0 your space station is always chosen randomly, if you give an integer, |
|---|
| [5333] | 16 | -- your space station will be generated randomly, but once you have the space station it will always be the same. |
|---|
| 17 | -- The argument xLength defines how large the space station will be into the x-direction. |
|---|
| 18 | -- The argument xVar defines how much the space station will vary at the ends in x-direction, this is so that the station is no cube. |
|---|
| 19 | -- The argument yLength is the same as xLength, but for the y-direction. |
|---|
| 20 | -- The argument yVar is the same as xLength, but for the y-direction. |
|---|
| 21 | -- The argument zLength is the same as xLength, but for the z-direction. |
|---|
| 22 | -- The argument zVar is the same as xLength, but for the z-direction. |
|---|
| 23 | -- The argument sSScale scales the station proportionally in all directions. |
|---|
| 24 | function createSpaceStationPar(ranSeed, xLength, xVar, yLength, yVar, zLength, zVar, sSScale) |
|---|
| 25 | |
|---|
| 26 | |
|---|
| 27 | |
|---|
| 28 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 29 | -- This prints xml code, which creates a MovableEntity, which I need to attach all the parts of the space station. |
|---|
| 30 | print("<MovableEntity scale=1 position=\"0,0,0\" >") |
|---|
| 31 | -- End create Movable Entity. |
|---|
| 32 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 33 | |
|---|
| 34 | |
|---|
| 35 | |
|---|
| 36 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 37 | -- Create a randomseed, so that the math.random() function is actually random. |
|---|
| [5341] | 38 | if ranSeed == 0 then |
|---|
| [5333] | 39 | math.randomseed(os.time()) |
|---|
| 40 | else |
|---|
| 41 | math.randomseed(ranSeed) |
|---|
| 42 | end |
|---|
| 43 | -- End create randomseed. |
|---|
| 44 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 45 | |
|---|
| 46 | |
|---|
| 47 | |
|---|
| 48 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 49 | -- Here you can define some global variables, with which you can modify the space station. |
|---|
| 50 | |
|---|
| 51 | -- Define the maximal size of the grid, this value is based on how large you define the area of bodyparts plus 20 gridpoints for attachparts. |
|---|
| 52 | sSSize=30 |
|---|
| 53 | if xLength>=yLength and xLength>=zLength then |
|---|
| 54 | sSSize=xLength+20 |
|---|
| 55 | elseif yLength>=xLength and yLength>=zLength then |
|---|
| 56 | sSSize=yLength+20 |
|---|
| 57 | elseif zLength>=xLength and zLength>=yLength then |
|---|
| 58 | sSSize=zLength+20 |
|---|
| 59 | end |
|---|
| 60 | -- Define how many parts the space station has, this value has to be exact, so be sure to increment it if you're adding a new part. |
|---|
| 61 | sSParts=9 |
|---|
| 62 | -- Define how many body parts the space station has, this value has to be exact. Body part means a part, which has connections at least in two directions. |
|---|
| 63 | sSBodyParts=3 |
|---|
| 64 | -- Define how many frontParts you have. |
|---|
| 65 | frontParts=1 |
|---|
| 66 | -- Define how many backParts you have. |
|---|
| 67 | backParts=1 |
|---|
| 68 | -- Define how many side parts for the left side you have. |
|---|
| 69 | leftSideParts=1 |
|---|
| 70 | -- Define how many side parts for the right side you have. |
|---|
| 71 | rightSideParts=1 |
|---|
| 72 | -- Define how many top parts you have. |
|---|
| 73 | topParts=2 |
|---|
| 74 | -- Define how many connection parts you have. |
|---|
| 75 | connParts=1 |
|---|
| 76 | -- Define the maximal dimension of a single part, be sure this value is big enough, better it's too big, it's only a matter of efficiency. |
|---|
| 77 | -- It should be at least 1 bigger than the biggest part needs, because I guarantee that it works with odd numbers, to do so I use the math.floor function. |
|---|
| 78 | pDim=6 |
|---|
| 79 | -- Define the griddimension, be sure this value matches the size of a single space station part plus the size of a connection part, which means your parts must be: |
|---|
| 80 | -- integer*(gridDim-connectionSize), then integer tells you how many griddimensions your part is. |
|---|
| 81 | gridDim=2.25 |
|---|
| 82 | -- End define global parameters. |
|---|
| 83 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 84 | |
|---|
| 85 | |
|---|
| 86 | |
|---|
| 87 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 88 | -- This creates a 4-dimensional grid, which tells us if there is a part or not, and in which direction it has connections. |
|---|
| 89 | -- The parameters x,y,z are the axis of the space station, which iterate to sSSize, the maximal size of the space station. |
|---|
| 90 | -- The griddimension, this word I will use later, means that the distance of a point to the next point is gridDim in the game, so the absolute x-axis is x*gridDim*sSScale, |
|---|
| 91 | -- and so on for the other dimensions y and z. |
|---|
| 92 | -- grid[x][y][z][0] contains 0 if there is no part at the position (x,y,z), otherwise 1. |
|---|
| 93 | -- grid[x][y][z][1] contains 0 if there is no connection from (x,y,z) in x-direction, "+" if there is one in the positive x-direction, |
|---|
| 94 | -- "-" if there is one in the negative x-direction, "+-" if there are in both x-directions. |
|---|
| 95 | -- grid[x][y][z][2] contains 0 if there is no connection from (x,y,z) in y-direction, "+" if there is one in the positive y-direction, |
|---|
| 96 | -- "-" if there is one in the negative y-direction, "+-" if there are in both y-directions. |
|---|
| 97 | -- grid[x][y][z][3] contains 0 if there is no connection from (x,y,z) in z-direction, "+" if there is one in the positive z-direction, |
|---|
| 98 | -- "-" if there is one in the negative z-direction, "+-" if there are in both z-directions. |
|---|
| 99 | grid = {} |
|---|
| 100 | for x=-math.floor(sSSize/2),math.floor(sSSize/2) do |
|---|
| 101 | grid[x] = {} |
|---|
| 102 | for y=-math.floor(sSSize/2),math.floor(sSSize/2) do |
|---|
| 103 | grid[x][y]= {} |
|---|
| 104 | for z=-math.floor(sSSize/2),math.floor(sSSize/2) do |
|---|
| 105 | grid[x][y][z]={} |
|---|
| 106 | for i=0,3 do |
|---|
| 107 | grid[x][y][z][i]=0 |
|---|
| 108 | end |
|---|
| 109 | end |
|---|
| 110 | end |
|---|
| 111 | end |
|---|
| 112 | -- End create 4-dim grid. |
|---|
| 113 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 114 | |
|---|
| 115 | |
|---|
| 116 | |
|---|
| 117 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 118 | -- This creates an array which stores all the parts, it's size is depending on the global values pDim and sSParts. |
|---|
| 119 | -- The first parameter i, tells us how many parts fit into the array, so it iterates from 1 to sSParts, each part has his own value i. |
|---|
| 120 | -- The second, third and fourth parameters are the relative coordinates of the part, you have to start at (0,0,0) and be sure you fill the array into the right direction. |
|---|
| 121 | -- A short example: your part is 2 griddimensions long and you place it in the game, that the relative coordinate point is at (0,0,0) and the part lies in the positive |
|---|
| 122 | -- z-axis, then you have to use the coordinate point (0,0,1). |
|---|
| 123 | -- The fifth parameter is an array with size 4, at index=0, you have to set 1 if your part covers the gridpoint at (x,y,z), otherwise 0. |
|---|
| 124 | -- At index=1,2,3 you define the possible connection directions (1 for x, 2 for y and 3 for z), be sure to use the notation from above (0, "+-", "+", "-"). |
|---|
| 125 | bodyParts={} |
|---|
| 126 | for i=1,sSParts do |
|---|
| 127 | bodyParts[i]={} |
|---|
| 128 | for x=-math.floor(pDim/2),math.floor(pDim/2) do |
|---|
| 129 | bodyParts[i][x]={} |
|---|
| 130 | for y=-math.floor(pDim/2),math.floor(pDim/2) do |
|---|
| 131 | bodyParts[i][x][y]={} |
|---|
| 132 | for z=-math.floor(pDim/2),math.floor(pDim/2) do |
|---|
| 133 | bodyParts[i][x][y][z]={} |
|---|
| 134 | for k=0,3 do |
|---|
| 135 | bodyParts[i][x][y][z][k]=0 |
|---|
| 136 | end |
|---|
| 137 | end |
|---|
| 138 | end |
|---|
| 139 | end |
|---|
| 140 | -- This contains the name of the mesh file. |
|---|
| 141 | bodyParts[i][0][0][0][4]="" |
|---|
| 142 | -- This contains the first possible rotation of your part, pitch=... yaw=... roll=... . |
|---|
| 143 | bodyParts[i][0][0][0][5]="" |
|---|
| 144 | -- This contains the second possible rotation of your part, pitch=... yaw=... roll=... . |
|---|
| 145 | bodyParts[i][0][0][0][6]="" |
|---|
| 146 | -- This contains the third possible rotation of your part, pitch=... yaw=... roll=... . |
|---|
| 147 | bodyParts[i][0][0][0][7]="" |
|---|
| 148 | -- Contains the movement rotation, rotationaxis=... rotationrate=... . |
|---|
| 149 | bodyParts[i][0][0][0][8]="" |
|---|
| 150 | -- Contains the attachment, if your part has an attachment, e.g. <ParticleEmitter .../>. |
|---|
| 151 | bodyParts[i][0][0][0][9]="" |
|---|
| 152 | -- Contains how many of this part you want to attach to your space station. |
|---|
| 153 | bodyParts[i][0][0][0][10]=1 |
|---|
| 154 | end |
|---|
| 155 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 156 | |
|---|
| 157 | |
|---|
| 158 | |
|---|
| 159 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 160 | -- Here you can add a part to the space station, there are some examples here and how to describe your part is written above in the commentary. |
|---|
| 161 | |
|---|
| 162 | -- The part must be inserted so, that the center of reference is at position (0,0,0). |
|---|
| 163 | -- At position bodyParts[i][0][0][0][4] you have to put the mesh name of your part. |
|---|
| 164 | -- At bodyParts[i][0][0][0][5] you can rotate your part, with pitch=angle, yaw=angle or roll=angle (x,y or z). Positive angle means in screw direction. |
|---|
| 165 | -- At bodyParts[i][0][0][0][6] you have another possibility to rotate your part in a different way, e.g. for left and right side parts. |
|---|
| 166 | -- At bodyParts[i][0][0][0][7] you have a third possibility to rotate your part, e.g. connection parts must be rotated into 3 different ways. |
|---|
| 167 | -- At bodyParts[i][0][0][0][8] you can rotate your part around his own axis, with rotationaxis="x,y,z" rotationrate=number. |
|---|
| 168 | -- At bodyParts[i][0][0][0][9] you can attach something to your model, e.g. <ParticleEmitter .../>. |
|---|
| 169 | |
|---|
| 170 | -- Insert the CuboidBody, which is only one griddimension and can have connections in every direction. |
|---|
| 171 | bodyParts[1][0][0][0][4]="CuboidBody.mesh" |
|---|
| 172 | |
|---|
| 173 | bodyParts[1][0][0][0][0]=1 |
|---|
| 174 | bodyParts[1][0][0][0][1]="+-" |
|---|
| 175 | bodyParts[1][0][0][0][2]="+-" |
|---|
| 176 | bodyParts[1][0][0][0][3]="+-" |
|---|
| 177 | -- End insert CuboidBody. |
|---|
| 178 | |
|---|
| 179 | -- Insert the DoubleCuboidBody, which is two griddimensions long, and one wide and high and can have connections in every direction except in the middle. |
|---|
| 180 | bodyParts[2][0][0][0][4]="DoubleCuboidBody.mesh" |
|---|
| 181 | bodyParts[2][0][0][0][5]="pitch=-90" |
|---|
| 182 | |
|---|
| 183 | bodyParts[2][0][0][0][0]=1 |
|---|
| 184 | bodyParts[2][0][0][0][1]="+-" |
|---|
| 185 | bodyParts[2][0][0][0][2]="+-" |
|---|
| 186 | bodyParts[2][0][0][0][3]="-" |
|---|
| 187 | |
|---|
| 188 | bodyParts[2][0][0][1][0]=1 |
|---|
| 189 | bodyParts[2][0][0][1][1]="+-" |
|---|
| 190 | bodyParts[2][0][0][1][2]="+-" |
|---|
| 191 | bodyParts[2][0][0][1][3]="+" |
|---|
| 192 | -- End insert DoubleCuboidBody. |
|---|
| 193 | |
|---|
| 194 | -- Insert the CuboidConnectionBody, it is three griddimensions long and one wide and high and can have only connections at griddimension 1 |
|---|
| 195 | -- (except the side in direction of griddimension 2) and griddimension 3 (except the side in direction of griddimension 2). |
|---|
| [5365] | 196 | bodyParts[3][0][0][0][4]="CuboidConnBody.mesh" |
|---|
| [5333] | 197 | bodyParts[3][0][0][0][5]="pitch=-90" |
|---|
| 198 | |
|---|
| 199 | bodyParts[3][0][0][0][0]=1 |
|---|
| 200 | bodyParts[3][0][0][0][1]="+-" |
|---|
| 201 | bodyParts[3][0][0][0][2]="+-" |
|---|
| 202 | bodyParts[3][0][0][0][3]="-" |
|---|
| 203 | |
|---|
| 204 | bodyParts[3][0][0][1][0]=1 |
|---|
| 205 | |
|---|
| 206 | bodyParts[3][0][0][2][0]=1 |
|---|
| 207 | bodyParts[3][0][0][2][1]="+-" |
|---|
| 208 | bodyParts[3][0][0][2][2]="+-" |
|---|
| 209 | bodyParts[3][0][0][2][3]="+" |
|---|
| 210 | -- End insert CuboidConnectionBody. |
|---|
| 211 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 212 | |
|---|
| 213 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 214 | -- Insert the back parts. |
|---|
| 215 | -- If you're space station has no back parts, be sure to set backPartsIndex[0]=false. |
|---|
| 216 | backPartsIndex={} |
|---|
| 217 | backPartsIndex[0]="" |
|---|
| 218 | |
|---|
| [5365] | 219 | -- Insert the thruster, which is one griddimension long, two wide and high, it can only have a connection into the negative z-direction. |
|---|
| [5333] | 220 | backPartsIndex[1]=4 |
|---|
| 221 | bodyParts[backPartsIndex[1]][0][0][0][4]="Thruster.mesh" |
|---|
| 222 | bodyParts[backPartsIndex[1]][0][0][0][5]="pitch=-90" |
|---|
| [5372] | 223 | bodyParts[backPartsIndex[1]][0][0][0][9]="<ParticleEmitter position=\"0,-0.5,0\" source=\"Orxonox/ThrusterFire\" />" |
|---|
| [5333] | 224 | bodyParts[backPartsIndex[1]][0][0][0][10]=5 |
|---|
| 225 | |
|---|
| 226 | bodyParts[backPartsIndex[1]][0][0][0][0]=1 |
|---|
| 227 | bodyParts[backPartsIndex[1]][0][0][0][3]="-" |
|---|
| [5365] | 228 | bodyParts[backPartsIndex[1]][1][0][0][0]=1 |
|---|
| 229 | bodyParts[backPartsIndex[1]][-1][0][0][0]=1 |
|---|
| 230 | bodyParts[backPartsIndex[1]][0][1][0][0]=1 |
|---|
| 231 | bodyParts[backPartsIndex[1]][0][-1][0][0]=1 |
|---|
| [5333] | 232 | -- End insert the thruster. |
|---|
| 233 | |
|---|
| 234 | -- End insert the back parts. |
|---|
| 235 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 236 | |
|---|
| 237 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 238 | -- Insert the front parts. If your space station has no front parts, be sure to set frontPartsIndex[0]=false. |
|---|
| 239 | frontPartsIndex={} |
|---|
| 240 | frontPartsIndex[0]="" |
|---|
| 241 | |
|---|
| 242 | -- The SemiCircleCockpit is 3 x-griddimensions long, 3 y-griddimensions and 2 z-griddimensions, it can only have a connection in the positive z-direction. |
|---|
| 243 | frontPartsIndex[1]=5 |
|---|
| 244 | bodyParts[frontPartsIndex[1]][0][0][0][4]="SemiCircleCockpit.mesh" |
|---|
| 245 | bodyParts[frontPartsIndex[1]][0][0][0][5]="pitch=-90 yaw=180" |
|---|
| [5365] | 246 | bodyParts[frontPartsIndex[1]][0][0][0][9]="<Billboard scale=0.01 position=\"0,-0.1,2.2\" colour=\"1.0,1.0,1.0\" material=\"Examples/Flare\" /> <Billboard scale=0.01 position=\"0.5,-0.1,2.2\" colour=\"1.0,1.0,1.0\" material=\"Examples/Flare\" /> <Billboard scale=0.01 position=\"-0.5,-0.1,2.2\" colour=\"1.0,1.0,1.0\" material=\"Examples/Flare\" />" |
|---|
| [5333] | 247 | |
|---|
| 248 | bodyParts[frontPartsIndex[1]][0][0][0][0]=1 |
|---|
| 249 | bodyParts[frontPartsIndex[1]][0][0][0][3]="+" |
|---|
| 250 | |
|---|
| 251 | bodyParts[frontPartsIndex[1]][-1][0][0][0]=1 |
|---|
| 252 | bodyParts[frontPartsIndex[1]][1][0][0][0]=1 |
|---|
| 253 | bodyParts[frontPartsIndex[1]][0][-1][0][0]=1 |
|---|
| 254 | bodyParts[frontPartsIndex[1]][0][1][0][0]=1 |
|---|
| 255 | bodyParts[frontPartsIndex[1]][-1][-1][0][0]=1 |
|---|
| 256 | bodyParts[frontPartsIndex[1]][1][-1][0][0]=1 |
|---|
| 257 | bodyParts[frontPartsIndex[1]][-1][1][0][0]=1 |
|---|
| 258 | bodyParts[frontPartsIndex[1]][1][1][0][0]=1 |
|---|
| 259 | bodyParts[frontPartsIndex[1]][0][0][-1][0]=1 |
|---|
| 260 | bodyParts[frontPartsIndex[1]][-1][0][-1][0]=1 |
|---|
| 261 | bodyParts[frontPartsIndex[1]][1][0][-1][0]=1 |
|---|
| 262 | bodyParts[frontPartsIndex[1]][0][-1][-1][0]=1 |
|---|
| 263 | bodyParts[frontPartsIndex[1]][0][1][-1][0]=1 |
|---|
| 264 | bodyParts[frontPartsIndex[1]][-1][-1][-1][0]=1 |
|---|
| 265 | bodyParts[frontPartsIndex[1]][1][-1][-1][0]=1 |
|---|
| 266 | bodyParts[frontPartsIndex[1]][-1][1][-1][0]=1 |
|---|
| 267 | bodyParts[frontPartsIndex[1]][1][1][-1][0]=1 |
|---|
| 268 | -- End insert SemiCircleCockpit. |
|---|
| 269 | |
|---|
| 270 | -- End insert the front parts. |
|---|
| 271 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 272 | |
|---|
| 273 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 274 | -- Insert the side parts. |
|---|
| 275 | -- If your space station has no left side parts, be sure to set leftsidePartsIndex[0]=false. |
|---|
| 276 | -- If your space station has no right side parts, be sure to set rightsidePartsIndex[0]=false. |
|---|
| 277 | leftSidePartsIndex={} |
|---|
| 278 | leftSidePartsIndex[0]="" |
|---|
| 279 | rightSidePartsIndex={} |
|---|
| 280 | rightSidePartsIndex[0]="" |
|---|
| 281 | |
|---|
| 282 | -- Insert the solar panel, which i wanna use as left and right side part. |
|---|
| 283 | leftSidePartsIndex[1]=6 |
|---|
| 284 | rightSidePartsIndex[1]=leftSidePartsIndex[1] |
|---|
| 285 | bodyParts[leftSidePartsIndex[1]][0][0][0][4]="SolarPanel.mesh" |
|---|
| 286 | bodyParts[leftSidePartsIndex[1]][0][0][0][5]="roll=90 pitch="..math.random(0,180) |
|---|
| 287 | bodyParts[rightSidePartsIndex[1]][0][0][0][6]="roll=-90 pitch="..math.random(0,180) |
|---|
| 288 | bodyParts[rightSidePartsIndex[1]][0][0][0][8]="rotationaxis=\"1,0,0\" rotationrate=2" |
|---|
| 289 | bodyParts[leftSidePartsIndex[1]][0][0][0][0]=1 |
|---|
| 290 | bodyParts[leftSidePartsIndex[1]][0][0][1][0]=1 |
|---|
| 291 | bodyParts[leftSidePartsIndex[1]][0][0][-1][0]=1 |
|---|
| 292 | bodyParts[leftSidePartsIndex[1]][0][1][0][0]=1 |
|---|
| 293 | bodyParts[leftSidePartsIndex[1]][0][1][1][0]=1 |
|---|
| 294 | bodyParts[leftSidePartsIndex[1]][0][1][-1][0]=1 |
|---|
| 295 | bodyParts[leftSidePartsIndex[1]][0][-1][0][0]=1 |
|---|
| 296 | bodyParts[leftSidePartsIndex[1]][0][-1][1][0]=1 |
|---|
| 297 | bodyParts[leftSidePartsIndex[1]][0][-1][-1][0]=1 |
|---|
| 298 | -- End insert solar panel. |
|---|
| 299 | |
|---|
| 300 | -- End insert side parts. |
|---|
| 301 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 302 | |
|---|
| 303 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 304 | -- Insert the top parts. |
|---|
| 305 | -- If you have no top parts, be sure to set topPartsIndex[0]=false |
|---|
| 306 | topPartsIndex={} |
|---|
| 307 | topPartsIndex[0]="" |
|---|
| 308 | |
|---|
| 309 | -- Insert the CuboidLandingZone. |
|---|
| 310 | topPartsIndex[1]=7 |
|---|
| 311 | bodyParts[topPartsIndex[1]][0][0][0][4]="CuboidLandingZone.mesh" |
|---|
| 312 | bodyParts[topPartsIndex[1]][0][0][0][5]="pitch=-90" |
|---|
| 313 | |
|---|
| 314 | bodyParts[topPartsIndex[1]][0][0][0][0]=1 |
|---|
| 315 | bodyParts[topPartsIndex[1]][0][0][0][2]="+-" |
|---|
| 316 | bodyParts[topPartsIndex[1]][1][0][0][0]=1 |
|---|
| 317 | bodyParts[topPartsIndex[1]][-1][0][0][0]=1 |
|---|
| 318 | bodyParts[topPartsIndex[1]][0][0][1][0]=1 |
|---|
| 319 | bodyParts[topPartsIndex[1]][1][0][1][0]=1 |
|---|
| 320 | bodyParts[topPartsIndex[1]][-1][0][1][0]=1 |
|---|
| 321 | bodyParts[topPartsIndex[1]][0][0][2][0]=1 |
|---|
| 322 | bodyParts[topPartsIndex[1]][1][0][2][0]=1 |
|---|
| 323 | bodyParts[topPartsIndex[1]][-1][0][2][0]=1 |
|---|
| 324 | bodyParts[topPartsIndex[1]][0][0][3][0]=1 |
|---|
| 325 | bodyParts[topPartsIndex[1]][1][0][3][0]=1 |
|---|
| 326 | bodyParts[topPartsIndex[1]][-1][0][3][0]=1 |
|---|
| 327 | -- End insert the CuboidLandingZone. |
|---|
| 328 | |
|---|
| 329 | -- Insert the SatelliteDish. |
|---|
| 330 | topPartsIndex[2]=8 |
|---|
| 331 | bodyParts[topPartsIndex[2]][0][0][0][4]="SatelliteDish.mesh" |
|---|
| 332 | bodyParts[topPartsIndex[2]][0][0][0][5]="pitch=-90" |
|---|
| 333 | bodyParts[topPartsIndex[2]][0][0][0][8]="rotationaxis=\"0,1,0\" rotationrate=5" |
|---|
| 334 | |
|---|
| 335 | bodyParts[topPartsIndex[2]][0][0][0][0]=1 |
|---|
| 336 | bodyParts[topPartsIndex[2]][0][0][1][0]=1 |
|---|
| 337 | bodyParts[topPartsIndex[2]][0][0][-1][0]=1 |
|---|
| 338 | bodyParts[topPartsIndex[2]][1][0][0][0]=1 |
|---|
| 339 | bodyParts[topPartsIndex[2]][1][0][1][0]=1 |
|---|
| 340 | bodyParts[topPartsIndex[2]][1][0][-1][0]=1 |
|---|
| 341 | bodyParts[topPartsIndex[2]][-1][0][0][0]=1 |
|---|
| 342 | bodyParts[topPartsIndex[2]][-1][0][1][0]=1 |
|---|
| 343 | bodyParts[topPartsIndex[2]][-1][0][-1][0]=1 |
|---|
| 344 | -- End insert the SatelliteDish. |
|---|
| 345 | |
|---|
| 346 | -- End insert the top parts. |
|---|
| 347 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 348 | |
|---|
| 349 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 350 | -- Insert the connection parts, which are used to connect all the bodyparts. |
|---|
| 351 | -- If you're spacestation has no connection parts, be sure to set connPartsIndex[0]=false. |
|---|
| 352 | connPartsIndex={} |
|---|
| 353 | connPartsIndex[0]="" |
|---|
| 354 | |
|---|
| 355 | -- Insert the CuboidConnection. |
|---|
| 356 | connPartsIndex[1]=9 |
|---|
| 357 | bodyParts[connPartsIndex[1]][0][0][0][4]="CuboidConnection.mesh" |
|---|
| 358 | bodyParts[connPartsIndex[1]][0][0][0][5]="roll=90" |
|---|
| 359 | bodyParts[connPartsIndex[1]][0][0][0][6]="" |
|---|
| 360 | bodyParts[connPartsIndex[1]][0][0][0][7]="pitch=90" |
|---|
| 361 | -- End insert the CuboidConnection. |
|---|
| 362 | |
|---|
| 363 | -- End insert the connection parts. |
|---|
| 364 | |
|---|
| 365 | -- End create array bodyParts. |
|---|
| 366 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 367 | |
|---|
| 368 | |
|---|
| 369 | |
|---|
| 370 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 371 | -- Here I define some functions which I will use later. |
|---|
| 372 | |
|---|
| 373 | --This function actualizes the grid, which I have to call always after I have added a new part to the space station. |
|---|
| 374 | function actualizeGrid(Index,x,y,z) |
|---|
| 375 | for i=math.floor(-pDim/2)+1,math.floor(pDim/2) do |
|---|
| 376 | for j=math.floor(-pDim/2)+1,math.floor(pDim/2) do |
|---|
| 377 | for k=math.floor(-pDim/2)+1,math.floor(pDim/2) do |
|---|
| 378 | if bodyParts[Index][i][j][k][0] == 1 then |
|---|
| 379 | for l=0,3 do |
|---|
| 380 | grid[x+i][y+j][z+k][l] = bodyParts[Index][i][j][k][l] |
|---|
| 381 | end |
|---|
| 382 | end |
|---|
| 383 | end |
|---|
| 384 | end |
|---|
| 385 | end |
|---|
| 386 | end |
|---|
| 387 | -- End actualizeGrid. |
|---|
| 388 | |
|---|
| 389 | -- This function checks wheter a given parts fits at that position or not. |
|---|
| 390 | -- If the part fits there it returns 1, otherwise 0. |
|---|
| 391 | function checkPart(Index,x,y,z) |
|---|
| 392 | check=1 |
|---|
| 393 | for i=math.floor(-pDim/2)+1,math.floor(pDim/2) do |
|---|
| 394 | for j=math.floor(-pDim/2)+1,math.floor(pDim/2) do |
|---|
| 395 | for k=math.floor(-pDim/2)+1,math.floor(pDim/2) do |
|---|
| 396 | -- If the part occupies the position (i,j,k), the grid must be empty there ((x+i, y+j, z+k)==0), if not, check is zero, |
|---|
| 397 | -- which means that the part doesn't fit there. |
|---|
| 398 | if bodyParts[Index][i][j][k][0] == 1 and grid[x+i][y+j][z+k][0] == 1 then |
|---|
| 399 | check=0 |
|---|
| 400 | end |
|---|
| 401 | end |
|---|
| 402 | end |
|---|
| 403 | end |
|---|
| 404 | return check |
|---|
| 405 | end |
|---|
| 406 | -- End checkPart function. |
|---|
| 407 | |
|---|
| 408 | -- This function prints the model with tempPartIndex in the bodyParts array at position lx,ly,lz. |
|---|
| 409 | -- If you need to rotate the model around his own axis, then you have to set movEntity true and define the details of the rotation in |
|---|
| 410 | -- bodyParts[tempPartIndex][0][0][0][8]. |
|---|
| 411 | -- If your model needs to be rotated like bodyParts[tempPartIndex][0][0][0][5], then side must be 1, for bodyParts[tempPartIndex][0][0][0][6] side must be 2, |
|---|
| 412 | -- for bodyParts[tempPartIndex][0][0][0][7] side must be 3. |
|---|
| 413 | function printModel(lx,ly,lz,tempPartIndex,movEntity,side) |
|---|
| 414 | if movEntity == true then |
|---|
| 415 | print("<MovableEntity scale=1 position=\"") print(lx*gridDim*sSScale) print(",") print(ly*gridDim*sSScale) print(",") print(lz*gridDim*sSScale) print("\" ") |
|---|
| 416 | print(bodyParts[tempPartIndex][0][0][0][8]) print(">") |
|---|
| 417 | print("<attached>") |
|---|
| 418 | lx=0 ly=0 lz=0 |
|---|
| 419 | end |
|---|
| 420 | |
|---|
| 421 | print("<Model position=\"") print(lx*gridDim*sSScale) print(",") print(ly*gridDim*sSScale) print(",") print(lz*gridDim*sSScale) |
|---|
| 422 | print("\" scale=") print(sSScale) print(" mesh= \"") print(bodyParts[tempPartIndex][0][0][0][4]) print("\"") |
|---|
| 423 | |
|---|
| 424 | if side == 1 then |
|---|
| 425 | print(bodyParts[tempPartIndex][0][0][0][5]) print(">") |
|---|
| 426 | elseif side == 2 then |
|---|
| 427 | print(bodyParts[tempPartIndex][0][0][0][6]) print(">") |
|---|
| 428 | elseif side == 3 then |
|---|
| 429 | print(bodyParts[tempPartIndex][0][0][0][7]) print(">") |
|---|
| 430 | end |
|---|
| 431 | |
|---|
| [5417] | 432 | print("<attached>") |
|---|
| 433 | print(bodyParts[tempPartIndex][0][0][0][9]) |
|---|
| [5333] | 434 | print("</attached>") |
|---|
| 435 | |
|---|
| 436 | print("</Model>") |
|---|
| 437 | |
|---|
| 438 | if movEntity == true then |
|---|
| 439 | print("</attached>") |
|---|
| 440 | print("</MovableEntity>") |
|---|
| 441 | end |
|---|
| 442 | end |
|---|
| 443 | -- End function printModel(). |
|---|
| 444 | |
|---|
| 445 | -- This function sets a part to a side of the space station. |
|---|
| 446 | -- The arguments lx,ly,lz are the coordinates of the grid, where you want to set the part. |
|---|
| 447 | -- The arguments xAxis,yAxis,zAxis can be 0 or 1, but only one argument out of the three can be 1. This means two of them must always be zero. You have to set xAxis to one, |
|---|
| 448 | -- if your part is attached to a side, which faces into the x-direction (negative or positive, this is later specified with Dir), that means the x-Axis is a normal vector |
|---|
| 449 | -- of the side to which you want to attach the part. The same for yAxis and zAxis. |
|---|
| 450 | -- The argument Dir must be 1 if your side, where you want to attach the part, faces into the positive direction, -1 if the side faces into the negative direction. The side |
|---|
| 451 | -- faces into the positive direction means, that the side of the side where the part will be attached is directed into the direction of the positive direction of the |
|---|
| 452 | -- corresponding axis. |
|---|
| 453 | -- The argument index is the index of the part for the bodyParts array. |
|---|
| 454 | -- The argument printMovEnt must be false if your part doesn't need to be attached to an extra MovableEntity. If your part must be attached to an extra MovableEntity |
|---|
| 455 | -- this argument must be true. The extra MovableEntity is used to rotate the part around his own axis, or something like that. |
|---|
| 456 | -- The argument printSide is like the argument side of the printModel() function. It defines how your part will be rotated. Read the commentary there. |
|---|
| 457 | -- The function returns 0 if the part couldn't be set, because it did not fit there or there was no side to attach the part. It returns 1 if the part is successfully set. |
|---|
| 458 | function setPart(lx,ly,lz,xAxis,yAxis,zAxis,Dir,index,printMovEnt,printSide) |
|---|
| 459 | |
|---|
| 460 | partSet=0 |
|---|
| 461 | -- For the bodyParts array I use 1 as x-, 2 as y- and 3 as z-Axis for the definition in which directions a part can have connections. |
|---|
| 462 | coord=1*xAxis+2*yAxis+3*zAxis |
|---|
| 463 | -- If I try to attach the part from the positive direction to the side of the space station, the part of the station (where I want to attach the new part) must have |
|---|
| 464 | -- a connection into the positive direction. Otherwise I look from the negative side and so the part of the station must have a connection into the negative direction. |
|---|
| 465 | if Dir==1 then |
|---|
| 466 | conn="+" |
|---|
| 467 | elseif Dir==-1 then |
|---|
| 468 | conn="-" |
|---|
| 469 | end |
|---|
| 470 | -- I look from the direction defined through Dir, and here I check, whether I have reached a side of the space station, which means at position lx,ly,lz is nothing and |
|---|
| 471 | -- at the next position is a part which can have a connection into the direction from where I look. |
|---|
| 472 | if grid[lx][ly][lz][0] == 0 and grid[lx+(-1*xAxis*Dir)][ly+(-1*yAxis*Dir)][lz+(-1*zAxis*Dir)][0] == 1 and (grid[lx+(-1*xAxis*Dir)][ly+(-1*yAxis*Dir)][lz+(-1*zAxis*Dir)][coord]=="+-" or grid[lx+(-1*xAxis*Dir)][ly+(-1*yAxis*Dir)][lz+(-1*zAxis*Dir)][coord]==conn) then |
|---|
| 473 | -- This checks whether the part fits at that position or not. |
|---|
| 474 | check=checkPart(index,lx,ly,lz) |
|---|
| 475 | if check == 1 then |
|---|
| 476 | -- This prints the part. |
|---|
| 477 | printModel(lx,ly,lz,index,printMovEnt,printSide) |
|---|
| 478 | partSet=1 |
|---|
| 479 | -- This actualizes the grid array with the values of the array bodyParts at the position index. |
|---|
| 480 | actualizeGrid(index,lx,ly,lz) |
|---|
| 481 | end |
|---|
| 482 | end |
|---|
| 483 | return partSet |
|---|
| 484 | end |
|---|
| 485 | -- End function setPart(). |
|---|
| 486 | |
|---|
| 487 | -- This function sets a part to a side of the space station. It is called spiralSet, because it starts in the middle of the side and goes out in a form of a spiral. |
|---|
| 488 | -- The argument xAxis,yAxis,zAxis,Dir,printMovEnt,printSide are the same as the arguments from the setPart() function, please read the commentary there. |
|---|
| 489 | -- The argument index here must be an array, where you define the index for your part for the bodyParts array. The first used index is 1 and goes up to parts. |
|---|
| 490 | -- The argument parts is the number of different parts which you want to attach to a side. |
|---|
| 491 | function spiralSet(xAxis,yAxis,zAxis,Dir,index,parts,printMovEnt,printSide) |
|---|
| 492 | if index[0] ~= false then |
|---|
| 493 | -- The array vector contains the actual position where you try to set the part. vector[0],vector[1] and vector[3] contains the x,y,z-coordinate. |
|---|
| 494 | vector={} |
|---|
| 495 | -- This must be done, because there are different sides from where I try to attach a part. |
|---|
| 496 | coord1=1*yAxis+2*zAxis |
|---|
| [5524] | 497 | coord2=math.mod(coord1+1,3) |
|---|
| 498 | coord3=math.mod(coord2+1,3) |
|---|
| [5333] | 499 | |
|---|
| 500 | for pc=1,parts do |
|---|
| 501 | tempIndex = index[pc] |
|---|
| 502 | for eachPart=1,bodyParts[tempIndex][0][0][0][10] do |
|---|
| 503 | partSet=0 |
|---|
| 504 | vector[coord1]=math.floor(Dir*sSSize/2)-2*Dir |
|---|
| 505 | while vector[coord1]~=math.floor(-1*Dir*sSSize/2)+2*Dir and partSet==0 do |
|---|
| 506 | round=0 |
|---|
| 507 | while round<=math.floor(sSSize/2)-2 and partSet==0 do |
|---|
| 508 | vector[coord2]=round |
|---|
| 509 | vector[coord3]=-round |
|---|
| 510 | while vector[coord3]<=round and partSet==0 do |
|---|
| 511 | partSet=setPart(vector[0],vector[1],vector[2],xAxis,yAxis,zAxis,Dir,tempIndex,printMovEnt,printSide) |
|---|
| 512 | vector[coord3]=vector[coord3]+1 |
|---|
| 513 | end |
|---|
| 514 | while vector[coord2]>=-round and partSet==0 do |
|---|
| 515 | partSet=setPart(vector[0],vector[1],vector[2],xAxis,yAxis,zAxis,Dir,tempIndex,printMovEnt,printSide) |
|---|
| 516 | vector[coord2]=vector[coord2]-1 |
|---|
| 517 | end |
|---|
| 518 | while vector[coord3]>-round and partSet==0 do |
|---|
| 519 | partSet=setPart(vector[0],vector[1],vector[2],xAxis,yAxis,zAxis,Dir,tempIndex,printMovEnt,printSide) |
|---|
| 520 | vector[coord3]=vector[coord3]-1 |
|---|
| 521 | end |
|---|
| 522 | while vector[coord2]<=round and partSet==0 do |
|---|
| 523 | partSet=setPart(vector[0],vector[1],vector[2],xAxis,yAxis,zAxis,Dir,tempIndex,printMovEnt,printSide) |
|---|
| 524 | vector[coord2]=vector[coord2]+1 |
|---|
| 525 | end |
|---|
| 526 | round=round+1 |
|---|
| 527 | end |
|---|
| 528 | vector[coord1]=vector[coord1]-Dir |
|---|
| 529 | end |
|---|
| 530 | end |
|---|
| 531 | end |
|---|
| 532 | end |
|---|
| 533 | end |
|---|
| 534 | -- End function spiralSet(). |
|---|
| 535 | |
|---|
| 536 | -- End define functions. |
|---|
| 537 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 538 | |
|---|
| 539 | |
|---|
| 540 | |
|---|
| 541 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 542 | -- This is xml code, which means now we attach some parts to the MovableEntity. |
|---|
| 543 | print("<attached>") |
|---|
| 544 | -- End attach to the MovableEntity. |
|---|
| 545 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 546 | |
|---|
| 547 | |
|---|
| 548 | |
|---|
| 549 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 550 | -- Attach all bodyparts. |
|---|
| [5417] | 551 | -- Define at which position in the x-direction you're space station will start. |
|---|
| [5333] | 552 | x=math.random(-math.floor(xLength/2),-math.floor(xLength/2)+xVar) |
|---|
| 553 | -- Define at which position in the x-direction you're space station will end. |
|---|
| 554 | xMax=math.random(math.floor(xLength/2),math.floor(xLength/2)+xVar) |
|---|
| 555 | while x<xMax do |
|---|
| 556 | -- The same for the y- and z-direction. |
|---|
| 557 | y=math.random(-math.floor(yLength/2),-math.floor(yLength/2)+yVar) |
|---|
| 558 | yMax=math.random(math.floor(yLength/2),math.floor(yLength/2)+yVar) |
|---|
| 559 | while y<yMax do |
|---|
| 560 | yMax=math.random(math.floor(yLength/2),math.floor(yLength/2)+yVar) |
|---|
| 561 | z=math.random(-math.floor(zLength/2),-math.floor(zLength/2)+zVar) |
|---|
| 562 | zMax=math.random(math.floor(zLength/2),math.floor(zLength/2)+zVar) |
|---|
| 563 | while z<zMax do |
|---|
| 564 | -- This loop choses a bodypart, which fits at position (x,y,z). |
|---|
| 565 | -- If after the fifth time the part does still not fit we terminate the loop and set no part at postition (x,y,z). |
|---|
| 566 | partSet=0 |
|---|
| 567 | counter=0 |
|---|
| 568 | while counter<5 and partSet==0 do |
|---|
| 569 | -- This choses randomly a bodyPartIndex, which is the index used for the parts in the array bodyParts. |
|---|
| 570 | tempBodyPartIndex=math.random(1,sSBodyParts) |
|---|
| 571 | check=checkPart(tempBodyPartIndex,x,y,z) |
|---|
| 572 | -- If check == 1, this means that the part fits there, so we put it there and break the while true loop, to go on. |
|---|
| 573 | if check == 1 then |
|---|
| 574 | -- This prints the chosen part at position (x*gridDim*sSScale,y*gridDim*sSScale,z*gridDim*sSScale). |
|---|
| 575 | printModel(x,y,z,tempBodyPartIndex,false,1) |
|---|
| 576 | -- This actualizes the grid array with the values of the array bodyParts at the position tempBodyPartIndex, which is our randomly chosen part. |
|---|
| 577 | actualizeGrid(tempBodyPartIndex,x,y,z) |
|---|
| 578 | partSet=1 |
|---|
| 579 | end |
|---|
| 580 | counter=counter+1 |
|---|
| 581 | end |
|---|
| 582 | z=z+1 |
|---|
| 583 | end |
|---|
| 584 | y=y+1 |
|---|
| 585 | end |
|---|
| 586 | x=x+1 |
|---|
| 587 | end |
|---|
| 588 | -- End attach all bodyparts. |
|---|
| 589 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 590 | |
|---|
| 591 | |
|---|
| 592 | |
|---|
| 593 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 594 | -- Attach backParts, if there are some. |
|---|
| 595 | spiralSet(0,0,1,1,backPartsIndex,backParts,false,1) |
|---|
| 596 | -- End attach backParts. |
|---|
| 597 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 598 | |
|---|
| 599 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 600 | -- Attach frontParts, if there are. |
|---|
| 601 | spiralSet(0,0,1,-1,frontPartsIndex,frontParts,false,1) |
|---|
| 602 | -- End attach frontParts. |
|---|
| 603 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 604 | |
|---|
| 605 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 606 | -- Attach parts on the left side of the space station. |
|---|
| 607 | spiralSet(1,0,0,-1,leftSidePartsIndex,leftSideParts,true,1) |
|---|
| 608 | -- End attach left side parts. |
|---|
| 609 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 610 | |
|---|
| 611 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 612 | -- Attach parts on the right side of the space station. |
|---|
| 613 | spiralSet(1,0,0,1,rightSidePartsIndex,rightSideParts,true,2) |
|---|
| 614 | -- End attach right side parts. |
|---|
| 615 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 616 | |
|---|
| 617 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 618 | -- Attach parts on top of the space station. |
|---|
| 619 | spiralSet(0,1,0,1,topPartsIndex,topParts,true,1) |
|---|
| 620 | -- End attach top parts. |
|---|
| 621 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 622 | |
|---|
| 623 | |
|---|
| 624 | |
|---|
| 625 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 626 | -- Attach all connectionparts. |
|---|
| 627 | -- This iterates through the whole grid array. |
|---|
| 628 | if connPartsIndex[0] ~= false then |
|---|
| 629 | for x=math.floor(-sSSize/2)+2,math.floor(sSSize/2)-2 do |
|---|
| 630 | for y=math.floor(-sSSize/2)+2,math.floor(sSSize/2)-2 do |
|---|
| 631 | for z=math.floor(-sSSize/2)+2,math.floor(sSSize/2)-2 do |
|---|
| 632 | tempConnPartIndex=connPartsIndex[math.random(1,connParts)] |
|---|
| 633 | -- This checks whether there has to be a connection part between (x,y,z) and (x+1,y,z) or not. First it checks if there is a part at (x,y,z) and |
|---|
| 634 | -- then it checks if that part can have a connection into the positive x-direction, if it can, it checks if there is a part at (x+1,y,z) and |
|---|
| 635 | -- if that part can have a connection into the negative x-direction, if both can, it prints the xml code to set a connection part. |
|---|
| 636 | if grid[x][y][z][0]==1 and (grid[x][y][z][1]=="+" or grid[x][y][z][1]=="+-") and grid[x+1][y][z][0]==1 and (grid[x+1][y][z][1]=="-" or grid[x+1][y][z][1]=="+-") then |
|---|
| 637 | -- This prints the connection part, the +1/2 is because the connection is set exactly in the middle of two gridpoints. |
|---|
| 638 | printModel(x+1/2,y,z,tempConnPartIndex,false,1) |
|---|
| 639 | end |
|---|
| 640 | -- The same as in the x-direction, but for the y-direction. |
|---|
| 641 | if grid[x][y][z][0]==1 and ( grid[x][y][z][2]=="+" or grid[x][y][z][2]=="+-" ) and grid[x][y+1][z][0]==1 and ( grid[x][y+1][z][2]=="-" or grid[x][y+1][z][2]=="+-" ) then |
|---|
| 642 | printModel(x,y+1/2,z,tempConnPartIndex,false,2) |
|---|
| 643 | end |
|---|
| 644 | -- The same as in the x-direction, but for the z-direction. |
|---|
| 645 | if grid[x][y][z][0]==1 and ( grid[x][y][z][3]=="+" or grid[x][y][z][3]=="+-" ) and grid[x][y][z+1][0]==1 and ( grid[x][y][z+1][3]=="-" or grid[x][y][z+1][3]=="+-" ) then |
|---|
| 646 | printModel(x,y,z+1/2,tempConnPartIndex,false,3) |
|---|
| 647 | end |
|---|
| 648 | end |
|---|
| 649 | end |
|---|
| 650 | end |
|---|
| 651 | end |
|---|
| 652 | -- End attach all connectionparts. |
|---|
| 653 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 654 | |
|---|
| 655 | |
|---|
| 656 | |
|---|
| 657 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 658 | -- This is xml code, which ends the attachment and the MovableEntity. |
|---|
| 659 | print("</attached>") |
|---|
| 660 | print("</MovableEntity>") |
|---|
| 661 | -- End ends attachment and MovableEntity. |
|---|
| 662 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|---|
| 663 | |
|---|
| 664 | |
|---|
| 665 | |
|---|
| 666 | end |
|---|
| 667 | -- End createSpaceStationPar() function. |
|---|
| 668 | |
|---|
| 669 | |
|---|
| 670 | |
|---|
| 671 | -- This function is for the lazy guys, which do not care how the space station looks like, so I use some good standard values. |
|---|
| 672 | function createSpaceStation() |
|---|
| [5341] | 673 | createSpaceStationPar(0,4,1,2,1,6,1,100) |
|---|
| [5333] | 674 | end |
|---|
| 675 | -- End createSpaceStaion() function. |
|---|
| 676 | |
|---|
| 677 | |
|---|
| 678 | |
|---|
