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)
