void UpdateTask::Execute(void)
{
TaskBegin(this);
if(bUpdateApp)
{
int res = CheckForUpdate();
if(!bSilent)
{
if(res == 0)
ThrowMsg(tr("No new updates available"), 0);
else if(res < 0)
ThrowMsg(tr("Error:"), tr("Can't connect to update server"));
}
}
if(bUpdateLang)
UpdateLanguageFiles();
if(bAutoDelete)
Application::Instance()->PushForDelete(this);
}
//=========================================================
// 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 );
}
}
void MoveTask::Execute(void)
{
TaskBegin(this);
// No items to process
if(Process.GetItemcount() == 0)
{
TaskEnd(this);
return;
}
if(ProgressWindow::Instance()->IsRunning())
ProgressWindow::Instance()->SetTitle(tr("Calculating transfer size..."));
else
StartProgress(tr("Calculating transfer size..."));
ProgressWindow::Instance()->SetTitle(this->getTitle().c_str());
string destPathSlash = (destPath.size() > 0 && destPath[destPath.size()-1] != '/') ? destPath + '/' : destPath;
int result = 0;
//! On same device we move files instead of copy them
for(int i = 0; i < Process.GetItemcount(); ++i)
{
if(CompareDevices(Process.GetItemPath(i), destPathSlash.c_str()))
{
string srcpath = Process.GetItemPath(i);
while(srcpath[srcpath.size()-1] == '/')
srcpath.erase(srcpath.size()-1);
const char *pathname = strrchr(srcpath.c_str(), '/');
if(!pathname)
continue;
string dstpath = destPathSlash + (pathname+1);
if(strcasecmp(srcpath.c_str(), dstpath.c_str()) == 0)
{
//! nothing to be done here
Process.RemoveItem(Process.GetItem(i));
i--;
continue;
}
//! moving directory to a path where the same directory name exists
//! we will move all files and remove src directory in the later process
if(Process.IsItemDir(i) && CheckFile(dstpath.c_str()))
continue;
int ret = MoveFile(srcpath.c_str(), dstpath.c_str());
if(ret < 0)
result = ret;
Process.RemoveItem(Process.GetItem(i));
i--;
}
}
list<ItemList> itemList;
if(GetItemList(itemList, true) < 0) {
result = -1;
}
//! free memory of process which is no longer required
Process.Reset();
//! On same device we move files instead of copy them
ProgressWindow::Instance()->SetCompleteValues(0, CopySize);
for(list<ItemList>::iterator listItr = itemList.begin(); listItr != itemList.end(); listItr++)
{
//! first move/remove all files in all sub directories
for(list<string>::iterator itr = listItr->files.begin(); itr != listItr->files.end(); itr++)
{
if(ProgressWindow::Instance()->IsCanceled())
break;
string srcpath = listItr->basepath + *itr;
string dstpath = destPathSlash + *itr;
string folderpath = dstpath;
size_t pos = folderpath.rfind('/');
if(pos != string::npos)
folderpath.erase(pos);
CreateSubfolder(folderpath.c_str());
int ret = MoveFile(srcpath.c_str(), dstpath.c_str());
if(ret < 0)
result = ret;
}
//! Remove all dirs reversed as they were appended to the list
for(list<string>::iterator itr = listItr->dirs.begin(); itr != listItr->dirs.end(); itr++)
{
if(ProgressWindow::Instance()->IsCanceled())
break;
RemoveFile((listItr->basepath + *itr).c_str());
}
if(ProgressWindow::Instance()->IsCanceled())
{
result = PROGRESS_CANCELED;
break;
}
}
if(result < 0 && result != PROGRESS_CANCELED && !Application::isClosing())
{
ThrowMsg(tr("Error:"), tr("Failed moving some item(s)."));
}
TaskEnd(this);
}
void UnpackTask::Execute(void)
{
TaskBegin(this);
// No items to process
if(!archive || (Process.GetItemcount() == 0 && !fullUnpack))
{
TaskEnd(this);
return;
}
if(ProgressWindow::Instance()->IsRunning())
ProgressWindow::Instance()->SetTitle(tr("Calculating extract size..."));
else
StartProgress(tr("Calculating extract size..."));
CopySize = GetUnpackSize();
ProgressWindow::Instance()->SetTitle(this->getTitle().c_str());
ProgressWindow::Instance()->SetCompleteValues(0, CopySize);
string destPathSlash = (destPath.size() > 0 && destPath[destPath.size()-1] != '/') ? destPath + '/' : destPath;
int result = 0;
if(fullUnpack)
{
result = browser->ExtractAll(destPathSlash.c_str());
}
else
{
for(int i = 0; i < Process.GetItemcount(); i++)
{
ArchiveFileStruct * currentItem = archive->GetFileStruct(Process.GetItemIndex(i));
if(currentItem->isdir)
{
int ret = browser->ExtractFolder(currentItem->filename, destPathSlash.c_str());
if(ret < 0)
result = ret;
}
else
{
int ret = archive->ExtractFile(currentItem->fileindex, destPathSlash.c_str(), false);
if(ret < 0)
result = ret;
}
if(ProgressWindow::Instance()->IsCanceled())
{
result = PROGRESS_CANCELED;
break;
}
}
}
if((result < 0) && !Application::isClosing() && result != PROGRESS_CANCELED)
{
ThrowMsg(tr("Error:"), tr("Failed extracting some item(s)."));
}
TaskEnd(this);
}
