private void ParseBuddyAdd(Internal.ByteArray message)
{
uint creatureID = message.ReadUnsignedInt();
string name = message.ReadString();
string desc = string.Empty;
uint icon = 0;
bool notifyLogin = false;
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameAdditionalVipInfo))
{
desc = message.ReadString();
icon = message.ReadUnsignedInt();
notifyLogin = message.ReadBoolean();
}
byte status = message.ReadUnsignedByte();
List <byte> groups;
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameBuddyGroups))
{
int count = message.ReadUnsignedByte();
groups = new List <byte>(count);
for (int i = 0; i < count; i++)
{
groups.Add(message.ReadUnsignedByte());
}
}
}
private void ParseNPCOffer(Internal.ByteArray message)
{
// todo, i believe tibia added extra data to detect currency
string npcName = null;
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameNameOnNpcTrade))
{
npcName = message.ReadString();
}
var buyObjects = new List <Trade.TradeObjectRef>();
var sellObjects = new List <Trade.TradeObjectRef>();
int listCount;
if (OpenTibiaUnity.GameManager.ClientVersion >= 900)
{
listCount = message.ReadUnsignedShort();
}
else
{
listCount = message.ReadUnsignedByte();
}
for (int i = 0; i < listCount; i++)
{
ushort objectID = message.ReadUnsignedShort();
ushort objectData = message.ReadUnsignedByte();
string name = message.ReadString();
uint weight = message.ReadUnsignedInt();
uint buyPrice = message.ReadUnsignedInt();
uint sellPrice = message.ReadUnsignedInt();
if (buyPrice > 0)
{
buyObjects.Add(new Trade.TradeObjectRef(objectID, objectData, name, buyPrice, weight));
}
if (sellPrice > 0)
{
sellObjects.Add(new Trade.TradeObjectRef(objectID, objectData, name, sellPrice, weight));
}
}
OpenTibiaUnity.GameManager.onRequestNPCTrade.Invoke(npcName, buyObjects, sellObjects);
}
private void ParseClientCheck(Internal.ByteArray message)
{
// TODO
uint something = message.ReadUnsignedInt();
message.Skip((int)something);
}
private void ParseBasicData(Internal.ByteArray message)
{
bool premium = message.ReadBoolean();
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GamePremiumExpiration))
{
uint premiumExpiration = message.ReadUnsignedInt();
}
byte vocation = message.ReadUnsignedByte();
if (OpenTibiaUnity.GameManager.ClientVersion >= 1100)
{
bool hasReachedMain = message.ReadBoolean();
}
List <byte> spells = new List <byte>();
ushort spellsCount = message.ReadUnsignedShort();
for (int i = 0; i < spellsCount; i++)
{
spells.Add(message.ReadUnsignedByte());
}
if (Player)
{
//_player.PremiumStatus = premium;
//_player.PremiumExpiration = premiumExpiration;
//_player.Vocation = vocation;
//_player.ReachedMain = hasReachedMain;
}
}
private void ParseCreatureMarks(Internal.ByteArray message)
{
int length;
if (OpenTibiaUnity.GameManager.ClientVersion >= 1035)
{
length = 1;
}
else
{
length = message.ReadUnsignedByte();
}
for (int i = 0; i < length; i++)
{
uint creatureId = message.ReadUnsignedInt();
bool permenant = message.ReadUnsignedByte() != 1;
byte mark = message.ReadUnsignedByte();
var creature = CreatureStorage.GetCreature(creatureId);
if (!!creature)
{
creature.Marks.SetMark(permenant ? MarkType.Permenant : MarkType.OneSecondTemp, mark);
CreatureStorage.InvalidateOpponents();
}
else
{
throw new System.Exception("ProtocolGame.ParseCreatureMarks: Unknown creature id: " + creatureId);
}
}
}
private void ParseOpenRewardWall(Internal.ByteArray message)
{
message.ReadBoolean(); // openedFromShrine
message.ReadUnsignedInt(); // timestamp for the player to be able to take the reward (0 = able)
message.ReadUnsignedByte(); // currentRewardIndex
bool showWarningWhenCollecting = message.ReadUnsignedByte() != 0; // showWarningWhenCollecting
if (showWarningWhenCollecting)
{
message.ReadString(); // warningMessage
}
message.ReadUnsignedInt(); // timestamp for the streak to expire (0 = won't expire until server save)
message.ReadUnsignedShort(); // current streak
message.ReadUnsignedShort(); // unknown
}
private void ParseMarketEnter(Internal.ByteArray message)
{
ulong balance;
if (OpenTibiaUnity.GameManager.ClientVersion >= 981)
{
balance = message.ReadUnsignedLong();
}
else
{
balance = message.ReadUnsignedInt();
}
int vocation = -1;
if (OpenTibiaUnity.GameManager.ClientVersion < 950)
{
vocation = message.ReadUnsignedByte();
}
int offers = message.ReadUnsignedByte();
int depotCount = message.ReadUnsignedByte();
for (int i = 0; i < depotCount; i++)
{
message.ReadUnsignedShort(); // objectId
message.ReadUnsignedShort(); // objectCount
}
}
private void ParseChallange(Internal.ByteArray message)
{
uint timestamp = message.ReadUnsignedInt();
byte challange = message.ReadUnsignedByte();
SendLogin(timestamp, challange);
SetConnectionState(ConnectionState.ConnectingStage2, false);
}
private void ParsePreyPrices(Internal.ByteArray message)
{
message.ReadUnsignedInt(); // rerollPrice in gold
if (OpenTibiaUnity.GameManager.ClientVersion >= 1190)
{
message.ReadUnsignedByte(); // unknown
message.ReadUnsignedByte(); // selectCreatureDirectly in preyWildCards
}
}
private void ParseMarketStatistics(Internal.ByteArray message)
{
int count = message.ReadUnsignedShort();
for (int i = 0; i < count; i++)
{
ushort objectId = message.ReadUnsignedShort();
uint objectPrice = message.ReadUnsignedInt();
}
}
private void ParseMarketDetail(Internal.ByteArray message)
{
ushort objectId = message.ReadUnsignedShort();
var last = MarketDetails.Weight;
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameImbuing))
{
last = MarketDetails.ImbuementSlots;
}
Dictionary <MarketDetails, string> details = new Dictionary <MarketDetails, string>();
for (var i = MarketDetails.First; i <= last; i++)
{
int strLen = message.ReadUnsignedShort();
if (strLen == 0)
{
continue;
}
details.Add(i, message.ReadString(strLen));
}
int time = DateTime.Now.Second / 1000 * Constants.SecondsPerDay;
int ctime = time;
int count = message.ReadUnsignedByte();
for (int i = 0; i < count; i++)
{
uint transactions = message.ReadUnsignedInt();
uint totalPrice = message.ReadUnsignedInt();
uint maximumPrice = message.ReadUnsignedInt();
uint minimumPrice = message.ReadUnsignedInt();
ctime -= Constants.SecondsPerDay;
}
ctime = time;
count = message.ReadUnsignedByte();
for (int i = 0; i < count; i++)
{
uint transactions = message.ReadUnsignedInt();
uint totalPrice = message.ReadUnsignedInt();
uint maximumPrice = message.ReadUnsignedInt();
uint minimumPrice = message.ReadUnsignedInt();
ctime -= Constants.SecondsPerDay;
}
}
private Market.Offer ReadMarketOffer(Internal.ByteArray message, MarketOfferTypes offerType, ushort var)
{
uint timestamp = message.ReadUnsignedInt();
ushort counter = message.ReadUnsignedShort();
ushort objectId;
switch (var)
{
case Constants.MarketRequestOwnOffers:
case Constants.MarketRequestOwnHistory:
objectId = message.ReadUnsignedShort();
break;
default:
objectId = var;
break;
}
ushort amount = message.ReadUnsignedShort();
uint piecePrice = message.ReadUnsignedInt();
MarketOfferStates state = MarketOfferStates.Active;
string character = null;
switch (var)
{
case Constants.MarketRequestOwnOffers:
break;
case Constants.MarketRequestOwnHistory:
state = (MarketOfferStates)message.ReadUnsignedByte();
break;
default:
character = message.ReadString();
break;
}
return(new Market.Offer(new Market.OfferId(counter, timestamp), offerType, objectId, amount, piecePrice, character, state));
}
private void ParseDailyRewardHistory(Internal.ByteArray message)
{
int count = message.ReadUnsignedByte();
for (int i = 0; i < count; i++)
{
var timestamp = message.ReadUnsignedInt(); // timestamp
message.ReadUnsignedByte(); // some state (0: none, 1: active[green])
message.ReadString(); // description
message.ReadUnsignedShort(); // streak
}
}
public int Encrypt(Internal.ByteArray message, int offset = 0, int length = int.MaxValue)
{
length = Math.Min(length, message.Length - offset);
message.Position = offset + length;
int encryptedLength = (int)(Math.Floor((length + BlockSize - 1) / (double)BlockSize) * BlockSize);
if (encryptedLength > length)
{
byte[] tmp = new byte[encryptedLength - length];
_random.NextBytes(tmp);
message.WriteBytes(tmp);
length = encryptedLength;
}
int i = offset;
while (i < offset + length)
{
message.Position = i;
uint v0 = message.ReadUnsignedInt();
uint v1 = message.ReadUnsignedInt();
uint delta = 0x61C88647;
uint sum = 0;
for (int r = 0; r < 32; r++)
{
v0 += (v1 << 4 ^ v1 >> 5) + v1 ^ sum + _key[sum & 3];
sum -= delta;
v1 += (v0 << 4 ^ v0 >> 5) + v0 ^ sum + _key[sum >> 11 & 3];
}
message.Position -= BlockSize;
message.WriteUnsignedInt(v0);
message.WriteUnsignedInt(v1);
i += BlockSize;
}
return(length);
}
public int Decrypt(Internal.ByteArray message, int offset = 0, int length = int.MaxValue)
{
length = Math.Min(length, message.Length - offset);
length -= length % BlockSize;
int i = offset;
while (i < offset + length)
{
message.Position = i;
uint v0 = message.ReadUnsignedInt();
uint v1 = message.ReadUnsignedInt();
uint delta = 0x61C88647;
uint sum = 0xC6EF3720;
for (int r = 0; r < 32; r++)
{
v1 -= (v0 << 4 ^ v0 >> 5) + v0 ^ sum + _key[sum >> 11 & 3];
sum += delta;
v0 -= (v1 << 4 ^ v1 >> 5) + v1 ^ sum + _key[sum & 3];
}
message.Position -= BlockSize;
message.WriteUnsignedInt(v0);
message.WriteUnsignedInt(v1);
i += BlockSize;
}
message.Position = offset;
int payloadLength = message.ReadUnsignedShort();
int messageLength = payloadLength + Internal.Connection.PacketLengthSize;
int lengthDelta = messageLength - length;
if (lengthDelta > 0 || -lengthDelta > length)
{
return(0);
}
message.Length += lengthDelta;
return(length);
}
private void ParseCreatureType(Internal.ByteArray message)
{
uint creatureId = message.ReadUnsignedInt();
byte type = message.ReadUnsignedByte();
uint master = 0;
if (OpenTibiaUnity.GameManager.ClientVersion >= 1120 && type == (int)CreatureType.Summon)
{
master = message.ReadUnsignedInt();
}
var creature = CreatureStorage.GetCreature(creatureId);
if (!!creature)
{
creature.Type = (CreatureType)type;
creature.SetSummonerId(master);
}
else
{
throw new System.Exception("ProtocolGame.ParseCreatureType: Unknown creature id: " + creatureId);
}
}
private void ParsePlayerStates(Internal.ByteArray message)
{
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GamePlayerStateU32))
{
Player.StateFlags = message.ReadUnsignedInt();
}
else if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GamePlayerStateU16))
{
Player.StateFlags = message.ReadUnsignedShort();
}
else
{
Player.StateFlags = message.ReadUnsignedByte();
}
}
private void ParseCreatureUnpass(Internal.ByteArray message)
{
uint creatureId = message.ReadUnsignedInt();
bool unpass = message.ReadBoolean();
var creature = CreatureStorage.GetCreature(creatureId);
if (!!creature)
{
creature.Unpassable = unpass;
}
else
{
throw new System.Exception("ProtocolGame.ParseCreatureUnpass: Unknown creature id: " + creatureId);
}
}
private void ParsePlayerHelpers(Internal.ByteArray message)
{
uint creatureId = message.ReadUnsignedInt();
ushort helpers = message.ReadUnsignedShort();
var creature = CreatureStorage.GetCreature(creatureId);
if (!!creature)
{
creature.NumberOfPvPHelpers = helpers;
}
else
{
throw new System.Exception("ProtocolGame.ParsePlayerHelpers: Unknown creature id: " + creatureId);
}
}
private void ParseCreatureShield(Internal.ByteArray message)
{
uint creatureId = message.ReadUnsignedInt();
byte partyFlag = message.ReadUnsignedByte();
var creature = CreatureStorage.GetCreature(creatureId);
if (!!creature)
{
creature.SetPartyFlag((PartyFlag)partyFlag);
}
else
{
throw new System.Exception("ProtocolGame.ParseCreatureShield: Unknown creature id: " + creatureId);
}
}
private void ParseTrappers(Internal.ByteArray message)
{
int n = message.ReadUnsignedByte();
List <Creatures.Creature> trappers = new List <Creatures.Creature>();
for (int i = 0; i < n; i++)
{
var creatureId = message.ReadUnsignedInt();
var creature = CreatureStorage.GetCreature(creatureId);
if (creature)
{
trappers.Add(creature);
}
}
CreatureStorage.SetTrappers(trappers);
}
private void ParseCreatureHealth(Internal.ByteArray message)
{
uint creatureId = message.ReadUnsignedInt();
byte healthPercent = message.ReadUnsignedByte();
var creature = CreatureStorage.GetCreature(creatureId);
if (!!creature)
{
creature.SetSkill(SkillType.HealthPercent, healthPercent);
CreatureStorage.InvalidateOpponents();
}
else
{
throw new System.Exception("ProtocolGame.ParseCreatureHealth: Unknown creature id: " + creatureId);
}
}
private void ParseCreatureMark(Internal.ByteArray message)
{
uint creatureId = message.ReadUnsignedInt();
byte mark = message.ReadUnsignedByte();
var creature = CreatureStorage.GetCreature(creatureId);
if (!!creature)
{
creature.Marks.SetMark(MarkType.OneSecondTemp, mark);
CreatureStorage.InvalidateOpponents();
}
else
{
throw new System.Exception("ProtocolGame.ParseCreatureMarks: Unknown creature id: " + creatureId);
}
}
private void ParseClearTarget(Internal.ByteArray message)
{
uint creatureId = 0;
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameAttackSeq))
{
creatureId = message.ReadUnsignedInt();
}
Creatures.Creature creature;
if (!!(creature = CreatureStorage.AttackTarget) && (creature.Id == creatureId || creatureId == 0))
{
CreatureStorage.SetAttackTarget(null, false);
}
else if (!!(creature = CreatureStorage.FollowTarget) && (creature.Id == creatureId || creatureId == 0))
{
CreatureStorage.SetFollowTarget(null, false);
}
}
private void ParseCreatureLight(Internal.ByteArray message)
{
uint creatureId = message.ReadUnsignedInt();
byte intensity = message.ReadUnsignedByte();
byte color = message.ReadUnsignedByte();
var creature = CreatureStorage.GetCreature(creatureId);
if (!!creature)
{
creature.Brightness = intensity;
creature.LightColor = Colors.ColorFrom8Bit(color);
}
else
{
throw new System.Exception("ProtocolGame.ParseCreatureLight: Unknown creature id: " + creatureId);
}
}
private void ParseLoginSuccess(Internal.ByteArray message)
{
Player.ID = message.ReadUnsignedInt();
#if !UNITY_EDITOR
string title = string.Format("{0} - {1}", Application.productName, Player.Name);
OpenTibiaUnity.GameManager.SetApplicationTitle(title);
#endif
BeatDuration = message.ReadUnsignedShort();
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameNewSpeedLaw))
{
Creatures.Creature.SpeedA = message.ReadDouble();
Creatures.Creature.SpeedB = message.ReadDouble();
Creatures.Creature.SpeedC = message.ReadDouble();
}
BugReportsAllowed = message.ReadBoolean();
if (OpenTibiaUnity.GameManager.ClientVersion >= 1054)
{
bool canChangePvPFrameRate = message.ReadBoolean();
}
if (OpenTibiaUnity.GameManager.ClientVersion >= 1058)
{
bool exportPvPEnabled = message.ReadBoolean();
}
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameIngameStore))
{
string storeLink = message.ReadString();
ushort storePackageSize = message.ReadUnsignedShort();
}
if (OpenTibiaUnity.GameManager.ClientVersion >= 1149 && OpenTibiaUnity.GameManager.BuildVersion >= 6018)
{
bool exivaRestrictions = message.ReadBoolean();
}
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameTournament))
{
bool tournamentActivated = message.ReadBoolean();
}
}
private void ParseCreatureOutfit(Internal.ByteArray message)
{
uint creatureId = message.ReadUnsignedInt();
var outfit = ReadCreatureOutfit(message);
var creature = CreatureStorage.GetCreature(creatureId);
if (!!creature)
{
creature.Outfit = outfit;
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GamePlayerMounts))
{
creature.MountOutfit = ReadMountOutfit(message, creature.MountOutfit);
}
}
else
{
throw new System.Exception("ProtocolGame.ParseCreatureOutfit: Unknown creature id: " + creatureId);
}
}
private void ParseCreatureSpeed(Internal.ByteArray message)
{
uint creatureId = message.ReadUnsignedInt();
int baseSpeed = -1;
if (OpenTibiaUnity.GameManager.ClientVersion >= 1059)
{
baseSpeed = message.ReadUnsignedShort();
}
int speed = message.ReadUnsignedShort();
var creature = CreatureStorage.GetCreature(creatureId);
if (!!creature)
{
creature.SetSkill(SkillType.Speed, speed, baseSpeed);
}
else
{
throw new System.Exception("ProtocolGame.ParseCreatureSpeed: Unknown creature id: " + creatureId);
}
}
private Creatures.Creature ReadCreatureInstance(Internal.ByteArray message, int type = -1,
UnityEngine.Vector3Int?absolutePosition = null)
{
if (type == -1)
{
type = message.ReadUnsignedShort();
}
if (type != AppearanceInstance.Creature && type != AppearanceInstance.OutdatedCreature && type != AppearanceInstance.UnknownCreature)
{
throw new System.Exception("ProtocolGame.ReadCreatureInstance: Invalid creature type");
}
var gameManager = OpenTibiaUnity.GameManager;
Creatures.Creature creature;
switch (type)
{
case AppearanceInstance.UnknownCreature:
case AppearanceInstance.OutdatedCreature: {
if (type == AppearanceInstance.UnknownCreature)
{
uint removeID = message.ReadUnsignedInt();
uint newID = message.ReadUnsignedInt();
CreatureType creatureType;
if (gameManager.ClientVersion >= 910)
{
creatureType = message.ReadEnum <CreatureType>();
}
else
{
if (newID >= Constants.PlayerStartID && newID < Constants.PlayerEndID)
{
creatureType = CreatureType.Player;
}
else if (newID >= Constants.MonsterStartID && newID < Constants.MonsterEndID)
{
creatureType = CreatureType.Monster;
}
else
{
creatureType = CreatureType.NPC;
}
}
if (newID == Player.ID)
{
creature = Player;
}
else
{
creature = new Creatures.Creature(newID);
}
creature = CreatureStorage.ReplaceCreature(creature, removeID);
if (!creature)
{
throw new System.Exception("ProtocolGame.ReadCreatureInstance: Failed to append creature.");
}
creature.Type = creatureType;
if (gameManager.ClientVersion >= 1120)
{
creature.SetSummonerID(creature.IsSummon ? message.ReadUnsignedInt() : 0);
}
creature.Name = message.ReadString();
}
else
{
uint creatureId = message.ReadUnsignedInt();
creature = CreatureStorage.GetCreature(creatureId);
if (!creature)
{
throw new System.Exception("ProtocolGame.ReadCreatureInstance: Outdated creature not found.");
}
}
creature.SetSkill(SkillType.HealthPercent, message.ReadUnsignedByte());
creature.Direction = message.ReadEnum <Direction>();
creature.Outfit = ReadCreatureOutfit(message, creature.Outfit);
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GamePlayerMounts))
{
creature.MountOutfit = ReadMountOutfit(message, creature.MountOutfit);
}
creature.Brightness = message.ReadUnsignedByte();
creature.LightColor = Colors.ColorFrom8Bit(message.ReadUnsignedByte());
creature.SetSkill(SkillType.Speed, message.ReadUnsignedShort());
creature.SetPKFlag(message.ReadEnum <PKFlag>());
creature.SetPartyFlag(message.ReadEnum <PartyFlag>());
if (gameManager.GetFeature(GameFeature.GameCreatureEmblems) && type == AppearanceInstance.UnknownCreature)
{
creature.SetGuildFlag(message.ReadEnum <GuildFlag>());
}
if (gameManager.GetFeature(GameFeature.GameCreatureMarks))
{
creature.Type = message.ReadEnum <CreatureType>();
if (gameManager.ClientVersion >= 1120)
{
creature.SetSummonerID(creature.IsSummon ? message.ReadUnsignedInt() : 0);
}
}
if (gameManager.GetFeature(GameFeature.GameCreatureIcons))
{
creature.SetSpeechCategory(message.ReadEnum <SpeechCategory>());
}
if (gameManager.GetFeature(GameFeature.GameCreatureMarks))
{
creature.Marks.SetMark(MarkType.Permenant, message.ReadUnsignedByte());
if (gameManager.GetFeature(GameFeature.GameInspectionWindow))
{
message.ReadUnsignedByte(); // inspection state
}
if (gameManager.ClientVersion < 1185)
{
creature.NumberOfPvPHelpers = message.ReadUnsignedShort();
}
}
if (gameManager.ClientVersion >= 854)
{
creature.Unpassable = message.ReadUnsignedByte() != 0;
}
else
{
creature.Unpassable = true;
}
break;
}
case AppearanceInstance.Creature: {
uint creatureId = message.ReadUnsignedInt();
creature = CreatureStorage.GetCreature(creatureId);
if (!creature)
{
throw new System.Exception(string.Format("ProtocolGame.ReadCreatureInstance: Known creature not found ({0}).", creatureId));
}
creature.Direction = message.ReadEnum <Direction>();
if (gameManager.ClientVersion >= 953)
{
creature.Unpassable = message.ReadUnsignedByte() != 0;
}
break;
}
default:
throw new System.Exception("ProtocolGame.ReadCreatureInstance: unknown creature identity type.");
}
if (absolutePosition.HasValue)
{
creature.Position = absolutePosition.Value;
}
CreatureStorage.MarkOpponentVisible(creature, true);
CreatureStorage.InvalidateOpponents();
return(creature);
}
private void ParseGameNews(Internal.ByteArray message)
{
// TODO (suggested structure; timestamp, boolean)
message.ReadUnsignedInt();
message.ReadUnsignedByte();
}
