public int GetStat(CharacterClassType type, byte level)
{
switch (type)
{
case CharacterClassType.Adventurer:
return(11);
case CharacterClassType.Swordman:
return(11);
case CharacterClassType.Archer:
return(12);
case CharacterClassType.Magician:
return(10);
case CharacterClassType.Wrestler:
return(11);
case CharacterClassType.Unknown:
return(11);
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public static void deserialize(byte[] data, ref Int32 offset, out CharacterClassType type)
{
UInt16 value = BitConverter.ToUInt16(data, offset);
type = (CharacterClassType)value;
offset += sizeof(UInt16);
}
private GameObject createPrefab(CharacterClassType characterClass)
{
switch (characterClass)
{
case CharacterClassType.Warrior:
return(Instantiate(characterPrefabs[0], this.transform));
case CharacterClassType.Crusader:
return(Instantiate(characterPrefabs[1], this.transform));
case CharacterClassType.Archer:
return(Instantiate(characterPrefabs[2], this.transform));
case CharacterClassType.Assassin:
return(Instantiate(characterPrefabs[3], this.transform));
case CharacterClassType.Wizard:
return(Instantiate(characterPrefabs[4], this.transform));
case CharacterClassType.Elementalist:
return(Instantiate(characterPrefabs[5], this.transform));
default:
return(null);
}
}
private void updateSelectedCharacter(CharacterClassType type)
{
JToken info = parsedCharactersInfo[type.ToString()];
selectedType = type;
selectedClassName.text = info["language"]["kr"].ToObject <string>();
selectedClassDescription.text = info["description"].ToObject <string>();
}
public void selectClass(CharacterClassType type)
{
this.updateSelectedCharacter(type);
if (previewCharacter)
{
previewCharacter.SetActive(false);
}
previewCharacter = previewNode.Find(type.ToString())?.gameObject;
previewCharacter.SetActive(true);
}
// -------------------------------------------------------------------
// Public
// -------------------------------------------------------------------
public GameDataId Get(CharacterClassType type)
{
GameDataId result;
if (this.typeLookup.TryGetValue(type, out result))
{
return(result);
}
return(GameDataId.Invalid);
}
public static CharacterClass CharacterClassFactory(CharacterClassType characterType)
{
switch (characterType)
{
case CharacterClassType.Warrior:
return new Warrior();
case CharacterClassType.Mage:
return new Mage();
case CharacterClassType.Thief:
return new Thief();
default:
throw new NotImplementedException();
}
}
public int GetJobLevelXp(CharacterClassType type, byte level) =>
(int)(type == CharacterClassType.Adventurer
? _jobLevelBasedAlgorithm.FirstJobXpData[
level - 1 > 0
? level - 1 >= _jobLevelBasedAlgorithm.FirstJobXpData.Length
? _jobLevelBasedAlgorithm.FirstJobXpData.Length - 1
: level - 1
: 0]
: _jobLevelBasedAlgorithm.Data[
level - 1 > 0
? level - 1 >= _jobLevelBasedAlgorithm.Data.Length
? _jobLevelBasedAlgorithm.Data.Length - 1
: level - 1
: 0]);
public async Task UserCantChangeClassLowJobLevelAsync(CharacterClassType characterClass)
{
_session !.Character.JobLevel = 20;
await _nrRunService.NRunLaunchAsync(_session, new Tuple <IAliveEntity, NrunPacket>(_session.Character, (new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
})));
var packet = (MsgiPacket?)_session.LastPackets.FirstOrDefault(s => s is MsgiPacket);
Assert.IsTrue(packet?.Message == Game18NConstString.CanNotChangeJobAtThisLevel && packet.Type == MessageType.White);
}
public async Task UserCanChangeClassAsync(CharacterClassType characterClass)
{
_session !.Character.Level = 15;
_session.Character.JobLevel = 20;
await _nrRunService.NRunLaunchAsync(_session, new Tuple <IAliveEntity, NrunPacket>(_session.Character, (new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
})));
Assert.IsTrue((_session.Character.Class == characterClass) && (_session.Character.Level == 15) &&
(_session.Character.JobLevel == 1));
}
public void UserCanChangeClass(CharacterClassType characterClass)
{
_session.Character.Level = 15;
_session.Character.JobLevel = 20;
_nRunHandler.Execute(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
}, _session);
Assert.IsTrue((_session.Character.Class == characterClass) && (_session.Character.Level == 15) &&
(_session.Character.JobLevel == 1));
}
public async Task UserCanChangeClassAsync(CharacterClassType characterClass)
{
_session !.Character.Level = 15;
_session.Character.JobLevel = 20;
await _nRunHandler !.ExecuteAsync(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
}, _session).ConfigureAwait(false);
Assert.IsTrue((_session.Character.Class == characterClass) && (_session.Character.Level == 15) &&
(_session.Character.JobLevel == 1));
}
public async Task UserCantChangeClassLowJobLevelAsync(CharacterClassType characterClass)
{
_session !.Character.JobLevel = 20;
await _nRunHandler !.ExecuteAsync(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
}, _session).ConfigureAwait(false);
var packet = (MsgiPacket?)_session.LastPackets.FirstOrDefault(s => s is MsgiPacket);
Assert.IsTrue(packet?.Message == Game18NConstString.CanNotChangeJobAtThisLevel && packet.Type == MessageType.White);
}
public async Task <SaltyCommandResult> ChangeClassAsync(
[Description("Class you want to change to")]
CharacterClassType newClass,
[Description("Character you want to change the class")]
IPlayerEntity player = null)
{
if (player == null)
{
player = Context.Player;
}
await player.ChangeClass(newClass);
return(new SaltyCommandResult(true, $"{player.Character.Name}'s class has been changed to {newClass.ToString()}."));
}
public async Task UserCantChangeClassLowJobLevelAsync(CharacterClassType characterClass)
{
_session !.Character.JobLevel = 20;
await _nRunHandler !.ExecuteAsync(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
}, _session).ConfigureAwait(false);
var packet = (MsgPacket?)_session.LastPackets.FirstOrDefault(s => s is MsgPacket);
Assert.IsTrue((packet?.Message == GameLanguage.Instance.GetMessageFromKey(LanguageKey.TOO_LOW_LEVEL,
_session.Account.Language)) && (packet.Type == MessageType.White));
}
public async Task UserCantChangeBadClassAsync(CharacterClassType characterClass)
{
_session !.Character.Class = characterClass;
await _nrRunService.NRunLaunchAsync(_session, new Tuple <IAliveEntity, NrunPacket>(_session.Character, (new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)CharacterClassType.Swordsman
})));
var packet = (MsgPacket?)_session.LastPackets.FirstOrDefault(s => s is MsgPacket);
Assert.IsTrue((packet?.Message == GameLanguage.Instance.GetMessageFromKey(LanguageKey.NOT_ADVENTURER,
_session.Account.Language)) && (packet.Type == MessageType.White));
}
public void UserCanChangeClass(CharacterClassType characterClass)
{
_session.Character.Level = 15;
_session.Character.JobLevel = 20;
_handler.RegisterSession(_session);
_handler.NRun(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
});
Assert.IsTrue(_session.Character.Class == characterClass && _session.Character.Level == 15 &&
_session.Character.JobLevel == 1);
}
public void UserCantChangeToBadClass(CharacterClassType characterClass)
{
_session !.Character.Level = 15;
_session.Character.JobLevel = 20;
_nRunHandler !.ExecuteAsync(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
}, _session);
Assert.IsTrue((_session.Character.Class == CharacterClassType.Adventurer) &&
(_session.Character.Level == 15) &&
(_session.Character.JobLevel == 20));
}
public ResourceKey GetIcon(CharacterClassType type, bool getLargeIcon = false)
{
ResourceKey result;
if (getLargeIcon && this.iconLargeLookup.TryGetValue(type, out result))
{
return(result);
}
if (this.iconSmallLookup.TryGetValue(type, out result))
{
return(result);
}
return(ResourceKey.Invalid);
}
public async Task UserCantChangeBadClassAsync(CharacterClassType characterClass)
{
_session !.Character.Class = characterClass;
await _nRunHandler !.ExecuteAsync(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)CharacterClassType.Swordsman
}, _session).ConfigureAwait(false);
var packet = (MsgPacket?)_session.LastPackets.FirstOrDefault(s => s is MsgPacket);
Assert.IsTrue((packet?.Message == GameLanguage.Instance.GetMessageFromKey(LanguageKey.NOT_ADVENTURER,
_session.Account.Language)) && (packet.Type == MessageType.White));
}
public void UserCantChangeClassLowJobLevel(CharacterClassType characterClass)
{
_session.Character.JobLevel = 20;
_nRunHandler.Execute(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
}, _session);
var packet = (MsgPacket)_session.LastPackets.FirstOrDefault(s => s is MsgPacket);
Assert.IsTrue((packet.Message == Language.Instance.GetMessageFromKey(LanguageKey.TOO_LOW_LEVEL,
_session.Account.Language)) && (packet.Type == MessageType.White));
}
public void UserCantChangeBadClass(CharacterClassType characterClass)
{
_session.Character.Class = characterClass;
_nRunHandler.Execute(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)CharacterClassType.Swordman
}, _session);
var packet = (MsgPacket)_session.LastPackets.FirstOrDefault(s => s is MsgPacket);
Assert.IsTrue((packet.Message == Language.Instance.GetMessageFromKey(LanguageKey.NOT_ADVENTURER,
_session.Account.Language)) && (packet.Type == MessageType.White));
}
public void UserCantChangeClassLowJobLevel(CharacterClassType characterClass)
{
_session.Character.JobLevel = 20;
_handler.RegisterSession(_session);
_handler.NRun(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
});
var packet = (MsgPacket)_session.LastPacket;
Assert.IsTrue(packet.Message == Language.Instance.GetMessageFromKey(LanguageKey.TOO_LOW_LEVEL,
_session.Account.Language) && packet.Type == MessageType.White);
}
public void UserCantChangeBadClass(CharacterClassType characterClass)
{
_session.Character.Class = characterClass;
_handler.RegisterSession(_session);
_handler.NRun(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)CharacterClassType.Swordman
});
var packet = (MsgPacket)_session.LastPacket;
Assert.IsTrue(packet.Message == Language.Instance.GetMessageFromKey(LanguageKey.NOT_ADVENTURER,
_session.Account.Language) && packet.Type == MessageType.White);
}
public async Task Test_Wear_Put_Item_BadClassAsync(CharacterClassType classToTest)
{
_session !.Character.Class = classToTest;
var items = new List <ItemDto>
{
new Item
{
Type = NoscorePocketType.Equipment, VNum = 1, EquipmentSlot = EquipmentType.MainWeapon,
Class = (byte)(31 - Math.Pow(2, (byte)classToTest))
}
};
_item = new ItemProvider(items,
new List <IEventHandler <Item, Tuple <InventoryItemInstance, UseItemPacket> > >
{
new WearEventHandler(Logger)
});
_session.Character.InventoryService !.AddItemToPocket(InventoryItemInstance.Create(_item.Create(1, 1),
_session.Character.CharacterId));
await _wearPacketHandler !.ExecuteAsync(new WearPacket {
InventorySlot = 0, Type = PocketType.Equipment
}, _session).ConfigureAwait(false);
Assert.IsTrue(_session.Character.InventoryService.All(s => s.Value.Type == NoscorePocketType.Equipment));
var packet = (SayPacket?)_session.LastPackets.FirstOrDefault(s => s is SayPacket);
Assert.IsTrue((packet?.Message == GameLanguage.Instance.GetMessageFromKey(LanguageKey.BAD_EQUIPMENT,
_session.Account.Language)) && (packet.Type == SayColorType.Yellow));
foreach (var validClass in Enum.GetValues(typeof(CharacterClassType)).OfType <CharacterClassType>()
.Where(s => s != classToTest).ToList())
{
_session.Character.Class = validClass;
var item = _session.Character.InventoryService.First();
await _wearPacketHandler.ExecuteAsync(new WearPacket { InventorySlot = 0, Type = PocketType.Equipment }, _session).ConfigureAwait(false);
Assert.IsTrue(item.Value.Type == NoscorePocketType.Wear);
item.Value.Type = NoscorePocketType.Equipment;
item.Value.Slot = 0;
}
}
private static CharacterClassType DetermineCharacterClassType(CharacterObject character)
{
CharacterClassType characterByDefaultFormationGroup = GetCharacterClassTypeByDefaultFormationGroup(character);
if (characterByDefaultFormationGroup != CharacterClassType.UNKNOWN)
{
return(characterByDefaultFormationGroup);
}
if (character.IsInfantry)
{
return(CharacterClassType.INFANTRY);
}
if (character.IsArcher)
{
return(character.IsMounted ? CharacterClassType.HORSE_ARCHER : CharacterClassType.RANGED);
}
return(character.IsMounted ? CharacterClassType.CAVALRY : CharacterClassType.UNKNOWN);
}
public async Task UserCanNotChangeClassWhenEquipmentAsync(CharacterClassType characterClass)
{
_session !.Character.Level = 15;
_session.Character.JobLevel = 20;
_session.Character.InventoryService !.AddItemToPocket(InventoryItemInstance.Create(_item !.Create(1, 1), 0));
var item = _session.Character.InventoryService.First();
item.Value.Type = NoscorePocketType.Wear;
await _nRunHandler !.ExecuteAsync(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
}, _session).ConfigureAwait(false);
var packet = (MsgPacket?)_session.LastPackets.FirstOrDefault(s => s is MsgPacket);
Assert.IsTrue((packet?.Message == GameLanguage.Instance.GetMessageFromKey(LanguageKey.EQ_NOT_EMPTY,
_session.Account.Language)) && (packet.Type == MessageType.White));
}
public void UserCanNotChangeClassWhenEquipment(CharacterClassType characterClass)
{
_session.Character.Level = 15;
_session.Character.JobLevel = 20;
_session.Character.Inventory.AddItemToPocket(_item.Create(1, 1));
var item = _session.Character.Inventory.First();
item.Value.Type = PocketType.Wear;
_handler.RegisterSession(_session);
_handler.NRun(new NrunPacket
{
VisualType = VisualType.Npc,
Runner = NrunRunnerType.ChangeClass,
VisualId = 0,
Type = (byte)characterClass
});
var packet = (MsgPacket)_session.LastPacket;
Assert.IsTrue(packet.Message == Language.Instance.GetMessageFromKey(LanguageKey.EQ_NOT_EMPTY,
_session.Account.Language) && packet.Type == MessageType.White);
}
public void Test_Wear_Put_Item_BadClass(CharacterClassType classToTest)
{
_session.Character.Class = classToTest;
var items = new List <Item>
{
new Item {
Type = PocketType.Equipment, VNum = 1, EquipmentSlot = EquipmentType.MainWeapon,
Class = (byte)(31 - Math.Pow(2, (byte)classToTest))
},
};
_itemBuilder = new ItemBuilderService(items, new List <IHandler <Item, Tuple <IItemInstance, UseItemPacket> > > {
new WearHandler()
});
_session.Character.Inventory.AddItemToPocket(_itemBuilder.Create(1, 1));
_handler.Wear(new WearPacket {
InventorySlot = 0, Type = PocketType.Equipment
});
Assert.IsTrue(_session.Character.Inventory.All(s => s.Value.Type == PocketType.Equipment));
var packet = (SayPacket)_session.LastPacket;
Assert.IsTrue(packet.Message == Language.Instance.GetMessageFromKey(LanguageKey.BAD_EQUIPMENT,
_session.Account.Language) && packet.Type == SayColorType.Yellow);
foreach (var validClass in Enum.GetValues(typeof(CharacterClassType)).OfType <CharacterClassType>().Where(s => s != classToTest).ToList())
{
_session.Character.Class = validClass;
var item = _session.Character.Inventory.First();
_handler.Wear(new WearPacket {
InventorySlot = 0, Type = PocketType.Equipment
});
Assert.IsTrue(item.Value.Type == PocketType.Wear);
item.Value.Type = PocketType.Equipment;
item.Value.Slot = 0;
}
}
public static async Task ChangeClass(this IPlayerEntity player, CharacterClassType type)
{
player.JobLevel = 1;
player.JobLevelXp = 0;
await player.SendPacketAsync(new NpInfoPacket { UnKnow = 0 });
await player.SendPacketAsync(new PClearPacket());
if (type == CharacterClassType.Adventurer)
{
player.Character.HairStyle = player.Character.HairStyle > HairStyleType.HairStyleB ? HairStyleType.HairStyleA : player.Character.HairStyle;
}
player.Character.Class = type;
player.HpMax = Algorithm.GetHpMax(type, player.Level);
player.MpMax = Algorithm.GetMpMax(type, player.Level);
player.Hp = player.HpMax;
player.Mp = player.MpMax;
await player.SendPacketAsync(player.GenerateTitPacket());
await player.ActualizeUiHpBar();
await player.SendPacketAsync(player.GenerateEqPacket());
await player.SendPacketAsync(player.GenerateEffectPacket(8));
await player.SendPacketAsync(player.GenerateEffectPacket(196));
await player.SendPacketAsync(player.GenerateScrPacket());
await player.SendChatMessageFormat(PlayerMessages.CHARACTER_YOUR_CLASS_CHANGED_TO_X, SayColorType.Blue, type);
player.Character.Faction = player.Family?.FamilyFaction ?? (FactionType)(1 + _randomGenerator.Next(0, 2));
await player.SendChatMessageFormat(PlayerMessages.CHARACTER_YOUR_FACTION_CHANGED_TO_X, SayColorType.Blue, player.Character.Faction);
await player.ActualizeUiFaction();
await player.ActualizeUiStatChar();
await player.SendPacketAsync(player.GenerateEffectPacket(4799 + (byte)player.Character.Faction));
await player.ActualizePlayerCondition();
await player.ActualizeUiExpBar();
await player.BroadcastAsync(player.GenerateCModePacket());
await player.BroadcastAsync(player.GenerateInPacket());
await player.BroadcastAsync(player.GenerateGidxPacket());
await player.BroadcastAsync(player.GenerateEffectPacket(6));
await player.BroadcastAsync(player.GenerateEffectPacket(196));
SkillComponent component = player.SkillComponent;
foreach (SkillDto skill in component.Skills.Values)
{
if (skill.Id >= 200)
{
component.Skills.Remove(skill.Id);
}
}
// TODO : LATER ADD SKILL
await player.ActualizeUiSkillList();
// Later too
/* foreach (QuicklistEntryDTO quicklists in DAOFactory.QuicklistEntryDAO.LoadByCharacterId(CharacterId).Where(quicklists => QuicklistEntries.Any(qle => qle.Id == quicklists.Id)))
* {
* DAOFactory.QuicklistEntryDAO.Delete(quicklists.Id);
* }
*
* QuicklistEntries = new List<QuicklistEntryDTO>
* {
* new QuicklistEntryDTO
* {
* CharacterId = CharacterId,
* Q1 = 0,
* Q2 = 9,
* Type = 1,
* Slot = 3,
* Pos = 1
* }
* };
* if (ServerManager.Instance.Groups.Any(s => s.IsMemberOfGroup(Session) && s.GroupType == GroupType.Group))
* {
* Session.CurrentMapInstance?.Broadcast(Session, $"pidx 1 1.{CharacterId}", ReceiverType.AllExceptMe);
* }*/
}
public int GetStat(CharacterClassType type, byte level) => _minDist[(int)type, level - 1 > 0 ? level - 1 : 0];
