Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: data/media/levels/CuboidSpaceStation.lua @ 5373

Last change on this file since 5373 was 5372, checked in by mkaiser, 16 years ago
i dont know
File size: 36.3 KB

Line
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.
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,
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.
38	if ranSeed == 0 then
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 xgridDimsSScale,
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).
196	bodyParts[3][0][0][0][4]="CuboidConnBody.mesh"
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
219	-- Insert the thruster, which is one griddimension long, two wide and high, it can only have a connection into the negative z-direction.
220	backPartsIndex[1]=4
221	bodyParts[backPartsIndex[1]][0][0][0][4]="Thruster.mesh"
222	bodyParts[backPartsIndex[1]][0][0][0][5]="pitch=-90"
223	bodyParts[backPartsIndex[1]][0][0][0][9]="<ParticleEmitter position=\"0,-0.5,0\" source=\"Orxonox/ThrusterFire\" />"
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]="-"
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
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"
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\" />"
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(lxgridDimsSScale) print(",") print(lygridDimsSScale) print(",") print(lzgridDimsSScale) 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(lxgridDimsSScale) print(",") print(lygridDimsSScale) print(",") print(lzgridDimsSScale)
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
432	print("<attached>")
433	print(bodyParts[tempPartIndex][0][0][0][9])
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=1xAxis+2yAxis+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+(-1xAxisDir)][ly+(-1yAxisDir)][lz+(-1zAxisDir)][0] == 1 and (grid[lx+(-1xAxisDir)][ly+(-1yAxisDir)][lz+(-1zAxisDir)][coord]=="+-" or grid[lx+(-1xAxisDir)][ly+(-1yAxisDir)][lz+(-1zAxisDir)][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=1yAxis+2zAxis
497	coord2=(coord1+1)%3
498	coord3=(coord2+1)%3
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(DirsSSize/2)-2Dir
505	while vector[coord1]~=math.floor(-1DirsSSize/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.
551	-- Define at which position in the x-direction you're space station will start.
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 (xgridDimsSScale,ygridDimsSScale,zgridDimsSScale).
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()
673	createSpaceStationPar(0,4,1,2,1,6,1,100)
674	end
675	-- End createSpaceStaion() function.
676
677
678

Note: See TracBrowser for help on using the repository browser.

Download in other formats: