public ZonePoint[] GetCircle(ZonePoint center, double radius, int points) { // Sanity check. if (points < 3) { throw new ArgumentOutOfRangeException("points", "Cannot compute a circle with fewer than 3 points."); } // Computes the input. CalcInput c = new CalcInput(); c.MainPoint = new Point(center); c.TargetVector = new Vector(radius, null); // For each needed point, translate the center "radius meters" // towards "i * 360/points". ZonePoint[] pts = new ZonePoint[points]; double step = 360d / points; for (int i = 0; i < points; i++) { c.TargetVector.Bearing = step * i; pts[i] = TranslatePointCore(c).ToZonePoint(_dataFactory); } return(pts); }
public LuaVararg VectorToSegmentLua(LuaTable zonePoint, LuaTable firstLineZonePoint, LuaTable secondLineZonePoint) { List <LuaValue> ret = new List <LuaValue>(2); if (zonePoint == null || firstLineZonePoint == null || secondLineZonePoint == null) { ret.Add(LuaNil.Instance); ret.Add(LuaNil.Instance); return(new LuaVararg(ret, true)); } // Gets the data model entities. ZonePoint zonePointEntity = _dataFactory.GetWherigoObject <ZonePoint>(zonePoint); ZonePoint firstLinezonePointEntity = _dataFactory.GetWherigoObject <ZonePoint>(firstLineZonePoint); ZonePoint secondLinezonePointEntity = _dataFactory.GetWherigoObject <ZonePoint>(secondLineZonePoint); // Performs the computation. LocationVector lv = _mathHelper.VectorToSegment( _dataFactory.GetWherigoObject <ZonePoint>(zonePoint), _dataFactory.GetWherigoObject <ZonePoint>(firstLineZonePoint), _dataFactory.GetWherigoObject <ZonePoint>(secondLineZonePoint) ); // Prepares the lua return. ret.Add(_dataFactory.GetNativeContainer(lv.Distance)); ret.Add(lv.Bearing.GetValueOrDefault()); return(new LuaVararg(ret, true)); }
override public List <ZonePoint> GetZonePointList() { List <ZonePoint> ZonePointList = new List <ZonePoint>(); List <byte[]> ZonePointPackets = GetPacketsOfType("OP_SendZonepoints", PacketDirection.ServerToClient); if (ZonePointPackets.Count < 1) { return(ZonePointList); } // Assume there is only 1 packet and process the first one. ByteStream Buffer = new ByteStream(ZonePointPackets[0]); UInt32 Entries = Buffer.ReadUInt32(); if (Entries == 0) { return(ZonePointList); } float x, y, z, Heading; UInt32 Number; UInt16 ZoneID, Instance; ZonePointList = new List <ZonePoint>(); for (int i = 0; i < Entries; ++i) { Number = Buffer.ReadUInt32(); y = Buffer.ReadSingle(); x = Buffer.ReadSingle(); z = Buffer.ReadSingle(); Heading = Buffer.ReadSingle(); if (Heading != 999) { Heading = Heading / 2; } ZoneID = Buffer.ReadUInt16(); Instance = Buffer.ReadUInt16(); Buffer.SkipBytes(8); // Skip the last UInt32 ZonePoint NewZonePoint = new ZonePoint(Number, ZoneID, Instance, x, y, z, x, y, z, Heading, ZoneID); ZonePointList.Add(NewZonePoint); } return(ZonePointList); }
/// <summary> /// Decides whether player can jump to the target point. /// All messages with reasons must be sent here. /// Can change destination too. /// </summary> /// <param name="targetPoint">The jump destination</param> /// <param name="player">The jumping player</param> /// <returns>True if allowed</returns> public bool IsAllowedToJump(ZonePoint targetPoint, GamePlayer player) { // Handles zoning INTO an instance. GameLocation loc = null; // First, we try the groups mission. if (player.Group != null) { Group grp = player.Group; if (grp.Mission is TaskDungeonMission task) { // Attempt to get the instance entrance location... loc = task.TaskRegion.InstanceEntranceLocation; } } else if (player.Mission is TaskDungeonMission) { // Then, try personal missions... TaskDungeonMission task = (TaskDungeonMission)player.Mission; loc = task.TaskRegion.InstanceEntranceLocation; } if (loc != null) { targetPoint.TargetX = loc.X; targetPoint.TargetY = loc.Y; targetPoint.TargetZ = loc.Z; targetPoint.TargetRegion = loc.RegionID; targetPoint.TargetHeading = loc.Heading; return(true); } player.Out.SendMessage("You need to have a proper mission before entering this area!", eChatType.CT_System, eChatLoc.CL_SystemWindow); return(false); }
private void GenerateCoin(ZonePoint zonePoint) { // Get coin from pull var coinObject = PoolManager.Instance.CoinPool.GetObject(zonePoint.GetPointPosition()); coinObject.SetActive(true); coinObject.transform.parent = _coinsContainer.transform; zonePoint.AddElement(coinObject); }
public void Remove(int x, int y) { ZonePoint zp = Points.Find(p => p.X == x && p.Y == y); if (zp != null) { Points.Remove(zp); } }
public bool ConsumeZonePointWith <T>(ZonePoint point) where T : IAreaConsumption { var result = Area .ConsumeZoneAt(point.GetZoneInfoOn(Area).MatchingObject, _factories[typeof(T)]()); return(result.Success); }
public bool IsAllowedToJump(ZonePoint targetPoint, GamePlayer player) { if (player.Level < 10 && player.Level > 4) { return(true); } player.Client.Out.SendMessage("You do not meet the requirements to enter this region!", eChatType.CT_System, eChatLoc.CL_ChatWindow); return(false); }
public bool IsPointInZone(ZonePoint point, Zone target) { // Computes the calculation input. CalcInput c = new CalcInput(); c.MainPoint = new Point(point); c.SetTargetZone(target); return(IsPointInZoneCore(c)); }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { ZonePoint zp = value as ZonePoint; if (zp == null) { return(null); } return(zp.ToString(GeoCoordinateUnit.DegreesMinutes)); }
/// <summary> /// Constructs a new RegionChangeRequestHandler /// </summary> /// <param name="actionSource">The action source</param> /// <param name="zonePoint">The target zone point</param> /// <param name="checker">The jump point checker instance</param> public RegionChangeRequestHandler(GamePlayer actionSource, ZonePoint zonePoint, IJumpPointHandler checkHandler) : base(actionSource) { if (zonePoint == null) { throw new ArgumentNullException("zonePoint"); } m_zonePoint = zonePoint; m_checkHandler = checkHandler; }
/// <summary> /// Decides whether player can jump to the target point. /// All messages with reasons must be sent here. /// Can change destination too. /// </summary> /// <param name="targetPoint">The jump destination</param> /// <param name="player">The jumping player</param> /// <returns>True if allowed</returns> public bool IsAllowedToJump(ZonePoint targetPoint, GamePlayer player) { if (GameServer.Instance.Configuration.ServerType != eGameServerType.GST_Normal) { return(true); } if (ServerProperties.Properties.ALLOW_ALL_REALMS_DF) { return(true); } return(player.Realm == DarknessFallOwner); }
public bool ConsumeZonePointWithNetwork <T>(ZonePoint point) where T : BaseInfrastructureNetworkZoneConsumption { var zoneInfo = point.GetZoneInfoOn(Area).MatchingObject; if (zoneInfo.ConsumptionState.GetIsNetworkMember <T>()) { return(true); } return(ConsumeZonePointWith <T>(point)); }
public bool IsAllowedToJump(ZonePoint targetPoint, GamePlayer player) { if (player.Client.Account.PrivLevel > 1) { return(true); } if (player.Level < 10 && player.Level > 4) { return(true); } player.Client.Out.SendMessage(LanguageMgr.GetTranslation(player.Client.Account.Language, "DemonsBreachJumpPoint.Requirements"), eChatType.CT_System, eChatLoc.CL_ChatWindow); return(false); }
/// <summary> /// Decides whether player can jump to the target point. /// All messages with reasons must be sent here. /// Can change destination too. /// </summary> /// <param name="targetPoint">The jump destination</param> /// <param name="player">The jumping player</param> /// <returns>True if allowed</returns> public bool IsAllowedToJump(ZonePoint targetPoint, GamePlayer player) { if (player.CurrentRegion is BaseInstance == false) { return(true); } if (((BaseInstance)player.CurrentRegion).OnInstanceDoor(player, targetPoint)) { return(true); } return(false); // Let instance handle zoning by itself in this case... }
public ZonePoint TranslatePoint(ZonePoint point, LocationVector vector) { // Computes the input. CalcInput c = new CalcInput(); c.MainPoint = new Point(point); c.TargetVector = new Vector(vector); // Performs the computation. Point newPoint = TranslatePointCore(c); // Returns the right object. return(newPoint.ToZonePoint(_dataFactory)); }
public LocationVector VectorToPoint(ZonePoint point, ZonePoint target) { // Computes the input. CalcInput c = new CalcInput(); c.MainPoint = new Point(point); c.TargetPoint = new Point(target); // Performs the computation. Vector vector = VectorToPointCore(c); // Returns the right object. return(vector.ToLocationVector(_dataFactory)); }
public bool IsPointInZoneLua(LuaTable zonePoint, LuaTable zone) { if (zonePoint == null || zone == null) { throw new ArgumentNullException(); } // Gets the data model entities. ZonePoint zonePointEntity = _dataFactory.GetWherigoObject <ZonePoint>(zonePoint); Zone zoneEntity = _dataFactory.GetWherigoObject <Zone>(zone); // Computes and returns. return(_mathHelper.IsPointInZone(zonePointEntity, zoneEntity)); }
/// <summary> /// Decides whether player can jump to the target point. /// All messages with reasons must be sent here. /// Can change destination too. /// </summary> /// <param name="targetPoint">The jump destination</param> /// <param name="player">The jumping player</param> /// <returns>True if allowed</returns> public bool IsAllowedToJump(ZonePoint targetPoint, GamePlayer player) { StartupLocations.StartLocation loc = StartupLocations.MainTownStartingLocations[player.CharacterClass.ID] as StartupLocations.StartLocation; if (loc != null) { targetPoint.TargetX = loc.X; targetPoint.TargetY = loc.Y; targetPoint.TargetZ = loc.Z; targetPoint.TargetHeading = (ushort)loc.Heading; return(true); } return(false); }
public LocationVector VectorToSegment(ZonePoint point, ZonePoint segmentStartPoint, ZonePoint segmentEndPoint) { // Computes the input. CalcInput c = new CalcInput(); c.MainPoint = new Point(point); c.SegmentPoint1 = new Point(segmentStartPoint); c.SegmentPoint2 = new Point(segmentEndPoint); // Performs the computation. Vector vector = VectorToSegmentCore(c); // Returns the right object. return(vector.ToLocationVector(_dataFactory)); }
/// <summary> /// Decides whether player can jump to the target point. /// All messages with reasons must be sent here. /// Can change destination too. /// </summary> /// <param name="targetPoint">The jump destination</param> /// <param name="player">The jumping player</param> /// <returns>True if allowed</returns> public bool IsAllowedToJump(ZonePoint targetPoint, GamePlayer player) { StartupLocation loc = StartupLocations.GetNonTutorialLocation(player); if (loc != null) { targetPoint.TargetX = loc.XPos; targetPoint.TargetY = loc.YPos; targetPoint.TargetZ = loc.ZPos; targetPoint.TargetHeading = (ushort)loc.Heading; targetPoint.TargetRegion = (ushort)loc.Region; return(true); } return(false); }
public LuaTable TranslatePointLua(LuaTable zonePoint, LuaTable distance, double bearing) { // Gets the data model entities. ZonePoint zonePointEntity = _dataFactory.GetWherigoObject <ZonePoint>(zonePoint); Distance distanceEntity = _dataFactory.GetWherigoObject <Distance>(distance); // Performs the computation. ZonePoint ret = _mathHelper.TranslatePoint( _dataFactory.GetWherigoObject <ZonePoint>(zonePoint), new LocationVector( _dataFactory.GetWherigoObject <Distance>(distance), bearing ) ); return(_dataFactory.GetNativeContainer(ret)); }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { ZonePoint zp = value as ZonePoint; if (zp == null) { if (!(parameter is string) || (string)parameter != "NoNull") { return(null); } else { zp = new ZonePoint(0, 0, 0); } } return(zp.ToGeoCoordinate()); }
public LuaVararg VectorToPointLua(LuaTable zonePoint1, LuaTable zonePoint2) { List <LuaValue> ret = new List <LuaValue>(2); // Gets the data model entities. ZonePoint zonePoint1Entity = _dataFactory.GetWherigoObject <ZonePoint>(zonePoint1); ZonePoint zonePoint2Entity = _dataFactory.GetWherigoObject <ZonePoint>(zonePoint2); // Performs the computation. LocationVector lv = _mathHelper.VectorToPoint( _dataFactory.GetWherigoObject <ZonePoint>(zonePoint1), _dataFactory.GetWherigoObject <ZonePoint>(zonePoint2) ); // Prepares the lua return. ret.Add(_dataFactory.GetNativeContainer(lv.Distance)); ret.Add(lv.Bearing.GetValueOrDefault()); return(new LuaVararg(ret, true)); }
internal GWS( Cartridge cart, Character player, IPlatformHelper platformHelper, LuaDataFactory dataFactory) { this._dataFactory = dataFactory; this._cartridgeEntity = cart; this._cartridge = (LuaDataContainer)cart.DataContainer; this._player = (LuaDataContainer)player.DataContainer; this._platformHelper = platformHelper; ZonePoint pos = player.ObjectLocation; this._latitude = pos.Latitude; this._longitude = pos.Longitude; this._altitude = pos.Latitude; }
public LuaVararg VectorToZoneLua(LuaTable zonePoint, LuaTable zone) { List <LuaValue> ret = new List <LuaValue>(2); if (zonePoint == null || zone == null) { throw new ArgumentNullException(); } // Gets the data model entities. ZonePoint zonePointEntity = _dataFactory.GetWherigoObject <ZonePoint>(zonePoint); Zone zoneEntity = _dataFactory.GetWherigoObject <Zone>(zone); // Performs the computation. LocationVector vector = _mathHelper.VectorToZone(zonePointEntity, zoneEntity); // Prepares the lua return. ret.Add(vector.Distance != null ? (LuaValue)_dataFactory.GetNativeContainer(vector.Distance) : LuaNil.Instance); ret.Add(vector.Bearing); return(new LuaVararg(ret, true)); }
public static ClientZonePoint Create(ZonePoint zonePoint) => new ClientZonePoint { x = zonePoint.X, y = zonePoint.Y };
private WherigoObject GetWherigoObjectCore( LuaTable obj, bool dontFailIfNotWigEntity = false, bool forceProtectFromGC = false, bool allowsNullTable = false, Type typeToCompare = null) { // Sanity check. if (obj == null) { if (!allowsNullTable) { throw new ArgumentNullException("Null table argument is not allowed."); } return(null); } // Gets the class of the entity. string cn = _luaState.SafeGetField <string>(obj, "ClassName"); if (cn == null) { if (dontFailIfNotWigEntity) { return(null); } throw new InvalidOperationException("obj has no ClassName string property."); } // Does the entity have an ObjIndex? // YES -> it should be in the AllZObjects table, so retrieve or make it. // NO -> make it anyway. WherigoObject ret = null; double? oiRaw = _luaState.SafeGetField <double?>(obj, "ObjIndex"); if (oiRaw == null) { // Creates a container for the table. // It is not protected from GC by default. LuaDataContainer ldc = CreateContainerCore(obj, forceProtectFromGC); // Immediately wraps the table into its corresponding class. if ("ZonePoint" == cn) { ret = new ZonePoint(ldc); } else if ("ZCommand" == cn || "ZReciprocalCommand" == cn) { ret = new Command( ldc, MakeCommandCalcTargetObjectsInstance(ldc), MakeCommandExecuteCommandInstance(ldc) ); } else if ("Distance" == cn) { ret = new Distance(ldc); } } else { // Tries to get the object from the cache if it is not // the player or cartridge object. int oi = (int)oiRaw.Value; bool isPlayer = oi < 0; bool isCartridge = oi == 0; Node node; if (!isPlayer && !isCartridge) { bool hasValue; lock (_syncRoot) { hasValue = _wEntities.TryGetValue(oi, out node); } // The object is known, returns it. if (hasValue) { ret = node.Object; // Double check the classname. string cachedCn = ret.DataContainer.GetString("ClassName"); if (cn != cachedCn) { throw new InvalidOperationException(String.Format("The object with id {0} is known to have class {1}, but class {2} was requested.", oi, cachedCn ?? "<null>", cn ?? "<null>")); } } } // The object is not known, make it and create a node for it. if (ret == null) { // Creates a GC-protected container for the table. FriendLuaDataContainer ldc = CreateContainerCore(obj, true); // Creates the object. if ("ZInput" == cn) { ret = new Input( ldc, MakeInputRunOnGetInputInstance(ldc) ); } else if ("ZTimer" == cn) { ret = new Timer(ldc); } else if ("ZCharacter" == cn) { if (isPlayer && _helper.Player != null) { ret = _helper.Player; } else { ret = new Character( ldc, MakeUIObjectRunOnClickInstance(ldc) ); } } else if ("ZItem" == cn) { ret = new Item( ldc, MakeUIObjectRunOnClickInstance(ldc) ); } else if ("ZTask" == cn) { ret = new Task( ldc, MakeUIObjectRunOnClickInstance(ldc) ); } else if ("Zone" == cn) { ret = new Zone( ldc, MakeUIObjectRunOnClickInstance(ldc) ); } else if ("ZMedia" == cn) { // Gets the ZMedia from the Cartridge which has the same Id. Media media = _helper.Cartridge.Resources.Single(m => m.MediaId == oi); // Injects the data container with metadata about the media. media.DataContainer = ldc; // The returned object is the media. ret = media; } else if ("ZCartridge" == cn) { // Sanity checks if the Cartridge GUIDs match. string baseId = _helper.Cartridge.Guid; string reqId = ldc.GetString("Id"); if (baseId != reqId) { //throw new InvalidOperationException(String.Format("Requested Cartridge with id {0}, but only knows Cartridge with id {1}.", reqId, baseId)); System.Diagnostics.Debug.WriteLine("LuaDataFactory: WARNING: " + String.Format("Requested Cartridge with id {0}, but only knows Cartridge with id {1}.", reqId, baseId)); } // Returns the cartridge object. ret = _helper.Cartridge; // Binds the cartridge container if the cartridge is unbound. if (ret.DataContainer == null) { ret.DataContainer = ldc; } } else { throw new InvalidOperationException("obj has an unknown classname: " + cn); } // Creates a node and registers it. Cartridge and player are not registered. if (!isPlayer && !isCartridge) { node = new Node() { Container = ldc, Object = ret }; lock (_syncRoot) { _wEntities.Add(oi, node); } } } } // Final sanity checks. if (ret == null) { throw new InvalidOperationException("Returned value was not computed."); } if (typeToCompare != null && !typeToCompare.IsAssignableFrom(ret.GetType())) { throw new InvalidOperationException(String.Format("The wherigo object is known to have type {0}, not {1} as requested.", ret.GetType().FullName, typeToCompare.FullName)); } return(ret); }
public Point(ZonePoint point) { Lat = point == null ? ZonePoint.Invalid.Latitude : point.Latitude; Lon = point == null ? ZonePoint.Invalid.Longitude : point.Longitude; }
public ZonePoint[] GetCircle(ZonePoint center, double radius, int points) { // Sanity check. if (points < 3) { throw new ArgumentOutOfRangeException("points", "Cannot compute a circle with fewer than 3 points."); } // Computes the input. CalcInput c = new CalcInput(); c.MainPoint = new Point(center); c.TargetVector = new Vector(radius, null); // For each needed point, translate the center "radius meters" // towards "i * 360/points". ZonePoint[] pts = new ZonePoint[points]; double step = 360d / points; for (int i = 0; i < points; i++) { c.TargetVector.Bearing = step * i; pts[i] = TranslatePointCore(c).ToZonePoint(_dataFactory); } return pts; }
public ZonePoint TranslatePoint(ZonePoint point, LocationVector vector) { // Computes the input. CalcInput c = new CalcInput(); c.MainPoint = new Point(point); c.TargetVector = new Vector(vector); // Performs the computation. Point newPoint = TranslatePointCore(c); // Returns the right object. return newPoint.ToZonePoint(_dataFactory); }
public LocationVector VectorToPoint(ZonePoint point, ZonePoint target) { // Computes the input. CalcInput c = new CalcInput(); c.MainPoint = new Point(point); c.TargetPoint = new Point(target); // Performs the computation. Vector vector = VectorToPointCore(c); // Returns the right object. return vector.ToLocationVector(_dataFactory); }
private static double CalculateDistance(ZonePoint x, ZonePoint y) { int x1 = x.X, x2 = y.X, y1 = x.Y, y2 = y.Y; return((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); }
public bool IsPointInZone(ZonePoint point, Zone target) { // Computes the calculation input. CalcInput c = new CalcInput(); c.MainPoint = new Point(point); c.SetTargetZone(target); return IsPointInZoneCore(c); }
public void HandlePacket(GameClient client, GSPacketIn packet) { ushort jumpSpotID = packet.ReadShort(); eRealm targetRealm = client.Player.Realm; if (client.Player.CurrentRegion.Expansion == (int)eClientExpansion.TrialsOfAtlantis && client.Player.CurrentZone.Realm != eRealm.None) { // if we are in TrialsOfAtlantis then base the target jump on the current region realm instead of the players realm // this is only used if zone table has the proper realms defined, otherwise it reverts to old behavior - Tolakram targetRealm = client.Player.CurrentZone.Realm; } var zonePoint = GameServer.Database.SelectObjects <ZonePoint>("`Id` = @Id AND (`Realm` = @Realm OR `Realm` = @DefaultRealm OR `Realm` IS NULL)", new [] { new QueryParameter("@Id", jumpSpotID), new QueryParameter("@Realm", (byte)targetRealm), new QueryParameter("@DefaultRealm", 0) }).FirstOrDefault(); if (zonePoint == null || zonePoint.TargetRegion == 0) { ChatUtil.SendDebugMessage(client, "Invalid Jump (ZonePoint table): [" + jumpSpotID + "]" + ((zonePoint == null) ? ". Entry missing!" : ". TargetRegion is 0!")); zonePoint = new ZonePoint(); zonePoint.Id = jumpSpotID; } if (client.Account.PrivLevel > 1) { client.Out.SendMessage("JumpSpotID = " + jumpSpotID, eChatType.CT_System, eChatLoc.CL_SystemWindow); client.Out.SendMessage("ZonePoint Target: Region = " + zonePoint.TargetRegion + ", ClassType = '" + zonePoint.ClassType + "'", eChatType.CT_System, eChatLoc.CL_SystemWindow); } //Dinberg: Fix - some jump points are handled code side, such as instances. //As such, region MAY be zero in the database, so this causes an issue. if (zonePoint.TargetRegion != 0) { Region reg = WorldMgr.GetRegion(zonePoint.TargetRegion); if (reg != null) { // check for target region disabled if player is in a standard region // otherwise the custom region should handle OnZonePoint for this check if (client.Player.CurrentRegion.IsCustom == false && reg.IsDisabled) { if ((client.Player.Mission is TaskDungeonMission && (client.Player.Mission as TaskDungeonMission).TaskRegion.Skin == reg.Skin) == false) { client.Out.SendMessage("This region has been disabled!", eChatType.CT_System, eChatLoc.CL_SystemWindow); if (client.Account.PrivLevel == 1) { return; } } } } } // Allow the region to either deny exit or handle the zonepoint in a custom way if (client.Player.CurrentRegion.OnZonePoint(client.Player, zonePoint) == false) { return; } //check caps for battleground Battleground bg = GameServer.KeepManager.GetBattleground(zonePoint.TargetRegion); if (bg != null) { if (client.Player.Level < bg.MinLevel && client.Player.Level > bg.MaxLevel && client.Player.RealmLevel >= bg.MaxRealmLevel) { return; } } IJumpPointHandler customHandler = null; if (string.IsNullOrEmpty(zonePoint.ClassType) == false) { customHandler = (IJumpPointHandler)m_customJumpPointHandlers[zonePoint.ClassType]; // check for db change to update cached handler if (customHandler != null && customHandler.GetType().FullName != zonePoint.ClassType) { customHandler = null; } if (customHandler == null) { //Dinberg - Instances need to use a special handler. This is because some instances will result //in duplicated zonepoints, such as if Tir Na Nog were to be instanced for a quest. string type = (client.Player.CurrentRegion.IsInstance) ? "DOL.GS.ServerRules.InstanceDoorJumpPoint" : zonePoint.ClassType; Type t = ScriptMgr.GetType(type); if (t == null) { Log.ErrorFormat("jump point {0}: class {1} not found!", zonePoint.Id, zonePoint.ClassType); } else if (!typeof(IJumpPointHandler).IsAssignableFrom(t)) { Log.ErrorFormat("jump point {0}: class {1} must implement IJumpPointHandler interface!", zonePoint.Id, zonePoint.ClassType); } else { try { customHandler = (IJumpPointHandler)Activator.CreateInstance(t); } catch (Exception e) { customHandler = null; Log.Error( string.Format("jump point {0}: error creating a new instance of jump point handler {1}", zonePoint.Id, zonePoint.ClassType), e); } } } if (customHandler != null) { m_customJumpPointHandlers[zonePoint.ClassType] = customHandler; } } new RegionChangeRequestHandler(client.Player, zonePoint, customHandler).Start(1); }
public LocationVector VectorToSegment(ZonePoint point, ZonePoint segmentStartPoint, ZonePoint segmentEndPoint) { // Computes the input. CalcInput c = new CalcInput(); c.MainPoint = new Point(point); c.SegmentPoint1 = new Point(segmentStartPoint); c.SegmentPoint2 = new Point(segmentEndPoint); // Performs the computation. Vector vector = VectorToSegmentCore(c); // Returns the right object. return vector.ToLocationVector(_dataFactory); }