SpawnModel::SpawnModel(Player* player, QObject *parent)
: QAbstractTableModel(parent), m_player(player)
{
connect(m_player, SIGNAL(posChanged(int16_t,int16_t,int16_t, int16_t,int16_t,int16_t,int32_t)),
this, SLOT(updatePosition(int16_t,int16_t,int16_t, int16_t,int16_t,int16_t,int32_t)));
connect(m_player, SIGNAL(levelChanged(uint8_t)), this, SLOT(updateLevel(uint8_t)));
}
//&---------------------------------------------------------------------*
//& Method addLineCompleted
//&---------------------------------------------------------------------*
//
//----------------------------------------------------------------------*
void Points::addLinesCompleted(const int id_lines) {
int mult = 0;
switch (id_lines) {
case 1:
mult = SCORE_MULTIPLIER_1LINE;
break;
case 2:
mult = SCORE_MULTIPLIER_2LINES;
break;
case 3:
mult = SCORE_MULTIPLIER_3LINES;
break;
case 4:
mult = SCORE_MULTIPLIER_4LINES;
break;
default:
break;
}
m_points += (m_level + 1) * mult;
m_lines += id_lines;
m_lineCountForLevel += id_lines;
updateTopScore();
updateTopLines();
updateLevel();
}
void GenericTetris::startGame()
{
clearBoard();
updateScore(0);
updateLevel(1);
newPiece();
}
void HexagonGame::update(float mFrameTime)
{
if(!hasDied)
{
manager.update(mFrameTime);
updateLevelEvents(mFrameTime);
if(timeStop <= 0)
{
currentTime += mFrameTime / 60.0f;
incrementTime += mFrameTime / 60.0f;
}
else timeStop -= 1 * mFrameTime;
updateIncrement();
updateLevel(mFrameTime);
updateRadius(mFrameTime);
if(!getBlackAndWhite()) styleData.update(mFrameTime);
}
else setRotationSpeed(getRotationSpeed() / 1.001f);
updateKeys();
if(!getNoRotation()) updateRotation(mFrameTime);
if(mustRestart) newGame(levelData.getId(), false);
}
void ScoreControl::setCurrentLevel(int nLevel)
{
m_nCurrentLevel = nLevel;
updateLevel();
setTargetScore();
}
bool Creature::updateXP(){
++xp;
if (xp % WINS_TO_LEVEL == 0) {
// The creature has gained a new level!!!
return updateLevel();
}
return false;
}
void Block::destroy()
{
_blockLevel--;
if( _blockLevel < 0)
_isBlockAlive = false;
else
updateLevel();
}
void StatusList::deleteStatus( const QString& name )
{
StatusProperty* child = status_children_.take( name );
if( child )
{
delete child;
updateLevel();
}
}
bool Block::increseLevel()
{
_blockLevel++;
if(_blockLevel > 3)
return false;
updateLevel();
return true;
}
void rates::packetSent(icq_packet *pPacket)
{
if (this)
{
WORD wGroup = getGroupFromPacket(pPacket);
if (wGroup)
updateLevel(wGroup, getNextRateLevel(wGroup));
}
}
void GenericTetrix::internalPieceDropped(int dropHeight)
{
gluePiece();
nPiecesDropped++;
if (nPiecesDropped % 25 == 0) {
level++;
updateLevel(level);
}
score = score + 7 + dropHeight;
removeFullLines();
updateScore(score);
pieceDropped(dropHeight);
}
void GenericTetrix::startGame(int gameType,int fillRandomLines)
{
gameID = gameType;
clearBoard(fillRandomLines);
nLinesRemoved = 0;
updateRemoved(nLinesRemoved);
nClearLines = height;
nPiecesDropped = 0;
score = 0;
updateScore(score);
level = 1;
updateLevel(level);
newPiece();
}
void TB_PokemonBody::connectWithAdvanced(TB_Advanced *ptr)
{
connect(ptr, SIGNAL(abilityChanged()), this, SLOT(updateAbility()));
connect(ptr, SIGNAL(levelChanged()), this, SLOT(updateLevel()));
connect(ptr, SIGNAL(imageChanged()), this, SLOT(updateImage()));
connect(ptr, SIGNAL(genderChanged()), this, SLOT(updateGender()));
connect(ptr, SIGNAL(genderChanged()), this, SLOT(updateImage()));
connect(ptr, SIGNAL(statChanged()), this, SLOT(updateEVs()));
connect(ptr, SIGNAL(pokeFormeChanged(Pokemon::uniqueId)), this, SLOT(changeForme(Pokemon::uniqueId)), Qt::QueuedConnection);
connect(this, SIGNAL(EVChanged(int)), ptr, SLOT(updateStat(int)));
connect(this, SIGNAL(natureChanged()), ptr, SLOT(updateStats()));
connect(this, SIGNAL(pokeImageChanged()), ptr, SLOT(updatePokeImage()));
connect(ptr, SIGNAL(levelChanged()), this, SIGNAL(levelChanged()));
}
int OptionWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: updateLevel((*reinterpret_cast< int(*)>(_a[1]))); break;
case 1: changeMulti(); break;
case 2: changeWall(); break;
default: ;
}
_id -= 3;
}
return _id;
}
void HexagonGame::update(float mFT)
{
if(!assets.pIsLocal() && Config::isEligibleForScore())
{
assets.playedSeconds += mFT / 60.f;
if(assets.playedSeconds >= 60.f)
{
assets.playedSeconds = 0;
Online::trySendMinutePlayed();
}
}
updateFlash(mFT);
effectTimelineManager.update(mFT);
if(!status.hasDied)
{
manager.update(mFT);
updateEvents(mFT);
updateTimeStop(mFT);
updateIncrement();
if(mustChangeSides && !manager.hasEntity(HGGroup::Wall)) sideChange(getRnd(levelStatus.sidesMin, levelStatus.sidesMax + 1));
updateLevel(mFT);
if(Config::getBeatPulse()) updateBeatPulse(mFT);
if(Config::getPulse()) updatePulse(mFT);
if(!Config::getBlackAndWhite()) styleData.update(mFT, pow(difficultyMult, 0.8f));
}
else levelStatus.rotationSpeed *= 0.99f;
if(Config::get3D()) update3D(mFT);
if(!Config::getNoRotation()) updateRotation(mFT);
overlayCamera.update(mFT);
backgroundCamera.update(mFT);
for(auto& c : depthCameras) c.update(mFT);
if(status.mustRestart)
{
changeLevel(restartId, restartFirstTime);
if(!assets.pIsLocal() && Config::isEligibleForScore()) {
Online::trySendRestart();
}
}
if(!status.scoreInvalid && Config::getOfficial() && fpsWatcher.isLimitReached()) invalidateScore();
fpsWatcher.update();
}
void setColor(const TPixel32 &color) const {
PaletteController *controller =
TTool::getApplication()->getPaletteController();
if (m_colorAutoApplyEnabled) {
TColorStyle *cs = m_palette->getStyle(m_styleId);
if (0 <= m_styleParamIndex &&
m_styleParamIndex < cs->getColorParamCount())
cs->setColorParamValue(m_styleParamIndex, color);
else
cs->setMainColor(color);
cs->invalidateIcon();
controller->getCurrentPalette()->notifyColorStyleChanged();
updateLevel();
} else {
controller->setColorSample(color);
}
}
/// insert P to the label of N; do necessary updates; may return Clash in case of data node N
bool
DlSatTester :: insertToDoEntry ( DlCompletionTree* node, const ConceptWDep& C,
DagTag tag, const char* reason = NULL )
{
// we will change current Node => save it if necessary
updateLevel ( node, C.getDep() );
CGraph.addConceptToNode ( node, C, tag );
setUsed(C.bp());
if ( node->isCached() )
return correctCachedEntry(node);
// add new info in TODO list
TODO.addEntry ( node, tag, C );
if ( node->isDataNode() ) // data concept -- run data center for it
return checkDataNode ? checkDataClash(node) : false;
else if ( LLM.isWritable(llGTA) ) // inform about it
logEntry ( node, C, reason );
return false;
}
void BaselinePattern::update(double elapsed)
{
player->totalElapsed += elapsed;
if (isFinished() && !stage->ground->isBlinking()) {
updateLevel();
saveData.push_back(getFinishedStageData());
setPattern();
}
for (int i = 0; i < stage->poppies.size(); ++i)
for (int j = 0; j < stage->pots.size(); ++j)
updatePlayerChoice(stage->poppies[i], stage->pots[j]);
updateFeedback();
updatePoppyBlinks(elapsed);
stage->update(elapsed);
stage->handlePoppyCollisions(elapsed);
stage->label1->setCaption("Time: " + toStringInt(player->totalElapsed));
}
void StatusList::setStatus( Level level, const QString& name, const QString& text )
{
QHash<QString, StatusProperty*>::iterator child_iter = status_children_.find( name );
StatusProperty* child;
if( child_iter == status_children_.end() )
{
child = new StatusProperty( name, text, level, this );
status_children_.insert( name, child );
}
else
{
child = child_iter.value();
child->setLevel( level );
child->setValue( text );
}
if( level > level_ )
{
setLevel( level );
}
else if( level < level_ )
{
updateLevel();
}
}
int main(int argc, char* argv[]) {
unsigned int largeurNiveau = 0, hauteurNiveau = 0;
unsigned int numLvl = 1;
Niveau level;
LevelError code_e;
CoupsJoues pileDeCoups = NULL;
Coup* coupDepile = NULL;
PileCible pileDeCibles = NULL;
char cheminFichierSolution[27] = {0};
FILE* fichierSolution = NULL;
Position positionJoueur;
unsigned int nbPoussee = 0, nbMvt = 0;
char continuerBoucle = 1;
SDLInitError sdl_e;
SDL_Surface *ecran;
SDL_Event event;
SDL_Surface** tableauSprites = NULL;
if(argc > 1) {
numLvl = atoi(argv[1]);
}
code_e = readLevel(FICHIER_NIVEAUX, &level, numLvl, &largeurNiveau, &hauteurNiveau, &positionJoueur, &pileDeCibles);
if(code_e != NoError) {
fprintf(stderr, "(%d) Erreur de lecture du fichier de niveau \"%s\".\n", code_e, FICHIER_NIVEAUX);
libererPileCible(&pileDeCibles);
freeNiveau(&level, hauteurNiveau);
exit(EXIT_FAILURE);
}
sdl_e = initSDL(&ecran);
if(sdl_e != InitOk) {
fprintf(stderr, "(%d) Erreur lors de initSDL(SDL_Surface**).\n", sdl_e);
libererPileCible(&pileDeCibles);
freeNiveau(&level, hauteurNiveau);
freeSDL(NULL);
exit(EXIT_FAILURE);
}
tableauSprites = (SDL_Surface**)malloc(NB_SPRITE * sizeof(SDL_Surface*));
if(tableauSprites == NULL) {
fprintf(stderr, "Erreur d'allocation du tableau de sprites.\n");
libererPileCible(&pileDeCibles);
freeNiveau(&level, hauteurNiveau);
freeSDL(NULL);
exit(EXIT_FAILURE);
}
sdl_e = loadSprites(&tableauSprites);
if(sdl_e != InitOk) {
fprintf(stderr, "(%d) Erreur de chargement des sprites dans le tableau de sprites.\n", sdl_e);
libererPileCible(&pileDeCibles);
freeNiveau(&level, hauteurNiveau);
freeSDL(&tableauSprites);
exit(EXIT_FAILURE);
}
printf("Niveau %d\n", numLvl);
afficheNiveau(&level, largeurNiveau, hauteurNiveau);
dessineEntete(ecran);
dessineCompteurs(ecran, nbMvt, nbPoussee);
dessineNiveau(&level, ecran, largeurNiveau, hauteurNiveau, &tableauSprites);
while (continuerBoucle)
{
while(SDL_PollEvent(&event)) {
switch(event.type)
{
case SDL_QUIT:
continuerBoucle = 0;
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym)
{
case SDLK_ESCAPE:
continuerBoucle = 0;
break;
case SDLK_UP:
arrowKeyDownHandler(HAUT, &level, &positionJoueur, &pileDeCoups, &nbMvt, &nbPoussee);
break;
case SDLK_DOWN:
arrowKeyDownHandler(BAS, &level, &positionJoueur, &pileDeCoups, &nbMvt, &nbPoussee);
break;
case SDLK_RIGHT:
arrowKeyDownHandler(DROITE, &level, &positionJoueur, &pileDeCoups, &nbMvt, &nbPoussee);
break;
case SDLK_LEFT:
arrowKeyDownHandler(GAUCHE, &level, &positionJoueur, &pileDeCoups, &nbMvt, &nbPoussee);
break;
case SDLK_r:
libererPile(&pileDeCoups);
code_e = updateLevel(LevelReset, FICHIER_NIVEAUX, &level, &positionJoueur, &pileDeCibles, &numLvl, &largeurNiveau, &hauteurNiveau);
if(code_e != NoError) {
fprintf(stderr, "(%d) Erreur lors du redemarrage du niveau.\n", code_e);
libererPileCible(&pileDeCibles);
freeNiveau(&level, hauteurNiveau);
freeSDL(&tableauSprites);
exit(EXIT_FAILURE);
}
nbMvt = 0;
nbPoussee = 0;
break;
case SDLK_e:
libererPile(&pileDeCoups);
code_e = updateLevel(LevelPrevious, FICHIER_NIVEAUX, &level, &positionJoueur, &pileDeCibles, &numLvl, &largeurNiveau, &hauteurNiveau);
if(code_e != NoError) {
fprintf(stderr, "(%d) Erreur lors du passage au niveau precedent.\n", code_e);
libererPileCible(&pileDeCibles);
freeNiveau(&level, hauteurNiveau);
freeSDL(&tableauSprites);
exit(EXIT_FAILURE);
}
nbMvt = 0;
nbPoussee = 0;
printf("Niveau %d\n", numLvl);
afficheNiveau(&level, largeurNiveau, hauteurNiveau);
break;
case SDLK_t:
sprintf(cheminFichierSolution, "./save/level%d.sol", numLvl);
fichierSolution = fopen(cheminFichierSolution, "r");
if(fichierSolution != NULL) {
fclose(fichierSolution);
libererPile(&pileDeCoups);
code_e = updateLevel(LevelNext, FICHIER_NIVEAUX, &level, &positionJoueur, &pileDeCibles, &numLvl, &largeurNiveau, &hauteurNiveau);
if(code_e != NoError) {
fprintf(stderr, "(%d) Erreur lors du passage au niveau suivant.\n", code_e);
libererPileCible(&pileDeCibles);
freeNiveau(&level, hauteurNiveau);
freeSDL(&tableauSprites);
exit(EXIT_FAILURE);
}
nbMvt = 0;
nbPoussee = 0;
printf("Niveau %d\n", numLvl);
afficheNiveau(&level, largeurNiveau, hauteurNiveau);
}
break;
case SDLK_w: /* NB: ceci est la version windows, allez savoir pourquoi SDL prend le clavier en qwerty */
if ((event.key.keysym.mod & KMOD_LCTRL) == KMOD_LCTRL)
{
coupDepile = depilerCoup(&pileDeCoups);
if(coupDepile != NULL) {
deplacerObjetRetour(&level, *coupDepile, &nbMvt, &nbPoussee);
calculPosition(&positionJoueur, (*coupDepile).direction, Negatif);
free(coupDepile);
}
}
break;
case SDLK_q: /* NB: ceci est la version windows, allez savoir pourquoi SDL prend le clavier en qwerty */
creerFichierSauvegarde(Sauvegarde, numLvl, &pileDeCoups);
break;
case SDLK_a: /* NB: ceci est la version windows, allez savoir pourquoi SDL prend le clavier en qwerty */
chargerFichierSauvegarde(numLvl, &pileDeCoups, &level, &positionJoueur, &pileDeCibles, &nbMvt, &nbPoussee);
break;
default: break;
}
if(toutesCiblesValidees(&pileDeCibles, &level) == CibleValidee) {
printf("Niveau %d termine en %d mouvements et en %d poussees ! \n", numLvl, nbMvt, nbPoussee);
creerFichierSauvegarde(Solution, numLvl, &pileDeCoups);
libererPile(&pileDeCoups);
code_e = updateLevel(LevelNext, FICHIER_NIVEAUX, &level, &positionJoueur, &pileDeCibles, &numLvl, &largeurNiveau, &hauteurNiveau);
if(code_e != NoError) {
fprintf(stderr, "(%d) Erreur lors du passage au niveau suivant.\n", code_e);
libererPileCible(&pileDeCibles);
freeNiveau(&level, hauteurNiveau);
freeSDL(&tableauSprites);
exit(EXIT_FAILURE);
}
nbMvt = 0;
nbPoussee = 0;
printf("Niveau %d\n", numLvl);
afficheNiveau(&level, largeurNiveau, hauteurNiveau);
}
break;
default: break;
}
}
effacerNiveau(ecran);
dessineEntete(ecran);
dessineCompteurs(ecran, nbMvt, nbPoussee);
dessineNiveau(&level, ecran, largeurNiveau, hauteurNiveau, &tableauSprites);
SDL_Flip(ecran);
SDL_Delay(20);
}
libererPile(&pileDeCoups);
libererPileCible(&pileDeCibles);
freeNiveau(&level, hauteurNiveau);
freeSDL(&tableauSprites);
return EXIT_SUCCESS;
}
void HexagonGame::update(FT mFT)
{
updateText();
updateFlash(mFT);
effectTimelineManager.update(mFT);
if(!status.started && (!Config::getRotateToStart() || inputImplCCW ||
inputImplCW || inputImplBothCWCCW))
{
status.started = true;
messageText.setString("");
assets.playSound("go.ogg");
assets.musicPlayer.resume();
if(Config::getOfficial()) fpsWatcher.enable();
}
// Naive touch controls
for(const auto& p : window.getFingerDownPositions())
{
if(p.x < window.getWidth() / 2.f)
inputImplCCW = 1;
else
inputImplCW = 1;
}
if(inputImplCW && !inputImplCCW)
inputMovement = 1;
else if(!inputImplCW && inputImplCCW)
inputMovement = -1;
else if(inputImplCW && inputImplCCW)
{
if(!inputImplBothCWCCW)
{
if(inputMovement == 1 && inputImplLastMovement == 1)
inputMovement = -1;
else if(inputMovement == -1 && inputImplLastMovement == -1)
inputMovement = 1;
}
}
else
inputMovement = 0;
if(status.started)
{
if(!assets.pIsLocal() && Config::isEligibleForScore())
{
assets.playedSeconds += ssvu::getFTToSeconds(mFT);
if(assets.playedSeconds >= 60.f)
{
assets.playedSeconds = 0;
Online::trySendMinutePlayed();
}
}
if(!status.hasDied)
{
manager.update(mFT);
updateEvents(mFT);
updateTimeStop(mFT);
updateIncrement();
if(mustChangeSides && !manager.hasEntity(HGGroup::Wall))
sideChange(getRndI(
levelStatus.sidesMin, levelStatus.sidesMax + 1));
updateLevel(mFT);
if(Config::getBeatPulse()) updateBeatPulse(mFT);
if(Config::getPulse()) updatePulse(mFT);
if(!Config::getBlackAndWhite())
styleData.update(mFT, pow(difficultyMult, 0.8f));
}
else
levelStatus.rotationSpeed *= 0.99f;
if(Config::get3D()) update3D(mFT);
if(!Config::getNoRotation()) updateRotation(mFT);
}
overlayCamera.update(mFT);
backgroundCamera.update(mFT);
if(status.started)
{
if(status.mustRestart)
{
fpsWatcher.disable();
changeLevel(restartId, restartFirstTime);
if(!assets.pIsLocal() && Config::isEligibleForScore())
{
Online::trySendRestart();
}
}
if(!status.scoreInvalid && Config::getOfficial() &&
fpsWatcher.isLimitReached())
invalidateScore();
fpsWatcher.update();
}
}
void SelectLevelScene::next(){
_curLevel++;
_curLevel = _curLevel % 11;
updateLevel();
}
void SelectLevelScene::prev(){
_curLevel--;
_curLevel += 11;
_curLevel = _curLevel % 11;
updateLevel();
}
void SelectLevelScene::setCurLevel(int level){
_curLevel = level - 1;
updateLevel();
}
LoadFileError chargerFichierSauvegarde(unsigned int numero, CoupsJoues* pileCoups, Niveau* n, Position* pos, PileCible* cibles, unsigned int* nbMvt, unsigned int* nbPoussee) {
LevelError level_e = NoError;
PileError pile_e = Ok;
PileSaveLoadError psl_e = SaveLoadNoError;
Coup* curseur = NULL;
char chemin[28] = {0};
FILE* fichierSauvegarde = NULL;
CoupsJoues pileDeCoupsTmp = NULL;
unsigned int tmph = 0;
unsigned int tmpl = 0;
unsigned int num_tmp = numero;
if(pileCoups == NULL || n == NULL || pos == NULL || cibles == NULL || nbMvt == NULL || nbPoussee == NULL) {
return LoadUndefinedParameter;
}
sprintf(chemin, "./save/level%d.save", numero);
/* reinitialise le niveau */
libererPile(pileCoups);
level_e = updateLevel(LevelReset, FICHIER_NIVEAUX, n, pos, cibles, &num_tmp, &tmph, &tmpl);
if(level_e != NoError) {
fprintf(stderr, "(%d) Erreur lors de la reinitialisation du niveau.\n", level_e);
return LoadError;
}
*nbMvt = 0;
*nbPoussee = 0;
/* ouvre le fichier de sauvegarde */
fichierSauvegarde = fopen(chemin, "r");
if(fichierSauvegarde == NULL) {
fprintf(stderr, "Impossible d'ouvrir le fichier \"%s\".\n", chemin);
return LoadError;
}
/* on charge les coups */
psl_e = chargerPileCoups(pileCoups, fichierSauvegarde);
if(psl_e != SaveLoadNoError) {
fprintf(stderr, "(%d) Erreur lors du chargement de la pile de coups.\n", psl_e);
return LoadError;
}
/* on joue les coups */
curseur = *pileCoups;
while(curseur != NULL) {
deplacerObjet(n, *curseur, nbMvt, nbPoussee);
calculPosition(pos, curseur->direction, Positif);
curseur = curseur->next;
}
fclose(fichierSauvegarde);
/* nous avons stocke les coups dans une pile, il faut donc l'inverser pour empiler les prochains coups au bon endroit */
pile_e = inverserPileCoups(pileCoups, &pileDeCoupsTmp);
if(pile_e != Ok) {
fprintf(stderr, "(%d) Erreur lors de l'inversion de la pile de coups.\n", pile_e);
return LoadError;
}
libererPile(pileCoups);
*pileCoups = pileDeCoupsTmp;
return LoadOk;
}
void OpenGlTexture::addLevel(uint32 level, const Graphics::Surface *surface, const byte *palette) {
assert(level < _levelCount);
updateLevel(level, surface, palette);
}
void WorldManager::doWork() {
updateScore();
updateLevel();
updateObjects();
}
LaneSettings::LaneSettings(ProjectSettings *projectSettings, SettingsElement *parentSettingsElement, Lane *lane)
: SettingsElement(projectSettings, parentSettingsElement, lane)
, ui(new Ui::LaneSettings)
, lane_(lane)
, init_(false)
, roadSystemItemPolyGraph_(NULL)
, insertWidthSectionHandle_(NULL)
, lswItem_(NULL)
{
ui->setupUi(this);
activateWidthGroupBox(false);
activateInsertGroupBox(false);
connect(ui->insertPushButton, SIGNAL(clicked(bool)), this, SLOT(activateInsertGroupBox(bool)));
connect(ui->editPushButton, SIGNAL(clicked(bool)), this, SLOT(activateWidthGroupBox(bool)));
// List //
//
QStringList typeNames;
typeNames << Lane::parseLaneTypeBack(Lane::LT_NONE)
<< Lane::parseLaneTypeBack(Lane::LT_DRIVING)
<< Lane::parseLaneTypeBack(Lane::LT_STOP)
<< Lane::parseLaneTypeBack(Lane::LT_SHOULDER)
<< Lane::parseLaneTypeBack(Lane::LT_BIKING)
<< Lane::parseLaneTypeBack(Lane::LT_SIDEWALK)
<< Lane::parseLaneTypeBack(Lane::LT_BORDER)
<< Lane::parseLaneTypeBack(Lane::LT_RESTRICTED)
<< Lane::parseLaneTypeBack(Lane::LT_PARKING)
<< Lane::parseLaneTypeBack(Lane::LT_MWYENTRY)
<< Lane::parseLaneTypeBack(Lane::LT_MWYEXIT)
<< Lane::parseLaneTypeBack(Lane::LT_SPECIAL1)
<< Lane::parseLaneTypeBack(Lane::LT_SPECIAL2)
<< Lane::parseLaneTypeBack(Lane::LT_SPECIAL3);
ui->typeBox->addItems(typeNames);
/*heightGraph_ = new ProfileGraph(projectSettings->getProjectWidget(), projectSettings->getProjectData());
heightGraph_->setParent(ui->widthGroup);
ui->horizontalLayout_3->insertWidget(0,heightGraph_);
//heightGraph_->getView()->setDragMode(QGraphicsView::ScrollHandDrag);
//QGraphicsScene* pScene = new NoDeselectScene(this);
//heightGraph_->getView()->setScene(pScene);
heightGraph_->getScene()->doDeselect(false);// we don't want to deselect ourselves if we click on the background, otherwise we delete ourselves--> chrash and it would not be practical anyway
*/
heightGraph_ = projectSettings->getProjectWidget()->getHeightGraph();
laneEditor_ = dynamic_cast<LaneEditor *>(projectSettings->getProjectWidget()->getProjectEditor());
if (!laneEditor_)
{
return; // another editor is active
}
roadSystemItemPolyGraph_ = new LaneWidthRoadSystemItem(heightGraph_, projectSettings->getProjectData()->getRoadSystem());
heightGraph_->getScene()->addItem(roadSystemItemPolyGraph_);
// Section Handle //
//
//insertWidthSectionHandle_ = new SectionHandle(roadSystemItemPolyGraph_);
//insertWidthSectionHandle_->hide();
roadSystemItemPolyGraph_->setSettings(this);
roadSystemItemPolyGraph_->setAcceptHoverEvents(true);
// Activate Road in ProfileGraph //
//
lswItem_ = new LaneSectionWidthItem(roadSystemItemPolyGraph_, lane_);
//selectedElevationRoadItems_.insert(road, roadItem);
// Fit View //
//
QRectF boundingBox = lswItem_->boundingRect();
if (boundingBox.width() < 15.0)
{
boundingBox.setWidth(15.0);
}
if (boundingBox.height() < 10.0)
{
boundingBox.setHeight(10.0);
}
heightGraph_->getView()->fitInView(boundingBox);
heightGraph_->getView()->zoomOut(Qt::Horizontal | Qt::Vertical);
//ui->horizontalLayout_3->insertWidget(0,heightGraph_);
//heightGraph_->show();
// Initial Values //
//
updateId();
updateType();
updateLevel();
updatePredecessor();
updateSuccessor();
updateWidth();
// Done //
//
init_ = true;
}
///////////////////////////////////////////
// Dispatches Zone data packets based on the opCode
void EQPacket::dispatchZoneData(const uint8_t *data, size_t len,
uint8_t dir, uint16_t opCode)
{
#ifdef DEBUG_PACKET
debug ("dispatchZoneData()");
#endif /* DEBUG_PACKET */
QString tempStr;
bool unk = true;
switch (opCode)
{
case OP_ClientUpdate: // old PlayerPosCode:
{
#ifdef PACKET_PAYLOAD_SIZE_DIAG
if ((len != sizeof(playerSpawnPosStruct)) &&
(len != sizeof(playerSelfPosStruct)))
{
fprintf(stderr, "WARNING: OP_ClientUpdate (%04x) (dataLen: %d != sizeof(playerSpawnPosStruct):%d or sizeof(playerSpawnSelfStruct):%d)\n",
OP_ClientUpdate, len,
sizeof(playerSpawnPosStruct), sizeof(playerSelfPosStruct));
unk = true;
}
else
unk = false;
#else
unk = false;
#endif
if (len == sizeof(playerSpawnPosStruct))
emit playerUpdate((const playerSpawnPosStruct*)data, len, dir);
else if (len == sizeof(playerSelfPosStruct))
emit playerUpdate((const playerSelfPosStruct*)data, len, dir);
else
unk = true;
break;
}
case OP_MobUpdate: // old MobUpdateCode:
{
unk = ! ValidatePayload(OP_MobUpdate, spawnPositionUpdate);
emit updateSpawns((const spawnPositionUpdate *)data, len, dir);
break;
}
case OP_WearChange: // old SpawnUpdateCode:
{
unk = ! ValidatePayload(OP_WearChange, SpawnUpdateStruct);
SpawnUpdateStruct *su = (SpawnUpdateStruct*)data;
// printf("SpawnUpdateCode(id=%d, sub=%d, arg1=%d, arg2=%d)\n",
// su->spawnId, su->subcommand,
// su->arg1, su->arg2);
/* Belith - I believe this is depreciated no? Doesn't work anyway ;) */
switch(su->subcommand) {
case 17:
emit updateSpawnMaxHP(su, len, dir);
break;
}
break;
emit updateSpawnInfo(su, len, dir);
}
case OP_SpawnAppearance: // old SpawnAppearanceCode:
{
unk = false;
emit spawnAppearance((const spawnAppearanceStruct*)data, len, dir);
break;
}
case OP_CommonMessage: // old ChannelMessageCode:
{
unk = false;
emit channelMessage((const channelMessageStruct*)data, len, dir);
break;
}
case OP_FormattedMessage: // old FormattedMessageCode:
{
unk = false;
emit formattedMessage((const formattedMessageStruct*)data, len, dir);
break;
}
case OP_SimpleMessage: // old SimpleMessageCode:
{
unk = false;
emit simpleMessage((const simpleMessageStruct*)data, len, dir);
break;
}
case OP_SpecialMesg:
{
unk = false;
emit specialMessage((const specialMessageStruct*)data, len, dir);
break;
}
case OP_GuildMOTD:
{
unk = false;
emit guildMOTD((const guildMOTDStruct*)data, len, dir);
break;
}
case OP_Death: // old NewCorpseCode:
{
unk = ! ValidatePayload(OP_Death, newCorpseStruct);
emit killSpawn((const newCorpseStruct*) data, len, dir);
break;
} /* end CorpseCode */
case OP_DeleteSpawn: // old DeleteSpawnCode:
{
unk = ! ValidatePayload(OP_DeleteSpawn, deleteSpawnStruct);
emit deleteSpawn((const deleteSpawnStruct*)data, len, dir);
break;
}
case OP_ItemLinkResponse: // old ItemInfoCode:
{
unk = false;
if (dir == DIR_SERVER)
emit itemInfo((const itemInfoStruct*)data, len, dir);
else
emit itemInfoReq((const itemInfoReqStruct*)data, len, dir);
}
case OP_ItemPacket: // old ItemCode:
{
unk = false;
if (dir == DIR_SERVER)
emit item((const itemPacketStruct*)data, len, dir);
break;
}
case OP_ItemPlayerPacket:
{
unk = false;
if (dir == DIR_SERVER)
emit playerItem((const char*)data, len, dir);
break;
}
case OP_NewSpawn: // old NewSpawnCode:
{
unk = ! ValidatePayload(OP_NewSpawn, newSpawnStruct);
emit newSpawn((const newSpawnStruct*)data, len, dir);
break;
}
case OP_ItemTextFile: // old BookTextCode:
{
unk = false;
printf("BOOK: '%s'\n", ((const bookTextStruct *)data)->text);
emit bookText((const bookTextStruct*)data, len, dir);
break;
}
case OP_MoneyOnCorpse: // old MoneyOnCorpseCode:
{
unk = ! ValidatePayload(OP_MoneyOnCorpse, moneyOnCorpseStruct);
emit moneyOnCorpse((const moneyOnCorpseStruct*)data, len, dir);
break;
} /* end MoneyOnCorpseCode */
case OP_RandomReply: // old RandomCode:
{
unk = ! ValidatePayload(OP_RandomReply, randomStruct);
emit random((const randomStruct*)data, len, dir);
break;
}
case OP_RandomReq: // RandomReqCode:
{
unk = ! ValidatePayload(OP_RandomReq, randomReqStruct);
emit random((const randomReqStruct*)data, len, dir);
break;
}
case OP_Emote: // old EmoteEmoteTextCode:
{
unk = false;
emit emoteText((const emoteTextStruct*)data, len, dir);
break;
}
case OP_CorpseLocResponse: // old CorpseLocCode:
{
unk = ! ValidatePayload(OP_CorpseLocResponse, corpseLocStruct);
emit corpseLoc((const corpseLocStruct*)data, len, dir);
break;
}
case OP_InspectAnswer: // old InspectDataCode:
{
unk = ! ValidatePayload(OP_InspectAnswer, inspectDataStruct);
emit inspectData((const inspectDataStruct *)data, len, dir);
break;
}
case OP_HPUpdate: // old NpcHpUpdateCode:
{
unk = ! ValidatePayload(OP_HPUpdate, hpNpcUpdateStruct);
emit updateNpcHP((const hpNpcUpdateStruct*)data, len, dir);
break;
}
case SPMesgCode:
{
unk = false;
emit spMessage((const spMesgStruct *)data, len, dir);
break;
}
case OP_MemorizeSpell: // old MemSpellCode:
{
unk = ! ValidatePayload(OP_MemorizeSpell, memSpellStruct);
emit handleSpell((const memSpellStruct*)data, len, dir);
break;
}
case OP_BeginCast: // old BeginCastCode
{
unk = ! ValidatePayload(OP_BeginCast, beginCastStruct);
emit beginCast((const beginCastStruct*)data, len, dir);
break;
}
case OP_CastSpell: // old StartCastCode:
{
unk = ! ValidatePayload(OP_CastSpell, startCastStruct);
emit startCast((const startCastStruct*)data, len, dir);
break;
}
case OP_BuffFadeMsg: // old SpellFadeCode:
{
unk = false;
emit spellFaded((const spellFadedStruct*)data, len, dir);
break;
}
case OP_ExpUpdate: // old ExpUpdateCode:
{
unk = ! ValidatePayload(OP_ExpUpdate, expUpdateStruct);
emit updateExp((const expUpdateStruct*)data, len, dir);
break;
}
case OP_LevelUpdate: // old LevelUpUpdateCode:
{
unk = ! ValidatePayload(OP_LevelUpdate, levelUpUpdateStruct);
emit updateLevel((const levelUpUpdateStruct *)data, len, dir);
break;
}
case OP_SkillUpdate: // old SkillIncCode
{
unk = ! ValidatePayload(OP_SkillUpdate, skillIncStruct);
emit increaseSkill((const skillIncStruct *)data, len, dir);
break;
}
case OP_MoveDoor: // old DoorOpenCode:
{
unk = false;
emit doorOpen(data, len, dir);
break;
}
case OP_Illusion: // old IllusionCode:
{
unk = false;
emit illusion(data, len, dir);
break;
}
case OP_ZoneChange: // old ZoneChangeCode:
{
unk = ! ValidatePayload(OP_ZoneChange, zoneChangeStruct);
// in the process of zoning, server hasn't switched yet.
emit zoneChange((const zoneChangeStruct*)data, len, dir);
break;
}
case OP_ZoneEntry: // old ZoneEntryCode:
{
// We're only interested in the server version
if (dir == DIR_CLIENT)
{
unk = ! ValidatePayload(OP_ZoneEntry, ClientZoneEntryStruct);
emit zoneEntry((const ClientZoneEntryStruct*)data, len, dir);
break;
}
unk = ! ValidatePayload(OP_ZoneEntry, ServerZoneEntryStruct);
emit zoneEntry((const ServerZoneEntryStruct*)data, len, dir);
break;
} /* end ZoneEntryCode */
case OP_NewZone: // old - NewZoneCode:
{
unk = ! ValidatePayload(OP_NewZone, newZoneStruct);
emit zoneNew((const newZoneStruct*)data, len, dir);
if (m_vPacket)
printf("New Zone at byte: %ld\n", m_vPacket->FilePos());
break;
}
case OP_PlayerProfile: // Character Profile server to client - old CharProfileCode
{
unk = false;
ValidatePayload(OP_PlayerProfile, charProfileStruct);
emit backfillPlayer((const charProfileStruct*)data, len, DIR_SERVER);
break;
}
case OP_ZoneSpawns: // ZoneSpawnsCode:
{
unk = false;
emit zoneSpawns((const zoneSpawnsStruct*)data, len, dir);
break;
}
case OP_TimeOfDay: // old TimeOfDayCode:
{
unk = ! ValidatePayload(OP_TimeOfDay, timeOfDayStruct);
emit timeOfDay((const timeOfDayStruct*)data, len, dir);
break;
}
case WearChangeCode:
{
unk = ! ValidatePayload(WearChangeCode, wearChangeStruct);
emit spawnWearingUpdate ((const wearChangeStruct*)data, len, dir);
break;
}
case OP_Action:
{
unk = ! ValidatePayload(OP_Action, actionStruct);
emit action((const actionStruct*)data, len, dir);
break;
}
case OP_CastBuff: // old ActionCode:
{
unk = false;
emit action2Message ((const action2Struct *)data, len, dir);
break;
}
case OP_Stamina: /// old StaminaCode:
{
unk = ! ValidatePayload(OP_Stamina, staminaStruct);
emit updateStamina((const staminaStruct *)data, len, dir);
break;
}
case OP_GroundSpawn: // old MakeDropCode:
{
#ifdef PACKET_PAYLOAD_SIZE_DIAG
if ((len != sizeof(makeDropStruct)) &&
(len != 0))
{
fprintf(stderr, "WARNING: OP_GroundSpawn (%04x) (dataLen: %d != sizeof(makeDropStruct):%d or 0)\n",
OP_GroundSpawn, len,
sizeof(makeDropStruct));
unk = true;
}
else
unk = false;
#else
unk = false;
#endif
emit newGroundItem((const makeDropStruct*)data, len, dir);
break;
}
case OP_ClickObject: // Old RemDropCode:
{
unk = ! ValidatePayload(OP_ClickObject, remDropStruct);
emit removeGroundItem((const remDropStruct *)data, len, dir);
break;
}
case OP_ShopRequest: // old OpenVendorCode:
{
unk = false;
emit openVendor(data, len, dir);
break;
}
case OP_ShopEnd: // old CloseVendorCode:
{
unk = false;
emit closeVendor(data, len, dir);
break;
}
case OP_GMTraining: // old OpenGMCode:
{
unk = false;
emit openGM(data, len, dir);
break;
}
case OP_GMEndTrainingResponse: // old CloseGMCode:
{
unk = false;
emit closeGM(data, len, dir);
break;
}
case OP_Consider: // old ConsiderCode:
{
unk = false;
ValidatePayload(OP_Consider, considerStruct);
emit consMessage((const considerStruct*)data, len, dir);
break;
}
case OP_TargetMouse: // old ClientTargetCode:
{
unk = ! ValidatePayload(OP_TargetMouse, clientTargetStruct);
emit clientTarget((const clientTargetStruct*) data, len, dir);
break;
}
case OP_SpawnDoor: // old DoorSpawnsCode:
{
unk = false;
#ifdef PACKET_PAYLOAD_SIZE_DIAG
// verify size
if (len % sizeof(doorStruct) != 0)
{
printf("WARNING: OP_SpawnDoor (%.04x) (dataLen:%d "
"%% sizeof(doorStruct):%d) != 0!\n",
OP_SpawnDoor, len, sizeof(doorStruct));
unk = true;
break;
}
#endif
int nDoors = len / sizeof(doorStruct);
const DoorSpawnsStruct *doorsStruct = (const DoorSpawnsStruct *)data;
for (int i = 0; i < nDoors; i++) {
emit newDoorSpawn(&doorsStruct->doors[i], len, dir);
}
emit newDoorSpawns(doorsStruct, len, dir);
break;
}
case OP_Buff: // old BuffDropCode:
{
unk = ! ValidatePayload(OP_Buff, buffStruct);
emit buff((const buffStruct*)data, len, dir);
// this is the server 'buff fading' AND the client 'cancel buff'
break;
}
case OP_Logout: // no contents
{
unk = false;
emit logOut(data, len, dir);
break;
}
case OP_SendZonePoints:
{
unk = false;
#ifdef PACKET_PAYLOAD_SIZE_DIAG
const zonePointsStruct* zp = (const zonePointsStruct*)data;
// verify size
if (((len - sizeof(zp->count) - sizeof(zp->unknown0xxx))
% sizeof(zonePointStruct)) != 0)
{
fprintf(stderr, "WARNING: OP_SendZonePoints (%04x) (dataLen: %d %% sizeof(zonePointStruct):%d) != 0!\n",
OP_SendZonePoints, len, sizeof(zonePointStruct));
unk = true;
break;
}
#endif
emit zonePoints((const zonePointsStruct*)data, len, dir);
break;
}
case OP_GuildMemberList: // old GuildMemberListCode
{
unk = false;
break;
}
case OP_GuildMemberUpdate: // old GuildMemberUpdateCode:
{
unk = false;
break;
}
case OP_SetRunMode: // old cRunToggleCode:
{
//unk = ! ValidatePayload(cRunToggleCode, cRunToggleStruct);
//emit cRunToggle((const cRunToggleStruct*)data, len, dir);
unk = false;
break;
}
case OP_Jump: // old cJumpCode:
{
//no data
unk = false;
break;
}
case OP_Camp: // old cStartCampingCode:
{
//no data
unk = false;
break;
}
case OP_SenseHeading: // old cSenseHeadingCode:
{
//no data
unk = false;
break;
}
case OP_Forage: // old ForageCode:
{
//no data
unk = false;
break;
}
#if 0 // ZBTEMP : If we don't bother setting unk, don't bother processing
case OP_ConsiderCorpse: //unknown contents // old cConCorpseCode:
{
//unk = ! ValidatePayload(cConCorpseCode, cConCorpseStruct);
//emit cConCorpse((const cConCorpseStruct*)data, len, dir);
break;
}
case OP_LootRequest: //unknown contents - old cLootCorpseCode
{
//unk = ! ValidatePayload(cLootCorpseCode, cLootCorpseStruct);
//emit cLootCorpse((const cLootCorpseStruct*)data, len, dir);
break;
}
case OP_EndLootRequest: //unknown contents - old cDoneLootingCode
{
//unk = ! ValidatePayload(cDoneLootingCode, cDoneLootingStruct);
//emit cDoneLooting((const cDoneLootingStruct*)data, len, dir);
break;
}
case OP_LootComplete: //unknown contents - old sDoneLootingCode
{
//unk = ! ValidatePayload(sDoneLootingCode, sDoneLootingStruct);
//emit sDoneLooting((const sDoneLootingStruct*)data, len, dir);
break;
}
case OP_WhoAllRequest: //unknown contents - old WhoAllReqCode
{
//unk = ! ValidatePayload(cWhoAllCode, cWhoAllStruct);
//emit cWhoAll((const cWhoAllStruct*)data, len, dir);
break;
}
case OP_WhoAllResponse: // old sWhoAllOutputCode: unknown contents
{
//unk = ! ValidatePayload(sWhoAllOutputCode, sWhoAllOutputStruct);
//emit sWhoAllOutput((const sWhoAllOutputStruct*)data, len, dir);
break;
}
case OP_ShopPlayerBuy: //unknown contents - old BuyItemCode
{
//unk = ! ValidatePayload(xBuyItemCode, xBuyItemStruct);
//emit xBuyItem((const xBuyItemStruct*)data, len, dir);
//both the client command and the server acknowledgement when buying
break;
}
#endif // ZBTEMP
#if 0 // ZBTEMP: OPCode Graveyard
case CastOnCode:
{
unk = false;
emit castOn((castOnStruct*)data, len, dir);
break;
}
case ManaDecrementCode:
{
unk = ! ValidatePayload(ManaDecrementCode, manaDecrementStruct);
emit manaChange((struct manaDecrementStruct *)data, len, dir);
break;
}
case BadCastCode:
{
unk = false; //! ValidatePayload(BadCastCode, badCastStruct);
emit interruptSpellCast((const badCastStruct*)data, len, dir);
break;
}
case SysMsgCode:
{
unk = false;
emit systemMessage((const sysMsgStruct*)data, len, dir);
break;
}
case AltExpUpdateCode:
{
unk = ! ValidatePayload(AltExpUpdateCode, altExpUpdateStruct);
emit updateAltExp((const altExpUpdateStruct*)data, len, dir);
break;
}
case Attack2Code:
{
unk = false;
emit attack2Hand1 ((const attack2Struct *)data, len, dir);
break;
}
case NewGuildInZoneCode:
{
unk = false;
break;
}
case MoneyUpdateCode:
{
unk = false;
emit moneyUpdate((const moneyUpdateStruct*)data, len, dir);
break;
}
case MoneyThingCode:
{
unk = false;
emit moneyThing((const moneyThingStruct*)data, len, dir);
break;
}
case BindWoundCode:
{
unk = false;
emit bindWound((bindWoundStruct*)data, len, dir);
break;
}
case GroupInfoCode:
{
// Too much still unknown.
unk = ! ValidatePayload(GroupInfoCode, groupMemberStruct);
emit groupInfo((const groupMemberStruct*)data, len, dir);
break;
}
case GroupInviteCode:
{
unk = ! ValidatePayload(GroupInviteCode, groupInviteStruct);
emit groupInvite((const groupInviteStruct*)data, len, dir);
break;
}
case GroupDeclineCode:
{
unk = ! ValidatePayload(GroupDeclineCode, groupDeclineStruct);
emit groupDecline((const groupDeclineStruct*)data, len, dir);
break;
}
case GroupAcceptCode:
{
unk = ! ValidatePayload(GroupAcceptCode, groupAcceptStruct);
emit groupAccept((const groupAcceptStruct*)data, len, dir);
break;
}
case GroupDeleteCode:
{
unk = ! ValidatePayload(GroupDeleteCode, groupDeleteStruct);
emit groupDelete((const groupDeleteStruct*)data, len, dir);
break;
}
case CharUpdateCode:
{
break;
}
case cChatFiltersCode:
{
//unk = ! ValidatePayload(cChatFiltersCode, cChatFiltersStruct);
//emit cChatFilters((const cChatFiltersStruct*)data, len, dir);
unk = false;
break;
}
case cOpenSpellBookCode:
{
//unk = ! ValidatePayload(cOpenSpellBookCode, cOpenSpellBookStruct);
//emit cOpenSpellBook((const cOpenSpellBookStruct*)data, len, dir);
unk = false;
break;
}
case OP_SwapSpell: // old TradeSpellBookSlotsCode:
{
unk = ! ValidatePayload(OP_SwapSpell, tradeSpellBookSlotsStruct);
emit tradeSpellBookSlots((const tradeSpellBookSlotsStruct*)data, len, dir);
break;
}
case sSpellFizzleRegainCode: //unknown contents, also comes when you Forage
{
//unk = ! ValidatePayload(sSpellFizzleRegainCode, sSpellFizzleRegainStruct);
//emit sSpellFizzleRegain((const sSpellFizzleRegainStruct*)data, len, dir);
break;
}
case sSpellInterruptedCode: //unknown contents
{
//unk = ! ValidatePayload(sSpellInterruptedCode, sSpellInterruptedStruct);
//emit sSpellInterrupted((const sSpellInterruptedStruct*)data, len, dir);
break;
}
case cHideCode:
{
//no data
unk = false;
break;
}
case cSneakCode:
{
//no data
unk = false;
break;
}
case cTrackCode:
{
//no data
unk = false;
break;
}
#endif // ZBTEMP // Currently dead opcodes
default:
{
}
} /* end switch(opCode) */
emit decodedZonePacket(data, len, dir, opCode, unk);
}
void OpenGlTexture::update(const Graphics::Surface *surface, const byte *palette) {
bind();
updateLevel(0, surface, palette);
}
