//04 void sto() { stack[getBase(ir.l, bp) + ir.m] = stack[sp]; sp = sp-1; }
std::string empathy::getAssetPath(std::string dir) { return join_path(getBase(),join_path("assets",dir)); }
void WalkerPrefect::onMidTile() { ReachedBuildings reachedBuildings; TilePos firePos; bool haveBurningRuinsNear = _looks4Fire( reachedBuildings, firePos ); bool isDestination = _getPathway().isDestination(); switch( _d->action ) { case Impl::doNothing: break; case Impl::patrol: { if( haveBurningRuinsNear ) { //tell our prefecture that need send prefect with water to fight with fire //on next deliverService //found fire, no water, go prefecture getBase().as<Prefecture>()->fireDetect( firePos ); _back2Prefecture(); Walker::onNewDirection(); } else { foreach( BuildingPtr building, reachedBuildings ) { building->applyService( ServiceWalkerPtr( this ) ); HousePtr house = building.as<House>(); if( house.isValid() && house->getHealthLevel() < 1 ) { house->deleteLater(); GameEventMgr::append( DisasterEvent::create( house->getTilePos(), DisasterEvent::plague ) ); } } } if( isDestination ) { _back2Prefecture(); } Walker::onMidTile(); } break; case Impl::back2Prefecture: { if( haveBurningRuinsNear ) { //tell our prefecture that need send prefect with water to fight with fire //on next deliverService getBase().as<Prefecture>()->fireDetect( firePos ); } if( isDestination ) { deleteLater(); _d->action = Impl::doNothing; } Walker::onMidTile(); } break; case Impl::gotoFire: { if( _getPathway().getDestination().getIJ().distanceFrom( getIJ() ) < 1.5f ) { LandOverlayPtr overlay = _getPathway().getDestination().getOverlay(); if( overlay.isValid() && overlay->getType() == B_BURNING_RUINS ) { _d->action = Impl::fightFire; _setGraphic( WG_PREFECT_FIGHTS_FIRE ); Walker::onNewDirection(); isDestination = false; } } if( isDestination ) { if( !haveBurningRuinsNear || _d->water == 0 ) { _back2Prefecture(); } else { _setGraphic( WG_PREFECT_DRAG_WATER ); _d->action = Impl::gotoFire; _checkPath2NearestFire( reachedBuildings ); Walker::onNewDirection(); } } Walker::onMidTile(); } break; case Impl::fightFire: break; }
uint32 ReduceParams::cflInit(const SharedContext& ctx) const { return cflSched.disabled() ? 0 : getLimit(getBase(ctx), fInit, initRange); }
void RenderMathMLRoot::layoutBlock(bool relayoutChildren, LayoutUnit) { ASSERT(needsLayout()); if (!relayoutChildren && simplifiedLayout()) return; updateStyle(); m_radicalOperatorTop = 0; m_baseWidth = 0; if (!isValid()) { setLogicalWidth(0); setLogicalHeight(0); clearNeedsLayout(); return; } // We layout the children, determine the vertical metrics of the base and set the logical width. // Note: Per the MathML specification, the children of <msqrt> are wrapped in an inferred <mrow>, which is the desired base. LayoutUnit baseAscent, baseDescent; recomputeLogicalWidth(); if (m_kind == SquareRoot) { baseAscent = baseDescent; RenderMathMLRow::computeLineVerticalStretch(baseAscent, baseDescent); RenderMathMLRow::layoutRowItems(baseAscent, baseDescent); m_baseWidth = logicalWidth(); } else { getBase().layoutIfNeeded(); m_baseWidth = getBase().logicalWidth(); baseAscent = ascentForChild(getBase()); baseDescent = getBase().logicalHeight() - baseAscent; getIndex().layoutIfNeeded(); } // Stretch the radical operator to cover the base height. // We can then determine the metrics of the radical operator + the base. m_radicalOperator.stretchTo(style(), baseAscent + baseDescent); LayoutUnit radicalOperatorHeight = m_radicalOperator.ascent() + m_radicalOperator.descent(); LayoutUnit indexBottomRaise = m_degreeBottomRaisePercent * radicalOperatorHeight; LayoutUnit radicalAscent = baseAscent + m_verticalGap + m_ruleThickness + m_extraAscender; LayoutUnit radicalDescent = std::max<LayoutUnit>(baseDescent, radicalOperatorHeight + m_extraAscender - radicalAscent); LayoutUnit descent = radicalDescent; LayoutUnit ascent = radicalAscent; // We set the logical width. if (m_kind == SquareRoot) setLogicalWidth(m_radicalOperator.width() + m_baseWidth); else { ASSERT(m_kind == RootWithIndex); setLogicalWidth(m_kernBeforeDegree + getIndex().logicalWidth() + m_kernAfterDegree + m_radicalOperator.width() + m_baseWidth); } // For <mroot>, we update the metrics to take into account the index. LayoutUnit indexAscent, indexDescent; if (m_kind == RootWithIndex) { indexAscent = ascentForChild(getIndex()); indexDescent = getIndex().logicalHeight() - indexAscent; ascent = std::max<LayoutUnit>(radicalAscent, indexBottomRaise + indexDescent + indexAscent - descent); } // We set the final position of children. m_radicalOperatorTop = ascent - radicalAscent + m_extraAscender; LayoutUnit horizontalOffset = m_radicalOperator.width(); if (m_kind == RootWithIndex) horizontalOffset += m_kernBeforeDegree + getIndex().logicalWidth() + m_kernAfterDegree; LayoutPoint baseLocation(mirrorIfNeeded(horizontalOffset, m_baseWidth), ascent - baseAscent); if (m_kind == SquareRoot) { for (auto* child = firstChildBox(); child; child = child->nextSiblingBox()) child->setLocation(child->location() + baseLocation); } else { ASSERT(m_kind == RootWithIndex); getBase().setLocation(baseLocation); LayoutPoint indexLocation(mirrorIfNeeded(m_kernBeforeDegree, getIndex()), ascent + descent - indexBottomRaise - indexDescent - indexAscent); getIndex().setLocation(indexLocation); } setLogicalHeight(ascent + descent); clearNeedsLayout(); }
QString SimpleType::generateSetter(QString inputString, QString outputVariable) { return ((SimpleType*) getBase())->generateSetter(inputString, outputVariable); }
void CANMessageObject::clear() { CANMessageClear(getBase(), _mob_num); get(false); }
void LevelCalculator::getTradeRequestFromSynthSymbol( MultuSymbolRequestEntryList& reqList, CppUtils::String const& synthSymbol, BrkLib::TradeDirection const td, int const volume ) { reqList.clear(); LOG(MSG_DEBUG, SOLVERIMPL, "Evaluating volume coefficients for synth symbol: " << synthSymbol ); map<CppUtils::String, CppUtils::Parser*>::iterator it = parsers_m.find(synthSymbol); if (it == parsers_m.end()) THROW(CppUtils::OperationFailed, "exc_ParserNotRegistered", "ctx_getTradeRequestFromSynthSymbol", synthSymbol ); CppUtils::StringMap const& smartcom_symbols_reverse = getBase().getSmartcomSymbolsReverse(); CppUtils::Parser & parser = *it->second; // need to get cooeficients in formula // // iterate through all reverse symbols for( CppUtils::StringMap::const_iterator it = smartcom_symbols_reverse.begin(); it != smartcom_symbols_reverse.end(); it++) { CppUtils::String const& symbol_pseudonym = it->first; CppUtils::String const& symbol_real = it->second; parser.ClearBind(); for( CppUtils::StringMap::const_iterator it2 = smartcom_symbols_reverse.begin(); it2 != smartcom_symbols_reverse.end(); it2++) { CppUtils::String const& symbol_pseudonym_2 = it2->first; if (symbol_pseudonym == symbol_pseudonym_2) parser[symbol_pseudonym_2] = 1; else parser[symbol_pseudonym_2] = 0; } // evaluate here try { double volume_coeff = parser.Evaluate(); // setup MultuSymbolRequestEntry reqEntry; reqEntry.symbol_m = symbol_real; reqEntry.direction_m = td; reqEntry.volume_m = abs(volume * (int)volume_coeff); if (td == BrkLib::TD_LONG) { if (volume_coeff < 0) reqEntry.direction_m = BrkLib::TD_SHORT; else if (volume_coeff > 0) reqEntry.direction_m = BrkLib::TD_LONG; else THROW(CppUtils::OperationFailed, "exc_VolumeCannotBeZero", "ctx_getTradeRequestFromSynthSymbol", ""); } else if (td == BrkLib::TD_SHORT) { if (volume_coeff < 0) reqEntry.direction_m = BrkLib::TD_LONG; else if (volume_coeff > 0) reqEntry.direction_m = BrkLib::TD_SHORT; else THROW(CppUtils::OperationFailed, "exc_VolumeCannotBeZero", "ctx_getTradeRequestFromSynthSymbol", ""); } else THROW(CppUtils::OperationFailed, "exc_DirectionTradeInvalid", "ctx_getTradeRequestFromSynthSymbol", ""); reqList.push_back(reqEntry); LOG(MSG_DEBUG, SOLVERIMPL, "Added request entry: " << reqEntry.toString() << "for synthetic symbol: " << synthSymbol << "( pseudonym: " << symbol_pseudonym << ")"); } catch(std::exception& e) { THROW(CppUtils::OperationFailed, "exc_ParserError", "ctx_getTradeRequestFromSynthSymbol", e.what()); } // resolve } }
void LevelCalculator::onRtData(HlpStruct::RtData const& rtdata,CalcContext* ctx) { // need to extract symbols // calculate synthetic if any if (getBase().getBase().getBarDataProvider_Smartcom() != rtdata.getProvider2()) return; CppUtils::StringMap const& smartcom_symbols = getBase().getSmartcomSymbols(); CppUtils::StringSet const& synthetic_symbols = getBase().getSyntheticSmartcomSymbols(); if (!initialized_m) { // iterate through all synbols and cache them for(CppUtils::StringMap::const_iterator it = smartcom_symbols.begin(); it != smartcom_symbols.end(); it++) { CppUtils::String const& symbol_i = it->first; int id = ctx->historyaccessorPtr->cacheSymbol( getBase().getBase().getBarDataProvider_Smartcom(), symbol_i, HlpStruct::AP_Minute, getBase().getTradeParam().tradePeriodMinutes_m); cache_ids_m[ symbol_i ] = id; dataset_m.registerSymbol( symbol_i ); } LOG(MSG_INFO, SOLVERIMPL, "Initialized all" ); initialized_m = true; //flag_m = 0; } int fastPer = getBase().getTradeParam().maFastPeriod_m; int slowPer = getBase().getTradeParam().maSlowPeriod_m; int cachePer = max(fastPer, slowPer); // will raise on each symbol arrival map<CppUtils::String, int>::const_iterator it2 = cache_ids_m.find(rtdata.getSymbol2()); if (it2 == cache_ids_m.end()) return; int cache_id = it2->second; HlpStruct::PriceData const& unclosed = ctx->historyaccessorPtr->getUnclosedCandle(cache_id); if (unclosed.isNewPeriod()) { //LOG(MSG_INFO, SOLVERIMPL, "Unclosed symbol: " << rtdata.getSymbol() << " - " << unclosed.toString()); Inqueue::DataRowPtr rptr = ctx->historyaccessorPtr->dataRowLast(); int total_idx = cachePer*2; // clear dataset because we could chaise symbol from the past and need to recalculate everything dataset_m.clearData(); // iterate through all rows while( ctx->historyaccessorPtr->dataRowPrev(rptr)) { // get current price data if (total_idx-- < 0) break; // iterate through all symbols double ttime = ctx->historyaccessorPtr->getCurrentDataRowTime(rptr); for( map<CppUtils::String, int>::const_iterator it2 = cache_ids_m.begin(); it2 != cache_ids_m.end(); it2 ++) { CppUtils::String const& symbol_i = it2->first; HlpStruct::PriceData const& pdata = ctx->historyaccessorPtr->getCurrentDataRow(it2->second, rptr ); //LOG(MSG_INFO, SOLVERIMPL, "time: " << CppUtils::getGmtTime(ttime) << " symbol: " << symbol_i << " data: " << pdata.toString() ); if (pdata.isValid()) { dataset_m.addPriceData(symbol_i, pdata); } else { HlpStruct::PriceData pdata_prev = ctx->historyaccessorPtr->getCurrentDataRowTryLocatePrevValid( it2->second, rptr ); if (pdata_prev.isValid()) { //LOG(MSG_INFO, SOLVERIMPL, "time: " << CppUtils::getGmtTime(ttime) << " symbol: " << symbol_i << " Found prev data: " << pdata_prev.toString() ); dataset_m.addPriceDataAsImportedFromPast(ttime, symbol_i, pdata_prev.close2_m); } else { LOG(MSG_INFO, SOLVERIMPL, "time: " << CppUtils::getGmtTime(ttime) << " symbol: " << symbol_i << " Cannot find prev data" ); } } } // end iterating through symbols } // end loop through rows // log /* CppUtils::UnsignedLongLong tm_stamp = CppUtils::UnsignedLongLong(CppUtils::getTime() * 1000.0); CppUtils::String file = "c:\\temp\\data\\content_raw_i_" + CppUtils::long64ToString(tm_stamp) + ".txt"; CppUtils::saveContentInFile2(file, dataset_m.dump()); // debug dump file = "c:\\temp\\data\\content_debug_i_" + CppUtils::long64ToString(tm_stamp) + ".txt"; CppUtils::saveContentInFile2(file, ctx->historyaccessorPtr->makeDebugDump(true)); */ // because this stuff below is calculated for finished candles - time is contained in thel last row double row_ttime = -1; if (dataset_m.last()) { row_ttime = dataset_m.getTimeKey(); } typedef Math::MovAverMathEngineNoNegativePrice<Math::MultiSymbolCacheSeriesProvider> MaEngineType; // iterate through synthetic symbols for( set<CppUtils::String>::const_iterator i3 = synthetic_symbols.begin(); i3 != synthetic_symbols.end(); i3++) { CppUtils::String const& symbol_i3 = *i3; MaEngineType ma_channel_fast(fastPer); MaEngineType::Result res_ma_channel_fast = ctx->historyaccessorPtr->callMathEngineWithMultiSymbolCacheSeries< MaEngineType::Result, Math::P_CloseBid, MaEngineType >(dataset_m, *i3, ma_channel_fast); MaEngineType ma_channel_slow(slowPer); MaEngineType::Result res_ma_channel_slow = ctx->historyaccessorPtr->callMathEngineWithMultiSymbolCacheSeries< MaEngineType::Result, Math::P_CloseBid, MaEngineType >(dataset_m, *i3, ma_channel_slow); if (!res_ma_channel_slow.isValid_m) { //LOG(MSG_INFO, SOLVERIMPL, "Trading symbol: " << symbol_i3 << " time:" << CppUtils::getGmtTime(row_ttime) << " MA slow is invalid"); continue; } if (!res_ma_channel_fast.isValid_m) { //LOG(MSG_INFO, SOLVERIMPL, "Trading symbol: " << symbol_i3 << " time:" << CppUtils::getGmtTime(row_ttime) << " MA fast is invalid"); continue; } BrkLib::TradeDirection td = signalContextMap_m[symbol_i3].update(row_ttime, res_ma_channel_slow.result_m, res_ma_channel_fast.result_m); //LOG(MSG_INFO, SOLVERIMPL, "symbol: " << symbol_i3 << " time:" << CppUtils::getGmtTime(row_ttime) << " MA slow: " << res_ma_channel_slow << " MA fast: " << res_ma_channel_fast << ", result: " << BrkLib::tradeDirection2String(td)); // main notification DRAWOBJ_LINEINDIC_4( getBase().getBase().getRunName(), CppUtils::getTime(), "MA", symbol_i3, getBase().getBase().getBarDataProvider_Smartcom(), "MASLOW", res_ma_channel_slow.result_m, -1, "MAFAST", res_ma_channel_fast.result_m, -1, "ROW_TTIME", row_ttime, -1, "SIGNAL",td, -1 ); if (getBase().getTradeParam().synthSymbolToTrade_m.get() != symbol_i3) continue; LOG(MSG_INFO, SOLVERIMPL, "Trading symbol: " << symbol_i3 << " time:" << CppUtils::getGmtTime(row_ttime) << " MA slow: " << res_ma_channel_slow.result_m << " MA fast: " << res_ma_channel_fast.result_m << ", result: " << BrkLib::tradeDirection2String(td)); // make trading solution if (td == BrkLib::TD_LONG && ( getBase().getGlobalTradeContext().get().allowTrading_m == BrkLib::TD_BOTH || getBase().getGlobalTradeContext().get().allowTrading_m == BrkLib::TD_LONG ) ) { TE_Signal_Long e; getBase().getTradingMachine().processEvent<TE_Signal_Long>(e); } else if (td == BrkLib::TD_SHORT && ( getBase().getGlobalTradeContext().get().allowTrading_m == BrkLib::TD_BOTH || getBase().getGlobalTradeContext().get().allowTrading_m == BrkLib::TD_SHORT ) ) { TE_Signal_Short e; getBase().getTradingMachine().processEvent<TE_Signal_Short>(e); } /* if (flag_m == 0) { flag_m = 1; TE_Signal_Long e; getBase().getTradingMachine().processEvent<TE_Signal_Long>(e); } else { flag_m = 0; TE_Signal_Short e; getBase().getTradingMachine().processEvent<TE_Signal_Short>(e); } */ } // loop through suymbols /* CppUtils::UnsignedLongLong tm_stamp = CppUtils::UnsignedLongLong(CppUtils::getTime() * 1000.0); CppUtils::String file = "c:\\temp\\data\\content_allrows_i_" + CppUtils::long64ToString(tm_stamp) + ".txt"; CppUtils::String data = ctx->historyaccessorPtr->dumpAllRows(); CppUtils::saveContentInFile2(file, data); file = "c:\\temp\\data\\content_debug_i_" + CppUtils::long64ToString(tm_stamp) + ".txt"; CppUtils::saveContentInFile2(file, ctx->historyaccessorPtr->makeDebugDump(true)); */ /* HlpStruct::MultiSymbolCache dataset_fixed = dataset_m; fixGapsInDataset(dataset_fixed, -1); file = "c:\\temp\\data\\content_fixed_i_" + CppUtils::long64ToString(tm_stamp) + ".txt"; CppUtils::saveContentInFile2(file, dataset_fixed.dump()); // calculate data HlpStruct::MultiSymbolCache synthetic_dataset; calculateSynthetic(dataset_fixed, synthetic_dataset); file = "c:\\temp\\data\\synthetic_i_" + CppUtils::long64ToString(tm_stamp) + ".txt"; CppUtils::saveContentInFile2(file, synthetic_dataset.dump()); */ } // if new period }
//this function is simply a store function void sto (int levels, int offset) { int base = getBase(levels, bp); stack [base + offset] = stack[sp]; sp --; }
BFSMultiVertex() { //vertices.assign(N / ckGetArraySize(), BFSVertex()); for(CmiUInt8 i = 0; i < N / ckGetArraySize(); i++) vertices.push_back(BFSVertex(getBase() + i)); }
//lod function will do 3 things //get the base value L levels down //grab the number at offset M //push that number void lod (int levels, int offset) { int base = getBase(levels, bp); int value = stack[base + offset]; lit(value); }
/* This task is responsible for gesture recognition. */ void gesture_recognition_task(void *pdata) { INT8U err; double end_time = 0.0; double start_time = OSTimeGet(); double frame_rate = 0.0; double time_passed = 0.0; int frame_count = 0; int x = 0; int y = 0; int direction_code = 0; int mode = SEARCH_MODE; struct SearchNode *storage_base = getBase(); printStorage(storage_base->next); struct DirectionNode *incoming_node, *last_incoming_node, *base; last_incoming_node = getDummyBase(); while (1) { int centroid = (int) OSQPend(position_queue, 0, &err); if (err == OS_NO_ERR) { end_time = OSTimeGet(); frame_count += 1; time_passed = (end_time - start_time) / OS_TICKS_PER_SEC; x = centroid & 1023; y = centroid >> 16; frame_rate = frame_count / time_passed; ; incoming_node = createDirectionNode(x, y, NO_GESTURE); /* We ignore position information that falls within the same grid */ if (compareTwoDirectionNodes(incoming_node, last_incoming_node) == NODES_DIFFERENT) { if (mode == SEARCH_MODE) { base = firstDirectionNode(incoming_node, last_incoming_node); } else { base = nextDirectionNode(incoming_node, base, last_incoming_node, &direction_code); } if (base) { // Leaf node if (base->gesture_code != NO_GESTURE) { mode = SEARCH_MODE; handleGestureCommands(base->gesture_code); } else { mode = FOLLOW_MODE; } } else { mode = SEARCH_MODE; } free(last_incoming_node); last_incoming_node = incoming_node; } else { } } else {
void pcode(Tinstruction inst[], int stack[], FILE *output){ int base = 1; // Points to the base address in the stack for the current invocation of a given procedure int top = 0; // Points to the current top of the stack int counter = 0; // Points to an instruction in the program area int aux; int stop = 0; do{ Tinstruction instruction = inst[counter]; counter++; switch (instruction.operation){ case LIT: top++; stack[top] = instruction.argument; break; case OPR: switch(instruction.argument){ case RTN: top = base - 1; counter = stack[top+3]; base = stack[top+2]; break; case NEG: stack[top]= -1*stack[top]; break; case ADD: top--; stack[top] += stack[top+1]; break; case SUB: top--; stack[top] -= stack[top+1]; break; case MUL: top--; stack[top] *= stack[top+1]; break; case DIV: top--; stack[top] /= stack[top+1]; break; case MOD: top--; stack[top] %= stack[top+1]; break; case ODD: stack[top] = (stack[top]%2 == 1); break; case EQL: top--; stack[top] = (stack[top] == stack[top+1]); break; case NEQ: top--; stack[top] = (stack[top] != stack[top+1]); break; case LSS: top--; stack[top] = (stack[top] < stack[top+1]); break; case LEQ: top--; stack[top] = (stack[top] <= stack[top+1]); break; case GTR: top--; stack[top] = (stack[top] > stack[top+1]); break; case GEQ: top--; stack[top] = (stack[top] >= stack[top+1]); break; default: printf("Unknown OPR subfunction"); break; } break; case LOD: top++; stack[top] = stack[ getBase(instruction.level, base, stack) + instruction.argument ]; stack[ getBase(instruction.level, base, stack) + instruction.argument ] = -10; break; case STO: stack[ getBase(instruction.level, base, stack) + instruction.argument ] = stack[top]; top--; break; case CAL: stack[top+1] = getBase(instruction.level, base, stack); stack[top+2] = base; stack[top+3] = counter; base = top+1; counter = instruction.argument; break; case INT: top += instruction.argument; break; case JMP: counter = instruction.argument-1; break; case JPC: if (stack[top] == 0){ counter = instruction.argument-1; } top--; break; default: printf("Unknown function"); } // PrintStackTrace fprintf(output,"%-10s %-7d %-7d %-7d %-7d %-15d", getInstructionName(instruction.operation),instruction.level, instruction.argument, top, counter, base); for (aux = base; aux<top+1 && top > 0;aux++){ if(stack[aux] == -10){ fprintf(output,"_ "); }else{ fprintf(output,"%d ", stack[aux]); } } fprintf(output,"\n"); // If RTN, stop stop = (instruction.operation == 1 && instruction.argument == 0); }while(stop == 0); }
QString SimpleType::getDataType() { return ((SimpleType*) getBase())->getDataType(); }
void pkCU::evaluateMove_script() { assert(getStackStage() == STAGE_MOVEBASE); assert(getTPKV().isAlive() && getPKV().isAlive()); const pokemon_nonvolatile& cPKNV = getPKNV(); const pokemon_nonvolatile& tPKNV = getTPKNV(); const move_nonvolatile& cMNV = cPKNV.getMove(getICAction()); const move& cMove = cMNV.getBase(); // the floor of the stack: everything below this stack value has been evaluated size_t baseFloor = iBase, baseCeil = getStack().size(); // calculate probability to hit, miss: //for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { //if (getStackStage() != STAGE_MOVEBASE) { continue; } stackStage[iBase] = STAGE_MODIFYHITCHANCE; fpType& probabilityToHit = getDamageComponent().tProbability; // TODO: take target into account when calculating probability to hit! /* probability to hit enemy pokemon */ if (cMove.targetsEnemy()) { probabilityToHit = getTMV().cGetAccuracy_boosted(FV_ACCURACY) // lowest is 33% or 3333 / 10000 * getTTMV().cGetAccuracy_boosted(FV_EVASION) // highest is 300% or 3 * cMove.getPrimaryAccuracy(); // lowest is 30% or 30 / 100 } else { probabilityToHit = cMove.getPrimaryAccuracy(); } // to-hit modifying values: int result = 0; CALLPLUGIN(result, PLUGIN_ON_MODIFYHITPROBABILITY, onModifyPower_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), probabilityToHit); } // evaluate miss(1), hit(0), for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_MODIFYHITCHANCE) { continue; } stackStage[iBase] = STAGE_PREDAMAGE; fpType& probabilityToHit = getDamageComponent().tProbability; // bound at MIN 0.033~ ... MAX 1.0 probabilityToHit = std::max(std::min(probabilityToHit, (fpType)1.0), (fpType)0.0); boost::array<size_t, 2> iHEnv = {{ getIBase(), SIZE_MAX }}; // did the move hit its target? Is it possible for the move to miss? if (mostlyGT(probabilityToHit, 0.0)) { // if there's a chance the primary effect will not occur: if (mostlyLT(probabilityToHit, 1.0)) { // duplicate the environment (duplicated environment is the miss environment): duplicateState(iHEnv, (1.0 - probabilityToHit)); } // modify bitmask as the hit effect occuring: getStack()[iHEnv[0]].setHit(getICTeam()); } // end of primary attack hits, and secondary attack is not assured else { // pass-through: no chance to hit stackStage[iBase] = STAGE_POSTDAMAGE; } } // perform script: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_PREDAMAGE) { continue; } advanceStackStage(); if (!getBase().hasHit(getICTeam())) { continue; } // parse alternative move plugins: int result = getPKNV().getMove_base(getICAction()).isImplemented()?1:0; // TODO: this check isn't working! CALLPLUGIN(result, PLUGIN_ON_EVALUATEMOVE, onEvaluateMove_rawType, *this, getPKNV().getMove(getICAction()), getPKNV(), getTPKNV(), getTMV(), getTTMV(), getPKV(), getTPKV()); } return; }
// save if inputString can be assigned to previously defined variable ok QString SimpleType::generateControl(QString inputString) { return ((SimpleType*) getBase())->generateControl(inputString); }
size_t pkCU::combineSimilarEnvironments() { std::vector<environment_possible>& stack = getStack(); size_t numUnique = stack.size(); #ifndef NDEBUG #ifndef _DISABLEPROBABILITYCHECK fpType probabilityAccumulator = 0.0; #endif #endif // hash environments (and summate probabilities for check): for (iBase = 0; iBase != numUnique; ++iBase) { environment_possible& cEnvironment = getBase(); // assert that each of these environments is getting hashed: assert(getStackStage() == STAGE_FINAL); advanceStackStage(); // WARNING: EXPENSIVE! cEnvironment.generateHash(); } // compare environment hashes: for (size_t iOEnv = 0, iSize = numUnique; iOEnv != iSize; iOEnv++) { environment_possible& oEnv = stack[iOEnv]; fpType& oProbability = damageComponents[iOEnv].cProbability; // don't attempt to merge pruned environments if (oEnv.isPruned()) { continue; } for (size_t iIEnv = iOEnv + 1; iIEnv != iSize; iIEnv++) { environment_possible& iEnv = stack[iIEnv]; fpType& iProbability = damageComponents[iIEnv].cProbability; // don't re-prune already pruned environments if (iEnv.isPruned()) { continue; } // don't merge non-identical environments #ifdef _PKCUCHECKSIGNATURE assert((oEnv.hash == iEnv.hash) == (oEnv.env == iEnv.env)); #endif if (oEnv.getHash() != iEnv.getHash()) { continue; } // combine the two environments by adding their probabilities and deleting the second oProbability += iProbability; // this is probably not representative of the current environment now oEnv.getBitmask() &= iEnv.getBitmask(); // flag this environment as merged with another environment oEnv.setMerged(); // flag the inner environment as pruned by another environment iEnv.setPruned(); // decrement number of unique values in vector numUnique--; } //endOf iInner // assign the collected probability to envP's smaller fixed point variable oEnv.getProbability() = fixedpoint::create<30>(oProbability); #ifndef NDEBUG #ifndef _DISABLEPROBABILITYCHECK probabilityAccumulator += oProbability; #endif #endif assert(mostlyGT(oProbability, 0.0) && mostlyLTE(oProbability, 1.0)); } // endOf iOuter #ifndef _DISABLEPROBABILITYCHECK assert(mostlyEQ(probabilityAccumulator, 1.0)); #endif return numUnique; } //endOf combineSimilarEnvironments
QString SimpleType::generateInit(QString varName) { return ((SimpleType*) getBase())->generateInit(varName); }
const pokemon_nonvolatile& pkCU::getTPKNV() { return getNV().getTeam(getIOTeam()).getPKNV(getBase().getEnv().getTeam(getIOTeam())); }
// Objects have simple paths /container/object-key // If the object is of type iop a vfile can also be mapped to represent // the columns inside the record // The /container/.inetfs_schema can be used to determine visible or // invisible columns // Container names and keys are sha256'ed and readdir is disabled string ObjectServer::encodePath(ServerContext& ctxt, const char *path, string& vfile) { string_list_t in, out; string_list_t::iterator it; string tmp; string root = getBase(); bool fix = false; int pos = 0; vfile.clear(); #if 0 //_STDERR("encode: in path = %s", path); if (strncmp(base_name(path), ".inetfs_", 8) == 0) { //_STDERR("encode: out path = %s", path); return path; } //else #endif if (strncmp(root.c_str(), path, root.length()) == 0) { path += root.length(); fix = true; } if (path == NULL || *path == 0 || SEPSTR == path) { //_STDERR("encode: out path = %s", fix ? root.c_str() : "/"); return fix ? root : SEPSTR; } path_to_list(path, in); bool is_control = false; for (it = in.begin(); it != in.end(); it++) { is_control = strncmp(it->c_str(), ".inetfs_", 8) == 0; tmp = *it; switch (pos) { case 0: if (!is_control) { make_hash16("sha256", *it, tmp); } out.push_back(tmp); break; case 1: if (!is_control) { make_hash16("sha256", *it, tmp); } #if 1 out.push_back(tmp); #else out.push_back(string(tmp.c_str(), 3)); out.push_back(string(tmp.c_str() + 3) + string(".dir")); #endif break; case 2: vfile = *it; break; default: vfile += SEPSTR + *it; } pos++; } tmp = implode(out, SEPCSTR); if (tmp.empty()) { tmp = SEPSTR; } if (tmp.c_str()[0] != SEPARATOR) { tmp = SEPSTR + tmp; } string pp = root + tmp; //_STDERR("encode: out path = %s", pp.c_str()); return root + tmp; }
void pkCU::setCPluginSet() { size_t iCPokemon = getBase().getEnv().getTeam(getICTeam()).getICPKV(); size_t iOPokemon = getBase().getEnv().getTeam(getIOTeam()).getICPKV(); cPluginSet = &pluginSets[getICTeam() * 6 + iCPokemon][iOPokemon]; }
void WalkerPrefect::onMidTile() { ReachedBuildings reachedBuildings; TilePos firePos; bool haveBurningRuinsNear = _looks4Fire( reachedBuildings, firePos ); bool isDestination = _pathWay.isDestination(); switch( _d->action ) { case Impl::patrol: { if( haveBurningRuinsNear ) { //tell our prefecture that need send prefect with water to fight with fire //on next deliverService //found fire, no water, go prefecture getBase().as<BuildingPrefect>()->fireDetect( firePos ); _back2Prefecture(); Walker::onNewDirection(); } else { for( ReachedBuildings::iterator itBuilding = reachedBuildings.begin(); itBuilding != reachedBuildings.end(); ++itBuilding) { (*itBuilding)->applyService( ServiceWalkerPtr( this ) ); } } if( isDestination ) { _back2Prefecture(); } Walker::onMidTile(); } break; case Impl::back2Prefecture: { if( haveBurningRuinsNear ) { //tell our prefecture that need send prefect with water to fight with fire //on next deliverService getBase().as<BuildingPrefect>()->fireDetect( firePos ); } if( isDestination ) { deleteLater(); _d->action = Impl::doNothing; } Walker::onMidTile(); } break; case Impl::gotoFire: { if( _pathWay.getDestination().getIJ().distanceFrom( getIJ() ) < 1.5f ) { LandOverlayPtr overlay = _pathWay.getDestination().get_terrain().getOverlay(); BurningRuinsPtr bruins = overlay.as<BurningRuins>(); if( bruins.isValid() ) { _d->action = Impl::fightFire; _walkerGraphic = WG_PREFECT_FIGHTS_FIRE; Walker::onNewDirection(); isDestination = false; } } if( isDestination ) { if( !haveBurningRuinsNear || _d->water == 0 ) { _back2Prefecture(); } else { _walkerGraphic = WG_PREFECT_DRAG_WATER; _d->action = Impl::gotoFire; _checkPath2NearestFire( reachedBuildings ); Walker::onNewDirection(); } } Walker::onMidTile(); } break; case Impl::fightFire: break; } }
void pkCU::evaluateMove() { // NOTE: ONLY ONE stage is set to preturn at a time assert(getStackStage() == STAGE_PRETURN); size_t iCAction = getICAction(); size_t iCTeam = getICTeam(); // the floor of the stack: everything below this stack value has been evaluated size_t baseFloor = iBase, baseCeil = getStack().size(), iNBase; // TODO: does this model the actual game? // if either pokemon is dead at this point, the only valid moves are switching and waiting if ( (!getPKV().isAlive() || !getTPKV().isAlive()) && isMoveAction(iCAction) ) { iCAction = AT_MOVE_NOTHING; } // does this move require a switch-out? if (isSwitchAction(iCAction)) { stackStage[iBase] = STAGE_PRESWITCH; evaluateMove_switch(); } // end of is Switch type action // is this pokemon doing nothing? else if (iCAction == AT_MOVE_NOTHING) { stackStage[iBase] = STAGE_POSTSECONDARY; // set that the current team did nothing this turn: getBase().setWaited(iCTeam); // pokemon performs no action, no update to the state is needed } // end of is Wait type action // is the pokemon moving normally? else if (isMoveAction(iCAction)) { assert(getPKV().isAlive() && getTPKV().isAlive()); // this is the first function which may generate more than one state of STAGE_STATUS type { stackStage[iBase] = STAGE_STATUS; evaluateMove_preMove(); } // POSSIBLE THAT POKEMON MIGHT HAVE DIED IN PREVIOUS STEP const move& cMove = getPKNV().getMove_base(iCAction); void (pkCU::*evaluate_t)(); if ( cMove.damageType == ATK_PHYSICAL || cMove.damageType == ATK_SPECIAL) { evaluate_t = &pkCU::evaluateMove_damage;} else { evaluate_t = &pkCU::evaluateMove_script;} // evaluate either move or plugin move: (increment with iNBase, as evaluateMove_damage will manipulate stack) for (iNBase = baseFloor, iBase = iNBase, baseCeil = getStack().size(); iNBase != baseCeil; ++iNBase, iBase = iNBase) { if (getStackStage() != STAGE_STATUS) { continue; } advanceStackStage(); // was this move blocked by a status? // did this pokemon die from the last pokemon's action? if (getBase().wasBlocked(iCTeam) || !getPKV().isAlive()) { stackStage[iBase] = STAGE_POSTTURN; continue; } // evaluate either evaluateMove_damage from stackstage movebase, or evaluateMove_script from stackstage postmove (this->*evaluate_t)(); } // for all worlds: (increment with iNBase, as evaluateMove_postMove will manipulate stack) for (iNBase = baseFloor, iBase = iNBase, baseCeil = getStack().size(); iNBase != baseCeil; ++iNBase, iBase = iNBase) { if (getStackStage() != STAGE_POSTDAMAGE) { continue; } advanceStackStage(); evaluateMove_postMove(); } // endOf forEach environment } // endOf isMove // POSSIBLE THAT POKEMON MIGHT HAVE DIED IN PREVIOUS STEP // end of turn occurences: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_POSTSECONDARY) { continue; } stackStage[iBase] = STAGE_POSTTURN; evaluateMove_postTurn(); } return; } // end of evaluateMove
QString Scene_polyhedron_transform_item::toolTip() const { return QObject::tr("<p>Affine transformation of <b>%1</b></p>" "<p>Keep <b>Ctrl</b> pressed and use the arcball to define an affine transformation.<br />" "Press <b>S</b> to apply the affine transformation to a copy of <b>%1</b>.</p>") .arg(getBase()->name()); }
void pkCU::evaluateMove_postMove() { assert(getStackStage() == STAGE_POSTMOVE); // the floor of the stack: everything below this stack value has been evaluated size_t baseFloor = iBase, baseCeil = getStack().size(); // the current environment we are evaluating upon. Will be copied, modified and pushed back eventually const pokemon_nonvolatile& cPKNV = getPKNV(); const pokemon_nonvolatile& tPKNV = getTPKNV(); const move_nonvolatile& cMNV = cPKNV.getMove(getICAction()); const move& cMove = cMNV.getBase(); size_t iCTeam = getICTeam(); // effects which occur regardless of a secondary effect occuring, but only if the move hit: //for (/*iBase = baseFloor, baseCeil = getStack().size()*/; iBase != baseCeil; ++iBase) { //if (getStackStage() != STAGE_POSTMOVE) { continue; } advanceStackStage(); int result = 0; CALLPLUGIN(result, PLUGIN_ON_ENDOFMOVE, onEvaluateMove_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV()); } // POSSIBLE THAT POKEMON MIGHT HAVE DIED IN PREVIOUS STEP // calculate probability to perform secondary: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_PRESECONDARY) { continue; } advanceStackStage(); // special behavior if the teammate is dead: (cannot compute secondary effects) if (!getPKV().isAlive()) { stackStage[iBase] = STAGE_POSTTURN; continue; } // does this move even have a secondary effect? (this check is in-loop because multiple environments could arise from previous call) if (!mostlyGT(cMove.getSecondaryAccuracy(), 0.0)) { stackStage[iBase] = STAGE_POSTSECONDARY; continue; } fpType& secondaryHitProbability = getDamageComponent().tProbability; /* probability to inflict secondary condition*/ secondaryHitProbability = cMove.getSecondaryAccuracy(); // lowest is 10% // to-hit modifying values: int result = 0; CALLPLUGIN(result, PLUGIN_ON_MODIFYSECONDARYPROBABILITY, onModifyPower_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), secondaryHitProbability); } // endOf calculate secondary probability // split environments based on their secondary chance: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_MODIFYSECONDARYHITCHANCE) { continue; } advanceStackStage(); boost::array<size_t, 2> iREnv = {{ getIBase() , SIZE_MAX }}; fpType& secondaryHitProbability = getDamageComponent().tProbability; secondaryHitProbability = std::max(std::min(secondaryHitProbability, (fpType)1.0), (fpType)0.0); // did the ability hit its target? Is it possible for the secondary ability to miss? if (getBase().hasHit(iCTeam) && (mostlyGT(secondaryHitProbability, 0.0))) { // if there's a chance the secondary effect will not occur: if (mostlyLT(secondaryHitProbability, 1.0)) { // duplicate the environment (duplicated environment is the secondary effect missed): duplicateState(iREnv, (1.0 - secondaryHitProbability)); } // modify bitmask as secondary effect occuring: getStack()[iREnv[0]].setSecondary(iCTeam); } // end of primary attack hits, and secondary attack is not assured else { // pass-through: no chance to secondary stackStage[iBase] = STAGE_POSTSECONDARY; continue; } } // calculate effect of secondary, if it occured: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_SECONDARY) { continue; } advanceStackStage(); // add extra effects to the move, such as secondaries and trigger effects if (!getBase().hasSecondary(iCTeam)) { continue; } // parse secondary effect plugins: int result = 0; CALLPLUGIN(result, PLUGIN_ON_SECONDARYEFFECT, onEvaluateMove_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV()); } // endOf if primary and secondary attacks hit } // endOf evaluateMove_postMove
bool DomConvenience::elementToVariant(const QDomElement& e, QVariant& v) { bool ok = false; if (e.tagName() == "string") { if (e.hasAttribute("value")) { v = QVariant(e.attribute("value")); ok = true; } else qWarning("%s element without value!", (const char*)e.tagName()); } else if (e.tagName() == "int") { int base = getBase(e); if (e.hasAttribute("value")) v = QVariant(e.attribute("value").toInt(&ok, base)); else qWarning("%s element without value!", (const char*)e.tagName()); } else if (e.tagName() == "uint") { int base = getBase(e); if (e.hasAttribute("value")) v = QVariant(e.attribute("value").toUInt(&ok, base)); else qWarning("%s element without value!", (const char*)e.tagName()); } else if (e.tagName() == "double") { if (e.hasAttribute("value")) v = QVariant(e.attribute("value").toDouble(&ok)); else qWarning("%s element without value!", (const char*)e.tagName()); } else if (e.tagName() == "bool") { if (e.hasAttribute("value")) { QString val = e.attribute("value"); v = QVariant(getBoolFromString(val, ok), 0); if (!ok) qWarning("%s element with bogus value '%s'!", (const char*)e.tagName(), (const char*)val); } else qWarning("%s element without value!", (const char*)e.tagName()); } else if (e.tagName() == "color") { QColor color = getColor(e); ok = color.isValid(); v = color; if (!ok) qWarning("%s element without valid value!", (const char*)e.tagName()); } else if (e.tagName() == "pen") { int base = getBase(e); uint w = 0; Qt::PenStyle s = Qt::SolidLine; Qt::PenCapStyle c = Qt::SquareCap; Qt::PenJoinStyle j = Qt::BevelJoin; QColor color = getColor(e); if (e.hasAttribute("style")) s = (Qt::PenStyle)e.attribute("style").toInt(0, base); if (e.hasAttribute("cap")) c = (Qt::PenCapStyle)e.attribute("cap").toInt(0, base); if (e.hasAttribute("join")) j = (Qt::PenJoinStyle)e.attribute("join").toInt(0, base); ok = color.isValid(); v = QPen(color, w, s, c, j); if (!ok) qWarning("%s element without valid value!", (const char*)e.tagName()); } else if (e.tagName() == "brush") { int base = getBase(e); QColor color = getColor(e); Qt::BrushStyle s = Qt::SolidPattern; if (e.hasAttribute("style")) s = (Qt::BrushStyle)e.attribute("style").toInt(0, base); ok = color.isValid(); v = QBrush(color, s); if (!ok) qWarning("%s element without valid value!", (const char*)e.tagName()); } else if (e.tagName() == "point") { int base = getBase(e); bool coordOk; int x = 0, y = 0; if (e.hasAttribute("x")) x = e.attribute("x").toInt(&coordOk, base); if (e.hasAttribute("y")) y = e.attribute("y").toInt(&coordOk, base); v = QVariant(QPoint(x, y)); ok = true; } else if (e.tagName() == "rect") { int base = getBase(e); bool coordOk; int x = 0, y = 0, width = 0, height = 0; if (e.hasAttribute("x")) x = e.attribute("x").toInt(&coordOk, base); if (e.hasAttribute("y")) y = e.attribute("y").toInt(&coordOk, base); if (e.hasAttribute("width")) width = e.attribute("width").toInt(&coordOk, base); if (e.hasAttribute("height")) height = e.attribute("height").toInt(&coordOk, base); v = QVariant(QRect(x, y, width, height)); ok = true; } else if (e.tagName() == "size") { int base = getBase(e); bool coordOk; int width = 0, height = 0; if (e.hasAttribute("width")) width = e.attribute("width").toInt(&coordOk, base); if (e.hasAttribute("height")) height = e.attribute("height").toInt(&coordOk, base); v = QVariant(QSize(width, height)); ok = true; } else if (e.tagName() == "key") { int key; if (e.hasAttribute("sequence")) { key = QAccel::stringToKey(e.attribute("sequence")); // fix the key code (deal with Qt brain death) key &= ~Qt::UNICODE_ACCEL; v = QVariant(QKeySequence(key)); ok = true; } } else if (e.tagName() == "font") { QFont f; bool boolOk; if (e.hasAttribute("family")) f.setFamily(e.attribute("family")); if (e.hasAttribute("pointsize")) f.setPointSize(e.attribute("pointsize").toInt()); if (e.hasAttribute("bold")) f.setBold(getBoolFromString(e.attribute("bold"), boolOk)); if (e.hasAttribute("italic")) f.setItalic(getBoolFromString(e.attribute("italic"), boolOk)); if (e.hasAttribute("strikeout")) f.setStrikeOut(getBoolFromString(e.attribute("strikeout"), boolOk)); v = QVariant(f); ok = true; } else if (e.tagName() == "sizepolicy") { QSizePolicy sp; if (e.hasAttribute("hsizetype")) sp.setHorData((QSizePolicy::SizeType)e.attribute("hsizetype").toInt()); if (e.hasAttribute("vsizetype")) sp.setVerData((QSizePolicy::SizeType)e.attribute("vsizetype").toInt()); if (e.hasAttribute("horstretch")) sp.setHorStretch(e.attribute("horstretch").toInt()); if (e.hasAttribute("verstretch")) sp.setHorStretch(e.attribute("verstretch").toInt()); v = QVariant(sp); ok = true; } else if (e.tagName() == "cursor") { if (e.hasAttribute("shape")) v = QVariant(QCursor(e.attribute("shape").toInt(&ok, 10))); else qWarning("%s element without value!", (const char*)e.tagName()); } else if (e.tagName() == "stringlist") { QDomNodeList stringNodeList = e.elementsByTagName("string"); QStringList stringList; QDomElement stringElement; for (uint i = 0; i < stringNodeList.length(); i++) { stringElement = stringNodeList.item(i).toElement(); if (!stringElement.hasAttribute("value")) { qWarning("%s element in %s without value! Ignoring!", (const char*)stringElement.tagName(), (const char*)e.tagName()); continue; } stringList.append(e.attribute("value")); } v = stringList; ok = true; } else if (e.tagName() == "uint64") { QString value = e.attribute("value"); // borrowed more or less from Qt 3.2 (since we have to support older) uint64_t val = 0; const QChar* p = value.unicode(); int l = value.length(); const uint64_t max_mult = UINT64_MAX / 16; if (!p) { qWarning("Invalid value for tag: %s", (const char*)e.tagName()); return false; } while ( l && p->isSpace() ) // skip leading space l--,p++; if ( !l ) return false; if ( *p == '+' ) l--,p++; if ( !l || !ok_in_hex(*p) ) return false; while ( l && ok_in_hex(*p) ) { l--; uint dv; if ( p->isDigit() ) dv = p->digitValue(); else { if ( *p >= 'a' && *p <= 'f' ) dv = *p - 'a' + 10; else dv = *p - 'A' + 10; } if ( val > max_mult || (val == max_mult && dv > UINT64_MAX % 16) ) return false; val = 16 * val + dv; p++; } QByteArray ba; ba.duplicate((const char*)&val, sizeof(uint64_t)); v = ba; ok = true; } else if (e.tagName() == "list") { qWarning("Unimplemented tag: %s", (const char*)e.tagName()); } else if (e.tagName() == "map") { qWarning("Unimplemented tag: %s", (const char*)e.tagName()); } else { qWarning("Unknown tag: %s", (const char*)e.tagName()); } return ok; }
void pkCU::evaluateMove_damage() { assert(getStackStage() == STAGE_MOVEBASE); assert(getTPKV().isAlive() && getPKV().isAlive()); // the floor of the stack: everything below this stack value has been evaluated size_t baseFloor = iBase, baseCeil = getStack().size(); const pokemon_nonvolatile& cPKNV = getPKNV(); const pokemon_nonvolatile& tPKNV = getTPKNV(); const move_nonvolatile& cMNV = cPKNV.getMove(getICAction()); const pokemon_base& cPKB = cPKNV.getBase(); const pokemon_base& tPKB = tPKNV.getBase(); const move& cMove = cMNV.getBase(); //Source: http://www.smogon.com/dp/articles/damage_formula /*BasePower = HH × BP × IT × CHG × (MS × WS) × UA × FA*/ // set basePower: //for (/*iBase = baseFloor, baseCeil = getStack().size()*/; iBase != baseCeil; ++iBase) { //if (getStackStage() != STAGE_MOVEBASE) { continue; } advanceStackStage(); uint32_t& basePower = getDamageComponent().damage; basePower = cMove.getPower(); int result = (basePower != UINT8_MAX)?1:0; CALLPLUGIN(result, PLUGIN_ON_SETBASEPOWER, onSetPower_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), basePower); assert(result > 0 && basePower > 0); } // calculate this move's type: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_SETBASEPOWER) { continue; } advanceStackStage(); const type*& cType = getDamageComponent().mType; cType = &cMove.getType(); int result = 0; CALLPLUGIN(result, PLUGIN_ON_SETMOVETYPE, onModifyMoveType_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), cType); } // modify basePower: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_SETMOVETYPE) { continue; } advanceStackStage(); uint32_t& basePower = getDamageComponent().damage; fpType baseModifier = 1.0; int result = 0; CALLPLUGIN(result, PLUGIN_ON_MODIFYBASEPOWER, onModifyPower_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), baseModifier); basePower = (uint32_t)(basePower * baseModifier); } // calculate attack and damage modifiers: uint32_t levelModifier = ((cPKNV.getLevel() * 2) / 5) + 2; for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_MODIFYBASEPOWER) { continue; } advanceStackStage(); damageComponents_t& cDamage = getDamageComponent(); size_t attackType; size_t defenseType; if (cMove.getDamageType() == ATK_PHYSICAL) { attackType = FV_ATTACK; defenseType = FV_DEFENSE; } else { attackType = FV_SPATTACK; defenseType = FV_SPDEFENSE; } uint32_t attackPower = getTMV().cGetFV_boosted(cPKNV, attackType); uint32_t attackPowerCrit = std::max(cPKNV.getFV_base(attackType), attackPower); uint32_t defensePower = getTTMV().cGetFV_boosted(tPKNV, defenseType); uint32_t defensePowerCrit = std::min(tPKNV.getFV_base(defenseType), defensePower); // calculate crit first: cDamage.damageCrit = ((levelModifier * cDamage.damage * attackPowerCrit) / 50) / defensePowerCrit; // and regular damage: cDamage.damage = ((levelModifier * cDamage.damage * attackPower) / 50) / defensePower; /* Mod1 = BRN × RL × TVT × SR × FF */ // modifier1: fpType attackPowerModifier = 1.0; int result = 0; CALLPLUGIN(result, PLUGIN_ON_MODIFYATTACKPOWER, onModifyPower_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), attackPowerModifier); // incorporate attack power modifier: cDamage.damage = (uint32_t)(cDamage.damage * attackPowerModifier) + 2; cDamage.damageCrit = (uint32_t)(cDamage.damageCrit * attackPowerModifier) + 2; } // calculate critical hit modifiers: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_MODIFYATTACKPOWER) { continue; } advanceStackStage(); damageComponents_t& cDamage = getDamageComponent(); /* CH - Critical Hit modifier 3 if has sniper ability AND critical hit (mult 1.5) 2 if critical hit (mult 1.0) 1 else */ fpType criticalHitModifier = 2.0; int result = 0; CALLPLUGIN(result, PLUGIN_ON_MODIFYCRITICALPOWER, onModifyPower_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), criticalHitModifier); // incorporate critical power modifier: cDamage.damageCrit = (uint32_t)(cDamage.damageCrit * criticalHitModifier); } // calculate raw damage modifiers: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_MODIFYCRITICALPOWER) { continue; } advanceStackStage(); damageComponents_t& cDamage = getDamageComponent(); /* Mod2 = Other modifier 1.3 if item = life orb 1+.1*n if item = metronome and used the same move n previous times, to a max of n=10 1.5 if attacking with Me First and attacks first (NOTE: SPECIAL BEHAVIOR with life orb / metronome!) 1 else */ fpType rawDamageMultiplier = 1.0; int result = 0; CALLPLUGIN(result, PLUGIN_ON_MODIFYRAWDAMAGE, onModifyPower_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), rawDamageMultiplier); // incorporate critical power modifier: cDamage.damage = (uint32_t)(cDamage.damage * rawDamageMultiplier); cDamage.damageCrit = (uint32_t)(cDamage.damageCrit * rawDamageMultiplier); } // calculate this move's STAB: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_MODIFYRAWDAMAGE) { continue; } advanceStackStage(); damageComponents_t& cDamage = getDamageComponent(); bool hasStab = ((&cPKB.getType(0) == cDamage.mType) || (&cPKB.getType(1) == cDamage.mType)); fpType STABMultiplier = hasStab?1.5:1.0; int result = 0; CALLPLUGIN(result, PLUGIN_ON_MODIFYSTAB, onModifyPower_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), STABMultiplier); // incorporate STAB modifier: cDamage.damage = (uint32_t)(cDamage.damage * STABMultiplier); cDamage.damageCrit = (uint32_t)(cDamage.damageCrit * STABMultiplier); } // calculate the enemy pokemon's type resistance: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_MODIFYSTAB) { continue; } advanceStackStage(); damageComponents_t& cDamage = getDamageComponent(); fpType typeModifier = 1.0; { // type1: typeModifier *= cDamage.mType->getModifier(tPKB.getType(0)); // type 2: typeModifier *= cDamage.mType->getModifier(tPKB.getType(1)); } int result = 0; CALLPLUGIN(result, PLUGIN_ON_SETDEFENSETYPE, onModifyTypePower_rawType, *this, cMNV, cPKNV, tPKNV, *cDamage.mType, getTMV(), getTTMV(), getPKV(), getTPKV(), typeModifier); // incorporate type modifier: cDamage.damage = (uint32_t)(cDamage.damage * typeModifier); cDamage.damageCrit = (uint32_t)(cDamage.damageCrit * typeModifier); } // calculate item resistance modifiers: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_MODIFYTYPERESISTANCE) { continue; } advanceStackStage(); damageComponents_t& cDamage = getDamageComponent(); /* Mod3 = SRF × EB × TL × TRB */ fpType itemModifier = 1.0; int result = 0; CALLPLUGIN(result, PLUGIN_ON_MODIFYITEMPOWER, onModifyPower_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), itemModifier); // incorporate type modifier: cDamage.damage = (uint32_t)(cDamage.damage * itemModifier); cDamage.damageCrit = (uint32_t)(cDamage.damageCrit * itemModifier); } /* Damage Formula = (((((((Level × 2 ÷ 5) + 2) × BasePower × [Sp]Atk ÷ 50) ÷ [Sp]Def) × Mod1) + 2) × CH × Mod2 × R ÷ 100) × STAB × Type1 × Type2 × Mod3 */ // calculate probability to hit, miss: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_MODIFYITEMPOWER) { continue; } advanceStackStage(); fpType& probabilityToHit = getDamageComponent().tProbability; /* probability to hit enemy pokemon */ probabilityToHit = getTMV().cGetAccuracy_boosted(FV_ACCURACY) // lowest is 33% or 1/3 * getTTMV().cGetAccuracy_boosted(FV_EVASION) // highest is 300% or 3 * cMove.getPrimaryAccuracy(); // lowest is 30% // to-hit modifying values: int result = 0; CALLPLUGIN(result, PLUGIN_ON_MODIFYHITPROBABILITY, onModifyPower_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), probabilityToHit); } // evaluate miss(1), hit(0): for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_MODIFYHITCHANCE) { continue; } advanceStackStage(); fpType& probabilityToHit = getDamageComponent().tProbability; // bound at MIN 0.033~ ... MAX 1.0 probabilityToHit = std::max(std::min(probabilityToHit, (fpType)1.0), (fpType)0.0); boost::array<size_t, 2> iHEnv = {{ getIBase(), SIZE_MAX }}; // did the move hit its target? Is it possible for the move to miss? if (mostlyGT(probabilityToHit, 0.0)) { // if there's a chance the primary effect will not occur: if (mostlyLT(probabilityToHit, 1.0)) { // duplicate the environment (duplicated environment is the miss environment): duplicateState(iHEnv, (1.0 - probabilityToHit)); } // modify bitmask as the hit effect occuring: getStack()[iHEnv[0]].setHit(getICTeam()); } // end of primary attack hits, and secondary attack is not assured else { // pass-through: no chance to hit or crit stackStage[iBase] = STAGE_POSTDAMAGE; } } // calculate probability to crit: for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_EVALUATEHITCHANCE) { continue; } advanceStackStage(); // don't continue to evaluate a stage that has not hit the enemy team: if (!getBase().hasHit(getICTeam())) { stackStage[iBase] = STAGE_POSTDAMAGE; continue; } fpType& probabilityToCrit = getDamageComponent().tProbability; /* Probability to critical hit, if the move has already hit */ probabilityToCrit = getTMV().cGetAccuracy_boosted(FV_CRITICALHIT); // to-crit modifying values: int result = 0; CALLPLUGIN(result, PLUGIN_ON_MODIFYCRITPROBABILITY, onModifyPower_rawType, *this, cMNV, cPKNV, tPKNV, getTMV(), getTTMV(), getPKV(), getTPKV(), probabilityToCrit); } // evaluate crit(2): for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_MODIFYCRITCHANCE) { continue; } advanceStackStage(); fpType& probabilityToCrit = getDamageComponent().tProbability; // determine the possibility that the move crit: boost::array<size_t, 2> iCEnv = {{ SIZE_MAX, getIBase() }}; if (mostlyGT(probabilityToCrit, 0.0) ) { if (mostlyLT(probabilityToCrit, 1.0)) { // duplicate the environment (duplicated environment is the crit environment): duplicateState(iCEnv, probabilityToCrit); } // modify bitmask as the crit effect occuring: getStack()[iCEnv[1]].setCrit(getICTeam()); } // even with no chance to crit there's still the possibility of damage } // perform actual damage calculation for (iBase = baseFloor, baseCeil = getStack().size(); iBase != baseCeil; ++iBase) { if (getStackStage() != STAGE_PREDAMAGE) { continue; } advanceStackStage(); if (!getBase().hasHit(getICTeam())) { continue; } calculateDamage(getBase().hasCrit(getICTeam())); } } // end of evaluateMove_damage
Atom Stubs::do_abc_callproplex(MethodFrame* f, const Multiname* name, int argc, Atom* args) { Atom base = getBase(args); Toplevel* t = toplevel(f); return t->callproperty(base, name, argc - 1, args, toVTable(t, base)); }
//03 void lod () { sp++; stack[sp] = stack[getBase(ir.l, bp) + ir.m]; }