/// <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>
/// 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);
}
}
/// <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;
}
