source: data/media/levels/CuboidSpaceStation2.lua @ 5312

<?lua
-- This lua script creates a totally random generated space station for the orxonox computer game!

-- This prints xml code, which creates a MovableEntity, which I need to attach all the parts of the space station, if you want to move, rotate or displace the whole space station, this is the line you have to change.
print("<MovableEntity scale=1 position=\"0,0,-5000\" velocity=\"0,0,0\" rotationaxis=\"0,0,1\" rotationrate=0 yaw=180 >")



-- Create a randomseed, so that the math.random() function is actually random.
        math.randomseed(os.time())
-- End create randomseed.



-- Here you can define some global variables, with which you can modify the space station.
        -- Define the maximal size of the space station, this is actually just for the grid, be sure that this value is big enough.
        sSSize=30
        -- 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.
        sSParts=7
        -- 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.
        sSBodyParts=3
        -- Define how many side parts for the left side you have.
        leftSideParts=1
        -- Define which index your left side parts have.
        leftSidePartsIndex={}
        -- Define how many side parts for the right side you have.
        rightSideParts=1
        -- Define which index your right side parts have.
        rightSidePartsIndex={}
        -- Define how many top parts you have.
        topParts=1
        -- Define which index your top parts have.
        topPartsIndex={}
        -- 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.
        pDim=6
        -- Define the length in x-direction of the space station which will be occupied by bodyparts.
        xBPLength=4
        -- Define the variation of the edges of your bodyparts in the x-direction.
        xBPVar=1
        -- Define the length in y-direction of the space station which will be occupied by bodyparts.
        yBPLength=2
        -- Define the variation of the edges of your bodyparts in the y-direction.
        yBPVar=1
        -- Define the length in the z-direction of the space station which will be occupied by bodyparts.
        zBPLength=6
        -- Define the variation of the edges of your bodyparts in the z-direction.
        zBPVar=1
        -- Define the scale of the space station.
        sSScale=100
        -- 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: integer*(gridDim-connectionSize), then integer tells you how many griddimensions your part is.
        gridDim=2.25
-- End define global parameters.



-- This creates a 4-dimensional grid, which tells us if there is a part or not, and in which direction it has connections.
-- The parameters x,y,z are the axis of the space station, which iterate to sSSize, the maximal size of the space station.
-- 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, and so on for the other dimensions y and z.
-- grid[x][y][z][0] contains 0 if there is no part at the position (x,y,z), otherwise 1.
-- 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, "-" if there is one in the negative x-direction, "+-" if there are in both x-directions.
-- 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, "-" if there is one in the negative y-direction, "+-" if there are in both y-directions.
-- 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, "-" if there is one in the negative z-direction, "+-" if there are in both z-directions.
        grid = {}
        for x=-math.floor(sSSize/2),math.floor(sSSize/2) do
                grid[x] = {}
                for y=-math.floor(sSSize/2),math.floor(sSSize/2) do
                        grid[x][y]= {}
                        for z=-math.floor(sSSize/2),math.floor(sSSize/2) do
                                grid[x][y][z]={}
                                for i=0,3 do
                                        grid[x][y][z][i]=0
                                end
                        end
                end
        end
-- End create 4-dim grid.



-- This creates an array which stores all the bodyparts, it's size is depending on the global values pDim and sSParts.
-- 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.
-- 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. 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 z-axis, then you have to use the coordinate point (0,0,1).
-- 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. 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, "+-", "+", "-").
        bodyParts={}
        for i=1,sSParts do
                bodyParts[i]={}
                for x=-math.floor(pDim/2),math.floor(pDim/2) do
                        bodyParts[i][x]={}
                        for y=-math.floor(pDim/2),math.floor(pDim/2) do
                                bodyParts[i][x][y]={}
                                for z=-math.floor(pDim/2),math.floor(pDim/2) do
                                        bodyParts[i][x][y][z]={}
                                        for k=0,3 do
                                                bodyParts[i][x][y][z][k]=0
                                        end
                                end
                        end
                end
                bodyParts[i][0][0][0][4]=""
                bodyParts[i][0][0][0][5]=""
                bodyParts[i][0][0][0][6]=""
        end



        -- 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.
        -- The part must be inserted so, that the center of reference is at position (0,0,0).
        -- At position bodyParts[i][0][0][0][4] you have to put the mesh name of your part.
        -- 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.
        -- At bodyParts[i][0][0][0][5] you have to rotate your part so that it fits on the left side of your station, left means in the direction of the negative x-direction. This is to be done if your part is a side part. Also if the part is a sidepart at bodyParts[i][0][0][0][6] you have to rotate the part so that it fits on the right side.
        
        -- Insert the CuboidBody, which is only one griddimension and can have connections in every direction.
        bodyParts[1][0][0][0][4]="CuboidBody.mesh"

        bodyParts[1][0][0][0][0]=1
        bodyParts[1][0][0][0][1]="+-"
        bodyParts[1][0][0][0][2]="+-"
        bodyParts[1][0][0][0][3]="+-"
        -- End insert CuboidBody.

        -- Insert the DoubleCuboidBody, which is two griddimensions long, and one wide and high and can have connections in every direction except in the middle.
        bodyParts[2][0][0][0][4]="DoubleCuboidBody.mesh"
        bodyParts[2][0][0][0][5]="pitch=-90"

        bodyParts[2][0][0][0][0]=1
        bodyParts[2][0][0][0][1]="+-"
        bodyParts[2][0][0][0][2]="+-"
        bodyParts[2][0][0][0][3]="-"

        bodyParts[2][0][0][1][0]=1
        bodyParts[2][0][0][1][1]="+-"
        bodyParts[2][0][0][1][2]="+-"
        bodyParts[2][0][0][1][3]="+"
        -- End insert DoubleCuboidBody.

        -- Insert the CuboidConnectionBody, it is three griddimensions long and one wide and high and can have only connections at griddimension 1 (except the side in direction of griddimension 2) and griddimension 3 (except the side in direction of griddimension 2).
        bodyParts[3][0][0][0][4]="CuboidConnectionBody.mesh"
        bodyParts[3][0][0][0][5]="pitch=-90"

        bodyParts[3][0][0][0][0]=1
        bodyParts[3][0][0][0][1]="+-"
        bodyParts[3][0][0][0][2]="+-"
        bodyParts[3][0][0][0][3]="-"

        bodyParts[3][0][0][1][0]=1

        bodyParts[3][0][0][2][0]=1
        bodyParts[3][0][0][2][1]="+-"
        bodyParts[3][0][0][2][2]="+-"
        bodyParts[3][0][0][2][3]="+"
        -- End insert CuboidConnectionBody.

        -- Insert the Thruster, which is one griddimension long, wide and high, it can only have a connection into the negative z-direction.
        -- If you're space station has no thrusters, be sure to set thrusterIndex=false, but maybe you can use this also for other parts, see section Attach thrusters to learn how thrusers are attached at your space station.
        thrusterIndex=4
        bodyParts[thrusterIndex][0][0][0][4]="Thruster.mesh"
        bodyParts[thrusterIndex][0][0][0][5]="pitch=-90"

        bodyParts[thrusterIndex][0][0][0][0]=1
        bodyParts[thrusterIndex][0][0][0][3]="-"
        --End insert the Thruster.

        -- Insert the Cockpit. If your space station has no cockpit, be sure to set cockpitIndex=false.
        -- The Cockpit is 3 x-griddimensions long, 3 y-griddimensions and 2 z-griddimensions, it can only have a connection in the positive z-direction.
        cockpitIndex=5
        bodyParts[cockpitIndex][0][0][0][4]="SemiCircleCockpit.mesh"
        bodyParts[cockpitIndex][0][0][0][5]="pitch=-90 yaw=180"

        bodyParts[cockpitIndex][0][0][0][0]=1
        bodyParts[cockpitIndex][0][0][0][3]="+"

        bodyParts[cockpitIndex][-1][0][0][0]=1
        bodyParts[cockpitIndex][1][0][0][0]=1
        bodyParts[cockpitIndex][0][-1][0][0]=1
        bodyParts[cockpitIndex][0][1][0][0]=1
        bodyParts[cockpitIndex][-1][-1][0][0]=1
        bodyParts[cockpitIndex][1][-1][0][0]=1
        bodyParts[cockpitIndex][-1][1][0][0]=1
        bodyParts[cockpitIndex][1][1][0][0]=1
        bodyParts[cockpitIndex][0][0][-1][0]=1
        bodyParts[cockpitIndex][-1][0][-1][0]=1
        bodyParts[cockpitIndex][1][0][-1][0]=1
        bodyParts[cockpitIndex][0][-1][-1][0]=1
        bodyParts[cockpitIndex][0][1][-1][0]=1
        bodyParts[cockpitIndex][-1][-1][-1][0]=1
        bodyParts[cockpitIndex][1][-1][-1][0]=1
        bodyParts[cockpitIndex][-1][1][-1][0]=1
        bodyParts[cockpitIndex][1][1][-1][0]=1
        -- End insert Cockpit.

        -- Insert the side parts.
        -- If your space station has no left side parts, be sure to set leftsidePartsIndex[0]=false.
        -- If your space station has no right side parts, be sure to set rightsidePartsIndex[0]=false.
        leftSidePartsIndex[0]=""
        rightSidePartsIndex[0]=""

        -- Insert the solar panel, which i wanna use as left and right side part.
        leftSidePartsIndex[1]=6
        rightSidePartsIndex[1]=leftSidePartsIndex[1]
        bodyParts[leftSidePartsIndex[1]][0][0][0][4]="SolarPanel.mesh"
        bodyParts[leftSidePartsIndex[1]][0][0][0][5]="roll=90 pitch="..math.random(0,180)
        bodyParts[rightSidePartsIndex[1]][0][0][0][6]="roll=-90 pitch="..math.random(0,180)

        bodyParts[leftSidePartsIndex[1]][0][0][0][0]=1
        bodyParts[leftSidePartsIndex[1]][0][0][1][0]=1
        bodyParts[leftSidePartsIndex[1]][0][0][-1][0]=1
        bodyParts[leftSidePartsIndex[1]][0][1][0][0]=1
        bodyParts[leftSidePartsIndex[1]][0][1][1][0]=1
        bodyParts[leftSidePartsIndex[1]][0][1][-1][0]=1
        bodyParts[leftSidePartsIndex[1]][0][-1][0][0]=1
        bodyParts[leftSidePartsIndex[1]][0][-1][1][0]=1
        bodyParts[leftSidePartsIndex[1]][0][-1][-1][0]=1
        -- End insert solar panel.

        -- End insert side parts.

        -- Insert the top parts.
        -- If you have no top parts, be sure to set topPartsIndex[0]=false
        topPartsIndex[1]=7
        bodyParts[topPartsIndex[1]][0][0][0][4]="CuboidLandingZone.mesh"
        bodyParts[topPartsIndex[1]][0][0][0][5]="pitch=-90"

        bodyParts[topPartsIndex[1]][0][0][0][0]=1
        bodyParts[topPartsIndex[1]][0][0][0][2]="+-"
        bodyParts[topPartsIndex[1]][1][0][0][0]=1
        bodyParts[topPartsIndex[1]][-1][0][0][0]=1
        bodyParts[topPartsIndex[1]][0][0][1][0]=1
        bodyParts[topPartsIndex[1]][1][0][1][0]=1
        bodyParts[topPartsIndex[1]][-1][0][1][0]=1
        bodyParts[topPartsIndex[1]][0][0][2][0]=1
        bodyParts[topPartsIndex[1]][1][0][2][0]=1
        bodyParts[topPartsIndex[1]][-1][0][2][0]=1
        bodyParts[topPartsIndex[1]][0][0][3][0]=1
        bodyParts[topPartsIndex[1]][1][0][3][0]=1
        bodyParts[topPartsIndex[1]][-1][0][3][0]=1
        -- End insert the top parts.

        -- Insert the connectionpart, which is used to connect all the bodyparts.
        -- If you're spacestation has no connectionpart, be sure to set connPartName=false.
        connPartName="CuboidConnection.mesh"
        -- End insert the connectionparts.

-- End create array bodyParts.

-- Here I define some functions which I will use later.
        --This function actualizes the grid, which I have to call always after I have added a new part to the space station.
        function actualizeGrid(Index,x,y,z)
                for i=math.floor(-pDim/2),math.floor(pDim/2) do
                        for j=math.floor(-pDim/2),math.floor(pDim/2) do
                                for k=math.floor(-pDim/2),math.floor(pDim/2) do
                                        if bodyParts[Index][i][j][k][0] == 1 then
                                                for l=0,3 do
                                                        grid[x+i][y+j][z+k][l] = bodyParts[Index][i][j][k][l]
                                                end
                                        end
                                end
                        end
                end
        end
        -- End actualizeGrid.

        -- This function checks wheter a given parts fits at that position or not.
        function checkPart(Index,x,y,z)
                check=1
                for i=math.floor(-pDim/2),math.floor(pDim/2) do
                        for j=math.floor(-pDim/2),math.floor(pDim/2) do
                                for k=math.floor(-pDim/2),math.floor(pDim/2) do
                                        -- 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, which means that the part doesn't fit there.
                                        if bodyParts[Index][i][j][k][0] == 1 and grid[x+i][y+j][z+k][0] == 1 then
                                                check=0
                                        end
                                end
                        end
                end
                return check
        end
        -- End checkPart function.
-- End define functions.

-- This is xml code, which means now we attach some parts to the MovableEntity.
print("<attached>")



-- Attach all bodyparts.
        -- Define at which position in the x-direction you're space station will start. 
        x=math.random(-math.floor(xBPLength/2),-math.floor(xBPLength/2)+xBPVar)
        -- Define at which position in the x-direction you're space station will end.
        xMax=math.random(math.floor(xBPLength/2),math.floor(xBPLength/2)+xBPVar)
        while x<xMax do
                -- The same for the y- and z-direction.
                y=math.random(-math.floor(yBPLength/2),-math.floor(yBPLength/2)+yBPVar)
                yMax=math.random(math.floor(yBPLength/2),math.floor(yBPLength/2)+yBPVar)
                while y<yMax do
                        yMax=math.random(math.floor(yBPLength/2),math.floor(yBPLength/2)+yBPVar)
                        z=math.random(-math.floor(zBPLength/2),-math.floor(zBPLength/2)+zBPVar)
                        zMax=math.random(math.floor(zBPLength/2),math.floor(zBPLength/2)+zBPVar)
                        while z<zMax do
                                -- This loop choses a bodypart, which fits at position (x,y,z).
                                -- If after the fifth time the part does still not fit we terminate the loop and set no part at postition (x,y,z).
                                partSet=0
                                counter=0
                                while counter<5 and partSet==0 do
                                        -- This choses randomly a bodyPartIndex, which is the index used for the parts in the array bodyParts.
                                        tempBodyPartIndex=math.random(1,sSBodyParts)
                                        check=checkPart(tempBodyPartIndex,x,y,z)
                                        -- If check == 1, this means that the part fits there, so we put it there and break the while true loop, to go on.
                                        if check == 1 then
                                                -- This is xml code which means at position (x*gridDim*sSScale) will be the randomly chosen part.
                                                print("<Model position=\"") print(x*gridDim*sSScale) print(",") print(y*gridDim*sSScale) print(",") print(z*gridDim*sSScale) print("\" scale=") print(sSScale) print(" mesh= \"") print(bodyParts[tempBodyPartIndex][0][0][0][4]) print("\"") print(bodyParts[tempBodyPartIndex][0][0][0][5]) print(" />")
                                                -- This actualizes the grid array with the values of the array bodyParts at the position tempBodyPartIndex, which is our randomly chosen part.
                                                actualizeGrid(tempBodyPartIndex,x,y,z)
                                                partSet=1
                                        end
                                        counter=counter+1
                                end
                                z=z+1
                        end
                        y=y+1
                end
                x=x+1
        end
-- End attach all bodyparts.



-- Attach thrusters, if there are some.
        if thrusterIndex ~= false then
                -- To attach thrusters we start at (-sSSize/2,-sSSize/2,-sSSize/2+1) and iterate through x and y as start points and then through z, where we go as long as there are parts, at the first position where isn't a part we set our thruster.
                for x=math.floor(-sSSize/2),math.floor(sSSize/2) do
                        for y=math.floor(-sSSize/2),math.floor(sSSize/2) do
                                 for z=math.floor(-sSSize/2)+1,math.floor(sSSize/2) do
                                        if grid[x][y][z-1][0] == 1 and grid[x][y][z][0] == 0 then
                                                print("<Model position=\"") print(x*gridDim*sSScale) print(",") print(y*gridDim*sSScale) print(",") print(z*gridDim*sSScale) print("\" scale=") print(sSScale) print(" mesh= \"") print(bodyParts[thrusterIndex][0][0][0][4]) print("\"") print(bodyParts[thrusterIndex][0][0][0][5]) print(" >")

                                                print("<attached>")
                                                        print("<ParticleEmitter position=\"0,0,0\" source=\"Orxonox/fire3\" />")
                                                print("</attached>")
                                                print("</Model>")
                                                -- This actualizes the grid array with the values of the array bodyParts at the position thrusterIndex.
                                                actualizeGrid(thrusterIndex,x,y,z)
                                                -- This breaks out of the for z=-sSSize/2+1,sSSize/2 loop, because we have set one thruster and for the z-axis that is all we want.
                                                break
                                        end
                                end
                        end
                end
        end
-- End attach Thrusters.



-- Attach cockpit, if there is one.
function setCockpit()
        if grid[x][y][z][0] == 0 and grid[x][y][z+1][0] == 1 then

                check=checkPart(cockpitIndex,x,y,z)

                if check == 1 then
                        print("<Model position=\"") print(x*gridDim*sSScale) print(",") print(y*gridDim*sSScale) print(",") print(z*gridDim*sSScale) print("\" scale=") print(sSScale) print(" mesh= \"") print(bodyParts[cockpitIndex][0][0][0][4]) print("\"") print(bodyParts[cockpitIndex][0][0][0][5]) print("/>")
                        cockpitSet=1
                        -- This actualizes the grid array with the values of the array bodyParts at the position cockpitIndex.
                        actualizeGrid(cockpitIndex,x,y,z)
                end

        end
end


        if cockpitIndex ~= false then
                cockpitSet=0
                z=math.floor(-sSSize/2)
                while z<=math.floor(sSSize/2)-1 and cockpitSet==0 do
                        round=0
                        while round<=math.floor(sSSize/2)-1 and cockpitSet==0 do
                                y=round
                                x=-round
                                while x<=round and cockpitSet==0 do
                                        setCockpit()
                                        x=x+1
                                end
                                while y>=-round and cockpitSet==0 do
                                        setCockpit()
                                        y=y-1
                                end
                                while x>-round and cockpitSet==0 do
                                        setCockpit()
                                        x=x-1
                                end
                                while y<=round and cockpitSet==0 do
                                        setCockpit()
                                        y=y+1
                                end
                                round=round+1
                        end
                        z=z+1
                end
        end
-- End attach cockpit.



-- Attach parts on the left side of the space station.
function setLeftSidePart()
        if grid[x][y][z][0] == 0 and grid[x+1][y][z][0] == 1 and (grid[x+1][y][z][1] == "+-" or grid[x+1][y][z][1] == "-") then

                check=checkPart(tempSidePartsIndex,x,y,z)

                if check == 1 then
                        print("<Model position=\"") print(x*gridDim*sSScale) print(",") print(y*gridDim*sSScale) print(",") print(z*gridDim*sSScale) print("\" scale=") print(sSScale) print(" mesh= \"") print(bodyParts[tempSidePartsIndex][0][0][0][4]) print("\"") print(bodyParts[tempSidePartsIndex][0][0][0][5]) print("/>")
                        partSet=1
                        -- This actualizes the grid array with the values of the array bodyParts at the position tempSidePartsIndex.
                        actualizeGrid(tempSidePartsIndex,x,y,z)
                end

        end
end


        if leftSidePartsIndex[0] ~= false then
                for sPC=1,leftSideParts do
                        tempSidePartsIndex = leftSidePartsIndex[math.random(1,leftSideParts)]
                        partSet=0
                        x=math.floor(-sSSize/2)
                        while x<=math.floor(sSSize/2)-1 and partSet==0 do
                                round=0
                                while round<=math.floor(sSSize/2)-1 and partSet==0 do
                                        y=round
                                        z=-round
                                        while z<=round and partSet==0 do
                                                setLeftSidePart()
                                                z=z+1
                                        end
                                        while y>=-round and partSet==0 do
                                                setLeftSidePart()
                                                y=y-1
                                        end
                                        while z>=-round and partSet==0 do
                                                setLeftSidePart()
                                                z=z-1
                                        end
                                        while y<=round and partSet==0 do
                                                setLeftSidePart()
                                                y=y+1
                                        end
                                        round=round+1
                                end
                                x=x+1
                        end
                end
        end
-- End attach left side parts.



-- Attach parts on the right side of the space station.
function setRightSidePart()
        if grid[x][y][z][0] == 0 and grid[x-1][y][z][0] == 1 and (grid[x-1][y][z][1] == "+-" or grid[x-1][y][z][1] == "+") then

                check=checkPart(tempSidePartsIndex,x,y,z)

                if check == 1 then
                        print("<Model position=\"") print(x*gridDim*sSScale) print(",") print(y*gridDim*sSScale) print(",") print(z*gridDim*sSScale) print("\" scale=") print(sSScale) print(" mesh= \"") print(bodyParts[tempSidePartsIndex][0][0][0][4]) print("\"") print(bodyParts[tempSidePartsIndex][0][0][0][6]) print("/>")
                        partSet=1
                        -- This actualizes the grid array with the values of the array bodyParts at the position tempSidePartsIndex.
                        actualizeGrid(tempSidePartsIndex,x,y,z)
                end

        end
end


        if rightSidePartsIndex[0] ~= false then
                for sPC=1,rightSideParts do
                        tempSidePartsIndex = rightSidePartsIndex[math.random(1,rightSideParts)]
                        partSet=0
                        x=math.floor(sSSize/2)
                        while x>=math.floor(-sSSize/2)+1 and partSet==0 do
                                round=0
                                while round<=math.floor(sSSize/2)-1 and partSet==0 do
                                        y=round
                                        z=-round
                                        while z<=round and partSet==0 do
                                                setRightSidePart()
                                                z=z+1
                                        end
                                        while y>=-round and partSet==0 do
                                                setRightSidePart()
                                                y=y-1
                                        end
                                        while z>=-round and partSet==0 do
                                                setRightSidePart()
                                                z=z-1
                                        end
                                        while y<=round and partSet==0 do
                                                setRightSidePart()
                                                y=y+1
                                        end
                                        round=round+1
                                end
                                x=x-1
                        end
                end
        end
-- End attach right side parts.



-- Attach parts on top of the space station.
function setTopPart()
        if grid[x][y][z][0] == 0 and grid[x][y-1][z][0] == 1 and (grid[x][y-1][z][2] == "+-" or grid[x][y-1][z][2] == "+") then

                check=checkPart(tempTopPartsIndex,x,y,z)

                if check == 1 then
                        print("<Model position=\"") print(x*gridDim*sSScale) print(",") print(y*gridDim*sSScale) print(",") print(z*gridDim*sSScale) print("\" scale=") print(sSScale) print(" mesh= \"") print(bodyParts[tempTopPartsIndex][0][0][0][4]) print("\"") print(bodyParts[tempTopPartsIndex][0][0][0][5]) print("/>")
                        partSet=1
                        -- This actualizes the grid array with the values of the array bodyParts at the position tempTopPartsIndex.
                        actualizeGrid(tempTopPartsIndex,x,y,z)
                end

        end
end


        if topPartsIndex[0] ~= false then
                for sPC=1,topParts do
                        tempTopPartsIndex = topPartsIndex[math.random(1,topParts)]
                        partSet=0
                        y=math.floor(sSSize/2)
                        while y>=math.floor(-sSSize/2)+1 and partSet==0 do
                                round=0
                                while round<=math.floor(sSSize/2)-1 and partSet==0 do
                                        x=round
                                        z=-round
                                        while z<=round and partSet==0 do
                                                setTopPart()
                                                z=z+1
                                        end
                                        while x>=-round and partSet==0 do
                                                setTopPart()
                                                x=x-1
                                        end
                                        while z>=-round and partSet==0 do
                                                setTopPart()
                                                z=z-1
                                        end
                                        while x<=round and partSet==0 do
                                                setTopPart()
                                                x=x+1
                                        end
                                        round=round+1
                                end
                                y=y-1
                        end
                end
        end
-- End attach top parts.



-- Attach all connectionparts.
        -- This iterates through the whole grid array.
        if connPartName ~= false then
                for x=math.floor(-sSSize/2),math.floor(sSSize/2)-1 do
                        for y=math.floor(-sSSize/2),math.floor(sSSize/2)-1 do
                                for z=math.floor(-sSSize/2),math.floor(sSSize/2)-1 do
                                        -- 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 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 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.
                                        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
                                                -- This is xml code which prints the connection part, the +gridDim*sSScale/2 is because the connection is set exactly in the middle of two gridpoints.
                                                print("<Model position=\"") print(x*gridDim*sSScale+gridDim*sSScale/2) print(",") print(y*gridDim*sSScale) print(",") print(z*gridDim*sSScale) print("\" scale=") print(sSScale) print(" mesh=\"") print(connPartName) print("\" roll=90 />")
                                        end
                                        -- The same as in the x-direction, but for the y-direction.
                                        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
                                                print("<Model position=\"") print(x*gridDim*sSScale) print(",") print(y*gridDim*sSScale+gridDim*sSScale/2) print(",") print(z*gridDim*sSScale) print("\" scale=") print(sSScale) print(" mesh=\"") print(connPartName) print("\" />")
                                        end
                                        -- The same as in the x-direction, but for the z-direction.
                                        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
                                                print("<Model position=\"") print(x*gridDim*sSScale) print(",") print(y*gridDim*sSScale) print(",") print(z*gridDim*sSScale+gridDim*sSScale/2) print("\" scale=") print(sSScale) print(" mesh=\"") print(connPartName) print("\" pitch=90 />")
                                        end
                                end
                        end
                end
        end
-- End attach all connectionparts.



-- This is xml code, which ends the attachment and the MovableEntity.
print("</attached>")
print("</MovableEntity>")

?>