bool
ScheduleAccount::CleanUp()
{
boost::lock_guard<boost::mutex> lock(mutex_);
for ( ScheduleMap::iterator i = scheduleMap_.begin();
i != scheduleMap_.end();
++ i ) {
string proc = "/proc/";
proc += boost::lexical_cast<string>(i->first);
struct stat stat;
if ( 0 == ::stat(proc.c_str(),&stat) ) {
continue;
}
LogError("Cleanup the schedule resources for process "
<< i->first);
for ( vector<string>::iterator iter = i->second.begin();
iter != i->second.end();
++ iter ) {
LogError("Cleanup the schedule resource " << *iter);
string tape;
bool share;
GetSchedule(*iter,tape,share);
schedule_->ReleaseTape(tape,share);
}
scheduleMap_.erase(i);
return true;
}
return false;
}
void AddEmployeeTransaction::Execute() {
PaymentClassification* pc = GetClassification();
PaymentSchedule* ps = GetSchedule();
PaymentMethod* pm = new HoldMethod();
Employee* e = new Employee(itsEmpid, itsName, itsAddress);
e->SetClassification(pc);
e->SetSchedule(ps);
e->SetMethod(pm);
GPayrollDatabase.AddEmployee(itsEmpid, e);
}
cSchedule *cSchedules::AddSchedule(tChannelID ChannelID)
{
ChannelID.ClrRid();
cSchedule *p = (cSchedule *)GetSchedule(ChannelID);
if (!p) {
p = new cSchedule(ChannelID);
Add(p);
}
return p;
}
// Find up to num aircraft which are free from cycle sb to fb. Returns # actually found
int SquadronClass::FindAvailableAircraft (MissionRequest mis)
{
int cb,i,got=0,snum=0,tav,ls;
uchar free[VEHICLES_PER_UNIT] = {0};
if (mis->start_block >= ATM_MAX_CYCLES)
return 0;
if (mis->flags & REQF_USERESERVES)
tav = GetTotalVehicles(); // Use any available aircraft
else if (FloatToInt32(GetTotalVehicles() * g_npercentage_available_aircraft/100) > g_nminimum_available_aircraft)
tav = FloatToInt32(GetTotalVehicles() * g_npercentage_available_aircraft/100); // Save 1/4 as reserve
else tav = g_nminimum_available_aircraft; // JPO fixup.
// Mark our last allowed slot (so we don't assign reserve aircraft
for (i=0;i<VEHICLES_PER_UNIT && tav>0; i++)
tav -= GetNumVehicles(i);
ls = i;
memset(free,1,ls);
// find all free slots
for (cb=mis->start_block; cb<=mis->final_block; cb++)
{
for (i=0;i<ls; i++)
{
if (GetSchedule(i) & (1 << cb))
free[i] = 0;
}
}
// now collect the rest of our aircraft (regardless of match)
for (i=0; i<ls && got < mis->aircraft; i++)
{
if (free[i] && GetNumVehicles(i))
{
mis->slots[snum] = i;
got += GetNumVehicles(i);
snum++;
}
}
#ifdef DEBUG
for (i=0; i<PILOTS_PER_FLIGHT; i++)
{
for (ls=0; ls<PILOTS_PER_FLIGHT; ls++)
{
ShiAssert (i == ls || mis->slots[i] == 255 || mis->slots[ls] != mis->slots[i]);
}
}
ShiAssert (!got || mis->slots[0] != 255);
#endif
return got;
}
cSchedule *cSchedules::AddSchedule(tChannelID ChannelID)
{
ChannelID.ClrRid();
cSchedule *p = (cSchedule *)GetSchedule(ChannelID);
if (!p) {
p = new cSchedule(ChannelID);
Add(p);
cChannel *channel = Channels.GetByChannelID(ChannelID);
if (channel)
channel->schedule = p;
}
return p;
}
const cSchedule *cSchedules::GetSchedule(const cChannel *Channel, bool AddIfMissing) const
{
// This is not very beautiful, but it dramatically speeds up the
// "What's on now/next?" menus.
static cSchedule DummySchedule(tChannelID::InvalidID);
if (!Channel->schedule)
Channel->schedule = GetSchedule(Channel->GetChannelID());
if (!Channel->schedule)
Channel->schedule = &DummySchedule;
if (Channel->schedule == &DummySchedule && AddIfMissing) {
cSchedule *Schedule = new cSchedule(Channel->GetChannelID());
((cSchedules *)this)->Add(Schedule);
Channel->schedule = Schedule;
}
return Channel->schedule != &DummySchedule? Channel->schedule : NULL;
}
// ==> Advanced Updates [MorphXT/Stulle] - Stulle
bool CScheduler::HasWeekly(int par_action)
{
if (theApp.scheduler->GetCount()==0) return false;
Schedule_Struct* curschedule;
for (uint8 si=0;si< theApp.scheduler->GetCount();si++) {
curschedule= GetSchedule(si);
if (curschedule->actions[0]==0 || !curschedule->enabled) continue;
if (curschedule->day!=DAY_DAYLY) { // not daily, so must be weekly ( or montly, good also)
for (int ai=0;ai<16;ai++) {
if (curschedule->actions[ai]==par_action)
return true;
}
}
}
// not found? then schedule does not exit.
return false;
}
void CScheduler::ActivateSchedule(int index,bool makedefault) {
Schedule_Struct* schedule=GetSchedule(index);
for (int ai=0;ai<16;ai++) {
if (schedule->actions[ai]==0) break;
if (schedule->values[ai]==_T("") /* maybe ignore in some future cases...*/ ) continue;
switch (schedule->actions[ai]) {
case 1 :
thePrefs.SetMaxUpload(_tstoi(schedule->values[ai]));
if (makedefault)
original_upload=(uint16)_tstoi(schedule->values[ai]);
break;
case 2 :
thePrefs.SetMaxDownload(_tstoi(schedule->values[ai]));
if (makedefault)
original_download=(uint16)_tstoi(schedule->values[ai]);
break;
case 3 :
thePrefs.SetMaxSourcesPerFile(_tstoi(schedule->values[ai]));
if (makedefault)
original_sources=_tstoi(schedule->values[ai]);
break;
case 4 :
thePrefs.SetMaxConsPerFive(_tstoi(schedule->values[ai]));
if (makedefault)
original_cons5s=_tstoi(schedule->values[ai]);
break;
case 5 :
thePrefs.SetMaxConnections(_tstoi(schedule->values[ai]));
if (makedefault)
original_connections=_tstoi(schedule->values[ai]);
break;
case 6 :
theApp.downloadqueue->SetCatStatus(_tstoi(schedule->values[ai]),MP_STOP);
break;
case 7 :
theApp.downloadqueue->SetCatStatus(_tstoi(schedule->values[ai]),MP_RESUME);
break;
}
}
}
void CScheduler::SetWeekly(int action,bool activate)
{
bool Currentactivated = HasWeekly(action);
if ( Currentactivated == activate)
return; // nothing to do.
if ( ( Currentactivated == false )&& (activate == true)) { // must we insert a new?
Schedule_Struct* newschedule=new Schedule_Struct();
struct tm tmTemp;
CTime tNow = CTime(safe_mktime(CTime::GetCurrentTime().GetLocalTm(&tmTemp)));
newschedule->day=tNow.GetDayOfWeek();
newschedule->enabled=true;
newschedule->time=time(NULL);
newschedule->time2=time(NULL);
newschedule->title=GetResString(IDS_SCHEDTEXT);
newschedule->ResetActions();
newschedule->actions[0]=action;
newschedule->values[0]=L"update";
AddSchedule(newschedule);
thePrefs.scheduler=true; // enable scheduler
}
if ((Currentactivated == true )&& (activate == false)) { // we must delete
Schedule_Struct* curschedule;
for (uint8 si=0;si< GetCount();si++) {
curschedule= GetSchedule(si);
if (curschedule->actions[0]==0 || !curschedule->enabled) continue;
if (curschedule->day!=DAY_DAYLY) { // not daily, so must be weekly ( or montly, good also)
for (int ai=0;ai<16;ai++) {
if (curschedule->actions[ai]==action) {
RemoveSchedule(si);
return ;
}
}
}
}
// not found? then schedule does not exist. ASSERT()?;
return ;
}
};
void CScheduler::ActivateSchedule(uint8 index,bool makedefault) {
Schedule_Struct* schedule=GetSchedule(index);
for (uint8 ai=0;ai<16;ai++) {
if (schedule->actions[ai]==0) break;
if (schedule->values[ai]=="" /* maybe ignore in some future cases...*/ ) continue;
switch (schedule->actions[ai]) {
//==> Maella [FAF] -Allow Bandwidth Settings in <1KB Incremements-
#ifdef FAF
case 1 : thePrefs.SetMaxUpload(_tstof(schedule->values[ai]));
if (makedefault) original_upload=_tstof(schedule->values[ai]);
break;
case 2 : thePrefs.SetMaxDownload(_tstof(schedule->values[ai]));
if (makedefault) original_download=_tstof(schedule->values[ai]);
break;
#else
case 1 : thePrefs.SetMaxUpload(_tstoi(schedule->values[ai]));
if (makedefault) original_upload=_tstoi(schedule->values[ai]);
break;
case 2 : thePrefs.SetMaxDownload(_tstoi(schedule->values[ai]));
if (makedefault) original_download=_tstoi(schedule->values[ai]);
break;
#endif
//<== Maella [FAF] -Allow Bandwidth Settings in <1KB Incremements-
case 3 : thePrefs.SetMaxSourcesPerFile(_tstoi(schedule->values[ai]));
if (makedefault) original_sources=_tstoi(schedule->values[ai]);
break;
case 4 : thePrefs.SetMaxConsPerFive(_tstoi(schedule->values[ai]));
if (makedefault) original_cons5s=_tstoi(schedule->values[ai]);
break;
case 5 : thePrefs.SetMaxConnections(_tstoi(schedule->values[ai]));
if (makedefault) original_connections=_tstoi(schedule->values[ai]);
break;
case 6 : theApp.downloadqueue->SetCatStatus(_tstoi(schedule->values[ai]),MP_STOP);break;
case 7 : theApp.downloadqueue->SetCatStatus(_tstoi(schedule->values[ai]),MP_RESUME);break;
}
}
}
//=========================================================
// MaintainSchedule - does all the per-think schedule maintenance.
// ensures that the monster leaves this function with a valid
// schedule!
//=========================================================
void CBaseMonster :: MaintainSchedule ( void )
{
Schedule_t *pNewSchedule;
int i;
// UNDONE: Tune/fix this 10... This is just here so infinite loops are impossible
for ( i = 0; i < 10; i++ )
{
if ( m_pSchedule != NULL && TaskIsComplete() )
{
NextScheduledTask();
}
// validate existing schedule
if ( !FScheduleValid() || m_MonsterState != m_IdealMonsterState )
{
// if we come into this block of code, the schedule is going to have to be changed.
// if the previous schedule was interrupted by a condition, GetIdealState will be
// called. Else, a schedule finished normally.
// Notify the monster that his schedule is changing
ScheduleChange();
// Call GetIdealState if we're not dead and one or more of the following...
// - in COMBAT state with no enemy (it died?)
// - conditions bits (excluding SCHEDULE_DONE) indicate interruption,
// - schedule is done but schedule indicates it wants GetIdealState called
// after successful completion (by setting bits_COND_SCHEDULE_DONE in iInterruptMask)
// DEAD & SCRIPT are not suggestions, they are commands!
if ( m_IdealMonsterState != MONSTERSTATE_DEAD &&
(m_IdealMonsterState != MONSTERSTATE_SCRIPT || m_IdealMonsterState == m_MonsterState) )
{
// if we're here, then either we're being told to do something (besides dying or playing a script)
// or our current schedule (besides dying) is invalid. -- LRC
if ( (m_afConditions && !HasConditions(bits_COND_SCHEDULE_DONE)) ||
(m_pSchedule && (m_pSchedule->iInterruptMask & bits_COND_SCHEDULE_DONE)) ||
((m_MonsterState == MONSTERSTATE_COMBAT) && (m_hEnemy == NULL)) )
{
GetIdealState();
}
}
if ( HasConditions( bits_COND_TASK_FAILED ) && m_MonsterState == m_IdealMonsterState )
{
if ( m_failSchedule != SCHED_NONE )
pNewSchedule = GetScheduleOfType( m_failSchedule );
else
pNewSchedule = GetScheduleOfType( SCHED_FAIL );
// schedule was invalid because the current task failed to start or complete
ALERT ( at_aiconsole, "Schedule Failed at %d!\n", m_iScheduleIndex );
ChangeSchedule( pNewSchedule );
}
else
{
SetState( m_IdealMonsterState );
if ( m_MonsterState == MONSTERSTATE_SCRIPT || m_MonsterState == MONSTERSTATE_DEAD )
{
pNewSchedule = CBaseMonster::GetSchedule();
}
else
pNewSchedule = GetSchedule();
ChangeSchedule( pNewSchedule );
}
}
if ( m_iTaskStatus == TASKSTATUS_NEW )
{
Task_t *pTask = GetTask();
ASSERT( pTask != NULL );
TaskBegin();
StartTask( pTask );
}
// UNDONE: Twice?!!!
if ( m_Activity != m_IdealActivity )
{
SetActivity ( m_IdealActivity );
}
if ( !TaskIsComplete() && m_iTaskStatus != TASKSTATUS_NEW )
break;
}
if ( TaskIsRunning() )
{
Task_t *pTask = GetTask();
ASSERT( pTask != NULL );
RunTask( pTask );
}
// UNDONE: We have to do this so that we have an animation set to blend to if RunTask changes the animation
// RunTask() will always change animations at the end of a script!
// Don't do this twice
if ( m_Activity != m_IdealActivity )
{
SetActivity ( m_IdealActivity );
}
}
//=========================================================
// GetSchedule - Decides which type of schedule best suits
// the monster's current state and conditions. Then calls
// monster's member function to get a pointer to a schedule
// of the proper type.
//=========================================================
Schedule_t *CBaseMonster :: GetSchedule ( void )
{
switch ( m_MonsterState )
{
case MONSTERSTATE_PRONE:
{
return GetScheduleOfType( SCHED_BARNACLE_VICTIM_GRAB );
break;
}
case MONSTERSTATE_NONE:
{
ALERT ( at_aiconsole, "MONSTERSTATE IS NONE!\n" );
break;
}
case MONSTERSTATE_IDLE:
{
if ( HasConditions ( bits_COND_HEAR_SOUND ) )
{
return GetScheduleOfType( SCHED_ALERT_FACE );
}
else if ( FRouteClear() )
{
// no valid route!
return GetScheduleOfType( SCHED_IDLE_STAND );
}
else
{
// valid route. Get moving
return GetScheduleOfType( SCHED_IDLE_WALK );
}
break;
}
case MONSTERSTATE_ALERT:
{
if ( HasConditions( bits_COND_ENEMY_DEAD ) && LookupActivity( ACT_VICTORY_DANCE ) != ACTIVITY_NOT_AVAILABLE )
{
return GetScheduleOfType ( SCHED_VICTORY_DANCE );
}
if ( HasConditions(bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE) )
{
if ( fabs( FlYawDiff() ) < (1.0 - m_flFieldOfView) * 60 ) // roughly in the correct direction
{
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ORIGIN );
}
else
{
return GetScheduleOfType( SCHED_ALERT_SMALL_FLINCH );
}
}
else if ( HasConditions ( bits_COND_HEAR_SOUND ) )
{
return GetScheduleOfType( SCHED_ALERT_FACE );
}
else
{
return GetScheduleOfType( SCHED_ALERT_STAND );
}
break;
}
case MONSTERSTATE_COMBAT:
{
if ( HasConditions( bits_COND_ENEMY_DEAD ) )
{
// clear the current (dead) enemy and try to find another.
m_hEnemy = NULL;
if ( GetEnemy() )
{
ClearConditions( bits_COND_ENEMY_DEAD );
return GetSchedule();
}
else
{
SetState( MONSTERSTATE_ALERT );
return GetSchedule();
}
}
if ( HasConditions(bits_COND_NEW_ENEMY) )
{
return GetScheduleOfType ( SCHED_WAKE_ANGRY );
}
else if (HasConditions(bits_COND_LIGHT_DAMAGE) && !HasMemory( bits_MEMORY_FLINCHED) )
{
return GetScheduleOfType( SCHED_SMALL_FLINCH );
}
else if ( !HasConditions(bits_COND_SEE_ENEMY) )
{
// we can't see the enemy
if ( !HasConditions(bits_COND_ENEMY_OCCLUDED) )
{
// enemy is unseen, but not occluded!
// turn to face enemy
return GetScheduleOfType( SCHED_COMBAT_FACE );
}
else
{
// chase!
return GetScheduleOfType( SCHED_CHASE_ENEMY );
}
}
else
{
// we can see the enemy
if ( HasConditions(bits_COND_CAN_RANGE_ATTACK1) )
{
return GetScheduleOfType( SCHED_RANGE_ATTACK1 );
}
if ( HasConditions(bits_COND_CAN_RANGE_ATTACK2) )
{
return GetScheduleOfType( SCHED_RANGE_ATTACK2 );
}
if ( HasConditions(bits_COND_CAN_MELEE_ATTACK1) )
{
return GetScheduleOfType( SCHED_MELEE_ATTACK1 );
}
if ( HasConditions(bits_COND_CAN_MELEE_ATTACK2) )
{
return GetScheduleOfType( SCHED_MELEE_ATTACK2 );
}
if ( !HasConditions(bits_COND_CAN_RANGE_ATTACK1 | bits_COND_CAN_MELEE_ATTACK1) )
{
// if we can see enemy but can't use either attack type, we must need to get closer to enemy
return GetScheduleOfType( SCHED_CHASE_ENEMY );
}
else if ( !FacingIdeal() )
{
//turn
return GetScheduleOfType( SCHED_COMBAT_FACE );
}
else
{
ALERT ( at_aiconsole, "No suitable combat schedule!\n" );
}
}
break;
}
case MONSTERSTATE_DEAD:
{
return GetScheduleOfType( SCHED_DIE );
break;
}
case MONSTERSTATE_SCRIPT:
{
ASSERT( m_pCine != NULL );
if ( !m_pCine )
{
ALERT( at_aiconsole, "Script failed for %s\n", STRING(pev->classname) );
// ALERT( at_console, "Script failed for %s\n", STRING(pev->classname) );
CineCleanup();
return GetScheduleOfType( SCHED_IDLE_STAND );
}
return GetScheduleOfType( SCHED_AISCRIPT );
}
default:
{
ALERT ( at_aiconsole, "Invalid State for GetSchedule!\n" );
break;
}
}
return &slError[ 0 ];
}
int MovingTrain::move(ElapsedTime currentTime,bool bNoLog)
{
PLACE_METHOD_TRACK_STRING();
switch(state)
{
case Birth:
{
InitTrain();
state = TrainFreeMoving;
generateEvent(currentTime,false);
}
break;
case TrainFreeMoving:
{
if (m_iPreState == Birth)
{
GetSchedule(currentTime);
}
else
{
GetSchedule(currentTime - m_TrainLogEntry.GetTurnAroundTime());
}
int nCount = m_movePath.size();
double dPrevHeading = 0.0;
for( int i=0; i<nCount; i++ )
{
CViehcleMovePath movePath = m_movePath[i];
int nPathCount = movePath.GetCount();
float fPrevHeading;
for( int z=0; z<nPathCount; z++ )
{
CStateTimePoint timePt = movePath.GetItem( z );
TrainEventStruct event;
ElapsedTime t;
event.time = timePt.GetTime();
t.setPrecisely(event.time);
if (currentTime < t)
{
currentTime = t;
}
event.x = (float)timePt.getX();
event.y = (float)timePt.getY();
event.z = (short)timePt.getZ();
if( z < nPathCount - 1 )
{
CStateTimePoint nextTimePt = movePath.GetItem( z+1 );
double dNewHeading = ( nextTimePt - timePt ).getHeading();
event.heading = (float)dNewHeading;
fPrevHeading = event.heading;
}
else
{
event.heading = fPrevHeading;
}
event.state = timePt.GetState();
m_TrainLogEntry.addEvent( event );
}
}
ElapsedTime delayTime;
delayTime.setPrecisely(01l);
generateEvent(currentTime - delayTime,false);//notify passenger train arrival
m_iPreState = state;
state = TrainArriveAtStation;
}
break;
case TrainArriveAtStation:
{
if (m_nFlowIndex + 1 == (int)m_TrainFlow.size())
{
m_nFlowIndex = 0;
}
m_nFlowIndex++;
IntegratedStation* pSourceStation = GetSourceStation(m_nFlowIndex);
pSourceStation->SetTrain(this);
ElapsedTime delayTime;
delayTime.setPrecisely(01l);
generateEvent(currentTime + delayTime,false);//for correct time to leave
state = TrainWaitForLeave;
}
break;
case TrainWaitForLeave:
{
currentTime += m_TrainLogEntry.GetTurnAroundTime();
generateEvent(currentTime,false);
m_iPreState = state;
state = TrainLeaveStation;
}
break;
case TrainLeaveStation:
{
if (m_TrainLogEntry.GetEndTime() < currentTime)
{
generateEvent(currentTime,false);
state = Death;
}
else
{
generateEvent(currentTime,false);
m_iPreState = state;
state = TrainFreeMoving;
}
IntegratedStation* pSourceStation = GetSourceStation(m_nFlowIndex);
pSourceStation->ClearStationTrain(this);
ClearThisStationPerson(pSourceStation);
}
break;
case Death:
{
FlushLog();
}
break;
default:
break;
}
return TRUE;
}
void CScheduler::ActivateSchedule(int index,bool makedefault) {
Schedule_Struct* schedule=GetSchedule(index);
for (int ai=0;ai<16;ai++) {
if (schedule->actions[ai]==0) break;
if (schedule->values[ai]==_T("") /* maybe ignore in some future cases...*/ ) continue;
switch (schedule->actions[ai]) {
case 1 :
//Xman
// Maella [FAF] -Allow Bandwidth Settings in <1KB Incremements-
/*
thePrefs.SetMaxUpload(_tstoi(schedule->values[ai]));
if (makedefault)
original_upload=(uint16)_tstoi(schedule->values[ai]);
break;
case 2 :
thePrefs.SetMaxDownload(_tstoi(schedule->values[ai]));
if (makedefault)
original_download=(uint16)_tstoi(schedule->values[ai]);
*/
thePrefs.SetMaxUpload((float)_tstof(schedule->values[ai]));
thePrefs.CheckSlotSpeed(); //Xman Xtreme Upload
if (makedefault)
original_upload=(float)_tstof(schedule->values[ai]);
break;
case 2 :
thePrefs.SetMaxDownload((float)_tstof(schedule->values[ai]));
if (makedefault)
original_download=(float)_tstof(schedule->values[ai]);
//Xman end
break;
case 3 :
thePrefs.SetMaxSourcesPerFile(_tstoi(schedule->values[ai]));
if (makedefault)
original_sources=_tstoi(schedule->values[ai]);
break;
case 4 :
thePrefs.SetMaxConsPerFive(_tstoi(schedule->values[ai]));
if (makedefault)
original_cons5s=_tstoi(schedule->values[ai]);
break;
case 5 :
thePrefs.SetMaxConnections(_tstoi(schedule->values[ai]));
if (makedefault)
original_connections=_tstoi(schedule->values[ai]);
break;
case 6 :
theApp.downloadqueue->SetCatStatus(_tstoi(schedule->values[ai]),MP_STOP);
break;
case 7 :
theApp.downloadqueue->SetCatStatus(_tstoi(schedule->values[ai]),MP_RESUME);
break;
// ==> Advanced Updates [MorphXT/Stulle] - Stulle
case ACTION_UPDIPCONF : {
AddLogLine (false,GetResString (IDS_SCHED_UPDATE_IPCONFIG_LOG));
theApp.emuledlg->CheckIPFilter();
} break;
case ACTION_UPDANTILEECH : {
AddLogLine (false,GetResString (IDS_SCHED_UPDATE_ANTILEECH_LOG));
theApp.emuledlg->DoDLPVersioncheck();
} break;
// <== Advanced Updates [MorphXT/Stulle] - Stulle
}
}
}
void ChangeClassificationTransaction::Change(Employee& e)
{
e.SetClassification(GetClassification());
e.SetSchedule(GetSchedule());
}
