int searchForStructures(){ char tempBoard[ (BOARD_MAX_SIZE+4) * (BOARD_MAX_SIZE+4)]; int i,j,finded,matrixSize,rtr; finded = 1;j = 0;rtr = 0; matrixSize = Board.settings.matrixSize; for(i = 0;i < (matrixSize+4) * (matrixSize+4);i++){ if(i % (matrixSize+4) < 2 || i %(matrixSize+4) >= matrixSize+2 || i / (matrixSize+4) < 2 || i/(matrixSize+4) >= matrixSize+2)tempBoard[i] = 0; else { tempBoard[i] = Board.Board[j]; j++; } } while(finded){ finded = 0; i = 0; while(i < Board.settings.numberOfStructures && !finded){ j = 0; while(j < (matrixSize+2)*(matrixSize+2) && !finded ){ if(controlStructure(tempBoard,j,i)){//verilen index ile structure ı karşılaştırıyor finded = 1; rtr = 1; Board.settings.player.score += Board.settings.structures[i].point; clearStructure(tempBoard,j,i); if(Board.settings.player.score > HighScore.score){ MYS_Score_SetScore(&HighScore,Board.settings.player.score,Board.settings.player.name,3); SaveScore(); } } if( j % (matrixSize+4) == matrixSize+2)j += 2; else j++; } i++; } } //sleep(30000); return rtr; }
CC_FILE_ERROR AsciiFilter::loadCloudFromFormatedAsciiFile( const QString& filename, ccHObject& container, const AsciiOpenDlg::Sequence& openSequence, char separator, unsigned approximateNumberOfLines, qint64 fileSize, unsigned maxCloudSize, unsigned skipLines, LoadParameters& parameters) { //we may have to "slice" clouds when opening them if they are too big! maxCloudSize = std::min(maxCloudSize,CC_MAX_NUMBER_OF_POINTS_PER_CLOUD); unsigned cloudChunkSize = std::min(maxCloudSize,approximateNumberOfLines); unsigned cloudChunkPos = 0; unsigned chunkRank = 1; //we initialize the loading accelerator structure and point cloud int maxPartIndex = -1; cloudAttributesDescriptor cloudDesc = prepareCloud(openSequence, cloudChunkSize, maxPartIndex, separator, chunkRank); if (!cloudDesc.cloud) return CC_FERR_NOT_ENOUGH_MEMORY; //we re-open the file (ASCII mode) QFile file(filename); if (!file.open(QFile::ReadOnly)) { //we clear already initialized data clearStructure(cloudDesc); return CC_FERR_READING; } QTextStream stream(&file); //we skip lines as defined on input { for (unsigned i=0; i<skipLines; ++i) { stream.readLine(); } } //progress indicator ccProgressDialog pdlg(true); CCLib::NormalizedProgress nprogress(&pdlg,approximateNumberOfLines); pdlg.setMethodTitle(qPrintable(QString("Open ASCII file [%1]").arg(filename))); pdlg.setInfo(qPrintable(QString("Approximate number of points: %1").arg(approximateNumberOfLines))); pdlg.start(); //buffers ScalarType D = 0; CCVector3d P(0,0,0); CCVector3d Pshift(0,0,0); CCVector3 N(0,0,0); ccColor::Rgb col; //other useful variables unsigned linesRead = 0; unsigned pointsRead = 0; CC_FILE_ERROR result = CC_FERR_NO_ERROR; //main process unsigned nextLimit = /*cloudChunkPos+*/cloudChunkSize; QString currentLine = stream.readLine(); while (!currentLine.isNull()) { ++linesRead; //comment if (currentLine.startsWith("//")) { currentLine = stream.readLine(); continue; } if (currentLine.size() == 0) { ccLog::Warning("[AsciiFilter::Load] Line %i is corrupted (empty)!",linesRead); currentLine = stream.readLine(); continue; } //if we have reached the max. number of points per cloud if (pointsRead == nextLimit) { ccLog::PrintDebug("[ASCII] Point %i -> end of chunk (%i points)",pointsRead,cloudChunkSize); //we re-evaluate the average line size { double averageLineSize = static_cast<double>(file.pos())/(pointsRead+skipLines); double newNbOfLinesApproximation = std::max(1.0, static_cast<double>(fileSize)/averageLineSize - static_cast<double>(skipLines)); //if approximation is smaller than actual one, we add 2% by default if (newNbOfLinesApproximation <= pointsRead) { newNbOfLinesApproximation = std::max(static_cast<double>(cloudChunkPos+cloudChunkSize)+1.0,static_cast<double>(pointsRead) * 1.02); } approximateNumberOfLines = static_cast<unsigned>(ceil(newNbOfLinesApproximation)); ccLog::PrintDebug("[ASCII] New approximate nb of lines: %i",approximateNumberOfLines); } //we try to resize actual clouds if (cloudChunkSize < maxCloudSize || approximateNumberOfLines-cloudChunkPos <= maxCloudSize) { ccLog::PrintDebug("[ASCII] We choose to enlarge existing clouds"); cloudChunkSize = std::min(maxCloudSize,approximateNumberOfLines-cloudChunkPos); if (!cloudDesc.cloud->reserve(cloudChunkSize)) { ccLog::Error("Not enough memory! Process stopped ..."); result = CC_FERR_NOT_ENOUGH_MEMORY; break; } } else //otherwise we have to create new clouds { ccLog::PrintDebug("[ASCII] We choose to instantiate new clouds"); //we store (and resize) actual cloud if (!cloudDesc.cloud->resize(cloudChunkSize)) ccLog::Warning("Memory reallocation failed ... some memory may have been wasted ..."); if (!cloudDesc.scalarFields.empty()) { for (unsigned k=0; k<cloudDesc.scalarFields.size(); ++k) cloudDesc.scalarFields[k]->computeMinAndMax(); cloudDesc.cloud->setCurrentDisplayedScalarField(0); cloudDesc.cloud->showSF(true); } //we add this cloud to the output container container.addChild(cloudDesc.cloud); cloudDesc.reset(); //and create new one cloudChunkPos = pointsRead; cloudChunkSize = std::min(maxCloudSize,approximateNumberOfLines-cloudChunkPos); cloudDesc = prepareCloud(openSequence, cloudChunkSize, maxPartIndex, separator, ++chunkRank); if (!cloudDesc.cloud) { ccLog::Error("Not enough memory! Process stopped ..."); break; } cloudDesc.cloud->setGlobalShift(Pshift); } //we update the progress info nprogress.scale(approximateNumberOfLines,100,true); pdlg.setInfo(qPrintable(QString("Approximate number of points: %1").arg(approximateNumberOfLines))); nextLimit = cloudChunkPos+cloudChunkSize; } //we split current line QStringList parts = currentLine.split(separator,QString::SkipEmptyParts); int nParts = parts.size(); if (nParts > maxPartIndex) { //(X,Y,Z) if (cloudDesc.xCoordIndex >= 0) P.x = parts[cloudDesc.xCoordIndex].toDouble(); if (cloudDesc.yCoordIndex >= 0) P.y = parts[cloudDesc.yCoordIndex].toDouble(); if (cloudDesc.zCoordIndex >= 0) P.z = parts[cloudDesc.zCoordIndex].toDouble(); //first point: check for 'big' coordinates if (pointsRead == 0) { if (HandleGlobalShift(P,Pshift,parameters)) { cloudDesc.cloud->setGlobalShift(Pshift); ccLog::Warning("[ASCIIFilter::loadFile] Cloud has been recentered! Translation: (%.2f,%.2f,%.2f)",Pshift.x,Pshift.y,Pshift.z); } } //add point cloudDesc.cloud->addPoint(CCVector3::fromArray((P+Pshift).u)); //Normal vector if (cloudDesc.hasNorms) { if (cloudDesc.xNormIndex >= 0) N.x = static_cast<PointCoordinateType>(parts[cloudDesc.xNormIndex].toDouble()); if (cloudDesc.yNormIndex >= 0) N.y = static_cast<PointCoordinateType>(parts[cloudDesc.yNormIndex].toDouble()); if (cloudDesc.zNormIndex >= 0) N.z = static_cast<PointCoordinateType>(parts[cloudDesc.zNormIndex].toDouble()); cloudDesc.cloud->addNorm(N); } //Colors if (cloudDesc.hasRGBColors) { if (cloudDesc.iRgbaIndex >= 0) { const uint32_t rgb = parts[cloudDesc.iRgbaIndex].toInt(); col.r = ((rgb >> 16) & 0x0000ff); col.g = ((rgb >> 8 ) & 0x0000ff); col.b = ((rgb ) & 0x0000ff); } else if (cloudDesc.fRgbaIndex >= 0) { const float rgbf = parts[cloudDesc.fRgbaIndex].toFloat(); const uint32_t rgb = (uint32_t)(*((uint32_t*)&rgbf)); col.r = ((rgb >> 16) & 0x0000ff); col.g = ((rgb >> 8 ) & 0x0000ff); col.b = ((rgb ) & 0x0000ff); } else { if (cloudDesc.redIndex >= 0) { float multiplier = cloudDesc.hasFloatRGBColors[0] ? static_cast<float>(ccColor::MAX) : 1.0f; col.r = static_cast<ColorCompType>(parts[cloudDesc.redIndex].toFloat() * multiplier); } if (cloudDesc.greenIndex >= 0) { float multiplier = cloudDesc.hasFloatRGBColors[1] ? static_cast<float>(ccColor::MAX) : 1.0f; col.g = static_cast<ColorCompType>(parts[cloudDesc.greenIndex].toFloat() * multiplier); } if (cloudDesc.blueIndex >= 0) { float multiplier = cloudDesc.hasFloatRGBColors[2] ? static_cast<float>(ccColor::MAX) : 1.0f; col.b = static_cast<ColorCompType>(parts[cloudDesc.blueIndex].toFloat() * multiplier); } } cloudDesc.cloud->addRGBColor(col.rgb); } else if (cloudDesc.greyIndex >= 0)