public static void GenerateMinilandEvent()
{
ServerManager.Instance.SaveAll();
foreach (CharacterDTO chara in DAOFactory.CharacterDAO.Where(s => s.State == (byte)CharacterState.Active))
{
// TODO
//GeneralLogDTO gen = DAOFactory.GeneralLogDAO.Where(s=>s.AccountId == null).LastOrDefault(s => s.LogData == "MinilandRefresh" && s.LogType == "World" && s.Timestamp.Day == DateTime.Now.Day);
int count = DAOFactory.GeneralLogDAO.Where(s => s.AccountId.Equals(chara.AccountId)).Count(s => s.LogData == "MINILAND" && s.Timestamp > DateTime.Now.AddDays(-1) && s.CharacterId == chara.CharacterId);
ClientSession session = ServerManager.Instance.GetSessionByCharacterId(chara.CharacterId);
if (session != null)
{
session.Character.GetReput(2 * count);
session.Character.MinilandPoint = 2000;
}
else if (CommunicationServiceClient.Instance.IsCharacterConnected(ServerManager.Instance.ServerGroup, chara.CharacterId))
{
//if (gen == null)
//{
//chara.Reput += 2 * count;
//}
chara.MinilandPoint = 2000;
CharacterDTO chara2 = chara;
DAOFactory.CharacterDAO.InsertOrUpdate(ref chara2);
}
}
GeneralLogDTO bite = new GeneralLogDTO {
LogData = "MinilandRefresh", LogType = "World", Timestamp = DateTime.Now
};
DAOFactory.GeneralLogDAO.InsertOrUpdate(ref bite);
ServerManager.Instance.StartedEvents.Remove(EventType.MINILANDREFRESHEVENT);
}
private void ExecuteHandler(ClientSession session)
{
ClientSession sess = ServerManager.Instance.GetSessionByCharacterId(CharacterId);
if (sess != null)
{
if (session.Character.Level >= 30)
{
GeneralLogDTO dto =
session.Character.GeneralLogs.LastOrDefault(s =>
s.LogData == "World" && s.LogType == "Connection");
GeneralLogDTO lastcompliment =
session.Character.GeneralLogs.LastOrDefault(s =>
s.LogData == "World" && s.LogType == "Compliment");
if (dto?.Timestamp.AddMinutes(60) <= DateTime.UtcNow)
{
if (lastcompliment == null || lastcompliment.Timestamp.AddDays(1) <= DateTime.UtcNow.Date)
{
sess.Character.Compliment++;
session.SendPacket(session.Character.GenerateSay(
string.Format(Language.Instance.GetMessageFromKey("COMPLIMENT_GIVEN"),
sess.Character.Name), 12));
session.Character.GeneralLogs.Add(new GeneralLogDTO
{
AccountId = session.Account.AccountId,
CharacterId = session.Character.CharacterId,
IpAddress = session.IpAddress,
LogData = "World",
LogType = "Compliment",
Timestamp = DateTime.UtcNow
});
session.CurrentMapInstance?.Broadcast(session,
session.Character.GenerateSay(
string.Format(Language.Instance.GetMessageFromKey("COMPLIMENT_RECEIVED"),
session.Character.Name), 12), ReceiverType.OnlySomeone,
characterId: CharacterId);
}
else
{
session.SendPacket(
session.Character.GenerateSay(
Language.Instance.GetMessageFromKey("COMPLIMENT_COOLDOWN"), 11));
}
}
else if (dto != null)
{
session.SendPacket(session.Character.GenerateSay(
string.Format(Language.Instance.GetMessageFromKey("COMPLIMENT_LOGIN_COOLDOWN"),
(dto.Timestamp.AddMinutes(60) - DateTime.UtcNow).Minutes), 11));
}
}
else
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("COMPLIMENT_NOT_MINLVL"),
11));
}
}
}
public static void GenerateMinilandEvent()
{
ServerManager.Instance.SaveAll();
GeneralLogDTO gen = DAOFactory.GeneralLogDAO.LoadByAccount(null).LastOrDefault(s => s.LogData == nameof(MinilandRefresh) && s.LogType == "World" && s.Timestamp.Date == DateTime.UtcNow.Date);
DAOFactory.GeneralLogDAO.Insert(new GeneralLogDTO {
LogData = nameof(MinilandRefresh), LogType = "World", Timestamp = DateTime.UtcNow
});
foreach (CharacterDTO chara in DAOFactory.CharacterDAO.LoadAll())
{
int count = DAOFactory.GeneralLogDAO.LoadByAccount(chara.AccountId).Count(s => s.LogData == "MINILAND" && s.Timestamp > DateTime.UtcNow.AddDays(-1) && s.CharacterId == chara.CharacterId);
ClientSession session = ServerManager.Instance.GetSessionByCharacterId(chara.CharacterId);
if (session != null)
{
session.Character.SetReputation(2 * count);
session.Character.MinilandPoint = 2000;
}
else if (!CommunicationServiceClient.Instance.IsCharacterConnected(ServerManager.Instance.ServerGroup, chara.CharacterId))
{
if (gen == null)
{
chara.Reputation += 2 * count;
}
chara.MinilandPoint = 2000;
CharacterDTO chara2 = chara;
DAOFactory.CharacterDAO.InsertOrUpdate(ref chara2);
}
}
ServerManager.Instance.StartedEvents.Remove(EventType.MinilandRefresh);
}
public IEnumerable<GeneralLogDTO> LoadByLogType(string logType, long? characterId, bool onlyToday = false)
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
List<GeneralLogDTO> result = new List<GeneralLogDTO>();
if (onlyToday)
{
DateTime today = DateTime.UtcNow.Date;
foreach (GeneralLog log in context.GeneralLog.AsNoTracking().Where(c =>
c.Timestamp.Year == today.Year && c.Timestamp.Month == today.Month
&& c.Timestamp.Day == today.Day && c.LogType.Equals(logType) && c.CharacterId == characterId))
{
GeneralLogDTO dto = new GeneralLogDTO();
Mapper.Mappers.GeneralLogMapper.ToGeneralLogDTO(log, dto);
result.Add(dto);
}
}
else
{
foreach (GeneralLog log in context.GeneralLog.AsNoTracking().Where(c =>
c.LogType.Equals(logType) && c.CharacterId == characterId))
{
GeneralLogDTO dto = new GeneralLogDTO();
Mapper.Mappers.GeneralLogMapper.ToGeneralLogDTO(log, dto);
result.Add(dto);
}
}
return result;
}
}
public static void GenerateMinilandEvent()
{
ServerManager.Instance.SaveAll();
foreach (CharacterDTO chara in DAOFactory.CharacterDAO.LoadAll())
{
GeneralLogDTO gen = DAOFactory.GeneralLogDAO.LoadByAccount(null).LastOrDefault(s => s.LogData == "MinilandRefresh" && s.LogType == "World" && s.Timestamp.Day == DateTime.Now.Day);
int count = DAOFactory.GeneralLogDAO.LoadByAccount(chara.AccountId).Count(s => s.LogData == "MINILAND" && s.Timestamp > DateTime.Now.AddDays(-1) && s.CharacterId == chara.CharacterId);
ClientSession Session = ServerManager.Instance.GetSessionByCharacterId(chara.CharacterId);
if (Session != null)
{
Session.Character.GetReput(2 * count);
Session.Character.MinilandPoint = 2000;
}
else if (!ServerCommunicationClient.Instance.HubProxy.Invoke <bool>("CharacterIsConnected", ServerManager.Instance.ServerGroup, chara.CharacterId).Result)
{
if (gen == null)
{
chara.Reput += 2 * count;
}
chara.MinilandPoint = 2000;
CharacterDTO chara2 = chara;
DAOFactory.CharacterDAO.InsertOrUpdate(ref chara2);
}
}
DAOFactory.GeneralLogDAO.Insert(new GeneralLogDTO {
LogData = "MinilandRefresh", LogType = "World", Timestamp = DateTime.Now
});
ServerManager.Instance.StartedEvents.Remove(EventType.MINILANDREFRESHEVENT);
}
public GeneralLogDTO Insert(GeneralLogDTO generallog)
{
using (var context = DataAccessHelper.CreateContext())
{
GeneralLog entity = _mapper.Map <GeneralLog>(generallog);
context.GeneralLog.Add(entity);
context.SaveChanges();
return(_mapper.Map <GeneralLogDTO>(generallog));
}
}
private static GeneralLogDTO insert(GeneralLogDTO GeneralLog, OpenNosContext context)
{
GeneralLog entity = new GeneralLog();
Mapper.Mappers.GeneralLogMapper.ToGeneralLog(GeneralLog, entity);
context.GeneralLog.Add(entity);
context.SaveChanges();
Mapper.Mappers.GeneralLogMapper.ToGeneralLogDTO(entity, GeneralLog);
return(GeneralLog);
}
public IEnumerable <GeneralLogDTO> LoadByAccount(long?accountId)
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
List <GeneralLogDTO> result = new List <GeneralLogDTO>();
foreach (GeneralLog GeneralLog in context.GeneralLog.Where(s => s.AccountId == accountId))
{
GeneralLogDTO dto = new GeneralLogDTO();
Mapper.Mappers.GeneralLogMapper.ToGeneralLogDTO(GeneralLog, dto);
result.Add(dto);
}
return(result);
}
}
public IEnumerable <GeneralLogDTO> LoadAll()
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
List <GeneralLogDTO> result = new List <GeneralLogDTO>();
foreach (GeneralLog generalLog in context.GeneralLog)
{
GeneralLogDTO dto = new GeneralLogDTO();
Mapper.Mappers.GeneralLogMapper.ToGeneralLogDTO(generalLog, dto);
result.Add(dto);
}
return(result);
}
}
public IEnumerable <GeneralLogDTO> LoadByLogType(string logType, long?characterId)
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
List <GeneralLogDTO> result = new List <GeneralLogDTO>();
foreach (GeneralLog log in context.GeneralLog.Where(c => c.LogType.Equals(logType) && c.CharacterId == characterId))
{
GeneralLogDTO dto = new GeneralLogDTO();
Mapper.Mappers.GeneralLogMapper.ToGeneralLogDTO(log, dto);
result.Add(dto);
}
return(result);
}
}
public static bool ToGeneralLogDTO(GeneralLog input, GeneralLogDTO output)
{
if (input == null)
{
return(false);
}
output.AccountId = input.AccountId;
output.CharacterId = input.CharacterId;
output.IpAddress = input.IpAddress;
output.LogData = input.LogData;
output.LogId = input.LogId;
output.LogType = input.LogType;
output.Timestamp = input.Timestamp;
return(true);
}
private GeneralLogDTO Update(GeneralLog entity, GeneralLogDTO generalLog, OpenNosContext context)
{
if (entity != null)
{
Mapper.Mappers.GeneralLogMapper.ToGeneralLog(generalLog, entity);
context.SaveChanges();
}
if (Mapper.Mappers.GeneralLogMapper.ToGeneralLogDTO(entity, generalLog))
{
return(generalLog);
}
return(null);
}
private static GeneralLogDTO update(GeneralLog entity, GeneralLogDTO GeneralLog, OpenNosContext context)
{
if (entity != null)
{
Mapper.Mappers.GeneralLogMapper.ToGeneralLog(GeneralLog, entity);
context.Entry(entity).State = EntityState.Modified;
context.SaveChanges();
}
if (Mapper.Mappers.GeneralLogMapper.ToGeneralLogDTO(entity, GeneralLog))
{
return(GeneralLog);
}
return(null);
}
public IEnumerable <GeneralLogDTO> LoadByIp(string ip)
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
string cleanIp = ip.Replace("tcp://", "");
cleanIp = cleanIp.Substring(0, cleanIp.LastIndexOf(":") > 0 ? cleanIp.LastIndexOf(":") : cleanIp.Length);
List <GeneralLogDTO> result = new List <GeneralLogDTO>();
foreach (GeneralLog GeneralLog in context.GeneralLog.Where(s => s.IpAddress.Contains(cleanIp)))
{
GeneralLogDTO dto = new GeneralLogDTO();
Mapper.Mappers.GeneralLogMapper.ToGeneralLogDTO(GeneralLog, dto);
result.Add(dto);
}
return(result);
}
}
public GeneralLogDTO Insert(GeneralLogDTO generallog)
{
try
{
using (var context = DataAccessHelper.CreateContext())
{
GeneralLog entity = _mapper.Map <GeneralLog>(generallog);
context.GeneralLog.Add(entity);
context.SaveChanges();
return(_mapper.Map <GeneralLogDTO>(generallog));
}
}
catch (Exception e)
{
Logger.Error(e);
return(null);
}
}
public GeneralLogDTO Insert(GeneralLogDTO generalLog)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
GeneralLog entity = new GeneralLog();
Mapper.Mappers.GeneralLogMapper.ToGeneralLog(generalLog, entity);
context.GeneralLog.Add(entity);
context.SaveChanges();
if (Mapper.Mappers.GeneralLogMapper.ToGeneralLogDTO(entity, generalLog))
{
return(generalLog);
}
return(null);
}
}
catch (Exception e)
{
Logger.Error(e);
return(null);
}
}
public SaveResult InsertOrUpdate(ref GeneralLogDTO GeneralLog)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
long LogId = GeneralLog.LogId;
GeneralLog entity = context.GeneralLog.FirstOrDefault(c => c.LogId.Equals(LogId));
if (entity == null)
{
GeneralLog = insert(GeneralLog, context);
return(SaveResult.Inserted);
}
GeneralLog = update(entity, GeneralLog, context);
return(SaveResult.Updated);
}
}
catch (Exception e)
{
Logger.Error(string.Format(Language.Instance.GetMessageFromKey("UPDATE_GeneralLog_ERROR"), GeneralLog.LogId, e.Message), e);
return(SaveResult.Error);
}
}
private void ExecuteHandler(ClientSession session)
{
if (session.IsOnMap || !session.HasSelectedCharacter)
{
// character should have been selected in SelectCharacter
return;
}
if (session.Character.MapInstance.Map.MapTypes.Any(m => m.MapTypeId == (short)MapTypeEnum.Act4) &&
ServerManager.Instance.ChannelId != 51)
{
session.Character.ChangeChannel(ServerManager.Instance.Configuration.Act4IP,
ServerManager.Instance.Configuration.Act4Port, 2);
return;
}
session.CurrentMapInstance = session.Character.MapInstance;
if (ServerManager.Instance.Configuration.SceneOnCreate &&
session.Character.GeneralLogs.CountLinq(s => s.LogType == "Connection") < 2)
{
session.SendPacket("scene 40");
}
if (ServerManager.Instance.Configuration.WorldInformation)
{
Assembly assembly = Assembly.GetEntryAssembly();
string productVersion = assembly?.Location != null
? FileVersionInfo.GetVersionInfo(assembly.Location).ProductVersion
: "1337";
session.SendPacket(session.Character.GenerateSay("----------[World Information]----------", 10));
session.SendPacket(
session.Character.GenerateSay("XARION - REUSRRECTION\n" +
$"Version : V4\n" +
$"Built by: XARION TEAM\n" +
$"Running on current Xarion supported source\n" + (ServerManager.Instance.IsDebugMode ? "DEBUG_MODE: Enabled\n" : "\n"), 11));
session.SendPacket(session.Character.GenerateSay("-----------------------------------------------",
10));
}
session.Character.LoadSpeed();
session.Character.LoadSkills();
session.Character.LoadPassiveSkills();
session.SendPacket(session.Character.GenerateTit());
session.SendPacket(session.Character.GenerateSpPoint());
session.SendPacket("rsfi 1 1 0 9 0 9");
if (session.Character.Hp <= 0)
{
ServerManager.Instance.ReviveFirstPosition(session.Character.CharacterId);
}
else
{
ServerManager.Instance.ChangeMap(session.Character.CharacterId);
}
session.SendPacket(session.Character.GenerateSki());
session.SendPacket(
$"fd {session.Character.Reputation} 0 {(int)session.Character.Dignity} {Math.Abs(session.Character.GetDignityIco())}");
session.SendPacket(session.Character.GenerateFd());
session.SendPacket("rage 0 250000");
session.SendPacket("rank_cool 0 0 18000");
ItemInstance specialistInstance = session.Character.Inventory.LoadBySlotAndType(8, InventoryType.Wear);
StaticBonusDTO medal = session.Character.StaticBonusList.Find(s =>
s.StaticBonusType == StaticBonusType.BazaarMedalGold ||
s.StaticBonusType == StaticBonusType.BazaarMedalSilver);
if (medal != null)
{
session.SendPacket(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("LOGIN_MEDAL"), 12));
}
if (session.Character.StaticBonusList.Any(s => s.StaticBonusType == StaticBonusType.PetBasket))
{
session.SendPacket("ib 1278 1");
}
if (session.Character.MapInstance.Map.MapTypes.Any(m => m.MapTypeId == (short)MapTypeEnum.CleftOfDarkness))
{
session.SendPacket("bc 0 0 0");
}
if (specialistInstance != null)
{
session.SendPacket(session.Character.GenerateSpPoint());
}
session.SendPacket("scr 0 0 0 0 0 0");
for (int i = 0; i < 10; i++)
{
session.SendPacket($"bn {i} {Language.Instance.GetMessageFromKey($"BN{i}")}");
}
session.SendPacket(session.Character.GenerateExts());
session.SendPacket(session.Character.GenerateMlinfo());
session.SendPacket(UserInterfaceHelper.GeneratePClear());
session.SendPacket(session.Character.GeneratePinit());
session.SendPacket(session.Character.GeneratePinit());
session.SendPackets(session.Character.Mates.Where(s => s.IsTeamMember).OrderBy(s => s.MateType).Select(s => s.GeneratePst()));
foreach (var mate in session.Character.Mates.Where(s => s.IsTeamMember))
{
mate.JoinTeam(true);
}
session.SendPacket("zzim");
session.SendPacket(
$"twk 1 {session.Character.CharacterId} {session.Account.Name} {session.Character.Name} {session.Account.Password.Substring(0, 16)}");
long?familyId = DAOFactory.FamilyCharacterDAO.LoadByCharacterId(session.Character.CharacterId)?.FamilyId;
if (familyId.HasValue)
{
session.Character.Family = ServerManager.Instance.FamilyList[familyId.Value];
}
if (session.Character.Family != null && session.Character.FamilyCharacter != null)
{
session.SendPacket(session.Character.GenerateGInfo());
session.SendPackets(session.Character.GetFamilyHistory());
session.SendPacket(session.Character.GenerateFamilyMember());
session.SendPacket(session.Character.GenerateFamilyMemberMessage());
session.SendPacket(session.Character.GenerateFamilyMemberExp());
session.Character.Faction = session.Character.Family.FamilyCharacters
.Find(s => s.Authority.Equals(FamilyAuthority.Head))?.Character
?.Faction ?? FactionType.None;
if (!string.IsNullOrWhiteSpace(session.Character.Family.FamilyMessage))
{
session.SendPacket(
UserInterfaceHelper.GenerateInfo("--- Family Message ---\n" +
session.Character.Family.FamilyMessage));
}
}
// qstlist target sqst bf
session.SendPacket("act6");
session.SendPacket(session.Character.GenerateFaction());
session.SendPackets(session.Character.GenerateScP());
session.SendPackets(session.Character.GenerateScN());
#pragma warning disable 618
session.Character.GenerateStartupInventory();
#pragma warning restore 618
session.SendPacket(session.Character.GenerateGold());
session.SendPackets(session.Character.GenerateQuicklist());
string clinit = "clinit";
string flinit = "flinit";
string kdlinit = "kdlinit";
foreach (CharacterDTO character in ServerManager.Instance.TopComplimented)
{
clinit +=
$" {character.CharacterId}|{character.Level}|{character.HeroLevel}|{character.Compliment}|{character.Name}";
}
foreach (CharacterDTO character in ServerManager.Instance.TopReputation)
{
flinit +=
$" {character.CharacterId}|{character.Level}|{character.HeroLevel}|{character.Reputation}|{character.Name}";
}
foreach (CharacterDTO character in ServerManager.Instance.TopPoints)
{
kdlinit +=
$" {character.CharacterId}|{character.Level}|{character.HeroLevel}|{character.Act4Points}|{character.Name}";
}
session.CurrentMapInstance?.Broadcast(session.Character.GenerateGidx());
session.SendPacket(session.Character.GenerateFinit());
session.SendPacket(session.Character.GenerateBlinit());
session.SendPacket(clinit);
session.SendPacket(flinit);
session.SendPacket(kdlinit);
session.Character.LastPvpRevive = DateTime.UtcNow;
List <PenaltyLogDTO> warning = DAOFactory.PenaltyLogDAO.LoadByAccount(session.Character.AccountId)
.Where(p => p.Penalty == PenaltyType.Warning).ToList();
if (warning.Count > 0)
{
session.SendPacket(UserInterfaceHelper.GenerateInfo(
string.Format(Language.Instance.GetMessageFromKey("WARNING_INFO"), warning.Count)));
}
// finfo - friends info
session.Character.LoadMail();
session.Character.LoadSentMail();
session.Character.DeleteTimeout();
foreach (StaticBuffDTO staticBuff in DAOFactory.StaticBuffDAO.LoadByCharacterId(session.Character
.CharacterId))
{
session.Character.AddStaticBuff(staticBuff);
}
if (session.Character.Authority == AuthorityType.BitchNiggerFaggot)
{
CommunicationServiceClient.Instance.SendMessageToCharacter(new ScsCharacterMessage
{
DestinationCharacterId = null,
SourceCharacterId = session.Character.CharacterId,
SourceWorldId = ServerManager.Instance.WorldId,
Message =
$"User {session.Character.Name} with rank BitchNiggerFaggot has logged in, don't trust *it*!",
Type = MessageType.Shout
});
}
string parsedip = session.IpAddress.Split(':')[1].Replace("//", "");
List <GeneralLogDTO> tmp = DAOFactory.GeneralLogDAO.LoadByLogType("DailyLogin", null, true).ToList();
if (!tmp.Any(s => s.AccountId.Equals(session.Account.AccountId)))
{
session.Character.RaidDracoRuns = 0;
session.Character.RaidGlacerusRuns = 0;
DAOFactory.GeneralLogDAO.WriteGeneralLog(session.Account.AccountId, parsedip, null, "DailyLogin",
"World");
}
GeneralLogDTO securityLog = DAOFactory.GeneralLogDAO.LoadByLogType("TOTP", null, true)
.LastOrDefault(s => s.AccountId == session.Account.AccountId);
if (securityLog?.IpAddress.Split(':')[1].Replace("//", "") != parsedip || securityLog.LogData != "SUCCESS")
{
if (string.IsNullOrWhiteSpace(session.Account.TotpSecret))
{
session.SendPacket(
UserInterfaceHelper.GenerateModal(
Language.Instance.GetMessageFromKey("WELCOME ON XARION").Replace("\\n", "\n"), 1));
session.Account.IsVerified = true;
}
else
{
session.SendPacket(
session.Character.GenerateSay(
Language.Instance.GetMessageFromKey("TOTP_INFO").Replace("\\n", "\n"), 12));
session.SendPacket(UserInterfaceHelper.GenerateGuri(10, 11, session.Character.CharacterId, 2));
Observable.Timer(TimeSpan.FromSeconds(60)).Subscribe(o =>
{
if (session.Account.IsVerified == false)
{
session.Disconnect();
}
});
}
}
else
{
session.Account.IsVerified = true;
}
session.Character.QuestManager = new QuestManager(session);
QuestModel firstQuestModel =
ServerManager.Instance.QuestModelList.FirstOrDefault(s => s.QuestGiver.Type == QuestGiverType.InitialQuest);
if (firstQuestModel != null && DAOFactory.QuestProgressDAO.LoadByCharacterId(session.Character.CharacterId)
.All(s => s.QuestId != firstQuestModel.QuestId))
{
session.Character.QuestManager.AddQuest(firstQuestModel.QuestId);
}
#region !Multi baguette detection!
bool trapTriggered = false;
bool possibleUnregisteredException = false;
long[][] connections = CommunicationServiceClient.Instance.RetrieveOnlineCharacters(session.Character.CharacterId);
foreach (long[] connection in connections)
{
if (connection != null)
{
CharacterDTO characterDTO = DAOFactory.CharacterDAO.LoadById(connection[0]);
if (characterDTO != null)
{
MultiAccountExceptionDTO exception = DAOFactory.MultiAccountExceptionDAO.LoadByAccount(characterDTO.AccountId);
if (exception == null && connections.Length > 3)
{
trapTriggered = true;
}
if (exception != null && connections.Length > exception.ExceptionLimit)
{
possibleUnregisteredException = true;
}
}
}
}
if (possibleUnregisteredException)
{
foreach (ClientSession team in ServerManager.Instance.Sessions.Where(s =>
s.Account.Authority == AuthorityType.GameMaster || s.Account.Authority == AuthorityType.Moderator))
{
if (team.HasSelectedCharacter)
{
team.SendPacket(team.Character.GenerateSay(
string.Format("Possible unregistered exception detected for user: "******", CharacterId: " + session.Character.CharacterId), 12));
}
}
}
if (trapTriggered)
{
foreach (ClientSession team in ServerManager.Instance.Sessions.Where(s =>
s.Account.Authority == AuthorityType.GameMaster || s.Account.Authority == AuthorityType.Moderator))
{
if (team.HasSelectedCharacter)
{
team.SendPacket(team.Character.GenerateSay(
string.Format("Possible multi account abusing user: "******", CharacterId: " + session.Character.CharacterId), 12));
}
}
}
#endregion
}
public GeneralLogDTO Insert(GeneralLogDTO generallog)
{
throw new NotImplementedException();
}
