public static void SendArenaTeamRosterResponse(IPacketReceiver client, ArenaTeam team)
{
using (var packet = CreateArenaTeamRosterResponsePacket(team))
{
client.Send(packet);
}
}
private static RealmPacketOut CreateArenaTeamRosterResponsePacket(ArenaTeam team)
{
RealmPacketOut realmPacketOut =
new RealmPacketOut(RealmServerOpCode.SMSG_ARENA_TEAM_ROSTER, 100);
realmPacketOut.WriteUInt(team.Id);
realmPacketOut.WriteByte(0);
realmPacketOut.WriteUInt(team.MemberCount);
realmPacketOut.WriteUInt(team.Type);
foreach (ArenaTeamMember arenaTeamMember in team.Members.Values)
{
realmPacketOut.WriteULong(arenaTeamMember.Character.EntityId.Full);
Character character = World.GetCharacter(arenaTeamMember.Character.EntityId.Low);
realmPacketOut.WriteByte(character != null ? 1 : 0);
realmPacketOut.WriteCString(arenaTeamMember.Character.Name);
realmPacketOut.WriteByte(team.Leader == arenaTeamMember ? 0 : 1);
realmPacketOut.WriteByte(character != null ? character.Level : 0);
realmPacketOut.WriteUInt((uint)arenaTeamMember.Class);
realmPacketOut.WriteUInt(arenaTeamMember.GamesWeek);
realmPacketOut.WriteUInt(arenaTeamMember.WinsWeek);
realmPacketOut.WriteUInt(arenaTeamMember.GamesSeason);
realmPacketOut.WriteUInt(arenaTeamMember.WinsSeason);
realmPacketOut.WriteUInt(arenaTeamMember.PersonalRating);
realmPacketOut.WriteFloat(0.0f);
realmPacketOut.WriteFloat(0.0f);
}
return(realmPacketOut);
}
private static RealmPacketOut CreateArenaTeamRosterResponsePacket(ArenaTeam team)
{
var packet = new RealmPacketOut(RealmServerOpCode.SMSG_ARENA_TEAM_ROSTER, 100);
packet.WriteUInt(team.Id);
packet.WriteByte(0);
packet.WriteUInt(team.MemberCount);
packet.WriteUInt(team.Type);
foreach (var member in team.Members.Values)
{
packet.WriteULong(member.Character.EntityId.Full);
var pl = World.GetCharacter(member.Character.EntityId.Low);
packet.WriteByte((pl != null) ? 1 : 0);
packet.WriteCString(member.Character.Name);
packet.WriteByte((team.Leader == member) ? 0 : 1);
packet.WriteByte((pl != null) ? pl.Level : 0);
packet.WriteUInt((uint)member.Class);
packet.WriteUInt(member.GamesWeek);
packet.WriteUInt(member.WinsWeek);
packet.WriteUInt(member.GamesSeason);
packet.WriteUInt(member.WinsSeason);
packet.WriteUInt(member.PersonalRating);
packet.WriteFloat(0.0f);
packet.WriteFloat(0.0f);
}
return(packet);
}
public static void LeaveAllArenaTeams(ObjectGuid guid)
{
PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.SEL_PLAYER_ARENA_TEAMS);
stmt.AddValue(0, guid.GetCounter());
SQLResult result = DB.Characters.Query(stmt);
if (result.IsEmpty())
{
return;
}
do
{
uint arenaTeamId = result.Read <uint>(0);
if (arenaTeamId != 0)
{
ArenaTeam arenaTeam = Global.ArenaTeamMgr.GetArenaTeamById(arenaTeamId);
if (arenaTeam != null)
{
arenaTeam.DelMember(guid, true);
}
}
}while (result.NextRow());
}
public static void SendArenaTeamRosterResponse(IPacketReceiver client, ArenaTeam team)
{
using (var packet = CreateArenaTeamRosterResponsePacket(team))
{
client.Send(packet);
}
}
static bool HandleArenaInfoCommand(StringArguments args, CommandHandler handler)
{
if (args.Empty())
{
return(false);
}
uint teamId = args.NextUInt32();
if (teamId == 0)
{
return(false);
}
ArenaTeam arena = Global.ArenaTeamMgr.GetArenaTeamById(teamId);
if (arena == null)
{
handler.SendSysMessage(CypherStrings.ArenaErrorNotFound, teamId);
return(false);
}
handler.SendSysMessage(CypherStrings.ArenaInfoHeader, arena.GetName(), arena.GetId(), arena.GetRating(), arena.GetArenaType(), arena.GetArenaType());
foreach (var member in arena.GetMembers())
{
handler.SendSysMessage(CypherStrings.ArenaInfoMembers, member.Name, member.Guid, member.PersonalRating, (arena.GetCaptain() == member.Guid ? "- Captain" : ""));
}
return(true);
}
/// <summary>Sends an arena team query response to the client.</summary>
/// <param name="client">the client to send to</param>
/// <param name="team">arena team to be sent</param>
public static void SendArenaTeamQueryResponse(IPacketReceiver client, ArenaTeam team)
{
using (RealmPacketOut queryResponsePacket = CreateArenaTeamQueryResponsePacket(team))
client.Send(queryResponsePacket, false);
using (RealmPacketOut statsResponsePacket = CreateArenaTeamStatsResponsePacket(team))
client.Send(statsResponsePacket, false);
}
public static void HandleArenaTeamQuery(IRealmClient client, RealmPacketIn packet)
{
ArenaTeam arenaTeam = ArenaMgr.GetArenaTeam(packet.ReadUInt32());
if (arenaTeam == null)
{
return;
}
ArenaTeamHandler.SendArenaTeamQueryResponse((IPacketReceiver)client, arenaTeam);
}
public static void HandleArenaTeamRoster(IRealmClient client, RealmPacketIn packet)
{
ArenaTeam arenaTeam = ArenaMgr.GetArenaTeam(packet.ReadUInt32());
if (arenaTeam == null)
{
return;
}
SendArenaTeamRosterResponse(client, arenaTeam);
}
/// <summary>
/// Sends an arena team query response to the client.
/// </summary>
/// <param name="client">the client to send to</param>
/// <param name="team">arena team to be sent</param>
public static void SendArenaTeamQueryResponse(IPacketReceiver client, ArenaTeam team)
{
using (var packet = CreateArenaTeamQueryResponsePacket(team))
{
client.Send(packet, addEnd: false);
}
using (var packet = CreateArenaTeamStatsResponsePacket(team))
{
client.Send(packet, addEnd: false);
}
}
public ArenaTeamStats(ArenaTeam arenaTeam)
{
team = arenaTeam;
rating = 1500;
gamesWeek = 0;
winsWeek = 0;
gamesSeason = 0;
winsSeason = 0;
rank = 0;
}
public ArenaFight CreateArenaFight(ArenaPreFight preFight)
{
var challengersTeam = new ArenaTeam(TeamEnum.TEAM_CHALLENGER, preFight.Arena.Map.GetRedFightPlacement());
var defendersTeam = new ArenaTeam(TeamEnum.TEAM_DEFENDER, preFight.Arena.Map.GetBlueFightPlacement());
var fight = new ArenaFight(preFight.Id, preFight.Arena.Map, defendersTeam, challengersTeam);
AddEntity(fight.Id, fight);
return(fight);
}
public ArenaTeamStats(ArenaTeam arenaTeam)
{
Team = arenaTeam;
Rating = 1500;
GamesWeek = 0;
WinsWeek = 0;
GamesSeason = 0;
WinsSeason = 0;
Rank = 0;
}
public uint GetCharacterArenaTeamIdByGuid(ObjectGuid guid, byte type)
{
var characterCacheEntry = _characterCacheStore.LookupByKey(guid);
if (characterCacheEntry == null)
{
return(0);
}
return(characterCacheEntry.ArenaTeamId[ArenaTeam.GetSlotByType(type)]);
}
private static RealmPacketOut CreateArenaTeamQueryResponsePacket(ArenaTeam team)
{
RealmPacketOut realmPacketOut =
new RealmPacketOut(RealmServerOpCode.SMSG_ARENA_TEAM_QUERY_RESPONSE,
28 + team.Name.Length + 1);
realmPacketOut.WriteUInt((byte)team.Id);
realmPacketOut.WriteCString(team.Name);
realmPacketOut.WriteUInt(team.Type);
return(realmPacketOut);
}
private static RealmPacketOut CreateArenaTeamStatsResponsePacket(ArenaTeam team)
{
RealmPacketOut realmPacketOut = new RealmPacketOut(RealmServerOpCode.SMSG_ARENA_TEAM_STATS, 28);
realmPacketOut.WriteUInt((byte)team.Id);
realmPacketOut.WriteUInt(team.Stats.rating);
realmPacketOut.WriteUInt(team.Stats.gamesWeek);
realmPacketOut.WriteUInt(team.Stats.winsWeek);
realmPacketOut.WriteUInt(team.Stats.gamesSeason);
realmPacketOut.WriteUInt(team.Stats.winsSeason);
realmPacketOut.WriteUInt(team.Stats.rank);
return(realmPacketOut);
}
private static RealmPacketOut CreateArenaTeamStatsResponsePacket(ArenaTeam team)
{
var packet = new RealmPacketOut(RealmServerOpCode.SMSG_ARENA_TEAM_STATS, 4*7);
packet.WriteUInt((byte)team.Id);
packet.WriteUInt(team.Stats.rating);
packet.WriteUInt(team.Stats.gamesWeek);
packet.WriteUInt(team.Stats.winsWeek);
packet.WriteUInt(team.Stats.gamesSeason);
packet.WriteUInt(team.Stats.winsSeason);
packet.WriteUInt(team.Stats.rank);
return packet;
}
public ArenaTeamMember(CharacterRecord chr, ArenaTeam team, bool isLeader)
: this()
{
ArenaTeam = team;
CharacterLowId = (int)chr.EntityLowId;
ArenaTeamId = team.Id;
_name = chr.Name;
Class = chr.Class;
GamesWeek = 0;
WinsWeek = 0;
GamesSeason = 0;
WinsSeason = 0;
PersonalRating = 1500;
}
private ListViewItem CreateListViewItemFromTeam(ArenaTeam team)
{
var item = new ListViewItem(new string[]
{
team.Ranking.ToString(),
team.Name,
team.Realm,
team.Side,
team.SessionGamesWon.ToString(),
team.SessionGamesLost.ToString(),
team.Rating.ToString(),
});
item.Tag = team;
return(item);
}
private static RealmPacketOut CreateArenaTeamQueryResponsePacket(ArenaTeam team)
{
var packet = new RealmPacketOut(RealmServerOpCode.SMSG_ARENA_TEAM_QUERY_RESPONSE, 4*7+team.Name.Length+1);
packet.WriteUInt((byte)team.Id);
packet.WriteCString(team.Name);
packet.WriteUInt(team.Type);
/* TO-DO : Implement Emblem
* packet.WriteUInt(team.Emblem.backgroundColor);
packet.WriteUInt(team.Emblem.emblemStyle);
packet.WriteUInt(team.Emblem.emblemColor);
packet.WriteUInt(team.Emblem.borderStyle);
packet.WriteUInt(team.Emblem.borderColor);
*/
return packet;
}
private static RealmPacketOut CreateArenaTeamQueryResponsePacket(ArenaTeam team)
{
var packet = new RealmPacketOut(RealmServerOpCode.SMSG_ARENA_TEAM_QUERY_RESPONSE, 4 * 7 + team.Name.Length + 1);
packet.WriteUInt((byte)team.Id);
packet.WriteCString(team.Name);
packet.WriteUInt(team.Type);
/* TO-DO : Implement Emblem
* packet.WriteUInt(team.Emblem.backgroundColor);
* packet.WriteUInt(team.Emblem.emblemStyle);
* packet.WriteUInt(team.Emblem.emblemColor);
* packet.WriteUInt(team.Emblem.borderStyle);
* packet.WriteUInt(team.Emblem.borderColor);
*/
return(packet);
}
static bool HandleArenaDisbandCommand(StringArguments args, CommandHandler handler)
{
if (args.Empty())
{
return(false);
}
uint teamId = args.NextUInt32();
if (teamId == 0)
{
return(false);
}
ArenaTeam arena = Global.ArenaTeamMgr.GetArenaTeamById(teamId);
if (arena == null)
{
handler.SendSysMessage(CypherStrings.ArenaErrorNotFound, teamId);
return(false);
}
if (arena.IsFighting())
{
handler.SendSysMessage(CypherStrings.ArenaErrorCombat);
return(false);
}
string name = arena.GetName();
arena.Disband();
if (handler.GetSession() != null)
{
Log.outDebug(LogFilter.Arena, "GameMaster: {0} [GUID: {1}] disbanded arena team type: {2} [Id: {3}].",
handler.GetSession().GetPlayer().GetName(), handler.GetSession().GetPlayer().GetGUID().ToString(), arena.GetArenaType(), teamId);
}
else
{
Log.outDebug(LogFilter.Arena, "Console: disbanded arena team type: {0} [Id: {1}].", arena.GetArenaType(), teamId);
}
handler.SendSysMessage(CypherStrings.ArenaDisband, name, teamId);
return(true);
}
public static void LeaveAllArenaTeams(ObjectGuid guid)
{
CharacterCacheEntry characterInfo = Global.CharacterCacheStorage.GetCharacterCacheByGuid(guid);
if (characterInfo == null)
{
return;
}
for (byte i = 0; i < SharedConst.MaxArenaSlot; ++i)
{
uint arenaTeamId = characterInfo.ArenaTeamId[i];
if (arenaTeamId != 0)
{
ArenaTeam arenaTeam = Global.ArenaTeamMgr.GetArenaTeamById(arenaTeamId);
if (arenaTeam != null)
{
arenaTeam.DelMember(guid, true);
}
}
}
}
public static int DetermineMobileNotoriety(Mobile source, Mobile target, bool useVengeance)
{
BaseCreature bc_Source = source as BaseCreature;
PlayerMobile pm_Source = source as PlayerMobile;
Mobile m_SourceController = null;
BaseCreature bc_SourceController = null;
PlayerMobile pm_SourceController = null;
BaseCreature bc_Target = target as BaseCreature;
PlayerMobile pm_Target = target as PlayerMobile;
Mobile m_TargetController = null;
BaseCreature bc_TargetController = null;
PlayerMobile pm_TargetController = null;
if (bc_Source != null)
{
m_SourceController = bc_Source.ControlMaster as Mobile;
bc_SourceController = bc_Source.ControlMaster as BaseCreature;
pm_SourceController = bc_Source.ControlMaster as PlayerMobile;
}
if (bc_Target != null)
{
m_TargetController = bc_Target.ControlMaster as Mobile;
bc_TargetController = bc_Target.ControlMaster as BaseCreature;
pm_TargetController = bc_Target.ControlMaster as PlayerMobile;
}
ArenaController fromArenaController = ArenaController.GetArenaAtLocation(source.Location, source.Map);
ArenaController targetArenaController = ArenaController.GetArenaAtLocation(target.Location, target.Map);
if (fromArenaController != null && targetArenaController != null && fromArenaController == targetArenaController)
{
if (fromArenaController.m_ArenaFight != null)
{
if (fromArenaController.m_ArenaFight.m_FightPhase == ArenaFight.FightPhaseType.Fight)
{
if (fromArenaController.m_ArenaFight.m_ArenaMatch != null)
{
ArenaMatch arenaMatch = fromArenaController.m_ArenaFight.m_ArenaMatch;
if (ArenaMatch.IsValidArenaMatch(arenaMatch, null, false))
{
PlayerMobile rootPlayerFrom = null;
PlayerMobile rootPlayerTarget = null;
if (pm_Source != null)
{
rootPlayerFrom = pm_Source;
}
if (pm_Target != null)
{
rootPlayerTarget = pm_Target;
}
if (pm_SourceController != null)
{
rootPlayerFrom = pm_SourceController;
}
if (pm_TargetController != null)
{
rootPlayerTarget = pm_TargetController;
}
ArenaParticipant fromArenaParticipant = fromArenaController.m_ArenaFight.m_ArenaMatch.GetParticipant(rootPlayerFrom);
ArenaParticipant targetArenaParticipant = fromArenaController.m_ArenaFight.m_ArenaMatch.GetParticipant(rootPlayerTarget);
if (fromArenaParticipant != null && targetArenaParticipant != null)
{
if (fromArenaParticipant.m_FightStatus == ArenaParticipant.FightStatusType.Alive && targetArenaParticipant.m_FightStatus == ArenaParticipant.FightStatusType.Alive)
{
ArenaTeam fromTeam = null;
ArenaTeam targetTeam = null;
foreach (ArenaTeam team in arenaMatch.m_Teams)
{
if (team == null)
{
continue;
}
if (team.Deleted)
{
continue;
}
ArenaParticipant participant = team.GetPlayerParticipant(rootPlayerFrom);
if (participant != null)
{
fromTeam = team;
}
participant = team.GetPlayerParticipant(rootPlayerTarget);
if (participant != null)
{
targetTeam = team;
}
}
if (fromTeam != null && targetTeam != null)
{
if (fromTeam == targetTeam)
{
return(Notoriety.Ally);
}
if (fromTeam != targetTeam)
{
return(Notoriety.Enemy);
}
}
}
}
}
}
}
}
}
//Berserk Creatures
if (bc_Source != null && (source is BladeSpirits || source is EnergyVortex))
{
if (bc_Source.ControlMaster != null && pm_Target != null)
{
//Blade Spirits + Energy Vortexes Can Freely Attack Their Control Master Without Causing Criminal Action
if (bc_Source.ControlMaster == pm_Target)
{
return(Notoriety.CanBeAttacked);
}
}
if (bc_Source.ControlMaster != null && bc_Target != null)
{
//Blade Spirits + Energy Vortexes Can Freely Attack Other Followers Of Their Control Master Without Causing Criminal Action
if (bc_Source.ControlMaster == bc_Target.ControlMaster)
{
return(Notoriety.CanBeAttacked);
}
}
}
if (target is BladeSpirits || target is EnergyVortex)
{
return(Notoriety.Murderer);
}
//Staff Members Always Attackable
if (target.AccessLevel > AccessLevel.Player)
{
return(Notoriety.CanBeAttacked);
}
if (m_TargetController != null)
{
//Creature Controlled By Staff Member
if (m_TargetController.AccessLevel > AccessLevel.Player)
{
return(Notoriety.CanBeAttacked);
}
}
//Enemy of One
if (pm_Source != null && bc_Target != null)
{
if (!bc_Target.Summoned && !bc_Target.Controlled && pm_Source.EnemyOfOneType == target.GetType())
{
return(Notoriety.Enemy);
}
}
//Justice Free Zone
if (SpellHelper.InBuccs(target.Map, target.Location) || SpellHelper.InYewOrcFort(target.Map, target.Location) || SpellHelper.InYewCrypts(target.Map, target.Location))
{
return(Notoriety.CanBeAttacked);
}
//Grey Zone Totem Nearby
if (GreyZoneTotem.InGreyZoneTotemArea(target.Location, target.Map))
{
return(Notoriety.CanBeAttacked);
}
//Hotspot Nearby
if (Custom.Hotspot.InHotspotArea(target.Location, target.Map, true))
{
return(Notoriety.CanBeAttacked);
}
//Player Notoriety
if (pm_Target != null)
{
//Friendly
if (pm_SourceController != null)
{
if (pm_SourceController == pm_Target)
{
return(Notoriety.Ally);
}
}
//Murderer
if (pm_Target.Murderer && !pm_Target.HideMurdererStatus)
{
return(Notoriety.Murderer);
}
//Criminal
if (pm_Target.Criminal)
{
return(Notoriety.Criminal);
}
//Perma-Grey
if (SkillHandlers.Stealing.ClassicMode && pm_Target.PermaFlags.Contains(source))
{
return(Notoriety.CanBeAttacked);
}
if (pm_SourceController != null)
{
//Target is Perma-Grey to Source Creature's Controller
if (SkillHandlers.Stealing.ClassicMode && pm_Target.PermaFlags.Contains(pm_SourceController))
{
return(Notoriety.CanBeAttacked);
}
}
}
//Guilds
//TEST: GUILD
/*
* Guild sourceGuild = GetGuildFor(source.Guild as Guild, source);
* Guild targetGuild = GetGuildFor(target.Guild as Guild, target);
*
* if (sourceGuild != null && targetGuild != null)
* {
* if (sourceGuild == targetGuild || sourceGuild.IsAlly(targetGuild))
* return Notoriety.Ally;
*
* else if (sourceGuild.IsEnemy(targetGuild))
* return Notoriety.Enemy;
* }
*/
//Creature Notoriety
if (bc_Target != null)
{
//Friendly
if (m_TargetController != null)
{
//Target is Source's Controller
if (source == m_TargetController)
{
return(Notoriety.Ally);
}
}
if (m_SourceController != null)
{
//Source is Target's Controller
if (m_SourceController == bc_Target)
{
return(Notoriety.Ally);
}
}
//Murderer
if (bc_Target.IsMurderer())
{
return(Notoriety.Murderer);
}
if (pm_TargetController != null)
{
if (pm_TargetController.Murderer)
{
return(Notoriety.Murderer);
}
}
if (bc_TargetController != null)
{
if (bc_TargetController.IsMurderer())
{
return(Notoriety.Murderer);
}
}
//Criminal
if (bc_Target.Criminal)
{
return(Notoriety.Criminal);
}
if (pm_TargetController != null)
{
if (pm_TargetController.Criminal)
{
return(Notoriety.Criminal);
}
}
if (bc_TargetController != null)
{
if (bc_TargetController.Criminal)
{
return(Notoriety.Criminal);
}
}
//Perma-Grey
if (pm_TargetController != null)
{
if (SkillHandlers.Stealing.ClassicMode && pm_TargetController.PermaFlags.Contains(source))
{
return(Notoriety.CanBeAttacked);
}
if (pm_SourceController != null)
{
//Target is Perma-Grey to Source Creature's Controller
if (SkillHandlers.Stealing.ClassicMode && pm_TargetController.PermaFlags.Contains(pm_SourceController))
{
return(Notoriety.CanBeAttacked);
}
}
}
}
//Housing
if (CheckHouseFlag(source, target, target.Location, target.Map))
{
return(Notoriety.CanBeAttacked);
}
//Aggressor: Source to Target
if (CheckAggressor(source.Aggressors, target))
{
return(Notoriety.CanBeAttacked);
}
if (CheckAggressed(source.Aggressed, target) && useVengeance)
{
return(Notoriety.CanBeAttacked);
}
//Aggressor: Source Controller to Target
if (m_SourceController != null)
{
if (CheckAggressor(m_SourceController.Aggressors, target))
{
return(Notoriety.CanBeAttacked);
}
if (CheckAggressed(m_SourceController.Aggressed, target) && useVengeance)
{
return(Notoriety.CanBeAttacked);
}
}
//Aggressor: Source to Target's Controller
if (m_TargetController != null)
{
if (CheckAggressor(source.Aggressors, m_TargetController))
{
return(Notoriety.CanBeAttacked);
}
if (CheckAggressed(source.Aggressed, m_TargetController) && useVengeance)
{
return(Notoriety.CanBeAttacked);
}
}
//Aggressor: Source Controller to Target's Controller
if (m_SourceController != null && m_TargetController != null)
{
if (CheckAggressor(m_SourceController.Aggressors, m_TargetController))
{
return(Notoriety.CanBeAttacked);
}
if (CheckAggressed(m_SourceController.Aggressed, m_TargetController) && useVengeance)
{
return(Notoriety.CanBeAttacked);
}
}
//Player Followers: If A Player or Any of Their Followers Have been Aggressed or Barded, the Player and All Other Followers Can Attack the Aggressor
PlayerMobile pm_Player = null;
if (pm_Source != null)
{
pm_Player = pm_Source;
}
if (pm_SourceController != null)
{
pm_Player = pm_SourceController;
}
if (pm_Player != null)
{
if (pm_Player.AllFollowers.Count > 0)
{
//Any of the Player's Other Followers
foreach (Mobile follower in pm_Player.AllFollowers)
{
BaseCreature bc_Follower = follower as BaseCreature;
if (bc_Follower == null)
{
continue;
}
//Follower Has Been Aggressed/Aggresor to Target
if (CheckAggressor(bc_Follower.Aggressors, target))
{
return(Notoriety.CanBeAttacked);
}
if (CheckAggressed(bc_Follower.Aggressed, target) && useVengeance)
{
return(Notoriety.CanBeAttacked);
}
//Follower Has Been Aggressed/Aggresor by/to Target's Controller
if (m_TargetController != null)
{
if (CheckAggressor(bc_Follower.Aggressors, m_TargetController))
{
return(Notoriety.CanBeAttacked);
}
if (CheckAggressed(bc_Follower.Aggressed, m_TargetController) && useVengeance)
{
return(Notoriety.CanBeAttacked);
}
}
}
}
}
//Ships: Players and Creatures Friendly to a Ship Can Freely Attack Non-Friendly Mobiles on their Ship
BaseShip sourceShip = null;
if (bc_Source != null)
{
if (bc_Source.ShipOccupied != null)
{
sourceShip = bc_Source.ShipOccupied;
}
}
if (pm_Source != null)
{
if (pm_Source.ShipOccupied != null)
{
sourceShip = pm_Source.ShipOccupied;
}
}
if (sourceShip != null)
{
BaseShip targetShip = null;
if (bc_Target != null)
{
if (bc_Target.ShipOccupied != null)
{
targetShip = bc_Target.ShipOccupied;
}
}
if (pm_Target != null)
{
if (pm_Target.ShipOccupied != null)
{
targetShip = pm_Target.ShipOccupied;
}
}
//On Same Ship
if (sourceShip != null && targetShip != null && !sourceShip.Deleted && !targetShip.Deleted && sourceShip == targetShip)
{
bool sourceBelongs = false;
bool targetBelongs = false;
//Source Belongs n the Ship
if (sourceShip.Crew.Contains(source) || sourceShip.IsFriend(source) || sourceShip.IsCoOwner(source) || sourceShip.IsOwner(source))
{
sourceBelongs = true;
}
//Source's Owner Belongs on the Ship
else if (bc_Source != null)
{
if (m_SourceController != null)
{
if (sourceShip.Crew.Contains(m_SourceController) || sourceShip.IsFriend(m_SourceController) || sourceShip.IsCoOwner(m_SourceController) || sourceShip.IsOwner(m_SourceController))
{
sourceBelongs = true;
}
}
}
//Target Belongs On The Ship
if (sourceShip.Crew.Contains(target) || sourceShip.IsFriend(target) || sourceShip.IsCoOwner(target) || sourceShip.IsOwner(target))
{
targetBelongs = true;
}
//Target's Owner Belongs On the Ship
else if (bc_Target != null)
{
if (m_TargetController != null)
{
if (sourceShip.Crew.Contains(m_TargetController) || sourceShip.IsFriend(m_TargetController) || sourceShip.IsCoOwner(m_TargetController) || sourceShip.IsOwner(m_TargetController))
{
targetBelongs = true;
}
}
}
//Target May Be Freely Attacked on Ship
if (sourceBelongs && !targetBelongs)
{
return(Notoriety.CanBeAttacked);
}
}
}
//Polymorph or Body Transformation
if (!(bc_Target != null && bc_Target.InitialInnocent))
{
if (target.Player && target.BodyMod > 0)
{
}
else if (!target.Body.IsHuman && !target.Body.IsGhost && !IsPet(bc_Target) && !TransformationSpellHelper.UnderTransformation(target))
{
return(Notoriety.CanBeAttacked);
}
}
//If somehow a player is attacking us with their tamed creatures, and their creatures are flagged to us but the player isn't
//if (pm_Source != null && pm_Target != null)
//{
// if (pm_Target.AllFollowers.Count > 0)
// {
// //Any of the Player's Other Followers
// foreach (Mobile follower in pm_Target.AllFollowers)
// {
// int notorietyResult = Notoriety.Compute(source, follower);
// //Enemy Tamer Adopts Notoriety of Their Creature (Anything other than Innocent)
// if (notorietyResult != 1)
// {
// foreach(var aggressor in source.Aggressors)
// {
// if (aggressor.Attacker == follower)
// return notorietyResult;
// }
// }
// }
// }
//}
return(Notoriety.Innocent);
}
public static IEnumerable<ArenaTeamMember> FindAll(ArenaTeam team)
{
//TODO: Use Detatched Criteria for this -- Via method in databaseprovider
return RealmWorldDBMgr.DatabaseProvider.Session.QueryOver<ArenaTeamMember>().Where(x => x.ArenaTeamId == (int)team.Id).List();
}
static bool HandleArenaCreateCommand(StringArguments args, CommandHandler handler)
{
if (args.Empty())
{
return(false);
}
Player target;
if (!handler.extractPlayerTarget(args[0] != '"' ? args : null, out target))
{
return(false);
}
string name = handler.extractQuotedArg(args.NextString());
if (string.IsNullOrEmpty(name))
{
return(false);
}
byte type = args.NextByte();
if (type == 0)
{
return(false);
}
if (Global.ArenaTeamMgr.GetArenaTeamByName(name) != null)
{
handler.SendSysMessage(CypherStrings.ArenaErrorNameExists, name);
return(false);
}
if (type == 2 || type == 3 || type == 5)
{
if (Player.GetArenaTeamIdFromDB(target.GetGUID(), type) != 0)
{
handler.SendSysMessage(CypherStrings.ArenaErrorSize, target.GetName());
return(false);
}
ArenaTeam arena = new ArenaTeam();
if (!arena.Create(target.GetGUID(), type, name, 4293102085, 101, 4293253939, 4, 4284049911))
{
handler.SendSysMessage(CypherStrings.BadValue);
return(false);
}
Global.ArenaTeamMgr.AddArenaTeam(arena);
handler.SendSysMessage(CypherStrings.ArenaCreate, arena.GetName(), arena.GetId(), arena.GetArenaType(), arena.GetCaptain());
}
else
{
handler.SendSysMessage(CypherStrings.BadValue);
return(false);
}
return(true);
}
static bool HandleArenaCaptainCommand(StringArguments args, CommandHandler handler)
{
if (args.Empty())
{
return(false);
}
string idStr;
string nameStr;
handler.extractOptFirstArg(args, out idStr, out nameStr);
if (string.IsNullOrEmpty(idStr))
{
return(false);
}
if (!uint.TryParse(idStr, out uint teamId) || teamId == 0)
{
return(false);
}
Player target;
ObjectGuid targetGuid;
if (!handler.extractPlayerTarget(new StringArguments(nameStr), out target, out targetGuid))
{
return(false);
}
ArenaTeam arena = Global.ArenaTeamMgr.GetArenaTeamById(teamId);
if (arena == null)
{
handler.SendSysMessage(CypherStrings.ArenaErrorNotFound, teamId);
return(false);
}
if (!target)
{
handler.SendSysMessage(CypherStrings.PlayerNotExistOrOffline, nameStr);
return(false);
}
if (arena.IsFighting())
{
handler.SendSysMessage(CypherStrings.ArenaErrorCombat);
return(false);
}
if (!arena.IsMember(targetGuid))
{
handler.SendSysMessage(CypherStrings.ArenaErrorNotMember, nameStr, arena.GetName());
return(false);
}
if (arena.GetCaptain() == targetGuid)
{
handler.SendSysMessage(CypherStrings.ArenaErrorCaptain, nameStr, arena.GetName());
return(false);
}
arena.SetCaptain(targetGuid);
CharacterInfo oldCaptainNameData = Global.WorldMgr.GetCharacterInfo(arena.GetCaptain());
if (oldCaptainNameData == null)
{
return(false);
}
handler.SendSysMessage(CypherStrings.ArenaCaptain, arena.GetName(), arena.GetId(), oldCaptainNameData.Name, target.GetName());
if (handler.GetSession() != null)
{
Log.outDebug(LogFilter.Arena, "GameMaster: {0} [GUID: {1}] promoted player: {2} [GUID: {3}] to leader of arena team \"{4}\"[Id: {5}]",
handler.GetSession().GetPlayer().GetName(), handler.GetSession().GetPlayer().GetGUID().ToString(), target.GetName(), target.GetGUID().ToString(), arena.GetName(), arena.GetId());
}
else
{
Log.outDebug(LogFilter.Arena, "Console: promoted player: {0} [GUID: {1}] to leader of arena team \"{2}\"[Id: {3}]",
target.GetName(), target.GetGUID().ToString(), arena.GetName(), arena.GetId());
}
return(true);
}
static bool HandleArenaRenameCommand(StringArguments args, CommandHandler handler)
{
if (args.Empty())
{
return(false);
}
string oldArenaStr = handler.extractQuotedArg(args.NextString());
if (string.IsNullOrEmpty(oldArenaStr))
{
handler.SendSysMessage(CypherStrings.BadValue);
return(false);
}
string newArenaStr = handler.extractQuotedArg(args.NextString());
if (string.IsNullOrEmpty(newArenaStr))
{
handler.SendSysMessage(CypherStrings.BadValue);
return(false);
}
ArenaTeam arena = Global.ArenaTeamMgr.GetArenaTeamByName(oldArenaStr);
if (arena == null)
{
handler.SendSysMessage(CypherStrings.AreanErrorNameNotFound, oldArenaStr);
return(false);
}
if (Global.ArenaTeamMgr.GetArenaTeamByName(newArenaStr) != null)
{
handler.SendSysMessage(CypherStrings.ArenaErrorNameExists, oldArenaStr);
return(false);
}
if (arena.IsFighting())
{
handler.SendSysMessage(CypherStrings.ArenaErrorCombat);
return(false);
}
if (!arena.SetName(newArenaStr))
{
handler.SendSysMessage(CypherStrings.BadValue);
return(false);
}
handler.SendSysMessage(CypherStrings.ArenaRename, arena.GetId(), oldArenaStr, newArenaStr);
if (handler.GetSession() != null)
{
Log.outDebug(LogFilter.Arena, "GameMaster: {0} [GUID: {1}] rename arena team \"{2}\"[Id: {3}] to \"{4}\"",
handler.GetSession().GetPlayer().GetName(), handler.GetSession().GetPlayer().GetGUID().ToString(), oldArenaStr, arena.GetId(), newArenaStr);
}
else
{
Log.outDebug(LogFilter.Arena, "Console: rename arena team \"{0}\"[Id: {1}] to \"{2}\"", oldArenaStr, arena.GetId(), newArenaStr);
}
return(true);
}
void HandleBattlemasterJoinArena(BattlemasterJoinArena packet)
{
// ignore if we already in BG or BG queue
if (GetPlayer().InBattleground())
{
return;
}
ArenaTypes arenatype = (ArenaTypes)ArenaTeam.GetTypeBySlot(packet.TeamSizeIndex);
//check existence
Battleground bg = Global.BattlegroundMgr.GetBattlegroundTemplate(BattlegroundTypeId.AA);
if (!bg)
{
Log.outError(LogFilter.Network, "Battleground: template bg (all arenas) not found");
return;
}
if (Global.DisableMgr.IsDisabledFor(DisableType.Battleground, (uint)BattlegroundTypeId.AA, null))
{
GetPlayer().SendSysMessage(CypherStrings.ArenaDisabled);
return;
}
BattlegroundTypeId bgTypeId = bg.GetTypeID();
BattlegroundQueueTypeId bgQueueTypeId = Global.BattlegroundMgr.BGQueueTypeId(bgTypeId, arenatype);
PVPDifficultyRecord bracketEntry = Global.DB2Mgr.GetBattlegroundBracketByLevel(bg.GetMapId(), GetPlayer().getLevel());
if (bracketEntry == null)
{
return;
}
Group grp = GetPlayer().GetGroup();
// no group found, error
if (!grp)
{
return;
}
if (grp.GetLeaderGUID() != GetPlayer().GetGUID())
{
return;
}
uint ateamId = GetPlayer().GetArenaTeamId(packet.TeamSizeIndex);
// check real arenateam existence only here (if it was moved to group.CanJoin .. () then we would ahve to get it twice)
ArenaTeam at = Global.ArenaTeamMgr.GetArenaTeamById(ateamId);
if (at == null)
{
GetPlayer().GetSession().SendNotInArenaTeamPacket(arenatype);
return;
}
// get the team rating for queuing
uint arenaRating = at.GetRating();
uint matchmakerRating = at.GetAverageMMR(grp);
// the arenateam id must match for everyone in the group
if (arenaRating <= 0)
{
arenaRating = 1;
}
BattlegroundQueue bgQueue = Global.BattlegroundMgr.GetBattlegroundQueue(bgQueueTypeId);
uint avgTime = 0;
GroupQueueInfo ginfo = null;
ObjectGuid errorGuid;
var err = grp.CanJoinBattlegroundQueue(bg, bgQueueTypeId, (uint)arenatype, (uint)arenatype, true, packet.TeamSizeIndex, out errorGuid);
if (err == 0)
{
Log.outDebug(LogFilter.Battleground, "Battleground: arena team id {0}, leader {1} queued with matchmaker rating {2} for type {3}", GetPlayer().GetArenaTeamId(packet.TeamSizeIndex), GetPlayer().GetName(), matchmakerRating, arenatype);
ginfo = bgQueue.AddGroup(GetPlayer(), grp, bgTypeId, bracketEntry, arenatype, true, false, arenaRating, matchmakerRating, ateamId);
avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry.GetBracketId());
}
for (GroupReference refe = grp.GetFirstMember(); refe != null; refe = refe.next())
{
Player member = refe.GetSource();
if (!member)
{
continue;
}
if (err != 0)
{
BattlefieldStatusFailed battlefieldStatus;
Global.BattlegroundMgr.BuildBattlegroundStatusFailed(out battlefieldStatus, bg, GetPlayer(), 0, arenatype, err, errorGuid);
member.SendPacket(battlefieldStatus);
continue;
}
// add to queue
uint queueSlot = member.AddBattlegroundQueueId(bgQueueTypeId);
BattlefieldStatusQueued battlefieldStatusQueued;
Global.BattlegroundMgr.BuildBattlegroundStatusQueued(out battlefieldStatusQueued, bg, member, queueSlot, ginfo.JoinTime, avgTime, arenatype, true);
member.SendPacket(battlefieldStatusQueued);
Log.outDebug(LogFilter.Battleground, "Battleground: player joined queue for arena as group bg queue type {0} bg type {1}: GUID {2}, NAME {3}", bgQueueTypeId, bgTypeId, member.GetGUID().ToString(), member.GetName());
}
Global.BattlegroundMgr.ScheduleQueueUpdate(matchmakerRating, arenatype, bgQueueTypeId, bgTypeId, bracketEntry.GetBracketId());
}
void HandleBattleFieldPort(BattlefieldPort battlefieldPort)
{
if (!GetPlayer().InBattlegroundQueue())
{
Log.outDebug(LogFilter.Battleground, "CMSG_BATTLEFIELD_PORT {0} Slot: {1}, Unk: {2}, Time: {3}, AcceptedInvite: {4}. Player not in queue!",
GetPlayerInfo(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, battlefieldPort.AcceptedInvite);
return;
}
BattlegroundQueueTypeId bgQueueTypeId = GetPlayer().GetBattlegroundQueueTypeId(battlefieldPort.Ticket.Id);
if (bgQueueTypeId == BattlegroundQueueTypeId.None)
{
Log.outDebug(LogFilter.Battleground, "CMSG_BATTLEFIELD_PORT {0} Slot: {1}, Unk: {2}, Time: {3}, AcceptedInvite: {4}. Invalid queueSlot!",
GetPlayerInfo(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, battlefieldPort.AcceptedInvite);
return;
}
BattlegroundQueue bgQueue = Global.BattlegroundMgr.GetBattlegroundQueue(bgQueueTypeId);
//we must use temporary variable, because GroupQueueInfo pointer can be deleted in BattlegroundQueue.RemovePlayer() function
GroupQueueInfo ginfo;
if (!bgQueue.GetPlayerGroupInfoData(GetPlayer().GetGUID(), out ginfo))
{
Log.outDebug(LogFilter.Battleground, "CMSG_BATTLEFIELD_PORT {0} Slot: {1}, Unk: {2}, Time: {3}, AcceptedInvite: {4}. Player not in queue (No player Group Info)!",
GetPlayerInfo(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, battlefieldPort.AcceptedInvite);
return;
}
// if action == 1, then instanceId is required
if (ginfo.IsInvitedToBGInstanceGUID == 0 && battlefieldPort.AcceptedInvite)
{
Log.outDebug(LogFilter.Battleground, "CMSG_BATTLEFIELD_PORT {0} Slot: {1}, Unk: {2}, Time: {3}, AcceptedInvite: {4}. Player is not invited to any bg!",
GetPlayerInfo(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, battlefieldPort.AcceptedInvite);
return;
}
BattlegroundTypeId bgTypeId = Global.BattlegroundMgr.BGTemplateId(bgQueueTypeId);
// BGTemplateId returns Battleground_AA when it is arena queue.
// Do instance id search as there is no AA bg instances.
Battleground bg = Global.BattlegroundMgr.GetBattleground(ginfo.IsInvitedToBGInstanceGUID, bgTypeId == BattlegroundTypeId.AA ? BattlegroundTypeId.None : bgTypeId);
if (!bg)
{
if (battlefieldPort.AcceptedInvite)
{
Log.outDebug(LogFilter.Battleground, "CMSG_BATTLEFIELD_PORT {0} Slot: {1}, Unk: {2}, Time: {3}, AcceptedInvite: {4}. Cant find BG with id {5}!",
GetPlayerInfo(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, battlefieldPort.AcceptedInvite, ginfo.IsInvitedToBGInstanceGUID);
return;
}
bg = Global.BattlegroundMgr.GetBattlegroundTemplate(bgTypeId);
if (!bg)
{
Log.outError(LogFilter.Network, "BattlegroundHandler: bg_template not found for type id {0}.", bgTypeId);
return;
}
}
// get real bg type
bgTypeId = bg.GetTypeID();
// expected bracket entry
PVPDifficultyRecord bracketEntry = Global.DB2Mgr.GetBattlegroundBracketByLevel(bg.GetMapId(), GetPlayer().getLevel());
if (bracketEntry == null)
{
return;
}
//some checks if player isn't cheating - it is not exactly cheating, but we cannot allow it
if (battlefieldPort.AcceptedInvite && ginfo.ArenaType == 0)
{
//if player is trying to enter Battleground(not arena!) and he has deserter debuff, we must just remove him from queue
if (!GetPlayer().CanJoinToBattleground(bg))
{
// send bg command result to show nice message
BattlefieldStatusFailed battlefieldStatus;
Global.BattlegroundMgr.BuildBattlegroundStatusFailed(out battlefieldStatus, bg, GetPlayer(), battlefieldPort.Ticket.Id, 0, GroupJoinBattlegroundResult.Deserters);
SendPacket(battlefieldStatus);
battlefieldPort.AcceptedInvite = false;
Log.outDebug(LogFilter.Battleground, "Player {0} ({1}) has a deserter debuff, do not port him to Battleground!", GetPlayer().GetName(), GetPlayer().GetGUID().ToString());
}
//if player don't match Battlegroundmax level, then do not allow him to enter! (this might happen when player leveled up during his waiting in queue
if (GetPlayer().getLevel() > bg.GetMaxLevel())
{
Log.outDebug(LogFilter.Network, "Player {0} ({1}) has level ({2}) higher than maxlevel ({3}) of Battleground({4})! Do not port him to Battleground!",
GetPlayer().GetName(), GetPlayer().GetGUID().ToString(), GetPlayer().getLevel(), bg.GetMaxLevel(), bg.GetTypeID());
battlefieldPort.AcceptedInvite = false;
}
}
if (battlefieldPort.AcceptedInvite)
{
// check Freeze debuff
if (GetPlayer().HasAura(9454))
{
return;
}
if (!GetPlayer().IsInvitedForBattlegroundQueueType(bgQueueTypeId))
{
return; // cheating?
}
if (!GetPlayer().InBattleground())
{
GetPlayer().SetBattlegroundEntryPoint();
}
// resurrect the player
if (!GetPlayer().IsAlive())
{
GetPlayer().ResurrectPlayer(1.0f);
GetPlayer().SpawnCorpseBones();
}
// stop taxi flight at port
if (GetPlayer().IsInFlight())
{
GetPlayer().GetMotionMaster().MovementExpired();
GetPlayer().CleanupAfterTaxiFlight();
}
BattlefieldStatusActive battlefieldStatus;
Global.BattlegroundMgr.BuildBattlegroundStatusActive(out battlefieldStatus, bg, GetPlayer(), battlefieldPort.Ticket.Id, GetPlayer().GetBattlegroundQueueJoinTime(bgQueueTypeId), bg.GetArenaType());
SendPacket(battlefieldStatus);
// remove BattlegroundQueue status from BGmgr
bgQueue.RemovePlayer(GetPlayer().GetGUID(), false);
// this is still needed here if Battleground"jumping" shouldn't add deserter debuff
// also this is required to prevent stuck at old Battlegroundafter SetBattlegroundId set to new
Battleground currentBg = GetPlayer().GetBattleground();
if (currentBg)
{
currentBg.RemovePlayerAtLeave(GetPlayer().GetGUID(), false, true);
}
// set the destination instance id
GetPlayer().SetBattlegroundId(bg.GetInstanceID(), bgTypeId);
// set the destination team
GetPlayer().SetBGTeam(ginfo.Team);
Global.BattlegroundMgr.SendToBattleground(GetPlayer(), ginfo.IsInvitedToBGInstanceGUID, bgTypeId);
Log.outDebug(LogFilter.Battleground, "Battleground: player {0} ({1}) joined battle for bg {2}, bgtype {3}, queue type {4}.", GetPlayer().GetName(), GetPlayer().GetGUID().ToString(), bg.GetInstanceID(), bg.GetTypeID(), bgQueueTypeId);
}
else // leave queue
{
// if player leaves rated arena match before match start, it is counted as he played but he lost
if (ginfo.IsRated && ginfo.IsInvitedToBGInstanceGUID != 0)
{
ArenaTeam at = Global.ArenaTeamMgr.GetArenaTeamById((uint)ginfo.Team);
if (at != null)
{
Log.outDebug(LogFilter.Battleground, "UPDATING memberLost's personal arena rating for {0} by opponents rating: {1}, because he has left queue!", GetPlayer().GetGUID().ToString(), ginfo.OpponentsTeamRating);
at.MemberLost(GetPlayer(), ginfo.OpponentsMatchmakerRating);
at.SaveToDB();
}
}
BattlefieldStatusNone battlefieldStatus = new BattlefieldStatusNone();
battlefieldStatus.Ticket = battlefieldPort.Ticket;
SendPacket(battlefieldStatus);
GetPlayer().RemoveBattlegroundQueueId(bgQueueTypeId); // must be called this way, because if you move this call to queue.removeplayer, it causes bugs
bgQueue.RemovePlayer(GetPlayer().GetGUID(), true);
// player left queue, we should update it - do not update Arena Queue
if (ginfo.ArenaType == 0)
{
Global.BattlegroundMgr.ScheduleQueueUpdate(ginfo.ArenaMatchmakerRating, ginfo.ArenaType, bgQueueTypeId, bgTypeId, bracketEntry.GetBracketId());
}
Log.outDebug(LogFilter.Battleground, "Battleground: player {0} ({1}) left queue for bgtype {2}, queue type {3}.", GetPlayer().GetName(), GetPlayer().GetGUID().ToString(), bg.GetTypeID(), bgQueueTypeId);
}
}
internal void Init(ArenaTeam team, Character chr)
{
ArenaTeam = team;
Character = chr;
}
/// <summary>
/// New or loaded arena team
/// </summary>
/// <param name="guild"></param>
public static void RegisterArenaTeam(ArenaTeam team)
{
ArenaTeamsById.Add(team.Id, team);
ArenaTeamsByName.Add(team.Name, team);
foreach (var atm in team.Members.Values)
{
if (atm.Character == null && !OfflineChars.ContainsKey(atm.Id))
OfflineChars.Add(atm.Id, atm);
}
}
internal void Init(ArenaTeam team)
{
Init(team, World.GetCharacter((uint)CharacterLowId));
}
public static void HandlePetitionTurnIn(IRealmClient client, RealmPacketIn packet)
{
var petitionGuid = packet.ReadEntityId();
var petition = client.ActiveCharacter.Inventory.GetItem(petitionGuid) as PetitionCharter;
if (petition == null)
{
return;
}
var name = petition.Petition.Name;
var type = petition.Petition.Type;
if (petition.Petition.SignedIds.Count < ((uint)type - 1))
{
SendPetitionTurnInResults(client, PetitionTurns.NEED_MORE_SIGNATURES);
return;
}
if (type == PetitionType.Guild && client.ActiveCharacter.IsInGuild)
{
SendPetitionTurnInResults(client, PetitionTurns.ALREADY_IN_GUILD);
return;
}
else if (client.ActiveCharacter.ArenaTeamMember[(uint)ArenaMgr.GetSlotByType((uint)type)] != null)
{
ArenaTeamHandler.SendResult(client, ArenaTeamCommandId.CREATE, name, string.Empty, ArenaTeamResult.ALREADY_IN_ARENA_TEAM);
return;
}
else if (type == PetitionType.Guild && GuildMgr.DoesGuildExist(name))
{
GuildHandler.SendResult(client, GuildCommandId.CREATE, name, GuildResult.NAME_EXISTS);
return;
}
else if (ArenaMgr.DoesArenaTeamExist(name))
{
ArenaTeamHandler.SendResult(client, ArenaTeamCommandId.CREATE, name, string.Empty, ArenaTeamResult.NAME_EXISTS);
return;
}
else
{
petition.Destroy();
if (type == PetitionType.Guild)
{
var guild = new Guild(client.ActiveCharacter.Record, name);
foreach (var chr in petition.Petition.SignedIds)
{
if (chr == 0)
{
continue;
}
else
{
var character = World.GetCharacter(chr);
guild.AddMember(character);
}
}
}
else
{
var team = new ArenaTeam(client.ActiveCharacter.Record, name, (uint)type);
foreach (var chr in petition.Petition.SignedIds)
{
if (chr == 0)
{
continue;
}
else
{
var character = World.GetCharacter(chr);
team.AddMember(character);
}
}
}
SendPetitionTurnInResults(client, PetitionTurns.OK);
}
}
private static RealmPacketOut CreateArenaTeamRosterResponsePacket(ArenaTeam team)
{
var packet = new RealmPacketOut(RealmServerOpCode.SMSG_ARENA_TEAM_ROSTER, 100);
packet.WriteUInt(team.Id);
packet.WriteByte(0);
packet.WriteUInt(team.MemberCount);
packet.WriteUInt(team.Type);
foreach (var member in team.Members.Values)
{
packet.WriteULong(member.Character.EntityId.Full);
var pl = World.GetCharacter(member.Character.EntityId.Low);
packet.WriteByte((pl != null) ? 1 : 0);
packet.WriteCString(member.Character.Name);
packet.WriteByte((team.Leader == member) ? 0 : 1);
packet.WriteByte((pl != null) ? pl.Level : 0);
packet.WriteUInt((uint)member.Class);
packet.WriteUInt(member.GamesWeek);
packet.WriteUInt(member.WinsWeek);
packet.WriteUInt(member.GamesSeason);
packet.WriteUInt(member.WinsSeason);
packet.WriteUInt(member.PersonalRating);
packet.WriteFloat(0.0f);
packet.WriteFloat(0.0f);
}
return packet;
}
public static void UnregisterArenaTeam(ArenaTeam team)
{
ArenaTeamsById.Remove(team.Id);
ArenaTeamsByName.Remove(team.Name);
}
public static void HandlePetitionTurnIn(IRealmClient client, RealmPacketIn packet)
{
var petitionGuid = packet.ReadEntityId();
var petition = client.ActiveCharacter.Inventory.GetItem(petitionGuid) as PetitionCharter;
if (petition == null) return;
var name = petition.Petition.Name;
var type = petition.Petition.Type;
if (petition.Petition.SignedIds.Count < ((uint)type - 1))
{
SendPetitionTurnInResults(client, PetitionTurns.NEED_MORE_SIGNATURES);
return;
}
if (type == PetitionType.Guild && client.ActiveCharacter.IsInGuild)
{
SendPetitionTurnInResults(client, PetitionTurns.ALREADY_IN_GUILD);
return;
}
else if (client.ActiveCharacter.ArenaTeamMember[(uint)ArenaMgr.GetSlotByType((uint)type)] != null)
{
ArenaTeamHandler.SendResult(client, ArenaTeamCommandId.CREATE, name, string.Empty, ArenaTeamResult.ALREADY_IN_ARENA_TEAM);
return;
}
else if (type == PetitionType.Guild && GuildMgr.DoesGuildExist(name))
{
GuildHandler.SendResult(client, GuildCommandId.CREATE, name, GuildResult.NAME_EXISTS);
return;
}
else if (ArenaMgr.DoesArenaTeamExist(name))
{
ArenaTeamHandler.SendResult(client, ArenaTeamCommandId.CREATE, name, string.Empty, ArenaTeamResult.NAME_EXISTS);
return;
}
else
{
petition.Destroy();
if (type == PetitionType.Guild)
{
var guild = new Guild(client.ActiveCharacter.Record, name);
foreach (var chr in petition.Petition.SignedIds)
{
if(chr == 0)
continue;
else
{
var character = World.GetCharacter(chr);
guild.AddMember(character);
}
}
}
else
{
var team = new ArenaTeam(client.ActiveCharacter.Record, name, (uint)type);
foreach (var chr in petition.Petition.SignedIds)
{
if(chr == 0)
continue;
else
{
var character = World.GetCharacter(chr);
team.AddMember(character);
}
}
}
SendPetitionTurnInResults(client, PetitionTurns.OK);
}
}
public static void SendArenaTeamRosterResponse(IPacketReceiver client, ArenaTeam team)
{
using (RealmPacketOut rosterResponsePacket = CreateArenaTeamRosterResponsePacket(team))
client.Send(rosterResponsePacket, false);
}
