source: data/contentcreation/pps/MirkoKaiser/CuboidSS/Version0/SpaceStation0.0.lua @ 5300

-- 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,-1000\" velocity=\"0,0,0\" rotationaxis=\"0,0,1\" rotationrate=0>")



-- 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 enough big.
        -- To actually define the size of the space station you have to change the values in the section Attach all bodyparts, be sure that that values are some griddimensions (at least the sSSize-(pDim)) smaller than sSSize.
        sSSize=20
        -- Define how many parts the space station have, this value has to be exact, so be sure to increment if you're adding a new part.
        sSParts=4
        -- Define how many body parts the space station have, this value has to be exact. Body part means a part, which has connections at least in two directions.
        sSBodyParts=3
        -- 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=2
        -- 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 2,25 in the game, so the absolute x-axis is x*2,25*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=0,sSSize do
                grid[x] = {}
                for y=0,sSSize do
                        grid[x][y]= {}
                        for z=0,sSSize 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 0 to sSParts-1, 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=0,sSParts-1 do
                bodyParts[i]={}
                for x=0,pDim do
                        bodyParts[i][x]={}
                        for y=0,pDim do
                                bodyParts[i][x][y]={}
                                for z=0,pDim do
                                        bodyParts[i][x][y][z]={}
                                        for k=0,3 do
                                                bodyParts[i][x][y][z][k]=0
                                        end
                                end
                        end
                end
        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.
        -- At position bodyParts[i][x][y][z][4] you have to put the mesh name of your part.
        -- At bodyParts[i][x][y][z][5] you can rotate your part, with pitch=angle, yaw=angle or roll=angle (x,y or z). Positive angle means in screw direction.
        
        -- Insert the CuboidBody, which is only one griddimension and can have connections in every direction.
        bodyParts[0][0][0][0][4]="CuboidBody.mesh"
        bodyParts[0][0][0][0][5]=""
        bodyParts[0][0][0][0][0]=1
        bodyParts[0][0][0][0][1]="+-"
        bodyParts[0][0][0][0][2]="+-"
        bodyParts[0][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[1][0][0][0][4]="DoubleCuboidBody.mesh"
        bodyParts[1][0][0][0][5]="pitch=-90"
        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]="-"
        bodyParts[1][0][0][1][0]=1
        bodyParts[1][0][0][1][1]="+-"
        bodyParts[1][0][0][1][2]="+-"
        bodyParts[1][0][0][1][3]="+"
        -- End insert DoubleCuboidBody.

        -- Insert the CuboidConnectionLong, which is a Bodypart indeed, 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[2][0][0][0][4]="CuboidConnectionBody.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]=0
        bodyParts[2][0][0][1][2]=0
        bodyParts[2][0][0][1][3]=0
        bodyParts[2][0][0][2][0]=1
        bodyParts[2][0][0][2][1]="+-"
        bodyParts[2][0][0][2][2]="+-"
        bodyParts[2][0][0][2][3]="+"
        -- End insert CuboidConnectionLong.

        -- 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=3
        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][1]=0
        bodyParts[thrusterIndex][0][0][0][2]=0
        bodyParts[thrusterIndex][0][0][0][3]="-"
        --End insert the Thruster.

-- End create array bodyParts.



-- 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(0,1)
        -- Define at which position in the x-direction you're space station will end.
        xMax=math.random(3,4)
        while x<xMax do
                -- The same for the y- and z-direction.
                y=math.random(0,1)
                yMax=math.random(3,4)
                while y<yMax do
                        yMax=math.random(3,4)
                        z=math.random(0,1)
                        zMax=math.random(6,8)
                        while z<zMax do
                                -- This loop choses a bodypart, which fits at position (x,y,z), check=1 is to start the loop, if after the fifth time the part does still not fit we terminate the loop and set no part at postition (x,y,z).
                                check=1
                                counter=0
                                while counter <5 and check==1 do
                                        -- This choses randomly a bodyPartIndex, which is the index used for the parts in the array bodyParts.
                                        tempBodyPartIndex=math.random(0,sSBodyParts-1)
                                        -- Check whether the randomly chosen part fits at that position or not. 
                                        for i=0,pDim do
                                                for j=0,pDim do
                                                        for k=0,pDim 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, so we do the while loop again.
                                                                if bodyParts[tempBodyPartIndex][i][j][k][0] == 1 and grid[x+i][y+j][z+k][0] == 1 then
                                                                        check=0
                                                                end
                                                        end
                                                end
                                        end
                                        -- 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.
                                                for i=0,pDim do
                                                        for j=0,pDim do
                                                                for k=0,pDim do
                                                                        if bodyParts[tempBodyPartIndex][i][j][k][0] == 1 then
                                                                                for l=0,3 do
                                                                                        grid[x+i][y+j][z+k][l] = bodyParts[tempBodyPartIndex][i][j][k][l]
                                                                                end
                                                                        end
                                                                end
                                                        end
                                                end
                                        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 (0,0,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=0,sSSize do
                        for y=0,sSSize do
                                 for z=1,sSSize 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\" scale=100 source=\"Orxonox/fire3\" />")
                                        print("</attached>")
                                        print("</Model>")

                                                -- This actualizes the array grid.
                                                for i=0,pDim do
                                                        for j=0,pDim do
                                                                for k=0,pDim do
                                                                        if bodyParts[tempBodyPartIndex][i][j][k][0] == 1 then
                                                                                for l=0,3 do
                                                                                        grid[x+i][y+j][z+k][l] = bodyParts[thrusterIndex][i][j][k][l]
                                                                                end
                                                                        end
                                                                end
                                                        end
                                                end
                                                -- This breaks out of the for z=0,sSSize 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.
        
-- End attach cockpit.



-- Attach all connectionparts.
        -- This iterates through the whole grid array.
        for x=0,sSSize-1 do
                for y=0,sSSize-1 do
                        for z=0,sSSize-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=\"CuboidConnection.mesh\" 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=\"CuboidConnection.mesh\" />")
                                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=\"CuboidConnection.mesh\" pitch=90 />")
                                end
                        end
                end
        end
-- End attach all connectionparts.



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