bool SuperastCPP::TraverseFunctionDecl(clang::FunctionDecl* functionDecl) {
const std::string functionName = functionDecl->getNameInfo().getAsString();
rapidjson::Value functionValue(rapidjson::kObjectType);
addId(functionValue);
addPos(functionValue, functionDecl);
functionValue.AddMember("type", "function-declaration", allocator);
// Add the name
functionValue.AddMember(
"name",
rapidjson::Value().SetString(functionName.c_str(),
functionName.size(),
allocator),
allocator);
// Add the return type
clang::QualType qualType = functionDecl->getCallResultType().getNonLValueExprType(*context);
functionValue.AddMember("return-type", createTypeValue((qualType.getTypePtr())), allocator);
// Array of parameters
rapidjson::Value parametersValue(rapidjson::kArrayType);
// Traverse parameters
for (unsigned int i = 0; i < functionDecl->param_size(); ++i) {
TRY_TO(TraverseDecl(functionDecl->getParamDecl(i)));
// Add the parameter to array
parametersValue.PushBack(sonValue, allocator);
}
// Add parameters to functionValue
functionValue.AddMember("parameters", parametersValue, allocator);
// If this is a function definition, traverse definition.
if (functionDecl->isThisDeclarationADefinition()) {
TRY_TO(TraverseStmt(functionDecl->getBody()));
ensureSonIsArray();
rapidjson::Value blockValue = createBlockValue(sonValue);
functionValue.AddMember("block", blockValue, allocator);
}
else {
// If not definition, add empty block
rapidjson::Value emptyArray(rapidjson::kArrayType);
functionValue.AddMember("block", createBlockValue(emptyArray), allocator);
}
// END BODY TRAVERSE
sonValue = functionValue;
return true;
}
JSONTEST_FIXTURE( ValueTest, compareArray )
{
// array compare size then content
Json::Value emptyArray(Json::arrayValue);
Json::Value l1aArray;
l1aArray.append( 0 );
Json::Value l1bArray;
l1bArray.append( 10 );
Json::Value l2aArray;
l2aArray.append( 0 );
l2aArray.append( 0 );
Json::Value l2bArray;
l2bArray.append( 0 );
l2bArray.append( 10 );
JSONTEST_ASSERT_PRED( checkIsLess( emptyArray, l1aArray ) );
JSONTEST_ASSERT_PRED( checkIsLess( emptyArray, l2aArray ) );
JSONTEST_ASSERT_PRED( checkIsLess( l1aArray, l2aArray ) );
JSONTEST_ASSERT_PRED( checkIsLess( l2aArray, l2bArray ) );
JSONTEST_ASSERT_PRED( checkIsEqual( emptyArray, Json::Value( emptyArray ) ) );
JSONTEST_ASSERT_PRED( checkIsEqual( l1aArray, Json::Value( l1aArray) ) );
JSONTEST_ASSERT_PRED( checkIsEqual( l2bArray, Json::Value( l2bArray) ) );
}
XBOX::VJSValue VJSStructuredClone::_NodeToValue (XBOX::VJSContext inContext, SNode *inNode, std::map<SNode *, JS4D::ValueRef> *ioAlreadyCreated, std::list<SEntry> *ioToDoList)
{
xbox_assert(ioAlreadyCreated != NULL && ioToDoList != NULL);
XBOX::VJSValue value(inContext);
switch (inNode->fType) {
case eNODE_UNDEFINED:
value.SetUndefined();
break;
case eNODE_NULL:
value.SetNull();
break;
case eNODE_BOOLEAN:
value.SetBool(inNode->fValue.fBoolean);
break;
case eNODE_NUMBER:
value.SetNumber<Real>(inNode->fValue.fNumber);
break;
case eNODE_STRING:
value.SetString(*inNode->fValue.fString);
break;
case eNODE_BOOLEAN_OBJECT:
value.SetBool(inNode->fValue.fBoolean);
value = _ConstructObject(inContext, "Boolean", value);
break;
case eNODE_NUMBER_OBJECT:
value.SetNumber(inNode->fValue.fNumber);
value = _ConstructObject(inContext, "Number", value);
break;
case eNODE_STRING_OBJECT:
case eNODE_REG_EXP_OBJECT:
value.SetString(*inNode->fValue.fString);
value = _ConstructObject(inContext, inNode->fType == eNODE_STRING_OBJECT ? "String" : "RegExp", value);
break;
case eNODE_DATE_OBJECT:
value.SetNumber(inNode->fValue.fNumber);
value = _ConstructObject(inContext, "Date", value);
break;
case eNODE_SERIALIZABLE:
value.SetString(*inNode->fValue.fSerializationData.fJSON);
value = _ConstructObject(inContext, *inNode->fValue.fSerializationData.fConstructorName, value);
break;
case eNODE_OBJECT: {
XBOX::VJSObject emptyObject(inContext);
SEntry entry;
emptyObject.MakeEmpty();
value.SetValueRef((JS4D::ValueRef) emptyObject.GetObjectRef());
xbox_assert(ioAlreadyCreated->find(inNode->fValue.fReference) == ioAlreadyCreated->end());
(*ioAlreadyCreated)[inNode] = value.GetValueRef();
entry.fValueRef = value.GetValueRef();
entry.fNode = inNode;
ioToDoList->push_back(entry);
break;
}
case eNODE_ARRAY: {
XBOX::VJSArray emptyArray(inContext);
SEntry entry;
value.SetValueRef((JS4D::ValueRef) emptyArray.GetObjectRef());
xbox_assert(ioAlreadyCreated->find(inNode->fValue.fReference) == ioAlreadyCreated->end());
(*ioAlreadyCreated)[inNode] = value.GetValueRef();
entry.fValueRef = value.GetValueRef();
entry.fNode = inNode;
ioToDoList->push_back(entry);
break;
}
case eNODE_REFERENCE: {
std::map<SNode *, JS4D::ValueRef>::iterator it;
it = ioAlreadyCreated->find(inNode->fValue.fReference);
xbox_assert(it != ioAlreadyCreated->end());
value.SetValueRef(it->second);
break;
}
default:
xbox_assert(false);
value.SetNull();
break;
}
return value;
}
// while(name[counnter] != null){
// counter++;
// }
// }
void writeFile(char* name, char* buffer, int secNum){
int fileNameCounter =0;
int i;
char mapArray [512];
char directoryArray [512];
char sectorBuffer [512];
int emptyfileFound = 0;
int bufferIndex = 0;
int EmptySectorNumber;
int j=0;
int sectorNumber =0;
readSector(mapArray,1);
readSector(directoryArray,2);
for(i=0; i<512; i++){
// checking for empty file
if(directoryArray[i] != 0x00 && emptyfileFound == 0){
i = i+31;
}else{
//printString("here2 \0");
emptyfileFound =1;
}
if(directoryArray[i] == 0x0 && emptyfileFound ==1){
// adding name of the file to the directory
if(fileNameCounter<6){
if(name[fileNameCounter]){
directoryArray[i] = name[fileNameCounter];
fileNameCounter++;
}else{
//directoryArray[i]= 0x0;
fileNameCounter++;
}
}
else {
// adding the content of the file to the sector
EmptySectorNumber = getTheFirstEmptySectorNumber(mapArray);
if(secNum != 0){
mapArray[EmptySectorNumber] = 0xFF;
directoryArray[i] = EmptySectorNumber;
for(j=0;j<512;j++){
sectorBuffer[j]= buffer[(sectorNumber*32)+j];
}
writeSector(sectorBuffer,EmptySectorNumber);
EmptySectorNumber++;
secNum--;
bufferIndex++;
emptyArray(buffer);
}else{
break;
}
}
}
}
writeSector(mapArray,1);
writeSector(directoryArray,2);
}
//=================================================================
bool TileAssembler::convertWorld()
{
#ifdef _ASSEMBLER_DEBUG
# ifdef _DEBUG
::g_df = fopen("../TileAssembler_debug.txt", "wb");
# else
::g_df = fopen("../TileAssembler_release.txt", "wb");
# endif
#endif
bool result = true;
std::string fname = iSrcDir;
fname.append("/");
fname.append("dir");
iCoordModelMapping->setModelNameFilterMethod(iFilterMethod);
iCoordModelMapping->readCoordinateMapping(fname);
Array<unsigned int> mapIds = iCoordModelMapping->getMaps();
if(mapIds.size() == 0)
{
result = false;
}
for(int i=0; i<mapIds.size() && result; ++i)
{
unsigned int mapId = mapIds[i];
#ifdef _ASSEMBLER_DEBUG
if(mapId == 0) // "Azeroth" just for debug
{
for(int x=28; x<29 && result; ++x) //debug
{
for(int y=28; y<29 && result; ++y)
{
#else
// ignore DeeprunTram (369) it is too large for short vector and not important
// ignore test (13), Test (29) , development (451)
if(mapId != 369 && mapId != 13 && mapId != 29 && mapId != 451)
{
for(int x=0; x<66 && result; ++x)
{
for(int y=0; y<66 && result; ++y)
{
#endif
Array<ModelContainer*> mc;
std::string dirname;
char buffer[100];
if(iCoordModelMapping->isWorldAreaMap(mapId) && x<65 && y<65)
{
sprintf(buffer, "%03u_%d_%d",mapId,x,y);
dirname = std::string(buffer);
}
else
{
sprintf(buffer, "%03u",mapId);
dirname = std::string(buffer);
}
result = fillModelContainerArray(dirname, mapId, x, y, mc);
emptyArray(mc);
}
}
}
}
#ifdef _ASSEMBLER_DEBUG
if(::g_df) fclose(::g_df);
#endif
return result;
}
//=================================================================
bool TileAssembler::fillModelContainerArray(const std::string& pDirFileName, unsigned int pMapId, int pXPos, int pYPos, Array<ModelContainer*>& pMC)
{
bool result = true;
ModelContainer* modelContainer;
NameCollection nameCollection = iCoordModelMapping->getFilenamesForCoordinate(pMapId, pXPos, pYPos);
if(nameCollection.size() > 0)
{
result = false;
char dirfilename[500];
sprintf(dirfilename,"%s/%s.vmdir",iDestDir.c_str(),pDirFileName.c_str());
FILE *dirfile = fopen(dirfilename, "ab");
if(dirfile)
{
result = true;
char destnamebuffer[500];
char fullnamedestnamebuffer[500];
if(nameCollection.iMainFiles.size() >0)
{
sprintf(destnamebuffer,"%03u_%i_%i.vmap",pMapId, pXPos, pYPos);
std::string checkDoubleStr = std::string(dirfilename);
checkDoubleStr.append("##");
checkDoubleStr.append(std::string(destnamebuffer));
// Check, if same file already is in the same dir file
if(!iCoordModelMapping->isAlreadyProcessedSingleFile(checkDoubleStr))
{
iCoordModelMapping->addAlreadyProcessedSingleFile(checkDoubleStr);
fprintf(dirfile, "%s\n",destnamebuffer);
sprintf(fullnamedestnamebuffer,"%s/%s",iDestDir.c_str(),destnamebuffer);
modelContainer = processNames(nameCollection.iMainFiles, fullnamedestnamebuffer);
if(modelContainer)
{
pMC.append(modelContainer);
}
else
{
result = false;
}
}
}
// process the large singe files
int pos = 0;
while(result && (pos < nameCollection.iSingeFiles.size()))
{
std::string destFileName = iDestDir;
destFileName.append("/");
std::string dirEntryName = getDirEntryNameFromModName(pMapId,nameCollection.iSingeFiles[pos]);
std::string checkDoubleStr = std::string(dirfilename);
checkDoubleStr.append("##");
checkDoubleStr.append(nameCollection.iSingeFiles[pos]);
// Check, if same file already is in the same dir file
if(!iCoordModelMapping->isAlreadyProcessedSingleFile(checkDoubleStr))
{
iCoordModelMapping->addAlreadyProcessedSingleFile(checkDoubleStr);
fprintf(dirfile, "%s\n",dirEntryName.c_str());
destFileName.append(dirEntryName);
Array<std::string> positionarray;
positionarray.append(nameCollection.iSingeFiles[pos]);
if(!iCoordModelMapping->isAlreadyProcessedSingleFile(nameCollection.iSingeFiles[pos]))
{
modelContainer = processNames(positionarray, destFileName.c_str());
iCoordModelMapping->addAlreadyProcessedSingleFile(nameCollection.iSingeFiles[pos]);
if(modelContainer)
{
pMC.append(modelContainer);
}
else
{
result = false;
}
}
}
++pos;
}
fclose(dirfile);
}
}
return(result);
}
//=================================================================
void removeEntriesFromTree(AABSPTree<SubModel *>* pTree)
{
Array<SubModel *> submodelArray;
pTree->getMembers(submodelArray);
int no = submodelArray.size();
while(no > 0)
{
--no;
delete submodelArray[no];
}
}
//=================================================================
ModelContainer* TileAssembler::processNames(const Array<std::string>& pPositions, const char* pDestFileName)
{
ModelContainer *modelContainer = 0;
Vector3 basepos = Vector3(0,0,0);
AABSPTree<SubModel *>* mainTree = new AABSPTree<SubModel *>();
int pos = 0;
bool result = true;
while(result && (pos < pPositions.size()))
{
std::string modelPosString = pPositions[pos];
std::string modelFileName = getModNameFromModPosName(modelPosString);
if(!fillModelIntoTree(mainTree, basepos, modelPosString, modelFileName))
{
result = false;
break;
}
++pos;
}
if(result && mainTree->size() > 0)
{
mainTree->balance();
modelContainer = new ModelContainer(mainTree);
modelContainer->writeFile(pDestFileName);
}
removeEntriesFromTree(mainTree);
delete mainTree;
return(modelContainer);
}
/// Construct a PicoJsonArray referencing an empty array.
PicoJsonArray()
: value(emptyArray()) { }
/// Construct a Json11Array referencing an empty array.
Json11Array()
: value(emptyArray()) { }
int main(){
//imposta il seme del random al tempo attuale. Necessario per la funzione rand()
srand(time(0));
/* *\
** Ciclo principale, chiede la modalita' di gioco e inizializza il ciclo di gioco **
** Decide casualmente il giocatore iniziale. **
\* */
do{
emptyArray(gameBoard);
printf("Seleziona modalita:\n 0 -- umano vs pc\n 1 -- umano vs umano\n 2 -- pc vs pc\n");
scanf("%d", &mod);
if(mod == -1){
break;
}
if(rand() % 2 + 1 == 1){
turn = 1;
printf("Giocatore 2 inizia per primo.\n");
}
else{
turn = 0;
printf("Giocatore 1 inizia per primo.\n");
}
/* *\
** Ciclo di gioco. Inizia cercando un vincitore. **
** In base alla modalita' selezionata e al turno, richiede un input al giocatore umano **
** o calcola le mosse dell'IA. **
** Stampa il campo da gioco e infine controlla se il e' pieno **
\* */
do{
if(checkForWinner(gameBoard) == 1 || checkForWinner(gameBoard) == 2){
break;
}
if(turn == 0 && pc == 2 || turn == 1 && pc == 1){
printf("-------------------\n");
(mod == 0 || mod == 2) ? printf("Turno del computer\n") : printf("Turno del giocatore 1\n");
printf("-------------------\n");
if(mod == 1) printInstructions();
(mod == 0 || mod == 2) ? (moveResult = elaborateMove(gameBoard, pc)) : (moveResult = makeMove(gameBoard, pc));
}
else if(turn == 0 && player == 2 || turn == 1 && player == 1){
printf("-------------------\n");
(mod == 2) ? printf("Turno del computer\n") : printf("Turno del giocatore 2\n");
printf("-------------------\n");
printInstructions();
(mod == 2) ? (moveResult = elaborateMove(gameBoard, player)) : (moveResult = makeMove(gameBoard, player));
}
if(moveResult != -1){
if(turn == 0){
turn = 1;
}
else{
turn = 0;
}
}
else{
printf("Partita terminata.\n");
turn = -1;
}
createTable(gameBoard);
if(gameBoardFull(gameBoard) && turn != -1){
checkForWinner(gameBoard);
turn = -1;
}
}while(turn != -1);
turn = 0;
}while(mod != -1);
getchar();
}
int bestMove(int player, int gameBoard[BOARD_SIZE][BOARD_SIZE], int bestCell[2]){
int mPriority[BOARD_SIZE][BOARD_SIZE];
int i = 0, j = 0;
int enemy;
int highestPriority = 0;
long rnd; //Variabile per contenere il risultato della funzione rand()
if(player == 1){
enemy = 2;
}
else if(player == 2){
enemy = 1;
}
emptyArray(mPriority); //Inizializza l'array delle priorita' a 0 in ogni sua cella
//I cicli controllano tutte le righe e colonne chiamando le funzioni checkRow e checkColumn
for(i = 0; i < BOARD_SIZE; i++){
ifLesserReplace(&highestPriority, checkRow(gameBoard, i, player, enemy, mPriority));
for(j = 0; j < BOARD_SIZE; j++){
ifLesserReplace(&highestPriority, checkColumn(gameBoard, j, player, enemy, mPriority));
}
}
//Analisi delle diagonali tramite checkDiagonal
ifLesserReplace(&highestPriority, checkDiagonal(gameBoard, player, enemy, mPriority));
if(highestPriority >= 5){
//Termina la partita
return 5;
}
printf("Highest status: %d\n", highestPriority);
//Inserisce in un array le mosse con priorita' massima
int highestPriorityMoves[9];
int highestPriorityMovesNumber = 0;
for(i = 0; i < 3; i++){
for(j = 0; j < 3; j++){
if(mPriority[i][j] == highestPriority){
/*La mossa e' memorizzata come un numero a 2 cifre
La prima cifra e' la x, la seconda la y */
highestPriorityMoves[highestPriorityMovesNumber] = (i * 10) + j;
highestPriorityMovesNumber++;
}/*Fine analisi mosse con priorita massima*/
}
}
//Estrae un numero pseudo-randomico compreso fra 0 e il numero di mosse con priorita' piu' alta (escluso)
rnd = rand() % highestPriorityMovesNumber;
//Inizializza l'array contenete le coord. della mossa scelta
//Se la mossa scelta e' un numero < 10 (ovvero la x era 0) imposta la x a 0, altrimenti la imposta come la prima cifra del numero
(highestPriorityMoves[rnd] < 10) ? (bestCell[0] = 0) : (bestCell[0] = highestPriorityMoves[rnd] / 10);
//Per la y invece, nel caso sia < 10 la y equivale al numero stesso, altrimenti equivale all'ultima cifra del numero
(highestPriorityMoves[rnd] < 10) ? (bestCell[1] = highestPriorityMoves[rnd]) : (bestCell[1] = highestPriorityMoves[rnd] % 10);
/*Fine analisi mossa migliore*/
return 1;
}
