/*
** Pomocná funkce doOperation.
** Zpracuje operátor, který je pøedán parametrem c po naètení znaku ze
** vstupního pole znakù.
**
** Dle priority pøedaného operátoru a pøípadnì priority operátoru na
** vrcholu zásobníku rozhodneme o dal¹ím postupu. Délka pøevedeného
** výrazu a takté¾ ukazatel na první volné místo, do kterého se má zapisovat,
** pøedstavuje parametr postLen, výstupním polem znakù je opìt postExpr.
*/
void doOperation ( tStack* s, char c, char* postExpr, unsigned* postLen ) {
char topChar;
if (!stackEmpty(s)) {
// nacteni znaku z vrcholu zasobniku pokud neni zasobnik prazdny
stackTop(s, &topChar);
}
// Operátor vkladam na vrchol zasobniku v pripade, ze:
// - zásobník je prázdný
// - na vrcholu zásobníku je levá závorka
// - na vrcholu zásobníku je operátor s ni¾¹í prioritou
if (
(stackEmpty(s)) ||
(topChar == '(') ||
(topChar == '+' && c != '-' && c != '+') ||
(topChar == '-' && c != '-' && c != '+')
) {
// nacteni operatoru do zasobniku
stackPush(s, c);
} else {
postExpr[*postLen] = topChar;
*postLen+=1;
stackPop(s);
doOperation(s, c, postExpr, postLen);
}
}
void FileWriter::write(Blob* data, ExceptionCode& ec)
{
ASSERT(writer());
ASSERT(data);
ASSERT(m_truncateLength == -1);
if (m_readyState == WRITING) {
setError(FileError::INVALID_STATE_ERR, ec);
return;
}
if (!data) {
setError(FileError::TYPE_MISMATCH_ERR, ec);
return;
}
if (m_recursionDepth > kMaxRecursionDepth) {
setError(FileError::SECURITY_ERR, ec);
return;
}
m_blobBeingWritten = data;
m_readyState = WRITING;
m_bytesWritten = 0;
m_bytesToWrite = data->size();
ASSERT(m_queuedOperation == OperationNone);
if (m_operationInProgress != OperationNone) {
// We must be waiting for an abort to complete, since m_readyState wasn't WRITING.
ASSERT(m_operationInProgress == OperationAbort);
m_queuedOperation = OperationWrite;
} else
doOperation(OperationWrite);
fireEvent(eventNames().writestartEvent);
}
void FileWriter::truncate(long long position, ExceptionCode& ec)
{
ASSERT(writer());
ASSERT(m_truncateLength == -1);
if (m_readyState == WRITING || position < 0) {
setError(FileError::INVALID_STATE_ERR, ec);
return;
}
if (m_recursionDepth > kMaxRecursionDepth) {
setError(FileError::SECURITY_ERR, ec);
return;
}
m_readyState = WRITING;
m_bytesWritten = 0;
m_bytesToWrite = 0;
m_truncateLength = position;
ASSERT(m_queuedOperation == OperationNone);
if (m_operationInProgress != OperationNone) {
// We must be waiting for an abort to complete, since m_readyState wasn't WRITING.
ASSERT(m_operationInProgress == OperationAbort);
m_queuedOperation = OperationTruncate;
} else
doOperation(OperationTruncate);
fireEvent(eventNames().writestartEvent);
}
void doActivities()
{
setNum1(4545);
setNum2(5);
setOperation(8);
getResult();
doOperation(10, 51, MYCALC_ADD);
setNum1(4545);
setNum2(5);
setOperation(MYCALC_DIV);
getResult();
doOperation(740, -4551, MYCALC_MUL);
}
void MainWindow::on_actionResizeMap_triggered(){
if(!map.isLoaded())return;
DialogResizeMap dlg(map.getWidth(),map.getHeight());
if(dlg.exec()!=QDialog::Accepted)return;
MoResizeMap mo(dlg.mapWidth,dlg.mapHeight,dlg.hAlign,dlg.vAlign);
mo.toolTip=tr("Resize Map");
doOperation(&mo);
}
void FileWriter::completeAbort()
{
ASSERT(m_operationInProgress == OperationAbort);
m_operationInProgress = OperationNone;
Operation operation = m_queuedOperation;
m_queuedOperation = OperationNone;
doOperation(operation);
}
void FileWriter::stop()
{
// Make sure we've actually got something to stop, and haven't already called abort().
if (!writer() || m_readyState != WRITING)
return;
doOperation(OperationAbort);
m_readyState = DONE;
}
void MainWindow::editItemScripts(u8 itemId){
DialogScripts dlg(map.itemAt(itemId).scripts,this);
dlg.setWindowTitle(QString(tr("Scripts for item#%1")).arg(itemId));
if(dlg.exec()==QDialog::Accepted){
MoEditItemScript mo(dlg.scripts,itemId);
mo.toolTip=QString(tr("Edit Scripts for item#%1")).arg(itemId);
doOperation(&mo);
}
}
void FileWriter::completeAbort()
{
ASSERT(m_operationInProgress == OperationAbort);
m_operationInProgress = OperationNone;
Operation operation = m_queuedOperation;
m_queuedOperation = OperationNone;
doOperation(operation);
unsetPendingActivity(this);
}
void forEach(ArrayUtil source, OperationFunc* doOperation, void* hint){
void *sourceItem = source.base;
void *end = source.base + (source.length * source.typeSize);
for( ; sourceItem != end; ){
doOperation(hint, sourceItem);
sourceItem += source.typeSize;
}
}
void FileWriter::abort(ExceptionCode& ec)
{
ASSERT(writer());
if (m_readyState != WRITING)
return;
++m_numAborts;
doOperation(OperationAbort);
signalCompletion(FileError::ABORT_ERR);
}
void onQNetworkReplyFinished() {
// either error or all data has been read
DEBUG("httpFinished()");
QVariant redirectionTarget = qreply->attribute(QNetworkRequest::RedirectionTargetAttribute);
if (!redirectionTarget.isNull())
{
QUrl newUrl = url.resolved(redirectionTarget.toUrl());
DEBUG("Handled redirect to: " << newUrl.toString());
qreply->deleteLater();
qreply = nullptr;
doOperation(newUrl);
return;
}
else if (qreply->error())
{
WARN("HTTP ERROR: " << qreply->errorString());
result << InvocationErrors::INVOCATION_FAILED;
QVariant statusCode = qreply->attribute( QNetworkRequest::HttpStatusCodeAttribute );
if (statusCode.isValid()) {
httpStatus = HTTPInvocationDefinition::resolveHttpStatus(statusCode.toInt());
} else {
httpStatus = HTTPInvocationDefinition::UNDEFINED;
result << Result::reasonFromDesc("Http response code is not valid");
}
invocationStatus = Invocation::ERROR;
// get possible return data (detailed error info)
// responseErrorData = qreply->readAll();
result << InvocationErrors::CONNECTION_FAILED
<< Result::Meta("qnetworkreply_error_string", qreply->errorString());
QNetworkReply::NetworkError err = qreply->error();
result << NetworkErrorReasons::from(err, qreply->errorString());
//result << Result::reasonFromCode("QNETWORKREPLY_ERROR", qreply->errorString());
emit q->finishedError(q);
}
else
{
// we have all data
// (TODO: is it so that readRead() is invoked before?)
if (outputFile.isOpen())
outputFile.close();
invocationStatus = Invocation::FINISHED;
emit q->finishedOK(q);
}
qreply->deleteLater();
qreply = nullptr;
}
//
// operation
//
void
GeneratorBase::handleOperation(IR__::InterfaceDef_ptr intf)
{
IR__::ContainedSeq_var contained_seq = intf->contents(CORBA__::dk_Operation, false);
CORBA::ULong len = contained_seq->length();
for(CORBA::ULong i = 0; i < len; i++)
{
IR__::OperationDef_var a_operation = IR__::OperationDef::_narrow(((*contained_seq)[i]));
doOperation(a_operation);
}
}
void MainWindow::on_buttonItemDelete_clicked()
{
if(!map.isLoaded())return;
QModelIndex selection=ui->itemTable->currentIndex();
if(!selection.isValid())return;
u8 selItem=selection.row();
if(selItem>=map.getItemCount())return;
MoDeleteItem mo(selItem);
mo.toolTip=QString(tr("Remove Item#%1")).arg(selItem);
doOperation(&mo);
}
void MainWindow::on_actionMapProperties_triggered()
{
if(!map.isLoaded()){
return;
}
DialogProperties dlg(map.metaData);
if(QDialog::Accepted==dlg.exec()){
MoEditMetaData mo(dlg.metaData);
mo.toolTip=tr("Change Properties");
doOperation(&mo);
}
}
void MainWindow::on_buttonItemDown_clicked()
{
if(!map.isLoaded())return;
QModelIndex selection=ui->itemTable->currentIndex();
if(!selection.isValid())return;
u8 selItem=selection.row();
if(selItem==map.getItemCount()-1)return;
if(selItem>=map.getItemCount())return;
MoSwapItem mo(selItem);
mo.toolTip=QString(tr("Move down Item#%1")).arg(selItem);
doOperation(&mo);
ui->itemTable->setCurrentIndex(itemTableModal.getIndex(selItem+1,selection.column()));
}
void MainWindow::on_buttonItemNew_clicked()
{
if(!map.isLoaded())return;
KfMap::RipeItem item;
QSize size=ui->mapViewScrollArea->size();
int tx=(ui->mapViewScrollArea->horizontalScrollBar()->value()+size.width()/2);
item.basic.x=(tx>=0?tx:0);
int ty=(ui->mapViewScrollArea->verticalScrollBar()->value()+size.height()/2);
item.basic.y=(ty>=0?ty:0);
if(item.basic.x>map.getWidth()*24)item.basic.x=map.getWidth()*24;
if(item.basic.y>map.getHeight()*24)item.basic.y=map.getHeight()*24;
MoNewItem mo(map.getItemCount(),item);
mo.toolTip=tr("Add Item");
doOperation(&mo);
ui->itemTable->setCurrentIndex(itemTableModal.getIndex(
map.getItemCount()-1,0));
}
double Parser::evaluatePostFix(const std::string &input, bool& failed)
{
std::queue<std::string> postFix = createPostFix(input,failed);
std::stack<double> numbers;
std::string debug;
std::string mainQuery = input;
double result = 0;
double firstNumber = 0;
double secondNumber = 0;
bool overflow = false;
while(!postFix.empty() && !overflow && !failed)
{
debug = postFix.front();
if(isdigit(postFix.front()[0]) || postFix.front()[0] == '#')
{
numbers.push(convertStringToNumber(postFix.front(), failed));
postFix.pop();
}
else //is an operator
{
if(numbers.size() >= 2) {
secondNumber = numbers.top();
numbers.pop();
firstNumber = numbers.top();
numbers.pop();
result = doOperation(firstNumber, secondNumber, postFix.front().c_str()[0], overflow); //all operators are 1 charater
failed = overflow;
postFix.pop();
numbers.push(result);
}
else {
failed = true;
errorCode_ = ERR_SYNTAX;
}
}
}
if(!numbers.empty()) {
return numbers.top();
}
else {
failed = true;
errorCode_ = ERR_SYNTAX;
return 0;
}
}
/*
** Konverzní funkce infix2postfix.
** Ète infixový výraz ze vstupního øetìzce infExpr a generuje
** odpovídající postfixový výraz do výstupního øetìzce (postup pøevodu
** hledejte v pøedná¹kách nebo ve studijní opoøe). Pamì» pro výstupní øetìzec
** (o velikosti MAX_LEN) je tøeba alokovat. Volající funkce, tedy
** pøíjemce konvertovaného øetìzce, zajistí korektní uvolnìní zde alokované
** pamìti.
**
** Tvar výrazu:
** 1. Výraz obsahuje operátory + - * / ve významu sèítání, odèítání,
** násobení a dìlení. Sèítání má stejnou prioritu jako odèítání,
** násobení má stejnou prioritu jako dìlení. Priorita násobení je
** vìt¹í ne¾ priorita sèítání. V¹echny operátory jsou binární
** (neuva¾ujte unární mínus).
**
** 2. Hodnoty ve výrazu jsou reprezentovány jednoznakovými identifikátory
** a èíslicemi - 0..9, a..z, A..Z (velikost písmen se rozli¹uje).
**
** 3. Ve výrazu mù¾e být pou¾it pøedem neurèený poèet dvojic kulatých
** závorek. Uva¾ujte, ¾e vstupní výraz je zapsán správnì (neo¹etøujte
** chybné zadání výrazu).
**
** 4. Ka¾dý korektnì zapsaný výraz (infixový i postfixový) musí být uzavøen
** ukonèovacím znakem '='.
**
** 5. Pøi stejné prioritì operátorù se výraz vyhodnocuje zleva doprava.
**
** Poznámky k implementaci
** -----------------------
** Jako zásobník pou¾ijte zásobník znakù tStack implementovaný v pøíkladu c202.
** Pro práci se zásobníkem pak pou¾ívejte výhradnì operace z jeho rozhraní.
**
** Pøi implementaci vyu¾ijte pomocné funkce untilLeftPar a doOperation.
**
** Øetìzcem (infixového a postfixového výrazu) je zde my¹leno pole znakù typu
** char, jen¾ je korektnì ukonèeno nulovým znakem dle zvyklostí jazyka C.
**
** Na vstupu oèekávejte pouze korektnì zapsané a ukonèené výrazy. Jejich délka
** nepøesáhne MAX_LEN-1 (MAX_LEN i s nulovým znakem) a tedy i výsledný výraz
** by se mìl vejít do alokovaného pole. Po alokaci dynamické pamìti si v¾dycky
** ovìøte, ¾e se alokace skuteènì zdraøila. V pøípadì chyby alokace vra»te namísto
** øetìzce konstantu NULL.
*/
char* infix2postfix (const char* infExpr) {
char *postExpr = malloc(MAX_LEN * sizeof(char));
unsigned postLen = 0;
tStack stack;
stackInit(&stack);
char tmp;
for(unsigned i = 0; (tmp = infExpr[i]) != '='; i++) {
switch(tmp) {
case '+':
case '-':
case '*':
case '/':
// Zpracuj operator
doOperation(&stack, tmp, postExpr, &postLen);
break;
case '(':
// Pridaj lavu zatvorku do zasobniku.
stackPush(&stack, '(');
break;
case ')':
// Zpracuj pravu zatvorku.
untilLeftPar(&stack, postExpr, &postLen);
break;
default:
// Zpracuj hodnotu.
// isalnum()
if((tmp >= '0' && tmp <='9') || (tmp >= 'a' && tmp <= 'z') || (tmp >= 'A' && tmp <= 'Z'))
postExpr[postLen++] = tmp;
break;
}
}
while(!stackEmpty(&stack)) {
stackTop(&stack, &tmp);
postExpr[postLen++] = tmp;
stackPop(&stack);
}
postExpr[postLen++] = '=';
postExpr[postLen] = '\0';
return postExpr;
}
void MainWindow::on_actionImportMap_triggered()
{
if(!map.isLoaded())return;
QString fileName=QFileDialog::getOpenFileName(this, tr("Import map from..."),
"",
tr("Binary file(*.bin)"));
if(fileName==QString::null)return;
QFile file(fileName);
if(!file.open(QIODevice::ReadOnly)){
QMessageBox msgBox;
msgBox.setText(tr("Failed to open the file."));
msgBox.setIcon(QMessageBox::Icon::Critical);
msgBox.exec();
return;
}
const uchar* src=file.map(0,file.size());
if(std::memcmp(src,exportMapMagic,4)!=0){
QMessageBox msgBox;
msgBox.setText(tr("The file is not a map."));
msgBox.setIcon(QMessageBox::Icon::Critical);
msgBox.exec();
return;
}
int importRoomId;
memcpy(&importRoomId,src+4,4);
if(importRoomId!=curRoomId){
QMessageBox msgBox;
msgBox.setText(tr("The index of the map being imported is not equal to current map's, "
"and they probably use different block sets.\n"
"Do you still want to import this map?"));
msgBox.setIcon(QMessageBox::Icon::Warning);
msgBox.setStandardButtons(QMessageBox::Yes|QMessageBox::No);
msgBox.setDefaultButton(QMessageBox::No);
if(msgBox.exec()!=QMessageBox::Yes)return;
}
KfMap importMap;
importMap.readFile(src+8);
MoPasteMap pasteMap(importMap);
pasteMap.toolTip=tr("Import Map");
doOperation(&pasteMap);
}
bool RDOSimulatorBase::rdoNext()
{
if (m_mode == RTM_Pause || m_mode == RTM_BreakPoint)
{
boost::this_thread::sleep(boost::posix_time::milliseconds(1));
return true;
}
// Если нажата клавиша или активная область, то задержки надо проскачить
bool keyboard = isKeyDown();
if (!keyboard)
{
// Задержка общей скорости моделирования
// Это mode == RTM_Jump || mode == RTM_Sync
if (m_mode != RTM_MaxSpeed && m_next_delay_count)
{
++m_next_delay_current;
if (m_next_delay_current < m_next_delay_count) return true;
m_next_delay_current = 0;
}
// Задержка синхронной скорости моделирования (длительность операций)
// Тут не надо проверять mode == RTM_Sync, т.к. это уже заложено в msec_wait,
// который сбрасывается в setMode и не изменяется далее.
if (m_msec_wait > 1)
{
boost::posix_time::ptime systime_current = boost::posix_time::microsec_clock::local_time();
std::size_t msec_curr = getMSec(systime_current);
std::size_t msec_delta;
// Милисекунды считаются с учетом часов, но при смене суток часы сбрасываются на ноль,
// и текущее время в милисекундах становится меньше предыдущего. Учитываем этот момент
// через ветку ELSE. Теперь система сможет учесть переход на один день вперед между
// двумя соседники моментами времени, но не сможет учесть на два и более дня. Это
// является маразматической ситуаций (ждать слудующего события два дня), но запросто
// может потребоваться в системе мониторинга реального времени, которая работает в
// автоматическом режиме, обрабатывая информацию с контроллеров. РДО это делать не умеет.
// Как решение - отказ от синхронной работы в таких системах, и учет только скорости, или
// переход на работу с календарем дней, месяцев и лет. SYSTEMTIME содержит такую информацию.
if (msec_curr >= m_msec_prev)
{
msec_delta = msec_curr - m_msec_prev;
}
else
{
msec_delta = UINT_MAX - m_msec_prev + msec_curr;
}
if (msec_delta <= m_msec_wait) return true;
m_msec_wait -= msec_delta;
}
}
// Окончание моделирования - сработало событие конца
if (endCondition())
{
onEndCondition();
return false;
}
if (m_currentTime != m_nextTime)
{
m_currentTime = m_nextTime;
onNewTimeNow();
}
// Выполнение операции
if (doOperation())
{
if (breakPoints())
{
setMode(RTM_BreakPoint);
}
return true;
}
else
{
// Переход к следующей операции
if (!m_timePoints.empty())
{
BOPlannedMap::iterator begin = m_timePoints.begin();
double newTime = begin->first;
const BOPlannedList& list = begin->second;
if (list.empty())
{
m_timePoints.erase(begin);
}
if (m_currentTime > newTime)
{
newTime = m_currentTime;
}
if (m_mode == RTM_Sync)
{
m_msec_wait += (newTime - m_nextTime) * 3600.0 * 1000.0 / m_showRate;
if (m_msec_wait > 0)
{
if (newTime != m_startTime)
{
if (m_speed > DBL_MIN)
{
m_msec_wait = m_msec_wait / m_speed;
}
else
{
m_msec_wait = m_msec_wait / DBL_MIN;
}
boost::posix_time::ptime systime_current = boost::posix_time::microsec_clock::local_time();
m_msec_prev = getMSec(systime_current);
}
else
{
m_msec_wait = 0;
}
}
}
m_nextTime = newTime;
return true;
}
else
{
// Окончание моделирования - нет больше событий
onNothingMoreToDo();
return false;
}
}
}
void doOperation(F&& func)
{
doOperation(std::forward<F>(func), detail::gen_seq<N>());
}
void httpFinished() {
DEBUG("httpFinished()");
QVariant redirectionTarget = qreply->attribute(QNetworkRequest::RedirectionTargetAttribute);
if (!redirectionTarget.isNull())
{
QUrl newUrl = url.resolved(redirectionTarget.toUrl());
DEBUG("Handled redirect to: " << newUrl.toString());
qreply->deleteLater();
qreply = nullptr;
doOperation(newUrl);
return;
}
else if (qreply->error())
{
WARN("HTTP ERROR:" << qreply->error() << qreply->errorString());
httpStatus = HTTPInvocationDefinition::UNDEFINED;
invocationStatus = Invocation::ERROR;
result << InvocationErrors::CONNECTION_FAILED
<< Result::Meta("qnetworkreply_error_string", qreply->errorString())
<< Result::Meta("qnetworkreply_error_number", qreply->error());
QNetworkReply::NetworkError err = qreply->error();
result << NetworkErrorReasons::from(err, qreply->errorString());
// get possible return data
replyData = qreply->readAll();
if (!replyData.isEmpty())
result << Result::Meta("response_data", replyData);
emit q->finishedError(q);
}
else
{
// we have data
replyData = qreply->readAll();
QVariant statusCode = qreply->attribute( QNetworkRequest::HttpStatusCodeAttribute );
if (statusCode.isValid())
{
// TODO: handle more codes!
switch (statusCode.toInt())
{
case 200:
httpStatus = HTTPInvocationDefinition::OK_200;
break;
default:
httpStatus = HTTPInvocationDefinition::UNDEFINED;
}
} else {
result << InvocationErrors::INVOCATION_FAILED
<< Result::reasonFromDesc("Invalid http status code");
}
invocationStatus = Invocation::RESPONSE_RECEIVED;
TRACE("DATA:" << replyData);
emit q->finishedOK(q);
}
qreply->deleteLater();
qreply = nullptr;
}
void doOperation() {
doOperation(invocationFactory->buildUrl(def.invocationPath(), params));
}
/*
** Konverzní funkce infix2postfix.
** Ète infixový výraz ze vstupního øetìzce infExpr a generuje
** odpovídající postfixový výraz do výstupního øetìzce (postup pøevodu
** hledejte v pøedná¹kách nebo ve studijní opoøe). Pamì» pro výstupní øetìzec
** (o velikosti MAX_LEN) je tøeba alokovat. Volající funkce, tedy
** pøíjemce konvertovaného øetìzce, zajistí korektní uvolnìní zde alokované
** pamìti.
**
** Tvar výrazu:
** 1. Výraz obsahuje operátory + - * / ve významu sèítání, odèítání,
** násobení a dìlení. Sèítání má stejnou prioritu jako odèítání,
** násobení má stejnou prioritu jako dìlení. Priorita násobení je
** vìt¹í ne¾ priorita sèítání. V¹echny operátory jsou binární
** (neuva¾ujte unární mínus).
**
** 2. Hodnoty ve výrazu jsou reprezentovány jednoznakovými identifikátory
** a èíslicemi - 0..9, a..z, A..Z (velikost písmen se rozli¹uje).
**
** 3. Ve výrazu mù¾e být pou¾it pøedem neurèený poèet dvojic kulatých
** závorek. Uva¾ujte, ¾e vstupní výraz je zapsán správnì (neo¹etøujte
** chybné zadání výrazu).
**
** 4. Ka¾dý korektnì zapsaný výraz (infixový i postfixový) musí být uzavøen
** ukonèovacím znakem '='.
**
** 5. Pøi stejné prioritì operátorù se výraz vyhodnocuje zleva doprava.
**
** Poznámky k implementaci
** -----------------------
** Jako zásobník pou¾ijte zásobník znakù tStack implementovaný v pøíkladu c202.
** Pro práci se zásobníkem pak pou¾ívejte výhradnì operace z jeho rozhraní.
**
** Pøi implementaci vyu¾ijte pomocné funkce untilLeftPar a doOperation.
**
** Øetìzcem (infixového a postfixového výrazu) je zde my¹leno pole znakù typu
** char, jen¾ je korektnì ukonèeno nulovým znakem dle zvyklostí jazyka C.
**
** Na vstupu oèekávejte pouze korektnì zapsané a ukonèené výrazy. Jejich délka
** nepøesáhne MAX_LEN-1 (MAX_LEN i s nulovým znakem) a tedy i výsledný výraz
** by se mìl vejít do alokovaného pole. Po alokaci dynamické pamìti si v¾dycky
** ovìøte, ¾e se alokace skuteènì zdraøila. V pøípadì chyby alokace vra»te namísto
** øetìzce konstantu NULL.
*/
char* infix2postfix (const char* infExpr) {
char *postExpr;
unsigned postLen = 0;
int stringSize;
tStack *s;
// alokace vystupniho retezce
if ((postExpr = (char *) malloc(MAX_LEN)) == NULL) {
return NULL;
}
// alokace zasobniku
if ((s = malloc(sizeof(char *) * STACK_SIZE)) == NULL) {
free(postExpr);
return NULL;
}
// inicializace zasobniku
stackInit(s);
// zjisteni delky retezce
stringSize = snprintf(NULL, 0, "%s", infExpr);
// zpracovani retezce
for (unsigned i = 0; i <= stringSize; i++) {
if (
(infExpr[i] >= '0' && infExpr[i] <= '9') ||
(infExpr[i] >= 'A' && infExpr[i] <= 'Z') ||
(infExpr[i] >= 'a' && infExpr[i] <= 'z')
) {
// nacteni alfanumerickeho znaku do vystupniho retezce
postExpr[postLen] = infExpr[i];
postLen++;
} else if (infExpr[i] == '(') {
// je-li zpracovana polozka leva zavorka, umistim na
// vrchol zasobniku
stackPush(s, infExpr[i]);
} else if (infExpr[i] == ')') {
// Je-li zpracovávanou polo¾kou pravá závorka,
// odebíram z vrcholu zasobniku polo¾ky a dávam
// na konec výstupního øetìzce a¾ narazim na levou
// závorku.
untilLeftPar(s, postExpr, &postLen);
} else if (infExpr[i] == '=') {
// Je-li zpracovávanou polo¾kou '=', pak postupnì
// odstraòuju prvky z vrcholu zásobníku a pøidávam na
// konec øetìzce, a¾ se zásobník zcela vyprázdní.
// Na konec se pøidá rovnítko, jako omezovaè výrazu.
while (!stackEmpty(s)) {
stackTop(s, &postExpr[postLen]);
postLen++;
stackPop(s);
}
postExpr[postLen] = '=';
postLen++;
postExpr[postLen] = '\0';
} else {
// zpracovani operatoru
doOperation(s, infExpr[i], postExpr, &postLen);
}
}
free(s);
return postExpr;
}
/**
* \brief 触发一个技能[SKY技能触发]
* \param rev 本次收到的客户端消息
* \param cmdLen 消息长度
* \return true 技能使用成功 false 技能使用失败
*/
bool zSkill::action(const Cmd::stAttackMagicUserCmd *rev,const DWORD cmdLen)
{
if (_entry)
{
actionbase = getNewBase();
curRevCmd = rev;
curRevCmdLen = cmdLen;
//sky SKILLID_IMMOLATE 献祭技能的ID
if(rev->wdMagicType == SKILLID_IMMOLATE && _entry->Immolate)
{
_entry->skillStatusM.clearSkill(rev->wdMagicType);
return true;
}
// 消耗
if (this->istemp||_entry->needWeapon(curRevCmd->wdMagicType)) // 检查施放技能是否需要武器
{
if (actionbase->ride==0)
{
if (_entry->checkMountHorse()) return false;
}
if (_entry->checkSkillCost(actionbase)) // 计算自身各种消耗
{
if (_entry->checkPercent()) // 判断技能施放成功的几率
{
std::vector<SkillStatus>::const_iterator iter;
if (_entry->checkReduce(actionbase->objcost,actionbase->objnum))
{
showMagicToAll();
switch(rev->wdMagicType)
{
case 226: // 食尸术
case 319: // 尸暴术
{
SceneNpc *pNpc = SceneNpcManager::getMe().getNpcByTempID(rev->dwDefenceTempID);
if (pNpc)
{
if (pNpc->getState() == zSceneEntry::SceneEntry_Death && !pNpc->isUse)
{
pNpc->isUse = true;
Cmd::stRemoveMapNpcMapScreenUserCmd removeNpc;
removeNpc.dwMapNpcDataPosition = rev->dwDefenceTempID;
pNpc->scene->sendCmdToNine(pNpc->getPosI(),&removeNpc,sizeof(removeNpc),pNpc->dupIndex);
}
else
{
return false;
}
}
else
{
return false;
}
}
break;
default:
break;
}
_entry->doSkillCost(actionbase);
for(iter = actionbase->skillStatus.begin(); iter != actionbase->skillStatus.end(); iter ++)
{
// 处理依赖消耗物品型技能对物品的消耗,目前此接口未启用,两个参数分别是物品ID和消耗数量
{
SkillStatus *pSkillStatus = (SkillStatus *)&*iter;
doOperation(pSkillStatus);
}
}
_entry->reduce(actionbase->objcost,actionbase->objnum);
return true;
}
}
}
}
}
else
{
Zebra::logger->error("学习的技能中_entry指针为空");
}
return false;
}
//
// home
//
void
GeneratorBase::doHome(IR__::HomeDef_ptr home)
{
beginHome(home);
IR__::ContainedSeq_var contained_seq;
CORBA::ULong len;
CORBA::ULong i;
// contained constants
contained_seq = home->contents(CORBA__::dk_Constant, false);
len = contained_seq->length();
for(i = 0; i < len; i++)
{
IR__::ConstantDef_var act_constant = IR__::ConstantDef::_narrow(((*contained_seq)[i]));
doConstant(act_constant);
}
// contained typedefs
contained_seq = home->contents(CORBA__::dk_Typedef, false);
len = contained_seq->length();
for(i = 0; i < len; i++)
{
IR__::TypedefDef_var act_typedef = IR__::TypedefDef::_narrow(((*contained_seq)[i]));
doTypedef(act_typedef);
}
// contained exceptions
contained_seq = home->contents(CORBA__::dk_Exception, false);
len = contained_seq->length();
for(i = 0; i < len; i++)
{
IR__::ExceptionDef_var act_exception = IR__::ExceptionDef::_narrow(((*contained_seq)[i]));
doException(act_exception);
}
// contained attributes
contained_seq = home->contents(CORBA__::dk_Attribute, false);
len = contained_seq->length();
for(i = 0; i < len; i++)
{
IR__::AttributeDef_var act_attribute = IR__::AttributeDef::_narrow(((*contained_seq)[i]));
doAttribute(act_attribute);
}
// contained operations
contained_seq = home->contents(CORBA__::dk_Operation, false);
len = contained_seq->length();
for(i = 0; i < len; i++)
{
IR__::OperationDef_var act_operation = IR__::OperationDef::_narrow(((*contained_seq)[i]));
doOperation(act_operation);
}
// contained factories
contained_seq = home->contents(CORBA__::dk_Factory, false);
len = contained_seq->length();
for(i = 0; i < len; i++)
{
IR__::FactoryDef_var act_factory = IR__::FactoryDef::_narrow(((*contained_seq)[i]));
doFactory(act_factory);
}
// contained finders
contained_seq = home->contents(CORBA__::dk_Finder, false);
len = contained_seq->length();
for(i = 0; i < len; i++)
{
IR__::FinderDef_var act_finder = IR__::FinderDef::_narrow(((*contained_seq)[i]));
doFinder(act_finder);
}
endHome(home);
}
