public void HegdingToValue(string strAttrName, ref uint attrValue)
{
GetAttrValueByName(strAttrName, ref attrValue);
AttrNameData attrItem = GameSystem.Instance.AttrNameConfigData.AttrNameDatas.Find((AttrNameData item) => { return(item.symbol == strAttrName); });
if (attrItem == null)
{
return;
}
Debug.Log("Player id: " + m_player.m_id + " attrName: " + strAttrName + " , attrValue0: " + attrValue);
if (attrItem.type != AttributeType.HEDGINGLEVEL)
{
return;
}
AttrData attrData = m_player.m_attrData;
HedgingConfig.hedgeLevelData data = GameSystem.Instance.HedgingConfig.GetHedgeLevelFactor(attrItem.id);
if (data != null)
{
IM.PrecNumber factor = data.factor;
uint attrID = data.oppositeID;
string symbol = GameSystem.Instance.AttrNameConfigData.GetAttrSymbol(attrID);
if (attrData.attrs.ContainsKey(symbol))
{
Debug.Log("Attr data: " + attrData.attrs[symbol] + " factor: " + factor);
attrValue = (uint)(attrData.attrs[symbol] * (1 + attrValue * factor)).roundToInt;
}
}
Debug.Log("Player id: " + m_player.m_id + " attrName: " + strAttrName + " , attrValue1: " + attrValue);
}
public override IM.PrecNumber AdjustShootRate(Player shooter, IM.PrecNumber rate)
{
if (shooter.m_StateMachine.m_curState.m_eState == PlayerState.State.eLayup ||
shooter.m_StateMachine.m_curState.m_eState == PlayerState.State.eDunk)
return IM.PrecNumber.one;
else
return IM.PrecNumber.zero;
}
public override IM.PrecNumber AdjustShootRate(Player shooter, IM.PrecNumber rate)
{
if (shooter == attacker)
{
return(IM.Number.zero);
}
else
{
return(rate);
}
}
public override IM.PrecNumber AdjustShootRate(Player shooter, IM.PrecNumber rate)
{
if (!blocked)
{
return(IM.Number.one);
}
else
{
return(rate);
}
}
public override IM.PrecNumber AdjustShootRate(Player shooter, IM.PrecNumber rate)
{
if (curStep.mustGoal)
{
return(IM.PrecNumber.one);
}
else if (curStep.cantGoal)
{
return(IM.PrecNumber.zero);
}
return(rate);
}
override public void OnEnter(PlayerState lastState)
{
base.OnEnter(lastState);
m_player.m_bMovedWithBall = true;
m_bDefenderOp = false;
m_bChecked = false;
PlayerAnimAttribute.AnimAttr crossoverAttr = m_player.m_animAttributes.GetAnimAttrById(Command.CrossOver, m_curAction);
if (crossoverAttr == null)
{
Debug.LogError("Current action: " + m_curAction + " in crossover id: " + m_curExecSkill.skill.id);
}
IM.Number frameRate = m_player.animMgr.GetFrameRate(m_curAction);
m_player.m_blockable.Init(crossoverAttr, frameRate);
SkillInput input = m_curExecSkill.curAction.inputs[0];
if (input.moveDir == EDirection.eLeft ||
(input.moveDir == EDirection.eForward && input.moveAngleRange.x >= IM.Math.HALF_CIRCLE && input.moveAngleRange.y >= IM.Math.HALF_CIRCLE))
{
m_crossDir = CrossDir.Left;
}
else if (input.moveDir == EDirection.eRight ||
(input.moveDir == EDirection.eForward && input.moveAngleRange.x <= IM.Math.HALF_CIRCLE && input.moveAngleRange.y <= IM.Math.HALF_CIRCLE))
{
m_crossDir = CrossDir.Right;
}
else
{
m_crossDir = CrossDir.None;
}
m_player.forward = GameUtils.HorizonalNormalized(m_basket.m_vShootTarget, m_player.position);
uint uSkillValue = 0;
m_player.m_skillSystem.HegdingToValue("cross_speed", ref uSkillValue);
//float crossSpeed = (m_player.m_finalAttrs["cross_speed"] + uSkillValue) * 0.0036f + 1f;(添加精度更高Number，还末测试)
IM.PrecNumber crossSpeed = new IM.PrecNumber((int)(m_player.m_finalAttrs["cross_speed"] + uSkillValue)) * new IM.PrecNumber(0, 003600) + IM.PrecNumber.one;
m_player.animMgr.Play(m_curAction, (IM.Number)crossSpeed, true).rootMotion.Reset();
targetPos = GetEndPos();
++m_player.mStatistics.data.cross_times;
}
public virtual ShootSolution GetShootSolution(UBasket basket, Area area, Player shooter, IM.PrecNumber rate)
{
return(null);
}
public override IM.PrecNumber AdjustShootRate(Player shooter, IM.PrecNumber rate)
{
return(IM.PrecNumber.zero);
}
public override ShootSolution GetShootSolution(UBasket basket, Area area, Player shooter, IM.PrecNumber rate)
{
if (in_tutorial)
{
return(GameSystem.Instance.shootSolutionManager.GetShootSolution(25, false, 1));
}
else
{
return(null);
}
}
public virtual IM.PrecNumber AdjustShootRate(Player shooter, IM.PrecNumber rate)
{
return(rate);
}
public override ShootSolution GetShootSolution(UBasket basket, Area area, Player shooter, IM.PrecNumber rate, ShootSolution.Type type)
{
ShootSolution solution = practise_behaviour.GetShootSolution(basket, area, shooter, rate);
if (solution == null)
{
solution = base.GetShootSolution(basket, area, shooter, rate, type);
}
Debug.Log("Practise shoot solution: " + solution.m_id);
return(solution);
}
void _CalcLayupRate()
{
if (m_bRateFixed)
{
return;
}
IM.Number fSideEffect = IM.Number.zero;
SkillSideEffect effect;
if (m_curExecSkill.skill.side_effects.TryGetValue((int)SkillSideEffect.Type.eShootRate, out effect))
{
fSideEffect = effect.value;
}
//else
// Debug.Log("No side effect data.");
Dictionary <string, uint> data = m_player.m_finalAttrs;
if (data == null)
{
Debug.LogError("Can not build player: " + m_player.m_name + " ,can not fight state by id: " + m_player.m_id);
return;
}
Dictionary <string, uint> skillAttr = m_player.GetSkillAttribute();
Dictionary <string, uint> playerData = m_player.m_finalAttrs;
//m_player.m_roleInfo.skill_slot_info.Find( (SkillSlotProto skillSlot)=>{ return skillSlot.id == m_curExecSkill.skill.id; } );
uint skillValue = 0;
IM.Number fDisturb = IM.Number.zero;
if (m_player.m_defenseTarget != null)
{
foreach (Player defenser in m_player.m_defenseTarget.m_team.members)
{
if (m_player.m_AOD.GetStateByPos(defenser.position) != AOD.Zone.eInvalid)
{
Dictionary <string, uint> defenderData = defenser.m_finalAttrs;
uint disturb = defenderData["disturb"];
uint disturb_attr = 0;
defenser.m_skillSystem.HegdingToValue("addn_disturb", ref disturb_attr);
//defenser.m_skillSystem.GetAttrValueByName("addn_disturb", ref disturb_attr);
disturb += disturb_attr;
uint fAntiDisturb = data["anti_disturb"];
uint anti_disturb_attr = 0;
m_player.m_skillSystem.HegdingToValue("addn_anti_disturb", ref anti_disturb_attr);
//m_player.m_skillSystem.GetAttrValueByName("addn_anti_disturb", ref anti_disturb_attr);
fAntiDisturb += anti_disturb_attr;
if (m_skillArea == Area.eNear)
{
fDisturb = layupNearHedging.Calc(new IM.Number((int)disturb), new IM.Number((int)fAntiDisturb));
}
else if (m_skillArea == Area.eMiddle)
{
fDisturb = layupMiddleHedging.Calc(new IM.Number((int)disturb), new IM.Number((int)fAntiDisturb));
}
m_bRateFixed = true;
break;
}
}
}
else
{
m_bRateFixed = true;
}
if (m_skillArea == Area.eNear)
{
IM.Number reduceScale = m_match.GetAttrReduceScale("layup_near", m_player);
m_player.m_skillSystem.HegdingToValue("layup_near", ref skillValue);
//m_player.m_skillSystem.GetAttrValueByName("layup_near", ref skillValue);
m_layupRate = ((data["layup_near"] + skillAttr["layup_near"] + skillValue) * layupNearMultiply + layupNearAdd) * reduceScale * (IM.Number.one - fDisturb) + fSideEffect;
}
else if (m_skillArea == Area.eMiddle)
{
IM.Number reduceScale = m_match.GetAttrReduceScale("layup_middle", m_player);
m_player.m_skillSystem.HegdingToValue("layup_middle", ref skillValue);
//m_player.m_skillSystem.GetAttrValueByName("layup_middle", ref skillValue);
m_layupRate = ((data["layup_middle"] + skillAttr["layup_middle"] + skillValue) * layupMiddleMultiply + layupMiddleAdd) * reduceScale * (IM.Number.one - fDisturb) + fSideEffect;
}
SkillSpec skillSpec = m_player.GetSkillSpecialAttribute(SkillSpecParam.eLayup_rate);
if (skillSpec.paramOp == SkillSpecParamOp.eAdd)
{
m_layupRate += skillSpec.value;
}
else if (skillSpec.paramOp == SkillSpecParamOp.eMulti)
{
m_layupRate *= skillSpec.value;
}
m_layupRate = m_match.AdjustShootRate(m_player, m_layupRate);
}
public static PrecNumber Min(PrecNumber x, PrecNumber y)
{
return(y < x ? y : x);
}
public override IM.PrecNumber AdjustShootRate(Player shooter, IM.PrecNumber rate)
{
return(practise_behaviour.AdjustShootRate(shooter, rate));
}
public override ShootSolution GetShootSolution(UBasket basket, Area area, Player shooter, IM.PrecNumber rate)
{
if (curStep.mustGoal || curStep.cantGoal)
{
if (curStep.shootSolution.Key != 0 || curStep.shootSolution.Value != 0)
{
return(GameSystem.Instance.shootSolutionManager.GetShootSolution(curStep.shootSolution.Key, curStep.mustGoal, curStep.shootSolution.Value));
}
}
return(null);
}
public void OnShoot()
{
bool bOpen = false;
if (m_player.m_bWithBall)
{
IM.Number rate_adjustment = IM.Number.zero;
if (m_player.shootStrength != null)
{
m_player.shootStrength.Stop();
rate_adjustment = m_player.shootStrength.rate_adjustment;
Debug.Log("Shoot rate adjustment: " + rate_adjustment);
}
IM.Vector3 target = m_basket.m_vShootTarget;
IM.PrecNumber fShootRate = IM.PrecNumber.one;
Dictionary <string, uint> data = m_player.m_finalAttrs;
Player disturber = null;
if (m_player.m_defenseTarget != null)
{
foreach (Player defenser in m_player.m_defenseTarget.m_team.members)
{
if (m_player.m_AOD.GetStateByPos(defenser.position) == AOD.Zone.eInvalid)
{
continue;
}
disturber = defenser;
break;
}
}
IM.Number fSideEffect = IM.Number.zero;
SkillSideEffect effect;
if (!m_curExecSkill.skill.side_effects.TryGetValue((int)SkillSideEffect.Type.eShootRate, out effect))
{
Debug.Log("No side effect data.");
}
else
{
fSideEffect = effect.value;
}
IM.Number fDisturb = IM.Number.zero;
if (disturber != null)
{
Dictionary <string, uint> disturberData = disturber.m_finalAttrs;
uint disturb = disturberData["disturb"];
uint disturb_attr = 0;
disturber.m_skillSystem.HegdingToValue("addn_disturb", ref disturb_attr);
disturb += disturb_attr;
uint fAntiDisturb = data["anti_disturb"];
uint anti_disturb_attr = 0;
m_player.m_skillSystem.HegdingToValue("addn_anti_disturb", ref anti_disturb_attr);
fAntiDisturb += anti_disturb_attr;
if (m_skillArea == Area.eFar)
{
fDisturb = shootFarHedging.Calc(new IM.Number((int)disturb), new IM.Number((int)fAntiDisturb));
}
else if (m_skillArea == Area.eNear)
{
fDisturb = shootNearHedging.Calc(new IM.Number((int)disturb), new IM.Number((int)fAntiDisturb));
}
else if (m_skillArea == Area.eMiddle)
{
fDisturb = shootMiddleHedging.Calc(new IM.Number((int)disturb), new IM.Number((int)fAntiDisturb));
}
if (disturber.m_StateMachine.m_curState.m_eState == PlayerState.State.eDefense)
{
fDisturb *= IM.Number.one;
}
else if (disturber.m_StateMachine.m_curState.m_eState == PlayerState.State.eBlock)
{
fDisturb *= IM.Number.one;
}
else
{
fDisturb = IM.Number.zero;
//Debug.Log("Can't disturb, state: " + disturber.m_StateMachine.m_curState.m_eState);
}
}
Debugger.Instance.m_steamer.message = " Disturb: " + fDisturb + " ";
IM.Number fDistToTarget = GameUtils.HorizonalDistance(m_player.position, m_basket.m_vShootTarget);
Debugger.Instance.m_steamer.message += "Distance to basket: " + fDistToTarget;
uint uShootData = 0;
uint uShootSkill = 0;
uint uShootFarData = 0;
if (m_skillArea == Area.eFar)
{
data.TryGetValue("shoot_far_dist", out uShootFarData);
IM.Number maxDistance = uShootFarData * new IM.Number(0, 005) + new IM.Number(9, 150);
//long distance influent
IM.Number fLongDistanceInfluent = IM.Number.one;
if (fDistToTarget > maxDistance)
{
fLongDistanceInfluent = new IM.Number(0, 100);
}
IM.Number reduceScale = m_match.GetAttrReduceScale("shoot_far", m_player);
data.TryGetValue("shoot_far", out uShootData);
m_player.m_skillSystem.HegdingToValue("shoot_far", ref uShootSkill);
//m_player.m_skillSystem.GetAttrValueByName("shoot_far", ref uShootSkill);
fShootRate = ((uShootData + uShootSkill) * reduceScale * shootFarMultiply + shootFarAdd) * (IM.Number.one - fDisturb) * fLongDistanceInfluent + fSideEffect;
}
else if (m_skillArea == Area.eNear)
{
IM.Number reduceScale = m_match.GetAttrReduceScale("shoot_near", m_player);
data.TryGetValue("shoot_near", out uShootData);
m_player.m_skillSystem.HegdingToValue("shoot_near", ref uShootSkill);
//m_player.m_skillSystem.GetAttrValueByName("shoot_near", ref uShootSkill);
fShootRate = ((uShootData + uShootSkill) * shootNearMultiply + shootNearAdd) * reduceScale * (IM.Number.one - fDisturb) + fSideEffect;
}
else if (m_skillArea == Area.eMiddle)
{
IM.Number reduceScale = m_match.GetAttrReduceScale("shoot_middle", m_player);
data.TryGetValue("shoot_middle", out uShootData);
m_player.m_skillSystem.HegdingToValue("shoot_middle", ref uShootSkill);
//m_player.m_skillSystem.GetAttrValueByName("shoot_middle", ref uShootSkill);
fShootRate = ((uShootData + uShootSkill) * shootMiddleMultiply + shootMiddleAdd) * reduceScale * (IM.Number.one - fDisturb) + fSideEffect;
}
fShootRate = IM.Math.Max(fShootRate + rate_adjustment, IM.Number.zero);
SkillSpec skillSpec = m_player.GetSkillSpecialAttribute(SkillSpecParam.eShoot_rate);
if (skillSpec.paramOp == SkillSpecParamOp.eAdd)
{
fShootRate += skillSpec.value;
}
else if (skillSpec.paramOp == SkillSpecParamOp.eMulti)
{
fShootRate *= skillSpec.value;
}
fShootRate = m_match.AdjustShootRate(m_player, (IM.Number)fShootRate);
//bool sumValue = false;
//if (!m_ball.m_bBlockSuccess)
// sumValue = m_stateMachine.attackRandom.AdjustRate(ref fShootRate, m_match.GetScore(m_skillArea == Area.eFar ? 3 : 2));
//if (!m_ball.m_bBlockSuccess && solution.m_bSuccess && sumValue)
// m_stateMachine.attackRandom.SumValue(m_match.GetScore(m_skillArea == Area.eFar ? 3 : 2));
bOpen = _CheckOpenShoot();
if (bOpen)
{
fShootRate *= new IM.Number(1, 300);
fShootRate = IM.Math.Min(fShootRate, IM.Number.one);
if (m_skillArea == Area.eFar)
{
++m_player.mStatistics.data.far_open_shoot;
}
else if (m_skillArea == Area.eNear)
{
++m_player.mStatistics.data.near_open_shoot;
}
else if (m_skillArea == Area.eMiddle)
{
++m_player.mStatistics.data.mid_open_shoot;
}
}
if (m_match.m_bTimeUp)
{
fShootRate = IM.Number.zero;
}
Debug.LogWarning("shoot rate==>>>" + fShootRate.ToString());
ShootSolution solution;
if (m_ball.m_bBlockSuccess && m_ball.m_shootSolution != null)
{
solution = m_ball.m_shootSolution;
}
else
{
solution = m_match.GetShootSolution(m_match.mCurScene.mBasket, m_skillArea, m_player, fShootRate, ShootSolution.Type.Shoot);
}
m_ball.m_shootSolution = solution;
Debug.Log("shoot ball success: " + solution.m_bSuccess);
IM.Vector3 vPos = m_ball.position;
uint ballId = m_ball.m_id;
UBasketball curBall = m_ball;
m_player.DropBall(curBall);
curBall.position = vPos;
curBall.OnShoot(m_player, m_skillArea, false);
ShootSolution.SShootCurve shootCurve = curBall.m_shootSolution.m_ShootCurveList[0];
IM.Number fFlyTime = shootCurve.fTime;
curBall.m_castedSkill = m_curExecSkill;
Debugger.Instance.m_steamer.message = " Final shoot rate: " + fShootRate;
}
m_player.eventHandler.NotifyAllListeners(PlayerActionEventHandler.AnimEvent.eShoot, (System.Object)bOpen);
if (m_skillArea == Area.eFar)
{
PlaySoundManager.Instance.PlaySound(MatchSoundEvent.Shot3Pt);
}
else
{
PlaySoundManager.Instance.PlaySound(MatchSoundEvent.Shot2Pt);
}
PlaySoundManager.Instance.PlaySound(MatchSoundEvent.Shoot);
}
public void OnDunk()
{
m_turningSpeed = IM.Number.zero;
m_bRateFixed = true;
if (m_player.m_bWithBall)
{
IM.Number prob = IM.Random.value;
m_dunkRate = m_match.AdjustShootRate(m_player, m_dunkRate);
//bool sumValue = m_stateMachine.attackRandom.AdjustRate(ref m_dunkRate, m_match.GetScore(2));
Debugger.Instance.m_steamer.message += " Dunk rate: ";
Debugger.Instance.m_steamer.message += m_dunkRate;
Debugger.Instance.m_steamer.message += " Probability: ";
Debugger.Instance.m_steamer.message += prob;
IM.Vector3 vBallVel = IM.Vector3.zero;
bool bGoal = prob < m_dunkRate;
//goal
if (bGoal)
{
IM.Number fPower = IM.Number.half;
vBallVel = m_player.forward * fPower;
vBallVel.y = -IM.Number.half;
/*
* if (sumValue)
* m_stateMachine.attackRandom.SumValue(m_match.GetScore(2));
*/
Debugger.Instance.m_steamer.message += " .Dunk goal.\n";
}
//no goal
else
{
IM.Number fPower = IM.Random.Range(IM.Number.two, new IM.Number(5));
vBallVel = (IM.Quaternion.AngleAxis(IM.Random.Range(-new IM.Number(30), new IM.Number(30)), IM.Vector3.up) * m_player.forward + IM.Vector3.up) * fPower;
vBallVel.y = new IM.Number(3);
Debugger.Instance.m_steamer.message += " .Dunk no goal.\n";
}
IM.Vector3 vPos = m_ball.position;
uint uBallId = m_ball.m_id;
UBasketball curBall = m_ball;
m_player.DropBall(curBall);
curBall.position = m_basket.m_vShootTarget;
bool bOpen = true;
if (m_player.m_defenseTarget != null)
{
foreach (Player defenser in m_player.m_defenseTarget.m_team.members)
{
if (m_player.m_AOD.GetStateByPos(defenser.position) != AOD.Zone.eInvalid)
{
bOpen = false;
break;
}
}
}
m_player.mStatistics.SkillUsageSuccess(m_curExecSkill.skill.id, bGoal);
curBall.OnDunk(bGoal, vBallVel, m_basket.m_vShootTarget, m_player);
}
m_stateMachine.m_listeners.ForEach((PlayerStateMachine.Listener lsn) => { lsn.OnDunkDone(m_player); });
m_player.eventHandler.NotifyAllListeners(PlayerActionEventHandler.AnimEvent.eDunk);
}
void _CalcDunkRate()
{
if (m_bRateFixed)
{
return;
}
IM.Number fSideEffect = IM.Number.zero;
SkillSideEffect effect;
if (m_curExecSkill.skill.side_effects.TryGetValue((int)SkillSideEffect.Type.eShootRate, out effect))
{
fSideEffect = effect.value;
}
//else
// Debug.Log("No side effect data.");
Dictionary <string, uint> skillAttr = m_player.GetSkillAttribute();
Dictionary <string, uint> data = m_player.m_finalAttrs;
if (data == null)
{
Debug.LogError("Can not build player: " + m_player.m_name + " ,can not find state by id: " + m_player.m_id);
return;
}
IM.Number fDisturb = IM.Number.zero;
if (m_player.m_defenseTarget != null)
{
foreach (Player defenser in m_player.m_defenseTarget.m_team.members)
{
if (m_player.m_AOD.GetStateByPos(defenser.position) != AOD.Zone.eInvalid)
{
Dictionary <string, uint> defenderData = defenser.m_finalAttrs;
uint disturb = defenderData["disturb"];
uint disturb_attr = 0;
defenser.m_skillSystem.HegdingToValue("addn_disturb", ref disturb_attr);
//defenser.m_skillSystem.GetAttrValueByName("addn_disturb", ref disturb_attr);
disturb += disturb_attr;
uint fAntiDisturb = data["anti_disturb"];
uint anti_disturb_attr = 0;
m_player.m_skillSystem.HegdingToValue("addn_anti_disturb", ref anti_disturb_attr);
//m_player.m_skillSystem.GetAttrValueByName("addn_anti_disturb", ref anti_disturb_attr);
fAntiDisturb += anti_disturb_attr;
if (m_skillArea == Area.eNear)
{
fDisturb = dunkNearHedging.Calc(new IM.Number((int)disturb), new IM.Number((int)fAntiDisturb));
}
else if (m_skillArea == Area.eMiddle)
{
fDisturb = dunkMiddleHedging.Calc(new IM.Number((int)disturb), new IM.Number((int)fAntiDisturb));
}
m_bRateFixed = true;
break;
}
}
}
else
{
m_bRateFixed = true;
}
uint uDunkData = 0;
uint uDunkSkill = 0;
if (m_skillArea == Area.eNear)
{
IM.Number reduceScale = m_match.GetAttrReduceScale("dunk_near", m_player);
data.TryGetValue("dunk_near", out uDunkData);
m_player.m_skillSystem.HegdingToValue("dunk_near", ref uDunkSkill);
//m_player.m_skillSystem.GetAttrValueByName("dunk_near", ref uDunkSkill);
m_dunkRate = ((uDunkData + uDunkSkill) * dunkNearMultiply + dunkNearAdd) * reduceScale * (IM.Number.one - fDisturb) + fSideEffect;
}
else if (m_skillArea == Area.eMiddle)
{
IM.Number reduceScale = m_match.GetAttrReduceScale("dunk_middle", m_player);
data.TryGetValue("dunk_middle", out uDunkData);
m_player.m_skillSystem.HegdingToValue("dunk_middle", ref uDunkSkill);
//m_player.m_skillSystem.GetAttrValueByName("dunk_middle", ref uDunkSkill);
m_dunkRate = ((uDunkData + uDunkSkill) * dunkMiddleMultiply + dunkMiddleAdd) * reduceScale * (IM.Number.one - fDisturb) + fSideEffect;
}
SkillSpec skillSpec = m_player.GetSkillSpecialAttribute(SkillSpecParam.eDunk_rate);
if (skillSpec.paramOp == SkillSpecParamOp.eAdd)
{
m_dunkRate += skillSpec.value;
}
else if (skillSpec.paramOp == SkillSpecParamOp.eMulti)
{
m_dunkRate *= skillSpec.value;
}
m_dunkRate = IM.Math.Max(m_dunkRate, IM.Number.zero);
m_dunkRate = m_match.AdjustShootRate(m_player, m_dunkRate);
}
public static PrecNumber Max(PrecNumber x, PrecNumber y)
{
return(y > x ? y : x);
}
