/// <summary>
///
/// </summary>
/// <returns></returns>
public bool CanStartFight(CharacterEntity character)
{
if (m_map.FightTeam0Cells.Count == 0 || m_map.FightTeam1Cells.Count == 0)
{
character.Dispatch(WorldMessage.SERVER_ERROR_MESSAGE("Unable to start fight withouth fightCells"));
return false;
}
return true;
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
public void StartUse(CharacterEntity character)
{
if(!character.CanGameAction(GameActionTypeEnum.EXCHANGE))
{
character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.ERROR, InformationEnum.ERROR_YOU_ARE_AWAY));
return;
}
character.ExchangeStorage(m_storage);
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
public void Buy(CharacterEntity character)
{
if (m_paddock.OnSale)
{
}
else
{
// Trying to buy a public or already owned paddock, cheating for sure :)))
character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
Logger.Info("PaddockDoor::Buy() trying to buy a free or already owned paddock " + character.Name);
}
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
public void Access(CharacterEntity character)
{
if (m_paddock.Public)
{
character.ExchangePaddock(m_paddock);
}
else if (!m_paddock.OnSale)
{
// TODO : if in the same guild and has enough rights
}
else
{
// Trying to access to an in sale paddock, almost cheating no ?
character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
}
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="skill"></param>
public override void UseWithSkill(CharacterEntity character, JobSkill skill)
{
if (!character.Waypoints.Any(waypoint => waypoint.MapId == Map.Id))
{
CharacterWaypointRepository.Instance.Create(character.Id, Map.Id);
character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.INFO, InformationEnum.INFO_WAYPOINT_REGISTERED));
}
switch(skill.Id)
{
case SkillIdEnum.SKILL_SAUVEGARDER:
Save(character);
break;
case SkillIdEnum.SKILL_UTILISER_ZAAP:
Use(character);
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
public void Save(CharacterEntity character)
{
character.SavedMapId = Map.Id;
character.SavedCellId = character.CellId;
character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.INFO, InformationEnum.INFO_WAYPOINT_SAVED));
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <returns></returns>
public bool CanJoinBeforeStart(CharacterEntity character)
{
if (LeaderId < 0 && AlignmentId == -1) // cant join taxcollector or monsters
return false;
// No more fighter accepted
if (FreePlace == null || IsOptionLocked(FightOptionTypeEnum.TYPE_NEW_PLAYER_BIS))
{
character.Dispatch(WorldMessage.GAME_ACTION(GameActionTypeEnum.FIGHT_JOIN, character.Id, "f"));
return false;
}
if (IsOptionLocked(FightOptionTypeEnum.TYPE_PARTY) && character.PartyId != ((CharacterEntity)m_fighters[0]).PartyId)
{
character.Dispatch(WorldMessage.GAME_ACTION(GameActionTypeEnum.FIGHT_JOIN, character.Id, "f"));
return false;
}
// no more place
if(FreePlace == null)
{
character.Dispatch(WorldMessage.GAME_ACTION(GameActionTypeEnum.FIGHT_JOIN, character.Id, "c")); // FULL
return false;
}
switch(Fight.Type)
{
case FightTypeEnum.TYPE_PVT:
var taxCollector = OpponentTeam.Fighters[0] as TaxCollectorEntity;
if (taxCollector == null)
return false;
if(character.GuildMember != null && character.GuildMember.GuildId == taxCollector.Guild.Id)
{
character.Dispatch(WorldMessage.SERVER_ERROR_MESSAGE("You can't take part in a fight against your own TaxCollector."));
return false;
}
break;
case FightTypeEnum.TYPE_PVM:
case FightTypeEnum.TYPE_AGGRESSION:
return AlignmentId <= (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL || character.AlignmentId == AlignmentId;
}
return true;
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="skill"></param>
private void Harvest(CharacterEntity character, SkillIdEnum skill)
{
if(!character.CanGameAction(GameActionTypeEnum.SKILL_HARVEST))
{
character.Dispatch(WorldMessage.IM_ERROR_MESSAGE(InformationEnum.ERROR_YOU_ARE_AWAY));
return;
}
if (!IsActive)
return;
m_currentJob = character.CharacterJobs.GetJob(skill);
if (m_currentJob == null)
return;
var duration = m_currentJob.HarvestDuration;
m_quantityFarmed = Util.Next(m_currentJob.HarvestMinQuantity, m_currentJob.HarvestMaxQuantity);
character.HarvestStart(this, duration);
m_currentHarvester = character;
Deactivate();
m_harvestTimer = base.AddTimer(duration, StopHarvest, true);
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="categoryId"></param>
/// <param name="floorId"></param>
/// <param name="price"></param>
public void TryBuy(CharacterEntity character, int categoryId, int floorId, long price)
{
Logger.Debug("AuctionHouse::TryBuy categoryId=" + categoryId + " floorId=" + floorId + " price=" + price);
if(price < 1)
{
character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
return;
}
if(character.Inventory.Kamas < price)
{
character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.ERROR, InformationEnum.ERROR_NOT_ENOUGH_KAMAS));
return;
}
if(!m_categoryById.ContainsKey(categoryId))
{
character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
return;
}
var category = m_categoryById[categoryId];
var floor = GetFloorById(floorId);
if(floor == AuctionCategoryFloorEnum.INVALID)
{
character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
return;
}
var auction = category.FirstOrDefault(floor);
switch (category.Buy(character, floor, price))
{
case AuctionBuyResultEnum.ALREADY_SOLD:
character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.INFO, InformationEnum.INFO_ITEM_ALREADY_SOLD));
SendCategoriesByTemplate(character, category.TemplateId);
break;
case AuctionBuyResultEnum.NOT_ENOUGH_KAMAS:
character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.ERROR, InformationEnum.ERROR_NOT_ENOUGH_KAMAS));
break;
case AuctionBuyResultEnum.SUCCES:
m_auctionsByAccount[auction.OwnerId].Remove(auction);
if (!CheckEmptyCategory(category))
{
SendCategoriesByTemplate(character, category.TemplateId);
}
UpdateMiddlePrice(category.TemplateId);
character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.INFO, InformationEnum.INFO_AUCTION_LOT_BOUGHT));
WorldService.Instance.AddMessage(() =>
{
auction.OwnerBank.AddKamas(price);
// check if player online and notify
var seller = EntityManager.Instance.GetCharacterByAccount(auction.OwnerId);
if (seller != null)
{
seller.AddMessage(() =>
{
seller.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.INFO, InformationEnum.INFO_AUCTION_BANK_CREDITED, price, auction.Item.TemplateId));
if (seller.HasGameAction(GameActionTypeEnum.EXCHANGE))
{
var action = seller.CurrentAction as GameAuctionHouseSellAction;
if (action != null)
{
if (action.AuctionExchange.Npc.AuctionHouse.Id == Id)
{
action.AuctionExchange.Npc.AuctionHouse.SendAuctionOwnerList(seller);
}
}
}
});
}
});
break;
default:
character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
public void SendTemplatesByTypeList(CharacterEntity character, int type)
{
var templates = new List<int>();
if(m_templatesByType.ContainsKey(type))
templates.AddRange(m_templatesByType[type]);
character.Dispatch(WorldMessage.AUCTION_HOUSE_TEMPLATE_LIST(type, templates));
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="templateId"></param>
public void SendCategoriesByTemplate(CharacterEntity character, int templateId)
{
var categories = new List<AuctionCategory>();
if (m_categoriesByTemplate.ContainsKey(templateId))
categories.AddRange(m_categoriesByTemplate[templateId]);
character.Dispatch(WorldMessage.AUCTION_HOUSE_AUCTION_LIST(templateId, categories));
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
public void SendAuctionOwnerList(CharacterEntity character)
{
if (!m_auctionsByAccount.ContainsKey(character.AccountId))
m_auctionsByAccount.Add(character.AccountId, new List<AuctionEntry>());
character.Dispatch(WorldMessage.AUCTION_HOUSE_AUCTION_OWNER_LIST(m_auctionsByAccount[character.AccountId]));
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
public void TrySpectate(CharacterEntity character)
{
AddMessage(() =>
{
if (LoopState == FightLoopStateEnum.STATE_WAIT_END || LoopState == FightLoopStateEnum.STATE_ENDED)
{
character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
return;
}
if (State != FightStateEnum.STATE_FIGHTING)
{
Logger.Debug("FightBase::TrySpectate cannot spectate placement " + character.Name);
character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.ERROR, InformationEnum.ERROR_FIGHT_SPECTATOR_LOCKED));
return;
}
if (!SpectatorTeam.CanJoin)
{
character.Dispatch(WorldMessage.INFORMATION_MESSAGE(InformationTypeEnum.ERROR, InformationEnum.ERROR_FIGHT_SPECTATOR_LOCKED));
return;
}
character.JoinSpectator(this);
SendFightJoinInfos(character);
});
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="teamId"></param>
public void TryJoin(CharacterEntity character, long teamId)
{
AddMessage(() =>
{
if (LoopState == FightLoopStateEnum.STATE_WAIT_END || LoopState == FightLoopStateEnum.STATE_ENDED)
{
character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
return;
}
if (State != FightStateEnum.STATE_PLACEMENT)
{
Logger.Debug("FightBase::TryJoin fight already started " + character.Name);
character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
return;
}
if (!CanJoin(character))
{
character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
return;
}
var team = teamId == Team0.LeaderId ? Team0 : Team1;
if (!team.CanJoinBeforeStart(character))
{
Logger.Debug("FightBase::TryJoin cannot join team before start " + character.Name);
character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
return;
}
JoinFight(character, team);
});
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="skillId"></param>
public virtual void UseWithSkill(CharacterEntity character, JobSkill skill)
{
character.Dispatch(WorldMessage.SERVER_INFO_MESSAGE("Interactive object not yet implemented."));
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="kick"></param>
/// <returns></returns>
public override FightActionResultEnum FightQuit(CharacterEntity character, bool kick = false)
{
if (LoopState == FightLoopStateEnum.STATE_WAIT_END || LoopState == FightLoopStateEnum.STATE_ENDED)
return FightActionResultEnum.RESULT_NOTHING;
switch (State)
{
case FightStateEnum.STATE_PLACEMENT:
if (kick)
{
character.Fight.Dispatch(WorldMessage.FIGHT_FLAG_UPDATE(OperatorEnum.OPERATOR_REMOVE, character.Team.LeaderId, character));
character.Fight.Dispatch(WorldMessage.GAME_MAP_INFORMATIONS(OperatorEnum.OPERATOR_REMOVE, character));
character.EndFight(true);
character.Dispatch(WorldMessage.FIGHT_LEAVE());
return FightActionResultEnum.RESULT_NOTHING;
}
if (TryKillFighter(character, character, true, true) != FightActionResultEnum.RESULT_END)
{
character.EndFight();
character.Dispatch(WorldMessage.FIGHT_LEAVE());
return FightActionResultEnum.RESULT_DEATH;
}
return FightActionResultEnum.RESULT_END;
case FightStateEnum.STATE_FIGHTING:
if (character.IsSpectating)
{
character.EndFight(kick);
character.Dispatch(WorldMessage.FIGHT_LEAVE());
return FightActionResultEnum.RESULT_NOTHING;
}
if (TryKillFighter(character, character, true, true) != FightActionResultEnum.RESULT_END)
{
Result.AddResult(character);
character.EndFight();
character.Dispatch(WorldMessage.FIGHT_LEAVE());
return FightActionResultEnum.RESULT_DEATH;
}
return FightActionResultEnum.RESULT_END;
}
return FightActionResultEnum.RESULT_NOTHING;
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="itemId"></param>
public void TryRemove(CharacterEntity character, long itemId)
{
Logger.Debug("AuctionHouse::TryRemove itemId=" + itemId);
if(!m_auctionsByAccount.ContainsKey(character.AccountId))
{
character.Dispatch(WorldMessage.OBJECT_MOVE_ERROR());
return;
}
var auction = m_auctionsByAccount[character.AccountId].Find(entry => entry.ItemId == itemId);
if(auction == null)
{
character.Dispatch(WorldMessage.OBJECT_MOVE_ERROR());
return;
}
m_auctionsByAccount[character.AccountId].Remove(auction);
AuctionCategory category = null;
int i = 0;
var categories = m_categoriesByTemplate[auction.Item.TemplateId];
while(i < categories.Count && category == null)
{
var current = categories[i];
if(current.Remove(auction))
category = current;
}
CheckEmptyCategory(category);
UpdateMiddlePrice(category.TemplateId);
auction.Remove();
character.Inventory.AddItem(auction.Item);
SendAuctionOwnerList(character);
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="monsterGroup"></param>
public bool StartMonsterFight(CharacterEntity character, MonsterGroupEntity monsterGroup)
{
if (!CanStartFight(character))
return false;
if (!character.CanGameAction(GameActionTypeEnum.FIGHT))
{
character.Dispatch(WorldMessage.IM_ERROR_MESSAGE(InformationEnum.ERROR_YOU_ARE_AWAY));
return false;
}
monsterGroup.StopAction(GameActionTypeEnum.MAP);
Add(new MonsterFight(m_map, m_fightId++, character, monsterGroup));
return true;
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="cellId"></param>
/// <param name="skillId"></param>
public void InteractiveExecute(CharacterEntity character, int cellId, int skillId)
{
var cell = GetCell(cellId);
if(cell != null)
{
if(cell.InteractiveObject != null)
{
cell.InteractiveObject.UseWithSkill(character, character.CharacterJobs.GetSkill(skillId));
}
else
{
character.Dispatch(WorldMessage.SERVER_INFO_MESSAGE("Not implemented yet."));
}
}
}
