void Creature::onAddCondition(ConditionType_t type, bool hadCondition) { switch(type) { case CONDITION_INVISIBLE: { if(!hadCondition) g_game.internalCreatureChangeVisible(this, VISIBLE_DISAPPEAR); break; } case CONDITION_PARALYZE: { if(hasCondition(CONDITION_HASTE, -1, false)) removeCondition(CONDITION_HASTE); break; } case CONDITION_HASTE: { if(hasCondition(CONDITION_PARALYZE, -1, false)) removeCondition(CONDITION_PARALYZE); break; } default: break; } }
void Creature::onAddCondition(ConditionType_t type) { if (type == CONDITION_PARALYZE && hasCondition(CONDITION_HASTE)) { removeCondition(CONDITION_HASTE); } else if (type == CONDITION_HASTE && hasCondition(CONDITION_PARALYZE)) { removeCondition(CONDITION_PARALYZE); } }
bool Creature::addCondition(Condition* condition, bool force/* = false*/) { if (condition == NULL) { return false; } if (!force && condition->getType() == CONDITION_HASTE && hasCondition(CONDITION_PARALYZE)) { int64_t walkDelay = getWalkDelay(); if (walkDelay > 0) { g_scheduler.addEvent(createSchedulerTask(walkDelay, boost::bind(&Game::forceAddCondition, &g_game, getID(), condition))); return false; } } Condition* prevCond = getCondition(condition->getType(), condition->getId(), condition->getSubId()); if (prevCond) { prevCond->addCondition(this, condition); delete condition; return true; } if (condition->startCondition(this)) { conditions.push_back(condition); onAddCondition(condition->getType()); return true; } delete condition; return false; }
void MultiwayPathsCoveredCheck::registerMatchers(MatchFinder *Finder) { Finder->addMatcher( switchStmt( hasCondition(allOf( // Match on switch statements that have either a bit-field or // an integer condition. The ordering in 'anyOf()' is // important because the last condition is the most general. anyOf(ignoringImpCasts(memberExpr(hasDeclaration( fieldDecl(isBitField()).bind("bitfield")))), ignoringImpCasts(declRefExpr().bind("non-enum-condition"))), // 'unless()' must be the last match here and must be bound, // otherwise the matcher does not work correctly, because it // will not explicitly ignore enum conditions. unless(ignoringImpCasts( declRefExpr(hasType(enumType())).bind("enum-condition")))))) .bind("switch"), this); // This option is noisy, therefore matching is configurable. if (WarnOnMissingElse) { Finder->addMatcher( ifStmt(allOf(hasParent(ifStmt()), unless(hasElse(anything())))) .bind("else-if"), this); } }
void Creature::onWalk(Direction& dir) { if(!hasCondition(CONDITION_DRUNK)) return; uint32_t r = random_range(0, 16); if(r > 4) return; switch(r) { case 0: dir = NORTH; break; case 1: dir = WEST; break; case 3: dir = SOUTH; break; case 4: dir = EAST; break; } g_game.internalCreatureSay(this, SPEAK_MONSTER_SAY, "Hicks!", isGhost()); }
void Creature::onWalk(Direction& dir) { if (hasCondition(CONDITION_DRUNK)) { uint32_t r = random_range(0, 20); if (r <= 4) { switch (r) { case 0: dir = NORTH; break; case 1: dir = WEST; break; case 3: dir = SOUTH; break; case 4: dir = EAST; break; default: break; } g_game.internalCreatureSay(this, SPEAK_MONSTER_SAY, "Hicks!", false); } } }
void DeleteNullPointerCheck::registerMatchers(MatchFinder *Finder) { const auto DeleteExpr = cxxDeleteExpr(has(castExpr(has(declRefExpr( to(decl(equalsBoundNode("deletedPointer")))))))) .bind("deleteExpr"); const auto DeleteMemberExpr = cxxDeleteExpr(has(castExpr(has(memberExpr(hasDeclaration( fieldDecl(equalsBoundNode("deletedMemberPointer")))))))) .bind("deleteMemberExpr"); const auto PointerExpr = ignoringImpCasts(anyOf( declRefExpr(to(decl().bind("deletedPointer"))), memberExpr(hasDeclaration(fieldDecl().bind("deletedMemberPointer"))))); const auto PointerCondition = castExpr(hasCastKind(CK_PointerToBoolean), hasSourceExpression(PointerExpr)); const auto BinaryPointerCheckCondition = binaryOperator(hasEitherOperand(castExpr(hasCastKind(CK_NullToPointer))), hasEitherOperand(PointerExpr)); Finder->addMatcher( ifStmt(hasCondition(anyOf(PointerCondition, BinaryPointerCheckCondition)), hasThen(anyOf( DeleteExpr, DeleteMemberExpr, compoundStmt(anyOf(has(DeleteExpr), has(DeleteMemberExpr)), statementCountIs(1)) .bind("compound")))) .bind("ifWithDelete"), this); }
void AssertSideEffectCheck::registerMatchers(MatchFinder *Finder) { auto ConditionWithSideEffect = hasCondition(hasDescendant(expr(hasSideEffect(CheckFunctionCalls)))); Finder->addMatcher( stmt(anyOf(conditionalOperator(ConditionWithSideEffect), ifStmt(ConditionWithSideEffect))).bind("condStmt"), this); }
void Creature::onEndCondition(const Condition* condition, bool preEnd /*= true*/) { if(!preEnd){ if(condition->getName() == CONDITION_INVISIBLE.toString() && !hasCondition(CONDITION_INVISIBLE)){ g_game.internalCreatureChangeVisible(this, true); } } }
void Creature::onAddCondition(ConditionType_t type, bool hadCondition) { if(type == CONDITION_INVISIBLE) { if(!hadCondition) g_game.internalCreatureChangeVisible(this, VISIBLE_DISAPPEAR); } else if(type == CONDITION_PARALYZE) { if(hasCondition(CONDITION_HASTE)) removeCondition(CONDITION_HASTE); } else if(type == CONDITION_HASTE) { if(hasCondition(CONDITION_PARALYZE)) removeCondition(CONDITION_PARALYZE); } }
bool Creature::addCombatCondition(Condition* condition) { bool hadCondition = hasCondition(condition->getType(), -1, false); //Caution: condition variable could be deleted after the call to addCondition ConditionType_t type = condition->getType(); if(!addCondition(condition)) return false; onAddCombatCondition(type, hadCondition); return true; }
void Creature::onWalk(Direction& dir) { if (hasCondition(CONDITION_DRUNK)) { uint32_t r = uniform_random(0, 20); if (r <= DIRECTION_DIAGONAL_MASK) { if (r < DIRECTION_DIAGONAL_MASK) { dir = static_cast<Direction>(r); } g_game.internalCreatureSay(this, TALKTYPE_MONSTER_SAY, "Hicks!", false); } } }
void Creature::onAddCondition(const Condition* condition, bool preAdd /*= true*/) { if(preAdd && condition->getName() == CONDITION_INVISIBLE.toString() && !hasCondition(CONDITION_INVISIBLE)){ g_game.internalCreatureChangeVisible(this, false); } else if(condition->getMechanicType() == MECHANIC_PARALYZED){ removeCondition(CONDITION_HASTE); } else if(condition->getName() == "haste" ){ removeCondition(MECHANIC_PARALYZED); } }
//============================================================================= // METHOD : SPELLcontroller::doInterrupt //============================================================================= void SPELLcontroller::doInterrupt() { SPELLexecutorStatus currentStatus = getStatus(); switch(currentStatus) { case STATUS_RUNNING: // Allowed status case STATUS_PAUSED: // Allowed status case STATUS_WAITING: // Allowed status break; default: DEBUG("[C] Discard interrupt command in current status " + SPELLexecutorUtils::statusToString(currentStatus)); return; } if (m_error) return; // Do not continue on error // Do not process interrupt if there is nothing ongoing if (!m_controllerLock.isClear() && !SPELLexecutor::instance().getScheduler().waiting()) { DEBUG("[C] Discard interrupt command as no driver operation is ongoing"); SPELLexecutor::instance().getCIF().write("No ongoing operations to be interrupted", LanguageConstants::SCOPE_SYS ); return; } else { SPELLexecutor::instance().getCIF().warning("Interrupt current operation", LanguageConstants::SCOPE_SYS ); } DEBUG("[C] Do interrupt"); DEBUG("[C] Set step mode"); setMode( MODE_STEP ); setStatus( STATUS_INTERRUPTED ); // Enable the pause flag for the line event to hold the execution m_wantPause = true; // Enable the interrupt flag to report the correct status m_wantInterrupt = true; // Enable the stepping mechanism m_execLock.clear(); if (hasCondition()) { SPELLexecutor::instance().getCIF().warning("Execution schedule condition has been cancelled", LanguageConstants::SCOPE_SYS ); SPELLexecutor::instance().getScheduler().abortWait(false); } else { SPELLexecutor::instance().getScheduler().interruptWait(); } DEBUG("[C] Do interrupt done"); }
bool Monster::hasToThinkAboutCreature(const CreaturePC& creature) const { assert(creature != nullptr); if (Creature::hasToThinkAboutCreature(creature)) { return true; } auto controller = creature->getController(); if (controller != nullptr) { if (controller->hasCondition(CONDITION_GAMEMASTER, GAMEMASTER_SNEAKY, false)) { return false; } return true; } return false; }
bool Creature::addCondition(Condition* condition) { if(!condition) return false; bool hadCondition = hasCondition(condition->getType(), -1, false); if(Condition* previous = getCondition(condition->getType(), condition->getId(), condition->getSubId())) { previous->addCondition(this, condition); delete condition; return true; } if(condition->startCondition(this)) { conditions.push_back(condition); onAddCondition(condition->getType(), hadCondition); return true; } delete condition; return false; }
void Creature::onEndCondition(ConditionType_t type) { if(type == CONDITION_INVISIBLE && !hasCondition(CONDITION_INVISIBLE, -1, false)) g_game.internalCreatureChangeVisible(this, VISIBLE_APPEAR); }
bool Creature::hasCondition(ConditionId id) const { return hasCondition(id.toString()); }
void SuspiciousStringCompareCheck::registerMatchers(MatchFinder *Finder) { // Match relational operators. const auto ComparisonUnaryOperator = unaryOperator(hasOperatorName("!")); const auto ComparisonBinaryOperator = binaryOperator(matchers::isComparisonOperator()); const auto ComparisonOperator = expr(anyOf(ComparisonUnaryOperator, ComparisonBinaryOperator)); // Add the list of known string compare-like functions and add user-defined // functions. std::vector<std::string> FunctionNames = utils::options::parseStringList( (llvm::Twine(KnownStringCompareFunctions) + StringCompareLikeFunctions) .str()); // Match a call to a string compare functions. const auto FunctionCompareDecl = functionDecl(hasAnyName(std::vector<StringRef>(FunctionNames.begin(), FunctionNames.end()))) .bind("decl"); const auto DirectStringCompareCallExpr = callExpr(hasDeclaration(FunctionCompareDecl)).bind("call"); const auto MacroStringCompareCallExpr = conditionalOperator(anyOf( hasTrueExpression(ignoringParenImpCasts(DirectStringCompareCallExpr)), hasFalseExpression(ignoringParenImpCasts(DirectStringCompareCallExpr)))); // The implicit cast is not present in C. const auto StringCompareCallExpr = ignoringParenImpCasts( anyOf(DirectStringCompareCallExpr, MacroStringCompareCallExpr)); if (WarnOnImplicitComparison) { // Detect suspicious calls to string compare: // 'if (strcmp())' -> 'if (strcmp() != 0)' Finder->addMatcher( stmt(anyOf(ifStmt(hasCondition(StringCompareCallExpr)), whileStmt(hasCondition(StringCompareCallExpr)), doStmt(hasCondition(StringCompareCallExpr)), forStmt(hasCondition(StringCompareCallExpr)), binaryOperator( anyOf(hasOperatorName("&&"), hasOperatorName("||")), hasEitherOperand(StringCompareCallExpr)))) .bind("missing-comparison"), this); } if (WarnOnLogicalNotComparison) { // Detect suspicious calls to string compared with '!' operator: // 'if (!strcmp())' -> 'if (strcmp() == 0)' Finder->addMatcher(unaryOperator(hasOperatorName("!"), hasUnaryOperand(ignoringParenImpCasts( StringCompareCallExpr))) .bind("logical-not-comparison"), this); } // Detect suspicious cast to an inconsistant type (i.e. not integer type). Finder->addMatcher( implicitCastExpr(unless(hasType(isInteger())), hasSourceExpression(StringCompareCallExpr)) .bind("invalid-conversion"), this); // Detect suspicious operator with string compare function as operand. Finder->addMatcher( binaryOperator( unless(anyOf(matchers::isComparisonOperator(), hasOperatorName("&&"), hasOperatorName("||"), hasOperatorName("="))), hasEitherOperand(StringCompareCallExpr)) .bind("suspicious-operator"), this); // Detect comparison to invalid constant: 'strcmp() == -1'. const auto InvalidLiteral = ignoringParenImpCasts( anyOf(integerLiteral(unless(equals(0))), unaryOperator( hasOperatorName("-"), has(ignoringParenImpCasts(integerLiteral(unless(equals(0)))))), characterLiteral(), cxxBoolLiteral())); Finder->addMatcher(binaryOperator(matchers::isComparisonOperator(), hasEitherOperand(StringCompareCallExpr), hasEitherOperand(InvalidLiteral)) .bind("invalid-comparison"), this); }