//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
void CBaseAnimatingOverlay::SetLayerPriority( int iLayer, int iPriority )
{
if (!IsValidLayer( iLayer ))
{
return;
}
if (m_AnimOverlay[iLayer].m_nPriority == iPriority)
{
return;
}
// look for an open slot and for existing layers that are lower priority
int i;
for (i = 0; i < m_AnimOverlay.Count(); i++)
{
if ( m_AnimOverlay[i].IsActive() )
{
if (m_AnimOverlay[i].m_nOrder > m_AnimOverlay[iLayer].m_nOrder)
{
m_AnimOverlay[i].m_nOrder--;
}
}
}
int iNewOrder = 0;
for (i = 0; i < m_AnimOverlay.Count(); i++)
{
if ( i != iLayer && m_AnimOverlay[i].IsActive() )
{
if (m_AnimOverlay[i].m_nPriority <= iPriority)
{
iNewOrder = MAX( iNewOrder, m_AnimOverlay[i].m_nOrder + 1 );
}
}
}
for (i = 0; i < m_AnimOverlay.Count(); i++)
{
if ( i != iLayer && m_AnimOverlay[i].IsActive() )
{
if ( m_AnimOverlay[i].m_nOrder >= iNewOrder)
{
m_AnimOverlay[i].m_nOrder++;
}
}
}
m_AnimOverlay[iLayer].m_nOrder = iNewOrder;
m_AnimOverlay[iLayer].m_nPriority = iPriority;
m_AnimOverlay[iLayer].MarkActive( );
VerifyOrder();
return;
}
void CUnitHandler::IdleUnitUpdate(int frame) {
list<integer2> limboremoveunits;
for (list<integer2>::iterator i = Limbo.begin(); i != Limbo.end(); i++) {
if (i->y > 0) {
i->y--;
}
else {
if (ai->cb->GetUnitDef(i->x) == NULL) {
// ignore dead unit
} else {
IdleUnits[ai->ut->GetCategory(i->x)].push_back(i->x);
}
limboremoveunits.push_back(*i);
}
}
if (limboremoveunits.size()) {
for (list<integer2>::iterator i = limboremoveunits.begin(); i != limboremoveunits.end(); i++) {
Limbo.remove(*i);
}
}
// make sure that all the builders are in action (hack?)
if (frame % 15 == 0) {
for (list<BuilderTracker*>::iterator i = BuilderTrackers.begin(); i != BuilderTrackers.end(); i++) {
// the new test
if ((*i)->idleStartFrame != -2) {
// the brand new builders must be filtered still
bool ans = VerifyOrder(*i);
const CCommandQueue* mycommands = ai->cb->GetCurrentUnitCommands((*i)->builderID);
Command c;
if (mycommands->size() > 0)
c = mycommands->front();
// two sec delay is ok
if (((*i)->commandOrderPushFrame + LAG_ACCEPTANCE) < frame) {
if (!ans) {
char text[512];
float3 pos = ai->cb->GetUnitPos((*i)->builderID);
sprintf(text, "builder %i VerifyOrder failed ", (*i)->builderID);
ClearOrder(*i, false);
if (!mycommands->empty())
DecodeOrder(*i, true);
else
IdleUnitAdd((*i)->builderID, frame);
}
}
}
}
}
}
void CBaseAnimatingOverlay::FastRemoveLayer( int iLayer )
{
if (!IsValidLayer( iLayer ))
return;
// shift the other layers down in order
for (int j = 0; j < m_AnimOverlay.Count(); j++ )
{
if ((m_AnimOverlay[ j ].IsActive()) && m_AnimOverlay[ j ].m_nOrder > m_AnimOverlay[ iLayer ].m_nOrder)
{
m_AnimOverlay[ j ].m_nOrder--;
}
}
m_AnimOverlay[ iLayer ].Init( this );
VerifyOrder();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CBaseAnimatingOverlay::AllocateLayer( int iPriority )
{
int i;
// look for an open slot and for existing layers that are lower priority
int iNewOrder = 0;
int iOpenLayer = -1;
int iNumOpen = 0;
for (i = 0; i < m_AnimOverlay.Count(); i++)
{
if ( m_AnimOverlay[i].IsActive() )
{
if (m_AnimOverlay[i].m_nPriority <= iPriority)
{
iNewOrder = MAX( iNewOrder, m_AnimOverlay[i].m_nOrder + 1 );
}
}
else if (m_AnimOverlay[ i ].IsDying())
{
// skip
}
else if (iOpenLayer == -1)
{
iOpenLayer = i;
}
else
{
iNumOpen++;
}
}
if (iOpenLayer == -1)
{
if (m_AnimOverlay.Count() >= MAX_OVERLAYS)
{
return -1;
}
iOpenLayer = m_AnimOverlay.AddToTail();
m_AnimOverlay[iOpenLayer].Init( this );
m_AnimOverlay[iOpenLayer].NetworkStateChanged();
}
// make sure there's always an empty unused layer so that history slots will be available on the client when it is used
if (iNumOpen == 0)
{
if (m_AnimOverlay.Count() < MAX_OVERLAYS)
{
i = m_AnimOverlay.AddToTail();
m_AnimOverlay[i].Init( this );
m_AnimOverlay[i].NetworkStateChanged();
}
}
for (i = 0; i < m_AnimOverlay.Count(); i++)
{
if ( m_AnimOverlay[i].m_nOrder >= iNewOrder && m_AnimOverlay[i].m_nOrder < MAX_OVERLAYS)
{
m_AnimOverlay[i].m_nOrder++;
}
}
m_AnimOverlay[iOpenLayer].m_fFlags = ANIM_LAYER_ACTIVE;
m_AnimOverlay[iOpenLayer].m_nOrder = iNewOrder;
m_AnimOverlay[iOpenLayer].m_nPriority = iPriority;
m_AnimOverlay[iOpenLayer].MarkActive();
VerifyOrder();
return iOpenLayer;
}
void CBaseAnimatingOverlay::StudioFrameAdvance ()
{
float flAdvance = GetAnimTimeInterval();
VerifyOrder();
BaseClass::StudioFrameAdvance();
for ( int i = 0; i < m_AnimOverlay.Count(); i++ )
{
CAnimationLayer *pLayer = &m_AnimOverlay[i];
if (pLayer->IsActive())
{
// Assert( !m_AnimOverlay[ i ].IsAbandoned() );
if (pLayer->IsKillMe())
{
if (pLayer->m_flKillDelay > 0)
{
pLayer->m_flKillDelay -= flAdvance;
pLayer->m_flKillDelay = clamp( pLayer->m_flKillDelay, 0.0, 1.0 );
}
else if (pLayer->m_flWeight != 0.0f)
{
// give it at least one frame advance cycle to propagate 0.0 to client
pLayer->m_flWeight -= pLayer->m_flKillRate * flAdvance;
pLayer->m_flWeight = clamp( pLayer->m_flWeight.Get(), 0.0, 1.0 );
}
else
{
// shift the other layers down in order
if (ai_sequence_debug.GetBool() == true && m_debugOverlays & OVERLAY_NPC_SELECTED_BIT)
{
Msg("removing %d (%d): %s : %5.3f (%.3f)\n", i, pLayer->m_nOrder.Get(), GetSequenceName( pLayer->m_nSequence ), pLayer->m_flCycle.Get(), pLayer->m_flWeight.Get() );
}
FastRemoveLayer( i );
// needs at least one thing cycle dead to trigger sequence change
pLayer->Dying();
continue;
}
}
pLayer->StudioFrameAdvance( flAdvance, this );
if ( pLayer->m_bSequenceFinished && (pLayer->IsAutokill()) )
{
pLayer->m_flWeight = 0.0f;
pLayer->KillMe();
}
}
else if (pLayer->IsDying())
{
pLayer->Dead();
}
else if (pLayer->m_flWeight > 0.0)
{
// Now that the server blends, it is turning off layers all the time. Having a weight left over
// when you're no longer marked as active is now harmless and commonplace. Just clean up.
pLayer->Init( this );
pLayer->Dying();
}
}
if (ai_sequence_debug.GetBool() == true && m_debugOverlays & OVERLAY_NPC_SELECTED_BIT)
{
for ( int i = 0; i < m_AnimOverlay.Count(); i++ )
{
if (m_AnimOverlay[ i ].IsActive())
{
/*
if (m_AnimOverlay[ i ].IsAbandoned())
{
Msg(" %d abandoned %.2f (%.2f)\n", i, gpGlobals->curtime, m_AnimOverlay[ i ].m_flLastAccess );
}
*/
Msg(" %d (%d): %s : %5.3f (%.3f)\n", i, m_AnimOverlay[ i ].m_nOrder.Get(), GetSequenceName( m_AnimOverlay[ i ].m_nSequence ), m_AnimOverlay[ i ].m_flCycle.Get(), m_AnimOverlay[ i ].m_flWeight.Get() );
}
}
}
VerifyOrder();
}
void CUnitHandler::IdleUnitUpdate(int frame) {
std::list<integer2> limboremoveunits;
for (std::list<integer2>::iterator i = Limbo.begin(); i != Limbo.end(); i++) {
if (i->y > 0) {
i->y--;
} else {
if (ai->cb->GetUnitDef(i->x) == NULL) {
// ignore dead unit
} else {
IdleUnits[ai->ut->GetCategory(i->x)].push_back(i->x);
}
limboremoveunits.push_back(*i);
}
}
if (limboremoveunits.size()) {
for (std::list<integer2>::iterator i = limboremoveunits.begin(); i != limboremoveunits.end(); i++) {
Limbo.remove(*i);
}
}
// make sure that all the builders are in action (hack?)
if (frame % 15 == 0) {
for (std::list<BuilderTracker*>::iterator i = BuilderTrackers.begin(); i != BuilderTrackers.end(); i++) {
if ((*i)->idleStartFrame != -2) {
// the brand new builders must be filtered still
bool ans = VerifyOrder(*i);
const int builderID = (*i)->builderID;
const CCommandQueue* myCommands = ai->cb->GetCurrentUnitCommands(builderID);
Command c;
if (myCommands->size() > 0) {
c = myCommands->front();
}
// two sec delay is ok
if (((*i)->commandOrderPushFrame + LAG_ACCEPTANCE) < frame) {
if (!ans) {
float3 pos = ai->cb->GetUnitPos(builderID);
std::stringstream msg;
msg << "[CUnitHandler::IdleUnitUpdate()][frame=" << frame << "]\n";
msg << "\tfailed to verify order for builder " << builderID;
msg << " with " << (myCommands->size()) << " remaining commands\n";
ai->GetLogger()->Log(msg.str());
ClearOrder(*i, false);
// due to the Legacy AI Wrapper inner workings,
// the command-queue we fetched above is now invalid,
// because it got changed in ClearOrder()
myCommands = ai->cb->GetCurrentUnitCommands(builderID);
if (!myCommands->empty()) {
DecodeOrder(*i, true);
} else {
IdleUnitAdd(builderID, frame);
}
}
}
}
}
}
}
main (int argc, char * argv[])
{
FILE * File1, * File2 ; // the input file and output file of sorting
long BufferRecords = 0; // number of records in buffer
long error = 0; // error flag
long RecordNum1 = 0; // total record number in file1
long RecordNum2 = 0; // total record number in file2
unsigned long CheckSum1 = 0; // checksum of file1
unsigned long CheckSum2 = 0; // checksum of file2
char LastRecord[RecordSize]; // a copy of the last record in the buffer
bool OrderSign = true; // sign of whether all the records in the file have the desired order
/************************************************************************
* *
* Put out greeting *
* *
************************************************************************/
fprintf(stderr,"ChkSort (%s) - Verify your PennySort result with its checksum and order.", VERSION);
fprintf(stderr,"\n Author: Peng Liu, Tsinghua University, China. [email protected] 12/2002\n");
/*********************************************************************
* *
* Decode parameters *
* *
*********************************************************************/
if (argc != 3)
{ usage(); error = 1; goto common_exit; }
FileName1=argv[1];
FileName2=argv[2];
/************************************************************************/
/* */
/* Allocate file buffer */
/* */
/************************************************************************/
Buffer = (char *)malloc( BufferSize ) ;
if( Buffer == NULL )
{
fprintf(stderr,"\nCouldn't allocate the I/O buffer\n");
error = 1; goto common_exit;
}
/************************************************************************/
/* */
/* Calculate checksum of <filename1> */
/* */
/************************************************************************/
fprintf(stderr,"\nAnalysing file: %s \n", FileName1);
// open <filename1>
File1 = fopen( FileName1, "r+b");
if( File1 == NULL )
{
fprintf(stderr,"\nError opening file %s\n", FileName1) ;
error = 1; goto common_exit;
}
// check whether the record length in <filename1> is exactly 100 bytes long
if (CheckRecordLen(File1, FileName1)==false)
{
error = 1; goto common_exit;
}
// count the total number of records and calculate its checksum
RecordNum1=0;
while ((BufferRecords=ReadToBuffer(File1)) !=0)
{
RecordNum1 += BufferRecords;
CheckSum1 += GetCheckSum(BufferRecords);
}
fclose(File1);
// tell the user about its record number and checksum
fprintf(stderr, "\nRecord Number: %d Checksum: %lX\n",RecordNum1, CheckSum1);
/************************************************************************/
/* */
/* Calculate checksum and check order of <filename2> */
/* */
/************************************************************************/
fprintf(stderr,"\n\nAnalysing file: %s \n", FileName2);
// open <filename2>
File2 = fopen( FileName2, "r+b");
if( File2 == NULL )
{
fprintf(stderr,"\nError opening file %s\n", FileName2) ;
error = 1; goto common_exit;
}
// check whether the record length in <filename2> is exactly 100 bytes long
if (CheckRecordLen(File2, FileName2)==false)
{
error = 1; goto common_exit;
}
// count the number of records and checksum of <filename2>
// and check the order of records in <filename2> one by one
RecordNum2=0;
LastRecord[0]=0;
while ((BufferRecords=ReadToBuffer(File2)) !=0)
{
OrderSign=VerifyOrder(LastRecord, BufferRecords);
// Compare the last record of previous buffer content with the first record of this one
if (!OrderSign)
break;
RecordNum2 += BufferRecords;
CheckSum2 += GetCheckSum(BufferRecords);
}
fclose(File2);
if (!OrderSign) // if the order of the records is not correct
goto common_exit;
// tell the user about its record number and checksum
fprintf(stderr, "\nRecord Number: %d Checksum: %lX\n",RecordNum2, CheckSum2);
/************************************************************************/
/* */
/* Put out result message of comparing checksum and order */
/* */
/************************************************************************/
if (CheckSum1==CheckSum2)
fprintf(stderr, "\n\nCongratulations: Verification Passed!\n");
else
fprintf(stderr, "\n\nBad News: Verification failed due to different checksums \n(although order of records are correct)!\n");
/************************************************************************/
/* */
/* All Done */
/* close output file; and exit */
/* */
/************************************************************************/
common_exit:
free(Buffer); // free record buffer
return(error); // return status code
} // End of ChkSort.cpp
void CUnitHandler::IdleUnitUpdate() {
// std::cout << "CUnitHandler::IdleUnitUpdate()" << std::endl;
list<integer2> limboremoveunits;
for(list<integer2>::iterator i = Limbo.begin(); i != Limbo.end(); i++){
if(i->y > 0){
i->y = i->y - 1;
}
else{
//L("adding unit to idle units: " << i->x);
if(ai->cb->GetUnitDef(i->x) == NULL)
{
//L(" Removeing dead unit... ");
}
else
IdleUnits[ai->ut->GetCategory(i->x)]->push_back(i->x);
if(ai->ut->GetCategory(i->x) == CAT_BUILDER)
{
//GetBuilderTracker(i->x)->idleStartFrame = -1; // Its ok now, stop the force idle (hack)
}
limboremoveunits.push_back(*i);
}
}
if(limboremoveunits.size()){
for(list<integer2>::iterator i = limboremoveunits.begin(); i != limboremoveunits.end(); i++){
Limbo.remove(*i);
}
}
// Make shure that all the builders are in action: (hack ?)
if(ai->cb->GetCurrentFrame() % 15 == 0)
for(list<BuilderTracker*>::iterator i = BuilderTrackers.begin(); i != BuilderTrackers.end(); i++){
// The new test:
if((*i)->idleStartFrame != -2) // The brand new builders must be filtered still
{
//L("VerifyOrder");
bool ans = VerifyOrder(*i);
const deque<Command>* mycommands = ai->cb->GetCurrentUnitCommands((*i)->builderID);
Command c;
if(mycommands->size() > 0)
c = mycommands->front();
// Two sec delay is ok
if(( (*i)->commandOrderPushFrame + LAG_ACCEPTANCE) < ai->cb->GetCurrentFrame())
{
//assert(ans);
if(!ans)
{
char text[512];
float3 pos = ai->cb->GetUnitPos((*i)->builderID);
sprintf(text, "builder %i VerifyOrder failed ", (*i)->builderID);
AIHCAddMapPoint amp;
amp.label = text;
amp.pos = pos;
////ai->cb->HandleCommand(&);
ClearOrder(*i, false);
if(!mycommands->empty())
DecodeOrder(*i, true);
else // Its idle
IdleUnitAdd((*i)->builderID);
}
}
}
/*
if((*i)->buildTaskId == 0 && (*i)->taskPlanId == 0 && (*i)->factoryId == 0 && (*i)->customOrderId == 0 && (*i)->idleStartFrame != -2)
{
// Its without tasks and not in the idle list
if((*i)->idleStartFrame == -1)
{
(*i)->idleStartFrame = ai->cb->GetCurrentFrame();
}
else
{
if(((*i)->idleStartFrame + 90) < ai->cb->GetCurrentFrame())
{
//L("Idle unit command force: " << (*i)->builderID);
char text[512];
float3 pos = ai->cb->GetUnitPos((*i)->builderID);
sprintf(text, "builder %i without tasks and not in the idle list (idle forced)", (*i)->builderID);
AIHCAddMapPoint amp;
amp.label = text;
amp.pos = pos;
////ai->cb->HandleCommand(&);
IdleUnitAdd((*i)->builderID);
(*i)->idleStartFrame = ai->cb->GetCurrentFrame(); // Just to cut down on the spam, if its not idle
}
}
} else if((*i)->idleStartFrame != -2) // This will only be ok if idleStartFrame is changed to -1 on unit UnitFinished
{
*/
/*
//L("VerifyOrder");
bool ans = VerifyOrder(*i);
const deque<Command>* mycommands = ai->cb->GetCurrentUnitCommands((*i)->builderID);
Command c;
if(mycommands->size() > 0)
c = mycommands->front();
// Two sec delay is ok
if(( (*i)->commandOrderPushFrame + 30 * 2) < ai->cb->GetCurrentFrame())
{
//assert(ans);
if(!ans)
{
char text[512];
float3 pos = ai->cb->GetUnitPos((*i)->builderID);
sprintf(text, "builder %i VerifyOrder failed ", (*i)->builderID);
AIHCAddMapPoint amp;
amp.label = text;
amp.pos = pos;
////ai->cb->HandleCommand(&);
}
}
* /
}
*/
}
}
