//public bool IsBlocked(Vector2 pos)
//{
// return true;
//}
public Sector Bounce(IM.Vector2 pos, Sector collideSector, SectorArea area)
{
int iCurSector = CalcSectorIdx(pos.x0z);
int iColomn = m_AngleList.Count;
int iCurColomn = iCurSector % iColomn;
GameMatch match = GameSystem.Instance.mClient.mCurMatch;
IM.Vector3 dirSectorToBasket = GameUtils.HorizonalNormalized(match.mCurScene.mBasket.m_vShootTarget, collideSector.center.x0z);
IM.Vector3 dirSectorToBasketRight = IM.Quaternion.AngleAxis(new IM.Number(90), IM.Vector3.up) * dirSectorToBasket;
IM.Vector2 curRight = dirSectorToBasketRight.xz;
IM.Vector2 dirSector2Pos = (collideSector.center - pos).normalized;
int iNewCol = iCurColomn;
if (IM.Vector2.Dot(dirSector2Pos, curRight) > IM.Number.zero)
{
iNewCol = Mathf.Clamp(iCurColomn + IM.Random.Range(3, 6), (int)area.start.x, (int)area.start.x + (int)area.range.x - 1);
}
else
{
iNewCol = Mathf.Clamp(iCurColomn - IM.Random.Range(3, 6), (int)area.start.x, (int)area.start.x + (int)area.range.x - 1);
}
int iNewRow = Mathf.Clamp((int)area.start.y + IM.Random.Range(0, (int)area.range.y), (int)area.start.y, (int)area.start.y + (int)area.range.y - 1);
int index = iNewRow * iColomn + iNewCol;
return(m_Sectors[index]);
//AddDrawSector("targetSector", targetSector);
}
public bool InFreeThrowLane(IM.Vector2 pos)
{
UBasket basket = mScene.mBasket;
IM.Number fDistanceToNet = IM.Vector2.Distance(pos, basket.m_vShootTarget.xz);
return(fDistanceToNet < mFreeThrowLane);
}
public void ConstrainMovementOnBegin(IM.Number fCurTime)
{
if (prepareTime < fCurTime)
{
return;
}
foreach (Player player in GameSystem.Instance.mClient.mPlayerManager)
{
IM.Vector2 curPos = new IM.Vector2(player.position.x, player.position.z);
GameScene scene = m_match.mCurScene;
IM.Vector2 vPt3Center = scene.mGround.mCenter.xz + scene.mGround.m3PointCenter;
IM.Vector2 dirCharToPt3Center = (curPos - vPt3Center).normalized;
if (player.m_team.m_role == GameMatch.MatchRole.eDefense)
{
if (!scene.mGround.In3PointRange(curPos, -F_KEEP_DIST_DEFENSE))
{
curPos = dirCharToPt3Center * (scene.mGround.m3PointRadius - F_KEEP_DIST_DEFENSE) + vPt3Center;
player.position = new IM.Vector3(curPos.x, player.position.y, curPos.y);
}
}
else
{
if (scene.mGround.In3PointRange(curPos, -F_KEEP_DIST_OFFENSE))
{
curPos = dirCharToPt3Center * (scene.mGround.m3PointRadius + F_KEEP_DIST_DEFENSE) + vPt3Center;
player.position = new IM.Vector3(curPos.x, player.position.y, curPos.y);
}
}
}
}
public Sector(int index)
{
idx = index;
distance = IM.Vector2.zero;
distance1 = IM.Vector2.zero;
range = IM.Vector2.zero;
center = IM.Vector2.zero;
}
public Area GetArea(Player player)
{
IM.Vector2 vPlayerPos = player.position.xz;
if (!In3PointRange(vPlayerPos))
{
return(Area.eFar);
}
if (InFreeThrowLane(vPlayerPos))
{
return(Area.eNear);
}
return(Area.eMiddle);
}
public bool DoSimulate(int sector, IM.Vector2 angleAdjustment, IM.Number speed, ShootSolution.AnimationType type, IM.Number reductionIndex, ref ShootSolution solution)
{
if (sector == -1)
{
return(false);
}
IM.Vector3 vecInitPos, vecInitVel;
IM.Vector3 vecFinPos, vecFinVel;
/*
* if(sector == 0)
* {
* vecInitPos = m_basket.m_rim.center;
* vecInitVel = new IM.Vector3(0.0f, 0.0f, 1.0f);
*
* vecInitVel = Quaternion.AngleAxis(m_fBeta, IM.Vector3.up) * vecInitVel;
* vecInitVel = Quaternion.AngleAxis(m_fAlpha, IM.Vector3.Cross(vecInitVel.normalized, IM.Vector3.up)) * vecInitVel;
*
* vecInitVel.Normalize();
* vecInitVel *= m_fVel_ini;
* }
* else
*/
{
vecInitPos = m_ball.position;
vecInitVel = m_basket.m_rim.center - vecInitPos;
vecInitVel.y = IM.Number.zero;
vecInitVel = IM.Quaternion.AngleAxis(angleAdjustment.x, IM.Vector3.up) * vecInitVel;
vecInitVel = IM.Quaternion.AngleAxis(angleAdjustment.y, IM.Vector3.Cross(vecInitVel.normalized, IM.Vector3.up)) * vecInitVel;
vecInitVel.Normalize();
vecInitVel *= speed;
}
solution.m_vInitPos = vecInitPos;
solution.m_vInitVel = vecInitVel;
solution.m_vFinPos = vecInitPos;
solution.m_vFinVel = vecInitVel;
solution.m_vStartPos = vecInitPos;
_Simulating(vecInitPos, vecInitVel, type, reductionIndex, ref solution);
vecInitPos = solution.m_vInitPos;
vecFinPos = solution.m_vFinPos;
vecFinVel = solution.m_vFinVel;
return(true);
}
public Area GetDunkArea(Player player)
{
IM.Vector2 vPlayerPos = player.position.xz;
GameMatch match = GameSystem.Instance.mClient.mCurMatch;
IM.Number fDistance = GameUtils.HorizonalDistance(match.mCurScene.mBasket.m_vShootTarget, player.position);
if (InFreeThrowLane(vPlayerPos))
{
return(Area.eNear);
}
return(Area.eMiddle);
//else if( fDistance < player.m_dunkDistance )
// return Area.eMiddle;
//return Area.eInvalid;
}
public IM.Number GetDistTo3PTLine(IM.Vector2 pos)
{
IM.Vector2 v3PtCenter = new IM.Vector2(mCenter.x + m3PointCenter.x, mCenter.z + m3PointCenter.y);
IM.Vector2 dir = (pos - v3PtCenter).normalized;
IM.Vector2 dirPoint3Forward = new IM.Vector2(IM.Number.zero, -IM.Number.one);
IM.Number angle = IM.Vector2.Angle(dir, dirPoint3Forward);
if (angle > m3PointMaxAngle)
{
return(m3PointBaseLine - IM.Math.Abs(pos.x));
}
else
{
return(m3PointRadius - IM.Vector2.Distance(pos, v3PtCenter));
}
}
IM.Vector3 GetPositionWithOutBall()
{
int colomn = RoadPathManager.Instance.m_AngleList.Count;
IM.Vector2 dirRim2Player = (m_player.position - m_basket.m_rim.center).normalized.xy;
int sectorIdx = 0;
int iCol = 0;
if (IM.Vector2.Dot(dirRim2Player, IM.Vector2.right) > IM.Number.zero)
{
iCol = IM.Random.Range(0, (int)m_player.m_favorSectors.range.x / 2);
}
else
{
iCol = IM.Random.Range((int)m_player.m_favorSectors.range.x / 2, (int)m_player.m_favorSectors.range.x);
}
int iRow = (int)m_player.m_favorSectors.start.y + IM.Random.Range(0, (int)m_player.m_favorSectors.range.y);
sectorIdx = colomn * iRow + iCol;
RoadPathManager.Sector sector = RoadPathManager.Instance.m_Sectors[sectorIdx];
IM.Number dev = m_system.AI.devFavArea;
int count = 0;
do
{
IM.Vector3 pos = new IM.Vector3(sector.center.x + IM.Random.Range(-dev, dev), IM.Number.zero, sector.center.y + IM.Random.Range(-dev, dev));
sectorIdx = RoadPathManager.Instance.CalcSectorIdx(pos);
} while (sectorIdx == -1 && count++ < 10);
if (sectorIdx != -1)
{
sector = RoadPathManager.Instance.m_Sectors[sectorIdx];
}
else
{
Debug.LogError("AI_Positioning, sector(-1). Name:" + m_player.m_name +
" SectorIdx:" + sector.idx + " Center:" + sector.center + " Dev:" + dev);
}
RoadPathManager.Instance.AddDrawSector(m_player.m_id + "_ToSector", sector);
return(sector.center.x0z);
}
public void ReadyToCountShoot()
{
mType = GoalType.eNone;
IM.Vector3 pPosition = m_player.position;
IM.Vector2 playerPos = pPosition.xz;
if (m_curMatch.mCurScene.mGround.InFreeThrowLane(playerPos))
{
mType = GoalType.eGoalNear;
}
else if (m_curMatch.mCurScene.mGround.In3PointRange(playerPos, IM.Number.zero))
{
mType = GoalType.eGoalMiddle;
}
else
{
mType = GoalType.eGoalFar;
}
//Debug.Log("ready to count");
}
public static void PositionAndShoot(AIState.Type positionState, AIState.Type shootState, GameMatch match, Player player)
{
PlayGround ground = match.mCurScene.mGround;
Area currArea = ground.GetArea(player);
bool outside = false;
if (currArea == Area.eFar)
{
outside = !ground.In3PointRange(player.position.xz, ground.mDist3PtOutside);
}
Area bestArea = GetBestShootArea(player);
if (currArea == bestArea && !outside)
{
player.m_aiMgr.SetTransaction(shootState);
}
else
{
IM.Vector2 v3PtCenter = new IM.Vector2(ground.mCenter.x + ground.m3PointCenter.x, ground.mCenter.z + ground.m3PointCenter.y);
IM.Vector2 playerPos = player.position.xz;
IM.Vector2 basketPos = match.mCurScene.mBasket.m_vShootTarget.xz;
IM.Number fDistanceToNet = IM.Vector2.Distance(playerPos, basketPos);
IM.Number fDistTo3PtCenter = IM.Vector2.Distance(playerPos, v3PtCenter);
IM.Vector2 dirOut = (playerPos - v3PtCenter).normalized;
IM.Number angle = IM.Vector2.Angle(dirOut, -IM.Vector2.up);
IM.Number dist = IM.Number.zero;
IM.Vector2 dir = IM.Vector2.up;
if (bestArea == Area.eNear)
{
dist = fDistanceToNet - match.mCurScene.mGround.mFreeThrowLane;
dir = (basketPos - playerPos).normalized;
}
else if (bestArea == Area.eMiddle)
{
if (currArea == Area.eNear)
{
dist = match.mCurScene.mGround.mFreeThrowLane - dist;
dir = (playerPos - basketPos).normalized;
}
else
{
if (angle > ground.m3PointMaxAngle)
{
dist = IM.Math.Abs(playerPos.x) - ground.m3PointBaseLine;
dir = playerPos.x > IM.Number.zero ? -IM.Vector2.right : IM.Vector2.right;
}
else
{
dist = fDistTo3PtCenter - ground.m3PointRadius;
dir = -dirOut;
}
}
}
else if (bestArea == Area.eFar)
{
if (outside)
{
if (angle > ground.m3PointMaxAngle)
{
dist = IM.Math.Abs(playerPos.x) - (ground.m3PointBaseLine + ground.mDist3PtOutside);
dir = playerPos.x > IM.Number.zero ? -IM.Vector2.right : IM.Vector2.right;
}
else
{
dist = fDistTo3PtCenter - (ground.m3PointRadius + ground.mDist3PtOutside);
dir = -dirOut;
}
}
else
{
if (angle > ground.m3PointMaxAngle)
{
dist = ground.m3PointBaseLine - IM.Math.Abs(playerPos.x);
dir = playerPos.x > IM.Number.zero ? IM.Vector2.right : -IM.Vector2.right;
}
else
{
dist = ground.m3PointRadius - fDistTo3PtCenter;
dir = dirOut;
}
}
}
if (dist < match.gameMode.repositionDist)
{
AIState state = player.m_aiMgr.GetState(positionState);
state.m_moveTarget = player.position + new IM.Vector3(dir.x, IM.Number.zero, dir.y) * dist;
player.m_aiMgr.SetTransaction(state);
}
else
{
player.m_aiMgr.SetTransaction(shootState);
}
}
}
public bool In3PointRange(IM.Vector2 pos)
{
return(In3PointRange(pos, IM.Number.zero));
}
public bool In3PointRange(IM.Vector2 pos, IM.Number fOffset)
{
IM.Number dist = GetDistTo3PTLine(pos);
return((dist + fOffset) > 0);
}
static public IM.Vector3 XmlGetAttr_IMVec3(XmlElement el)
{
IM.Vector2 vec2 = XmlGetAttr_IMVec2(el);
return(new IM.Vector3(vec2.x, vec2.y, XmlGetAttr_Number(el, "z")));
}
