public StoreOpenParameters ReadStoreOpenParameters(Internal.CommunicationStream message)
{
var openAction = message.ReadEnum <StoreOpenParameterAction>();
Store.OpenParameters.IStoreOpenParamater openParam = null;
switch (openAction)
{
case StoreOpenParameterAction.Invalid:
{
break;
}
case StoreOpenParameterAction.CategoryType:
{
var categoryType = message.ReadEnum <StoreCategoryType>();
openParam = new Store.OpenParameters.StoreCategoryTypeOpenParamater(categoryType);
break;
}
case StoreOpenParameterAction.CategoryAndFilter:
{
var categoryAndFilter = ReadStoreCategoryAndFilter(message);
openParam = new Store.OpenParameters.StoreCategoryAndFilterOpenParamater(categoryAndFilter);
break;
}
case StoreOpenParameterAction.OfferType:
{
var offerType = message.ReadEnum <StoreOfferType>();
openParam = new Store.OpenParameters.StoreOfferTypeOpenParamater(offerType);
break;
}
case StoreOpenParameterAction.OfferId:
{
var offerId = message.ReadUnsignedInt();
openParam = new Store.OpenParameters.StoreOfferIdOpenParamater(offerId);
break;
}
case StoreOpenParameterAction.CategoryName:
{
var categoryName = message.ReadString();
openParam = new Store.OpenParameters.StoreCategoryNameOpenParamater(categoryName);
break;
}
}
// enum too, 0, 1, 2, 3
message.ReadUnsignedByte();
/**
* 0: default
* 1: home
* // 2, 3?
*/
message.ReadBoolean(); // 0, 1, 2, 3 (enum)
return(new StoreOpenParameters(openAction, openParam));
}
private void ParsePreyData(Internal.CommunicationStream message)
{
int slot = message.ReadUnsignedByte();
var state = message.ReadEnum <PreySlotStates>();
switch (state)
{
case PreySlotStates.Locked: {
message.ReadEnum <PreySlotUnlockType>();
break;
}
case PreySlotStates.Inactive: {
break;
}
case PreySlotStates.Active: {
string monsterName = message.ReadString();
var monsterOutfit = ProtocolGameExtentions.ReadCreatureOutfit(message);
var bonusType = message.ReadEnum <PreyBonusTypes>();
int bonusValue = message.ReadUnsignedShort();
int bonusGrade = message.ReadUnsignedByte();
int timeLeft = message.ReadUnsignedShort();
break;
}
case PreySlotStates.Selection: {
byte size = message.ReadUnsignedByte();
for (int i = 0; i < size; i++)
{
string monsterName = message.ReadString();
var monsterOutfit = ProtocolGameExtentions.ReadCreatureOutfit(message);
}
break;
}
case PreySlotStates.SelectionChangeMonster: {
var bonusType = message.ReadEnum <PreyBonusTypes>();
int bonusValue = message.ReadUnsignedShort();
int bonusGrade = message.ReadUnsignedByte();
byte size = message.ReadUnsignedByte();
for (int i = 0; i < size; i++)
{
string monsterName = message.ReadString();
var monsterOutfit = ProtocolGameExtentions.ReadCreatureOutfit(message);
}
break;
}
default:
break;
}
message.ReadUnsignedShort(); // timeUntilFreeListReroll
if (OpenTibiaUnity.GameManager.ClientVersion >= 1190)
{
message.ReadUnsignedByte(); // preyWildCards
}
}
public StoreOffer ReadLegacyStoreOffer(Internal.CommunicationStream message)
{
bool supportsHighlighting = OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameIngameStoreHighlights);
uint offerId = message.ReadUnsignedInt();
string offerName = message.ReadString();
string offerDescription = message.ReadString();
var storeOffer = new StoreOffer(offerName, offerDescription);
uint price = message.ReadUnsignedInt();
var highlightState = message.ReadEnum <StoreHighlightState>();
uint saleValidUntil = 0, saleBasePrice = 0;
if (highlightState == StoreHighlightState.Sale && supportsHighlighting && OpenTibiaUnity.GameManager.ClientVersion >= 1097)
{
saleValidUntil = message.ReadUnsignedInt();
saleBasePrice = message.ReadUnsignedInt();
}
var disabledState = message.ReadEnum <StoreOfferDisableState>();
string disabledReason = string.Empty;
if (supportsHighlighting && disabledState == StoreOfferDisableState.Disabled)
{
disabledReason = message.ReadString();
}
var quantityConfiguration = new StoreOfferQuantityConfiguration(offerId, price, 1, highlightState, false);
quantityConfiguration.DisabledState = disabledState;
if (disabledState == StoreOfferDisableState.Disabled)
{
quantityConfiguration.DisabledReasons.Add(disabledReason);
}
if (highlightState == StoreHighlightState.Sale && supportsHighlighting && OpenTibiaUnity.GameManager.ClientVersion >= 1097)
{
quantityConfiguration.SetSaleParameters(saleValidUntil, saleBasePrice);
}
storeOffer.AddQuantityConfiguration(quantityConfiguration);
int iconCount = message.ReadUnsignedByte();
for (int i = 0; i < iconCount; i++)
{
storeOffer.AddVisualisation(new Store.Visualisations.StoreIconVisualisation(message.ReadString()));
}
int productCount = message.ReadUnsignedShort();
for (int i = 0; i < productCount; i++)
{
storeOffer.AddProduct(ReadStoreProduct(message));
}
return(storeOffer);
}
private StoreCategory ReadStoreCategory(Internal.CommunicationStream message)
{
string name;
string description = null;
StoreHighlightState highlightState = StoreHighlightState.None;
name = message.ReadString();
if (OpenTibiaUnity.GameManager.ClientVersion < 1180)
{
description = message.ReadString();
}
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameIngameStoreHighlights))
{
highlightState = message.ReadEnum <StoreHighlightState>();
}
var category = new StoreCategory(name, description, highlightState);
int iconCount = message.ReadUnsignedByte();
for (int i = 0; i < iconCount; i++)
{
category.AddIcon(message.ReadString());
}
return(category);
}
public StoreVisualisation ReadStoreVisualisation(Internal.CommunicationStream message)
{
var appearanceType = message.ReadEnum <StoreOfferAppearanceType>();
switch (appearanceType)
{
case StoreOfferAppearanceType.Icon: {
string icon = message.ReadString();
return(new Store.Visualisations.StoreIconVisualisation(icon));
}
case StoreOfferAppearanceType.Mount: {
ushort outfitId = message.ReadUnsignedShort();
return(new Store.Visualisations.StoreMountVisualisation(outfitId));
}
case StoreOfferAppearanceType.Outfit: {
ushort outfitId = message.ReadUnsignedShort();
byte head = message.ReadUnsignedByte();
byte body = message.ReadUnsignedByte();
byte legs = message.ReadUnsignedByte();
byte feet = message.ReadUnsignedByte();
return(new Store.Visualisations.StoreOutfitVisualisation(outfitId, head, body, legs, feet));
}
case StoreOfferAppearanceType.Object: {
ushort objectId = message.ReadUnsignedShort();
return(new Store.Visualisations.StoreObjectVisualisation(objectId));
}
}
return(null);
}
private void ParseSetInventory(Internal.CommunicationStream message)
{
var slot = message.ReadEnum <ClothSlots>();
var @object = ProtocolGameExtentions.ReadObjectInstance(message);
OpenTibiaUnity.ContainerStorage.BodyContainerView.SetObject(slot, @object);
}
private void ParseMonsterCyclopediaMonsters(Internal.CommunicationStream message)
{
string classification = message.ReadString();
int monsters = message.ReadUnsignedShort();
for (int i = 0; i < monsters; i++)
{
// the client should detect monster name
// and some information about it through staticdata
ushort raceID = message.ReadUnsignedShort();
var stage = message.ReadEnum <CyclopediaRaceStage>();
if (stage != CyclopediaRaceStage.Unlocked)
{
var occurrence = message.ReadEnum <CyclopediaRaceOccurence>();
}
}
}
private void ParseStoreOffers(Internal.CommunicationStream message)
{
var gameManager = OpenTibiaUnity.GameManager;
string categoryName = message.ReadString();
if (gameManager.ClientVersion >= 1180)
{
uint selectedOfferId = message.ReadUnsignedInt();
var sortType = message.ReadEnum <StoreOfferSortType>();
int filterCount = message.ReadUnsignedByte();
for (int i = 0; i < filterCount; i++)
{
string filter = message.ReadString();
}
if (gameManager.ClientVersion >= 1185)
{
// if a filter is not included, then if "Show all" is not selected
// the offer will be hidden until then..
// if the offer has no filter, then this value won't affect it
int shownFiltersCount = message.ReadUnsignedShort();
for (int i = 0; i < shownFiltersCount; i++)
{
int filterIndex = message.ReadUnsignedByte();
}
}
}
var storeCategory = OpenTibiaUnity.StoreStorage.FindCategory(categoryName);
int offerCount = message.ReadUnsignedShort();
for (int i = 0; i < offerCount; i++)
{
var offer = ReadStoreOffer(message);
// server may be sending information about non-existant category
if (storeCategory != null)
{
storeCategory.AddOffer(offer);
}
}
if (gameManager.ClientVersion >= 1180 && categoryName == Constants.StoreHomeCategoryName)
{
byte featuredOfferCount = message.ReadUnsignedByte();
for (int i = 0; i < featuredOfferCount; i++)
{
var storeFeaturedOffer = ReadStoreFeaturedOffer(message);
}
byte unknown = message.ReadUnsignedByte();
}
}
private void ParseUpdateLootContainers(Internal.CommunicationStream message)
{
byte unknown = message.ReadUnsignedByte();
int count = message.ReadUnsignedByte();
for (int i = 0; i < count; i++)
{
var type = message.ReadEnum <ObjectCategory>();
ushort objectId = message.ReadUnsignedShort();
}
}
private void ReadCyclopediaCharacterInfoRecentPvpKills(Internal.CommunicationStream message)
{
ushort count = message.ReadUnsignedShort();
for (int i = 0; i < count; i++)
{
uint time = message.ReadUnsignedInt();
string description = message.ReadString();
var status = message.ReadEnum <CyclopediaPvpKillStatus>();
}
}
private void ParseCreatureShield(Internal.CommunicationStream message)
{
uint creatureId = message.ReadUnsignedInt();
var partyFlag = message.ReadEnum <PartyFlag>();
var creature = CreatureStorage.GetCreatureById(creatureId);
if (!!creature)
{
creature.SetPartyFlag(partyFlag);
}/*else {
* throw new System.Exception("ProtocolGame.ParseCreatureShield: Unknown creature id: " + creatureId);
* }*/
}
private void ReadCyclopediaCharacterInfoCombatStats(Internal.CommunicationStream message)
{
SkillType[] specialSkills = new SkillType[] {
SkillType.CriticalHitChance,
SkillType.CriticalHitDamage,
SkillType.LifeLeechChance,
SkillType.LifeLeechAmount,
SkillType.ManaLeechChance,
SkillType.ManaLeechAmount
};
foreach (var skill in specialSkills)
{
var skillStruct = ReadSkill(message, true);
}
int playerBlessings = message.ReadUnsignedByte();
int totalBlessings = message.ReadUnsignedByte();
ushort attackValue = message.ReadUnsignedShort();
var combatType = message.ReadEnum <CyclopediaCombatType>();
int convertedDamage = message.ReadUnsignedByte();
combatType = message.ReadEnum <CyclopediaCombatType>();
int armorValue = message.ReadUnsignedShort();
int defenseValue = message.ReadUnsignedShort();
int combats = message.ReadUnsignedByte();
for (int i = 0; i < combats; i++)
{
combatType = message.ReadEnum <CyclopediaCombatType>();
int combatValue = message.ReadUnsignedByte();
}
}
private void ParseCyclopediaCharacterInfo(Internal.CommunicationStream message)
{
// TODO, in 12.15 there are extra 4 bytes in both client/server
// i suggest that these bytes might have to do with character id
// as tibia introduced the so called "Friends widget"
var type = message.ReadEnum <CyclopediaCharacterInfoType>();
switch (type)
{
case CyclopediaCharacterInfoType.BaseInformation:
{
ReadCyclopediaCharacterInfoBaseInformation(message);
break;
}
case CyclopediaCharacterInfoType.GeneralStats:
{
ReadCyclopediaCharacterInfoGeneralStats(message);
break;
}
case CyclopediaCharacterInfoType.CombatStats:
{
ReadCyclopediaCharacterInfoCombatStats(message);
break;
}
case CyclopediaCharacterInfoType.RecentDeaths:
{
ReadCyclopediaCharacterInfoRecentDeaths(message);
break;
}
case CyclopediaCharacterInfoType.RecentPvpKills:
{
ReadCyclopediaCharacterInfoRecentPvpKills(message);
break;
}
case CyclopediaCharacterInfoType.Achievements:
{
ReadCyclopediaCharacterInfoAchievements(message);
break;
}
}
}
private void ParseInspectionList(Internal.CommunicationStream message)
{
bool isPlayer = message.ReadBoolean();
int size = message.ReadUnsignedByte();
for (int i = 0; i < size; i++)
{
var @object = ReadObjectInstance(message);
if (isPlayer)
{
var slot = message.ReadEnum <ClothSlots>();
}
int imbuementSlots = message.ReadUnsignedByte();
for (int j = 0; j < imbuementSlots; j++)
{
int imbuementId = message.ReadUnsignedByte();
}
int details = message.ReadUnsignedByte();
for (int j = 0; j < details; j++)
{
string name = message.ReadString();
string description = message.ReadString();
}
}
if (isPlayer)
{
string playerName = message.ReadString();
var outfit = ReadCreatureOutfit(message);
int details = message.ReadUnsignedByte();
for (int j = 0; j < details; j++)
{
string name = message.ReadString();
string description = message.ReadString();
}
}
}
private void ReadCyclopediaCharacterInfoGeneralStats(Internal.CommunicationStream message)
{
ulong experience = message.ReadUnsignedLong();
ushort level = message.ReadUnsignedShort();
int levelPercent = message.ReadUnsignedByte();
float baseXpGain = message.ReadUnsignedShort() / 100f;
float grindingAddend = message.ReadUnsignedShort() / 100f;
float storeBoostAddend = message.ReadUnsignedShort() / 100f;
float huntingBoostFactor = message.ReadUnsignedShort() / 100f;
message.ReadUnsignedShort(); // yet unknown
bool canBuyXpBoost = message.ReadBoolean();
int health = message.ReadUnsignedShort();
int maxHealth = message.ReadUnsignedShort();
int mana = message.ReadUnsignedShort();
int maxMana = message.ReadUnsignedShort();
int soul = message.ReadUnsignedByte();
int ticks = OpenTibiaUnity.TicksMillis;
int stamina = ticks + 60000 * message.ReadUnsignedShort();
int regeneration = ticks + 1000 * message.ReadUnsignedShort();
int training = ticks + 60000 * message.ReadUnsignedShort();
int speed = message.ReadUnsignedShort();
int baseSpeed = message.ReadUnsignedShort();
uint totalCapacity = message.ReadUnsignedInt();
uint baseCapacity = message.ReadUnsignedInt();
uint freeCapacity = message.ReadUnsignedInt();
int skillCount = message.ReadUnsignedByte();
for (int i = 0; i < skillCount; i++)
{
var skillType = message.ReadEnum <SkillType>();
var skill = ReadSkill(message);
}
}
public StoreOfferQuantityConfiguration ReadStoreOfferQuantityConfiguration(Internal.CommunicationStream message)
{
uint offerId = message.ReadUnsignedInt();
ushort amount = message.ReadUnsignedShort();
uint price = message.ReadUnsignedInt();
bool useTransferableCoins = message.ReadBoolean();
bool disabled = message.ReadBoolean();
var disabledReasons = new List <string>();
if (disabled)
{
int errorCount = message.ReadUnsignedByte();
for (int i = 0; i < errorCount; i++)
{
disabledReasons.Add(message.ReadString());
}
}
var highlightState = message.ReadEnum <StoreHighlightState>();
if (highlightState == StoreHighlightState.Sale)
{
uint saleValidUntilTimestamp = message.ReadUnsignedInt();
uint basePrice = message.ReadUnsignedInt();
}
var quantityConfiguration = new StoreOfferQuantityConfiguration(offerId, price, amount, highlightState, useTransferableCoins);
quantityConfiguration.DisabledReasons.AddRange(disabledReasons);
if (disabled)
{
quantityConfiguration.DisabledState = StoreOfferDisableState.Disabled;
}
return(quantityConfiguration);
}
private void ParseChannelEvent(Internal.CommunicationStream message)
{
int channelId = message.ReadUnsignedShort();
var channel = ChatStorage.GetChannel(channelId);
string playerName = message.ReadString();
var eventType = message.ReadEnum <ChannelEvent>();
if (channel == null)
{
#if DEBUG || NDEBUG
Debug.LogWarning("ProtocolGame.ParseChannelEvent: invalid channel id " + channelId);
#endif
return;
}
switch (eventType)
{
case ChannelEvent.PlayerJoined:
channel.PlayerJoined(playerName);
break;
case ChannelEvent.PlayerLeft:
channel.PlayerLeft(playerName);
break;
case ChannelEvent.PlayerInvited:
channel.PlayerInvited(playerName);
break;
case ChannelEvent.PlayerExcluded:
channel.PlayerExcluded(playerName);
break;
case ChannelEvent.PlayerPending:
channel.PlayerPending(playerName);
break;
}
}
private ProtocolOutfit ReadNewProtocolOutfit(Internal.CommunicationStream message)
{
ushort outfitId = message.ReadUnsignedShort();
var outfitName = message.ReadString();
int addOns = message.ReadUnsignedByte();
OutfitLockType lockType = OutfitLockType.Unlocked;
uint offerId = 0;
var clientVersion = OpenTibiaUnity.GameManager.ClientVersion;
if (clientVersion >= 1185)
{
if (clientVersion >= 1220)
{
lockType = message.ReadEnum <OutfitLockType>();
}
else if (message.ReadBoolean())
{
lockType = OutfitLockType.Store;
}
if (lockType == OutfitLockType.Store)
{
offerId = message.ReadUnsignedInt();
}
}
return(new ProtocolOutfit()
{
_id = outfitId,
Name = outfitName,
AddOns = addOns,
LockType = lockType,
StoreOfferId = offerId,
});
}
private DailyReward.DailyReward ReadDailyReward(Internal.CommunicationStream message)
{
var rewardType = message.ReadEnum <DailyRewardType>();
var reward = new DailyReward.DailyReward(rewardType);
switch (rewardType)
{
case DailyRewardType.PickedItems: {
reward.AllowedMaximumItems = message.ReadUnsignedByte();
int objectCount = message.ReadUnsignedByte();
for (int i = 0; i < objectCount; i++)
{
ushort objectId = message.ReadUnsignedShort();
string objectName = message.ReadString();
uint objectWeight = message.ReadUnsignedInt();
reward.AddItem(new DailyReward.Types.Object(objectId, objectName, objectWeight, -1));
}
break;
}
case DailyRewardType.FixedItems: {
int itemsCount = message.ReadUnsignedByte();
for (int i = 0; i < itemsCount; i++)
{
var subType = message.ReadEnum <DailyRewardSubType>();
switch (subType)
{
case DailyRewardSubType.Object: {
ushort objectId = message.ReadUnsignedShort();
string objectName = message.ReadString();
int objectAmount = message.ReadUnsignedByte();
reward.AddItem(new DailyReward.Types.Object(objectId, objectName, 0, objectAmount));
break;
}
case DailyRewardSubType.PreyBonusRerolls: {
int amount = message.ReadUnsignedByte();
reward.AddItem(new DailyReward.Types.PreyBonusRerolls(amount));
break;
}
case DailyRewardSubType.FiftyPercentXpBoost: {
ushort minutes = message.ReadUnsignedShort();
reward.AddItem(new DailyReward.Types.XpBoost(minutes));
break;
}
default:
throw new System.Exception("ProtocolGame.ReadDailyReward: Invalid reward sub-type " + (int)subType + ".");
}
}
break;
}
}
return(reward);
}
public void ParseShowMessageDialog(Internal.CommunicationStream message)
{
var type = message.ReadEnum <MessageDialogType>();
string content = message.ReadString();
}
private Creatures.Creature ReadCreatureInstance(Internal.CommunicationStream 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.ClientVersion >= 1220 && creature.Type == CreatureType.Player)
{
byte unknown = message.ReadUnsignedByte(); // suggestion: boolean isFriend (friend system)
}
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);
}
public static LoginserverMessageType ReadLoginType(this Internal.CommunicationStream message)
{
return(message.ReadEnum <LoginserverMessageType>());
}
private void ParseDeleteInventory(Internal.CommunicationStream message)
{
var slot = message.ReadEnum <ClothSlots>();
OpenTibiaUnity.ContainerStorage.BodyContainerView.SetObject(slot, null);
}
private void ParseOutfitDialog(Internal.CommunicationStream message)
{
var outfit = ProtocolGameExtentions.ReadCreatureOutfit(message);
Appearances.AppearanceInstance mountOutfit = null;
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GamePlayerMounts))
{
mountOutfit = ProtocolGameExtentions.ReadMountOutfit(message);
}
var outfitList = new List <ProtocolOutfit>();
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameNewOutfitProtocol))
{
int count;
if (OpenTibiaUnity.GameManager.ClientVersion >= 1185)
{
count = message.ReadUnsignedShort();
}
else
{
count = message.ReadUnsignedByte();
}
for (int i = 0; i < count; i++)
{
outfitList.Add(ReadNewProtocolOutfit(message));
}
}
else
{
ushort outfitStart, outfitEnd;
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GameOutfitIdU16))
{
outfitStart = message.ReadUnsignedShort();
outfitEnd = message.ReadUnsignedShort();
}
else
{
outfitStart = message.ReadUnsignedByte();
outfitEnd = message.ReadUnsignedByte();
}
for (ushort i = outfitStart; i <= outfitEnd; i++)
{
outfitList.Add(new ProtocolOutfit()
{
_id = i
});
}
}
List <ProtocolMount> mountList = null;
if (OpenTibiaUnity.GameManager.GetFeature(GameFeature.GamePlayerMounts))
{
mountList = new List <ProtocolMount>();
int count;
if (OpenTibiaUnity.GameManager.ClientVersion >= 1185)
{
count = message.ReadUnsignedShort();
}
else
{
count = message.ReadUnsignedByte();
}
for (int i = 0; i < count; i++)
{
mountList.Add(ReadProtocolMount(message));
}
}
OutfitDialogType type = 0;
if (OpenTibiaUnity.GameManager.ClientVersion >= 1185)
{
type = message.ReadEnum <OutfitDialogType>();
bool mounted = message.ReadBoolean();
}
OpenTibiaUnity.GameManager.onRequestOutfitDialog.Invoke(outfit, mountOutfit, outfitList, mountList);
}
private void ParseMonsterCyclopediaRace(Internal.CommunicationStream message)
{
ushort raceID = message.ReadUnsignedShort();
var classification = message.ReadString();
int unlockState = message.ReadUnsignedByte();
uint totalKills = message.ReadUnsignedInt();
int killsToFirstDetailStage = message.ReadUnsignedShort();
int killsToSecondDetailStage = message.ReadUnsignedShort();
int killsToThirdDetailStage = message.ReadUnsignedShort();
if (unlockState >= 1)
{
var difficulty = message.ReadEnum <CyclopediaRaceDifficulty>();
var occurrence = message.ReadEnum <CyclopediaRaceOccurence>();
int count = message.ReadUnsignedByte();
for (int i = 0; i < count; i++)
{
ushort objectID = message.ReadUnsignedShort();
var rarity = message.ReadEnum <CyclopediaRaceLootRarity>();
bool specialEventLoot = message.ReadBoolean();
if (objectID != 0)
{
var objectName = message.ReadString();
var lootType = message.ReadEnum <CyclopediaRaceLootType>();
}
}
}
if (unlockState >= 2)
{
ushort charmPoints = message.ReadUnsignedShort();
var attackType = message.ReadEnum <CyclopediaRaceAttackType>();
bool castSpellsOrUseSkills = message.ReadBoolean(); // shows the icon of spells
uint health = message.ReadUnsignedInt();
uint experience = message.ReadUnsignedInt();
ushort speed = message.ReadUnsignedShort();
ushort armor = message.ReadUnsignedShort();
}
if (unlockState >= 3)
{
int count = message.ReadUnsignedByte();
for (int i = 0; i < count; i++)
{
var combatType = message.ReadEnum <CyclopediaCombatType>();
int value = message.ReadShort();
}
count = message.ReadUnsignedShort();
for (int i = 0; i < count; i++)
{
string location = message.ReadString();
}
}
if (unlockState >= 4)
{
bool hasCharmSelected = message.ReadBoolean();
if (hasCharmSelected)
{
int selectedCharmID = message.ReadUnsignedByte();
int unknown0 = message.ReadUnsignedByte();
int unknown1 = message.ReadUnsignedByte();
int unknown2 = message.ReadUnsignedByte();
}
bool canSelectCharm = message.ReadBoolean();
}
}
