bool _CheckCollision_Ground(ShootSolution.SShootCurve curve, ref IM.Number fTime)
{
IM.Number a = curve.fY_a;
IM.Number b = curve.fY_b;
IM.Number c = curve.fY_c - m_ball.m_ballRadius;
IM.Number fTime_1 = (-b - IM.Math.Sqrt(b * b - new IM.Number(4) * a * c)) / IM.Number.two / a;
IM.Number fTime_2 = (-b + IM.Math.Sqrt(b * b - new IM.Number(4) * a * c)) / IM.Number.two / a;
if (fTime_1 > fTime_2)
{
IM.Number fTemp = fTime_2;
fTime_2 = fTime_1;
fTime_1 = fTemp;
}
if (fTime_1 > IM.Number.zero)
{
fTime = fTime_1;
return(true);
}
else if (fTime_2 > IM.Number.zero)
{
fTime = fTime_2;
return(true);
}
return(false);
}
bool _CheckCollision_BackBoard(ShootSolution.SShootCurve curve, ref IM.Number fTime)
{
IM.Number a = curve.fZ_a;
IM.Number b = curve.fZ_b;
IM.Number c = curve.fZ_c - m_basket.m_backboard.center.z + m_ball.m_ballRadius;
if (a == IM.Number.zero)
{
fTime = -c / b;
if (b <= IM.Number.zero)
{
return(false);
}
}
else
{
IM.Number fTime_1 = (-b - IM.Math.Sqrt(b * b - new IM.Number(4) * a * c)) / IM.Number.two / a;
IM.Number fTime_2 = (-b + IM.Math.Sqrt(b * b - new IM.Number(4) * a * c)) / IM.Number.two / a;
if (fTime_1 > fTime_2)
{
IM.Number fTemp = fTime_2;
fTime_2 = fTime_1;
fTime_1 = fTemp;
}
if (fTime_1 > IM.Number.zero)
{
fTime = fTime_1;
}
else if (fTime_2 > IM.Number.zero)
{
fTime = fTime_2;
}
else
{
return(false);
}
}
IM.Vector3 vecBallPos = new IM.Vector3(
curve.fX_a * fTime * fTime + curve.fX_b * fTime + curve.fX_c,
curve.fY_a * fTime * fTime + curve.fY_b * fTime + curve.fY_c,
curve.fZ_a * fTime * fTime + curve.fZ_b * fTime + curve.fZ_c);
if (IM.Math.Abs(vecBallPos.x - m_basket.m_backboard.center.x) < m_basket.m_backboard.width / IM.Number.two &&
IM.Math.Abs(vecBallPos.y - m_basket.m_backboard.center.y) < m_basket.m_backboard.height / IM.Number.two)
{
return(true);
}
return(false);
}
bool _CheckShootSuccess(ShootSolution.SShootCurve shootCurve, ref IM.Number fTime)
{
IM.Number a = shootCurve.fY_a;
IM.Number b = shootCurve.fY_b;
IM.Number c = shootCurve.fY_c - m_basket.m_rim.center.y;
if (b * b - new IM.Number(4) * a * c < IM.Number.zero)
{
return(false);
}
IM.Number fTime_1 = (-b - IM.Math.Sqrt(b * b - new IM.Number(4) * a * c)) / IM.Number.two / a;
IM.Number fTime_2 = (-b + IM.Math.Sqrt(b * b - new IM.Number(4) * a * c)) / IM.Number.two / a;
if (fTime_1 > fTime_2)
{
IM.Number fTemp = fTime_1;
fTime_1 = fTime_2;
fTime_2 = fTemp;
}
if (fTime_2 >= IM.Number.zero && fTime_2 < shootCurve.fTime)
{
fTime = fTime_2;
}
else if (fTime_1 >= IM.Number.zero && fTime_1 < shootCurve.fTime)
{
fTime = fTime_1;
}
else
{
return(false);
}
IM.Vector3 vecBallPos = new IM.Vector3(
shootCurve.fX_a * fTime * fTime + shootCurve.fX_b * fTime + shootCurve.fX_c,
shootCurve.fY_a * fTime * fTime + shootCurve.fY_b * fTime + shootCurve.fY_c,
shootCurve.fZ_a * fTime * fTime + shootCurve.fZ_b * fTime + shootCurve.fZ_c);
IM.Number fEpsilon = new IM.Number(0, 010);
IM.Number fDistRim2Ball = (vecBallPos - m_basket.m_rim.center).magnitude;
if (fDistRim2Ball < (m_basket.m_rim.radius - m_ball.m_ballRadius + fEpsilon))
{
IM.Number speedY = IM.Number.two * shootCurve.fY_a * fTime + shootCurve.fY_b;
if (speedY < IM.Number.zero)
{
return(true);
}
}
return(false);
}
public void CalculateShootCurve(ref ShootSolution.SShootCurve curve, IM.Vector3 vecInitPos, IM.Vector3 vecInitVel)
{
curve.fX_a = IM.Number.zero;
curve.fX_b = vecInitVel.x;
curve.fX_c = vecInitPos.x;
curve.fY_a = IM.Number.half * IM.Vector3.gravity.y;
curve.fY_b = vecInitVel.y;
curve.fY_c = vecInitPos.y;
curve.fZ_a = IM.Number.zero;
curve.fZ_b = vecInitVel.z;
curve.fZ_c = vecInitPos.z;
}
void _DoCollision_BackBoard(IM.Number fBounceBackboard, ShootSolution.SShootCurve shootCurve, IM.Number fTime, ref IM.Vector3 vecResultPos, ref IM.Vector3 vecResultVel)
{
IM.Vector3 vecBallPos = new IM.Vector3(
shootCurve.fX_a * fTime * fTime + shootCurve.fX_b * fTime + shootCurve.fX_c,
shootCurve.fY_a * fTime * fTime + shootCurve.fY_b * fTime + shootCurve.fY_c,
shootCurve.fZ_a * fTime * fTime + shootCurve.fZ_b * fTime + shootCurve.fZ_c);
IM.Vector3 vecBallVel = new IM.Vector3(
vecBallVel.x = IM.Number.two * shootCurve.fX_a * fTime + shootCurve.fX_b,
vecBallVel.y = IM.Number.two * shootCurve.fY_a * fTime + shootCurve.fY_b,
vecBallVel.z = IM.Number.two * shootCurve.fZ_a * fTime + shootCurve.fZ_b);
//vecBallVel.x = -0.7f * vecBallVel.x;
vecBallVel.z = -fBounceBackboard * vecBallVel.z;
vecResultPos = vecBallPos;
vecResultVel = vecBallVel;
}
void OnRebound(UBasketball ball)
{
ShootSolution.SShootCurve curve = ball.CompleteLastCurve();
IM.Number ballMaxHeight = curve.GetHighestPosition().y;
//Debug.Log("Ball max height: " + ballMaxHeight);
IM.Number npcReboundBallHeight = AIUtils.GetNPCReboundBallHeight(npcReboundAttr.maxHeight, playerReboundAttr.maxHeight, ballMaxHeight,
match.npcHeightScale, match.playerHeightScale, match.ballHeightScale);
//Debug.Log("NPC rebound ball height: " + npcReboundBallHeight);
IM.Number time1, time2;
curve.GetTimeByHeight(npcReboundBallHeight, out time1, out time2);
IM.Number ballFlyTime = time2;
//Debug.Log("Ball fly time: " + ballFlyTime);
if (ballFlyTime < -new IM.Number(0, 1))
{
Debug.LogError("Ball fly time error.");
}
SkillInstance basicRebound = m_player.m_skillSystem.GetBasicSkillsByCommand(Command.Rebound)[0];
string basicActionId = basicRebound.skill.actions[0].action_id;
IM.Number frameRate = m_player.animMgr.GetFrameRate(basicActionId);
Dictionary <string, PlayerAnimAttribute.AnimAttr> rebounds = m_player.m_animAttributes.m_rebound;
int reboundKey = rebounds[m_player.animMgr.GetOriginName(basicActionId)].GetKeyFrame("OnRebound").frame;
IM.Number reboundActionTime = reboundKey / frameRate;
IM.Number reboundDelayTime = ballFlyTime - reboundActionTime;
if (reboundDelayTime < IM.Number.zero)
{
reboundDelayTime = IM.Number.zero;
}
if (timerRebound == null)
{
timerRebound = new GameUtils.Timer(reboundDelayTime, DoRebound);
}
timerRebound.SetTimer(reboundDelayTime);
timerRebound.stop = false;
}
void _DoCollision_Rim(IM.Vector3 vBounceRim, ShootSolution.SShootCurve shootCurve, IM.Number fTime, ref IM.Vector3 vecResultPos, ref IM.Vector3 vecResultVel)
{
fTime -= new IM.Number(0, 001);
IM.Vector3 vecBallPos = new IM.Vector3(
shootCurve.fX_a * fTime * fTime + shootCurve.fX_b * fTime + shootCurve.fX_c,
shootCurve.fY_a * fTime * fTime + shootCurve.fY_b * fTime + shootCurve.fY_c,
shootCurve.fZ_a * fTime * fTime + shootCurve.fZ_b * fTime + shootCurve.fZ_c);
fTime += new IM.Number(0, 001);
IM.Vector3 vecBallVel = new IM.Vector3(
IM.Number.two * shootCurve.fX_a * fTime + shootCurve.fX_b,
IM.Number.two * shootCurve.fY_a * fTime + shootCurve.fY_b,
IM.Number.two * shootCurve.fZ_a * fTime + shootCurve.fZ_b);
IM.Vector3 vecRim2Ball = vecBallPos - m_basket.m_rim.center;
IM.Vector3 vecRim2BallHori = vecRim2Ball;
vecRim2BallHori.y = IM.Number.zero;
vecRim2BallHori.Normalize();
IM.Vector3 vecContactPos = m_basket.m_rim.center + m_basket.m_rim.radius * vecRim2BallHori;
IM.Vector3 vecForce = vecBallPos - vecContactPos;
vecForce.Normalize();
/*
* if(vecForce.y > 0.7f)
* {
* vecForce.y = 1.0f;
* vecForce.x = vecForce.z = IM.Number.zero;
* }
*/
IM.Number fDotProd = IM.Vector3.Dot(vecBallVel, vecForce);
vecResultVel = vecBallVel - vecForce * fDotProd;
vecResultVel.x *= vBounceRim.x;
vecResultVel.y *= vBounceRim.y;
vecResultVel.z *= vBounceRim.z;
vecResultPos = vecBallPos;
}
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 _DrawCurves()
{
//draw shoot solution
ShootSolution solution = mBall.m_shootSolution;
if (solution == null)
{
return;
}
if (solution.m_fTime > new IM.Number(1000))
{
return;
}
_BuildShootCurves();
int iKeyCount = m_shootCurveKeys.Count;
for (int idx = 0; idx != iKeyCount; idx++)
{
if (idx + 1 >= iKeyCount)
{
break;
}
if (solution.m_bSuccess)
{
Handles.color = Color.red;
}
else
{
if (ShootSimulator.instance != null && solution == ShootSimulator.instance.m_simulatingShootSolution)
{
Handles.color = Color.red;
}
else
{
Handles.color = Color.red;
}
}
Handles.DrawLine(m_shootCurveKeys[idx], m_shootCurveKeys[idx + 1]);
}
if (!solution.m_bSuccess)
{
int iCurveCnt = solution.m_ShootCurveList.Count;
if (iCurveCnt == 0)
{
return;
}
ShootSolution.SShootCurve curve = solution.m_ShootCurveList[iCurveCnt - 1];
Vector3 vPosHighest = (Vector3)curve.GetHighestPosition();
GUIStyle style = new GUIStyle();
style.normal.textColor = Color.red;
Handles.Label(vPosHighest, vPosHighest.y.ToString(), style);
const float dotLineLength = 0.2f;
List <Vector3> poly = new List <Vector3>();
while (vPosHighest.y > 0.0f)
{
poly.Add(vPosHighest);
vPosHighest.y -= dotLineLength;
poly.Add(vPosHighest);
vPosHighest.y -= dotLineLength;
}
Handles.color = Color.red;
Handles.DrawPolyLine(poly.ToArray());
}
}
public bool Save(XmlDocument pDoc, XmlElement pSolution)
{
XmlNode pNodeInit = pDoc.CreateElement("init");
XmlNode pNodePosition = pDoc.CreateElement("position");
XmlNode pNodeVelocity = pDoc.CreateElement("velocity");
XmlNode pNodeBounceRim = pDoc.CreateElement("bounce_rim");
XmlNode pNodeBounceBackboard = pDoc.CreateElement("bounce_backboard");
pSolution.AppendChild(pNodeInit);
pNodeInit.AppendChild(pNodePosition);
pNodeInit.AppendChild(pNodeVelocity);
pNodeInit.AppendChild(pNodeBounceRim);
pNodeInit.AppendChild(pNodeBounceBackboard);
string text = string.Format("{0:f3} {1:f3} {2:f3}", m_vInitPos.x, m_vInitPos.y, m_vInitPos.z);
pNodePosition.AppendChild(pDoc.CreateTextNode(text));
text = string.Format("{0:f3} {1:f3} {2:f3}", m_vInitVel.x, m_vInitVel.y, m_vInitVel.z);
pNodeVelocity.AppendChild(pDoc.CreateTextNode(text));
text = string.Format("{0:f3} {1:f3} {2:f3}", m_vBounceRimAdjustment.x, m_vBounceRimAdjustment.y, m_vBounceRimAdjustment.z);
pNodeBounceRim.AppendChild(pDoc.CreateTextNode(text));
text = string.Format("{0:f3}", m_fBounceBackboard);
pNodeBounceBackboard.AppendChild(pDoc.CreateTextNode(text));
XmlNode pNodeTime = pDoc.CreateElement("time");
pSolution.AppendChild(pNodeTime);
pNodeTime.AppendChild(pDoc.CreateTextNode(m_fTime.ToString()));
XmlNode pNodeCleanShot = pDoc.CreateElement("clean_shot");
pSolution.AppendChild(pNodeCleanShot);
pNodeCleanShot.AppendChild(pDoc.CreateTextNode(m_bCleanShot.ToString()));
XmlNode pNodeType = pDoc.CreateElement("type");
pSolution.AppendChild(pNodeType);
pNodeType.AppendChild(pDoc.CreateTextNode(((int)m_type).ToString()));
XmlNode pNodeMaxHeight = pDoc.CreateElement("max_height");
pSolution.AppendChild(pNodeMaxHeight);
IM.Number fMaxHeight = m_ShootCurveList[m_ShootCurveList.Count - 1].GetHighestPosition().y;
pNodeMaxHeight.AppendChild(pDoc.CreateTextNode(fMaxHeight.ToString()));
//for editor, don't save the last one.
XmlNode pNodeCurve;
for (int idx = 0; idx != m_ShootCurveList.Count; idx++)
{
ShootSolution.SShootCurve curve = m_ShootCurveList[idx];
string value = string.Format("{0:f3} {1:f3} {2:f3} {3:f3} {4:f3} {5:f3} {6:f3} {7:f3} {8:f3} {9:f3}",
curve.fTime, curve.fX_a, curve.fX_b, curve.fX_c,
curve.fY_a, curve.fY_b, curve.fY_c,
curve.fZ_a, curve.fZ_b, curve.fZ_c);
pNodeCurve = pDoc.CreateElement("curve");
pSolution.AppendChild(pNodeCurve);
pNodeCurve.AppendChild(pDoc.CreateTextNode(value));
}
XmlNode pNodeFin = pDoc.CreateElement("fin");
pNodePosition = pDoc.CreateElement("position");
pNodeVelocity = pDoc.CreateElement("velocity");
pSolution.AppendChild(pNodeFin);
pNodeFin.AppendChild(pNodePosition);
pNodeFin.AppendChild(pNodeVelocity);
text = string.Format("{0:f3} {1:f3} {2:f3}", m_vFinPos.x, m_vFinPos.y, m_vFinPos.z);
pNodePosition.AppendChild(pDoc.CreateTextNode(text));
text = string.Format("{0:f3} {1:f3} {2:f3}", m_vFinVel.x, m_vFinVel.y, m_vFinVel.z);
pNodeVelocity.AppendChild(pDoc.CreateTextNode(text));
XmlNode animationClip = pDoc.CreateElement("animationType");
XmlNode animationTime = pDoc.CreateElement("playTime");
XmlNode animationSpeed = pDoc.CreateElement("playSpeed");
XmlNode reductionIndex = pDoc.CreateElement("redunctionIndex");
XmlNode isLock = pDoc.CreateElement("isLock");
pSolution.AppendChild(animationClip);
animationClip.AppendChild(pDoc.CreateTextNode(((int)m_animationType).ToString()));
pSolution.AppendChild(animationTime);
animationTime.AppendChild(pDoc.CreateTextNode(m_playTime.ToString()));
pSolution.AppendChild(animationSpeed);
animationSpeed.AppendChild(pDoc.CreateTextNode(m_playSpeed.ToString()));
pSolution.AppendChild(reductionIndex);
reductionIndex.AppendChild(pDoc.CreateTextNode(m_reductionIndex.ToString()));
pSolution.AppendChild(isLock);
isLock.AppendChild(pDoc.CreateTextNode(m_isLock.ToString()));
return(true);
}
public bool Create(XmlElement solutionNode, bool bSuccess, bool bForEditor = false)
{
ClearCurve();
m_bSuccess = bSuccess;
XmlElement node = solutionNode.SelectSingleNode("./init/position") as XmlElement;
if (node == null)
{
return(false);
}
m_vInitPos = IM.Vector3.Parse(node.InnerText);
node = solutionNode.SelectSingleNode("./init/velocity") as XmlElement;
if (node == null)
{
return(false);
}
m_vInitVel = IM.Vector3.Parse(node.InnerText);
node = solutionNode.SelectSingleNode("./init/bounce_rim") as XmlElement;
if (node != null)
{
m_vBounceRimAdjustment = IM.Vector3.Parse(node.InnerText);
}
node = solutionNode.SelectSingleNode("./init/bounce_backboard") as XmlElement;
if (node != null)
{
m_fBounceBackboard = IM.Number.Parse(node.InnerText);
}
node = solutionNode.SelectSingleNode("./time") as XmlElement;
if (node == null)
{
return(false);
}
m_fTime = IM.Number.Parse(node.InnerText);
node = solutionNode.SelectSingleNode("./clean_shot") as XmlElement;
if (node != null)
{
m_bCleanShot = bool.Parse(node.InnerText);
}
node = solutionNode.SelectSingleNode("./type") as XmlElement;
if (node != null)
{
m_type = (Type)(int.Parse(node.InnerText));
}
node = solutionNode.SelectSingleNode("./max_height") as XmlElement;
if (node != null)
{
m_fMaxHeight = IM.Number.Parse(node.InnerText);
}
node = solutionNode.SelectSingleNode("./animationType") as XmlElement;
if (node != null)
{
m_animationType = (AnimationType)(int.Parse(node.InnerText));
}
node = solutionNode.SelectSingleNode("./playTime") as XmlElement;
if (node != null)
{
m_playTime = IM.Number.Parse(node.InnerText);
}
node = solutionNode.SelectSingleNode("./playSpeed") as XmlElement;
if (node != null)
{
m_playSpeed = IM.Number.Parse(node.InnerText);
}
node = solutionNode.SelectSingleNode("./redunctionIndex") as XmlElement;
if (node != null)
{
m_reductionIndex = IM.Number.Parse(node.InnerText);
}
node = solutionNode.SelectSingleNode("./isLock") as XmlElement;
if (node != null)
{
m_isLock = bool.Parse(node.InnerText);
}
XmlNodeList curveNodes = solutionNode.SelectNodes("./curve");
foreach (XmlElement curveNode in curveNodes)
{
ShootSolution.SShootCurve shootCurve = new ShootSolution.SShootCurve();
string[] values = curveNode.InnerText.Split(' ');
shootCurve.fTime = IM.Number.Parse(values[0]);
shootCurve.fX_a = IM.Number.Parse(values[1]);
shootCurve.fX_b = IM.Number.Parse(values[2]);
shootCurve.fX_c = IM.Number.Parse(values[3]);
shootCurve.fY_a = IM.Number.Parse(values[4]);
shootCurve.fY_b = IM.Number.Parse(values[5]);
shootCurve.fY_c = IM.Number.Parse(values[6]);
shootCurve.fZ_a = IM.Number.Parse(values[7]);
shootCurve.fZ_b = IM.Number.Parse(values[8]);
shootCurve.fZ_c = IM.Number.Parse(values[9]);
m_ShootCurveList.Add(shootCurve);
}
node = solutionNode.SelectSingleNode("./fin/position") as XmlElement;
if (node == null)
{
return(false);
}
m_vFinPos = IM.Vector3.Parse(node.InnerText);
node = solutionNode.SelectSingleNode("./fin/velocity") as XmlElement;
if (node == null)
{
return(false);
}
m_vFinVel = IM.Vector3.Parse(node.InnerText);
int cnt = m_ShootCurveList.Count;
if (!bForEditor && !bSuccess && cnt >= 2)
{
ShootSolution.SShootCurve lastCurve = m_ShootCurveList[cnt - 1];
m_vFinPos.x = lastCurve.fX_c;
m_vFinPos.y = lastCurve.fY_c;
m_vFinPos.z = lastCurve.fZ_c;
m_vFinVel.x = lastCurve.fX_b;
m_vFinVel.y = lastCurve.fY_b;
m_vFinVel.z = lastCurve.fZ_b;
m_fTime -= lastCurve.fTime;
m_ShootCurveList.Remove(lastCurve);
}
return(true);
}
public void OnLayup()
{
m_turningSpeed = IM.Number.zero;
bool bShootOut = false;
bool bOpen = false;
if (m_player.m_bWithBall)
{
/*
* bool sumValue = false;
* if (!m_ball.m_bBlockSuccess)
* sumValue = m_stateMachine.attackRandom.AdjustRate(ref m_layupRate, m_match.GetScore(2));
*/
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, m_layupRate, ShootSolution.Type.Layup);
}
//if (!m_ball.m_bBlockSuccess && solution.m_bSuccess && sumValue)
// m_stateMachine.attackRandom.SumValue(m_match.GetScore(2));
m_ball.m_shootSolution = solution;
IM.Vector3 vPos = m_ball.position;
uint uBallId = m_ball.m_id;
UBasketball curBall = m_ball;
m_player.DropBall(curBall);
curBall.position = vPos;
curBall.m_castedSkill = m_curExecSkill;
curBall.OnShoot(m_player, m_skillArea, true);
ShootSolution.SShootCurve shootCurve = curBall.m_shootSolution.m_ShootCurveList[0];
IM.Number fFlyTime = shootCurve.fTime;
bShootOut = true;
bOpen = _CheckOpenShoot();
if (bOpen)
{
//m_layupRate *= 1.3f;
//m_layupRate = Mathf.Min(m_layupRate, 1.0f);
if (m_skillArea == Area.eNear)
{
++m_player.mStatistics.data.layup_near_open_shoot;
}
else if (m_skillArea == Area.eMiddle)
{
++m_player.mStatistics.data.layup_mid_open_shoot;
}
}
Debugger.Instance.m_steamer.message = " Final shoot rate: " + m_layupRate;
}
m_bRateFixed = true;
m_player.eventHandler.NotifyAllListeners(PlayerActionEventHandler.AnimEvent.eLayup, (System.Object)bOpen);
if (bShootOut)
{
AudioClip clip = AudioManager.Instance.GetClip("Misc/3point_01");
if (clip != null)
{
AudioManager.Instance.PlaySound(clip);
}
}
}
bool _Simulating(IM.Vector3 vecInitPos, IM.Vector3 vecInitVel, ShootSolution.AnimationType type, IM.Number reductionIndex, ref ShootSolution solution)
{
solution.ClearCurve();
ShootSolution.SShootCurve shootCurve = new ShootSolution.SShootCurve();
int iBoundCount = 0;
bool bSuccess = false;
while (true)
{
IM.Vector3 vecFinVel;
IM.Number fTime_Rim = IM.Number.zero;
IM.Number fTime_BackBoard = IM.Number.zero;
IM.Number fTime_Ground = IM.Number.zero;
CalculateShootCurve(ref shootCurve, vecInitPos, vecInitVel);
if (!_CheckCollision_Rim(shootCurve, ref fTime_Rim) || fTime_Rim < new IM.Number(0, 100))
{
fTime_Rim = new IM.Number(10000);
}
if (!_CheckCollision_BackBoard(shootCurve, ref fTime_BackBoard) || fTime_BackBoard < new IM.Number(0, 100))
{
fTime_BackBoard = new IM.Number(10000);
}
if (!_CheckCollision_Ground(shootCurve, ref fTime_Ground))
{
fTime_Ground = new IM.Number(10000);
}
//collide rim
if (fTime_Rim < fTime_BackBoard && fTime_Rim < fTime_Ground)
{
shootCurve.fTime = fTime_Rim;
//if (solution.m_animationType != ShootSolution.AnimationType.none)
// _DoCollision_Rim(solution.m_vBounceRimAdjustment * reductionIndex, shootCurve, fTime_Rim, ref vecInitPos, ref vecInitVel);
//else
_DoCollision_Rim(solution.m_vBounceRimAdjustment, shootCurve, fTime_Rim, ref vecInitPos, ref vecInitVel);
if (_CheckShootSuccess(shootCurve, ref fTime_Rim))
{
bSuccess = true;
}
iBoundCount++;
solution.AddCurve(shootCurve.fTime, shootCurve.fX_a, shootCurve.fX_b, shootCurve.fX_c,
shootCurve.fY_a, shootCurve.fY_b, shootCurve.fY_c, shootCurve.fZ_a, shootCurve.fZ_b, shootCurve.fZ_c);
solution.m_vFinPos = vecInitPos;
solution.m_vFinVel = vecInitVel;
}
//collide backboard
else if (fTime_BackBoard < fTime_Rim && fTime_BackBoard < fTime_Ground)
{
shootCurve.fTime = fTime_BackBoard;
iBoundCount++;
_DoCollision_BackBoard(solution.m_fBounceBackboard, shootCurve, fTime_BackBoard, ref vecInitPos, ref vecInitVel);
if (_CheckShootSuccess(shootCurve, ref fTime_BackBoard))
{
bSuccess = true;
}
solution.AddCurve(shootCurve.fTime, shootCurve.fX_a, shootCurve.fX_b, shootCurve.fX_c,
shootCurve.fY_a, shootCurve.fY_b, shootCurve.fY_c, shootCurve.fZ_a, shootCurve.fZ_b, shootCurve.fZ_c);
solution.m_vFinPos = vecInitPos;
solution.m_vFinVel = vecInitVel;
}
else
{
shootCurve.fTime = fTime_Ground;
IM.Number fTime_Goal = IM.Number.zero;
if (_CheckShootSuccess(shootCurve, ref fTime_Goal))
{
Debug.Log("goal success");
bSuccess = true;
solution.AddCurve(fTime_Goal, shootCurve.fX_a, shootCurve.fX_b, shootCurve.fX_c,
shootCurve.fY_a, shootCurve.fY_b, shootCurve.fY_c, shootCurve.fZ_a, shootCurve.fZ_b, shootCurve.fZ_c);
//goal in rim
vecFinVel = solution.m_vFinVel;
vecFinVel.x *= new IM.Number(0, 100);
vecFinVel.y *= new IM.Number(0, 200);
vecFinVel.z *= new IM.Number(0, 100);
solution.m_vFinVel = vecFinVel;
}
else
{
bSuccess = false;
solution.AddCurve(fTime_Ground, shootCurve.fX_a, shootCurve.fX_b, shootCurve.fX_c,
shootCurve.fY_a, shootCurve.fY_b, shootCurve.fY_c, shootCurve.fZ_a, shootCurve.fZ_b, shootCurve.fZ_c);
}
/*
* else if(iBoundCount > 0)
* {
* bSuccess = false;
*
* vecFinVel = solution.m_vFinVel;
* vecFinVel.x *= 0.5f;
* vecFinVel.y *= 1.3f;
* vecFinVel.z *= 0.5f;
*
* solution.m_vFinVel = vecFinVel;
* solution.AddCurve(fTime_Ground, shootCurve.fX_a, shootCurve.fX_b, shootCurve.fX_c,
* shootCurve.fY_a, shootCurve.fY_b, shootCurve.fY_c, shootCurve.fZ_a, shootCurve.fZ_b, shootCurve.fZ_c);
* }
*/
solution.m_bSuccess = bSuccess;
break;
}
if (iBoundCount > 100)
{
Debug.Log("Invalid shoot solution: too many bounds.");
//solution.ClearCurve();
return(false);
}
if (shootCurve.fTime > new IM.Number(1000))
{
return(false);
}
}
return(true);
}
bool _CheckCollision_Rim(ShootSolution.SShootCurve curve, ref IM.Number fTime)
{
IM.Number fIncTime = new IM.Number(0, 001);
IM.Number fTimeCur = IM.Number.zero;
IM.Vector3 vecBallPos;
int deathLoopGuarder = 0;
while (true)
{
deathLoopGuarder++;
if (deathLoopGuarder > 20000)
{
return(false);
}
fTimeCur += fIncTime;
vecBallPos.x = curve.fX_a * fTimeCur * fTimeCur + curve.fX_b * fTimeCur + curve.fX_c;
vecBallPos.y = curve.fY_a * fTimeCur * fTimeCur + curve.fY_b * fTimeCur + curve.fY_c;
vecBallPos.z = curve.fZ_a * fTimeCur * fTimeCur + curve.fZ_b * fTimeCur + curve.fZ_c;
if (vecBallPos.y < IM.Number.zero)
{
return(false);
}
if (IM.Math.Abs(vecBallPos.y - m_basket.m_rim.center.y) > m_ball.m_ballRadius)
{
continue;
}
if ((vecBallPos - m_basket.m_rim.center).magnitude > (m_ball.m_ballRadius + m_basket.m_rim.radius))
{
continue;
}
IM.Vector3 vecRim2Ball = vecBallPos - m_basket.m_rim.center;
IM.Vector3 vecRim2BallHoriz = vecRim2Ball;
vecRim2BallHoriz.y = IM.Number.zero;
IM.Number fRadiusRim = IM.Math.Sqrt(m_ball.m_ballRadius * m_ball.m_ballRadius - vecRim2Ball.y * vecRim2Ball.y);
IM.Number fDistance2D = vecRim2BallHoriz.magnitude;
if (fDistance2D > m_ball.m_ballRadius)
{
if (fDistance2D < fRadiusRim + m_basket.m_rim.radius)
{
fTime = fTimeCur;
return(true);
}
}
else
{
if (fDistance2D + fRadiusRim > m_basket.m_rim.radius)
{
fTime = fTimeCur;
return(true);
}
}
}
return(false);
}
override public void Update(IM.Number fDeltaTime)
{
base.Update(fDeltaTime);
if (m_player.CanRebound(m_ball) && (timerRebound == null || timerRebound.stop))
{
//Debug.Log("Rebound info of " + m_player.m_name);
ReboundAttrConfig.ReboundAttr attr = GameSystem.Instance.ReboundAttrConfigData.GetReboundAttr(m_player.m_position);
if (attr == null)
{
Debug.LogError("Rebound height config error.");
}
ShootSolution.SShootCurve curve = m_ball.CompleteLastCurve();
IM.Number ballHeight = m_ball.position.y;
ballHeight *= (IM.Number.one - m_system.AI.devBallHeight);
if (ballHeight >= attr.minHeight)
{
//Debug.Log("Rebound max height: " + attr.maxHeight +" Ball height: " + ballHeight + " Rebound height scale: " + attr.reboundHeightScale + " Ball height scale: " + attr.ballHeightScale);
IM.Number npcReboundBallHeight = AIUtils.GetNPCReboundBallHeight(attr.maxHeight, ballHeight, attr.reboundHeightScale, attr.ballHeightScale);
//Debug.Log("NPC rebound ball height: " + npcReboundBallHeight);
IM.Number time1, time2;
curve.GetTimeByHeight(npcReboundBallHeight, out time1, out time2);
IM.Number ballFlyTime = time2;
//Debug.Log("Ball fly time: " + ballFlyTime);
if (ballFlyTime < -new IM.Number(0, 1))
{
Debug.LogError("Ball fly time error.");
}
SkillInstance basicRebound = m_player.m_skillSystem.GetBasicSkillsByCommand(Command.Rebound)[0];
string basicActionId = basicRebound.skill.actions[0].action_id;
IM.Number frameRate = m_player.animMgr.GetFrameRate(basicActionId);
Dictionary <string, PlayerAnimAttribute.AnimAttr> rebounds = m_player.m_animAttributes.m_rebound;
int reboundKey = rebounds[m_player.animMgr.GetOriginName(basicActionId)].GetKeyFrame("OnRebound").frame;
IM.Number reboundActionTime = reboundKey / frameRate;
IM.Number reboundDelayTime = ballFlyTime - m_ball.m_fTime - reboundActionTime;
//Debug.Log("Rebound delay time: " + reboundDelayTime);
if (reboundDelayTime < IM.Number.zero)
{
reboundDelayTime = IM.Number.zero;
}
timerRebound.SetTimer(reboundDelayTime);
timerRebound.stop = false;
return;
}
}
if (m_ball.m_owner != null)
{
m_system.SetTransaction(AIState.Type.eIdle);
}
else
{
IM.Vector3 vMoveTarget = m_ball.position;
if (m_ball.m_ballState == BallState.eUseBall_Shoot)
{
vMoveTarget = m_match.mCurScene.mBasket.m_vShootTarget;
}
vMoveTarget.y = IM.Number.zero;
m_moveTarget = vMoveTarget;
m_player.m_moveType = fogs.proto.msg.MoveType.eMT_Rush;
if (m_ball.m_ballState == BallState.eLoseBall &&
(m_player.m_position == PositionType.PT_PG || m_player.m_position == PositionType.PT_SG))
{
IM.Vector3 ballPos = m_ball.position;
IM.Number distToBall = GameUtils.HorizonalDistance(ballPos, m_player.position);
if (distToBall < PlayerState_BodyThrowCatch.GetMaxDistance(m_player) && ballPos.y <= IM.Number.one)
{
m_system.SetTransaction(AIState.Type.eBodyThrowCatch);
}
}
}
if (timerRebound != null)
{
timerRebound.Update(fDeltaTime);
}
}
