public void ProcessMessage(ParsedMessage message, Client client)
{
Channel channel = message.GetChannel(message.Parameters[1]);
User user = message.GetUserFromNick(message.Parameters[5]);
user.HostName = message.Parameters[3];
user.UserName = message.Parameters[2];
user.RealName = string.Join(" ", message.Parameters.Skip(8)).Trim();
user.IsOperator = message.Parameters[6].Contains('*');
foreach (char c in message.Parameters[6])
{
switch (c)
{
case 'G':
user.IsAway = true;
break;
case 'H':
user.IsAway = false;
break;
default:
if (User.RankChars.ContainsKey(c))
{
channel.SetRank(user, user.Ranks[channel.Name] | User.RankChars[c]);
}
break;
}
}
client.TriggerOnWho(user, string.Join(" ", message.Parameters.Skip(3)));
channel.TriggerOnWho(user, string.Join(" ", message.Parameters.Skip(3)));
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User user = message.GetUser();
string notice = message.Parameters[1];
client.TriggerOnNotice(user, notice);
}
public static bool CheckMessage(ParsedMessage message, Client client)
{
return message.Command == "PRIVMSG" &&
!message.IsChannel() &&
message.IsCTCP() &&
message.GetCTCPCommand() == "VERSION";
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User user = message.GetUser();
Channel channel = message.GetChannel();
string action = message.GetCTCPParameter();
channel.TriggerOnAction(user, action);
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User user = message.GetUser();
Channel channel = message.GetChannel();
string line = message.Parameters[1];
channel.TriggerOnMessage(user, line);
}
public static bool CheckMessage(ParsedMessage message, Client client)
{
return message.Command == "PRIVMSG" &&
!message.IsChannel() &&
message.IsCTCP() &&
message.GetCTCPCommand() == "ACTION" &&
message.HasCTCPParameter();
}
public void ProcessMessage(ParsedMessage message, Client client)
{
string user = message.GetUser().NickName;
string nick = message.Parameters[0];
User newUser = client.UserFactory.ChangeNick(user, nick);
newUser.TriggerOnNickNameChange(user);
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User user = message.GetUser();
string reason = message.Parameters[0];
client.UserFactory.RemoveNick(user.NickName);
user.TriggerOnQuit(reason);
user._channels.Clear();
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User kicker = message.GetUser();
Channel channel = message.GetChannel();
User user = message.GetUserFromNick(message.Parameters[1]);
string reason = message.Parameters[2];
channel.TriggerOnKick(kicker, user, reason);
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
// string info = message.Parameters[1];
client.User.IsAway = true;
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
User user = message.GetUser();
client.TriggerOnVersion(user);
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
Channel channel = message.GetChannel(message.Parameters[1]);
channel.Topic.ClearTopic();
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
string welcome = message.Parameters[1];
client.TriggerOnConnect();
client.TriggerOnWelcome(welcome);
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
string modes = message.Parameters[1];
this.ParseModes(client.User, modes);
client.TriggerOnUserMode(modes);
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
User user = message.GetUser();
string action = message.GetCTCPParameter();
client.TriggerOnAction(user, action);
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
char chanType = Convert.ToChar(message.Parameters[1]);
Channel channel = message.GetChannel(message.Parameters[2]);
switch (chanType)
{
case '=':
channel.IsPrivate = false;
channel.IsSecret = false;
break;
case '*':
channel.IsPrivate = true;
channel.IsSecret = false;
break;
case '@':
channel.IsSecret = true;
break;
}
string[] users = message.Parameters[3].Split(' ');
foreach (string userStr in users)
{
if (string.IsNullOrEmpty(userStr))
{
break;
}
UserRank rank = UserRank.None;
string nick = userStr;
char[] ranks = userStr.TakeWhile(c => User.RankChars.ContainsKey(c)).ToArray(); // Take all the user statuses
nick = new string(userStr.SkipWhile(c => User.RankChars.ContainsKey(c)).ToArray()); // Take the remaining nick
User user = client.UserFactory.FromNick(nick);
foreach (char rankChar in ranks)
{
rank = rank | User.RankChars[rankChar];
}
channel.SetRank(user, rank);
channel.AddUser(user);
}
channel.TriggerOnNames(users);
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
User user = message.GetUser();
string line = message.Parameters[1];
client.TriggerOnMessage(user, line);
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User user = message.GetUser();
Channel channel = message.GetChannel();
string topic = message.Parameters[1];
channel.Topic.Message = topic;
channel.Topic.Author = user;
channel.Topic.LastUpdated = DateTime.Now;
channel.TriggerOnTopicChange(channel.Topic);
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User user = message.GetUser();
Channel channel = message.GetChannel();
channel.JoinUser(user);
if (user == client.User)
{
client.TriggerOnChannelJoin(channel);
}
client.Send(channel.SendWho());
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
Channel channel = message.GetChannel(message.Parameters[1]);
string topic = null;
if (message.Parameters.Length >= 3)
topic= message.Parameters[2];
channel.Topic.Message = topic;
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User user = message.GetUser();
if (message.Parameters.Length == 0)
{
user.IsAway = false;
user.AwayMessage = null;
}
else
{
user.IsAway = true;
user.AwayMessage = message.Parameters[0];
}
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_GET_USER_LIST))
{
return;
}
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (OpcodeFinder.Instance.PacketCount < 18 && message.Payload.Count > 1000)
{
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_SKILL_LIST))
{
return;
}
if (message.Payload.Count != 4)
{
return;
}
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (message.Payload.Count < 2 + 2 + 4 + 8 + 4 + 4)
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_JOIN_PRIVATE_CHANNEL))
{
return;
}
var authorOffset = Reader.ReadUInt16();
var messageOffset = Reader.ReadUInt16();
var channel = Reader.ReadUInt32();
if (!S_JOIN_PRIVATE_CHANNEL.JoinedChannelId.Contains(channel))
{
return;
}
var authorId = Reader.ReadUInt64();
if (Reader.BaseStream.Position != authorOffset - 4)
{
return;
}
try { var author = Reader.ReadTeraString(); }
catch (Exception e) { return; }
if (Reader.BaseStream.Position != messageOffset - 4)
{
return;
}
try
{
var msg = Reader.ReadTeraString();
if (!msg.Contains("<FONT"))
{
return;
}
}
catch (Exception e) { return; }
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
private static Post ProcessMessage(string subject, string messageBody, string expectedCategory, IEnumerable <MailAttachment> attachments, DateTime?expectedPositionDateTime, Position expectedPosition)
{
var post = new Post();
var postRepositoryMock = MockRepository.GenerateMock <IPostRepository>();
postRepositoryMock.Expect(b => b.Create()).Return(post);
postRepositoryMock.Expect(b => b.SubmitChanges());
var postCategory = new PostCategory();
var postCategoryRepositoryMock = MockRepository.GenerateMock <IPostCategoryRepository>();
postCategoryRepositoryMock.Expect(b => b.GetByTitle(expectedCategory)).Return(postCategory);
var pictureRepositoryMock = MockRepository.GenerateMock <IPictureRepository>();
if (attachments != null)
{
foreach (var attachment in attachments)
{
pictureRepositoryMock.Expect(m => m.AddPictureToAlbum("mailClientPicturesAlbumID", null, attachment.Name, "", "", expectedPositionDateTime, expectedPosition))
.Constraints(new[] { RM.Is.Equal("mailClientPicturesAlbumID"), new StreamConstraint(attachment.Data), RM.Is.Equal(attachment.Name), RM.Is.Equal(""), RM.Is.Equal(""), RM.Is.Equal(expectedPositionDateTime), RM.Is.Equal(expectedPosition) })
.Return(
new Picture
{
PictureUri = new Uri("http://" + attachment.Name),
ThumbnailUri = new Uri("http://thumbnail." + attachment.Name),
Title = attachment.Name
});
}
}
var parsedMessage = new ParsedMessage("*****@*****.**", "*****@*****.**", subject, messageBody, attachments);
var postMessageProcessor = new PostMessageProcessor(postRepositoryMock, postCategoryRepositoryMock, pictureRepositoryMock);
postMessageProcessor.ProcessMessage(parsedMessage);
postRepositoryMock.VerifyAllExpectations();
postCategoryRepositoryMock.VerifyAllExpectations();
pictureRepositoryMock.VerifyAllExpectations();
return(post);
}
private DroneContext UpdateDrone(ParsedMessage pm)
{
//log.Debug("processing update for drone");
var drone = drones.Where(x => x.Info.EntityId == pm.EntityId).FirstOrDefault();
if (drone == null)
{
drone = new DroneContext(new DroneInfo(pm.EntityId, pm.Name, pm.Location, pm.Velocity), null);
drones.Add(drone);
}
else
{
drone.Info.Update(pm.Name, pm.Location, pm.Velocity, pm.Docked, pm.CameraCount, pm.ShipSize, pm.DrillCount, pm.WeaponCount, pm.SensorCount, pm.ConnectorCount, pm.PercentCargo, pm.HP, pm.MaxStorage, pm.MergeCount, pm.GuneCount, pm.RocketCount, pm.ReactorCount, pm.BatteryCount, pm.CurrentPower, pm.MaxPower);
}
IdentifyDroneType(drone);
return(drone);
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_CLEAR_QUEST_INFO))
{
return;
}
if (message.Payload.Count != 97 && message.Payload.Count != 61)
{
return;
}
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.C_START_SKILL))
{
return;
}
if (message.Payload.Count < 2 + 2 + 8 + 4 + 4 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 1 + 4 + 4 + 4 + 4 + 4)
{
return;
}
Reader.Skip(2 + 2);
var source = Reader.ReadUInt64();
var pos = Reader.ReadVector3f();
Reader.Skip(2);
var model = Reader.ReadUInt32();
var skill = Reader.ReadUInt32();
var stage = Reader.ReadUInt32();
Reader.Skip(4);
var id = Reader.ReadUInt32(); // == sActionEnd.id
if (source != DbUtils.GetPlayercId())
{
return;
}
if (model != DbUtils.GetPlayerModel())
{
return;
}
if (!Equals(pos, DbUtils.GetPlayerLocation()))
{
return;
}
if (skill - 0x04000000 != C_START_SKILL.LatestSkill)
{
return;
}
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
LastId = id;
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (message.Payload.Count != 8 + 4 + 4 + 4 + 4)
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.C_START_SKILL))
{
return;
}
var target = Reader.ReadUInt64();
var prevVal = Reader.ReadUInt32();
var newVal = Reader.ReadUInt32();
var type = Reader.ReadUInt32();
var skill = Reader.ReadUInt32();
if (type != 0 && type != 1 && type != 2 && type != 3)
{
return;
}
if (prevVal > 7)
{
return;
}
if (newVal > 7)
{
return;
}
if (C_START_SKILL.LatestSkill != skill)
{
return;
}
if (DbUtils.GetPlayercId() != target && !DbUtils.IsNpcSpawned(target))
{
return;
}
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (message.Payload.Count != 0)
{
return;
}
if (C_NPCGUILD_LIST.PossibleOpcode != 0 && C_DUNGEON_CLEAR_COUNT_LIST.PossibleOpcode != 0)
{
return;
}
PossibleOpcode = message.OpCode;
}
/// <summary>
/// Creates a parsed message.
/// </summary>
/// <param name="action">The soap action.</param>
/// <returns>The resulting parsed message.</returns>
internal static ParsedMessage CreateParsedMessage(string action)
{
ParsedMessage parsedMessage = TestHelper.CreateParsedMessage(action, @"
<soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xsd='http://www.w3.org/2001/XMLSchema'>
<soap:Header>
<Action soap:mustUnderstand='1' xmlns='http://schemas.microsoft.com/ws/2005/05/addressing/none'>http://tempuri.org/HelloWorldXmlSerializerRequest</Action>
</soap:Header>
<soap:Body xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xsd='http://www.w3.org/2001/XMLSchema'>
<SimpleXmlSerializerRequest xmlns='http://tempuri.org/'>
<r S='wcfxml' I='1001'/>
</SimpleXmlSerializerRequest>
</soap:Body>
</soap:Envelope>
");
return(parsedMessage);
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_EVENT_QUEST_SUMMARY))
{
return;
}
if (message.Payload.Count != 5)
{
return;
}
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.C_SELECT_USER))
{
return;
}
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (message.Payload.Count == 11)
{
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
Channel channel = message.GetChannel(message.Parameters[1]);
string topic = null;
if (message.Parameters.Length >= 3)
{
topic = message.Parameters[2];
}
channel.Topic.Message = topic;
}
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (message.Payload.Count < 2 + 2 + 4 + 1 + 1 + 4 + 4 + 4)
{
return;
}
var nameOffset = Reader.ReadUInt16();
var msgOffset = Reader.ReadUInt16();
var id = Reader.ReadUInt32();
var unk = Reader.ReadByte();
var raid = Reader.ReadByte();
var unk2 = Reader.ReadUInt32();
if (raid != 0 && raid != 1)
{
return;
}
if (unk2 != 65)
{
return;
}
try
{
if (Reader.BaseStream.Position != nameOffset - 4)
{
return;
}
var name = Reader.ReadTeraString();
}
catch (Exception e) { return; }
try
{
if (Reader.BaseStream.Position != msgOffset - 4)
{
return;
}
var msg = Reader.ReadTeraString();
}
catch (Exception e) { return; }
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
if (OpcodeFinder.Instance.GetOpcode(OPCODE) == message.OpCode)
{
Parse();
}
return;
}
if (message.Payload.Count != 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 1 + 1 + 1 + 8)
{
return;
}
var skill = Reader.ReadUInt32() - 0x04000000; //would need skill database or specific skillId to use
var w = Reader.ReadUInt16();
var pos = Reader.ReadVector3f();
var endPos = Reader.ReadVector3f();
var unk = Reader.ReadByte(); //always true
var moving = Reader.ReadByte(); //bool
var cont = Reader.ReadByte(); //bool
var target = Reader.ReadUInt64();
if (unk != 1)
{
return;
}
if (moving != 0 && moving != 1)
{
return;
}
if (cont != 0 && cont != 1)
{
return;
}
if (!pos.Equals(DbUtils.GetPlayerLocation()))
{
return;
}
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
LatestSkill = skill;
}
/// <summary>
/// Spawn an object using Flutter postMessage.
/// </summary>
/// <param name="message">Message which is expected to be in json string.</param>
public void FlutterSpawn(string message)
{
Debug.Log(message);
ParsedMessage parsed = JsonUtility.FromJson <ParsedMessage>(message);
Spawn(parsed.position, parsed.batiment.id);
Color color = new Color32((byte)parsed.color.r, (byte)parsed.color.g, (byte)parsed.color.b, 150);
Colorize(color);
AddBatimentComponent(parsed.batiment);
var batimentComponent = SpawnedObject.GetComponent <BatimentDataHolder>();
if (!string.IsNullOrEmpty(batimentComponent.batiment.img_url))
{
AddImageLoaderComponent();
}
ChangeText(batimentComponent.batiment.nom, parsed.distance);
}
private static PositionReport ProcessMessage(string subject, string messageBody)
{
var positionReport = new PositionReport();
var positionReportRepositoryMock = MockRepository.GenerateMock <IPositionReportRepository>();
positionReportRepositoryMock.Expect(b => b.Create()).Return(positionReport);
positionReportRepositoryMock.Expect(b => b.SubmitChanges());
var parsedMessage = new ParsedMessage("*****@*****.**", "*****@*****.**", subject, messageBody, null);
var positionReportMessageProcessor = new PositionReportMessageProcessor(positionReportRepositoryMock);
positionReportMessageProcessor.ProcessMessage(parsedMessage);
positionReportRepositoryMock.VerifyAllExpectations();
return(positionReport);
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
Channel channel = message.GetChannel(message.Parameters[1]);
User user = message.GetUser(message.Parameters[2]);
int timestamp = int.Parse(message.Parameters[3]);
DateTime time = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
time = time.AddSeconds(timestamp);
channel.Topic.Author = user;
channel.Topic.LastUpdated = time.ToLocalTime();
channel.TriggerOnTopic(channel.Topic);
}
}
public void Update(ParsedMessage message)
{
message.On <S_PLAYER_STAT_UPDATE>(x => Update(x));
message.On <S_PARTY_MEMBER_STAT_UPDATE>(x => Update(x));
message.On <SPartyMemberChangeHp>(x => Update(x));
message.On <SCreatureChangeHp>(x => Update(x));
message.On <SPlayerChangeMp>(x => Update(x));
message.On <SDespawnUser>(x => Update(x));
message.On <SAbnormalityEnd>(x => Update(x));
message.On <SAbnormalityRefresh>(x => Update(x));
message.On <SAbnormalityBegin>(x => Update(x));
message.On <SpawnMeServerMessage>(x => Update(x));
message.On <SDespawnNpc>(x => Update(x));
message.On <SCreatureLife>(x => Update(x));
message.On <SNpcStatus>(x => Update(x));
message.On <SpawnUserServerMessage>(x => Update(x));
message.On <SNpcOccupierInfo>(x => Update(x));
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_LOGIN_ARBITER))
{
return;
}
if (OpcodeFinder.Instance.PacketCount > 6 && OpcodeFinder.Instance.PacketCount < 13 && message.Payload.Count > 18)
{
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
}
public void Find(ParsedMessage message)
{
PacketCount++;
AllPackets.Add(PacketCount, message);
NetworkController.Instance.UiUpdateData.Add(message);
if (_viewOnly)
{
return;
}
if (message.Direction == MessageDirection.ClientToServer)
{
Parallel.ForEach(ClientOpcode, x => x.Key.Invoke(x.Value, new object[] { message }));
}
else
{
Parallel.ForEach(ServerOpcode, x => x.Key.Invoke(x.Value, new object[] { message }));
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[0]);
if (target == client.User)
{
Channel channel = message.GetChannel(message.Parameters[1]);
User user = message.GetUser(message.Parameters[2]);
int timestamp = int.Parse(message.Parameters[3]);
DateTime time = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
time = time.AddSeconds(timestamp);
channel.Topic.Author = user;
channel.Topic.LastUpdated = time.ToLocalTime();
channel.TriggerOnTopic(channel.Topic);
}
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.C_START_SKILL))
{
return;
}
if (message.Payload.Count != 8 + 4 + 4 + 4 + 2 + 4 + 4 + 4 + 4)
{
return;
}
var source = Reader.ReadUInt64();
var pos = Reader.ReadVector3f();
Reader.Skip(2);
var model = Reader.ReadUInt32();
var skill = Reader.ReadUInt32();
Reader.Skip(4); //type; can be used if needed
var id = Reader.ReadUInt32(); // == sActionStage.id
if (source != DbUtils.GetPlayercId())
{
return;
}
if (model != DbUtils.GetPlayerModel())
{
return;
}
if (skill - 0x04000000 != C_START_SKILL.LatestSkill)
{
return;
}
if (id != S_ACTION_STAGE.LastId)
{
return;
}
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (message.Payload.Count != 0)
{
return;
}
if (!waiting)
{
return;
}
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
S_RETURN_TO_LOBBY.Wait();
waiting = false;
}
private static Picture ProcessPictureMessageTest(string subject, string messageBody, string expectedTitle, string expectedBody, byte[] image)
{
var picture = new Picture();
var pictureRepositoryMock = MockRepository.GenerateMock <IPictureRepository>();
pictureRepositoryMock.Expect(b => b.AddPictureToAlbum(null, null, null, null, null, null, null)).IgnoreArguments().Return(picture);
var mailAttachment = new MailAttachment("image", image);
var parsedMessage = new ParsedMessage("*****@*****.**", "*****@*****.**", subject, messageBody, new[] { mailAttachment });
var pictureMessageProcessor = new PictureMessageProcessor(pictureRepositoryMock);
pictureMessageProcessor.ProcessMessage(parsedMessage);
pictureRepositoryMock.VerifyAllExpectations();
return(picture);
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (message.Payload.Count != 8 + 4 + 4 + 4 + 4)
{
return;
}
var target = Reader.ReadUInt64();
var id = Reader.ReadUInt32();
var duration = Reader.ReadUInt32();
Reader.Skip(4);
var stacks = Reader.ReadUInt32();
//we could check this on minor battle solutions
if (id != 4000)
{
return;
}
if (stacks != 1)
{
return;
}
if (duration != 30 * 60 * 1000)
{
return;
}
if (OpcodeFinder.Instance.KnowledgeDatabase.TryGetValue(OpcodeFinder.KnowledgeDatabaseItem.LoggedCharacter, out var result))
{
var ch = (LoggedCharacter)result;
if (ch.Cid != target)
{
return;
}
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (message.Payload.Count != 4 + 4)
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_PARTY_MEMBER_LIST))
{
return;
}
if (!OpcodeFinder.Instance.KnowledgeDatabase.ContainsKey(OpcodeFinder.KnowledgeDatabaseItem.PartyMemberList))
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_PARTY_MEMBER_ABNORMAL_ADD))
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_PARTY_MEMBER_ABNORMAL_DEL))
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_PARTY_MEMBER_ABNORMAL_REFRESH))
{
return;
}
var serverId = Reader.ReadUInt32();
var playerId = Reader.ReadUInt32();
if (!DbUtils.IsPartyMember(playerId, serverId))
{
return;
}
PossibleOpcode = message.OpCode;
LastServerId = serverId;
LastPlayerId = playerId;
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_PARTY_MEMBER_LIST))
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_PARTY_MEMBER_STAT_UPDATE))
{
return;
}
if (message.Payload.Count != 4 + 4 + 4 + 4 + 4)
{
return;
}
if (!OpcodeFinder.Instance.KnowledgeDatabase.ContainsKey(OpcodeFinder.KnowledgeDatabaseItem.PartyMemberList))
{
return;
}
var serverId = Reader.ReadUInt32();
var playerId = Reader.ReadUInt32();
var curRe = Reader.ReadUInt32();
var maxRe = Reader.ReadUInt32();
var unk = Reader.ReadUInt32();
if (!DbUtils.IsPartyMember(playerId, serverId))
{
return;
}
var m = DbUtils.GetPartyMember(playerId, serverId);
if (m.MaxRe != maxRe)
{
return;
}
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (message.Payload.Count != 4 + 4 + 4 + 4 + 4 + 4)
{
return;
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_PARTY_MEMBER_LIST))
{
return; //check that we already are in party
}
if (!OpcodeFinder.Instance.KnowledgeDatabase.ContainsKey(OpcodeFinder.KnowledgeDatabaseItem.PartyMemberList))
{
return; //
}
if (!OpcodeFinder.Instance.IsKnown(OpcodeEnum.S_PARTY_MEMBER_ABNORMAL_ADD))
{
return; //check that we already received abnormalAdd
}
var serverId = Reader.ReadUInt32();
var playerId = Reader.ReadUInt32();
var abnormId = Reader.ReadUInt32(); //maybe it would be better to use a specific buff (minor battle solution?)
var duration = Reader.ReadUInt32();
var unk = Reader.ReadUInt32();
var stacks = Reader.ReadUInt32();
if (!DbUtils.IsPartyMember(playerId, serverId))
{
return;
}
if (!DbUtils.PartyMemberHasAbnorm(playerId, serverId, abnormId))
{
return;
}
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (message.Payload.Count < 2 + 2 + 4)
{
return;
}
var count = Reader.ReadUInt16();
var offset = Reader.ReadUInt16();
try
{
Reader.BaseStream.Position = offset - 4;
for (int i = 0; i < count; i++)
{
Reader.Skip(4 + 4 + 4 + 4 + 2);
}
}
catch (Exception e) { return; }
if (OpcodeFinder.Instance.GetMessage(OpcodeFinder.Instance.PacketCount - 1).OpCode != OpcodeFinder.Instance.GetOpcode(OpcodeEnum.C_REQUEST_USER_ITEMLEVEL_INFO))
{
return;
}
if (OpcodeFinder.Instance.GetMessage(OpcodeFinder.Instance.PacketCount - 2).OpCode != OpcodeFinder.Instance.GetOpcode(OpcodeEnum.C_DUNGEON_CLEAR_COUNT_LIST))
{
return;
}
if (OpcodeFinder.Instance.GetMessage(OpcodeFinder.Instance.PacketCount - 3).OpCode != OpcodeFinder.Instance.GetOpcode(OpcodeEnum.C_NPCGUILD_LIST))
{
return;
}
if (OpcodeFinder.Instance.GetMessage(OpcodeFinder.Instance.PacketCount - 4).OpCode != OpcodeFinder.Instance.GetOpcode(OpcodeEnum.C_DUNGEON_COOL_TIME_LIST))
{
return;
}
PossibleOpcode = message.OpCode;
}
public new void Process(ParsedMessage message)
{
base.Process(message);
if (IsKnown || OpcodeFinder.Instance.IsKnown(message.OpCode))
{
return;
}
if (message.Payload.Count != 0)
{
return;
}
var previousPacket = OpcodeFinder.Instance.GetMessage(OpcodeFinder.Instance.PacketCount - 1);
if (previousPacket.Direction == Tera.MessageDirection.ServerToClient && previousPacket.Payload.Count == 0)
{
OpcodeFinder.Instance.SetOpcode(previousPacket.OpCode, OpcodeEnum.S_PING);
OpcodeFinder.Instance.SetOpcode(message.OpCode, OPCODE);
}
}
public void ProcessMessage(ParsedMessage message, Client client)
{
Channel channel = message.GetChannel();
User user = message.GetUser();
string reason = null;
if (message.Parameters.Length >= 2)
reason = message.Parameters[1];
channel.LeaveUser(user, reason);
if (user == client.User)
{
client.ChannelFactory.RemoveName(channel.Name);
client.TriggerOnChannelLeave(channel);
channel.ClearUsers();
}
else
{
client.Send(channel.SendWho());
}
}
public static bool CheckMessage(ParsedMessage message, Client client)
{
return message.Command == "NOTICE" &&
!message.IsChannel() &&
!message.IsCTCP();
}
public static bool CheckMessage(ParsedMessage message, Client client)
{
return message.Command == "332";
}
public void ProcessMessage(ParsedMessage message, Client client)
{
Channel target = message.GetChannel(message.Parameters[0]);
target.InviteList.Add(message.Parameters[1]);
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User target = message.GetUserFromNick(message.Parameters[1]);
target.AwayMessage = message.Parameters[2];
}
public void ProcessMessage(ParsedMessage message, Client client)
{
User setter = message.GetUser();
Channel channel = message.GetChannel();
string modes = message.Parameters[1];
string[] parameters = message.Parameters.Skip(2).ToArray();
List<KeyValuePair<string, string>> changes = this.ParseModes(client, channel, modes, parameters);
channel.TriggerOnMode(setter, changes);
}
public static bool CheckMessage(ParsedMessage message, Client client)
{
return message.Command == "MODE" &&
message.IsChannel();
}
public void ProcessMessage(ParsedMessage message, Client client)
{
Channel channel = message.GetChannel(message.Parameters[1]);
channel.TriggerOnChannelOperatorNeeded(channel, message.Parameters[2]);
}
