/** * checks if the peasant can produce * produce the unit and returns 0 if succesful and 1 if not * checks if the peasant can produce */ static int produceUnit(int x1, int y1, int x2, int y2, enum unitType type) { // only on the neighbouring field if(!isNeighbour(x1, y1, x2, y2)) return 1; // is it inside the board if(!insideBoard(x1, y1, globalBoardSize)) return 1; if(!insideBoard(x2, y2, globalBoardSize)) return 1; // no unit or it is not a peasant on (x1, y1) UnitsList peasant = findUnit(x1, y1); if (peasant == NULL || peasant->type != PEASANT) return 1; // has the unit moved last two turns if (actualTurnNumber - peasant->lastMove < 3) return 1; UnitsList secondUnit = findUnit(x2, y2); // is there any other unit on (x2, y2) if(secondUnit != NULL) return 1; addUnit(x2, y2, type); // updates the last move of the peasant peasant->lastMove = actualTurnNumber; return 0; }
/** * moves the unit and returns 0 * returns 1 if not possible */ int move(int x1, int y1, int x2, int y2) { // moves only to the neighbouring if(!isNeighbour(x1, y1, x2, y2)) return 1; // inside board if(!insideBoard(x1, y1, globalBoardSize)) return 1; if(!insideBoard(x2, y2, globalBoardSize)) return 1; UnitsList unitFirst = findUnit(x1, y1); // first unit does not exist if (unitFirst == NULL) return 1; // has the unit moved already if (unitFirst->lastMove == actualTurnNumber) return 1; // does the player move his own unit if (unitFirst->player != actualPlayer) return 1; UnitsList unitSecond = findUnit(x2, y2); // moving onto the own unit if(unitSecond != NULL && unitSecond->player == actualPlayer) return 1; // moving on the enemy unit or the empty field if (x1 <= 10 && y1 <= 10) { topleft[unitFirst->x][unitFirst->y] = '.'; } unitFirst->x = x2; unitFirst->y = y2; unitFirst->lastMove = actualTurnNumber; // unit first is on the field for sure int winner = 1; // starts the fight if there is an enemy unit if (unitSecond != NULL) winner = walka(unitFirst, unitSecond); if (x2 <= 10 && y2 <= 10) { if (winner == 0) topleft[x2][y2] = '.'; else if (winner == 1) topleft[x2][y2] = mark(unitFirst->type, unitFirst->player); else topleft[x2][y2] = mark(unitSecond->type, unitSecond->player); } return 0; }
QValueList<Problem> BackgroundParser::problems( const QString& fileName ) { Unit* u = 0; if( (u = findUnit(fileName)) == 0 ){ m_fileList->remove( fileName ); u = parseFile( fileName, false ); } return u ? u->problems : QValueList<Problem>(); }
RefJavaAST BackgroundParser::translationUnit( const QString& fileName ) { Unit* u = 0; if( (u = findUnit(fileName)) == 0 ){ m_fileList->remove( fileName ); u = parseFile( fileName, false ); } return u->translationUnit; }
unit_t ProfilePlotView::unitForQuantity(quantity_t q) const { QSettings s; s.beginGroup("Settings"); QVariant uname = s.value(QString("Unit%1").arg(q)); s.endGroup(); try { if (! uname.isValid()) return findUnit(q, 0); else return findUnit(q, (const char *)uname.toByteArray()); } catch (std::runtime_error & e) { } return unit_t(); }
ParsedFilePointer BackgroundParser::translationUnit( const QString& fileName ) { Unit * u = findUnit( fileName ); if ( u == 0 ) { return 0; /*m_fileList->remove ( fileName ); u = parseFile( fileName, false );*/ } return u->translationUnit; }
QValueList<Problem> BackgroundParser::problems( const QString& fileName, bool readFromDisk, bool forceParse ) { Q_UNUSED(readFromDisk); Unit * u = findUnit( fileName ); if ( u == 0 || forceParse ) { /* m_fileList->remove ( fileName ); u = parseFile( fileName, readFromDisk ); */ } return u ? u->problems : QValueList<Problem>(); }
void BackgroundParser::removeFile( const QString& fileName ) { QMutexLocker locker( &m_mutex ); if( Unit* unit = findUnit(fileName) ){ m_driver->remove( fileName ); m_unitDict.remove( fileName ); delete( unit ); unit = 0; } if( m_fileList->isEmpty() ) m_isEmpty.wakeAll(); }
ULONG RBF_InterruptHandler(UBYTE * data, ULONG length, ULONG unitnum, APTR userdata) { struct ParallelUnit * PU = NULL; ULONG index = 0; D(bug("!Received %d bytes on unit %d (%s)\n",length,unitnum,data)); PU = findUnit(pubParallelBase, unitnum); if (NULL != PU) { if (0 != (PU->pu_Status & STATUS_READS_PENDING)) { struct IOStdReq * ioreq; ioreq = (struct IOStdReq *)PU->pu_ActiveRead; if (NULL == ioreq) { ioreq = (struct IOStdReq *)GetMsg(&PU->pu_QReadCommandPort); PU->pu_ActiveRead = (struct Message *)ioreq; D(bug("Something is wrong!")); } while (NULL != ioreq) { /* ** Copy the remaining data into a request buffer. ** This loop woll possibly execute several times */ UBYTE * destBuf; UWORD indexDestBuf; D(bug("Have a IORequest for Parallel device!\n")); destBuf = ioreq->io_Data; indexDestBuf = ioreq->io_Actual; /* ** I copy as many bytes as I can into this request */ while (index < length) { destBuf[indexDestBuf] = data[index]; index++; indexDestBuf++; D(bug("io_Length %d: io_Actual: %d\n",ioreq->io_Length,indexDestBuf)); if ((-1 == ioreq->io_Length && 0 == destBuf[indexDestBuf-1]) || (indexDestBuf == ioreq->io_Length)) { /* ** this request is done, I answer the message */ ioreq->io_Actual = indexDestBuf; ReplyMsg((struct Message *)ioreq); /* ** Get the next request ... */ ioreq = (struct IOStdReq *)GetMsg(&PU->pu_QReadCommandPort); PU->pu_ActiveRead = (struct Message *)ioreq; break; } } if (index == length && NULL != ioreq) { ioreq->io_Actual = indexDestBuf; break; } } if (NULL == ioreq) PU->pu_Status &= ~STATUS_READS_PENDING; } } /* if (NULL != pu) */ /* ** Simply dropping the incoming data */ return length; }
/* * The write buffer empty interrupt handler */ ULONG WBE_InterruptHandler( ULONG unitnum, APTR userdata) { ULONG total = 0; struct ParallelUnit * PU; PU = findUnit(pubParallelBase, unitnum); if (NULL != PU) { /* * First get any active write */ struct IOExtPar * ioparreq = (struct IOExtPar *)PU->pu_ActiveWrite; while (1) { /* * Try to transmit the active write request */ if (NULL != ioparreq) { ULONG writtenbytes; writtenbytes = HIDD_ParallelUnit_Write(PU->pu_Unit, &((char *)ioparreq->IOPar.io_Data)[PU->pu_NextToWrite], PU->pu_WriteLength); /* * Check whether this was written completely. */ total += writtenbytes; if (writtenbytes >= PU->pu_WriteLength) { /* This one is done */ ReplyMsg(&ioparreq->IOPar.io_Message); } else { /* * Not completed, yet. */ PU->pu_WriteLength -= writtenbytes; PU->pu_NextToWrite += writtenbytes; /* * Get out of the loop */ break; } } /* * Get the next request from the queue. */ ioparreq = (struct IOExtPar *)GetMsg(&PU->pu_QWriteCommandPort); PU->pu_ActiveWrite = (struct Message *)ioparreq; if (NULL == ioparreq) { /* * No more request left. Done. */ PU->pu_Status &= ~STATUS_WRITES_PENDING; break; } /* * There is a new request. */ PU->pu_NextToWrite = 0; if (-1 == ioparreq->IOPar.io_Length) { PU->pu_WriteLength = strlen(ioparreq->IOPar.io_Data); } else { PU->pu_WriteLength = ioparreq->IOPar.io_Length; } /* * And repeat the loop with this request */ } } return total; }
// find the first unit of type belonging to player Id. int cUnitUtils::findUnit(int type, int iPlayerId) { return findUnit(type, iPlayerId, -1); }
void *memReAllocate(const sChar *file, const sU32 line, const allocType type, const sU32 size, void *addr) { allocUnit *au; sU32 hashIndex, oldSize, newRealSize; void *oldAddr, *newRealAddr; FRASSERT(size<MAXALLOC); if (!addr) return memAllocate(file, line, type, size); au=findUnit(addr); if (!au) { fr::debugOut("%s : trying to realloc nonallocated memory\n", formatOwner(file, line)); sourceFile="include_debug_h_everywhere_please.cpp"; sourceLine=303; return 0; } if (type!=au->type) fr::debugOut("%s : allocation and reallocation types mismatch (%s vs %s)\n", formatOwner(file, line), atypes[au->type], atypes[type]); oldSize=au->size; oldAddr=au->addr; newRealSize=calcRealSize(size); newRealAddr=realloc(au->realAddr, newRealSize); stats.curAlloc-=au->size; stats.curRealAlloc-=au->realSize; au->realSize=newRealSize; au->realAddr=newRealAddr; au->size=calcSize(newRealSize); au->addr=calcAddr(newRealAddr); au->type=type; au->line=line; if (file) strncpy(au->file, file, 63); else strcpy(au->file, "???"); hashIndex=0xffffffff; if (oldAddr!=au->addr) { hashIndex=((sU32) oldAddr>>4) & ALLOCHASHMASK; if (allocHash[hashIndex]==au) allocHash[hashIndex]=au->next; else { if (au->prev) au->prev->next=au->next; if (au->next) au->next->prev=au->prev; } hashIndex=((sU32) au->addr>>4) & ALLOCHASHMASK; if (allocHash[hashIndex]) allocHash[hashIndex]->prev=au; au->next=allocHash[hashIndex]; au->prev=0; allocHash[hashIndex]=au; }