void Updater::run() {
connect(ai, SIGNAL(startUpdate(QList<FileUpdate>)), this, SLOT(startUpdate(QList<FileUpdate>)));
connect(dm, SIGNAL(downloadsFinished(QList<FileUpdate>)), this, SLOT(downloadFinished(QList<FileUpdate>)));
connect(ai, SIGNAL(applicationClosed(bool)), this, SLOT(startExchange(bool)));
connect(ai, SIGNAL(executableChanged(QString)), this, SLOT(setExecutable(QString)));
connect(fh, SIGNAL(exchangingFinished(bool)), this, SLOT(exchangeFinished(bool)));
connect(dm, SIGNAL(error(QString)), ai, SLOT(sendError(QString)));
connect(fh, SIGNAL(error(QString)), ai, SLOT(sendError(QString)));
connect(ai, SIGNAL(close()), this, SLOT(closeRequested()));
}
void AssetsManager::update()
{
if (!_localManifest->isLoaded())
{
CCLOG("AssetsManager : No local manifest file found error.\n");
dispatchUpdateEvent(EventAssetsManager::EventCode::ERROR_NO_LOCAL_MANIFEST);
return;
}
_waitToUpdate = true;
switch (_updateState) {
case State::UNCHECKED:
{
_updateState = State::PREDOWNLOAD_VERSION;
}
case State::PREDOWNLOAD_VERSION:
{
downloadVersion();
}
break;
case State::VERSION_LOADED:
{
parseVersion();
}
break;
case State::PREDOWNLOAD_MANIFEST:
{
downloadManifest();
}
break;
case State::MANIFEST_LOADED:
{
parseManifest();
}
break;
case State::FAIL_TO_UPDATE:
case State::NEED_UPDATE:
{
// Manifest not loaded yet
if (!_remoteManifest->isLoaded())
{
_waitToUpdate = true;
_updateState = State::PREDOWNLOAD_MANIFEST;
downloadManifest();
}
else
{
startUpdate();
}
}
break;
case State::UP_TO_DATE:
case State::UPDATING:
_waitToUpdate = false;
break;
default:
break;
}
}
void AssetsManager::parseManifest()
{
if (_updateState != State::MANIFEST_LOADED)
return;
_remoteManifest->parse(_tempManifestPath);
if (!_remoteManifest->isLoaded())
{
CCLOG("AssetsManager : Error parsing manifest file\n");
dispatchUpdateEvent(EventAssetsManager::EventCode::ERROR_PARSE_MANIFEST);
_updateState = State::UNCHECKED;
}
else
{
if (_localManifest->versionEquals(_remoteManifest))
{
_updateState = State::UP_TO_DATE;
dispatchUpdateEvent(EventAssetsManager::EventCode::ALREADY_UP_TO_DATE);
}
else
{
_updateState = State::NEED_UPDATE;
dispatchUpdateEvent(EventAssetsManager::EventCode::NEW_VERSION_FOUND);
if (_waitToUpdate)
{
startUpdate();
}
}
}
}
void AssetsManagerEx::parseManifest()
{
if (_updateState != State::MANIFEST_LOADED)
return;
_remoteManifest->parse(_tempManifestPath);
if (!_remoteManifest->isLoaded())
{
CCLOG("AssetsManagerEx : Error parsing manifest file, %s", _tempManifestPath.c_str());
dispatchUpdateEvent(EventAssetsManagerEx::EventCode::ERROR_PARSE_MANIFEST);
_updateState = State::UNCHECKED;
}
else
{
if (_localManifest->versionGreater(_remoteManifest, _versionCompareHandle))
{
_updateState = State::UP_TO_DATE;
_fileUtils->removeDirectory(_tempStoragePath);
dispatchUpdateEvent(EventAssetsManagerEx::EventCode::ALREADY_UP_TO_DATE);
}
else
{
_updateState = State::NEED_UPDATE;
dispatchUpdateEvent(EventAssetsManagerEx::EventCode::NEW_VERSION_FOUND);
if (_updateEntry == UpdateEntry::DO_UPDATE)
{
startUpdate();
}
}
}
}
UpdateWindow::UpdateWindow(const QString &version, QWidget *parent) :
QWidget(parent),
mProgressBar(0),
mLabel(0),
mCancelButton(0),
mCurrentVersion(version),
mCurrentWork(WT_UPDATELIST),
mUpdateDownloader(0)
{
QVBoxLayout *vlayout = new QVBoxLayout(this);
QHBoxLayout *hlayout = new QHBoxLayout(this);
mLabel = new QLabel(tr("Stage"), this);
mProgressBar = new QProgressBar(this);
mCancelButton = new QPushButton(tr("Cancel"), this);
mCancelButton->setEnabled(false);
hlayout->addWidget(mProgressBar);
hlayout->addWidget(mCancelButton);
connect(mCancelButton, SIGNAL(clicked()), this, SLOT(workCanceled()));
vlayout->addWidget(mLabel);
vlayout->addLayout(hlayout);
setLayout(vlayout);
startUpdate();
}
void AvatarManager::updateOtherAvatars(float deltaTime) {
if (_avatarHash.size() < 2 && _avatarFades.isEmpty()) {
return;
}
bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
PerformanceWarning warn(showWarnings, "Application::updateAvatars()");
PerformanceTimer perfTimer("otherAvatars");
// simulate avatars
AvatarHash::iterator avatarIterator = _avatarHash.begin();
while (avatarIterator != _avatarHash.end()) {
auto avatar = std::dynamic_pointer_cast<Avatar>(avatarIterator.value());
if (avatar == _myAvatar || !avatar->isInitialized()) {
// DO NOT update _myAvatar! Its update has already been done earlier in the main loop.
// DO NOT update or fade out uninitialized Avatars
++avatarIterator;
} else if (avatar->shouldDie()) {
removeAvatarMotionState(avatar);
_avatarFades.push_back(avatarIterator.value());
avatarIterator = _avatarHash.erase(avatarIterator);
} else {
avatar->startUpdate();
avatar->simulate(deltaTime);
avatar->endUpdate();
++avatarIterator;
}
}
// simulate avatar fades
simulateAvatarFades(deltaTime);
}
void VisualizationManager::updateFps()
{
if ( update_timer_->isActive() )
{
startUpdate();
}
}
accelerometerWindow::accelerometerWindow(QWidget *parent) :
QDialog(parent),
ui(new Ui::accelerometerWindow)
{
ui->setupUi(this);
timeT = 0;
this->_filter = new Filter<double>();
this->averageX = 0;
this->averageY = 0;
this->averageZ = 0;
// this->AccelX = LinAlg::Ones<double>(1000, 1);
// this->AccelY = LinAlg::Ones<double>(1000, 1);
// this->AccelZ = LinAlg::Ones<double>(1000, 1);
//this->props.setWindow(this);
props.setCentralWidget(ui->widget);
this->plotX = new PlotHandler::plot<double>(1,1,props);
props.setCentralWidget(ui->widget_2);
this->plotY = new PlotHandler::plot<double>(1,1,props);
props.setCentralWidget(ui->widget_3);
this->plotZ = new PlotHandler::plot<double>(1,1,props);
accelHandler = new accelerometerHandler(this);
QTimer::singleShot(0, this, SLOT(startUpdate()));
}
void AvatarManager::simulateAvatarFades(float deltaTime) {
QVector<AvatarSharedPointer>::iterator fadingIterator = _avatarFades.begin();
const float SHRINK_RATE = 0.9f;
const float MIN_FADE_SCALE = MIN_AVATAR_SCALE;
render::ScenePointer scene = qApp->getMain3DScene();
render::PendingChanges pendingChanges;
while (fadingIterator != _avatarFades.end()) {
auto avatar = std::static_pointer_cast<Avatar>(*fadingIterator);
avatar->startUpdate();
avatar->setTargetScale(avatar->getUniformScale() * SHRINK_RATE);
if (avatar->getTargetScale() <= MIN_FADE_SCALE) {
avatar->removeFromScene(*fadingIterator, scene, pendingChanges);
// only remove from _avatarFades if we're sure its motionState has been removed from PhysicsEngine
if (_motionStatesToRemoveFromPhysics.empty()) {
fadingIterator = _avatarFades.erase(fadingIterator);
} else {
++fadingIterator;
}
} else {
avatar->simulate(deltaTime);
++fadingIterator;
}
avatar->endUpdate();
}
scene->enqueuePendingChanges(pendingChanges);
}
void rssUpdater::update (QUrl rssAddress)
{
busy = true;
emit startUpdate(rssAddress);
address = rssAddress;
fetch();
}
FormUpdate::FormUpdate(QWidget *parent)
: QDialog(parent), m_downloader(nullptr), m_readyToInstall(false), m_ui(new Ui::FormUpdate) {
m_ui->setupUi(this);
m_btnUpdate = m_ui->m_buttonBox->addButton(tr("Download update"), QDialogButtonBox::ActionRole);
m_btnUpdate->setToolTip(tr("Download new installation files."));
m_ui->m_lblCurrentRelease->setText(APP_VERSION);
// Set flags and attributes.
setWindowFlags(Qt::MSWindowsFixedSizeDialogHint | Qt::Dialog | Qt::WindowSystemMenuHint | Qt::WindowTitleHint);
setWindowIcon(qApp->icons()->fromTheme(QSL("help-about")));
connect(m_btnUpdate, SIGNAL(clicked()), this, SLOT(startUpdate()));
checkForUpdates();
}
void VisualizationManager::load( const Config& config )
{
stopUpdate();
emitStatusUpdate( "Creating displays" );
root_display_group_->load( config );
emitStatusUpdate( "Creating tools" );
tool_manager_->load( config.mapGetChild( "Tools" ));
emitStatusUpdate( "Creating views" );
view_manager_->load( config.mapGetChild( "Views" ));
startUpdate();
}
/* ========== MAIN ========== */
int main(int argc, char* argv[]) {
/* Print out starting time */
double start = when();
printf("Starting time: %f\n", start);
/* Create thread count */
int nthreads = atoi(argv[1]);
/* Create plate */
main_plate = createPlate();
main_prev_plate = createPlate();
main_locked_cells = createCharPlate(); // bool array of locked cells
/* Init barriers and mutex */
pthread_mutex_init(&finished_count, NULL);
barr = (barrier_node*)malloc(sizeof(barrier_node));
mylib_init_barrier(barr, nthreads);
/* Init main plate and make a duplicate copy */
initPlate(main_plate, main_prev_plate);
/* Start updating */
startUpdate(nthreads);//, barr);
/* Report time and cleanup */
double end = when();
printf("\nEnding time: %f\n", end);
printf("Total execution time: %f\n", end - start);
printf("Number of iterations: %d\n\n", iterations);
/* Destroy mutex and barriers */
pthread_mutex_destroy(&finished_count);
mylib_destroy_barrier(barr);
/* free memory */
printf("Cleanup\n");
free(barr);
cleanupFloat(main_plate);
cleanupFloat(main_prev_plate);
cleanupChar(main_locked_cells);
return EXIT_SUCCESS;
}
void ModuleMgr::update()
{
_waitToUpdate = true;
switch (_updateState) {
case State::UNCHECKED:
{
_updateState = State::PREDOWNLOAD_MANIFEST;
}
case State::PREDOWNLOAD_MANIFEST:
{
downloadManifest();
}
break;
case State::MANIFEST_LOADED:
{
parseManifest();
}
break;
case State::FAIL_TO_UPDATE:
case State::NEED_UPDATE:
{
// Manifest not loaded yet
if (!_remoteManifest->isLoaded())
{
_waitToUpdate = true;
_updateState = State::PREDOWNLOAD_MANIFEST;
downloadManifest();
}
else
{
startUpdate();
}
}
break;
case State::UP_TO_DATE:
case State::UPDATING:
_waitToUpdate = false;
break;
default:
break;
}
}
void Game::update()
{
switch (gameStatus){
case PREPARE:
prepareUpdate();
break;
case START:
startUpdate();
break;
case AREDELAY:
areDelayUpdate();
break;
case DROP:
dropUpdate();
break;
case WIN:
winUpdate();
break;
}
}
void ModuleMgr::parseManifest()
{
if (_updateState != State::MANIFEST_LOADED)
return;
_remoteManifest->parse(_remoteManifestPath);
if (!_remoteManifest->isLoaded())
{
CCLOG("ModuleMgr : Error parsing manifest file\n");
dispatchUpdateEvent(ModuleMgrEvent::EventCode::ERROR_PARSE_MANIFEST);
_updateState = State::UNCHECKED;
}
else
{
// _updateState = State::NEED_UPDATE;
// dispatchUpdateEvent(ModuleMgrEvent::EventCode::NEW_VERSION_FOUND);
startUpdate();
}
}
void AvatarManager::updateOtherAvatars(float deltaTime) {
// lock the hash for read to check the size
QReadLocker lock(&_hashLock);
if (_avatarHash.size() < 2 && _avatarFades.isEmpty()) {
return;
}
lock.unlock();
bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
PerformanceWarning warn(showWarnings, "Application::updateAvatars()");
PerformanceTimer perfTimer("otherAvatars");
// simulate avatars
auto hashCopy = getHashCopy();
AvatarHash::iterator avatarIterator = hashCopy.begin();
while (avatarIterator != hashCopy.end()) {
auto avatar = std::static_pointer_cast<Avatar>(avatarIterator.value());
if (avatar == _myAvatar || !avatar->isInitialized()) {
// DO NOT update _myAvatar! Its update has already been done earlier in the main loop.
// DO NOT update or fade out uninitialized Avatars
++avatarIterator;
} else if (avatar->shouldDie()) {
removeAvatar(avatarIterator.key());
++avatarIterator;
} else {
avatar->startUpdate();
avatar->simulate(deltaTime);
avatar->endUpdate();
++avatarIterator;
}
}
// simulate avatar fades
simulateAvatarFades(deltaTime);
}
bool SGSHero::init(const char* hero_name, HERO_SIDE side)
{
if (!Sprite::init()) {
return false;
}
__name = hero_name;
__side = side;
__active = true;
/* range and level should be loaded from the hero script */
__range = SGCorpsAttackRange::CORPS_RANGE_INFANTRY;
__level = 10;
initActions();
initAttackActions();
initSpecActions();
this->setAnchorPoint(Vec2(0.5f, 0.5f));
this->setName(hero_name);
notifyObserver("hero_add", reinterpret_cast<void*>(this));
// init category
initCategory();
/* For Test Weapon Repo Purpose Only */
//SGWeaponBase *pDefArm = SGWeaponBase::Create("·ï»ËÓðÒÂ", 0);
/* Test case ends */
__status = HERO_STATUS_NORMAL;
__ai = HERO_AI_ATTACK;
initDataNum();
startUpdate(0.0f);
return true;
}
void AvatarManager::simulateAvatarFades(float deltaTime) {
QVector<AvatarSharedPointer>::iterator fadingIterator = _avatarFades.begin();
const float SHRINK_RATE = 0.9f;
const float MIN_FADE_SCALE = 0.001f;
render::ScenePointer scene = qApp->getMain3DScene();
render::PendingChanges pendingChanges;
while (fadingIterator != _avatarFades.end()) {
auto avatar = std::static_pointer_cast<Avatar>(*fadingIterator);
avatar->startUpdate();
avatar->setTargetScale(avatar->getScale() * SHRINK_RATE, true);
if (avatar->getTargetScale() < MIN_FADE_SCALE) {
avatar->removeFromScene(*fadingIterator, scene, pendingChanges);
fadingIterator = _avatarFades.erase(fadingIterator);
} else {
avatar->simulate(deltaTime);
++fadingIterator;
}
avatar->endUpdate();
}
scene->enqueuePendingChanges(pendingChanges);
}
void AssetsManagerEx::update()
{
if (_updateEntry != UpdateEntry::NONE)
{
CCLOGERROR("AssetsManagerEx::update, updateEntry isn't NONE");
return;
}
if (!_inited){
CCLOG("AssetsManagerEx : Manifests uninited.\n");
dispatchUpdateEvent(EventAssetsManagerEx::EventCode::ERROR_NO_LOCAL_MANIFEST);
return;
}
if (!_localManifest->isLoaded())
{
CCLOG("AssetsManagerEx : No local manifest file found error.\n");
dispatchUpdateEvent(EventAssetsManagerEx::EventCode::ERROR_NO_LOCAL_MANIFEST);
return;
}
_updateEntry = UpdateEntry::DO_UPDATE;
switch (_updateState) {
case State::UNCHECKED:
{
_updateState = State::PREDOWNLOAD_VERSION;
}
case State::PREDOWNLOAD_VERSION:
{
downloadVersion();
}
break;
case State::VERSION_LOADED:
{
parseVersion();
}
break;
case State::PREDOWNLOAD_MANIFEST:
{
downloadManifest();
}
break;
case State::MANIFEST_LOADED:
{
parseManifest();
}
break;
case State::FAIL_TO_UPDATE:
case State::NEED_UPDATE:
{
// Manifest not loaded yet
if (!_remoteManifest->isLoaded())
{
_updateState = State::PREDOWNLOAD_MANIFEST;
downloadManifest();
}
else
{
startUpdate();
}
}
break;
case State::UP_TO_DATE:
case State::UPDATING:
case State::UNZIPPING:
_updateEntry = UpdateEntry::NONE;
break;
default:
break;
}
}
