Vec3 GetRefractedDirection (const Vec3& vec, const Vec3& normal, double refractionIndex)
{
double nr;
Vec3 nNormal;
if ((normal * vec) < 0.0) { // Going into.
nr = 1.0 / refractionIndex;
nNormal = normal;
} else { // Coming out from.
nr = refractionIndex;
nNormal = -1.0 * normal;
}
Vec3 invVec = -1.0 * vec;
double cosAlpha = -(nNormal*vec);
double a = 1.0 - nr*nr * (1.0 - (cosAlpha * cosAlpha));
if (IsGreaterOrEqual (a, 0.0)) {
return nr * vec + (nr * cosAlpha - sqrt (a)) * nNormal;
} else {
return GetReflectedDirection (vec, nNormal);
}
}
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;
}
