/// <summary>
///
/// </summary>
/// <param name="attacker"></param>
/// <param name="defender"></param>
public GameChallengeRequestAction(CharacterEntity attacker, CharacterEntity defender)
: base(GameActionTypeEnum.CHALLENGE_REQUEST, attacker)
{
Attacker = attacker;
Defender = defender;
Attacker.Map.Dispatch(WorldMessage.GAME_ACTION(GameActionTypeEnum.CHALLENGE_REQUEST, Attacker.Id, SerializeAs_GameAction()));
}
/// <summary>
///
/// </summary>
private void ReleasePlayer(CharacterEntity character)
{
if (!character.IsGhost)
return;
character.Reborn();
}
/// <summary>
///
/// </summary>
public MonsterFight(MapInstance map, long id, CharacterEntity character, MonsterGroupEntity monsterGroup)
: base(FightTypeEnum.TYPE_PVM,
map,
id,
character.Id,
-1,
character.CellId,
monsterGroup.Id,
-1,
monsterGroup.CellId,
WorldConfig.PVM_START_TIMEOUT,
WorldConfig.PVM_TURN_TIME,
false,
false,
new LootMonsterBehavior())
{
Character = character;
MonsterGroup = monsterGroup;
JoinFight(Character, Team0);
foreach(var monster in monsterGroup.Monsters)
JoinFight(monster, Team1);
foreach (var challenge in ChallengeManager.Instance.Generate(WorldConfig.PVM_CHALLENGE_COUNT))
Team0.AddChallenge(challenge);
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="merchant"></param>
public GameMerchantExchangeAction(CharacterEntity character, MerchantEntity merchant)
: base(new MerchantExchange(character, merchant), character, merchant)
{
Merchant = merchant;
Character = character;
Merchant.Buyers.Add(Character);
}
/// <summary>
///
/// </summary>
/// <param name="map"></param>
/// <param name="id"></param>
/// <param name="aggressor"></param>
/// <param name="victim"></param>
public AlignmentFight(MapInstance map, long id, AbstractFighter aggressor, CharacterEntity victim)
: base(FightTypeEnum.TYPE_AGGRESSION, map, id, aggressor.Id, aggressor.AlignmentId, aggressor.CellId, victim.Id, victim.AlignmentId, victim.CellId, WorldConfig.AGGRESSION_START_TIMEOUT, WorldConfig.AGGRESSION_TURN_TIME, false, true, new HonorGainBehavior())
{
IsNeutralAgression = victim.AlignmentId == (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL;
JoinFight(aggressor, Team0);
JoinFight(victim, Team1);
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="npc"></param>
public NpcExchange(CharacterEntity character, NonPlayerCharacterEntity npc)
: base(ExchangeTypeEnum.EXCHANGE_NPC, character, npc)
{
m_templateQuantity = new Dictionary<int, long>();
Character = character;
Npc = npc;
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="skill"></param>
public override void UseWithSkill(CharacterEntity character, JobSkill skill)
{
switch(skill.Id)
{
case SkillIdEnum.SKILL_USE_PHOENIX:
ReleasePlayer(character);
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="master"></param>
/// <param name="member"></param>
public PartyInstance(long id, CharacterEntity master, CharacterEntity member)
{
Id = id;
m_memberById = new Dictionary<long, CharacterEntity>();
m_leader = master;
AddMember(master);
AddMember(member);
}
/// <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>
/// <param name="skill"></param>
public override void UseWithSkill(CharacterEntity character, JobSkill skill)
{
switch(skill.Id)
{
case SkillIdEnum.SKILL_FOUILLER:
StartUse(character);
break;
}
}
/// <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>
public JobBook(CharacterEntity character)
{
Jobs = CharacterJobRepository.Instance.GetByCharacterId(character.Id);
m_character = character;
// JOB BASE, GOT YA
AddJob(JobIdEnum.JOB_BASE);
base.AddHandler(character.Dispatch);
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="skill"></param>
/// <param name="type"></param>
public CraftPlanExchange(CharacterEntity character, CraftPlan plan, JobSkill skill, ExchangeTypeEnum type = ExchangeTypeEnum.EXCHANGE_CRAFTPLAN)
: base(type)
{
m_caseItems = new Dictionary<long, int>();
m_templateQuantity = new Dictionary<int, long>();
m_plan = plan;
Character = character;
Skill = (CraftSkill)skill;
Job = Character.CharacterJobs.GetJob(skill.Id);
MaxCase = Job.CraftMaxCase;
}
/// <summary>
///
/// </summary>
/// <param name="map"></param>
/// <param name="id"></param>
/// <param name="monsters"></param>
/// <param name="victim"></param>
public AlignmentFight(MapInstance map, long id, MonsterGroupEntity monsters, CharacterEntity victim)
: base(FightTypeEnum.TYPE_AGGRESSION, map, id, monsters.Id, monsters.AlignmentId, monsters.CellId, victim.Id, victim.AlignmentId, victim.CellId, WorldConfig.AGGRESSION_START_TIMEOUT, WorldConfig.AGGRESSION_TURN_TIME, false, true)
{
IsNeutralAgression = victim.AlignmentId == (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL;
Monsters = monsters;
foreach (var monster in monsters.Monsters)
JoinFight(monster, Team0);
JoinFight(victim, Team1);
}
/// <summary>
///
/// </summary>
public TaxCollectorFight(MapInstance map, long id, CharacterEntity attacker, TaxCollectorEntity taxCollector)
: base(FightTypeEnum.TYPE_PVT, map, id, attacker.Id, 0, attacker.CellId, taxCollector.Id, 0, taxCollector.CellId, WorldConfig.PVT_START_TIMEOUT, WorldConfig.PVT_TURN_TIME)
{
CanDefend = true;
Attacker = attacker;
TaxCollector = taxCollector;
JoinFight(Attacker, Team0);
JoinFight(TaxCollector, Team1);
AddTimer(WorldConfig.PVT_TELEPORT_DEFENDERS_TIMEOUT, TeleportDefenders, true);
}
/// <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="member"></param>
public void AddMember(CharacterEntity member)
{
// new player just joined
Dispatch(WorldMessage.PARTY_MEMBER_LIST(member));
m_memberById.Add(member.Id, member);
AddHandler(member.SafeDispatch);
// set party and send members list
member.PartyId = Id;
member.SafeDispatch(WorldMessage.PARTY_CREATE_SUCCESS(m_leader.Name));
member.SafeDispatch(WorldMessage.PARTY_SET_LEADER(m_leader.Id));
member.SafeDispatch(WorldMessage.PARTY_MEMBER_LIST(m_memberById.Values.ToArray()));
}
/// <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>
/// <param name="skill"></param>
public override void UseWithSkill(CharacterEntity character, JobSkill skill)
{
switch(skill.Id)
{
case SkillIdEnum.SKILL_SCIER:
case SkillIdEnum.SKILL_COUDRE_UN_CHAPEAU:
case SkillIdEnum.SKILL_COUDRE_UNE_CAPE:
case SkillIdEnum.SKILL_CONFECTIONNER_UNE_CEINTURE:
case SkillIdEnum.SKILL_CONFECTIONNER_DES_BOTTES:
case SkillIdEnum.SKILL_CREER_UN_ANNEAU:
case SkillIdEnum.SKILL_CREER_UNE_AMULETTE:
case SkillIdEnum.SKILL_FORGER_UN_BOUCLIER:
case SkillIdEnum.SKILL_FORGER_UNE_DAGUE:
case SkillIdEnum.SKILL_FORGER_UNE_HACHE:
case SkillIdEnum.SKILL_SCULPTER_UN_ARC:
case SkillIdEnum.SKILL_SCULPTER_UNE_BAGUETTE:
case SkillIdEnum.SKILL_SCULPTER_UN_BATON:
case SkillIdEnum.SKILL_FORGER_UN_MARTEAU:
case SkillIdEnum.SKILL_FORGER_UNE_FAUX:
case SkillIdEnum.SKILL_FORGER_UNE_PIOCHE:
case SkillIdEnum.SKILL_FORGER_UNE_EPEE:
case SkillIdEnum.SKILL_COUDRE_UN_SAC:
case SkillIdEnum.SKILL_FORGER_UNE_PELLE:
case SkillIdEnum.SKILL_CUIRE_DU_PAIN:
case SkillIdEnum.SKILL_EGRENER:
case SkillIdEnum.SKILL_MOUDRE:
case SkillIdEnum.SKILL_FONDRE:
case SkillIdEnum.SKILL_POLIR_UNE_PIERRE:
case SkillIdEnum.SKILL_PREPARER_UN_POISSON:
case SkillIdEnum.SKILL_PREPARER_UNE_POTION:
case SkillIdEnum.SKILL_PREPARER_UNE_VIANDE:
case SkillIdEnum.SKILL_CONFECTIONNER_UNE_CLEF:
case SkillIdEnum.SKILL_BRICOLER:
case SkillIdEnum.SKILL_PREPARER:
case SkillIdEnum.SKILL_VIDER_POISSON:
Craft(character, skill);
break;
}
}
/// <summary>
///
/// </summary>
public ChallengerFight(MapInstance map, long id, CharacterEntity attacker, CharacterEntity defender)
: base(FightTypeEnum.TYPE_CHALLENGE,
map,
id,
attacker.Id,
0,
attacker.CellId,
defender.Id,
0,
defender.CellId,
WorldConfig.PVP_START_TIMEOUT,
WorldConfig.PVP_TURN_TIME,
true,
false,
new RegenerateLosersBehavior(),
new RegenerateWinnersBehavior())
{
Attacker = attacker;
Defender = defender;
JoinFight(Attacker, Team0);
JoinFight(Defender, Team1);
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="npc"></param>
public GameAuctionHouseSellAction(CharacterEntity character, NonPlayerCharacterEntity npc)
: base(new AuctionHouseSellExchange(character, npc), character, npc)
{
}
/// <summary>
///
/// </summary>
/// <param name="defender"></param>
public void ChallengePlayer(CharacterEntity player)
{
CurrentAction = new GameChallengeRequestAction(this, player);
player.CurrentAction = CurrentAction;
StartAction(GameActionTypeEnum.CHALLENGE_REQUEST);
player.StartAction(GameActionTypeEnum.CHALLENGE_REQUEST);
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="skill"></param>
public override void UseWithSkill(CharacterEntity character, JobSkill skill)
{
if (m_paddock == null)
{
base.UseWithSkill(character, skill);
}
else
{
switch (skill.Id)
{
case SkillIdEnum.SKILL_ACCEDER:
Access(character);
break;
case SkillIdEnum.SKILL_ACHETER_ENCLOS:
Buy(character);
break;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="channel"></param>
/// <param name="message"></param>
/// <param name="whispedCharacter"></param>
public override bool DispatchChatMessage(ChatChannelEnum channel, string message, CharacterEntity whispedCharacter = null)
{
if(channel == ChatChannelEnum.CHANNEL_PRIVATE_SEND)
{
if(whispedCharacter.Away || whispedCharacter.HasEnnemy(Pseudo))
{
Dispatch(WorldMessage.IM_ERROR_MESSAGE(InformationEnum.ERROR_PLAYER_AWAY_MESSAGE, whispedCharacter.Name));
return false;
}
if(Away)
{
Dispatch(WorldMessage.IM_INFO_MESSAGE(InformationEnum.INFO_YOU_ARE_AWAY_PLAYERS_CANT_RESPOND));
}
}
return base.DispatchChatMessage(channel, message, whispedCharacter);
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <param name="id"></param>
/// <param name="level"></param>
/// <returns></returns>
public JobSkill GetSkill(CharacterEntity character, int id, int level)
{
return m_skills.Find(skill => (int)skill.Id == id && skill.Usable(character, level));
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public bool HasSkill(CharacterEntity character, SkillIdEnum id, int level)
{
return HasSkill(character, (int)id, level);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public bool HasSkill(CharacterEntity character, int id, int level)
{
return m_skills.Any(skill => (int)skill.Id == id && skill.Usable(character, level));
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
public void ExchangePlayer(CharacterEntity player)
{
CurrentAction = new GamePlayerExchangeAction(this, player);
player.CurrentAction = CurrentAction;
}
/// <summary>
///
/// </summary>
/// <param name="character"></param>
/// <returns></returns>
public override bool CanJoin(CharacterEntity character)
{
return true;
}
