黑客帝国-building_generator

@Cd = 0;
vector colors[] = {{1,0,0}, {0,1,0}, {0,0,1}};
@Cd = set(colors[i@vol]);

for( int i = 0; i < gramArrLen; i++)
{
    int CornerVariationArr[];
    string gramEntry = shapeGram[i]; 
    
    string gramElements[] = split(gramEntry,"|");
    //reverse grammar = naive attempt
    //gramElements = gramElements[::-1];
    //loop through and look up grammar and level to build dimension array
    //printf( "%g \n", gramElements);  
    //build repeating array, macro array, non-repeating macros
    int repeatElements[];
    int scalingElements[];
    int macroElements[];
    int fixedBlocks[];
    string expandGrammar[];
    string macroGrammar;
    string macroFormat;
    int bucketArray[];
    string format;
    int grammarType;
    int Importance[];
    int indexCount = 0;
    for ( int ii = 0; ii < len(gramElements); ii++)
    {
        format = strip(gramElements[ii]);
        grammarType = 4;
        //check for corner variations
        //ideally this is generic to work with all modules
        //look up corner grammar via corner priority
        if (format[0]=="C" )//&& @primnum == primToTest)
        {
            
            if (debug) printf("PrimID: %g\n", @primnum);
            
            if(len(format)>1)
            {
                append(CornerVariationArr, atoi(format[-1]));
                //format="C";
            }
            else append(CornerVariationArr, 0);
            if (debug) printf("Corner Variation Array: %g\n", CornerVariationArr);  
        }
            
        //check for macros 
        if (find(format, "-") > 0)
        {
            append(macroElements, 1);
            string elements[] = split(format, "-"); 
            for(int h = 0; h < len(elements); h++)
            {
               append(bucketArray, indexCount); 
            }
            indexCount++;
            
        }
        else
        {
            append(macroElements, 0);
            append(bucketArray, indexCount);
            indexCount++;
        }
            
        //check for repeating modules
        if (find(format, "(") >= 0)
        {
            append(repeatElements, 1);
            grammarType = 1;
        } else append(repeatElements, 0);
        
        if (find(format, "*") >=0 )
        {
            append(scalingElements, 1);
            grammarType = 1;
        } else append(scalingElements, 0);
        
        // check for fixed macro repetition amount
        if (find(format, "]") > 0)
        {
            int index = atoi(split(format,"]")[1]);
            append( fixedBlocks, index);
            grammarType = 2;
        }
        else append( fixedBlocks , 0);
        
        append(Importance, grammarType);
    }
    
    //debug
    if (debug==2)
    {
        printf( "%g : repeating\n", repeatElements);
        printf( "%g : scaling\n", scalingElements);
        printf( "%g : macro blocks\n", macroElements );
        printf( "%g : fixed repeat macro block\n", fixedBlocks );
        printf( "%g : bucket array\n", bucketArray );
        printf( "%g : Importance\n", Importance );
    }

d@ExpandGrammars[key] = expandGrammar;
d@CornerVariation[key] = CornerVariationArr;
d@GramRepeats[key] = repeatElements;
d@GramScales[key] = scalingElements;
d@GramMacroBlocks[key] = macroElements;
d@GramMacroFixedLength[key] =  fixedBlocks ;
d@GramBucketArray[key] = bucketArray;
d@GramDims[key] = grammarDims;
i@CornerCap = cornerCap;

function float CheckFit(float BucketDims[]; int TempBuckets[]; float faceLength)
{
    //total placed modules
    float placedLength = 0;
    for (int i = 0; i < len(TempBuckets); i++)
    {
        placedLength += (BucketDims[i] * TempBuckets[i]);
    }
    //printf( "placed Length:%g \n", placedLength);
    return (faceLength - placedLength);
}

function float PlacedLength(float BucketDims[]; int TempBuckets[])
{
    //total placed modules
    float placedLength = 0;
    for (int i = 0; i < len(TempBuckets); i++)
    {
        placedLength += (BucketDims[i] * TempBuckets[i]);
    }
    //printf( "placed Length:%g \n", placedLength);
    return (placedLength);
}

append(modulePtsAdded, newPtNum);
//?
setpointattrib(0, "CornerType", newPtNum, "", "set");
                                                                        
setpointattrib(0, "CornerNormal", newPtNum, {0,0,0}, "set");
//?
setpointattrib(0, "Corner", newPtNum, moduleCount, "set");
moduleCount +=1;
setpointattrib(0, "P", newPtNum, (PointStart + (primWallDir * offsetTotal)), "set");
setpointattrib(0, "N", newPtNum, wallNormal, "set");
setpointattrib(0, "ModuleType", newPtNum, module, "set");
setpointattrib(0, "ModuleIndexOnPrim", newPtNum, len(modulePtsAdded), "set");
setpointattrib(0, "scale", newPtNum, scale, "set");
setpointattrib(0, "offset", newPtNum, offset, "set");
setpointattrib(0, "ModDimZ", newPtNum, modDimZ, "set");
setpointattrib(0, "levelNum", newPtNum, levelNum, "set");
setpointattrib(0, "FloorNum", newPtNum, floorNum, "set");
setpointattrib(0, "Height", newPtNum, floorheight, "set");
setpointattrib(0, "PrimID", newPtNum, @primnum, "set");
setpointattrib(0, "FacadePt", newPtNum, facade, "set");
setpointattrib(0, "lot_ID", newPtNum, i@lot_ID, "set");
setpointattrib(0, "class", newPtNum, i@class, "set");
setpointattrib(0, "NYBlocks", newPtNum, NYBlocks, "set");
setpointattrib(0, "CornerVariation", newPtNum, "", "set");
setpointattrib(0, "BrandIndexRND", newPtNum, brandIndexRND, "set");

//[CHECK]set grammar index to -1 by default 
setpointattrib(0, "GrammarIndex", newPtNum, -1, "set");

setpointattrib(0, "CORNEROVERRIDE", newPtNum, "", "set");
setpointattrib(0, "BDF_Index", newPtNum, BDF_Index, "set");
setpointattrib(0, "BDF", newPtNum, s@bdf, "set");