/// <summary>
/// Get the next waypoint of a certain type
/// </summary>
/// <param name="w1"></param>
/// <param name="wt"></param>
/// <param name="ignorable"></param>
/// <returns></returns>
public ArbiterWaypoint GetNext(ArbiterWaypoint w1, WaypointType wt, List <ArbiterWaypoint> ignorable)
{
List <WaypointType> wts = new List <WaypointType>();
wts.Add(wt);
return(this.GetNext(w1, wts, ignorable));
}
public void SetupNavWaypoint(CelestialBody targetBody, double latitude, double longitude, double altitude, WaypointType type, Color color)
{
this.targetBody = targetBody;
this.latitude = latitude;
this.longitude = longitude;
this.altitude = altitude;
switch ( type )
{
case WaypointType.PLANE:
indicator.renderer.material.mainTexture = mTexPlane;
break;
case WaypointType.ROVER:
indicator.renderer.material.mainTexture = mTexRover;
break;
default:
indicator.renderer.material.mainTexture = mTexDefault;
break;
}
indicator.renderer.material.SetColor("_Color", color);
if (targetBody.pqsController != null)
{
Vector3d pqsRadialVector = QuaternionD.AngleAxis(longitude, Vector3d.down) * QuaternionD.AngleAxis(latitude, Vector3d.forward) * Vector3d.right;
height = targetBody.pqsController.GetSurfaceHeight(pqsRadialVector) - targetBody.pqsController.radius;
if (height < 0)
height = 0;
}
}
public Waypoint(MPos position, WaypointLocation location, WaypointType type)
{
Position = position;
Location = location;
Type = type;
}
public FmsFlightplan CreateFmsFlightplanFromGarminFpl(GarminFpl garminFlightplan)
{
List <PlanItem> planItems = new List <PlanItem>();
foreach (var routepoint in garminFlightplan.Route.Routepoint)
{
Waypoint waypointToRoutepoint = garminFlightplan.Waypointtable.Waypoint.Single(x =>
x.Identifier == routepoint.Waypointidentifier && x.Type == routepoint.Waypointtype &&
x.Countrycode == routepoint.Waypointcountrycode);
double lat = waypointToRoutepoint.Lat;
double lon = waypointToRoutepoint.Lon;
WaypointType waypointType = _fplToFmsWaypointTypeConverter.FplWaypointTypeToFms(waypointToRoutepoint.Type);
string id;
if (waypointType == WaypointType.LatLon)
{
id = CreateIdentifierFromCoordinates(lat, lon);
}
else
{
id = waypointToRoutepoint.Identifier;
}
planItems.Add(new PlanItem(
waypointType,
id,
0,
lat,
lon)
);
}
Header header = new Header(planItems.Count - 1);
return(new FmsFlightplan(header, planItems));
}
public DisplayWaypoint(Serial serial, int x, int y, int z, int mapID, WaypointType type, string name, bool ignoreObject)
: base(0xE5)
{
EnsureCapacity(21 + (name.Length * 2));
m_Stream.Write(serial);
m_Stream.Write((ushort)x);
m_Stream.Write((ushort)y);
m_Stream.Write((sbyte)z);
m_Stream.Write((byte)mapID); //map
m_Stream.Write((ushort)type);
m_Stream.Write((ushort)(ignoreObject ? 1 : 0));
if (type == WaypointType.Corpse)
{
m_Stream.Write(1046414);
}
else
{
m_Stream.Write(1062613);
}
m_Stream.WriteLittleUniNull(name);
m_Stream.Write((short)0); // terminate
}
public Waypoint(WaypointType Type, ShopAction ShopAction, uint ItemID, int Amount)
{
wType = Type;
wShopAction = ShopAction;
wItemID = ItemID;
wAmount = Amount;
}
public void AddWaypoint(WaypointType waypointType)
{
if (!Enable && GlobalVariables.IsConnected())
{
Position pos = GlobalVariables.GetPlayerPosition().Clone();
switch (waypointType)
{
case WaypointType.WAYPOINT_GROUND:
case WaypointType.WAYPOINT_ROPE:
case WaypointType.WAYPOINT_LADDER:
Waypoints.Add(new WalkWaypoint(pos, waypointType));
break;
case WaypointType.WAYPOINT_HOLE:
pos.Y++;
pos.Z--;
Waypoints.Add(new WalkWaypoint(pos, waypointType));
break;
case WaypointType.WAYPOINT_RAMP:
break;
case WaypointType.WAYPOINT_STAIR_UP:
pos.Y--;
Waypoints.Add(new WalkWaypoint(pos, waypointType));
break;
case WaypointType.WAYPOINT_START_DOWN:
pos.Y++;
Waypoints.Add(new WalkWaypoint(pos, waypointType));
break;
}
}
}
public void Initialize(int x, int y, WaypointType type, float timeMultiplier)
{
X = x;
Y = y;
Type = type;
TimeMultiplier = timeMultiplier;
}
private void addWaypointByType(WaypointType type)
{
if (this.memory.isUseable())
{
PlayerPosition p = this.memory.position();
Waypoint wp = new Waypoint();
wp.position = p;
wp.type = type;
wp.id = (uint)this.waypointList.Count;
Single range = Convert.ToSingle(gatheringRangeInputField.Text);
if (type == WaypointType.Gathering && range >= 1)
{
wp.range = range;
}
else
{
wp.range = 0;
}
if (type == WaypointType.Default)
{
this.lastAwpWaypoint = wp;
}
this.waypointList.Add(wp);
this.addWaypointToList(wp);
}
}
public PlanItem(WaypointType typ, string id, double altitude, double latitude, double longitude)
{
Typ = typ;
Id = id.MustNotBeNulllOrWhitespace(nameof(id));
Altitude = altitude;
Latitude = latitude;
Longitude = longitude;
}
public static void Create(Mobile m, Mobile mob, WaypointType type, bool ignoreObject = false)
{
NetState ns = m.NetState;
if (ns != null && mob != null && !mob.Deleted)
{
ns.Send(new DisplayWaypoint(mob.Serial, mob.X, mob.Y, mob.Z, mob.Map.MapID, type, mob.Name + " " + mob.Title, ignoreObject));
}
}
public Waypoint(WaypointType Type, ConditionalVarType VarType, uint ItemID, ConditionalCheckType CheckType, int Output, string GoToLabel)
{
wType = Type;
wCondVarType = VarType;
wItemID = ItemID;
wCondCheckType = CheckType;
wCondOutput = Output;
wLabelName = GoToLabel;
}
public static void Create(Mobile m, IEntity e, WaypointType type, string arg, bool ignoreObject = false)
{
NetState ns = m.NetState;
if (ns != null && e != null && !e.Deleted && (!(e is Mobile) || ((Mobile)e).Alive))
{
ns.Send(new DisplayWaypoint(e.Serial, e.X, e.Y, e.Z, e.Map.MapID, type, arg, ignoreObject));
}
}
public static Waypoint FromLocation(WaypointType type, ILocation location)
{
if (location == null)
{
return(null);
}
return(new Waypoint(type, location));
}
public PolygonWaypoint(int id, double x, double y, WaypointType type)
{
this.id = id;
this.x = x;
this.y = y;
this.waypointType = type;
neighbors = new List <PolygonWaypoint>();
edgeNum = -1;
}
public Waypoint(int id, WaypointType type, int xWaypointRange, int yWaypointRange, string label, WaypointLocation location, string action)
{
Id = id;
Type = type;
Label = label;
Location = location;
Action = action;
XWaypointRange = xWaypointRange;
YWaypointRange = yWaypointRange;
}
public ElevatorWaypoint(uint destinationFloor, WaypointType waypointType)
{
this.DestinationFloor = destinationFloor;
this.WaypointType = waypointType;
if (waypointType == WaypointType.PICK_UP)
{
throw new InvalidWaypointException("The waypoint must have have an associated next to be type Pick Up");
}
}
public Waypoint(WaypointType type, WaypointHandler h, Vector2 tileCoords, float depth)
{
Type = type;
handler = h;
TileCoords = tileCoords;
if (type == WaypointType.Lift)
BoundingRectangle = new BoundingBox(new Vector3(tileCoords.X, tileCoords.Y, depth), new Vector3(tileCoords.X + 300, tileCoords.Y + 40, depth));
else
BoundingRectangle = new BoundingBox(new Vector3(tileCoords.X, tileCoords.Y, depth), new Vector3(tileCoords.X + 60, tileCoords.Y + 40, depth));
}
private void MoveAgentTo(Vector3 point)
{
ClearPathObjects();
if (!aimAgent.gameObject.activeSelf)
{
aimAgent.gameObject.SetActive(true);
}
NavMeshPath path = new NavMeshPath();
navMeshAgent.CalculatePath(point, path);
switch (path.status)
{
case NavMeshPathStatus.PathComplete:
Debug.Log("PATH IS POSSIBLE!!!! :) ");
lastPath = WaypointType.Complete;
navMeshAgent.SetDestination(point);
if (!aimTarget.gameObject.activeSelf)
{
aimTarget.gameObject.SetActive(true);
}
aimTarget.position = point;
foreach (Vector3 pathPoint in path.corners)
{
GameObject pathObject = GetWaypoint(lastPath);
pathObject.transform.SetParent(transform.parent);
pathObject.transform.position = pathPoint;
pathObjects.Add(pathObject);
}
break;
case NavMeshPathStatus.PathPartial:
Debug.Log("ONLY PARTIAL PATH IS POSSIBLE... :( ");
lastPath = WaypointType.Incomplete;
foreach (Vector3 pathPoint in path.corners)
{
GameObject pathObject = GetWaypoint(lastPath);
pathObject.transform.SetParent(transform.parent);
pathObject.transform.position = pathPoint;
pathObjects.Add(pathObject);
}
break;
case NavMeshPathStatus.PathInvalid:
Debug.Log("NO PATH POSSIBLE... :( ");
break;
}
}
public ElevatorWaypoint(uint destinationFloor, WaypointType waypointType, uint associatedNext)
{
this.DestinationFloor = destinationFloor;
this.WaypointType = waypointType;
if (waypointType != WaypointType.PICK_UP)
{
throw new InvalidWaypointException("The waypoint must be of type Pick Up to have an associated next");
}
this._associatedNext = associatedNext;
}
public Waypoint(WaypointType type, string name, double latitude, double longitude, double altitude, double?bearing = null, string region = null, string airport = null)
{
Type = type;
Name = name;
Region = region;
Airport = airport;
Latitude = latitude;
Longitude = longitude;
Altitude = altitude;
Bearing = bearing;
}
void Update()
{
switch (type){
case WaypointType.loop: // loops around the waypoints
if (transform.position == waypoints[waypointIndex].position) {
if (waypointIndex == waypoints.Length-1){
waypointIndex = 0;
}
else{
waypointIndex ++;
}
}
break;
case WaypointType.pingPong: // go though the wayponts and back in reverse order
if (transform.position == waypoints[waypointIndex].position) {
if (waypointIndex == waypoints.Length-1){
isReverse = true;
}
if (waypointIndex == 0){
isReverse = false;
}
if (isReverse) {
waypointIndex--;
}
else {
waypointIndex++;
}
}
break;
case WaypointType.once: // go through the waypoints and stop at the end
if (transform.position == waypoints[waypointIndex].position) {
if (waypointIndex == waypoints.Length - 1){
type = WaypointType.off;
break;
}
else {
waypointIndex ++;
}
}
break;
case WaypointType.random: // go to a random waypoint
if (transform.position == waypoints[waypointIndex].position) {
waypointIndex = Random.Range(0, waypoints.Length);
}
break;
case WaypointType.off: // go to the next waypoint on the list and stop
break;
}
transform.position = Vector3.MoveTowards(transform.position, waypoints[waypointIndex].position, Time.deltaTime * speed);
}
public static Waypoint FromAddress(WaypointType type, string address)
{
if (address == null)
{
return(null);
}
return(new Waypoint(type, null)
{
Address = address
});
}
private void typeComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
WaypointType wpt = (WaypointType)this.typeComboBox.SelectedItem;
if (wpt == WaypointType.Gathering)
{
this.rangeTextField.Enabled = true;
}
else
{
this.rangeTextField.Enabled = false;
}
}
public Waypoint(Vector3 pos, float headingAngle, WaypointType type, float radius)
{
Type = type;
Position = pos;
HeadingAngle = headingAngle;
Radius = radius;
if (type == WaypointType.Hover) SecondsToWait = 2.0f;
else if (type == WaypointType.Land) SecondsToWait = float.MaxValue;
else SecondsToWait = 0;
SecondsWaited = 0;
}
// Returning Waypoints to pool
public void ReturnWaypointToPool(GameObject waypointToStore, WaypointType wType)
{
waypointToStore.SetActive(false);
if (wType == WaypointType.Complete)
{
waypointToStore.transform.SetParent(unusedCompletePool);
}
else if (wType == WaypointType.Complete)
{
waypointToStore.transform.SetParent(unusedIncompletePool);
}
waypointToStore.transform.localScale = Vector3.one;
waypointToStore.transform.position = Vector3.zero;
}
public GameObject GetWaypoint(WaypointType wType)
{
GameObject wObject = null;
switch (wType)
{
case WaypointType.Complete:
wObject = unusedCompletePool.GetChild(UnityEngine.Random.Range(0, unusedCompletePool.childCount - 1)).gameObject;
break;
case WaypointType.Incomplete:
wObject = unusedIncompletePool.GetChild(UnityEngine.Random.Range(0, unusedIncompletePool.childCount - 1)).gameObject;
break;
}
wObject.SetActive(true);
// Return tree with proper material attached to it
return(wObject);
}
//-----------------------------------------------------------------------------------------------
public Waypoint(FPoint fp, Waypoint parent, bool done)
{
this.type = WaypointType.Normal;
this.done = done;
this.parent = parent;
this.fp = fp.Clone();
if (parent == null)
{
G = 0;
}
else
{
G = parent.G + fp.Distance(parent.fp);
}
H = fp.Distance(fp_dst);
F = G + H;
}
/// <summary>
/// Get the next waypoint of a certain type
/// </summary>
/// <param name="loc">Location to start looking from</param>
/// <param name="wt">Waypoint type to look for</param>
/// <param name="ignorable">ignorable waypoints</param>
/// <returns></returns>
public ArbiterWaypoint GetNext(Coordinates loc, WaypointType wt, List <ArbiterWaypoint> ignorable)
{
List <WaypointType> wts = new List <WaypointType>();
wts.Add(wt);
SLComponentType closest = this.ClosestComponent(loc);
if (closest == SLComponentType.Initial)
{
return(this.GetNext(this.Initial.GetClosestPartition(loc).Final, wts, ignorable));
}
else if (closest == SLComponentType.Final)
{
return(this.GetNext(this.Final.GetClosestPartition(loc).Final, wts, ignorable));
}
else
{
return(this.GetNext(this.Final.GetClosestPartition(loc).Final, wts, ignorable));
}
}
/// <summary>
/// Gets next waypoint of a certain type ignoring certain waypoints
/// </summary>
/// <param name="w1"></param>
/// <param name="wt"></param>
/// <param name="ignorable"></param>
/// <returns></returns>
public ArbiterWaypoint GetNext(ArbiterWaypoint w1, WaypointType wt, List <ArbiterWaypoint> ignorable)
{
ArbiterWaypoint tmp = w1;
while (tmp != null)
{
if (tmp.WaypointTypeEquals(wt) && !ignorable.Contains(tmp))
{
return(tmp);
}
if (tmp.NextPartition != null)
{
tmp = tmp.NextPartition.Final;
}
else
{
tmp = null;
}
}
return(null);
}
public Waypoint(Vector3 pos, float headingAngle, WaypointType type, float radius)
{
Type = type;
Position = pos;
HeadingAngle = headingAngle;
Radius = radius;
if (type == WaypointType.Hover)
{
SecondsToWait = 2.0f;
}
else if (type == WaypointType.Land)
{
SecondsToWait = float.MaxValue;
}
else
{
SecondsToWait = 0;
}
SecondsWaited = 0;
}
public List <GameObject> SearchPathUnknownTarget(Waypoint initalWaypoint, WaypointType waypointTypeToFind)
{
List <GameObject> path = new List <GameObject>();
List <Waypoint> visited = new List <Waypoint>();
// BFS Style
/*List<Waypoint> visited = new List<Waypoint>();
* Queue<Waypoint> q = new Queue<Waypoint>();
*
* q.Enqueue(initalWaypoint);
* visited.Add(initalWaypoint);
*
* while (q.Count != 0)
* {
* Waypoint waypoint = q.Dequeue();
*
* if (waypoint.ReturnWaypointType() == waypointTypeToFind)
* {
* path.Add(waypoint.ReturnWaypointGameObject());
* return path;
* }
*
* foreach (Waypoint w in waypoint.connectedWaypoints)
* {
* if (!visited.Contains(w))
* {
* visited.Add(w);
* q.Enqueue(w);
* }
* }
* }*/
path.Add(initalWaypoint.ReturnWaypointGameObject());
visited.Add(initalWaypoint);
path = SearchWaypointPathRecursiveType(initalWaypoint, waypointTypeToFind, path, visited);
return(path);
}
/// <summary>
/// Get the next waypoint of a certain type
/// </summary>
/// <param name="w1">Starting waypoint of search</param>
/// <param name="wt">Waypoint type to look for</param>
/// <returns></returns>
public ArbiterWaypoint GetNext(ArbiterWaypoint w1, WaypointType wt)
{
ArbiterWaypoint tmp = w1;
while (tmp != null)
{
if (tmp.WaypointTypeEquals(wt))
{
return(tmp);
}
if (tmp.NextPartition != null)
{
tmp = tmp.NextPartition.Final;
}
else
{
tmp = null;
}
}
return(null);
}
/// <summary>
/// Type off a waypoint
/// </summary>
/// <param name="wt"></param>
/// <returns></returns>
public bool WaypointTypeEquals(WaypointType wt)
{
if (wt == WaypointType.End)
{
return(this.NextPartition == null ? true : false);
}
else if (wt == WaypointType.Entry)
{
return(this.isEntry);
}
else if (wt == WaypointType.Exit)
{
return(this.isExit);
}
else if (wt == WaypointType.Stop)
{
return(this.IsStop);
}
else
{
return(this.PreviousPartition == null);
}
}
private List <GameObject> SearchWaypointPathRecursiveType(
Waypoint currentWaypoint,
WaypointType waypointTypeToFind,
List <GameObject> list,
List <Waypoint> visited)
{
// Check for base case
if (currentWaypoint.ReturnWaypointType() == waypointTypeToFind)
{
return(list);
}
// int i = 0;
// check for other posibilties
foreach (Waypoint w in currentWaypoint.connectedWaypoints)
{
//Debug.Log(i);
//i++;
if (visited.Contains(w) == false)
{
visited.Add(w);
list.Add(w.ReturnWaypointGameObject());
SearchWaypointPathRecursiveType(w, waypointTypeToFind, list, visited);
if (list[list.Count - 1].GetComponent <Waypoint>().ReturnWaypointType() == waypointTypeToFind)
{
return(list);
}
list.Remove(w.ReturnWaypointGameObject());
}
}
return(list);
}
private Vector3 getPosition(Vector3 origin, Vector3 target, float progress, WaypointType type)
{
Vector3 position = Vector3.Lerp(origin, target, progress);
float arcHeight = 0f;
switch (type)
{
case WaypointType.HorizontalJump:
case WaypointType.HorizontalJumpDown:
arcHeight = .5f;
position.y += Mathf.Sin(progress * Mathf.PI) * arcHeight;
break;
case WaypointType.WalkOffDown:
if (progress <= .5f)
{
position.y = origin.y;
}
else
{
position.y = Mathf.Lerp(origin.y, target.y, (progress - .5f) * 2);
}
break;
case WaypointType.VerticalJumpUp:
float yDiff = target.y - origin.y;
arcHeight = yDiff / 2 + .5f;
float subProgress = Mathf.Clamp(progress * 1.5f, 0, 1);
position.y = Mathf.Lerp(origin.y, target.y, subProgress);
position.y += Mathf.Sin(subProgress * Mathf.PI) * arcHeight;
break;
}
return(position);
}
/// <summary>
/// Gets next waypoint of a certain type ignoring certain waypoints
/// </summary>
/// <param name="w1"></param>
/// <param name="wt"></param>
/// <param name="ignorable"></param>
/// <returns></returns>
public ArbiterWaypoint GetNext(ArbiterWaypoint w1, WaypointType wt, List<ArbiterWaypoint> ignorable)
{
ArbiterWaypoint tmp = w1;
while (tmp != null)
{
if (tmp.WaypointTypeEquals(wt) && !ignorable.Contains(tmp))
return tmp;
if (tmp.NextPartition != null)
tmp = tmp.NextPartition.Final;
else
tmp = null;
}
return null;
}
public PolygonWaypoint(int id, double x, double y, WaypointType type) {
this.id = id;
this.x = x;
this.y = y;
this.waypointType = type;
neighbors = new List<PolygonWaypoint>();
edgeNum = -1;
}
/// <summary>
/// Get the next waypoint of a certain type
/// </summary>
/// <param name="w1">Starting waypoint of search</param>
/// <param name="wt">Waypoint type to look for</param>
/// <returns></returns>
public ArbiterWaypoint GetNext(ArbiterWaypoint w1, WaypointType wt)
{
return this.GetNext(w1, wt, new List<ArbiterWaypoint>());
}
public Waypoint(Vector2 node, WaypointType type, float waitTime)
{
Node = node;
Type = type;
WaitTime = waitTime;
}
/// <summary>
/// Type off a waypoint
/// </summary>
/// <param name="wt"></param>
/// <returns></returns>
public bool WaypointTypeEquals(WaypointType wt)
{
if (wt == WaypointType.End)
{
return this.NextPartition == null ? true : false;
}
else if (wt == WaypointType.Entry)
{
return this.isEntry;
}
else if (wt == WaypointType.Exit)
{
return this.isExit;
}
else if (wt == WaypointType.Stop)
{
return this.IsStop;
}
else
return this.PreviousPartition == null;
}
public Waypoint(WaypointType Type, string LabelName)
{
wType = Type;
wLabelName = LabelName;
}
/// <summary>
/// Get the next waypoint of a certain type
/// </summary>
/// <param name="loc">Location to start looking from</param>
/// <param name="wt">Waypoint type to look for</param>
/// <param name="ignorable">ignorable waypoints</param>
/// <returns></returns>
public ArbiterWaypoint GetNext(Coordinates loc, WaypointType wt, List<ArbiterWaypoint> ignorable)
{
return this.GetNext(this.GetClosestPartition(loc).Final, wt, ignorable);
}
public Waypoint(WaypointType waypointType, Location location, string action)
{
_waypointType = waypointType;
_location = location;
_action = action;
}
public Waypoint(WaypointType Type, int SleepTime1, int SleepTime2)
{
wType = Type;
wSleepTime1 = SleepTime1;
wSleepTime2 = SleepTime2;
}
public Waypoint(WaypointType Type, Location Location)
{
wType = Type;
wLocation = Location;
}
/// <summary>
/// Get the next waypoint of a certain type
/// </summary>
/// <param name="loc">Location to start looking from</param>
/// <param name="wt">Waypoint type to look for</param>
/// <param name="ignorable">ignorable waypoints</param>
/// <returns></returns>
public ArbiterWaypoint GetNext(Coordinates loc, WaypointType wt, List<ArbiterWaypoint> ignorable)
{
List<WaypointType> wts = new List<WaypointType>();
wts.Add(wt);
SLComponentType closest = this.ClosestComponent(loc);
if (closest == SLComponentType.Initial)
return this.GetNext(this.Initial.GetClosestPartition(loc).Final, wts, ignorable);
else if (closest == SLComponentType.Final)
return this.GetNext(this.Final.GetClosestPartition(loc).Final, wts, ignorable);
else
return this.GetNext(this.Final.GetClosestPartition(loc).Final, wts, ignorable);
}
public Waypoint(WaypointType Type)
{
wType = Type;
}
public Waypoint(int waypointID, WaypointType waypointType, Location location, string action)
{
_waypointId = waypointID;
_waypointType = waypointType;
_location = location;
_action = action;
}
public DisplayWaypoint(Serial serial, int x, int y, int z, int mapID, /*int type*/WaypointType type, string name)
: base(0xE5)
{
this.EnsureCapacity(25);
m_Stream.Write((int)serial);
m_Stream.Write((short)x);
m_Stream.Write((short)y);
m_Stream.Write((sbyte)z);
m_Stream.Write((byte)mapID); //map
m_Stream.Write((ushort)type);
//m_Stream.Write((short)type); //type
m_Stream.Write((short)0);
if (type.Equals(1))
m_Stream.Write((int)1046414);
else
m_Stream.Write((int)1062613);
m_Stream.WriteLittleUniNull(name);
m_Stream.Write((short)0); // terminate
}
public Waypoint(WaypointType Type, SayType SayType, string TextToSay)
{
wType = Type;
wSayType = SayType;
wTextToSay = TextToSay;
}
public KRDisplayWaypoint(IEntity e, WaypointType type, int cliLoc)
: this(e.Serial, e.Location, e.Map, type, false, cliLoc, String.Empty)
{
}
public Waypoint(WaypointType Type, uint ItemID)
{
wType = Type;
wItemID = ItemID;
}
public KRDisplayWaypoint(IEntity e, WaypointType type, bool ignoreSerial, int cliLoc, string args)
: this(e.Serial, e.Location, e.Map, type, ignoreSerial, cliLoc, args)
{
}
/// <summary>
/// Criando o waypoint.
/// </summary>
public Waypoint(int pId, GameObject pObject, WaypointType pType)
: base(pId, pObject)
{
this._type = pType;
}
public KRDisplayWaypoint(Serial serial, IPoint3D location, Map map, WaypointType type, bool ignoreSerial, int cliLoc)
: this(serial, location, map, type, ignoreSerial, cliLoc, String.Empty)
{
}
public KRDisplayWaypoint(Serial serial, IPoint3D location, Map map, WaypointType type, bool ignoreSerial, int cliLoc, string args)
: base(0xE5)
{
if (args == null)
args = String.Empty;
EnsureCapacity(21 + (args.Length * 2));
m_Stream.Write((int)serial);
m_Stream.Write((ushort)location.X);
m_Stream.Write((ushort)location.Y);
m_Stream.Write((byte)location.Z);
m_Stream.Write((byte)map.MapID);
m_Stream.Write((ushort)type);
m_Stream.Write((ushort)(ignoreSerial ? 1 : 0));
m_Stream.Write(cliLoc);
m_Stream.WriteLittleUniNull(args);
}
/// <summary>
/// Get the next waypoint of a certain type
/// </summary>
/// <param name="w1"></param>
/// <param name="wt"></param>
/// <param name="ignorable"></param>
/// <returns></returns>
public ArbiterWaypoint GetNext(ArbiterWaypoint w1, WaypointType wt, List<ArbiterWaypoint> ignorable)
{
List<WaypointType> wts = new List<WaypointType>();
wts.Add(wt);
return this.GetNext(w1, wts, ignorable);
}
protected override void OnNextWaypoint()
{
if (previousWaypoint != null && currentWaypoint != null)
{
WaypointType wptypeFrom = previousWaypoint.GetComponent <WaypointType>();
WaypointType wptypeTo = currentWaypoint.GetComponent <WaypointType>();
if (wptypeFrom != null)
{
switch (wptypeFrom.Value)
{
case WaypointType.WPType.Null:
speedMod = FromModifiers.NullMod;
break;
case WaypointType.WPType.Grass:
speedMod = FromModifiers.GrassMod;
break;
case WaypointType.WPType.Water:
speedMod = FromModifiers.WaterMod;
break;
case WaypointType.WPType.Sand:
speedMod = FromModifiers.SandMod;
break;
case WaypointType.WPType.Snow:
speedMod = FromModifiers.SnowMod;
break;
case WaypointType.WPType.Mountain:
speedMod = FromModifiers.MountainMod;
break;
case WaypointType.WPType.Bridge:
speedMod = FromModifiers.BridgeMod;
break;
case WaypointType.WPType.Town:
speedMod = FromModifiers.TownMod;
break;
}
}
else
{
speedMod = 1.0f;
}
if (wptypeTo != null)
{
switch (wptypeTo.Value)
{
case WaypointType.WPType.Null:
speedMod *= ToModifiers.NullMod;
break;
case WaypointType.WPType.Grass:
speedMod *= ToModifiers.GrassMod;
break;
case WaypointType.WPType.Water:
speedMod *= ToModifiers.WaterMod;
break;
case WaypointType.WPType.Sand:
speedMod *= ToModifiers.SandMod;
break;
case WaypointType.WPType.Snow:
speedMod *= ToModifiers.SnowMod;
break;
case WaypointType.WPType.Mountain:
speedMod *= ToModifiers.MountainMod;
break;
case WaypointType.WPType.Bridge:
speedMod *= ToModifiers.BridgeMod;
break;
case WaypointType.WPType.Town:
speedMod *= ToModifiers.TownMod;
break;
}
}
}
}
/// <summary>
/// Get the next waypoint of a certain type
/// </summary>
/// <param name="w1">Starting waypoint of search</param>
/// <param name="wt">Waypoint type to look for</param>
/// <returns></returns>
public ArbiterWaypoint GetNext(ArbiterWaypoint w1, WaypointType wt)
{
ArbiterWaypoint tmp = w1;
while (tmp != null)
{
if (tmp.WaypointTypeEquals(wt))
return tmp;
if (tmp.NextPartition != null)
tmp = tmp.NextPartition.Final;
else
tmp = null;
}
return null;
}
