/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { var temp = new UploadedNano() { NanoId = arguments[0].AsInt32() }; ((Character)self).UploadedNanos.Add(temp); UploadedNanosDao.Instance.WriteNano(((Character)self).Identity.Instance, temp); if (((Character)self).Controller.Client != null) { var message = new CharacterActionMessage() { Identity = self.Identity, Action = CharacterActionType.UploadNano, Target = self.Identity, Parameter1 = (int)IdentityType.NanoProgram, Parameter2 = temp.NanoId, Unknown = 0 }; ((Character)self).Controller.Client.SendCompressed(message); } return true; }
public override List<string> GetPrpertyValue(INamedEntity NE) { Predicate<Transceiver> match = null; Transceiver tranceiver = NE as Transceiver; List<string> list = new List<string>(); List<GeoPolygonRegion> polygonRegionList = this.m_Model.GeoObserver.GeoProvider.PolygonRegionList; List<Transceiver> tranceiverList = this.m_Model.TranceiverColl.TranceiverList; for (int i = 0; i < polygonRegionList.Count; i++) { if (match == null) { match = delegate (Transceiver temp) { return temp.Name == tranceiver.Name; }; } if (this.m_CellFilter.GetCalculateTranceivers(tranceiverList, polygonRegionList[i], true).Exists(match)) { list.Add(polygonRegionList[i].Name); } } if (list.Count == 0) { list.Add(this.otherField); } return list; }
public override List<string> GetPrpertyValue(INamedEntity NE) { Site site = NE as Site; List<string> list = new List<string>(); list.Add(this.GetValue(site)); return list; }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, INamedEntity caller, IInstancedEntity target, object[] arguments) { lock (target) { return this.FunctionExecute(self, caller, target, arguments); } }
private void BuildSubstitutionNode(PineappleTreeNode node, INamedEntity entity, string originalLine) { node.BacklightColorIndex = (int)Highlights.Substitution; node.Subitems.Add("Class substitution"); if (originalLine != null && Configs.Instance.ShowOriginal) node.Subitems.Add("Original line: " + originalLine); node.ToolTipText = "Target method not found in mapping."; node.ImageIndex = TreeBuilder.GetIconForEntity(entity.EntityType); }
public void Test_Monster_Join_Group() { _entity = new MapMonster { Name = "test" }; _group.JoinGroup(_entity); Assert.IsTrue(!_group.IsEmpty); }
private string GetEntityName(INamedEntity entity) { if (tbtnSimple.Checked) return entity.NameSimple; if (tbtnShort.Checked) return entity.NameShort; if (tbtnFull.Checked) return entity.NameFull; throw new ArgumentException("Invalid selected show mode"); }
public static PidxPacket GeneratePidx(this Group group, INamedEntity entity) { return(new PidxPacket { GroupId = group.Count == 1 ? -1 : group.GroupId, SubPackets = group.Count == 1 ? new List <PidxSubPacket?> { entity.GenerateSubPidx(true) } : group.Values.Select(s => s.Item2.GenerateSubPidx()).ToList() as List <PidxSubPacket?> }); }
public static SpeakPacket GenerateSpk(this INamedEntity visualEntity, SpeakPacket packet) { return(new SpeakPacket { VisualType = visualEntity.VisualType, VisualId = visualEntity.VisualId, SpeakType = packet.SpeakType, EntityName = visualEntity.Name, Message = packet.Message }); }
private void BuildSubstitutionNode(PineappleTreeNode node, INamedEntity entity, string originalLine) { node.BacklightColorIndex = (int)Highlights.Substitution; node.Text += "\nClass substitution"; if (originalLine != null && Configs.Instance.ShowOriginal) { node.Text += "\nOriginal line: " + originalLine; } node.ToolTipText = "Target method not found in mapping."; node.ImageIndex = TreeBuilder.GetIconForEntity(entity.EntityType, mainForm); }
private void BuildFailedNode(PineappleTreeNode node, INamedEntity entity, string originalLine) { node.ImageIndex = TreeBuilder.GetIconForEntity(entity.EntityType, mainForm); node.BacklightColorIndex = (int)Highlights.Unknown; node.Text += "\nUnable to deobfuscate."; if (originalLine != null && Configs.Instance.ShowOriginal) { node.Text += "\nOriginal line: " + originalLine; } node.ToolTipText = "Unable to deobfuscate method. It is of an unknown or system assembly."; }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, INamedEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { lock (target) { return(this.FunctionExecute(self, caller, target, arguments)); } }
/// <summary> /// Creates a chat message packet for a non-player object. /// </summary> /// <param name="type">the type of chat message</param> /// <param name="language">the language the message is in</param> /// <param name="obj">the object "saying" the message</param> /// <param name="msg">the message itself</param> /// <param name="tag">any chat tags for the object</param> /// <returns>the generated chat packet</returns> private static RealmPacketOut CreateObjectChatMessage(ChatMsgType type, ChatLanguage language, INamedEntity obj, string msg, ChatTag tag) { var packet = CreateObjectChatMessage(type, language, obj); //packet.Write(obj.EntityId); packet.WriteUIntPascalString(msg); // 30 + nameLength + msg.Length packet.Write((byte)tag); // 31 + ... return(packet); }
private IRepository CreateDefault <TEntity>(DbContext context) where TEntity : class, IEntity, new() { return((new TEntity()) switch { IDateTimeEntity _ => CreateGenericRepository <TEntity>(typeof(DateTimeStateRepository <>), context), IRangeEntity <DateTime> _ => CreateGenericRepository <TEntity>(typeof(DateRangeRepository <>), context), IRangeEntity <TimeSpan> _ => CreateGenericRepository <TEntity>(typeof(TimeRangeRepository <>), context), INamedEntity _ => CreateGenericRepository <TEntity>(typeof(NamedRepository <>), context), _ => new Repository <TEntity>(context), });
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, INamedEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { IZoneClient client = ((ICharacter)self).Client; BankMessage bankmessage = OpenBank.Create(client); client.Character.Send(bankmessage); return(true); }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, INamedEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { if (Self is Character) { Character t = (Character)Self; bool found = false; int placement; if (Arguments.Length == 2) { placement = 0; } else { placement = (Int32)Arguments[Arguments.Length - 1]; } if (placement >= 49) { if (t.SocialTab.ContainsKey((Int32)Arguments[1])) { t.SocialTab[(Int32)Arguments[1]] = (Int32)Arguments[0]; } else { t.SocialTab.Add((Int32)Arguments[1], (Int32)Arguments[0]); } } else { foreach (AOTextures aot in t.Textures) { if (aot.place == (Int32)Arguments[1]) { found = true; aot.Texture = (Int32)Arguments[0]; } } if (!found) { t.Textures.Add(new AOTextures((Int32)Arguments[1], (Int32)Arguments[0])); } } AppearanceUpdate.AnnounceAppearanceUpdate(t); } return(true); }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, INamedEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { Character ch = (Character)Self; ch.Stats[Arguments[0].AsInt32()].PercentageModifier += Arguments[1].AsInt32(); Console.WriteLine("percentage-modify stat " + Arguments[0].AsInt32()); return(true); }
//Pet Monster in packet public static InPacket GenerateIn(this INamedEntity visualEntity) { return(new InPacket() { VisualType = visualEntity.VisualType, Name = visualEntity.Name, VNum = visualEntity.VNum == 0 ? string.Empty : visualEntity.VNum.ToString(), PositionX = visualEntity.PositionX, PositionY = visualEntity.PositionY, Direction = visualEntity.Direction, }); }
private static void AssertResult(List <SearchResults> list, int index, string name, string nameSimple, string nameFull) { SearchResults results = list[index]; INamedEntity result = results.SingleResult; Assert.IsNull(result, "Have no result"); Assert.IsFalse(results.IsSingleResult, "Not a single result"); Assert.AreEqual(SearchResultMessage.Failed, results.Message, "Result type"); Assert.AreEqual(nameSimple, results.ToString(), "results.ToString"); Assert.AreEqual(name, results.ToString(OutputType.Short), "ToString(Short)"); Assert.AreEqual(nameSimple, results.ToString(OutputType.Simple), "ToString(Simple)"); Assert.AreEqual(nameFull, results.ToString(OutputType.Full), "ToString(Full)"); }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute(INamedEntity Self, INamedEntity Caller, IInstancedEntity Target, object[] Arguments) { int statNumber = (int)Arguments[0]; int statValue = (int)Arguments[1]; IStats tempTarget = Target; if (tempTarget != null) { tempTarget.Stats[statNumber].Value = statValue; return true; } return false; }
/// <summary> /// </summary> /// <param name="identity"> /// </param> /// <returns> /// </returns> public INamedEntity FindNamedEntityByIdentity(Identity identity) { foreach (IInstancedEntity entity in this.Entities) { if ((entity.Identity.Instance == identity.Instance) && (entity.Identity.Type == identity.Type)) { INamedEntity temp = entity as INamedEntity; return(temp); } } return(null); }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute(INamedEntity Self, INamedEntity Caller, IInstancedEntity Target, object[] Arguments) { int statNumber = (int)Arguments[0]; int statValue = (int)Arguments[1]; IStats tempTarget = Target; if (tempTarget != null) { tempTarget.Stats[statNumber].Value = statValue; return(true); } return(false); }
/// <summary> /// Add a NamedEntity /// </summary> public static void AddNamedEntity(INamedEntity entity) { if (entity is Character) { AddCharacter((Character)entity); return; } using (worldLock.EnterWriteLock()) { s_namedEntities.Add(entity.EntityId.Low, entity); s_entitiesByName.Add(entity.Name, entity); } }
public void WriteDeclaration(IDefinition definition) { if (definition == null) return; IAssembly assembly = definition as IAssembly; if (assembly != null) { WriteAssemblyDeclaration(assembly); return; } INamespaceDefinition ns = definition as INamespaceDefinition; if (ns != null) { WriteNamespaceDeclaration(ns); return; } ITypeDefinition type = definition as ITypeDefinition; if (type != null) { WriteTypeDeclaration(type); return; } ITypeDefinitionMember member = definition as ITypeDefinitionMember; if (member != null) { WriteMemberDeclaration(member); return; } DummyInternalConstructor ctor = definition as DummyInternalConstructor; if (ctor != null) { WritePrivateConstructor(ctor.ContainingType); return; } INamedEntity named = definition as INamedEntity; if (named != null) { WriteIdentifier(named.Name); return; } _writer.Write("Unknown definition type {0}", definition.ToString()); }
public void Test_Add_Player() { _entity = new Character { Name = "TestExistingCharacter", Slot = 1, AccountId = 1, MapId = 1, State = CharacterState.Active }; _group.JoinGroup(_entity); Assert.IsFalse(_group.Count == 2); }
public static PinitSubPacket GenerateSubPinit(this INamedEntity namedEntity, int groupPosition) { return(new PinitSubPacket { VisualType = namedEntity.VisualType, VisualId = namedEntity.VisualId, GroupPosition = groupPosition, Level = namedEntity.Level, Name = namedEntity.Name, Gender = (namedEntity as ICharacterEntity)?.Gender ?? GenderType.Male, Class = namedEntity.Class, Morph = namedEntity.Morph, HeroLevel = namedEntity.HeroLevel }); }
public object Resolve(string identifier) { foreach (E element in this) { if (element is NamedEntity) { INamedEntity namedEntity = (NamedEntity)element; if (namedEntity.Identifier.EqualsIdentifier(identifier)) { return(element); } } } return(null); }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, INamedEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { // TODO: Use the arguments!!!!! Coordinate destination = new Coordinate(); IQuaternion heading = new Quaternion(0.0, 0.0, 0.0, 0.0); Identity playfield = new Identity(); ((Character)Self).Teleport(destination, heading, playfield); return(true); }
public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { ICharacter character = (ICharacter)self; int statelId = (int)((uint)0xC0000000 | arguments[1].AsInt32() | (arguments[2].AsInt32() << 16)); character.Stats[StatIds.externaldoorinstance].BaseValue = 0; character.Stats[StatIds.externalplayfieldinstance].BaseValue = 0; if (arguments[1].AsInt32() > 0) { StatelData sd = PlayfieldLoader.PFData[arguments[1].AsInt32()].GetDoor(statelId); if (sd == null) { throw new Exception( "Statel " + arguments[3].AsInt32().ToString("X") + " not found? Check the rdb dammit"); } Vector3 v = new Vector3(sd.X, sd.Y, sd.Z); Quaternion q = new Quaternion(sd.HeadingX, sd.HeadingY, sd.HeadingZ, sd.HeadingW); Quaternion.Normalize(q); Vector3 n = (Vector3)q.RotateVector3(Vector3.AxisZ); v.x += n.x * 2.5; v.z += n.z * 2.5; character.Playfield.Teleport( (Dynel)character, new Coordinate(v), q, new Identity() { Type = (IdentityType)arguments[0].AsInt32(), Instance = arguments[1].AsInt32() }); } return true; self.Stats[StatIds.externalplayfieldinstance].Value = 0; self.Stats[StatIds.externaldoorinstance].Value = 0; self.Playfield.Teleport( (Dynel)self, new Coordinate(100, 10, 100), ((ICharacter)self).Heading, new Identity() { Type = (IdentityType)arguments[0].AsInt32(), Instance = arguments[1].AsInt32() }); return true; }
private void UsingNamespace(string fullName, INamedEntity errorEntity) { if (_metadataWriter.IsUsingStringTooLong(fullName, errorEntity)) { return; } try { _symWriter.UsingNamespace(fullName); } catch (Exception ex) { throw new PdbWritingException(ex); } }
private string GetEntityName(INamedEntity entity) { if (tbtnSimple.Checked) { return(entity.NameSimple); } if (tbtnShort.Checked) { return(entity.NameShort); } if (tbtnFull.Checked) { return(entity.NameFull); } throw new ArgumentException("Invalid selected show mode"); }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { string text = arguments[0].AsString(); var message = new FormatFeedbackMessage() { Identity = self.Identity, FormattedMessage = "~&!!!\":!!!)<s" + (char)(text.Length + 1), Unknown1 = 0, Unknown2 = 0, }; ((ICharacter)self).Send(message); return true; }
private static void AssertSubstitution(List <SearchResults> list, int index, string name, string nameSimple, string nameFull) { SearchResults results = list[index]; INamedEntity result = results.SingleResult; Assert.IsFalse(result is RenamedBase, "Is NOT RenamedBase (and is just some Entity)"); Assert.IsNotNull(result, "Have result"); Assert.IsTrue(results.IsSingleResult, "Single result"); Assert.AreEqual(SearchResultMessage.Substitution, results.Message, "Result type"); Assert.AreEqual(nameFull, result.NameFull, "NameFull"); Assert.AreEqual(nameSimple, result.NameSimple, "NameSimple"); Assert.AreEqual(name, result.NameShort, "NameShort"); Assert.AreEqual(nameSimple, results.ToString(), "results.ToString"); Assert.AreEqual(name, results.ToString(OutputType.Short), "ToString(Short)"); Assert.AreEqual(nameSimple, results.ToString(OutputType.Simple), "ToString(Simple)"); Assert.AreEqual(nameFull, results.ToString(OutputType.Full), "ToString(Full)"); }
// This ignores parameter types, which we'll need at some point internal static bool MethodMatchesFullyQualifiedName(string fullyQualifiedName, IMethodDefinition definition) { string[] nameComponents = fullyQualifiedName.Split('.'); INamedEntity nameIterator = definition; for (int componentIndex = nameComponents.Length - 1; componentIndex >= 0; componentIndex--) { string nameComponent = nameComponents[componentIndex]; if (nameIterator.Name.Value.Equals(nameComponent)) { if (nameIterator is ITypeDefinitionMember) { ITypeDefinition containingTypeDefinition = ((ITypeDefinitionMember)nameIterator).ContainingTypeDefinition; if (containingTypeDefinition is INamedTypeDefinition) { nameIterator = ((INamedTypeDefinition)containingTypeDefinition); } else { return(false); } } else if (nameIterator is INamespaceMember) { INamespaceDefinition containingNamespace = ((INamespaceMember)nameIterator).ContainingNamespace; nameIterator = containingNamespace; } else { return(false); } } else { return(false); } } return(true); }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, INamedEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { int Statnumber; int minhit; int maxhit; Statnumber = (int)Arguments[0]; minhit = (int)Arguments[1]; maxhit = (int)Arguments[2]; if (minhit > maxhit) { minhit = maxhit; maxhit = (int)Arguments[1]; } Random rnd = new Random(); int random = rnd.Next(minhit, maxhit); Character ch = (Character)Self; // Increase only to maximum value. if max value is lower then actual value, half of the random will be subtracted if (Statnumber == 27) { random = Math.Min(random, ch.Stats[StatIds.life].Value - ch.Stats[StatIds.health].Value); } if (Statnumber == 132) { random = Math.Min( random, ch.Stats[StatIds.maxnanoenergy].Value - ch.Stats[StatIds.nanoenergypool].Value); } if (random < 0) { random /= 2; } ((Character)Self).Stats[Statnumber].Value += random; return(true); }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, INamedEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { int statNumber = Arguments[0].AsInt32(); int statValue = Arguments[1].AsInt32(); IStats tempTarget = Target; if (tempTarget != null) { tempTarget.Stats[statNumber].Set((uint)statValue); return(true); } return(false); }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { string text = arguments[0].AsString(); var message = new FormatFeedbackMessage() { Identity = self.Identity, FormattedMessage = "~&!!!\":!!!)<s" + (char)(text.Length + 1), Unknown1 = 0, Unknown2 = 0, }; ((ICharacter)self).Send(message); return(true); }
private static void AssertResult(List <SearchResults> list, int index, string module, string name, string nameSimple, string nameFull) { SearchResults results = list[index]; INamedEntity result = results.SingleResult; Assert.IsTrue(result is RenamedBase, "Is RenamedBase"); Assert.IsNotNull(result, "Have result"); Assert.IsTrue(results.IsSingleResult, "Single result"); Assert.AreEqual(SearchResultMessage.Normal, results.Message, "Result type"); Assert.AreEqual(module, result.Module, "Module"); Assert.AreEqual(nameFull, result.NameFull, "NameFull"); Assert.AreEqual(nameSimple, result.NameSimple, "NameSimple"); Assert.AreEqual(name, result.NameShort, "NameShort"); Assert.AreEqual(nameSimple, results.ToString(), "results.ToString"); Assert.AreEqual(name, results.ToString(OutputType.Short), "ToString(Short)"); Assert.AreEqual(nameSimple, results.ToString(OutputType.Simple), "ToString(Simple)"); Assert.AreEqual(nameFull, results.ToString(OutputType.Full), "ToString(Full)"); }
public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { ICharacter character = (ICharacter)self; int statelId = (int)((uint)0xC0000000 | arguments[1].AsInt32() | (arguments[2].AsInt32() << 16)); character.Stats[StatIds.externaldoorinstance].BaseValue = (uint)caller.Identity.Instance; character.Stats[StatIds.externalplayfieldinstance].BaseValue = (uint)character.Playfield.Identity.Instance; if (arguments[1].AsInt32() > 0) { StatelData sd = PlayfieldLoader.PFData[arguments[1].AsInt32()].GetDoor(statelId); if (sd == null) { throw new Exception( "Statel " + arguments[3].AsInt32().ToString("X") + " not found? Check the rdb dammit"); } Vector3 v = new Vector3(sd.X, sd.Y, sd.Z); Quaternion q = new Quaternion(sd.HeadingX, sd.HeadingY, sd.HeadingZ, sd.HeadingW); Quaternion.Normalize(q); Vector3 n = (Vector3)q.RotateVector3(Vector3.AxisZ); v.x += n.x * 2.5; v.z += n.z * 2.5; character.Playfield.Teleport( (Dynel)character, new Coordinate(v), q, new Identity() { Type = (IdentityType)arguments[0].AsInt32(), Instance = arguments[1].AsInt32() }); } return(true); }
private void AddResult(INamedEntity item) { if (results != null) { results.Add(item); return; } if (resultItem != null) { results = new List<INamedEntity>(); results.Add(resultItem); results.Add(item); resultItem = null; message = SearchResultMessage.Ambiguous; return; } resultItem = item; message = SearchResultMessage.Normal; }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { if (arguments.Count() != 3) { return false; } uint arg1 = arguments[1].AsUInt32(); int toPlayfield = arguments[2].AsInt32(); byte destinationIndex = (byte)(arg1 >> 16); PlayfieldData pfd = PlayfieldLoader.PFData[toPlayfield]; PlayfieldDestination pfDestination = pfd.Destinations[destinationIndex]; float newX = (pfDestination.EndX - pfDestination.StartX) * 0.5f + pfDestination.StartX; float newZ = (pfDestination.EndZ - pfDestination.StartZ) * 0.5f + pfDestination.StartZ; float dist = WallCollision.Distance( pfDestination.StartX, pfDestination.StartZ, pfDestination.EndX, pfDestination.EndZ); float headDistX = (pfDestination.EndX - pfDestination.StartX) / dist; float headDistZ = (pfDestination.EndZ - pfDestination.StartZ) / dist; newX -= headDistZ * 4; newZ += headDistX * 4; Coordinate destCoordinate = new Coordinate(newX, pfDestination.EndY, newZ); ((ICharacter)self).Teleport( destCoordinate, ((ICharacter)self).Heading, new Identity() { Type = IdentityType.Playfield, Instance = toPlayfield }); return true; }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, INamedEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { string text = arguments[0].AsString(); byte b = 0; var message = new FormatFeedbackMessage() { Identity = self.Identity, Message = text + (char)b, Unknown1 = 0, DataLength = (short)(text.Length + 0xf), Unknown2 = 0x7e26, Unknown3 = 0x21212122, Unknown4 = 0x3a212121, Unknown5 = 0x293C, Unknown6 = 0x73, Unknown7 = 0 }; ((ICharacter)self).Send(message); return true; }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, IEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { if (Arguments.Length == 2) { ((Character)Self).Stats[StatIds.headmesh].Value = Arguments[1].AsInt32(); ((Character)Self).MeshLayer.AddMesh(0, Arguments[1].AsInt32(), Arguments[0].AsInt32(), 4); } else { int placement = (Int32)Arguments[Arguments.Length - 1]; if (placement >= 49) { // Social page ((Character)Self).SocialMeshLayer.AddMesh(0, Arguments[1].AsInt32(), Arguments[0].AsInt32(), 4); } else { ((Character)Self).Stats[StatIds.headmesh].Value = Arguments[0].AsInt32(); ((Character)Self).MeshLayer.AddMesh(0, Arguments[1].AsInt32(), Arguments[0].AsInt32(), 4); } } ((Character)Self).ChangedAppearance = true; return true; }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, IEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { int Statnumber; int minhit; int maxhit; Statnumber = (int)Arguments[0]; minhit = (int)Arguments[1]; maxhit = (int)Arguments[2]; if (minhit > maxhit) { minhit = maxhit; maxhit = (int)Arguments[1]; } Random rnd = new Random(); int random = rnd.Next(minhit, maxhit); Character ch = (Character)Self; // Increase only to maximum value. if max value is lower then actual value, half of the random will be subtracted if (Statnumber == 27) { random = Math.Min(random, ch.Stats[StatIds.life].Value - ch.Stats[StatIds.health].Value); } if (Statnumber == 132) { random = Math.Min( random, ch.Stats[StatIds.maxnanoenergy].Value - ch.Stats[StatIds.nanoenergypool].Value); } if (random < 0) { random /= 2; } ((Character)Self).Stats[Statnumber].Value += random; return true; }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, INamedEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { // TODO: Wait for mesh name list Character ch = (Character)Self; switch (Arguments[0].AsString()) { case "robe": ch.Stats[StatIds.mesh].Value = 1; break; default: ch.Stats[StatIds.mesh].Value = 0; break; } ch.ChangedAppearance = true; return true; }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, IEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { int statNumber = Arguments[0].AsInt32(); int statValue = Arguments[1].AsInt32(); IStats tempTarget = Target; if (tempTarget != null) { tempTarget.Stats[statNumber].Set((uint)statValue); return true; } return false; }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, IEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { if (Self is Character) { Character t = (Character)Self; bool found = false; int placement; if (Arguments.Length == 2) { placement = 0; } else { placement = (Int32)Arguments[Arguments.Length - 1]; } if (placement >= 49) { if (t.SocialTab.ContainsKey((Int32)Arguments[1])) { t.SocialTab[(Int32)Arguments[1]] = (Int32)Arguments[0]; } else { t.SocialTab.Add((Int32)Arguments[1], (Int32)Arguments[0]); } } else { foreach (AOTextures aot in t.Textures) { if (aot.place == (Int32)Arguments[1]) { found = true; aot.Texture = (Int32)Arguments[0]; } } if (!found) { t.Textures.Add(new AOTextures((Int32)Arguments[1], (Int32)Arguments[0])); } } } ((Character)Self).ChangedAppearance = true; return true; }
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, IEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { // TODO: Use the arguments!!!!! Coordinate destination = new Coordinate(Arguments[0].AsInt32(), Arguments[1].AsInt32(), Arguments[2].AsInt32()); IQuaternion heading = new Quaternion(0.0, 0.0, 0.0, 0.0); Identity playfield = new Identity() { Type = IdentityType.Playfield, Instance = Arguments[3].AsInt32() }; if (playfield.Instance==0) { playfield = Self.Playfield.Identity; } ((Character)Self).Teleport(destination, heading, playfield); return true; }
/// <summary> /// Calls a function by its number /// </summary> /// <param name="functionNumber"> /// The number of the function /// </param> /// <param name="self"> /// The self. /// </param> /// <param name="caller"> /// The caller. /// </param> /// <param name="target"> /// The target. /// </param> /// <param name="arguments"> /// The arguments. /// </param> /// <returns> /// </returns> public bool CallFunction( int functionNumber, INamedEntity self, INamedEntity caller, IInstancedEntity target, object[] arguments) { FunctionPrototype func = this.GetFunctionByNumber(functionNumber); return func.Execute(self, caller, target, arguments); }
/// <summary> /// Locks function targets and executes the function /// </summary> /// <param name="self"> /// Dynel (Character or NPC) /// </param> /// <param name="caller"> /// Caller of the function /// </param> /// <param name="target"> /// Target of the Function (Dynel or Statel) /// </param> /// <param name="arguments"> /// Function Arguments /// </param> /// <returns> /// </returns> public abstract bool Execute( INamedEntity self, INamedEntity caller, IInstancedEntity target, MessagePackObject[] arguments);
/// <summary> /// </summary> /// <param name="Self"> /// </param> /// <param name="Caller"> /// </param> /// <param name="Target"> /// </param> /// <param name="Arguments"> /// </param> /// <returns> /// </returns> public bool FunctionExecute( INamedEntity Self, IEntity Caller, IInstancedEntity Target, MessagePackObject[] Arguments) { ((Character)Self).Stats[Arguments[0].AsInt32()].Modifier += Arguments[1].AsInt32(); return true; }
/// <summary> /// Creates a chat message packet for a non-player object. /// </summary> /// <param name="type">the type of chat message</param> /// <param name="language">the language the message is in</param> /// <param name="obj">the object "saying" the message</param> /// <param name="msg">the message itself</param> /// <param name="tag">any chat tags for the object</param> /// <returns>the generated chat packet</returns> private static RealmPacketOut CreateObjectChatMessage(ChatMsgType type, ChatLanguage language, INamedEntity obj, string msg, ChatTag tag) { var packet = CreateObjectChatMessage(type, language, obj); //packet.Write(obj.EntityId); packet.WriteUIntPascalString(msg); // 30 + nameLength + msg.Length packet.Write((byte)tag); // 31 + ... return packet; }
protected static CoreDataSet GetDataByCategory(IList<CoreDataSet> dataList, INamedEntity namedEntity) { return dataList.FirstOrDefault(x => x.CategoryId == namedEntity.Id); }
private static RealmPacketOut CreateObjectChatMessage(ChatMsgType type, ChatLanguage language, INamedEntity obj) { var name = obj.Name; var packet = new RealmPacketOut(RealmServerOpCode.SMSG_MESSAGECHAT, 31 + name.Length + 50); packet.Write((byte)type); // 1 packet.Write((uint)language); // 5 packet.Write(obj.EntityId); // 13 packet.Write(0); // 17 packet.WriteUIntPascalString(name); // 21 + nameLength packet.Write((long)0); // 29 + nameLength //packet.Write(obj.EntityId); return packet; }
private void UsingNamespace(string fullName, INamedEntity errorEntity) { if (_metadataWriter.IsUsingStringTooLong(fullName, errorEntity)) { return; } try { _symWriter.UsingNamespace(fullName); if (_callLogger.LogOperation(OP.UsingNamespace)) { _callLogger.LogArgument(fullName); } } catch (Exception ex) { throw new PdbWritingException(ex); } }
public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { uint externalDoorInstance = self.Stats[StatIds.externaldoorinstance].BaseValue; int externalPlayfieldId = self.Stats[StatIds.externalplayfieldinstance].Value; StatelData door = PlayfieldLoader.PFData[externalPlayfieldId].Statels.FirstOrDefault( x => (uint)x.Identity.Instance == externalDoorInstance && (x.Identity.Type == IdentityType.Door /*|| x.Identity.Type==IdentityType.MissionEntrance*/)); if (door != null) { Vector3 v = new Vector3(door.X, door.Y, door.Z); Quaternion q = new Quaternion(door.HeadingX, door.HeadingY, door.HeadingZ, door.HeadingW); Quaternion.Normalize(q); Vector3 n = (Vector3)q.RotateVector3(Vector3.AxisZ); v.x += n.x * 2.5; v.z += n.z * 2.5; self.Playfield.Teleport( (Dynel)self, new Coordinate(v), q, new Identity() { Type = IdentityType.Playfield, Instance = externalPlayfieldId }); } return door != null; }
public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { Vendor temp = caller as Vendor; if (temp != null) { if (temp.BaseInventory.Pages[temp.BaseInventory.StandardPage].List().Count == 0) { if (temp.OriginalIdentity.Equals(Identity.None)) { } else { int id = temp.Playfield.Identity.Instance << 16 | ((temp.OriginalIdentity.Instance >> 16) & 0xff); ((ICharacter)self).Playfield.Publish( ChatTextMessageHandler.Default.CreateIM( ((ICharacter)self), "This shop has no entry in the database yet. Please enter a new entry with the id " + id.ToString() + ".")); } } else { ShopUpdateMessageHandler.Default.Send((ICharacter)self, caller, ((Vendor)caller).BaseInventory.Pages[((Vendor)caller).BaseInventory.StandardPage]); } } return true; }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { BankMessageHandler.Default.Send((ICharacter)self); return true; }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, INamedEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { IZoneClient client = ((ICharacter)self).Client; BankMessage bankmessage = OpenBank.Create(client); client.Character.Send(bankmessage); return true; }