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);
}
