001: /*bltype
002: 7 root
003: 8 trunk
004: 9 treetop
005: 10 branch
006: 11 branchEndingLeft
007: 12 branchEndingRight
008: 13 branchEndingLeftStop
009: 14 branchEndingRightStop
010: 15 treeLeaves
011: 16 treeLeavesEnding
012: 17 arcon
013:
014: int defaultStoneBlockWeight=11;
015: int defaultWoodBlockWeight=5;
016: int defaultWoodBondStrength=100;
017: const int maxTreeHeight=13;
018: const int minTreeBranchSpacing=1;
019: const int treeBranchGrowthChance=12;
020: const int minTreeBranchSpacingFromGround=1;
021: const int minTreeBranchLenght=0;
022: const int maxTreeBranchLenght=4;
023: const int treeBranchEndingChance=4;
024: const int maxTreeLeavesThick=4;
025: const int treeLeafGrowthChance=7;
026: const int treeLeafEndingChance=4;
027: const int arconGrowthChance=25;
028:
029: */
030:
031: #define jindex x+y*width
032: int bltype[width*height];
033: int weight[height*width];
034: int bond_ver[height*width];
035: int bond_hor[height*width];
036: int architecture[height*width];
037:
038: class architecture_bit_t
039: {
040: public:
041: static const int stationary=1;
042: static const int dynamic=2;
043: static const int bond_down=4;
044: static const int bond_right=8;
045: static const int temporary_unstable=16;
046: };
047: architecture_bit_t architecture_bit;
048:
049: //=================================================
050: // process trees
051: for(int y=0;y<height;y++)
052: for(int x=0;x<width;x++){
053: if(bltype[jindex]==7){ // tree root
054: // cycle through height
055: int heightReached=0;
056: for(int he=1;he<maxTreeHeight;he++){
057: if(y-he<0)break;
058: if((bltype[x+(y-he)*width]==0 )||
059: (bltype[x+(y-he)*width]==15)||
060: (bltype[x+(y-he)*width]==16)||
061: (bltype[x+(y-he)*width]==17)||
062: (bltype[x+(y-he)*width]==11)||
063: (bltype[x+(y-he)*width]==12)||
064: (bltype[x+(y-he)*width]==13)||
065: (bltype[x+(y-he)*width]==14)||
066: (bltype[x+(y-he)*width]==10)){
067: // free space (or leaves), need to grow
068: if(he>1){
069: // there is Trunk and old top below
070: bltype[x+(y-he+1)*width]=8; //turn old top to trunk
071: }
072: //place treeTop
073: bltype[x+(y-he)*width]=9;
074: architecture[x+(y-he)*width]=architecture_bit.dynamic | architecture_bit.bond_down;
075: bond_ver[x+(y-he)*width]=defaultWoodBondStrength;
076: weight[x+(y-he)*width]=defaultStoneBlockWeight;
077:
078: heightReached++;
079: break;
080: }else{
081: if((bltype[x+(y-he)*width]==8)||(bltype[x+(y-he)*width]==9)&&
082: ( (architecture[x+(y-he)*width] & architecture_bit.bond_down)!=0 )
083: ){ // this is still tree
084: heightReached++;
085: continue;
086: }else{ // this is not tree any more
087: break;
088: }
089: }
090: }
091: int newBranchThisMove=0;
092: if(heightReached> minTreeBranchSpacingFromGround){
093: int sideBranchFreeSpaceCounter=0;
094: int zoneStartIndex=y-minTreeBranchSpacingFromGround-1;
095: int zoneStopIndex=zoneStartIndex;
096: if(x+1<width){
097: for(int trunkIndex=minTreeBranchSpacingFromGround+1; trunkIndex<heightReached; trunkIndex++){
098: //find growth zone
099:
100: if((bltype[x+1+(y-trunkIndex)*width]!=10)&&(bltype[x+1+(y-trunkIndex)*width]!=12)){
101: // TODO: add hor-bond check
102: if(sideBranchFreeSpaceCounter>0){
103: zoneStopIndex--;
104: }
105: if(sideBranchFreeSpaceCounter==0){
106: zoneStartIndex=y-trunkIndex;
107: zoneStopIndex=zoneStartIndex;
108: }
109: sideBranchFreeSpaceCounter++;
110: }else{
111: sideBranchFreeSpaceCounter=0-minTreeBranchSpacing;
112: }
113: }
114: if(sideBranchFreeSpaceCounter>0){
115: // branch-free space, can try to create branch
116: for(int branchTryIndex=zoneStartIndex;branchTryIndex>zoneStopIndex;branchTryIndex--)
117: if((rand()%treeBranchGrowthChance)==0){
118: // create new branch
119: if((bltype[x+1+(branchTryIndex)*width]==0 )||
120: (bltype[x+1+(branchTryIndex)*width]==15)||
121: (bltype[x+1+(branchTryIndex)*width]==16)||
122: (bltype[x+1+(branchTryIndex)*width]==17))
123: {
124: bltype[x+1+(branchTryIndex)*width]=12;
125: architecture[x+1+(branchTryIndex)*width]=architecture_bit.dynamic;
126: architecture[x+(branchTryIndex)*width] |= architecture_bit.bond_right;
127: bond_hor[x+(branchTryIndex)*width]=defaultWoodBondStrength;
128: weight[x+1+(branchTryIndex)*width]=defaultStoneBlockWeight;
129: newBranchThisMove=1;
130: break;
131: }
132: }
133: }}
134: // now the same for left side
135: sideBranchFreeSpaceCounter=0;
136: zoneStartIndex=y-minTreeBranchSpacingFromGround-1;
137: zoneStopIndex=zoneStartIndex;
138: if(x-1>0){
139: for(int trunkIndex=minTreeBranchSpacingFromGround+1; trunkIndex<heightReached; trunkIndex++){
140: //find growth zone
141:
142: if((bltype[x-1+(y-trunkIndex)*width]!=10)&&(bltype[x-1+(y-trunkIndex)*width]!=11)){
143: if(sideBranchFreeSpaceCounter>0){
144: zoneStopIndex--;
145: }
146: if(sideBranchFreeSpaceCounter==0){
147: zoneStartIndex=y-trunkIndex;
148: zoneStopIndex=zoneStartIndex;
149: }
150: sideBranchFreeSpaceCounter++;
151: }else{
152: sideBranchFreeSpaceCounter=0-minTreeBranchSpacing;
153: }
154: }
155: if(sideBranchFreeSpaceCounter>0){
156: // branch-free space, can try to create branch
157: for(int branchTryIndex=zoneStartIndex;branchTryIndex>zoneStopIndex;branchTryIndex--)
158: if((rand()%treeBranchGrowthChance)==0){
159: // create new branch
160: if((bltype[x-1+(branchTryIndex)*width]==0 )||
161: (bltype[x-1+(branchTryIndex)*width]==15)||
162: (bltype[x-1+(branchTryIndex)*width]==16)||
163: (bltype[x-1+(branchTryIndex)*width]==17))
164: {
165: bltype[x-1+(branchTryIndex)*width]=11;
166: architecture[x-1+(branchTryIndex)*width]=architecture_bit.dynamic;
167: architecture[x-1+(branchTryIndex)*width] |= architecture_bit.bond_right;
168: bond_hor[x-1+(branchTryIndex)*width]=defaultWoodBondStrength;
169: weight[x-1+(branchTryIndex)*width]=defaultStoneBlockWeight;
170: newBranchThisMove=1;
171: break;
172: }
173: }
174: }}
175: }
176: if(newBranchThisMove==0){
177: //right side
178: if(x+1<width)
179: for(int onHeight=1;onHeight<=heightReached; onHeight++){
180: if(((bltype[x+1+(y-onHeight)*width]==10)||(bltype[x+1+(y-onHeight)*width]==12))&&
181: ((architecture[x+(y-onHeight)*width] & architecture_bit.bond_right)!=0 )){
182: // if branch on this height
183: for(int branchLenght=1;branchLenght<=maxTreeBranchLenght; branchLenght++){
184: if(x+1+branchLenght>=width)break;
185: if(((bltype[x+1+branchLenght+(y-onHeight)*width]==10)||(bltype[x+1+branchLenght+(y-onHeight)*width]==12))&&
186: ((architecture[x+branchLenght+(y-onHeight)*width] & architecture_bit.bond_right)!=0 )){
187: }else{
188: // branch end - can try to grow
189: if(!((bltype[x+1+branchLenght+(y-onHeight)*width]==0 )||
190: (bltype[x+1+branchLenght+(y-onHeight)*width]==15)||
191: (bltype[x+1+branchLenght+(y-onHeight)*width]==16)||
192: (bltype[x+1+branchLenght+(y-onHeight)*width]==17)
193: ))break;
194:
195: //branch grows!
196: bltype[x+branchLenght+(y-onHeight)*width]=10;
197: bltype[x+1+branchLenght+(y-onHeight)*width]=12;
198: architecture[x+1+branchLenght+(y-onHeight)*width]=architecture_bit.dynamic;
199: architecture[x+branchLenght+(y-onHeight)*width] |= architecture_bit.bond_right;
200: bond_hor[x+branchLenght+(y-onHeight)*width]=defaultWoodBondStrength;
201: weight[x+1+branchLenght+(y-onHeight)*width]=defaultStoneBlockWeight;
202:
203: if(branchLenght>minTreeBranchLenght){
204: if((rand()%treeBranchEndingChance)==0){
205: bltype[x+1+branchLenght+(y-onHeight)*width]=14;
206: }
207: }
208: break; //enough for this branch
209: }
210: }
211: }
212: }
213: //left side
214: if(x-1>=0)
215: for(int onHeight=1;onHeight<=heightReached; onHeight++){
216: if(((bltype[x-1+(y-onHeight)*width]==10)||(bltype[x-1+(y-onHeight)*width]==11))&&
217: ((architecture[x-1+(y-onHeight)*width] & architecture_bit.bond_right)!=0 )){
218: // if branch on this height
219: for(int branchLenght=1;branchLenght<=maxTreeBranchLenght; branchLenght++){
220: if(x-1-branchLenght<0)break;
221: if(((bltype[x-1-branchLenght+(y-onHeight)*width]==10)||(bltype[x-1-branchLenght+(y-onHeight)*width]==11))&&
222: ((architecture[x-1-branchLenght+(y-onHeight)*width] & architecture_bit.bond_right)!=0 )){
223: }else{
224: // branch end - can try to grow
225: if(!((bltype[x-1-branchLenght+(y-onHeight)*width]==0 )||
226: (bltype[x-1-branchLenght+(y-onHeight)*width]==15)||
227: (bltype[x-1-branchLenght+(y-onHeight)*width]==16)||
228: (bltype[x-1-branchLenght+(y-onHeight)*width]==17)
229: ))break;
230:
231: //branch grows!
232: bltype[x-branchLenght+(y-onHeight)*width]=10;
233: bltype[x-1-branchLenght+(y-onHeight)*width]=11;
234: architecture[x-1-branchLenght+(y-onHeight)*width]=architecture_bit.dynamic;
235: architecture[x-1-branchLenght+(y-onHeight)*width] |= architecture_bit.bond_right;
236: bond_hor[x-1-branchLenght+(y-onHeight)*width]=defaultWoodBondStrength;
237: weight[x-1-branchLenght+(y-onHeight)*width]=defaultStoneBlockWeight;
238:
239: if(branchLenght>minTreeBranchLenght){
240: if((rand()%treeBranchEndingChance)==0){
241: bltype[x-1-branchLenght+(y-onHeight)*width]=13;
242: }
243: }
244: break; //enough for this branch
245: }
246: }
247: }
248: }
249: }
250: // grow leaves on trunk, to right
251: if(x+1<width)
252: for(int onHeight=2;onHeight<=heightReached; onHeight++){
253: if(bltype[x+1+(y-onHeight)*width]==0){
254: if((rand()%treeLeafGrowthChance)==0){
255: if((rand()%treeLeafEndingChance)==0){
256: bltype[x+1+(y-onHeight)*width]=16;
257: }else{
258: bltype[x+1+(y-onHeight)*width]=15;
259: }
260: architecture[x+1+(y-onHeight)*width]=architecture_bit.dynamic;
261: architecture[x+ (y-onHeight)*width] |= architecture_bit.bond_right;
262: bond_hor [x+ (y-onHeight)*width]=defaultWoodBondStrength;
263: weight [x+1+(y-onHeight)*width]=defaultWoodBlockWeight;
264: if((y-onHeight)>0)
265: if(
266: (bltype[x+1+(y-onHeight-1)*width]==15)||
267: (bltype[x+1+(y-onHeight-1)*width]==16)||
268: (bltype[x+1+(y-onHeight-1)*width]==10)||
269: (bltype[x+1+(y-onHeight-1)*width]==11)||
270: (bltype[x+1+(y-onHeight-1)*width]==12)||
271: (bltype[x+1+(y-onHeight-1)*width]==13)||
272: (bltype[x+1+(y-onHeight-1)*width]==14)
273: ){
274: architecture[x+1+(y-onHeight-1)*width] |= architecture_bit.bond_down;
275: bond_ver[x+1+(y-onHeight-1)*width]=defaultWoodBondStrength;
276: }
277: if(
278: (bltype[x+1+(y-onHeight+1)*width]==15)||
279: (bltype[x+1+(y-onHeight+1)*width]==16)||
280: (bltype[x+1+(y-onHeight+1)*width]==10)||
281: (bltype[x+1+(y-onHeight+1)*width]==11)||
282: (bltype[x+1+(y-onHeight+1)*width]==12)||
283: (bltype[x+1+(y-onHeight+1)*width]==13)||
284: (bltype[x+1+(y-onHeight+1)*width]==14)
285: ){
286: architecture[x+1+(y-onHeight)*width] |= architecture_bit.bond_down;
287: bond_ver[x+1+(y-onHeight)*width]=defaultWoodBondStrength;
288: }
289: }
290: continue;
291: }
292: if((bltype[x+1+(y-onHeight)*width]==15)&&
293: ((architecture[x+(y-onHeight)*width] & architecture_bit.bond_right)!=0 )){
294: // if there are leaves on this height, then grow more leaves on that side
295: for(int leavesLayer=1;leavesLayer<=maxTreeLeavesThick;leavesLayer++){
296: if(x+leavesLayer>width)break;
297: if(bltype[x+leavesLayer+(y-onHeight)*width]!=15){
298: if(bltype[x+leavesLayer+(y-onHeight)*width]==0)
299: if((rand()%treeLeafGrowthChance)==0){
300: // add one more leaf block
301: if((rand()%treeLeafEndingChance)==0){
302: bltype[x+leavesLayer+(y-onHeight)*width]=16;
303: }else{
304: bltype[x+leavesLayer+(y-onHeight)*width]=15;
305: }
306: architecture[x+leavesLayer +(y-onHeight)*width]=architecture_bit.dynamic;
307: architecture[x+leavesLayer-1+(y-onHeight)*width] |= architecture_bit.bond_right;
308: bond_hor [x+leavesLayer-1+(y-onHeight)*width]=defaultWoodBondStrength;
309: weight [x+leavesLayer +(y-onHeight)*width]=defaultWoodBlockWeight;
310: if((y-onHeight)>0)
311: if(
312: (bltype[x+leavesLayer+(y-onHeight-1)*width]==15)||
313: (bltype[x+leavesLayer+(y-onHeight-1)*width]==16)||
314: (bltype[x+leavesLayer+(y-onHeight-1)*width]==10)||
315: (bltype[x+leavesLayer+(y-onHeight-1)*width]==11)||
316: (bltype[x+leavesLayer+(y-onHeight-1)*width]==12)||
317: (bltype[x+leavesLayer+(y-onHeight-1)*width]==13)||
318: (bltype[x+leavesLayer+(y-onHeight-1)*width]==14)
319: ){
320: architecture[x+leavesLayer+(y-onHeight-1)*width] |= architecture_bit.bond_down;
321: bond_ver [x+leavesLayer+(y-onHeight-1)*width]=defaultWoodBondStrength;
322: }
323: if(
324: (bltype[x+leavesLayer+(y-onHeight+1)*width]==15)||
325: (bltype[x+leavesLayer+(y-onHeight+1)*width]==16)||
326: (bltype[x+leavesLayer+(y-onHeight+1)*width]==10)||
327: (bltype[x+leavesLayer+(y-onHeight+1)*width]==11)||
328: (bltype[x+leavesLayer+(y-onHeight+1)*width]==12)||
329: (bltype[x+leavesLayer+(y-onHeight+1)*width]==13)||
330: (bltype[x+leavesLayer+(y-onHeight+1)*width]==14)
331: ){
332: architecture[x+leavesLayer+(y-onHeight)*width] |= architecture_bit.bond_down;
333: bond_ver [x+leavesLayer+(y-onHeight)*width]=defaultWoodBondStrength;
334: }
335: }
336: break;
337: }
338: }
339: }
340: }
341: // grow leaves on trunk, to left
342: if(x-1>=0)
343: for(int onHeight=2;onHeight<=heightReached; onHeight++){
344: if(bltype[x-1+(y-onHeight)*width]==0){
345: if((rand()%treeLeafGrowthChance)==0){
346: if((rand()%treeLeafEndingChance)==0){
347: bltype[x-1+(y-onHeight)*width]=16;
348: }else{
349: bltype[x-1+(y-onHeight)*width]=15;
350: }
351: architecture[x-1+(y-onHeight)*width]=architecture_bit.dynamic;
352: architecture[x-1+(y-onHeight)*width] |= architecture_bit.bond_right;
353: bond_hor [x-1+(y-onHeight)*width]=defaultWoodBondStrength;
354: weight [x-1+(y-onHeight)*width]=defaultWoodBlockWeight;
355: if((y-onHeight)>0)
356: if(
357: (bltype[x-1+(y-onHeight-1)*width]==15)||
358: (bltype[x-1+(y-onHeight-1)*width]==16)||
359: (bltype[x-1+(y-onHeight-1)*width]==10)||
360: (bltype[x-1+(y-onHeight-1)*width]==11)||
361: (bltype[x-1+(y-onHeight-1)*width]==12)||
362: (bltype[x-1+(y-onHeight-1)*width]==13)||
363: (bltype[x-1+(y-onHeight-1)*width]==14)
364: ){
365: architecture[x-1+(y-onHeight-1)*width] |= architecture_bit.bond_down;
366: bond_ver [x-1+(y-onHeight-1)*width]=defaultWoodBondStrength;
367: }
368: if(
369: (bltype[x-1+(y-onHeight+1)*width]==15)||
370: (bltype[x-1+(y-onHeight+1)*width]==16)||
371: (bltype[x-1+(y-onHeight+1)*width]==10)||
372: (bltype[x-1+(y-onHeight+1)*width]==11)||
373: (bltype[x-1+(y-onHeight+1)*width]==12)||
374: (bltype[x-1+(y-onHeight+1)*width]==13)||
375: (bltype[x-1+(y-onHeight+1)*width]==14)
376: ){
377: architecture[x-1+(y-onHeight)*width] |= architecture_bit.bond_down;
378: bond_ver [x-1+(y-onHeight)*width]=defaultWoodBondStrength;
379: }
380: }
381: continue;
382: }
383: if((bltype[x-1+(y-onHeight)*width]==15)&&
384: ((architecture[x-1+(y-onHeight)*width] & architecture_bit.bond_right)!=0 )){
385: // if there are leaves on this height, then grow more leaves on that side
386: for(int leavesLayer=1;leavesLayer<=maxTreeLeavesThick;leavesLayer++){
387: if(x-leavesLayer<0)break;
388: if(bltype[x-leavesLayer+(y-onHeight)*width]!=15){
389: if(bltype[x-leavesLayer+(y-onHeight)*width]==0)
390: if((rand()%treeLeafGrowthChance)==0){
391: // add one more leaf block
392: if((rand()%treeLeafEndingChance)==0){
393: bltype[x-leavesLayer+(y-onHeight)*width]=16;
394: }else{
395: bltype[x-leavesLayer+(y-onHeight)*width]=15;
396: }
397: architecture[x-leavesLayer+(y-onHeight)*width]=architecture_bit.dynamic;
398: architecture[x-leavesLayer+(y-onHeight)*width] |= architecture_bit.bond_right;
399: bond_hor [x-leavesLayer+(y-onHeight)*width]=defaultWoodBondStrength;
400: weight [x-leavesLayer+(y-onHeight)*width]=defaultWoodBlockWeight;
401: if((y-onHeight)>0)
402: if(
403: (bltype[x-leavesLayer+(y-onHeight-1)*width]==15)||
404: (bltype[x-leavesLayer+(y-onHeight-1)*width]==16)||
405: (bltype[x-leavesLayer+(y-onHeight-1)*width]==10)||
406: (bltype[x-leavesLayer+(y-onHeight-1)*width]==11)||
407: (bltype[x-leavesLayer+(y-onHeight-1)*width]==12)||
408: (bltype[x-leavesLayer+(y-onHeight-1)*width]==13)||
409: (bltype[x-leavesLayer+(y-onHeight-1)*width]==14)
410: ){
411: architecture[x-leavesLayer+(y-onHeight-1)*width] |= architecture_bit.bond_down;
412: bond_ver [x-leavesLayer+(y-onHeight-1)*width]=defaultWoodBondStrength;
413: }
414: if(
415: (bltype[x-leavesLayer+(y-onHeight+1)*width]==15)||
416: (bltype[x-leavesLayer+(y-onHeight+1)*width]==16)||
417: (bltype[x-leavesLayer+(y-onHeight+1)*width]==10)||
418: (bltype[x-leavesLayer+(y-onHeight+1)*width]==11)||
419: (bltype[x-leavesLayer+(y-onHeight+1)*width]==12)||
420: (bltype[x-leavesLayer+(y-onHeight+1)*width]==13)||
421: (bltype[x-leavesLayer+(y-onHeight+1)*width]==14)
422: ){
423: architecture[x-leavesLayer+(y-onHeight)*width] |= architecture_bit.bond_down;
424: bond_ver [x-leavesLayer+(y-onHeight)*width]=defaultWoodBondStrength;
425: }
426: }
427: break;
428: }
429: }
430: }
431: }
432: //grow arcons, right
433: //first - find lower branch
434: if(x+1<width)
435: for(int onHeight=2;onHeight<=heightReached; onHeight++){
436: if((bltype[x+1+(y-onHeight)*width]!=10)&&
437: (bltype[x+1+(y-onHeight)*width]!=12)&&
438: (bltype[x+1+(y-onHeight)*width]!=14)) continue;
439: //cycle through branch
440: for(int branchLenght=1;branchLenght<=maxTreeBranchLenght; branchLenght++){
441: if(x+1+branchLenght>=width)break;
442: if(((bltype[x+1+branchLenght+(y-onHeight)*width]==10)||
443: (bltype[x+1+branchLenght+(y-onHeight)*width]==12)||
444: (bltype[x+1+branchLenght+(y-onHeight)*width]==14)
445: )&&
446: ((architecture[x+branchLenght+(y-onHeight)*width] & architecture_bit.bond_right)!=0 )){
447: if( (bltype[x+1+branchLenght+(y-onHeight+1)*width]==0 )||
448: (bltype[x+1+branchLenght+(y-onHeight+1)*width]==15)||
449: (bltype[x+1+branchLenght+(y-onHeight+1)*width]==16))
450: if((rand()%arconGrowthChance)==0){
451: bltype [x+1+branchLenght+(y-onHeight+1)*width]=17;
452: architecture[x+1+branchLenght+(y-onHeight+1)*width]=architecture_bit.dynamic;
453: weight [x+1+branchLenght+(y-onHeight+1)*width]=defaultStoneBlockWeight;
454:
455: architecture[x+1+branchLenght+(y-onHeight )*width] |= architecture_bit.bond_down;
456: bond_ver [x+1+branchLenght+(y-onHeight )*width]=1;
457:
458: architecture[x +branchLenght+(y-onHeight+1)*width] &= (~architecture_bit.bond_right);
459: bond_hor [x +branchLenght+(y-onHeight+1)*width]=0;
460:
461: architecture[x+1+branchLenght+(y-onHeight+1)*width] &= (~architecture_bit.bond_down);
462: bond_ver [x+1+branchLenght+(y-onHeight+1)*width]=0;
463:
464: architecture[x+1+branchLenght+(y-onHeight+1)*width] &= (~architecture_bit.bond_right);
465: bond_hor [x+1+branchLenght+(y-onHeight+1)*width]=0;
466:
467: break;
468: }
469: }
470: }
471: break;
472: }
473: //grow arcons, left
474: //first - find lower branch
475: if(x-1>=0)
476: for(int onHeight=2;onHeight<=heightReached; onHeight++){
477: if((bltype[x-1+(y-onHeight)*width]!=10)&&
478: (bltype[x-1+(y-onHeight)*width]!=11)&&
479: (bltype[x-1+(y-onHeight)*width]!=13)) continue;
480: //cycle through branch
481: for(int branchLenght=1;branchLenght<=maxTreeBranchLenght; branchLenght++){
482: if(x-1-branchLenght<0)break;
483: if(((bltype[x-1-branchLenght+(y-onHeight)*width]==10)||
484: (bltype[x-1-branchLenght+(y-onHeight)*width]==11)||
485: (bltype[x-1-branchLenght+(y-onHeight)*width]==13)
486: )&&
487: ((architecture[x-1-branchLenght+(y-onHeight)*width] & architecture_bit.bond_right)!=0 )){
488: if( (bltype[x-1-branchLenght+(y-onHeight+1)*width]==0 )||
489: (bltype[x-1-branchLenght+(y-onHeight+1)*width]==15)||
490: (bltype[x-1-branchLenght+(y-onHeight+1)*width]==16))
491: if((rand()%arconGrowthChance)==0){
492: bltype [x-1-branchLenght+(y-onHeight+1)*width]=17;
493: architecture[x-1-branchLenght+(y-onHeight+1)*width]=architecture_bit.dynamic;
494: weight [x-1-branchLenght+(y-onHeight+1)*width]=defaultStoneBlockWeight;
495:
496: architecture[x-1-branchLenght+(y-onHeight )*width] |= architecture_bit.bond_down;
497: bond_ver [x-1-branchLenght+(y-onHeight )*width]=1;
498:
499: architecture[x-1-branchLenght+(y-onHeight+1)*width] &= (~architecture_bit.bond_right);
500: bond_hor [x-1-branchLenght+(y-onHeight+1)*width]=0;
501:
502: architecture[x-1-branchLenght+(y-onHeight+1)*width] &= (~architecture_bit.bond_down);
503: bond_ver [x-1-branchLenght+(y-onHeight+1)*width]=0;
504:
505: if(x-2-branchLenght>=0){
506: architecture[x-2-branchLenght+(y-onHeight+1)*width] &= (~architecture_bit.bond_right);
507: bond_hor [x-2-branchLenght+(y-onHeight+1)*width]=0;
508: }
509: break;
510: }
511: }
512: }
513: break;
514: }
515: }
516: if(bltype[jindex]==17){ // arcon
517: if(y+1<height){
518: // acron grow
519: if(bltype[x+y*width+width]==1){
520: if((rand()%arconGrowthChance)==0){
521: bltype[jindex]=7; // make new root
522: architecture[jindex] |= architecture_bit.bond_down;
523: bond_ver [jindex]=defaultWoodBondStrength;
524: }
525: }
526: //arcon should fall through leaves
527: if((bltype[x + y * width+width]==15)||
528: (bltype[x + y * width+width]==16))
529: {
530: bltype[x + y * width+width]=0;
531: architecture[x + y * width ] &= (~architecture_bit.bond_down);
532: architecture[x + y * width + width] &= (~architecture_bit.dynamic);
533: architecture[x + y * width + width] &= (~architecture_bit.bond_down);
534: architecture[x + y * width + width] &= (~architecture_bit.bond_right);
535: if(x-1>=0){
536: architecture[x-1+y * width + width] &= (~architecture_bit.bond_right);
537: }
538: }
539: }
540: }
541: }