public static void DeleteClan(Clan deletedClan)
{
if (deletedClan != null)
{
foreach (var battleStation in GameManager.BattleStations.Values.Where(x => x.Clan.Id == deletedClan.Id))
{
battleStation.Destroy(null, DestructionType.MISC);
}
GameManager.Clans.TryRemove(deletedClan.Id, out deletedClan);
foreach (var gameSession in GameManager.GameSessions.Values)
{
var member = gameSession?.Player;
if (member != null && member.Clan.Id == deletedClan.Id)
{
member.Clan = GameManager.GetClan(0);
var command = ClanChangedCommand.write(member.Clan.Tag, member.Clan.Id, member.Id);
member.SendCommand(command);
member.SendCommandToInRangePlayers(command);
}
}
foreach (var clan in GameManager.Clans.Values)
{
clan.Diplomacies.Remove(deletedClan.Id);
}
}
}
public static void LeaveFromClan(Player player)
{
foreach (var battleStation in GameManager.BattleStations.Values)
{
if (battleStation.EquippedStationModule.ContainsKey(player.Clan.Id))
{
battleStation.EquippedStationModule[player.Clan.Id].ForEach(x => { if (x.OwnerId == player.Id)
{
x.Destroy(null, DestructionType.MISC);
}
});
}
}
if (player?.GameSession != null)
{
if (player.Clan.Id != 0)
{
player.Clan = GameManager.GetClan(0);
var command = ClanChangedCommand.write(player.Clan.Tag, player.Clan.Id, player.Id);
player.SendCommand(command);
player.SendCommandToInRangePlayers(command);
}
}
}
public static void JoinToClan(Player player, Clan clan)
{
if (player?.GameSession != null && clan != null)
{
player.Clan = clan;
var command = ClanChangedCommand.write(clan.Tag, clan.Id, player.Id);
player.SendCommand(command);
player.SendCommandToInRangePlayers(command);
}
}
public static async Task <ValidatedView> AcceptJoinRequest(int accountId, int targetId)
{
try {
ClanMemberModel clanMemberModel = await Model <ClanMemberModel> .AsQueryable()
.FirstOrDefault(x => x.AccountID == accountId);
if (clanMemberModel == null || clanMemberModel.Role < ClanRole.VICE_LEADER)
{
return(ValidatedView.Invalid(ErrorCode.CLAN_ACCEPT_MEMBER_INSUFFICIENT_RIGHTS));
}
if (await Model <ClanMemberModel> .AsQueryable().Count(x => x.ClanID == clanMemberModel.ClanID) >= 50)
{
return(ValidatedView.Invalid(ErrorCode.CLAN_FULL));
}
ClanMemberPendingModel clanMemberPendingModel = await Model <ClanMemberPendingModel> .AsQueryable()
.FirstOrDefault(x => x.AccountID == targetId && x.ClanID == clanMemberModel.ClanID);
if (clanMemberPendingModel == null)
{
return(ValidatedView.Invalid(ErrorCode.CLAN_PENDING_DID_NOT_REQUEST));
}
ClanMemberModel newClanMemberModel = new ClanMemberModel {
ClanID = clanMemberModel.ClanID, AccountID = targetId
};
await Model <ClanMemberPendingModel> .AsCollection().DeleteManyAsync(x => x.AccountID == targetId);
await Model <ClanMemberModel> .AsCollection().InsertOneAsync(newClanMemberModel);
if (GameManager.Get(accountId, out PlayerController controller))
{
ValidatedView <ClanOverview> validatedView = await RetrieveClanOverviewFromMember(accountId);
if (validatedView.IsValid)
{
controller.Account.Clan = validatedView.Object ?? new ClanOverview();
}
ClanChangedCommand clanChangedCommand = PacketBuilder.ClanChangedCommand(controller);
controller.Send(clanChangedCommand);
controller.EntitesInRange(x => x.Send(clanChangedCommand));
}
return(ValidatedView.Valid());
} catch (Exception e) {
GameContext.Logger.LogError(e);
}
return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED));
}
public static async Task <ValidatedView> CreateClan(int accountId, ClanCreateView clanCreateView)
{
if (!clanCreateView.IsValid(out string message))
{
return(ValidatedView.Invalid(message));
}
try {
if (await Model <ClanMemberModel> .AsQueryable().Any(x => x.AccountID == accountId))
{
GameContext.Logger.LogCritical($"Player [id: '{accountId}'] tries creating a clan while being member of another!");
return(ValidatedView.Invalid(ErrorCode.CLAN_ALREADY_MEMBER));
}
if (await Model <ClanModel> .AsQueryable().Any(x => x.Name == clanCreateView.Name))
{
return(ValidatedView.Invalid(ErrorCode.CLAN_NAME_ALREADY_IN_USE));
}
if (await Model <ClanModel> .AsQueryable().Any(x => x.Tag == clanCreateView.Tag))
{
return(ValidatedView.Invalid(ErrorCode.CLAN_TAG_ALREADY_IN_USE));
}
ClanModel clanModel = Mapper <ClanCreateView> .Map <ClanModel>(clanCreateView);
ClanMemberModel clanMemberModel = new ClanMemberModel {
ClanID = clanModel.ID, AccountID = accountId, Role = ClanRole.LEADER
};
await Model <ClanMemberPendingModel> .AsCollection().DeleteManyAsync(x => x.AccountID == accountId);
await Model <ClanModel> .AsCollection().InsertOneAsync(clanModel);
await Model <ClanMemberModel> .AsCollection().InsertOneAsync(clanMemberModel);
if (GameManager.Get(accountId, out PlayerController controller))
{
controller.Account.Clan = Mapper <ClanModel> .Map <ClanOverview>(clanModel);
ClanChangedCommand clanChangedCommand = PacketBuilder.ClanChangedCommand(controller);
controller.Send(clanChangedCommand);
controller.EntitesInRange(x => x.Send(clanChangedCommand));
}
return(ValidatedView.Valid());
} catch (Exception e) {
GameContext.Logger.LogError(e);
}
return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED));
}
public static void CreateClan(Player player, int clanId, int factionId, string name, string tag)
{
if (!GameManager.Clans.ContainsKey(clanId))
{
var clan = new Clan(clanId, name, tag, factionId);
GameManager.Clans.TryAdd(clan.Id, clan);
if (player?.GameSession != null)
{
player.Clan = clan;
var command = ClanChangedCommand.write(clan.Tag, clan.Id, player.Id);
player.SendCommand(command);
player.SendCommandToInRangePlayers(command);
}
}
}
public static void ChangeClanData(Clan clan, string name, string tag, int factionId)
{
if (clan.Id != 0)
{
clan.Tag = tag;
clan.Name = name;
//clan.FactionId = factionId;
foreach (GameSession gameSession in GameManager.GameSessions.Values.Where(x => x.Player.Clan.Id == clan.Id))
{
var player = gameSession.Player;
if (player != null)
{
GameManager.SendCommandToMap(player.Spacemap.Id, ClanChangedCommand.write(clan.Tag, clan.Id, player.Id));
}
}
}
}
public static async Task <ValidatedView> Edit(int accountId, ClanCreateView clanUpdateView)
{
if (!clanUpdateView.IsValid(out string message))
{
return(ValidatedView.Invalid(message));
}
try {
ClanMemberModel clanMemberModel = await Model <ClanMemberModel>
.AsQueryable().FirstOrDefault(x => x.AccountID == accountId);
if (clanMemberModel != null)
{
ClanModel clanModel = await Model <ClanModel> .AsQueryable()
.FirstOrDefault(x => x.ID == clanMemberModel.ClanID);
if (clanModel == null)
{
return(ValidatedView.Invalid(ErrorCode.CLAN_NOT_FOUND));
}
else
{
if (clanMemberModel.Role < ClanRole.LEADER)
{
return(ValidatedView.Invalid(ErrorCode.CLAN_MANAGE_INSUFFICIENT_RIGHTS));
}
if (clanModel.Name == clanUpdateView.Name &&
clanModel.Tag == clanUpdateView.Tag &&
clanModel.Description == clanUpdateView.Description)
{
return(ValidatedView.Valid());
}
if (clanModel.Name != clanUpdateView.Name &&
await Model <ClanModel> .AsQueryable().Any(x => x.Name == clanUpdateView.Name))
{
return(ValidatedView.Invalid(ErrorCode.CLAN_NAME_ALREADY_IN_USE));
}
bool clanTagChanged = clanModel.Tag != clanUpdateView.Tag;
if (clanTagChanged &&
await Model <ClanModel> .AsQueryable().Any(x => x.Tag == clanUpdateView.Tag))
{
return(ValidatedView.Invalid(ErrorCode.CLAN_TAG_ALREADY_IN_USE));
}
clanModel = Mapper <ClanCreateView> .Map(clanUpdateView, clanModel);
await Model <ClanModel> .AsCollection()
.ReplaceOneAsync(x => x.ID == clanModel.ID, clanModel);
foreach (ClanMemberModel member in await Model <ClanMemberModel> .AsQueryable()
.Where(x => x.ClanID == clanModel.ID).ToList())
{
if (GameManager.Get(member.AccountID, out PlayerController controller))
{
controller.Account.Clan = Mapper <ClanModel> .Map <ClanOverview>(clanModel);
ClanChangedCommand clanChangedCommand = PacketBuilder.ClanChangedCommand(controller);
controller.Send(clanChangedCommand);
controller.EntitesInRange(x => x.Send(clanChangedCommand));
}
}
return(ValidatedView.Valid());
}
}
else
{
return(ValidatedView.Invalid(ErrorCode.CLAN_NOT_MEMBER));
}
} catch (Exception e) {
GameContext.Logger.LogError(e);
}
return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED));
}
public static async Task <ValidatedView> Leave(int accountId)
{
try {
ClanMemberModel clanMemberModel = await Model <ClanMemberModel>
.AsQueryable().FirstOrDefault(x => x.AccountID == accountId);
if (clanMemberModel != null)
{
ClanModel clanModel = await Model <ClanModel> .AsQueryable()
.FirstOrDefault(x => x.ID == clanMemberModel.ClanID);
if (clanModel == null)
{
return(ValidatedView.Invalid(ErrorCode.CLAN_NOT_FOUND));
}
else
{
if (await Model <ClanMemberModel> .AsQueryable()
.Where(x => x.ClanID == clanModel.ID).Count() > 1 &&
clanMemberModel.Role == ClanRole.LEADER)
{
return(ValidatedView.Invalid(ErrorCode.CLAN_CANNOT_LEAVE_WHILE_LEADER));
}
if (GameManager.Get(accountId, out PlayerController controller))
{
if (!controller.ZoneAssembly.CanEquip)
{
return(ValidatedView.Invalid(ErrorCode.CLAN_CANNOT_LEAVE_WHILE_NOT_AT_BASE));
}
}
await Model <ClanMemberModel> .AsCollection()
.DeleteOneAsync(x => x.AccountID == accountId);
if (clanMemberModel.Role == ClanRole.LEADER)
{
await Delete(clanModel.ID);
}
if (GameManager.Get(accountId, out controller))
{
controller.Account.Clan = new ClanOverview();
ClanChangedCommand clanChangedCommand = PacketBuilder.ClanChangedCommand(controller);
controller.Send(clanChangedCommand);
controller.EntitesInRange(x => x.Send(clanChangedCommand));
}
return(ValidatedView.Valid());
}
}
else
{
return(ValidatedView.Invalid(ErrorCode.CLAN_NOT_MEMBER));
}
} catch (Exception e) {
GameContext.Logger.LogError(e);
}
return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED));
}
