public ActionResult AttackCharacter(int?characterId)
{
if (characterId == null || characterId == Convert.ToInt32(SessionManager.GetCharacterId()))
{
FlashMessage.Danger("Erro: ", "Você não não pode atacar o seu próprio personagem!!!");
return(RedirectToAction("Ranking", "Home"));
}
Character challenger = CharacterDAO.GetAllInformations(Convert.ToInt32(SessionManager.GetCharacterId()));
Character challenged = CharacterDAO.GetAllInformations(characterId);
Character winner = MakeCombat(challenger, challenged);
GiveBonusFromCombat(winner);
CharacterDAO.Update(GiveBonusFromCombat(winner));
if (winner.CharacterId != Convert.ToInt32(SessionManager.GetCharacterId()))
{
FlashMessage.Danger(":/ ", "Você perdeu o combate, tente bater em alguém mais noob!!!");
return(RedirectToAction("Ranking", "Home"));
}
return(RedirectToAction("IsCharacterEnvolved", "Characters"));
}
private void GameEnter() //TODO move this to player class
{
CharacterChoosePacket ccp = (CharacterChoosePacket)ReadPacket(new CharacterChoosePacket());
_log.Info(ccp.Index.ToString(CultureInfo.InvariantCulture));
//TODO Save characters in class
CharacterDAO chrMgr = new CharacterDAO(Server.ServerInstance.Database);
AccountDAO accMgr = new AccountDAO(Server.ServerInstance.Database);
int accountID = accMgr.GetAccountID(AccountName);
Character[] chars = chrMgr.GetCharactersByAccount(accountID);
CharacterListPacket clp = new CharacterListPacket(chars,
accMgr.GetAccountEmpire(accountID));
//TODO Everything wrong down here
//inventario ->
SendPacket(new InventoryItemsPacket());
//stats
SendPacket(new CharacterStatsPacket(chars[ccp.Index])); //TODO Check index
//unknown 1
ReadBuffer(8);
//entity spawn
SendPacket(new EntitySpawnPacket(chars[ccp.Index]));
LauncherNamePacket lnp = new LauncherNamePacket();
ReadPacket(lnp);
}
public ActionResult BuyItem(int itemId)
{
int characterId = Convert.ToInt32(SessionManager.GetCharacterId());
Character character = CharacterDAO.GetAllInformations(characterId);
Item itemToBuy = ItemDAO.Get(itemId);
if (character.Coins < itemToBuy.Price || character.Level < itemToBuy.RequiredLevel)
{
FlashMessage.Danger("Erro: ", "Você não possuí moedas suficientes para realizar a compra ou não tem level suficiente para adquirir o item");
return(RedirectToAction("Market", "Home", null));
}
foreach (var itemInBag in character.Bag.ItemsInBag)
{
if (itemInBag.Item == null)
{
character.Coins -= itemToBuy.Price;
itemInBag.Item = itemToBuy;
CharacterDAO.Update(character);
return(RedirectToAction("Index", "Home", null));
}
}
FlashMessage.Danger("Erro: ", "Você não possuí slots vazios na mochila para armazenar o item");
return(RedirectToAction("Market", "Home", null));
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
/// <param name="character"></param>
private void CharacterDeletionExecute(WorldClient client, CharacterDAO character)
{
if (!CharacterRepository.Instance.Delete(character))
{
client.Send(WorldMessage.CHARACTER_DELETION_ERROR());
return;
}
if (character.Guild.GuildId != -1)
{
var guild = GuildManager.Instance.GetGuild(character.Guild.GuildId);
guild.MemberKick(GuildManager.Instance.GetMember(character.Guild.GuildId, character.Id), character.Name);
}
InventoryItemRepository.Instance.EntityRemoved((int)EntityTypeEnum.TYPE_CHARACTER, character.Id);
InventoryItemRepository.Instance.EntityRemoved((int)EntityTypeEnum.TYPE_MERCHANT, character.Id);
CharacterWaypointRepository.Instance.RemoveAll(character.Id);
CharacterGuildRepository.Instance.ImplicitDeletion(character.Guild);
CharacterAlignmentRepository.Instance.ImplicitDeletion(character.Alignment);
foreach (var job in CharacterJobRepository.Instance.GetByCharacterId(character.Id))
{
CharacterJobRepository.Instance.ImplicitDeletion(job);
}
client.Characters.Remove(character);
client.Send(WorldMessage.CHARACTER_LIST(client.Characters));
}
public ActionResult CharacterDetails(int?characterId)
{
if (characterId == null)
{
return(RedirectToAction("Ranking"));
}
return(View(CharacterDAO.GetAllInformations(characterId)));
}
/// <summary>
///
/// </summary>
/// <param name="characterDAO"></param>
/// <returns></returns>
public MerchantEntity CreateMerchant(CharacterDAO characterDAO)
{
var merchant = new MerchantEntity(characterDAO);
m_merchantById.Add(merchant.Id, merchant);
m_merchantByName.Add(merchant.Name.ToLower(), merchant);
m_merchantByAccount.Add(merchant.AccountId, merchant);
return(merchant);
}
private void SaveCharacter([FromSource] Player player, string firstName, string lastName)
{
Debug.WriteLine("Adding character " + firstName + " " + lastName);
Character character = new Character(AccountManager.GetAccount(player).Id, firstName, lastName);
Debug.WriteLine("getaccount good " + character.AccountId.ToString());
CharacterDAO characterDAO = new CharacterDAO();
character = characterDAO.SaveOrUpdate(character);
player.TriggerEvent("createdCharacter", character.Id, character.FirstName, character.LastName);
}
/// <summary>
/// Queries the database and retrieves all valid users that can then be added to the campaign
/// </summary>
private void InitUsers()
{
// Retrieve list of all users
UserDAO userDAO = new UserDAO();
validUsers = userDAO.GetAllUsers();
// Retrieve list of user characters
CharacterDAO characterDAO = new CharacterDAO();
userCharacters = userDAO.GetUserCharacters(validUsers[0].ID);
}
/// <summary>
/// Saves character to the user's account
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BtnSave_Click(object sender, EventArgs e)
{
Character character = (Character)Session["character"];
UserDAO userDAO = new UserDAO();
User user = userDAO.GetUser(Context.User.Identity.Name);
CharacterDAO characterDAO = new CharacterDAO();
character.DbID = characterDAO.UploadCharacter(user.ID, character);
Response.Redirect("~/Users/Characters/SeeAllCharacters.aspx?newCharacter=true");
}
public ActionResult Index()
{
int userId = Convert.ToInt32(SessionManager.GetUserId());
User user = UserDAO.Get(userId);
if (user.Character == null)
{
return(View("GenerateCharacter"));
}
Character character = CharacterDAO.GetAllInformations(user.Character.CharacterId);
return(View(character));
}
private void ListCharactersForAccount([FromSource] Player player)
{
CharacterDAO characterDAO = new CharacterDAO();
List <Character> characters = characterDAO.GetCharactersForAccount(AccountManager.GetAccount(player).Id);
IList <IList <dynamic> > charactersList = new List <IList <dynamic> >();
foreach (Character character in characters)
{
charactersList.Add(new List <dynamic> {
character.Id, character.FirstName, character.LastName
});
}
player.TriggerEvent("listCharacters", charactersList);
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
public GenericStats(CharacterDAO character)
{
m_effects.Add(EffectEnum.AddAP, new GenericEffect(EffectEnum.AddAP, character.Ap));
m_effects.Add(EffectEnum.AddMP, new GenericEffect(EffectEnum.AddMP, character.Mp));
m_effects.Add(EffectEnum.AddProspection, new GenericEffect(EffectEnum.AddProspection, ((CharacterBreedEnum)character.Breed == CharacterBreedEnum.BREED_ENUTROF ? 120 : 100)));
m_effects.Add(EffectEnum.AddPods, new GenericEffect(EffectEnum.AddPods, 1000));
m_effects.Add(EffectEnum.AddInvocationMax, new GenericEffect(EffectEnum.AddInvocationMax, 1));
m_effects.Add(EffectEnum.AddInitiative, new GenericEffect(EffectEnum.AddInitiative, 100));
m_effects.Add(EffectEnum.AddVitality, new GenericEffect(EffectEnum.AddVitality, character.Vitality));
m_effects.Add(EffectEnum.AddWisdom, new GenericEffect(EffectEnum.AddWisdom, character.Wisdom));
m_effects.Add(EffectEnum.AddStrength, new GenericEffect(EffectEnum.AddStrength, character.Strength));
m_effects.Add(EffectEnum.AddIntelligence, new GenericEffect(EffectEnum.AddIntelligence, character.Intelligence));
m_effects.Add(EffectEnum.AddAgility, new GenericEffect(EffectEnum.AddAgility, character.Agility));
m_effects.Add(EffectEnum.AddChance, new GenericEffect(EffectEnum.AddChance, character.Chance));
}
public ActionResult SellItem(int characterId, int itemInBagId)
{
Character character = CharacterDAO.GetAllInformations(characterId);
ItemInBag itemInBag = ItemInBagDAO.Get(itemInBagId);
character.Coins += itemInBag.Item.Price;
CharacterDAO.Update(character);
itemInBag.Equipped = false;
itemInBag.Item = null;
ItemInBagDAO.Update(itemInBag);
return(RedirectToAction("Index", "Home", null));
}
private void ChangeCharacter([FromSource] Player player, int id)
{
CharacterDAO characterDAO = new CharacterDAO();
Character newCharacter = characterDAO.GetCharacterByIdAndAccountId(id, AccountManager.GetAccount(player).Id);
if (newCharacter != null)
{
playerCharacters.Remove(player.Handle);
playerCharacters.Add(player.Handle, newCharacter);
player.TriggerEvent("changedCharacter", newCharacter.Id, newCharacter.FirstName, newCharacter.LastName);
}
else
{
player.TriggerEvent("errorMessage", "Unable to change to character with id " + id.ToString());
}
}
public ActionResult AddAttributePointToAnCharacter(int characterId, int attributeInCharacterId)
{
Character character = CharacterDAO.Get(characterId);
if (character.AttributePoints > 0)
{
AttributeInCharacter attributeInCharacter = AttributeInCharacterDAO.Get(attributeInCharacterId);
attributeInCharacter.ProficiencyPoints++;
character.AttributePoints--;
CharacterDAO.Update(character);
AttributeInCharacterDAO.Update(attributeInCharacter);
}
return(RedirectToAction("Index", "Home", null));
}
private void Awake()
{
this.DatabaseName = "GameCode.db";
this.isCopyDataBaseMode = false;
WeaponDAO = new WeaponDAO(this);
CharacterDAO = new CharacterDAO(this);
try
{
base.Awake();
}
catch (Exception e)
{
Debug.LogError(e.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
/// <param name="record"></param>
private void CharacterCreateExecute(WorldClient client, CharacterDAO record)
{
if (CharacterRepository.Instance.GetByName(record.Name) != null)
{
client.Send(WorldMessage.CHARACTER_CREATION_ERROR_NAME_ALREADY_EXISTS());
return;
}
CharacterRepository.Instance.Insert(record);
client.Characters.Add(record);
WorldService.Instance.AddMessage(() =>
{
client.Send(WorldMessage.CHARACTER_CREATION_SUCCESS());
client.Send(WorldMessage.CHARACTER_LIST(client.Characters));
});
}
public ActionResult IsCharacterEnvolved()
{
Character character = CharacterDAO.Get(Convert.ToInt32(SessionManager.GetCharacterId()));
if (character.Experience >= character.Level * 10)
{
character.Level += 1;
character.Experience = 0;
character.Coins += 10;
character.LifePoints += 5;
character.AttributePoints += 1;
CharacterDAO.Update(character);
FlashMessage.Confirmation("Evolução ", "Parabéns, você passou de level!!!");
return(RedirectToAction("Index", "Home"));
}
FlashMessage.Confirmation(":) ", "Parabéns, você ganhou esse duelo!!!");
return(RedirectToAction("Ranking", "Home"));
}
void CharacterTest(MySqlConnection connection)
{
List <Character> characters = new List <Character>();
characters.Add(new Character(2, "Dan the awesome", "male", 3));
CharacterDAO.InsertCharacters(connection, characters);
List <Character> characters2 = CharacterDAO.GetCharacters(connection);
characters2[1].Title = "Dan";
CharacterDAO.UpdateCharacters(connection, characters2);
characters2 = CharacterDAO.GetCharacters(connection);
CharacterDAO.DeleteCharacters(connection, characters);
characters2 = CharacterDAO.GetCharacters(connection);
}
/// <summary>
///
/// </summary>
/// <param name="account"></param>
/// <param name="characterDAO"></param>
/// <returns></returns>
public CharacterEntity CreateCharacter(AccountTicket account, CharacterDAO characterDAO)
{
// Uniquement 1 marchant par compte par serveur
var merchant = GetMerchantByAccount(characterDAO.AccountId);
if (merchant != null)
{
RemoveMerchant(merchant);
}
var character = new CharacterEntity(account, characterDAO);
m_characterById.Add(character.Id, character);
m_characterByName.Add(character.Name.ToLower(), character);
m_characterByAccount.Add(character.AccountId, character);
m_characterByNickname.Add(account.Pseudo.ToLower(), character);
OnlinePlayers++;
Logger.Info("EntityManager online players : " + OnlinePlayers);
return(character);
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
/// <param name="character"></param>
public void CharacterSelectExecute(WorldClient client, CharacterDAO character)
{
client.FrameManager.RemoveFrame(CharacterSelectionFrame.Instance);
client.CurrentCharacter = EntityManager.Instance.CreateCharacter(client.Account, character);
WorldService.Instance.AddUpdatable(client.CurrentCharacter);
client.CurrentCharacter.AddMessage(() =>
{
client.CurrentCharacter.FrameManager.AddFrame(QuestFrame.Instance);
client.CurrentCharacter.FrameManager.AddFrame(BasicFrame.Instance);
client.CurrentCharacter.FrameManager.AddFrame(SocialFrame.Instance);
client.CurrentCharacter.FrameManager.AddFrame(SpellFrame.Instance);
client.CurrentCharacter.FrameManager.AddFrame(GameCreationFrame.Instance);
CharacterConnectSend(client);
client.Account.LastConnectionTime = DateTime.Now;
client.Account.LastConnectionIP = client.Ip;
});
}
private void VerifyAuth()
{
GameAuthorizationPacket gap = (GameAuthorizationPacket)ReadPacket(new GameAuthorizationPacket());
_log.Info(gap.Username);
_log.Info(gap.SessionID.ToString(CultureInfo.InvariantCulture));
if (AuthService.CheckSession(gap.Username, gap.SessionID))
{
AccountName = gap.Username;
AuthService.SendSessionAction(gap.Username, SessionAction.Login);
//TODO Save characters in class
CharacterDAO chrMgr = new CharacterDAO(Server.ServerInstance.Database);
AccountDAO accMgr = new AccountDAO(Server.ServerInstance.Database);
int accountID = accMgr.GetAccountID(gap.Username);
CharacterListPacket clp = new CharacterListPacket(chrMgr.GetCharactersByAccount(accountID),
accMgr.GetAccountEmpire(accountID));
SendPacket(clp);
}
else
{
Disconnect("Invalid session");
}
}
public ActionResult Ranking()
{
return(View(CharacterDAO.GetAll()));
}
/// <summary>
///
/// </summary>
/// <param name="guild"></param>
/// <param name="character"></param>
public GuildMember(GuildInstance guild, CharacterDAO character)
{
m_character = character;
TaxCollectorJoinedId = -1;
Guild = guild;
}
/// <summary>
///
/// </summary>
/// <param name="power"></param>
/// <param name="characterDAO"></param>
public MerchantEntity(CharacterDAO characterDAO)
: base(null, characterDAO, EntityTypeEnum.TYPE_MERCHANT)
{
Buyers = new List<CharacterEntity>();
}
/// <summary>
///
/// </summary>
/// <param name="power"></param>
/// <param name="characterDAO"></param>
public MerchantEntity(CharacterDAO characterDAO)
: base(null, characterDAO, EntityTypeEnum.TYPE_MERCHANT)
{
Buyers = new List <CharacterEntity>();
}
/// <summary>
///
/// </summary>
/// <param name="guild"></param>
/// <param name="character"></param>
public GuildMember(GuildInstance guild, CharacterDAO character)
{
m_character = character;
TaxCollectorJoinedId = -1;
Guild = guild;
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
/// <param name="message"></param>
private void HandleCharacterCreate(WorldClient client, string message)
{
if (client.Characters == null)
{
client.Send(WorldMessage.CHARACTER_CREATION_ERROR());
return;
}
var infos = message.Substring(2).Split('|');
if (infos.Length < 6)
{
client.Send(WorldMessage.CHARACTER_CREATION_ERROR());
return;
}
var name = infos[0];
byte breed = 0;
if (!byte.TryParse(infos[1], out breed))
{
client.Send(WorldMessage.CHARACTER_CREATION_ERROR());
return;
}
bool sex = infos[2] == "1";
var color1 = -1;
if (!int.TryParse(infos[3], out color1))
{
client.Send(WorldMessage.CHARACTER_CREATION_ERROR());
return;
}
var color2 = -1;
if (!int.TryParse(infos[4], out color2))
{
client.Send(WorldMessage.CHARACTER_CREATION_ERROR());
return;
}
var color3 = -1;
if (!int.TryParse(infos[5], out color3))
{
client.Send(WorldMessage.CHARACTER_CREATION_ERROR());
return;
}
if (client.Characters.Count > 4)
{
client.Send(WorldMessage.CHARACTER_CREATION_ERROR_FULL());
return;
}
if (!Enum.IsDefined(typeof(CharacterBreedEnum), breed))
{
client.Send(WorldMessage.CHARACTER_CREATION_ERROR());
return;
}
if (color1 < -1 || color2 < -1 || color3 < -1)
{
client.Send(WorldMessage.CHARACTER_CREATION_ERROR());
return;
}
WorldService.Instance.AddMessage(() =>
{
var character = new CharacterDAO()
{
Id = CharacterRepository.Instance.NextCharacterId,
// global
AccountId = client.Account.Id,
Name = name,
Experience = 0,
Level = WorldConfig.CHARACTER_CREATION_LEVEL,
MaxLevel = WorldConfig.CHARACTER_CREATION_LEVEL,
// stats
Ap = WorldConfig.CHARACTER_CREATION_AP,
Mp = WorldConfig.CHARACTER_CREATION_MP,
Chance = WorldConfig.CHARACTER_CREATION_CHANCE,
Intelligence = WorldConfig.CHARACTER_CREATION_INTELLIGENCE,
Agility = WorldConfig.CHARACTER_CREATION_AGILITY,
Strength = WorldConfig.CHARACTER_CREATION_STRENGTH,
Vitality = WorldConfig.CHARACTER_CREATION_VITALITY,
Wisdom = WorldConfig.CHARACTER_CREATION_WISDOM,
CaracPoint = WorldConfig.CHARACTER_CREATION_CARACPOINT,
SpellPoint = WorldConfig.CHARACTER_CREATION_SPELLPOINT,
// emotes
EmoteCapacity = WorldConfig.CHARACTER_CREATION_EMOTE_CAPACITY,
// life status
Life = WorldConfig.CHARACTER_CREATION_LIFE,
Dead = false,
DeathCount = 0,
Energy = WorldConfig.CHARACTER_CREATION_ENERGY,
// position
MapId = WorldConfig.GetStartMap((CharacterBreedEnum)breed),
CellId = WorldConfig.GetStartCell((CharacterBreedEnum)breed),
// restricts
Restriction = (int)PlayerRestrictionEnum.RESTRICTION_NEW_CHARACTER,
// skin and color,
Breed = breed,
Color1 = color1,
Color2 = color2,
Color3 = color3,
Skin = breed * 10 + (sex ? 1 : 0),
SkinSize = 100,
Sex = sex,
TitleId = 0,
TitleParams = "",
Merchant = false,
SavedMapId = WorldConfig.GetStartMap((CharacterBreedEnum)breed),
SavedCellId = WorldConfig.GetStartCell((CharacterBreedEnum)breed),
Kamas = 0,
};
WorldService.Instance.AddMessage(() =>
{
CharacterCreateExecute(client, character);
});
});
}
public CharacterController()
{
requestCode = RequestCode.Character;
mCharacter = new CharacterDAO();
mImgDao = new ImgDAO();
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
public GenericStats(CharacterDAO character)
{
m_effects.Add(EffectEnum.AddAP, new GenericEffect(EffectEnum.AddAP, character.Ap));
m_effects.Add(EffectEnum.AddMP, new GenericEffect(EffectEnum.AddMP, character.Mp));
m_effects.Add(EffectEnum.AddProspection, new GenericEffect(EffectEnum.AddProspection, ((CharacterBreedEnum)character.Breed == CharacterBreedEnum.BREED_ENUTROF ? 120 : 100)));
m_effects.Add(EffectEnum.AddPods, new GenericEffect(EffectEnum.AddPods, 1000));
m_effects.Add(EffectEnum.AddInvocationMax, new GenericEffect(EffectEnum.AddInvocationMax, 1));
m_effects.Add(EffectEnum.AddInitiative, new GenericEffect(EffectEnum.AddInitiative, 100));
m_effects.Add(EffectEnum.AddVitality, new GenericEffect(EffectEnum.AddVitality, character.Vitality));
m_effects.Add(EffectEnum.AddWisdom, new GenericEffect(EffectEnum.AddWisdom, character.Wisdom));
m_effects.Add(EffectEnum.AddStrength, new GenericEffect(EffectEnum.AddStrength, character.Strength));
m_effects.Add(EffectEnum.AddIntelligence, new GenericEffect(EffectEnum.AddIntelligence, character.Intelligence));
m_effects.Add(EffectEnum.AddAgility, new GenericEffect(EffectEnum.AddAgility, character.Agility));
m_effects.Add(EffectEnum.AddChance, new GenericEffect(EffectEnum.AddChance, character.Chance));
}
/// <summary>
///
/// </summary>
/// <param name="account"></param>
/// <param name="characterDAO"></param>
/// <param name="type"></param>
public CharacterEntity(AccountTicket account, CharacterDAO characterDAO, EntityTypeEnum type = EntityTypeEnum.TYPE_CHARACTER)
: base(type, characterDAO.Id)
{
m_lastRegenTime = -1;
m_lastEmoteId = -1;
Away = false;
DatabaseRecord = characterDAO;
Alignment = characterDAO.Alignment;
Account = account;
PartyId = -1;
PartyInvitedPlayerId = -1;
PartyInviterPlayerId = -1;
GuildInvitedPlayerId = -1;
GuildInviterPlayerId = -1;
NotifyOnFriendConnection = true;
Quests = new List<CharacterQuest>(characterDAO.Quests.Select(record => new CharacterQuest(this, record)));
CharacterJobs = new JobBook(this);
Statistics = new GenericStats(characterDAO);
SpellBook = SpellBookFactory.Instance.Create(this);
Waypoints = CharacterWaypointRepository.Instance.GetByCharacterId(Id);
FrameManager = new FrameManager<CharacterEntity, string>(this);
Inventory = new CharacterInventory(this);
Bank = BankManager.Instance.GetBankByAccountId(AccountId);
PersonalShop = new PersistentInventory((int)EntityTypeEnum.TYPE_MERCHANT, Id);
Relations = SocialRelationRepository.Instance.GetByAccountId(AccountId);
var guildMember = GuildManager.Instance.GetMember(characterDAO.Guild.GuildId, Id);
if (guildMember != null)
if (type == EntityTypeEnum.TYPE_CHARACTER)
guildMember.CharacterConnected(this);
else
SetCharacterGuild(guildMember); // Merchant
SetChatChannel(ChatChannelEnum.CHANNEL_GUILD, () => DispatchGuildMessage);
SetChatChannel(ChatChannelEnum.CHANNEL_GROUP, () => DispatchPartyMessage);
RefreshPersonalShopTaxe();
CheckRestrictions();
LoadEquippedMount();
}
internal static Character Create(string accountName, CharacterCreatePacket characterCreatePacket)
{
CharacterDAO chrMgr = new CharacterDAO(Server.ServerInstance.Database);
return(chrMgr.CreateNewCharacter(characterCreatePacket, accountName)); // Cosa fare con OnCreate()?
}
