using RichCreator.Utility.Structs;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
using RichCreator.Utility.Skills;
|
using RichCreator.Utility.InputControl;
|
using RichCreator.Utility.PathFinding;
|
using RichCreator.Utility.Utilitys;
|
|
namespace RichCreator.Utility.Maps
|
{
|
/// <summary>
|
/// 房间信息
|
/// </summary>
|
public class HouseInfo
|
{
|
public HouseInfo(HousePathInfo houseInfo)
|
{
|
this.HousePathInfo = houseInfo;
|
InitPathInfo(null);
|
}
|
|
public HouseInfo(Int32 index,MapType mapType,bool isEnd, HIDCode[] skills,Int32[] withoutNumber)
|
{
|
this.Index = index;
|
this.MapType = mapType;
|
this.IsEnd = isEnd;
|
|
Skills = new SkillQueue();
|
for (int i = 0; skills!=null&&i < skills.Length; i++)
|
{
|
Skills.EnQueue(false,skills[i]);
|
}
|
|
if (index < 0)
|
{
|
throw new ArgumentOutOfRangeException("houseIndex");
|
}
|
|
try
|
{
|
this.HousePathInfo = HousePathInfo.From(this.MapType, index);
|
}
|
catch (Exception e)
|
{
|
throw e;
|
}
|
|
InitPathInfo(withoutNumber);
|
}
|
|
|
/// <summary>
|
/// 房间编号
|
/// </summary>
|
public Int32 Index { get; set; }
|
|
private Direction[] doorDirection = null;
|
/// <summary>
|
/// 门的位置
|
/// todo:cacel
|
/// </summary>
|
public Direction[] DoorDirection
|
{
|
get
|
{
|
return doorDirection;
|
}
|
}
|
|
/// <summary>
|
/// 技能队列
|
/// </summary>
|
public SkillQueue Skills { get; set; }
|
|
/// <summary>
|
/// 是否为结束房间
|
/// </summary>
|
public bool IsEnd { get; set; }
|
|
/// <summary>
|
/// 地图类型
|
/// </summary>
|
public MapType MapType { get; set; }
|
|
|
/// <summary>
|
/// 房间信息
|
/// </summary>
|
public HousePathInfo HousePathInfo { get; private set; }
|
|
/// <summary>
|
/// 路径查找器
|
/// </summary>
|
private Dijkstra<ZTPoint> PathFinder { get; set; }
|
|
/// <summary>
|
/// 定位字典
|
/// </summary>
|
private Dictionary<Int32, ZTPoint> LocationDic = new Dictionary<int, ZTPoint>();
|
|
/// <summary>
|
/// 排除数字
|
/// </summary>
|
public Dictionary<Int32, bool> WithoutNumber = new Dictionary<int, bool>();
|
|
/// <summary>
|
/// 屏幕坐标转地图坐标
|
/// </summary>
|
/// <param name="screenCoordinate"></param>
|
/// <param name="locationParameter"></param>
|
/// <param name="locationCoordinate"></param>
|
/// <returns></returns>
|
public ZTPoint ScreenToMapCoordinate(ZTPoint screenCoordinate,ParametersPoint locationCoor)
|
{
|
if (!LocationDic.ContainsKey(locationCoor.Parameter))
|
{
|
throw new ArgumentOutOfRangeException("不存在的定位点,parameter:" + locationCoor.Parameter.ToString());
|
}
|
|
//目标屏幕坐标+(定位点地图坐标-定位点屏幕坐标)
|
return screenCoordinate.Add(LocationDic[locationCoor.Parameter].Sub(locationCoor.Point));
|
}
|
|
/// <summary>
|
/// 地图坐标转屏幕坐标
|
/// </summary>
|
/// <param name="mapCoordinate"></param>
|
/// <param name="locationParameter"></param>
|
/// <param name="locationCoordinate"></param>
|
/// <returns></returns>
|
public ZTPoint MapToScreenCoordinate(ZTPoint mapCoordinate, ParametersPoint locationCoor)
|
{
|
if (!LocationDic.ContainsKey(locationCoor.Parameter))
|
{
|
throw new ArgumentOutOfRangeException("不存在的定位点,parameter:" + locationCoor.Parameter.ToString());
|
}
|
|
//目标地图坐标-(定位点地图坐标-定位点屏幕坐标)
|
return mapCoordinate.Sub(LocationDic[locationCoor.Parameter].Sub(locationCoor.Point));
|
}
|
|
/// <summary>
|
/// 两点之间寻路
|
/// </summary>
|
/// <param name="start"></param>
|
/// <param name="end"></param>
|
public List<ZTPoint> FindPath(ZTPoint start, ZTPoint end)
|
{
|
if (start.Equals(end))
|
{
|
return new List<ZTPoint>();
|
}
|
|
//查询两点间是否连通
|
if (Iscross(start, end))
|
{
|
//两点直接连通
|
return new List<ZTPoint>() { end };
|
}
|
|
//确保两点不在障碍物里
|
ZTPoint startPathGuid = ZTPoint.Empty;
|
ZTPoint endPathGuid = ZTPoint.Empty;
|
bool inObstacle = EnsureNotInObstacle(out startPathGuid, start);
|
inObstacle = EnsureNotInObstacle(out endPathGuid, end) || inObstacle;
|
|
//查询两点间是否连通
|
if (inObstacle && Iscross(startPathGuid, endPathGuid))
|
{
|
//两点直接连通
|
List<ZTPoint> points = new List<ZTPoint>();
|
if (!start.Equals(startPathGuid))
|
{
|
points.Add(startPathGuid);
|
}
|
if (!end.Equals(endPathGuid))
|
{
|
points.Add(endPathGuid);
|
}
|
points.Add(end);
|
return points;
|
}
|
|
|
//把两点添加到寻路网中
|
AddConnectivityEdgeToFinder(startPathGuid, endPathGuid);
|
|
//寻路，组合路径
|
List<ZTPoint> paths = this.PathFinder.ShortestPath(startPathGuid, endPathGuid);
|
|
//去除寻路网中
|
RemoveStartAndEndVerticeFromFinder(endPathGuid, endPathGuid);
|
|
//生成的路径不包含第一个点，拟如果第一个点是路径引导，则加入路径
|
if (!start.Equals(startPathGuid))
|
{
|
paths.Insert(0, startPathGuid);
|
}
|
|
//如果最后一个点是路径引导点，测加上终点
|
if (!end.Equals(endPathGuid))
|
{
|
paths.Add(end);
|
}
|
|
return paths;
|
}
|
|
|
/// <summary>
|
/// 是否在下一关进门点区域内
|
/// </summary>
|
/// <param name="nextGatePoint"></param>
|
/// <param name="rolePosition"></param>
|
/// <returns></returns>
|
public bool IsInNextGatePoint(out ParametersPoint nextGatePoint, ZTPoint rolePosition)
|
{
|
nextGatePoint = ParametersPoint.Empty;
|
const Int32 X_OFFSET = 5;
|
const Int32 Y_OFFSET = 5;
|
for (Int32 i = 0; i < this.HousePathInfo.NextGates.Count; i++)
|
{
|
ParametersPoint nextGate = this.HousePathInfo.NextGates[i];
|
if (GeoHelper.IsInRect(rolePosition, new ZTRectangle(nextGate.Point.X- X_OFFSET, nextGate.Point.Y- Y_OFFSET, nextGate.Point.X+ X_OFFSET, nextGate.Point.Y+ Y_OFFSET)))
|
{
|
nextGatePoint = nextGate;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// 获取指定方向的进门点
|
/// </summary>
|
/// <param name="dir"></param>
|
/// <returns></returns>
|
public ZTPoint GetNextGatePoint(Direction dir)
|
{
|
int dirNumber = 0;
|
switch (dir)
|
{
|
case Direction.Up:
|
dirNumber = 0;
|
break;
|
case Direction.Right:
|
dirNumber = 1;
|
break;
|
case Direction.Bottom:
|
dirNumber = 2;
|
break;
|
case Direction.Left:
|
dirNumber = 3;
|
break;
|
}
|
for (int i = 0; i < this.HousePathInfo.NextGates.Count; i++)
|
{
|
if (dirNumber == this.HousePathInfo.NextGates[i].Parameter)
|
{
|
return this.HousePathInfo.NextGates[i].Point;
|
}
|
}
|
throw new ArgumentOutOfRangeException("house index:" + this.Index.ToString() + ",direction :" + dir.ToString() + " is not exists!~");
|
}
|
|
/// <summary>
|
/// 判断两点间是否连通
|
/// </summary>
|
/// <param name="start"></param>
|
/// <param name="end"></param>
|
/// <returns></returns>
|
private bool Iscross(ZTPoint start, ZTPoint end)
|
{
|
for (int i = 0; i < this.HousePathInfo.Obstacles.Count; i++)
|
{
|
Intersection interSection = GeoHelper.IntersectionOf(new ZTLinePoint(start, end), this.HousePathInfo.Obstacles[i]);
|
if (interSection != Intersection.None)
|
{
|
return false;
|
}
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// 是否在障碍物里，如果在障碍物里则返回最近的不在障碍物点
|
/// </summary>
|
/// <param name="pathGuidePoint"></param>
|
/// <returns>true:在障碍物，false:不在障碍物里</returns>
|
private bool EnsureNotInObstacle(out ZTPoint pathGuidePoint,ZTPoint source)
|
{
|
pathGuidePoint = ZTPoint.Empty;
|
|
//点是否在障碍物里
|
ZTPolygon obstacle = ZTPolygon.Empty;
|
for (int i = 0; i < this.HousePathInfo.Obstacles.Count; i++)
|
{
|
ZTPolygon temp = this.HousePathInfo.Obstacles[i];
|
if (GeoHelper.IntersectionOf(source, temp) != Intersection.None)
|
{
|
obstacle = this.HousePathInfo.Obstacles[i];
|
break;
|
}
|
}
|
if (obstacle.Equals(ZTPolygon.Empty))
|
{
|
//不在障碍物内
|
pathGuidePoint = source;
|
return false;
|
}
|
|
//点是否在路径导引区域
|
for (int i = 0; i < this.HousePathInfo.PathGuides.Count; i++)
|
{
|
ZTTargetPolygon temp = this.HousePathInfo.PathGuides[i];
|
if (GeoHelper.IntersectionOf(source, temp.Polygon) != Intersection.None)
|
{
|
pathGuidePoint = temp.Target;
|
return true;
|
}
|
}
|
|
|
//计算距离障碍物外最近的距离
|
double distance = 0;
|
ZTPoint lastPoint = ZTPoint.Empty;
|
for (int i = 0; i < obstacle.Points.Length; i++)
|
{
|
if (i == 0)
|
{
|
lastPoint = obstacle.Points[i];
|
distance = GeoHelper.GetPointDistance(lastPoint, pathGuidePoint);
|
}
|
double lastDistance = GeoHelper.GetNearestDistance(new ZTLinePoint(lastPoint, obstacle[i]), pathGuidePoint);
|
if (lastDistance < distance)
|
{
|
distance = lastDistance;
|
}
|
if (distance <= 0)
|
{
|
distance = 0;
|
break;
|
}
|
}
|
|
//查找最近离开障碍物的点
|
ZTPoint testPoint = ZTPoint.Empty;
|
Int32 maxDistance = Math.Max(Math.Max(source.X, this.HousePathInfo.Width - source.X), Math.Max(source.Y, this.HousePathInfo.Height - source.Y));
|
for (int i = (Int32)distance; i < maxDistance; i++)
|
{
|
//下
|
if (source.Y + i <= this.HousePathInfo.Height)
|
{
|
testPoint = new ZTPoint(source.X, source.Y + i);
|
if (GeoHelper.IntersectionOf(testPoint, obstacle) == Intersection.None)
|
{
|
testPoint.Y += 10;
|
pathGuidePoint = testPoint;
|
break;
|
}
|
}
|
|
|
//右
|
if (source.X <= this.HousePathInfo.Width)
|
{
|
testPoint = new ZTPoint(source.X + i, source.Y);
|
if (GeoHelper.IntersectionOf(testPoint, obstacle) == Intersection.None)
|
{
|
testPoint.X += 10;
|
pathGuidePoint = testPoint;
|
break;
|
}
|
}
|
|
//左
|
if (source.X - i >= 0)
|
{
|
testPoint = new ZTPoint(source.X - i, source.Y);
|
if (GeoHelper.IntersectionOf(testPoint, obstacle) == Intersection.None)
|
{
|
testPoint.X -= 10;
|
pathGuidePoint = testPoint;
|
break;
|
}
|
}
|
|
//上
|
if (source.Y - i >= 0)
|
{
|
testPoint = new ZTPoint(source.X, source.Y - i);
|
if (GeoHelper.IntersectionOf(testPoint, obstacle) == Intersection.None)
|
{
|
testPoint.Y -= 10;
|
pathGuidePoint = testPoint;
|
break;
|
}
|
}
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// 初始化寻路器
|
/// </summary>
|
private void InitPathInfo(Int32[] withoutNumber)
|
{
|
this.PathFinder = new Dijkstra<ZTPoint>();
|
|
//添加寻路路径
|
ZTLinePoint line;
|
for (int i = 0; i < this.HousePathInfo.FindPathLines.Count; i++)
|
{
|
line = this.HousePathInfo.FindPathLines[i];
|
this.PathFinder.AddEdge(line.P1, line.P2, line.GetDistance());
|
}
|
|
|
//定位点添加到字典
|
for (int i = 0; i < this.HousePathInfo.LocationPoints.Count; i++)
|
{
|
ParametersPoint pp = this.HousePathInfo.LocationPoints[i];
|
if (!this.LocationDic.ContainsKey(pp.Parameter))
|
{
|
this.LocationDic.Add(pp.Parameter, pp.Point);
|
}
|
}
|
|
//计算门朝向
|
doorDirection = new Direction[this.HousePathInfo.NextGates.Count];
|
for (Int32 i = 0; i < this.HousePathInfo.NextGates.Count; i++)
|
{
|
switch (this.HousePathInfo.NextGates[i].Parameter)
|
{
|
case 0:
|
doorDirection[i] = Direction.Up;
|
break;
|
case 1:
|
doorDirection[i] = Direction.Right;
|
break;
|
case 2:
|
doorDirection[i] = Direction.Bottom;
|
break;
|
case 3:
|
doorDirection[i] = Direction.Left;
|
break;
|
}
|
}
|
|
if (withoutNumber != null)
|
{
|
for (int i = 0; i < withoutNumber.Length; i++)
|
{
|
if (!this.WithoutNumber.ContainsKey(withoutNumber[i]))
|
{
|
this.WithoutNumber.Add(withoutNumber[i], true);
|
}
|
}
|
}
|
|
}
|
|
/// <summary>
|
/// 向查找器中添加起点和终点可连通的边
|
/// </summary>
|
/// <param name="start"></param>
|
/// <param name="end"></param>
|
private void AddConnectivityEdgeToFinder(ZTPoint start, ZTPoint end)
|
{
|
Int32 distance = 0;
|
ZTPoint point;
|
for (int i = 0; i < this.HousePathInfo.FindPathPoints.Count; i++)
|
{
|
point = this.HousePathInfo.FindPathPoints[i];
|
if (Iscross(start, point))
|
{
|
distance = (Int32)GeoHelper.GetPointDistance(start, point);
|
this.PathFinder.AddEdge(start, point, distance);
|
}
|
|
if (Iscross(end, point))
|
{
|
distance = (Int32)GeoHelper.GetPointDistance(end, point);
|
this.PathFinder.AddEdge(end, point, distance);
|
}
|
}
|
|
}
|
|
|
/// <summary>
|
/// 从查找器中移除起点和终点
|
/// </summary>
|
/// <param name="start"></param>
|
/// <param name="end"></param>
|
private void RemoveStartAndEndVerticeFromFinder(ZTPoint start, ZTPoint end)
|
{
|
this.PathFinder.RemoveEdge(start);
|
this.PathFinder.RemoveEdge(end);
|
}
|
}
|
}
|
