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 CUnitHandler::IdleUnitAdd(int unit) { //L("IdleUnitAdd: " << unit); int category = ai->ut->GetCategory(unit); if(category != -1){ const deque<Command>* mycommands = ai->cb->GetCurrentUnitCommands(unit); if(mycommands->empty()){ if(category == CAT_BUILDER) { BuilderTracker* builderTracker = GetBuilderTracker(unit); //L("it was a builder"); // Add clear here ClearOrder(builderTracker, true); if(builderTracker->idleStartFrame == -2) { // It was in the idle list allready ? IdleUnitRemove(builderTracker->builderID); } builderTracker->idleStartFrame = -2; // Its in the idle list now if(builderTracker->commandOrderPushFrame == -2) // Make shure that if the unit was just built it will have some time to leave the factory { builderTracker->commandOrderPushFrame = ai->cb->GetCurrentFrame() + 30*3; } //else if(builderTracker->commandOrderPushFrame == -) // builderTracker->commandOrderPushFrame = ; } integer2 myunit(unit,LIMBOTIME); //L("Adding unit : " << myunit.x << " To Limbo " << myunit.y); Limbo.remove(myunit); //IdleUnitRemove(unit); // This might be a better idea, but its over the edge (possible assertion) Limbo.push_back(myunit); } else { // The unit have orders still if(category == CAT_BUILDER) { BuilderTracker* builderTracker = GetBuilderTracker(unit); assert(false); DecodeOrder(builderTracker, true); } } } }
void CUnitHandler::IdleUnitAdd(int unit, int frame) { UnitCategory category = ai->ut->GetCategory(unit); if (category != CAT_LAST) { const CCommandQueue* myCommands = ai->cb->GetCurrentUnitCommands(unit); if (myCommands->empty()) { if (category == CAT_BUILDER) { BuilderTracker* builderTracker = GetBuilderTracker(unit); // add clear here ClearOrder(builderTracker, true); if (builderTracker->idleStartFrame == -2) { // it was in the idle list already? IdleUnitRemove(builderTracker->builderID); } builderTracker->idleStartFrame = -2; if (builderTracker->commandOrderPushFrame == -2) { // make sure that if the unit was just built // it will have some time to leave the factory builderTracker->commandOrderPushFrame = frame + 30 * 3; } } integer2 myunit(unit, LIMBOTIME); Limbo.remove(myunit); Limbo.push_back(myunit); } else { // the unit has orders still, so should not be idle if (category == CAT_BUILDER) { if (false) { // KLOOTNOTE: somehow we are reaching this branch // on initialization when USE_CREG is not defined, // mycommands->size() returns garbage? // // BuilderTracker* builderTracker = GetBuilderTracker(unit); // DecodeOrder(builderTracker, true); } } } } }
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); } } } } } } }
bool SampleInstrumentTable::key(unsigned long p_unicode, unsigned long p_scan_code,bool p_press,bool p_repeat,int p_modifier_mask) { if (!p_press) return true; KeyBindList kbind=KeyBind::get_bind( p_scan_code|p_modifier_mask ); if (kbind==KB_MAX) return false; bool capture=false; switch (kbind) { case KB_PATTERN_RAISE_NOTES: { for (int i=0;i<Note::NOTES;i++) { if (instrument->get_note_number(i)>=Note::NOTES) continue; int new_note=instrument->get_note_number(i)+1; if (new_note>=Note::NOTES) new_note=Note::EMPTY; instrument->set_note_number(i,new_note); } } break; case KB_PATTERN_LOWER_NOTES: { for (int i=0;i<Note::NOTES;i++) { if (instrument->get_note_number(i)>=Note::NOTES) continue; if (instrument->get_note_number(i)==0) continue; instrument->set_note_number(i,instrument->get_note_number(i)-1); } } break; case KB_CURSOR_WRITE_MASK: { //for (int i=0;i<Note::NOTES;i++) { instrument->set_sample_number(cursor_y,sample_mask); MoveDown(); //} } break; /* case KB_CURSOR_INSERT: { editor->orderlist_insert(); } break; case KB_CURSOR_DELETE: { editor->orderlist_delete(); } break; */ case KB_CURSOR_MOVE_UP: { MoveUp(); capture=true; } break; case KB_CURSOR_MOVE_DOWN: { MoveDown(); capture=true; } break; case KB_CURSOR_MOVE_LEFT: { if (MoveLeft()) capture=true; } break; case KB_CURSOR_MOVE_RIGHT: { if (MoveRight()) capture=true; } break; case KB_CURSOR_PAGE_UP: { PageUp(); capture=true; } break; case KB_CURSOR_PAGE_DOWN: { PageDown(); capture=true; } break; case KB_CURSOR_FIELD_CLEAR: { ClearOrder(); } break; default: { switch (cursor_x) { case 0: { int tmpkey = editor->get_note_from_charcode(kbind); if (tmpkey>=0) { instrument->set_note_number(cursor_y,tmpkey); instrument->set_sample_number(cursor_y,sample_mask); MoveDown(); } } break; case 1: { if ((p_unicode>='0') && (p_unicode<='9')) { int aux_numb=instrument->get_note_number(cursor_y) % 12; instrument->set_note_number(cursor_y,(p_unicode-'0')*12+aux_numb); MoveDown(); } } break; case 2: { if ((p_unicode>='0') && (p_unicode<='9')) { int aux_numb=instrument->get_sample_number(cursor_y); if (aux_numb==Note::EMPTY) aux_numb=0; else aux_numb++; int num_right=aux_numb % 10; aux_numb=(p_unicode-'0')*10+num_right; if (aux_numb==0) aux_numb=Note::EMPTY; else aux_numb--; sample_mask=aux_numb; instrument->set_sample_number(cursor_y,aux_numb); MoveRight(); } } break; case 3: { if ((p_unicode>='0') && (p_unicode<='9')) { int aux_numb=instrument->get_sample_number(cursor_y); int num_left; if (aux_numb==Note::EMPTY) aux_numb=0; else aux_numb++; num_left=aux_numb / 10; aux_numb=num_left*10+(p_unicode-'0'); if (aux_numb==0) aux_numb=Note::EMPTY; else aux_numb--; sample_mask=aux_numb; instrument->set_sample_number(cursor_y,aux_numb); MoveLeft(); MoveDown(); } } break; } } } if (range) range->set(row_offset); update(); return capture; }
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(&); } } * / } */ } }