int main (int argc, char * argv[])
{
int T[SIZE], max, diff;
double start, stop;
register int i, j;
/* keep the starting time */
start = startChrono ();
/*algo a gogo*/
retour * res;
graphe_t * gr = creation_arbre("DLP_170.dat");
res = dijkstra(gr,1,170);
for(int i=0;i<169;i++)
cout <<"label: " << res[i].label << " prec: " << res[i].prec << " dist: " << res[i].distance << endl;
/*fin algo*/
/* stop the chrono */
stop = stopChrono (start);
/* display the elapsed time */
printf("algo: max = %8d in %.2f s\n", max, stop);
return EXIT_SUCCESS;
}
void wait(u64 amount)
{
startChrono();
u64 initialValue = chrono();
while(chrono() - initialValue < amount);
}
bool playGame(Affichage A, Damier *map, Snake *snake, Sound sound)
{
int end = 0;
bool win = FALSE;
Position newPos = initPosition();
Input input = initInput();
Chrono chrono = initChrono();
Timer timer = initTimer();
setProiesToMap(map);
drawTile(A, TILE_TITLE);
drawTextChrono(chrono, A);
drawMap(A, *map, newPosition(MAXCASES/2 + 3,MAXCASES/2), *snake);
startChrono(&chrono);
while (1)
{
setTimer(&timer);
newPos = updatePositions(map, snake, &input);
if (input.end)
break;
if (testPosMap(newPos))
{
end = addPositionSnake(map, snake, newPos, sound);
if (end)
{
win = FALSE;
break;
}
}
setPositionsToMap(map, snake);
drawChrono(chrono, A);
drawMap(A, *map, newPos, *snake);
if(endChrono(chrono))
{
win = FALSE;
break;
}
if (endGame(map))
{
win = TRUE;
break;
}
reguleFPS(&timer);
}
deleteChrono(&chrono);
return win;
}
void chrono(u32 seconds)
{
static u64 startingTicks = 0;
if(!startingTicks) startChrono(0);
u64 res;
do
{
res = 0;
for(u32 i = 0; i < 4; i++) res |= REG_TIMER_VAL(i) << (16 * i);
}
while(res - startingTicks < seconds * TICKS_PER_SEC);
if(!seconds) startingTicks = res;
}
u32 waitInput(bool isMenu)
{
static u64 dPadDelay = 0ULL;
u64 initialValue = 0ULL;
u32 key,
oldKey = HID_PAD;
if(isMenu)
{
dPadDelay = dPadDelay > 0ULL ? 87ULL : 143ULL;
startChrono();
initialValue = chrono();
}
while(true)
{
key = HID_PAD;
if(!key)
{
if((i2cReadRegister(I2C_DEV_MCU, 0x10) & 1)== 1) mcuPowerOff();
oldKey = 0;
dPadDelay = 0;
continue;
}
if(key == oldKey && (!isMenu || (!(key & DPAD_BUTTONS) || chrono() - initialValue < dPadDelay))) continue;
//Make sure the key is pressed
u32 i;
for(i = 0; i < 0x13000 && key == HID_PAD; i++);
if(i == 0x13000) break;
}
return key;
}
int copyObjectToActor(int flag2, int var1, int foundName, int16 flag, int x, int y, int z, int stage, int room, int alpha, int beta, int gamma, int var2, int var3, int var4, int var5) {
int i;
int j;
actorStruct *actorPtr = actorTable;
char *bodyPtr;
ZVStruct *zvPtr;
for(i = 0; i < NUM_MAX_ACTOR; i++) {
if(actorPtr->field_0 == -1)
break;
actorPtr++;
}
if(i == NUM_MAX_ACTOR)
return -1;
currentProcessedActorPtr = actorPtr;
currentProcessedActorIdx = i;
actorPtr->bodyNum = flag2;
actorPtr->flags = flag;
actorPtr->stage = stage;
actorPtr->room = room;
actorPtr->worldX = actorPtr->roomX = x;
actorPtr->worldY = actorPtr->roomY = y;
actorPtr->worldZ = actorPtr->roomZ = z;
if(room != currentDisplayedRoom) {
actorPtr->worldX -= (int16)((roomDataTable[currentDisplayedRoom].worldX - roomDataTable[actorPtr->room].worldX) * 10);
actorPtr->worldY += (int16)((roomDataTable[currentDisplayedRoom].worldY - roomDataTable[actorPtr->room].worldY) * 10);
actorPtr->worldZ += (int16)((roomDataTable[currentDisplayedRoom].worldZ - roomDataTable[actorPtr->room].worldZ) * 10);
}
actorPtr->alpha = alpha;
actorPtr->beta = beta;
actorPtr->gamma = gamma;
actorPtr->dynFlags = 1;
actorPtr->ANIM = var2;
actorPtr->FRAME = var3;
actorPtr->field_40 = var4;
actorPtr->field_42 = var5;
actorPtr->END_FRAME = 1;
actorPtr->END_ANIM = 1;
actorPtr->field_44 = -1;
actorPtr->field_46 = 0;
actorPtr->field_48 = -1;
actorPtr->modX = 0;
actorPtr->modY = 0;
actorPtr->modZ = 0;
for(j = 0; j < 3; j++) {
actorPtr->COL[j] = -1;
}
actorPtr->COL_BY = -1;
actorPtr->HARD_DEC = -1;
actorPtr->HARD_COL = -1;
if(g_fitd->getGameType() != GType_AITD1) {
actorPtr->hardMat = -1;
}
actorPtr->rotate.oldAngle = 0;
actorPtr->rotate.newAngle = 0;
actorPtr->rotate.param = 0;
actorPtr->field_60.oldAngle = 0;
actorPtr->field_60.newAngle = 0;
actorPtr->field_60.param = 0;
actorPtr->falling = 0;
actorPtr->field_72 = 0;
actorPtr->speed = 0;
actorPtr->trackMode = 0;
actorPtr->trackNumber = -1;
actorPtr->animActionType = 0;
actorPtr->HIT = -1;
actorPtr->HIT_BY = -1;
if(flag2 != -1) {
bodyPtr = listBody->get(actorPtr->bodyNum);
if(var2 != -1) {
char *animPtr = listAnim->get(var2);
initAnimInBody(var3, animPtr, bodyPtr);
actorPtr->field_4C = getAnimParam(animPtr);
actorPtr->END_ANIM = 0;
actorPtr->flags |= 1;
// computeScreenBox(actorPtr->field_22 + actorPtr->field_5A, actorPtr->field_24 + actorPtr->field_5C, actorPtr->anim + actorPtr->field_5E, actorPtr->alpha, actorPtr->beta, actorPtr->gamma, bodyPtr);
if(BBox3D1 < 0)
BBox3D1 = 0;
if(BBox3D3 > 319)
BBox3D3 = 319;
if(BBox3D2 < 0)
BBox3D2 = 0;
if(BBox3D4 > 199)
BBox3D4 = 199;
actorPtr->field_14 = BBox3D1;
actorPtr->field_16 = BBox3D2;
actorPtr->field_18 = BBox3D3;
actorPtr->field_1A = BBox3D4;
} else {
if(!(actorPtr->flags & 4)) {
actorPtr->flags &= 0xFFFE;
}
}
}
startChrono(&actorPtr->ROOM_CHRONO);
startChrono(&actorPtr->CHRONO);
zvPtr = &actorPtr->zv;
switch(var1) {
case 0: {
if(flag2 != -1) {
getZvMax(bodyPtr, zvPtr);
} else {
makeDefaultZV(zvPtr);
}
break;
}
case 1: {
if(flag2 != -1) {
getZvNormal(bodyPtr, zvPtr);
} else {
makeDefaultZV(zvPtr);
}
break;
}
case 2: {
if(flag2 != -1) {
getZvCube(bodyPtr, zvPtr);
} else {
makeDefaultZV(zvPtr);
}
break;
}
case 3: {
if(flag2 != -1) {
getZvRot(bodyPtr, zvPtr, alpha, beta, gamma);
} else {
makeDefaultZV(zvPtr);
}
break;
}
case 4: {
if(g_fitd->getGameType() < GType_AITD3) {
char *roomDataPtr = (char *)getRoomData(room);
int numElements;
int j;
roomDataPtr += *(int16 *)roomDataPtr;
numElements = *(int16 *)roomDataPtr;
roomDataPtr += 2;
for(j = 0; j < numElements; j++) {
if(*(int16 *)(roomDataPtr + 0xE) == 9) {
if(*(int16 *)(roomDataPtr + 0xC) == foundName) {
int tempX;
int tempY;
int tempZ;
zvPtr->ZVX1 = (int16)READ_LE_UINT16(roomDataPtr + 0x00);
zvPtr->ZVX2 = (int16)READ_LE_UINT16(roomDataPtr + 0x02);
zvPtr->ZVY1 = (int16)READ_LE_UINT16(roomDataPtr + 0x04);
zvPtr->ZVY2 = (int16)READ_LE_UINT16(roomDataPtr + 0x06);
zvPtr->ZVZ1 = (int16)READ_LE_UINT16(roomDataPtr + 0x08);
zvPtr->ZVZ2 = (int16)READ_LE_UINT16(roomDataPtr + 0x0A);
x = 0;
y = 0;
z = 0;
tempX = ((*(int16 *)roomDataPtr) + (*(int16 *)(roomDataPtr + 2))) / 2;
actorPtr->worldX = tempX;
actorPtr->roomX = tempX;
tempY = ((*(int16 *)(roomDataPtr + 4)) + (*(int16 *)(roomDataPtr + 6))) / 2;
actorPtr->worldY = tempY;
actorPtr->roomY = tempY;
tempZ = ((*(int16 *)(roomDataPtr + 8)) + (*(int16 *)(roomDataPtr + 0xA))) / 2;
actorPtr->worldZ = tempZ;
actorPtr->roomZ = tempZ;
if(room != currentDisplayedRoom) {
actorPtr->worldX = (roomDataTable[currentDisplayedRoom].worldX - roomDataTable[room].worldX) * 10;
actorPtr->worldY = (roomDataTable[currentDisplayedRoom].worldY - roomDataTable[room].worldY) * 10;
actorPtr->worldZ = (roomDataTable[currentDisplayedRoom].worldZ - roomDataTable[room].worldZ) * 10;
}
break;
}
}
roomDataPtr += 0x10;
}
if(j == numElements) {
makeDefaultZV(zvPtr);
}
}
break;
}
default: {
warning("Unsupported ZV type in copyObjectToActor\n");
error("var1: %d\n", var1);
ASSERT(0);
break;
}
}
zvPtr->ZVX1 += x;
zvPtr->ZVX2 += x;
zvPtr->ZVY1 += y;
zvPtr->ZVY2 += y;
zvPtr->ZVZ1 += z;
zvPtr->ZVZ2 += z;
return(i);
}
void SQLCONN::phrasea_query(char *sql, Cquerytree2Parm *qp)
{
qp->sqlconn->connect();
MYSQL *xconn = (MYSQL *)(qp->sqlconn->get_native_conn());
/*
SQLCONN xconn(this->host, this->port, this->user, this->passwd, this->dbname);
xconn.connect();
*/
CHRONO chrono;
std::pair < std::set<PCANSWER, PCANSWERCOMPRID_DESC>::iterator, bool> insert_ret;
// mysql_thread_init();
startChrono(chrono);
// zend_printf("SQL:%s<br/>\n", sql);
MYSQL_STMT *stmt;
// if((stmt = mysql_stmt_init(&(this->mysql_connx))))
if((stmt = mysql_stmt_init(xconn)))
{
// qp->sqlmutex->lock();
if(mysql_stmt_prepare(stmt, sql, strlen(sql)) == 0)
{
// Execute the SELECT query
if(mysql_stmt_execute(stmt) == 0)
{
qp->n->time_sqlQuery = stopChrono(chrono);
// Bind the result buffers for all columns before fetching them
MYSQL_BIND bind[7];
unsigned long length[7];
my_bool is_null[7];
my_bool error[7];
long int_result[7];
unsigned char sha256[65];
char skey[201];
memset(bind, 0, sizeof (bind));
// every field is int...
for(int i = 0; i < 7; i++)
{
length[i] = 0;
is_null[i] = true; // so each not fetched column (not listed in sql) will be null
error[i] = false;
int_result[i] = 0;
// INTEGER COLUMN(S)
bind[i].buffer_type = MYSQL_TYPE_LONG;
bind[i].buffer = (char *) (&int_result[i]);
bind[i].is_null = &is_null[i];
bind[i].length = &length[i];
bind[i].error = &error[i];
}
// ... except :
// sha256 column : 256 bits
memset(sha256, 0, sizeof (sha256));
bind[SQLFIELD_SHA256].buffer_type = MYSQL_TYPE_STRING;
bind[SQLFIELD_SHA256].buffer_length = 65;
bind[SQLFIELD_SHA256].buffer = (char *) sha256;
// skey column : 100 chars utf8
memset(skey, 0, sizeof (skey));
bind[SQLFIELD_SKEY].buffer_type = MYSQL_TYPE_STRING;
bind[SQLFIELD_SKEY].buffer_length = 201;
bind[SQLFIELD_SKEY].buffer = (char *) skey;
// Bind the result buffers
if(mysql_stmt_bind_result(stmt, bind) == 0)
{
bool ok_to_fetch = true;
// Now buffer all results to client (optional step)
startChrono(chrono);
ok_to_fetch = (mysql_stmt_store_result(stmt) == 0);
qp->n->time_sqlStore = stopChrono(chrono);
// if(mutex_locked)
// {
// pthread_mutex_unlock(qp->sqlmutex);
// mutex_locked = false;
// }
// fetch results
if(ok_to_fetch)
{
long rid;
long lastrid = -1;
startChrono(chrono);
while(mysql_stmt_fetch(stmt) == 0)
{
rid = int_result[SQLFIELD_RID];
CANSWER *answer;
if((answer = new CANSWER()))
{
answer->rid = rid;
insert_ret = qp->n->answers.insert(answer);
if(insert_ret.second == false)
{
// this rid already exists
delete answer;
answer = *(insert_ret.first);
}
else
{
// n->nbranswers++;
// a new rid
answer->cid = int_result[SQLFIELD_CID];
if(!is_null[SQLFIELD_SHA256])
answer->sha2 = new CSHA(sha256);
if(!is_null[SQLFIELD_SKEY])
{
skey[length[SQLFIELD_SKEY]] = '\0';
switch(qp->sortMethod)
{
case SORTMETHOD_STR:
answer->sortkey.s = new std::string(skey);
break;
case SORTMETHOD_INT:
#ifdef PHP_WIN32
answer->sortkey.l = _strtoui64(skey, NULL, 10);
#else
answer->sortkey.l = atoll(skey);
#endif
break;
}
}
}
}
if(!is_null[SQLFIELD_IW] && answer)
{
CHIT *hit;
if(hit = new CHIT(int_result[SQLFIELD_IW]))
{
if(!(answer->firsthit))
answer->firsthit = hit;
if(answer->lasthit)
answer->lasthit->nexthit = hit;
answer->lasthit = hit;
}
}
if(!is_null[SQLFIELD_HITSTART] && !is_null[SQLFIELD_HITLEN] && answer)
{
CSPOT *spot;
if(spot = new CSPOT(int_result[SQLFIELD_HITSTART], int_result[SQLFIELD_HITLEN]))
{
if(!(answer->firstspot))
answer->firstspot = spot;
if(answer->lastspot)
answer->lastspot->_nextspot = spot;
answer->lastspot = spot;
}
}
}
qp->n->time_sqlFetch = stopChrono(chrono);
}
else // store error
{
zend_printf("ERR: line %d : %s<br/>\n", __LINE__, mysql_stmt_error(stmt));
}
}
else // bind error
{
zend_printf("ERR: line %d : %s<br/>\n", __LINE__, mysql_stmt_error(stmt));
}
}
else // execute error
{
zend_printf("ERR: line %d : %s<br/>\n", __LINE__, mysql_stmt_error(stmt));
}
}
else // prepare error
{
zend_printf("ERR: line %d : %s<br/>\n%s<br/>\n", __LINE__, mysql_stmt_error(stmt), sql);
}
// mysql_stmt_close(stmt);
// qp->sqlmutex->unlock();
}
// mysql_thread_end();
}
