public static void BindHeatMapServices(this IDependencyCollection dc, IServicesSettings settings)
{
var bidAskRepository = new BidAskRepository(new MyNoSqlServerClient <BidAskMySqlTableEntity>(settings.CacheUrl, "bidask"));
dc.AddSingleton <IBidAskRepository, BidAskRepository>(bidAskRepository);
var bidAskHistoryRepository = new BidAskHistoryRepository(new MyNoSqlServerClient <BidAskHistoryTableEntity>(settings.CacheUrl, "bidaskhistory"));
dc.AddSingleton <IBidAskHistoryRepository, BidAskHistoryRepository>(bidAskHistoryRepository);
var bidAskCache = new BidAskCache(bidAskRepository);
dc.AddSingleton <IBidAskCache, BidAskCache>(bidAskCache);
var indexInfoRepo = new IndexInformationRepository(new MyNoSqlServerClient <IndexInformationTableEntity>(settings.CacheUrl, "indexinfo"));
dc.AddSingleton <IIndexInformationRepository, IndexInformationRepository>(indexInfoRepo);
var overshootInfoRepo = new OvershootIndicatorsDataRepository(new MyNoSqlServerClient <OvershootIndicatorNoSqlEntity>(settings.CacheUrl, "overshoots"));
dc.AddSingleton <IOvershootIndicatorsDataRepository, OvershootIndicatorsDataRepository>(overshootInfoRepo);
TimerExecutor = new TimerExecutor(1000)
.RegisterTimer(nameof(bidAskCache), bidAskCache);
TimerExecutor.Start();
}
public void Initialize()
{
var commandsReader1 = new CommandFileReader($"file{Program.Node}.txt");
_timerExecutor = new TimerExecutor(
commandsReader1.ReadCommands().ToArray(),
command =>
{
//Console.WriteLine($"Executing command {command.Time}...");
switch (command.Type)
{
case CommandType.Insert:
// ReSharper disable once PossibleInvalidOperationException
return(InsertAsync(command.Key, command.Value.Value));
case CommandType.Select:
return(command.Key != null
? SelectAsync(command.Key)
: SelectAllAsync());
default:
throw new ArgumentOutOfRangeException();
}
});
IsInitialized = true;
_mainTask = Task.Run(async() =>
{
await WaitInitAsync();
Console.WriteLine("Start executing...");
await _timerExecutor.Execute();
});
}
static void Main(string[] args)
{
Write("Enter count of seconds: ");
int sec = int.Parse(ReadLine());
Timer timer = new Timer();
TimerExecutor del = timer.Start;
del.Invoke(sec);
}
static async Task Main(string[] args)
{
if (args.Length != 3)
{
throw new ArgumentException();
}
var filePath1 = args[0];
var filePath2 = args[1];
var filePath3 = args[2];
var commandsReader1 = new CommandFileReader(filePath1);
var commandsReader2 = new CommandFileReader(filePath2);
var commandsReader3 = new CommandFileReader(filePath3);
var executor = new TimerExecutor(
commandsReader1.ReadCommands()
.Concat(commandsReader2.ReadCommands())
.Concat(commandsReader3.ReadCommands())
.ToArray(),
command =>
{
//Console.WriteLine($"Executing command {command.Time}...");
switch (command.Type)
{
case CommandType.Insert:
// ReSharper disable once PossibleInvalidOperationException
return(InsertAsync(command.Key, command.Value.Value));
case CommandType.Select:
return(command.Key != null
? SelectAsync(command.Key)
: SelectAllAsync());
default:
throw new ArgumentOutOfRangeException();
}
});
await WaitSlavesAsync();
Console.WriteLine("Start executing...");
await executor.Execute();
Console.WriteLine("Show stats...");
await ShowStatsAsync();
Console.WriteLine("Done!");
}
private TimerExecutorItem _onUserTaskCreated(int durationSec, int taskId, int initiativeUserId, int targetPlanetId, Action <IDbConnection> onFinnalyTimerElapsed = null)
{
var timer = TimerExecutor.CreateUserTaskTimer(durationSec, taskId, initiativeUserId, targetPlanetId, () =>
{
_dbProvider.ContextAction(connection =>
{
try
{
connection.OpenIfClosed();
RunTaskItem(connection, taskId);
onFinnalyTimerElapsed?.Invoke(connection);
return(true);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
finally
{
connection.CloseIfOpened();
}
});
});
var started = TimerExecutor.SetFinalizeAndStart(timer);
if (!started)
{
timer.Dispose();
throw new NotImplementedException("OnUserTaskCreated: !started");
}
else
{
TimerExecutor.AddOrUpdate(timer);
}
return(timer);
}
public Dictionary <string, object> Create(IDbConnection connection)
{
CachedPlanetCount = _gameRunner.GetPlanetIds(connection).Count;
var resolver = _gameRunner.ServiceProvider;
var hasWorld = resolver.GetService <IGGalaxyRepository>().HasItems(connection);
var dic = new Dictionary <string, object>();
dic.Add("GameConnectionName", DbProvider.AppConnectionName.ToString());
dic.Add("WorldExists", hasWorld);
dic.Add(nameof(CacheInitialized), CacheInitialized);
dic.Add(nameof(NpcTaskRunnerRunned), NpcTaskRunnerRunned);
dic.Add("SynchronizerDemonsStarted", Synchronizer.DemonsStarted);
dic.Add(nameof(OnlineGameUsers), OnlineGameUsers);
dic.Add(nameof(SkagryActivatedTaskCount), SkagryActivatedTaskCount);
dic.Add(nameof(CachedPlanetCount), CachedPlanetCount);
//demons
dic.Add("________", "________");
dic.Add(nameof(IAllianceLocalStorageCache), resolver.GetService <IAllianceLocalStorageCache>().GetCount());
dic.Add(nameof(IAllianceFleetLocalStorageCache), resolver.GetService <IAllianceFleetLocalStorageCache>().GetCount());
dic.Add(nameof(IAllianceRequestMessageLocalStorageCache), resolver.GetService <IAllianceRequestMessageLocalStorageCache>().GetCount());
dic.Add(nameof(IAllianceRoleLocalStorageCache), resolver.GetService <IAllianceRoleLocalStorageCache>().GetCount());
dic.Add(nameof(IAllianceTechLocalStorageCache), resolver.GetService <IAllianceTechLocalStorageCache>().GetCount());
dic.Add(nameof(IAllianceUserLocalStorageCache), resolver.GetService <IAllianceUserLocalStorageCache>().GetCount());
dic.Add(nameof(IGDetailMoonLocalStorageCache), resolver.GetService <IGDetailMoonLocalStorageCache>().GetCount());
dic.Add(nameof(IGDetailPlanetLocalStorageCache), resolver.GetService <IGDetailPlanetLocalStorageCache>().GetCount());
dic.Add(nameof(IGDetailSystemLocalStorageCache), resolver.GetService <IGDetailSystemLocalStorageCache>().GetCount());
dic.Add(nameof(IGGalaxyLocalStorageCache), resolver.GetService <IGGalaxyLocalStorageCache>().GetCount());
dic.Add(nameof(IGGameTypeLocalStorageCache), resolver.GetService <IGGameTypeLocalStorageCache>().GetCount());
dic.Add(nameof(IGGeometryMoonLocalStorageCache), resolver.GetService <IGGeometryMoonLocalStorageCache>().GetCount());
dic.Add(nameof(IGGeometryPlanetLocalStorageCache), resolver.GetService <IGGeometryPlanetLocalStorageCache>().GetCount());
dic.Add(nameof(IGGeometryStarLocalStorageCache), resolver.GetService <IGGeometryStarLocalStorageCache>().GetCount());
dic.Add(nameof(IGGeometrySystemLocalStorageCache), resolver.GetService <IGGeometrySystemLocalStorageCache>().GetCount());
dic.Add(nameof(IGSectorsLocalStorageCache), resolver.GetService <IGSectorsLocalStorageCache>().GetCount());
dic.Add(nameof(IGTextureTypeLocalStorageCache), resolver.GetService <IGTextureTypeLocalStorageCache>().GetCount());
dic.Add(nameof(ICurrencyLocalStorageCache), resolver.GetService <ICurrencyLocalStorageCache>().GetCount());
dic.Add(nameof(IProductStoreLocalStorageCache), resolver.GetService <IProductStoreLocalStorageCache>().GetCount());
dic.Add(nameof(IProductTypeLocalStorageCache), resolver.GetService <IProductTypeLocalStorageCache>().GetCount());
dic.Add(nameof(IUserBalanceCcLocalStorageCache), resolver.GetService <IUserBalanceCcLocalStorageCache>().GetCount());
dic.Add(nameof(IUserBookmarkLocalStorageCache), resolver.GetService <IUserBookmarkLocalStorageCache>().GetCount());
dic.Add(nameof(IJournalBuyLocalStorageCache), resolver.GetService <IJournalBuyLocalStorageCache>().GetCount());
dic.Add(nameof(IPremiumLocalStorageCache), resolver.GetService <IPremiumLocalStorageCache>().GetCount());
dic.Add(nameof(ITransicationCcLocalStorageCache), resolver.GetService <ITransicationCcLocalStorageCache>().GetCount());
dic.Add(nameof(IUMotherJumpLocalStorageCache), resolver.GetService <IUMotherJumpLocalStorageCache>().GetCount());
dic.Add(nameof(IUReportLocalStorageCache), resolver.GetService <IUReportLocalStorageCache>().GetCount());
dic.Add(nameof(IUserChestLocalStorageCache), resolver.GetService <IUserChestLocalStorageCache>().GetCount());
dic.Add(nameof(IUserLocalStorageCache), resolver.GetService <IUserLocalStorageCache>().GetCount());
dic.Add(nameof(IUserMothershipLocalStorageCache), resolver.GetService <IUserMothershipLocalStorageCache>().GetCount());
dic.Add(nameof(IUSpyLocalStorageCache), resolver.GetService <IUSpyLocalStorageCache>().GetCount());
dic.Add(nameof(IUTaskLocalStorageCache), resolver.GetService <IUTaskLocalStorageCache>().GetCount());
//advanced
dic.Add("_________", "_________");
dic.Add(nameof(TmpCache), TmpCache.GetCount());
dic.Add(nameof(TimerExecutor), TimerExecutor.GetCount());
dic.Add(nameof(IMainGameHubLocalStorageCache), resolver.GetService <IMainGameHubLocalStorageCache>().GetCount());
dic.Add(nameof(IUserAuthToGameCache), resolver.GetService <IUserAuthToGameCache>().GetCount());
dic.Add(nameof(IUserNameSercherPkCache), resolver.GetService <IUserNameSercherPkCache>().GetCount());
dic.Add(nameof(IAlianceNameSercherPkCache), resolver.GetService <IAlianceNameSercherPkCache>().GetCount());
dic.Add(nameof(IPlanetNameToPlanetIdPkCache), resolver.GetService <IPlanetNameToPlanetIdPkCache>().GetCount());
dic.Add(nameof(ISystemNameSercherPkCache), resolver.GetService <ISystemNameSercherPkCache>().GetCount());
return(dic);
}
public static void Run()
{
EventSink.Instance = new EventSink();
if ( !ScriptCompiler.Compile( Environment.Debug ) )
{
Console.WriteLine( "Fatal: Compilation failed. Press any key to exit." );
Console.ReadLine();
return;
}
ScriptCompiler.VerifyLibraries();
// This instance is shared among timer scheduler and timer executor,
// and accessed from both core & timer threads.
Queue<Timer> timerQueue = new Queue<Timer>();
// Timer scheduler must be set up before world load, since world load
// could schedule timers on entity deserialization.
var timerScheduler = TimerScheduler.Instance = new TimerScheduler( timerQueue );
m_TimerThread = new TimerThread( timerScheduler );
TimerExecutor timerExecutor = new TimerExecutor( timerQueue );
PacketHandlers.Instance = new PacketHandlers();
try
{
ScriptCompiler.Configure();
TileData.Configure();
}
catch ( TargetInvocationException e )
{
Console.WriteLine( "Fatal: Configure exception: {0}", e.InnerException );
return;
}
Environment.SaveConfig();
Region.Load();
World.Instance.Load();
try
{
ScriptCompiler.Initialize();
}
catch ( TargetInvocationException e )
{
Logger.Error( "Initialize exception: {0}", e.InnerException );
return;
}
m_TimerThread.Start();
NetServer netServer = new NetServer( new Listener( Listener.Port ) );
netServer.Initialize();
GameServer.Instance = new GameServer( netServer, PacketHandlers.Instance );
GameServer.Instance.Initialize();
EventSink.Instance.InvokeServerStarted();
PacketDispatcher.Initialize();
m_Now = DateTime.UtcNow;
m_TotalProfile = new MainProfile( m_Now );
m_CurrentProfile = new MainProfile( m_Now );
try
{
while ( !m_Closing )
{
m_Now = DateTime.UtcNow;
Thread.Sleep( 1 );
ClockProfile( MainProfile.TimerId.Idle );
Mobile.ProcessDeltaQueue();
ClockProfile( MainProfile.TimerId.MobileDelta );
Item.ProcessDeltaQueue();
ClockProfile( MainProfile.TimerId.ItemDelta );
timerExecutor.Slice();
ClockProfile( MainProfile.TimerId.Timers );
netServer.Slice();
ClockProfile( MainProfile.TimerId.Network );
// Done with this iteration.
m_TotalProfile.Next();
m_CurrentProfile.Next();
}
}
catch ( Exception e )
{
HandleCrashed( e );
}
m_TimerThread.Stop();
}
private void _runPlanet(IDbConnection connection, int planetId, int currentTime)
{
if (Stoped)
{
return;
}
if (_activatedPlanetIds.Contains(planetId))
{
return;
}
var planet = _getPlanet(connection, planetId);
if (planet == null)
{
return;
}
if (planet.UserId == Npc.SkagryGameUserId)
{
return;
}
var lastActive = UnixTime.ToTimestamp(planet.LastActive);
if (currentTime - lastActive < MIN_ATACK_DELTA_TIME_SECOND)
{
return;
}
if (planet.DangerLevel < 1)
{
return;
}
var dangerProportion = 0.5 / planet.DangerLevel;
var rand = _rand.NextDouble();
if (rand > dangerProportion)
{
return;
}
var agrLevel = _getFleetAgrLevel(planet.Hangar);
if (agrLevel < MIN_AGR_LEVEL)
{
return;
}
var chance = 0.5;
if (agrLevel < 100)
{
chance = 0.5;
}
else if (agrLevel < 500)
{
chance = 0.7;
}
else if (agrLevel <= 1000)
{
chance = 0.8;
}
else
{
chance = 0.9;
}
rand = _rand.NextDouble();
if (rand > chance)
{
return;
}
var activePlanetTasks = TimerExecutor.GetTaskTimersByPlanetId(planet.Id);
if (activePlanetTasks.Count > MAX_TASK_IN_PLANET_LIMIT ||
activePlanetTasks.GetSkaryTaskCountInPlanet(planet.Id) > 0)
{
_delayLockPlanet(planetId, activePlanetTasks);
return;
}
if (activePlanetTasks.Count(i => i.InProgress || i.IsDisposed) > 0)
{
return;
}
var targetUserId = planet.UserId;
var userTasks = TimerExecutor.GetUserTaskTimers(targetUserId);
if (userTasks != null && userTasks.Count > MAX_USER_TASK_LIMIT)
{
var maxDelay = userTasks.Where(i => !i.InProgress && !i.IsDisposed).Select(i => i.Timer.Interval).Max();
var delay = maxDelay * 2;
foreach (var task in userTasks)
{
var pid = _getPlanetId(task);
if (pid != planetId)
{
_delayLockPlanet(pid, delay);
}
}
if (!_activatedPlanetIds.Contains(planetId))
{
_delayLockPlanet(planetId, delay);
}
return;
}
_createTaskToUser(connection, planet);
}
public void RunTaskItem(IDbConnection connection, int taskId)
{
if (taskId == 0)
{
return;
}
var taskItem = _uTaskService.GetByTaskId(connection, taskId, true);
if (taskItem == null)
{
_demonLog.CrateAndSave("UserTaskDataModel", "TaskRunner.RunTaskItem.taskItemIsNull", new { TaskId = taskId }, taskId);
return;
}
if (taskItem.TaskEnd)
{
return;
}
lock (_runTaskItemLocker)
{
var currUtcTime = DateTime.UtcNow;
var curTime = UnixTime.ToTimestamp(currUtcTime);
var endTime = taskItem.DateActivate + taskItem.Duration;
var timers = TimerExecutor.GetTaskTimersByTaskId(taskItem.Id);
if (timers.Count > 1)
{
_demonLog.CrateAndSave("UserTaskDataModel", "TaskRunner.RunTaskItem.multipleTimers_", new { TaskId = taskId }, taskId);
return;
}
var timer = timers.FirstOrDefault();
if (timer == null)
{
var delay = endTime - curTime;
if (delay > 0)
{
_onUserTaskCreated(delay, taskItem.Id, taskItem.SourceUserId, taskItem.TargetPlanetId);
return;
}
}
else if (!timer.InProgress || timer.IsDisposed)
{
return;
}
taskItem = _uTaskService.SetUpdateInProgress(connection, taskItem);
#region Body
try
{
var targetPlanetId = taskItem.TargetPlanetId;
var targetPlanetSrc = _gDetailPlanetService.GetPlanet(connection, targetPlanetId);
var defenderUser = _gameUserService.GetGameUser(connection, targetPlanetSrc.UserId);
var defendorPremium = _storeService.GetPremiumWorkModel(connection, defenderUser.Id);
var defendorPlanet = _planetRunner.RunSinglePlanet(connection, targetPlanetSrc, defendorPremium, _gDetailPlanetService);
//result.TimeOver = true;
//var user = taskItem.user;
UserDataModel sourceUser = null;
var npc = NpcHelper.GetNpcByName(Npc.SkagyName);
if (taskItem.SourceUserId == defenderUser.Id)
{
taskItem.IsAtack = false;
taskItem.IsTransfer = true;
sourceUser = defenderUser;
}
else
{
taskItem.IsAtack = true;
taskItem.IsTransfer = false;
if (taskItem.SourceUserId == npc.NpcUser.Id)
{
sourceUser = npc.NpcUser;
}
else
{
sourceUser = _gameUserService.GetGameUser(connection, taskItem.SourceUserId);
}
}
#region IsAtack
if (taskItem.IsAtack)
{
var atackModel = new TmpAtackModel
{
TaskItem = taskItem,
SourceUser = new TmpAtackItem
{
User = sourceUser
},
DefendorUser = new TmpAtackItem
{
User = defenderUser,
Premium = defendorPremium
},
DefendorPlanet = defendorPlanet,
Npc = npc,
BattleTime = curTime,
BattleDtTime = currUtcTime
};
_atack(connection, atackModel);
var ti = atackModel.TaskItem.CloneDeep();
var report = atackModel.ReportDataModel.CloneDeep();
int?newTotalWinnerUserCc = atackModel.NewTotalWinnerUserCc;
Task.Factory.StartNew(() => { _uTaskService.NotyfyTaskFinished(ti, report, newTotalWinnerUserCc); });
return;
}
#endregion
#region IsTransfer
defendorPlanet.Hangar = UnitList.CalculateNewUnits(taskItem.SourceFleet, defendorPlanet.Hangar, true);
_gDetailPlanetService.AddOrUpdate(connection, defendorPlanet);
taskItem.TaskEnd = true;
_uTaskService.UnlockUpdateInProgress(connection, taskItem.Id);
var updatedTask = _uTaskService.AddOrUpdate(connection, taskItem);
Task.Factory.StartNew(() => { _uTaskService.NotyfyTaskFinished(updatedTask); });
#endregion
}
catch (Exception e)
{
_demonLog.CrateAndSave("UserTaskDataModel", "TaskRunner.RunTaskItem.ExceptionTaskItemData", taskItem, taskItem.Id);
_demonLog.CrateAndSave("Exception", "TaskRunner.RunTaskItem.ExceptionData", e, taskItem.Id);
_uTaskService.UnlockUpdateInProgress(connection, taskItem.Id);
throw;
}
}
#endregion
}
