void GamePlayScene::loadGameState(const std::vector<char> *data) { union change { int i; unsigned char buf[4]; } itoc; itoc.buf[0] = data->at(0); itoc.buf[1] = data->at(1); itoc.buf[2] = data->at(2); itoc.buf[3] = data->at(3); loadPuzzle(itoc.i); m_sudoku->loadGameFromBuffer(data); AbstractCommand *cmd; int pos = SUDOKU_SIZE * SUDOKU_SIZE * 3 + 4; while (pos < data->size()) { cmd = AbstractCommand::loadFromBuffer(this, data, pos); m_logStack.push_back(cmd); if (cmd->isPuzzleCmd()) { m_undoStack.push_back(cmd->clone()); } pos += cmd->getCommandBufSize(); } m_puzzleLayer->resetValues(); m_inputLayer->setUndoButton(hasSomethingToUndo()); m_inputLayer->setNumberCompleted(); }
void BattleInput::receiveData(QByteArray inf) { if (inf.isEmpty()) { if (paused()) { delayedCommands.push_back(inf); return; } /* An empty array means raw Command */ if (commands.size() > 0) { AbstractCommand *command = *commands.begin(); commands.pop_front(); command->apply(); delete command; return; } } if (paused() && inf[0] != char(BC::BattleChat) && inf[0] != char(BC::SpectatorChat) && inf[0] != char(BC::ClockStart) && inf[0] != char(BC::ClockStop) && inf[0] != char(BC::Spectating)) { delayedCommands.push_back(inf); return; } DataStream in (&inf, QIODevice::ReadOnly); uchar command; qint8 player; in >> command >> player; dealWithCommandInfo(in, command, player); }
AbstractCommand* Terminal::getCommandByName(char* commandName) { for(uint8_t q = 0 ; q < commands->getSize() ; q ++) { AbstractCommand* command = commands->get(q); if(strcmp_P(commandName, (char*)command->getName()) == 0) { return command; } } return 0; }
void Terminal::processHelp() { if(commands->getSize() == 0) { serial->println(F("No commands available.")); return; } for(uint8_t q = 0 ; q < commands->getSize() ; q ++) { AbstractCommand* command = commands->get(q); serial->println(command->getName()); } }
AbstractCommand *CommandFactory::parseCommand(QString const &command) { QString const normalizedCommand = command.toLower().trimmed(); QStringList const parts = normalizedCommand.split(" ", QString::SkipEmptyParts); if (parts.isEmpty()) { return 0; } AbstractCommand *result = parseCommand(parts); if (result) { result->setParent(this); } else { qDebug() << "Error while parsing command" << command; } return result; }
void RegularBattleScene::unpause() { pauseCount -= 1; if (pauseCount == 0 && !unpausing) { unpausing = true; while (commands.size() > 0) { AbstractCommand *command = *commands.begin(); commands.pop_front(); command->apply(); delete command; } unpausing = false; } baseClass::unpause(); }
void Connection::receiveCommand() { QByteArray arr = m_connection->readAll(); debugOutput(1, QString::fromLatin1("Command received: ") + (arr)); QList<CommandInfo> commands = availableCommands(); for(QList<CommandInfo>::iterator it = commands.begin(); it != commands.end(); ++it) { if (it->commandName == QString::fromLatin1(arr)) { debugOutput(1, "Found command in list"); disconnect(m_connection, SIGNAL(readyRead()), this, SLOT(receiveCommand())); AbstractCommand* command = (*it).commandFunc(); command->setSocket(m_connection); m_command = command; return; } } debugOutput(2, QString::fromLatin1("Unknown command received: ") + (arr)); }
AbstractCommand * Pilot::BuildOne(DataType data, CommandType command, const std::string & commandName){ // instanciate data AbstractData * d = DataFactory::Create(data); if ( !d ){ Logger::Instance() << "Error data not built"; return NULL; } // instanciate Command AbstractCommand * c = CommandFactory::Create(command); if ( !c ){ Logger::Instance() << "Error command not built"; return NULL; } // link data with command and delegate ownership c->SetData(d); // append to container (take ownership, will be deleted automatically) _containerContainer.Set(commandName,c); return c; }
/* * Return the index number of occurrence of this command. If doesn't exists return NULL; * The first command has number 0. */ AbstractCommand* SyncMLProcessor::getCommand(SyncBody* syncBody, const char*commandName, int index) { int iterator = 0, found = 0; ArrayList* list = syncBody->getCommands(); AbstractCommand* a = NULL; const char* name = NULL; do { a = (AbstractCommand*)getArrayElement(list, iterator); if (a) { name = a->getName(); // is returned the pointer to the element not a new element if (name && strcmp(name, commandName) == 0) { if (found == index) break; else found++; } } ++iterator; } while(a); return a; }
void BattleScene::useCommand() { if (commands.size() > 0) { AbstractCommand *command = *commands.begin(); int val = command->val(); if (!onPeek(val)) { return; } commands.pop_front(); command->apply(); delete command; if (replayCount > 0 && misReplayingCommands) { replayCount --; if (replayCount == 0) { misReplayingCommands = false; } } } }
void Service::invokeCommand (const QString& cmd) { qDebug() << "[DesktopControl::Service::invokeCommand()] Heard " << cmd << "from the user."; AbstractCategory* glbl = AbstractCategory::global(); CommandList commands = glbl->matchAllCommands (cmd); if (!commands.isEmpty()) { if (commands.count() == 1) { AbstractCommand* onlyCommand = commands.first(); qDebug() << "[DesktopControl::Service::invokeCommand()] Only matched a command " << onlyCommand->id() << "matched with statements" << onlyCommand->statements(); emit commandFound (cmd, onlyCommand); onlyCommand->invoke (cmd); return; } else { emit multipleCommandsFound (cmd, commands); Q_FOREACH (AbstractCommand * command, commands) { qDebug() << "[DesktopControl::Service::invokeCommand()] Command " << command->id() << "matched with statements" << command->statements(); } } } else {
void testExecute(){ Sequence sequence( "foo", 1, 4, 4, 500000 ); Track track( "name", "singer" ); track.events()->clear(); Event singer( 0, EventType::SINGER ); track.events()->add( singer, 1 ); Event note( 1920, EventType::NOTE ); note.note = 60; track.events()->add( note, 2 ); *sequence.track(0) = track; Event editedNote = note; editedNote.note = 61; EditEventCommand command( 0, 2, editedNote ); AbstractCommand *inverseCommand = command.execute( &sequence ); CPPUNIT_ASSERT_EQUAL(61, sequence.track(0)->events()->findFromId(2)->note); AbstractCommand *garbage = inverseCommand->execute( &sequence ); CPPUNIT_ASSERT_EQUAL(60, sequence.track(0)->events()->findFromId(2)->note); delete inverseCommand; delete garbage; }
void Terminal::loop() { performBackgroundCommands(); // check for incoming commands if(!readString()) { return; } char* command = commandParams.getParam(0); if(strcmp_P(command, (char*)F("break")) == 0) { cancelBackgroundCommands(); commandParams.reset(); printTerminalReadyIfNeeded(); return; } if(areBackgroundCommands()) { commandParams.reset(); serial->println(F("terminal busy")); return; } if(strcmp_P(command, (char*)F("")) == 0) { commandParams.reset(); printTerminalReadyIfNeeded(); return; } if(strcmp_P(command, (char*)F("help")) == 0) { processHelp(); commandParams.reset(); printTerminalReadyIfNeeded(); return; } AbstractCommand* commandToExecute = getCommandByName(command); if(commandToExecute != 0) { commandToExecute->process(&commandParams, this->serial); commandParams.reset(); if(commandToExecute->isBackground()) { this->backgroundCommand = commandToExecute; } else { printTerminalReadyIfNeeded(); } return; } serial->print(command); serial->println(F(": unknown command")); commandParams.reset(); printTerminalReady(); }