void CSymbolEngineHistory::RegisterAction(int autoplayer_action_code) {
AssertRange(autoplayer_action_code, k_autoplayer_function_beep,
k_autoplayer_function_fold);
// Nothing to do of the "action" was "beep".
if (autoplayer_action_code == k_autoplayer_function_beep) {
return;
}
// Special handling for check/call
// Some people have problems scraping check and call correctly,
// as usually only one of these buttons is visible
// and they often share the same place.
// Others might decide to "call" if it is free to call, etc.
// Therefore we set "_prevaction", "didchec", "didcall" here
// depending on the amount to call.
if ((autoplayer_action_code == k_autoplayer_function_call)
|| (autoplayer_action_code == k_autoplayer_function_check)) {
if (IsSmallerOrEqual(p_symbol_engine_chip_amounts->call(), 0.0)) {
// It was free to check
_autoplayer_actions[BETROUND][k_autoplayer_function_check]++;
SetPrevaction(k_autoplayer_function_check);
} else {
// There was name positive amount to call
_autoplayer_actions[BETROUND][k_autoplayer_function_call]++;
SetPrevaction(k_autoplayer_function_call);
}
} else {
_autoplayer_actions[BETROUND][autoplayer_action_code]++;
SetPrevaction(autoplayer_action_code);
}
}
void CTableLimits::AdjustForReasonableness()
{
write_log(3, "CTableLimits::CheckForReasonableness()\n");
// SB unknown?
if (IsSmallerOrEqual(tablelimit_unreliable_input.sblind, 0))
{
SetSmallBlind(GuessSmallBlindFromBigBlind());
write_log(3, "CTableLimits: adjusting SB\n");
}
// BB unknown?
if (IsSmallerOrEqual(tablelimit_unreliable_input.bblind, 0))
{
SetBigBlind(GuessBigBlindFromSmallBlind());
write_log(3, "CTableLimits: adjusting BB\n");
}
// BB out of range?
if (IsGreater(tablelimit_unreliable_input.bblind, (tablelimit_unreliable_input.sblind*3)))
{
if (IsGreater(tablelimit_unreliable_input.sblind, 0))
{
SetBigBlind(GuessBigBlindFromSmallBlind());
}
}
// SB out of range?
if (IsGreaterOrEqual(tablelimit_unreliable_input.sblind, tablelimit_unreliable_input.bblind))
{
// Formerly this code was checking for SB > BB,
// but up to now we never saw an online-game with identical blinds.
// SB >= BB does usually mean, that SB did already act and complete.
SetSmallBlind(GuessSmallBlindFromBigBlind());
write_log(3, "CTableLimits: adjusting SB\n");
}
// Always force big-bet = 2 * big-blind
SetBigBet(GuessBigBetFromBigBlind());
write_log(3, "CTableLimits: adjusting big bet\n");
}
double CParseTreeNode::EvaluateBinaryExpression(bool log) {
assert(_first_sibbling != NULL);
assert(_second_sibbling != NULL);
assert(_third_sibbling == NULL);
assert(_terminal_name == "");
double value_of_first_sibbling = EvaluateSibbling(_first_sibbling, log);
double value_of_second_sibbling = 0.0;
// Short circuiting
// Don't evaluate unnecessary parts of expressions
if (_node_type == kTokenOperatorLogicalAnd) {
if (value_of_first_sibbling == false) {
return false;
}
value_of_second_sibbling = EvaluateSibbling(_second_sibbling, log);
return (value_of_second_sibbling ? true : false);
} else if (_node_type == kTokenOperatorLogicalOr) {
// Attention!
// We can not look here for "value_of_first_sibbling == true"
// because this way we would only accept true (==1)
// but we want to accept any non-zero value.
// http://www.maxinmontreal.com/forums/viewtopic.php?f=111&t=17899
if (value_of_first_sibbling) {
return true;
}
value_of_second_sibbling = EvaluateSibbling(_second_sibbling, log);
return (value_of_second_sibbling ? true : false);
}
// Short circuiting done
// Now normal evaluation of operators that need both operands
value_of_second_sibbling = EvaluateSibbling(_second_sibbling, log);
switch (_node_type) {
case kTokenOperatorPlus:
return value_of_first_sibbling + value_of_second_sibbling;
case kTokenOperatorMinus:
return value_of_first_sibbling - value_of_second_sibbling;
case kTokenOperatorMultiplication:
return value_of_first_sibbling * value_of_second_sibbling;
case kTokenOperatorDivision:
if (value_of_second_sibbling == 0) {
OH_MessageBox_Error_Warning("Division by zero.");
return kUndefined;
} else {
return value_of_first_sibbling / value_of_second_sibbling;
}
case kTokenOperatorModulo:
if (value_of_second_sibbling == 0) {
OH_MessageBox_Error_Warning("Division by zero.");
return kUndefined;
} else {
return (unsigned long)value_of_first_sibbling
% (unsigned long)value_of_second_sibbling;
}
case kTokenOperatorExponentiation:
return pow(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorEquality:
return IsEqual(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorApproximatellyEqual:
return IsApproximatellyEqual(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorSmaller:
return IsSmaller(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorSmallerOrEqual:
return IsSmallerOrEqual(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorGreater:
return IsGreater(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorGreaterOrEqual:
return IsGreaterOrEqual(value_of_first_sibbling, value_of_second_sibbling);
case kTokenOperatorNotEqual:
case kTokenOperatorLogicalXOr:
return value_of_first_sibbling != value_of_second_sibbling;
case kTokenOperatorBinaryAnd:
return (unsigned long)value_of_first_sibbling
& (unsigned long)value_of_second_sibbling;
case kTokenOperatorBinaryOr:
return (unsigned long)value_of_first_sibbling
| (unsigned long)value_of_second_sibbling;
case kTokenOperatorBinaryXOr:
return (unsigned long)value_of_first_sibbling
^ (unsigned long)value_of_second_sibbling;
case kTokenOperatorBitShiftLeft:
return (unsigned long)value_of_first_sibbling
<< (unsigned long)value_of_second_sibbling;
case kTokenOperatorBitShiftRight:
return (unsigned long)value_of_first_sibbling
>> (unsigned long)value_of_second_sibbling;
case kTokenOperatorPercentage:
return value_of_first_sibbling * value_of_second_sibbling * 0.01;
default: assert(false);
}
return kUndefined;
}
