public static void ProcessDeletion(bool succes, WorldClient client, long characterId)
{
if (!succes)
{
client.Send(new CharacterDeletionErrorMessage((sbyte)CharacterDeletionErrorEnum.DEL_ERR_NO_REASON));
return;
}
var record = client.GetAccountCharacter(characterId);
if (record == null)
{
client.Send(new CharacterDeletionErrorMessage((sbyte)CharacterDeletionErrorEnum.DEL_ERR_NO_REASON));
return;
}
client.Characters.Remove(record);
if (record.GuildId != 0)
{
GuildRecord.RemoveWhereId(record);
}
DatabaseManager.GetInstance().RemoveWhereIdMethod((long)characterId);
client.SendCharactersList();
}
public static bool CanCreateAlliance(WorldClient client, AllianceCreationValidMessage message)
{
if (!client.Character.HasGuild)
{
client.Send(new AllianceCreationResultMessage((sbyte)GuildCreationResultEnum.GUILD_CREATE_ERROR_LEAVE));
return(false);
}
if (client.Character.HasAlliance)
{
client.Send(new AllianceCreationResultMessage((sbyte)GuildCreationResultEnum.GUILD_CREATE_ERROR_ALREADY_IN_GUILD));
return(false);
}
if (message.allianceTag.Length < 3 || message.allianceTag.Length > 5)
{
client.Send(new AllianceCreationResultMessage((sbyte)GuildCreationResultEnum.GUILD_CREATE_ERROR_REQUIREMENT_UNMET));
return(false);
}
if (AllianceRecord.NameTaked(message.allianceName) || AllianceRecord.TagTaked(message.allianceTag))
{
client.Send(new AllianceCreationResultMessage((sbyte)GuildCreationResultEnum.GUILD_CREATE_ERROR_NAME_ALREADY_EXISTS));
return(false);
}
if (GuildRecord.GetGuild(client.Character.GuildId).GetLeader().CharacterId != client.Character.Id)
{
client.Send(new AllianceCreationResultMessage((sbyte)GuildCreationResultEnum.GUILD_CREATE_ERROR_REQUIREMENT_UNMET));
return(false);
}
return(true);
}
public Guild CreateGuild(string name)
{
lock (m_lock)
{
var id = m_idProvider.Pop();
var record = new GuildRecord
{
Id = id,
Name = name,
CreationDate = DateTime.Now,
IsNew = true,
Experience = 0,
Boost = 0,
Prospecting = 100,
Wisdom = 0,
Pods = 1000,
MaxTaxCollectors = 1,
EmblemBackgroundColor = Color.White.ToArgb(),
EmblemBackgroundShape = 1,
EmblemForegroundColor = Color.Black.ToArgb(),
EmblemForegroundShape = 1,
Spells = new int[0],
};
var guild = new Guild(record, new GuildMember[0]);
m_guilds.Add(guild.Id, guild);
return(guild);
}
}
public void SendGuildInfos()
{
if (HasGuild)
{
Client.Send(new GuildJoinedMessage(GuildRecord.GetGuild(GuildId).GetGuildInformations(), CharacterGuildRecord.GetCharacterGuild(Id).Rights, false));
HumanOptions.Add(new HumanOptionGuild(GetGuild().GetGuildInformations()));
}
}
public static AllianceRecord CreateAlliance(GuildRecord creator, string tag, string name, GuildEmblem emblem)
{
AllianceRecord Alliance = new AllianceRecord(AllianceRecord.PopNextId(), name, tag, emblem.symbolColor, emblem.symbolShape, emblem.backgroundShape, emblem.backgroundColor, creator.Id);
Alliance.AddElement();
JoinAlliance(creator, Alliance, null);
return(Alliance);
}
public GuildEmblem(GuildRecord record)
{
this.Record = record;
if (this.SymbolShape != 0)
{
this.Template = Singleton <GuildManager> .Instance.TryGetEmblem((int)this.SymbolShape);
}
}
/// <summary>
/// Créer le GuildRecord et le CharacterGuildRecord, et les met en cache pour les sauvegarder en db.
/// </summary>
/// <param name="owner"></param>
/// <param name="message"></param>
/// <returns></returns>
public GuildRecord CreateGuild(Character owner, GuildCreationValidMessage message)
{
GuildRecord guild = new GuildRecord(GuildRecord.PopNextId(), message.guildName, message.guildEmblem.symbolShape,
message.guildEmblem.symbolColor, message.guildEmblem.backgroundShape, message.guildEmblem.backgroundColor, 1, 0, 1);
guild.AddElement();
JoinGuild(guild, owner, GuildRightsBitEnum.GUILD_RIGHT_BOSS, (ushort)GuildRightsBitEnum.GUILD_RIGHT_BOSS);
return(guild);
}
public GuildEmblem(GuildRecord record)
{
Record = record;
if (SymbolShape != 0)
{
Template = GuildManager.Instance.TryGetEmblem(SymbolShape);
}
}
public GuildInstance(GuildRecord record)
{
this.Record = record;
Members = new List <GuildMemberInstance>();
foreach (var memberRec in Record.Members)
{
Members.Add(new GuildMemberInstance(this, memberRec));
}
}
public static void SendGuildInformationsGeneral(WorldClient client)
{
GuildRecord guild = GuildRecord.GetGuild(client.Character.GuildId);
ulong expFloor = ExperienceRecord.GetExperienceForGuild((ushort)(guild.Level));
ulong expNextFloor = ExperienceRecord.GetExperienceForGuild((ushort)(guild.Level + 1));
client.Send(new GuildInformationsGeneralMessage(true, false,
(byte)guild.Level, expFloor, guild.Experience, expNextFloor, 0,
(ushort)CharacterGuildRecord.MembersCount(guild.Id),
(ushort)GuildProvider.Instance.ConnectedMembersCount(guild.Id)));
}
public static void Guild(WorldClient client, string message)
{
sbyte channel = (sbyte)ChatActivableChannelsEnum.CHANNEL_GUILD;
if (client.Character.GetGuild() != null)
{
GuildRecord guild = client.Character.GetGuild();
foreach (WorldClient c in WorldServer.Instance.GetAllClientsOnline().FindAll(x => x.Character.GetGuild() == guild))
{
c.Send(new ChatServerMessage(channel, message, 1, "Symbioz", client.Character.Id, client.Character.Record.Name, client.Account.Id));
}
}
}
public static IEnumerable <GuildInsiderFactSheetInformations> GetGuildsInsiderFactSheetInformations(int AllianceId)
{
List <GuildInsiderFactSheetInformations> guilds = new List <GuildInsiderFactSheetInformations>();
List <GuildAllianceRecord> records = GuildAllianceRecord.GuildsAlliances.FindAll(x => x.AllianceId == AllianceId);
foreach (GuildAllianceRecord record in records)
{
GuildRecord guild = GuildRecord.GetGuild(record.GuildId);
GuildInsiderFactSheetInformations a = new GuildInsiderFactSheetInformations((uint)guild.Id, guild.Name, guild.GetEmblemObject(), (uint)guild.GetLeader().CharacterId, (byte)guild.Level, (ushort)GuildProvider.GetMembers(guild.Id).Length, CharacterRecord.GetCharacterRecordById(guild.GetLeader().CharacterId).Name, (ushort)GuildProvider.Instance.ConnectedMembersCount(guild.Id), 0, 0, true);
guilds.Add(a);
}
return((IEnumerable <GuildInsiderFactSheetInformations>)guilds);
}
public static void JoinAlliance(GuildRecord Guild, AllianceRecord Alliance, WorldClient Inviter = null)
{
GuildAllianceRecord Gmember = new GuildAllianceRecord(Guild.Id, Alliance.Id);
Gmember.AddElement();
if (Inviter != null)
{
Inviter.Send(new AllianceInvitationAnswerMessage(true));
}
foreach (CharacterGuildRecord member in CharacterGuildRecord.CharactersGuilds.FindAll(x => x.GuildId == Guild.Id))
{
AllianceRecord.OnCharacterJoinAlliance(CharacterRecord.GetCharacterRecordById(member.CharacterId), Alliance);
}
}
public Guild(GuildRecord record, System.Collections.Generic.IEnumerable <GuildMember> members)
{
this.Record = record;
this.m_members.AddRange(members);
this.Level = Singleton <ExperienceManager> .Instance.GetGuildLevel(this.Experience);
this.ExperienceLevelFloor = Singleton <ExperienceManager> .Instance.GetGuildLevelExperience(this.Level);
this.ExperienceNextLevelFloor = Singleton <ExperienceManager> .Instance.GetGuildNextLevelExperience(this.Level);
this.Emblem = new GuildEmblem(this.Record);
foreach (GuildMember guildMember in this.m_members)
{
if (guildMember.IsBoss)
{
if (this.Boss != null)
{
Guild.logger.Error <int, string>("There is at least two boss in guild {0} ({1})", this.Id, this.Name);
}
this.Boss = guildMember;
}
this.BindMemberEvents(guildMember);
guildMember.BindGuild(this);
}
if (this.m_members.Count == 0)
{
Guild.logger.Error <int, string>("Guild {0} ({1}) is empty", this.Id, this.Name);
}
else
{
if (this.Boss == null)
{
GuildMember guildMember = this.m_members.First <GuildMember>();
this.SetBoss(guildMember);
Guild.logger.Error <int, string>("There is at no boss in guild {0} ({1}) -> Promote new Boss", this.Id, this.Name);
}
}
int num = 0;
while (num < record.Spells.Length && num < Guild.TAX_COLLECTOR_SPELLS.Length)
{
if (record.Spells[num] != 0)
{
this.m_spells[num] = new Spell((int)Guild.TAX_COLLECTOR_SPELLS[num], (byte)record.Spells[num]);
}
num++;
}
}
public static void HandleGuildCreationRequest(GuildCreationValidMessage message, WorldClient client)
{
if (GuildProvider.Instance.HasGuild(client.Character.Id))
{
client.Send(new GuildCreationResultMessage((sbyte)GuildCreationResultEnum.GUILD_CREATE_ERROR_ALREADY_IN_GUILD));
return;
}
if (GuildRecord.CanCreateGuild(message.guildName))
{
GuildRecord newGuild = GuildProvider.Instance.CreateGuild(client.Character, message);
client.Send(new GuildCreationResultMessage((sbyte)GuildCreationResultEnum.GUILD_CREATE_OK));
}
else
{
client.Send(new GuildCreationResultMessage((sbyte)GuildCreationResultEnum.GUILD_CREATE_ERROR_NAME_ALREADY_EXISTS));
}
}
public void JoinGuild(GuildRecord guild, Character character, GuildRightsBitEnum rights, ushort rank)
{
CharacterGuildRecord characterGuild = new CharacterGuildRecord(character.Id, guild.Id, rank, 0, 0, (uint)rights);
characterGuild.AddElement();
character.HumanOptions.Add(new HumanOptionGuild(guild.GetGuildInformations()));
character.Client.Send(new GuildJoinedMessage(guild.GetGuildInformations(), (uint)rights, true));
character.RefreshOnMapInstance();
character.LearnEmote(GuildProvider.EMOTE_ID);
if (character.HasAlliance)
{
character.HumanOptions.Add(new HumanOptionAlliance(character.GetAlliance().GetAllianceInformations(), (sbyte)0));
character.Client.Send(new AllianceJoinedMessage(character.GetAlliance().GetAllianceInformations(), true));
character.RefreshOnMapInstance();
character.LearnEmote(AllianceProvider.EMOTE_ID);
}
}
public Guild(GuildRecord record, IEnumerable <GuildMember> members)
{
Record = record;
m_members.AddRange(members);
Level = ExperienceManager.Instance.GetGuildLevel(Experience);
ExperienceLevelFloor = ExperienceManager.Instance.GetGuildLevelExperience(Level);
ExperienceNextLevelFloor = ExperienceManager.Instance.GetGuildNextLevelExperience(Level);
Emblem = new GuildEmblem(Record);
BulletinDate = DateTime.Now;
LastNotifiedDate = DateTime.Now;
if (m_members.Count == 0 && !record.IsNew)
{
logger.Error("Guild {0} ({1}) is empty", Id, Name);
return;
}
foreach (var member in m_members)
{
BindMemberEvents(member);
member.BindGuild(this);
}
if (Boss == null && !record.IsNew)
{
logger.Error("There is at no boss in guild {0} ({1}) -> Promote new Boss", Id, Name);
var newBoss = Members.OrderBy(x => x.RankId).FirstOrDefault();
if (newBoss != null)
{
SetBoss(newBoss);
}
}
// load spells
for (var i = 0; i < record.Spells.Length && i < TAX_COLLECTOR_SPELLS.Length; i++)
{
if (record.Spells[i] == 0)
{
continue;
}
m_spells[i] = new Spell(TAX_COLLECTOR_SPELLS[i], (byte)record.Spells[i]);
}
}
public GuildCreationResultEnum CreateGuild(Character owner, string name, GuildEmblem emblem)
{
ContextGuildEmblem contextEmblem = ContextGuildEmblem.New(emblem);
if (name.Contains('\'') || GuildRecord.Exist(name))
{
return(GuildCreationResultEnum.GUILD_CREATE_ERROR_NAME_ALREADY_EXISTS);
}
if (GuildRecord.Exist(contextEmblem))
{
return(GuildCreationResultEnum.GUILD_CREATE_ERROR_EMBLEM_ALREADY_EXISTS);
}
GuildRecord record = GuildRecord.New(name, contextEmblem, DEFAULT_MAX_TAX_COLLECTOR);
record.AddElement();
GuildInstance instance = new GuildInstance(record);
instance.Join(owner, true);
Guilds.Add(instance);
return(GuildCreationResultEnum.GUILD_CREATE_OK);
}
public bool KickFromAlliance(int guildId, WorldClient by)
{
if (GuildRecord.GetGuild(guildId) != null)
{
GuildAllianceRecord member = GuildAllianceRecord.GetCharacterAlliance(guildId);
if (member != null || member.AllianceId == this.Id)
{
List <CharacterGuildRecord> charactersGuildRecord = CharacterGuildRecord.CharactersGuilds.FindAll(x => x.GuildId == guildId);
foreach (CharacterGuildRecord characterGuild in charactersGuildRecord)
{
Character character = WorldServer.Instance.GetOnlineClient(characterGuild.CharacterId).Character;
AllianceRecord.OnCharacterLeftAlliance(character);
}
member.RemoveElement();
Logger.Log(AllianceRecord.CountGuildInAlliance(member.AllianceId));
if (AllianceRecord.CountGuildInAlliance(member.AllianceId) < 1)
{
AllianceRecord.DeleteAlliance(member.AllianceId);
}
return(true);
}
}
return(false);
}
public static void HandleGetGuildInFactRequest(GuildFactsRequestMessage message, WorldClient client)
{
GuildRecord guild = GuildRecord.GetGuild((int)message.guildId);
if (guild == null)
{
return;
}
AllianceRecord alliance = AllianceProvider.GetAllianceFromGuild(guild.Id);
List <CharacterMinimalInformations> membersMinimalInfos = new List <CharacterMinimalInformations>();
foreach (GuildMember member in CharacterGuildRecord.GetMembers(guild.Id))
{
membersMinimalInfos.Add(new CharacterMinimalInformations(member.id, member.level, member.name));
}
if (alliance == null)
{
client.Send(new GuildFactsMessage(new GuildFactSheetInformations((uint)guild.Id, guild.Name, guild.GetEmblemObject(), (uint)GuildProvider.GetLeader(guild.Id).CharacterId, (byte)guild.Level, (ushort)CharacterGuildRecord.GetMembers(guild.Id).Count()), 0, 0, true, (IEnumerable <CharacterMinimalInformations>)membersMinimalInfos));
}
else
{
client.Send(new GuildInAllianceFactsMessage(new GuildFactSheetInformations((uint)guild.Id, guild.Name, guild.GetEmblemObject(), (uint)GuildProvider.GetLeader(guild.Id).CharacterId, (byte)guild.Level, (ushort)CharacterGuildRecord.GetMembers(guild.Id).Count()), 0, 0, true, (IEnumerable <CharacterMinimalInformations>)membersMinimalInfos, new BasicNamedAllianceInformations((uint)alliance.Id, alliance.Tag, alliance.Name)));
}
}
public List <GuildRecord> ComputeMapFlooding()
{
BinaryHeap <GuildRecord> open = new BinaryHeap <GuildRecord>();
List <GuildRecord> closed = new List <GuildRecord>();
//add the initial nodes for each guild in the priority queue
foreach (Guild g in guildList)
{
GuildRecord gr = new GuildRecord();
gr.location = GetNearestVertex(g.baseObject.transform.position);
gr.guild = g;
gr.strength = g.GetDropOff(0f);
open.Add(gr);
}
//create main Dijkstra iteration and return the assignments
while (open.Count != 0)
{
GuildRecord current = open.Remove();
Vertex v = current.location;
Vector3 currPos = v.transform.position;
Vertex[] neighbours = GetNeighbours(current.location);
//loop for computing each neighbour and put the current node in the closed list
foreach (Vertex n in neighbours)
{
//compute the drop-off from the current vertex and check whether
//it is worth trying to change the guild assigned
Vector3 nPos = n.transform.position;
float dist = Vector3.Distance(currPos, nPos);
float strength = current.guild.GetDropOff(dist);
if (strength < dropOffThreshold)
{
continue;
}
//create an auxiliary GuilRecord node with the current vertex's data
GuildRecord neighGR = new GuildRecord();
neighGR.location = n;
neighGR.strength = strength;
VertexInfluence vi = n as VertexInfluence;
neighGR.guild = vi.guild;
//check the closed list and validate the time
//when a new assignment must be avoided
if (closed.Contains(neighGR))
{
Vertex location = neighGR.location;
int index = closed.FindIndex(x => x.location == location);
GuildRecord gr = closed[index];
if (gr.guild.name != current.guild.name && gr.strength < strength)
{
continue;
}
}
else if (open.Contains(neighGR))
{
bool mustContinue = false;
foreach (GuildRecord gr in open)
{
if (gr.Equals(neighGR))
{
mustContinue = true;
break;
}
}
if (mustContinue)
{
continue;
}
}
else
{
neighGR = new GuildRecord();
neighGR.location = n;
}
neighGR.guild = current.guild;
neighGR.strength = strength;
open.Add(neighGR);
}
closed.Add(current);
}
return(closed);
}
public List <GuildRecord> ComputeMapFlooding()
{
GPWiki.BinaryHeap <GuildRecord> open;
open = new GPWiki.BinaryHeap <GuildRecord>();
List <GuildRecord> closed;
closed = new List <GuildRecord>();
foreach (Guild g in guildList)
{
GuildRecord gr = new GuildRecord();
Vector3 pos = g.baseObject.transform.position;
gr.location = GetNearestVertex(pos);
gr.guild = g;
gr.strength = g.GetDropOff(0f);
open.Add(gr);
}
while (open.Count != 0)
{
GuildRecord current;
current = open.Remove();
Vertex v = current.location;
Vector3 currPos;
currPos = v.transform.position;
Vertex[] neighbours;
neighbours = GetNeighbours(v);
foreach (Vertex n in neighbours)
{
Vector3 nPos = n.transform.position;
float dist = Vector3.Distance(currPos, nPos);
float strength = current.guild.GetDropOff(dist);
if (strength < dropOffThreshold)
{
continue;
}
GuildRecord neighGR = new GuildRecord();
neighGR.location = n;
neighGR.strength = strength;
VertexInfluence vi;
vi = n as VertexInfluence;
neighGR.guild = vi.guild;
if (closed.Contains(neighGR))
{
Vertex location = neighGR.location;
int index = closed.FindIndex(x => x.location == location);
GuildRecord gr = closed[index];
if (gr.guild.name != current.guild.name &&
gr.strength < strength)
{
continue;
}
}
else if (open.Contains(neighGR))
{
bool mustContinue = false;
foreach (GuildRecord gr in open)
{
if (gr.Equals(neighGR))
{
mustContinue = true;
break;
}
}
if (mustContinue)
{
continue;
}
}
else
{
neighGR = new GuildRecord();
neighGR.location = n;
}
neighGR.guild = current.guild;
neighGR.strength = strength;
open.Add(neighGR);
}
closed.Add(current);
}
return(closed);
}
public GuildRecord GetGuild()
{
return(HasGuild ? GuildRecord.GetGuild(GuildId) : null);
}
public static GuildRecord GetLeader(int allianceId)
{
AllianceRecord alliance = GetAlliance(allianceId);
return(GuildRecord.GetGuild(alliance.LeaderGuildId));
}
public override bool Eval(WorldClient client)
{
return(GuildRecord.GetGuild(client.Character.GuildId) != null && BasicEval(ConditionValue, ComparaisonSymbol, GuildRecord.GetGuild(client.Character.GuildId).Level));
}
