/// <summary>
///
/// </summary>
/// <param name="selectRay">A ray in Xna Coords that was cast according to the viewport</param>
/// <param name="add">Whether to add the selected triangle to the selection</param>
public void UpdateSelectedTriangle(Ray selectRay, bool add)
{
if (!add)
{
Vertices.Clear();
Indices.Clear();
}
var pos3D = selectRay.Position;
var dir3D = selectRay.Direction;
PositionUtil.TransformXnaCoordsToWoWCoords(ref pos3D);
PositionUtil.TransformXnaCoordsToWoWCoords(ref dir3D);
var ray3D = new Ray(pos3D, dir3D);
var pos2D = new Vector2(pos3D.X, pos3D.Y);
var dir2D = new Vector2(dir3D.X, dir3D.Y).NormalizedCopy();
var ray2D = new Ray2D(pos2D, dir2D);
var closestTime = float.MaxValue;
var closestVec0 = Vector3.Zero;
var closestVec1 = Vector3.Zero;
var closestVec2 = Vector3.Zero;
foreach (var tile in _adtManager.MapTiles)
{
var results = new List <Index3>();
if (!tile.GetPotentialColliders(ray2D, results))
{
continue;
}
foreach (var tri in results)
{
var vec0 = tile.TerrainVertices[tri.Index0];
var vec1 = tile.TerrainVertices[tri.Index1];
var vec2 = tile.TerrainVertices[tri.Index2];
float time;
if (!Intersection.RayTriangleIntersect(ray3D, vec0, vec1, vec2, out time))
{
continue;
}
if (time > closestTime)
{
continue;
}
closestTime = time;
closestVec0 = vec0;
closestVec1 = vec1;
closestVec2 = vec2;
}
}
if (closestTime == float.MaxValue)
{
return;
}
AddSelectedTriangle(closestVec0, closestVec1, closestVec2);
}
public override bool AttackNearestTarget()
{
var alreadGotAValidTarget = CurrentTarget != null && CurrentTarget.Targetable;
if (alreadGotAValidTarget || !(nextAttackPossible < Time.time))
{
return(InRange);
}
var findNewTarget = nearestTarget == null ||
!IsInRange(nearestTarget) ||
!IsInLineOfSight(nearestTarget.gameObject) ||
!nearestTarget.Targetable;
if (findNewTarget)
{
var target = TargetManager.Instance.GetEnemies(team)
.Where(o => {
var dmg = o.GetComponent <Damageable>();
return(dmg != null && dmg.Targetable);
})
.Where(IsInLineOfSight)
.Aggregate(null, PositionUtil.FindNearest(gameObject.transform.position));
nearestTarget = target != null?target.GetComponent <Damageable>() : null;
}
CurrentTarget = nearestTarget;
return(InRange);
}
private static Vector3 WarpLocation(GameObject caster)
{
var splat = caster.GetComponentInChildren <SplatManager>();
var warpLocation = PositionUtil.ClosesNavMeshPosition(splat.GetSpellCursorPosition());
return(warpLocation);
}
private void Update()
{
if (NotActive())
{
return;
}
if (animator != null)
{
animator.SetFloat("Speed", agent.velocity.magnitude);
}
if (nextEnemyCheck <= Time.time)
{
attack.SetTarget(
TargetManager.Instance.GetValidEnemyTargets(team)
.Select(dmg => dmg.gameObject)
.Aggregate(null, PositionUtil.FindNearest(gameObject.transform.position))
.GetComponent <Damageable>());
nextEnemyCheck = Time.time + ReevaluateInterval;
}
agent.isStopped = attack.InRange;
var t = attack.GetTarget();
if (t != null)
{
agent.SetDestination(t.gameObject.transform.position);
}
}
public LiquidType GetLiquidType(Vector3 worldPos)
{
Point2D tileCoord;
Point2D chunkCoord;
var unitCoord = PositionUtil.GetHeightMapXYForPos(worldPos, out tileCoord, out chunkCoord);
var tile = GetTile(tileCoord.X, tileCoord.Y);
if (tile == null)
{
return(LiquidType.None);
}
var type = tile.GetLiquidType(chunkCoord);
if (type != LiquidType.None)
{
// check if below the liquid height level
if (tile.GetLiquidHeight(chunkCoord, unitCoord) > worldPos.Z)
{
return(type);
}
}
return(LiquidType.None);
}
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
TerrainDisplayConfig.Initialize();
LogUtil.SetupConsoleLogging();
NativeMethods.StormLibFolder = TerrainDisplayConfig.LibDir;
NativeMethods.InitAPI();
var defaultTileId = TileIdentifier.DefaultTileIdentifier;
var useExtractedData = TerrainDisplayConfig.UseExtractedData;
if (useExtractedData)
{
TerrainManager = new ExtractedTerrainManager(TerrainDisplayConfig.MapDir, defaultTileId);
}
else
{
TerrainManager = new MpqTerrainManager(defaultTileId);
}
TerrainManager.LoadTile(defaultTileId);
AvatarPosition = new Vector3(TerrainConstants.CenterPoint - (defaultTileId.TileX + 1) * TerrainConstants.TileSize,
TerrainConstants.CenterPoint - (defaultTileId.TileY) * TerrainConstants.TileSize,
100.0f);
PositionUtil.TransformWoWCoordsToXNACoords(ref AvatarPosition);
//new RecastRunner(TerrainManager).Start();
using (var game = new Game1(AvatarPosition.ToXna()))
{
game.Run();
}
}
private bool IsInLineOfSight(GameObject target)
{
RaycastHit hit;
return(PositionUtil.RayFromToHitOnlyTerrain(gameObject.transform.position, target.transform.position,
out hit));
}
/// <summary>
/// (BD-09)-->84
/// </summary>
/// <param name="bd_lat"></param>
/// <param name="bd_lon"></param>
/// <returns></returns>
public static Gps bd09_To_Gps84(double bd_lat, double bd_lon)
{
Gps gcj02 = PositionUtil.bd09_To_Gcj02(bd_lat, bd_lon);
Gps map84 = PositionUtil.gcj_To_Gps84(gcj02.getWgLat(), gcj02.getWgLon());
return(map84);
}
public Point Translate(double lat, double lng, bool address = false)
{
Point gps;
if (lat == -1.0 && lat == -1.0)
{
gps = new Point(-1.000, -1.000);
gps.Address = "未解析到地址.";
return(gps);
}
gps = PositionUtil.gps84_To_Gcj02(lat, lat);
try
{
if (address)
{
gps.Address = GetAddress(gps);
}
return(gps);
}
catch (Exception)
{
gps.Address = "未知";
return(gps);
}
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
WorldObject obj = trigger.Args.Target;
var zone = obj.Zone;
string zoneStr;
if (zone != null)
{
zoneStr = zone.Id.ToString();
while ((zone = zone.ParentZone) != null)
{
zoneStr += " in " + zone;
}
}
else
{
zoneStr = "<null>";
}
var height = obj.TerrainHeight;
trigger.Reply("Map: " + obj.Map + ", Zone: " + zoneStr);
trigger.Reply("Position X: " + obj.Position.X + ", Y: " + obj.Position.Y + ", Z: " + obj.Position.Z + ", O: " + obj.Orientation +
"(" + Math.Abs(obj.Position.Z - height) + " yds from Ground)");
int tileX, tileY;
PositionUtil.GetTileXYForPos(obj.Position, out tileX, out tileY);
trigger.ReplyFormat("Tile: X={0}, Y={1} (Collision Data {2})", tileX, tileY,
obj.Map.Terrain.IsAvailable(tileX, tileY) ?
ChatUtility.Colorize("Available", Color.Green) :
ChatUtility.Colorize("Unavailable", Color.Red));
}
protected override bool BuildPolyVerticiesAndIndicies()
{
List <Vector3> vertices;
List <int> indices;
_manager.GetMeshVerticesAndIndices(out vertices, out indices);
if (vertices.Count == 0 || indices.Count == 0)
{
return(false);
}
_cachedPolyVertices = new VertexPositionNormalColored[vertices.Count];
for (var i = 0; i < vertices.Count; i++)
{
_cachedPolyVertices[i] = new VertexPositionNormalColored(vertices[i].ToXna(), MeshPolyColor,
Vector3.Up.ToXna());
PositionUtil.TransformWoWCoordsToXNACoords(ref _cachedPolyVertices[i]);
}
_cachedPolyIndices = new int[indices.Count];
for (int i = 0; i < indices.Count; i++)
{
_cachedPolyIndices[i] = indices[i];
}
RenderPolyCached = true;
return(true);
}
public bool IsAvailable(int tileX, int tileY)
{
if (PositionUtil.VerifyTileCoords(tileX, tileY))
{
return(TileProfile[tileX, tileY]);
}
return(false);
}
/// <summary>
/// Google中国用的是GCJ02坐标系，Google国外用的是WGS84坐标系
/// </summary>
/// <param name="lat"></param>
/// <param name="lng"></param>
/// <param name="address"></param>
/// <returns></returns>
public Point Translate(double lat, double lng, bool address = false)
{
//国内转成 Gcj02
if (PositionUtil.outOfChina(lat, lng))
{
return(PositionUtil.gps84_To_Gcj02(lat, lng));
}
//国外直接返回
return(new Point(lat, lng));
}
/// <summary>
/// Creates a backstab action. Backstab does more damage when the target isn't facing the attacker.
/// </summary>
/// <param name="factor">
/// The damage multiplication factor. 2 = double damage
/// </param>
/// <returns></returns>
public static Action <MeleeAttack> Backstab(double factor)
{
return(attack => {
var dmg = attack.AttackDamage;
if (!PositionUtil.Facing(attack.GetTarget().gameObject.transform, attack.gameObject.transform))
{
dmg = (int)(dmg * factor);
}
attack.GetTarget().Damage(dmg);
});
}
void CenterMap(int index)
{
var camPos = Camera.main.transform.position;
var width = Map.row; //May need to change to Map.row
PositionUtil.CalcPosition(index, width, out tempX, out tempY);
camPos.x = tempX * TileSize.x;
camPos.y = -(tempY * TileSize.y);
Camera.main.transform.position = camPos;
}
public float GetLiquidHeight(Vector3 worldPos)
{
Point2D tileCoord;
Point2D chunkCoord;
var unitCoord = PositionUtil.GetHeightMapXYForPos(worldPos, out tileCoord, out chunkCoord);
var tile = GetTile(tileCoord.X, tileCoord.Y);
return((tile == null)
? float.MinValue
: tile.GetLiquidHeight(chunkCoord, unitCoord));
}
public void MoveInDir(Vector2 dir)
{
PositionUtil.CalcPosition(currentTile, map.row, out tempX, out tempY);
tempX += (int)dir.x;
tempY += (int)dir.y;
PositionUtil.CalcIndex(tempX, tempY, map.row, out tempIndex);
//Debug.Log("Moving to: " + tempIndex);
MoveTo(tempIndex, true);
}
public override bool OnActivation(GameObject c)
{
Vector3 hitOnTerrain;
PositionUtil.ProjectOnTerrainFromPosition(c.transform.position, out hitOnTerrain);
var areaOfEffect = Instantiate(AoEPrefab, hitOnTerrain, c.transform.rotation);
areaOfEffect.AffectedTeams = new List <int> {
c.GetComponent <Team>().TeamId
};
return(true);
}
public void TestGetValidVerticalPositionMethod()
{
Position pos = new Position(1, 1);
var moves = PositionUtil.GetValidVerticalPosition(pos).ToList();
Assert.IsNotNull(moves);
Assert.AreEqual(7, moves.Count);
var possibles = new[] { new Position(2, 1), new Position(3, 1), new Position(4, 1), new Position(5, 1), new Position(6, 1), new Position(7, 1), new Position(8, 1) };
foreach (var possible in possibles)
{
Assert.IsTrue(moves.Contains(possible));
}
}
public void TestGetValidHorizontalPositionMethod()
{
Position pos = new Position(1, 1);
var moves = PositionUtil.GetValidHorizontalPosition(pos).ToList();
Assert.IsNotNull(moves);
Assert.AreEqual(7, moves.Count);
var possibles = new[] { new Position(1, 2), new Position(1, 3), new Position(1, 4), new Position(1, 5), new Position(1, 6), new Position(1, 7), new Position(1, 8) };
foreach (var possible in possibles)
{
Assert.IsTrue(moves.Contains(possible));
}
}
private static int CopyVectorsToRecastArray(IList <Vector3> renderVertices, IList <Vector3> vertices, int vecOffset)
{
if (renderVertices != null)
{
var length = renderVertices.Count;
for (var i = 0; i < length; i++)
{
var vertex = renderVertices[i];
PositionUtil.TransformWoWCoordsToRecastCoords(ref vertex);
vertices[vecOffset + i] = vertex;
}
vecOffset += renderVertices.Count;
}
return(vecOffset);
}
private void BuildVerticiesAndIndicies()
{
// Cycle through each ADT
var tempVertices = new List <VertexPositionNormalColored>();
var tempIndicies = new List <int>();
var offset = 0;
foreach (var adt in _manager.MapTiles)
{
// Handle the ADTs
for (var v = 0; v < adt.TerrainVertices.Count; v++)
{
var vertex = adt.TerrainVertices[v];
var vertexPosNmlCol = new VertexPositionNormalColored(vertex.ToXna(), TerrainColor,
Microsoft.Xna.Framework.Vector3.Down);
tempVertices.Add(vertexPosNmlCol);
}
for (var i = 0; i < adt.Indices.Count; i++)
{
tempIndicies.Add(adt.Indices[i] + offset);
}
offset = tempVertices.Count;
//if (!DrawLiquids) continue;
for (var v = 0; v < adt.LiquidVertices.Count; v++)
{
var vertex = adt.LiquidVertices[v];
var vertexPosNmlCol = new VertexPositionNormalColored(vertex.ToXna(), WaterColor,
Microsoft.Xna.Framework.Vector3.Down);
tempVertices.Add(vertexPosNmlCol);
}
for (var i = 0; i < adt.LiquidIndices.Count; i++)
{
tempIndicies.Add(adt.LiquidIndices[i] + offset);
}
offset = tempVertices.Count;
}
_cachedIndices = tempIndicies.ToArray();
_cachedVertices = tempVertices.ToArray();
_renderCached = true;
for (var i = 0; i < _cachedVertices.Length; i++)
{
PositionUtil.TransformWoWCoordsToXNACoords(ref _cachedVertices[i]);
}
}
internal static bool TryLoad(TileIdentifier tileId, out Tile tile)
{
tile = null;
var mpqManager = new MpqTerrainManager(tileId);
if (!mpqManager.LoadTile(tileId)) return false;
tile = new Tile
{
//_terrainTree = mpqManager.ADTManager.MapTiles[0].QuadTree,
//_m2Tree = ((M2Manager) mpqManager.M2Manager).QuadTree,
//_wmoTree = ((WMOManager) mpqManager.WMOManager).QuadTree,
Bounds = PositionUtil.GetTileBoundingRect(tileId),
};
return true;
}
public bool GetClickLocation(out GameObject target, out ClickLocation click)
{
click = new ClickLocation();
Vector3 terrainHit;
if (!PositionUtil.GetCursorLocation(out target, out terrainHit, ClickableLayers) ||
EventSystem.current.IsPointerOverGameObject())
{
return(false);
}
click = new ClickLocation {
Target = target, Location = terrainHit
};
return(true);
}
private void BuildVerticiesAndIndicies()
{
var tileId = TileIdentifier.DefaultTileIdentifier;
var tempVertices = new List <VertexPositionNormalColored>();
var tempIndices = new List <int>();
var offset = 0;
var baseXPos = TerrainConstants.CenterPoint - (tileId.TileX + 1) * TerrainConstants.TileSize;
var baseYPos = TerrainConstants.CenterPoint - (tileId.TileY + 1) * TerrainConstants.TileSize;
var baseZPos = -100.0f;
// The Bottom-Righthand corner of a Tile in WoW coords
var baseAxisVec = new Vector3(baseXPos, baseYPos, baseZPos);
//var baseAxisVec = new Vector3(0.0f);
// The Top-Lefthand corner of a Tile in WoW coords
var endAxisVec = baseAxisVec + new Vector3(TerrainConstants.TileSize * 2);
PositionUtil.TransformWoWCoordsToXNACoords(ref baseAxisVec);
PositionUtil.TransformWoWCoordsToXNACoords(ref endAxisVec);
// The WoW X-axis drawn in XNA coords
tempVertices.Add(new VertexPositionNormalColored(baseAxisVec, Color.Red, Vector3.Up));
tempIndices.Add(0);
tempVertices.Add(new VertexPositionNormalColored(new Vector3(baseAxisVec.X, baseAxisVec.Y, endAxisVec.Z), Color.Red, Vector3.Up));
tempIndices.Add(1);
tempIndices.Add(0);
// The WoW Y-axis drawn in XNA coords
tempVertices.Add(new VertexPositionNormalColored(baseAxisVec, Color.White, Vector3.Up));
tempIndices.Add(2);
tempVertices.Add(new VertexPositionNormalColored(new Vector3(endAxisVec.X, baseAxisVec.Y, baseAxisVec.Z), Color.White, Vector3.Up));
tempIndices.Add(3);
tempIndices.Add(2);
// The WoW Z-axis
tempVertices.Add(new VertexPositionNormalColored(baseAxisVec, Color.Blue, Vector3.Up));
tempIndices.Add(4);
tempVertices.Add(new VertexPositionNormalColored(new Vector3(baseAxisVec.X, endAxisVec.Y, baseAxisVec.Z), Color.Blue, Vector3.Up));
tempIndices.Add(5);
tempIndices.Add(4);
_cachedIndices = tempIndices.ToArray();
_cachedVertices = tempVertices.ToArray();
_renderCached = true;
}
private void SpawnFire()
{
PlayersWithinDistance(VulnerabilityRange).ForEach(o => o.AddComponent <Vulnerability>().Duration = 2);
var availablePlayers = PlayersWithinDistance(FireRange);
if (!availablePlayers.Any())
{
return;
}
var target = availablePlayers.ElementAt(Random.Range(0, availablePlayers.Count));
Vector3 targetPos;
if (PositionUtil.HighestTerrain(target.transform.position, out targetPos))
{
Instantiate(FirePrefab, targetPos, FirePrefab.transform.rotation);
}
}
void VisitTile(int index)
{
int column, newX, newY, row = 0;
PositionUtil.CalcPosition(index, Map.col, out tempX, out tempY);
var half = Mathf.FloorToInt(viewDistance / 2f);
tempX -= half;
tempY -= half;
var total = viewDistance * viewDistance;
var maxCol = viewDistance - 1;
for (int i = 0; i < total; i++)
{
column = i % viewDistance;
newX = column + tempX;
newY = row + tempY;
PositionUtil.CalcIndex(newX, newY, Map.col, out index);
if (index > -1 && index < Map.mapTiles.Length)
{
var tile = Map.mapTiles[index];
tile.visited = true;
DecorateTile(index);
foreach (var neighbor in tile.Neighbors)
{
if (neighbor != null)
{
if (!neighbor.visited)
{
neighbor.CalcFOWAutoTileID();
DecorateTile(neighbor.TileID);
}
}
}
}
if (column == maxCol)
{
row++;
}
}
}
public static TileIdentifier ByPosition(MapId mapId, Vector3 position)
{
int tileX, tileY;
if (!PositionUtil.GetTileXYForPos(position, out tileX, out tileY))
{
return(null);
}
return(new TileIdentifier
{
MapId = mapId,
MapName = InternalMapNames[mapId],
TileX = tileX,
TileY = tileY
});
}
protected override void BuildVerticiesAndIndicies()
{
_cachedVertices = new VertexPositionNormalColored[_manager.Vertices.Count];
_cachedIndices = new int[_manager.Indices.Count];
for (var i = 0; i < _manager.Vertices.Count; i++)
{
var position = _manager.Vertices[i];
PositionUtil.TransformWoWCoordsToXNACoords(ref position);
_cachedVertices[i] = new VertexPositionNormalColored(position.ToXna(), SelectedTriangleColor,
Vector3.Up);
}
for (var i = 0; i < _manager.Indices.Count; i++)
{
_cachedIndices[i] = _manager.Indices[i];
}
}
private void Shoot()
{
var hits = PositionUtil.RayAllFromTo(gameObject, Target, Range);
foreach (var hit in hits)
{
var dmg = hit.transform.gameObject.GetComponent <Damageable>();
var team = hit.transform.gameObject.GetComponent <Team>();
if (dmg == null || !AffectedTeams.Contains(team.TeamId))
{
continue;
}
dmg.Damage(Damage);
break;
}
Destroy(gameObject);
}
