public void GetCityBytes_WhenPlayersInRegionArentInOrder_ShouldSucceed(
[Frozen] DefaultMultiObjectLock.Factory lockerFactory,
IMultiObjectLock locker,
IMiniMapRegionObject obj1,
IMiniMapRegionObject obj2,
MiniMapRegion miniMapRegion)
{
obj1.Hash.Returns(1);
obj2.Hash.Returns(2);
lockerFactory().Lock(Arg.Is <ILockable[]>(p => p.SequenceEqual(new[] { obj2, obj1 })))
.Returns(locker);
locker.When(p => p.SortLocks(Arg.Is <ILockable[]>(a => a.SequenceEqual(new[] { obj2, obj1 }))))
.Do(args => Array.Sort((ILockable[])args[0], DefaultMultiObjectLock.CompareObject));
locker.Do(Arg.Any <Func <bool> >()).Returns(callInfo =>
{
var action = callInfo.Arg <Func <bool> >();
return(action());
});
miniMapRegion.Add(obj2);
miniMapRegion.Add(obj1);
miniMapRegion.GetCityBytes().Should().NotBeNull();
}
public DefaultLocker(DefaultMultiObjectLock.Factory multiObjectLockFactory,
CallbackLock.Factory callbackLockFactory,
IGameObjectLocator locator)
{
this.multiObjectLockFactory = multiObjectLockFactory;
this.callbackLockFactory = callbackLockFactory;
this.locator = locator;
}
public Region(byte[] map, DefaultMultiObjectLock.Factory lockerFactory, IRegionLocator regionLocator, IRegionObjectListFactory regionObjectListFactory)
{
this.map = map;
this.lockerFactory = lockerFactory;
this.regionLocator = regionLocator;
tileObjects = regionObjectListFactory.CreateRegionObjectList();
primaryObjects = regionObjectListFactory.CreateRegionObjectList();
}
public BarbarianTribeManager(IDbManager dbManager,
IBarbarianTribeFactory barbarianTribeFactory,
IBarbarianTribeConfigurator barbarianTribeConfigurator,
IRegionManager regionManager,
DefaultMultiObjectLock.Factory multiObjectLockFactory,
ITileLocator tileLocator)
{
this.dbManager = dbManager;
this.barbarianTribeFactory = barbarianTribeFactory;
this.barbarianTribeConfigurator = barbarianTribeConfigurator;
this.regionManager = regionManager;
this.multiObjectLockFactory = multiObjectLockFactory;
this.tileLocator = tileLocator;
}
public void Lock_CityIdTroopId_WhenTroopIsNotFound_ShouldReturnEmptyLockAndNullCity(
[Frozen] IGameObjectLocator locator,
[FrozenMock] DefaultMultiObjectLock.Factory lockFactory,
IMultiObjectLock cityLock,
IMultiObjectLock emptyLock,
ICity city,
ITroopObject troop,
DefaultLocker locker)
{
lockFactory().Returns(cityLock, emptyLock);
ICity outCity;
locator.TryGetObjects(1, out outCity).Returns(call =>
{
call[1] = city;
return(true);
});
ITroopObject outTroop;
city.TryGetTroop(2, out outTroop).Returns(false);
ICity lockedCity;
ITroopObject lockedTroop;
var multiObjLock = locker.Lock(1, 2, out lockedCity, out lockedTroop);
((object)lockedCity).Should().BeNull();
lockedTroop.Should().BeNull();
multiObjLock.Should().Be(emptyLock);
emptyLock.Received(1)
.Lock(Arg.Is <ILockable[]>(itemsLocked => !itemsLocked.Any()));
cityLock.Received(1)
.Lock(Arg.Is <ILockable[]>(itemsLocked => itemsLocked.SequenceEqual(new[] { city })));
cityLock.Received(1).UnlockAll();
}
public void Load(Container container)
{
container.Options.ConstructorResolutionBehavior = new MostResolvableConstructorBehavior(container);
container.Register <IKernel>(() => new Ioc(container), Lifestyle.Singleton);
#region World/Map
var worldRegistration = Lifestyle.Singleton.CreateRegistration <World>(container);
container.AddRegistration(typeof(IWorld), worldRegistration);
container.AddRegistration(typeof(IGameObjectLocator), worldRegistration);
container.Register <IGlobal, Global>(Lifestyle.Singleton);
container.Register <IRegionManager, RegionManager>(Lifestyle.Singleton);
container.Register <IRegionLocator, RegionLocator>(Lifestyle.Singleton);
container.Register <RegionObjectList>();
container.Register <ICityManager, CityManager>(Lifestyle.Singleton);
container.Register <IForestManager, ForestManager>(Lifestyle.Singleton);
container.Register <IRoadManager, RoadManager>(Lifestyle.Singleton);
container.Register <IRoadPathFinder, RoadPathFinder>();
container.Register <IThemeManager, ThemeManager>(Lifestyle.Singleton);
container.Register <IStoreManager, StoreManager>(Lifestyle.Singleton);
container.Register <StoreSync>(Lifestyle.Singleton);
#endregion
#region General Comms
container.Register <BlockingBufferManager>(() => new BlockingBufferManager(2048, 7500), Lifestyle.Singleton);
container.Register <SocketAwaitablePool>(() => new SocketAwaitablePool(100), Lifestyle.Singleton);
container.Register <IChannel, Channel>(Lifestyle.Singleton);
container.Register <IPolicyServer, PolicyServer>(Lifestyle.Singleton);
container.Register <INetworkServer, AsyncTcpServer>(Lifestyle.Singleton);
container.Register <TServer>(() =>
{
var logger = LoggerFactory.Current.GetLogger <TSimpleServer>();
return(new TSimpleServer(new Notification.Processor(container.GetInstance <NotificationHandler>()), new TServerSocket(46000), logger.Warn));
}, Lifestyle.Singleton);
container.Register <Chat>(Lifestyle.Singleton);
container.Register <ICityTriggerManager, CityTriggerManager>(Lifestyle.Singleton);
container.Register <IQueueListener, QueueListener>(Lifestyle.Singleton);
container.Register <IQueueCommandProcessor>(() => new QueueCommandProcessor(container.GetInstance <PlayerQueueCommandsModule>()), Lifestyle.Singleton);
if (Config.database_load_players)
{
container.Register <ILoginHandler, MainSiteLoginHandler>(Lifestyle.Singleton);
}
else
{
container.Register <ILoginHandler, DummyLoginHandler>(Lifestyle.Singleton);
}
#endregion
#region Tribes
container.Register <ITribeManager, TribeManager>(Lifestyle.Singleton);
container.Register <ITribeLogger, TribeLogger>();
#endregion
#region Locking
container.Register <DefaultMultiObjectLock.Factory>(() => () => new DefaultMultiObjectLock(container.GetInstance <IDbManager>()), Lifestyle.Singleton);
container.Register <ILocker>(() =>
{
DefaultMultiObjectLock.Factory multiObjectLockFactory = () => new DefaultMultiObjectLock(container.GetInstance <IDbManager>());
return(new DefaultLocker(multiObjectLockFactory,
() => new CallbackLock(multiObjectLockFactory),
container.GetInstance <IGameObjectLocator>()));
}, Lifestyle.Singleton);
#endregion
#region Formulas
container.Register <Formula>(Lifestyle.Singleton);
container.Register <RequirementFormula>(Lifestyle.Singleton);
#endregion
#region CSV Factories
container.Register <FactoriesInitializer>(Lifestyle.Singleton);
container.Register <ActionRequirementFactory>(Lifestyle.Singleton);
container.Register <IStructureCsvFactory, StructureCsvFactory>(Lifestyle.Singleton);
container.Register <EffectRequirementFactory>(Lifestyle.Singleton);
container.Register <InitFactory>(Lifestyle.Singleton);
container.Register <PropertyFactory>(Lifestyle.Singleton);
container.Register <IRequirementCsvFactory, RequirementCsvFactory>(Lifestyle.Singleton);
container.Register <TechnologyFactory>(Lifestyle.Singleton);
container.Register <UnitFactory>(Lifestyle.Singleton);
container.Register <IObjectTypeFactory, ObjectTypeFactory>(Lifestyle.Singleton);
container.Register <UnitModFactory>(Lifestyle.Singleton);
container.Register <MapFactory>(Lifestyle.Singleton);
#endregion
#region Database
container.Register <IDbManager>(() => new MySqlDbManager(LoggerFactory.Current.GetLogger <IDbManager>(),
Config.database_host,
Config.database_username,
Config.database_password,
Config.database_database,
Config.database_timeout,
Config.database_max_connections,
Config.database_verbose), Lifestyle.Singleton);
#endregion
#region Battle
container.Register <IBattleReport, BattleReport>();
container.Register <IBattleManagerFactory, BattleManagerFactory>();
container.Register <IBattleReportWriter, SqlBattleReportWriter>();
container.Register <ICombatUnitFactory, CombatUnitFactory>(Lifestyle.Singleton);
container.Register <IBattleFormulas, BattleFormulas>(Lifestyle.Singleton);
#endregion
#region Processor
container.Register <CommandLineProcessor>(() => new CommandLineProcessor(container.GetInstance <AssignmentCommandLineModule>(),
container.GetInstance <PlayerCommandLineModule>(),
container.GetInstance <CityCommandLineModule>(),
container.GetInstance <ResourcesCommandLineModule>(),
container.GetInstance <TribeCommandLineModule>(),
container.GetInstance <StrongholdCommandLineModule>(),
container.GetInstance <RegionCommandsLineModule>(),
container.GetInstance <BarbarianTribeCommandsLineModule>(),
container.GetInstance <SystemCommandLineModule>(),
container.GetInstance <BarbarianTribeCommandsLineModule>()),
Lifestyle.Singleton);
container.Register <IProcessor>(() => new Processor(container.GetInstance <AssignmentCommandsModule>(),
container.GetInstance <BattleCommandsModule>(),
container.GetInstance <EventCommandsModule>(),
container.GetInstance <ChatCommandsModule>(),
container.GetInstance <CommandLineCommandsModule>(),
container.GetInstance <LoginCommandsModule>(),
container.GetInstance <MarketCommandsModule>(),
container.GetInstance <MiscCommandsModule>(),
container.GetInstance <PlayerCommandsModule>(),
container.GetInstance <RegionCommandsModule>(),
container.GetInstance <StructureCommandsModule>(),
container.GetInstance <TribeCommandsModule>(),
container.GetInstance <TribesmanCommandsModule>(),
container.GetInstance <StrongholdCommandsModule>(),
container.GetInstance <ProfileCommandsModule>(),
container.GetInstance <TroopCommandsModule>(),
container.GetInstance <StoreCommandsModule>()),
Lifestyle.Singleton);
#endregion
#region Utils
container.Register <SmartThreadPool>(() => new SmartThreadPool(), Lifestyle.Singleton);
container.Register <IScheduler>(() =>
{
ITaskScheduler taskScheduler;
if (Config.scheduler_use_smartthreadpoool)
{
var threadPool = container.GetInstance <SmartThreadPool>();
taskScheduler = new SmartThreadPoolTaskScheduler(threadPool.CreateWorkItemsGroup(Config.scheduler_threads));
}
else
{
taskScheduler = new LimitedConcurrencyLevelTaskScheduler.TaskFactory(new LimitedConcurrencyLevelTaskScheduler(Config.scheduler_threads));
}
return(new ThreadedScheduler(taskScheduler));
}, Lifestyle.Singleton);
container.Register <ITileLocator, TileLocator>();
container.Register <GetRandom>(() => new Random().Next);
container.Register <Procedure>(Lifestyle.Singleton);
container.Register <BattleProcedure>(Lifestyle.Singleton);
container.Register <StrongholdBattleProcedure>(Lifestyle.Singleton);
container.Register <CityBattleProcedure>(Lifestyle.Singleton);
container.Register <BarbarianTribeBattleProcedure>(Lifestyle.Singleton);
container.Register <CallbackProcedure>(Lifestyle.Singleton);
container.Register <Random>(() => new Random());
container.Register <ISystemVariableManager, SystemVariableManager>(Lifestyle.Singleton);
container.Register <SystemVariablesUpdater>(Lifestyle.Singleton);
#endregion
#region Stronghold
container.Register <IStrongholdManager, StrongholdManager>(Lifestyle.Singleton);
container.Register <IStrongholdConfigurator>(() => new StrongholdConfigurator(
new NameGenerator(Path.Combine(Config.maps_folder, "strongholdnames.txt")),
container.GetInstance <MapFactory>(),
container.GetInstance <ITileLocator>(),
container.GetInstance <IRegionManager>()), Lifestyle.Singleton);
if (Config.stronghold_bypass_activation)
{
container.Register <IStrongholdActivationCondition, DummyActivationCondition>();
}
else
{
container.Register <IStrongholdActivationCondition, StrongholdActivationCondition>();
}
container.Register <StrongholdActivationChecker>(Lifestyle.Singleton);
container.Register <StrongholdChecker>(Lifestyle.Singleton);
container.Register <IStrongholdFactory, StrongholdFactory>();
container.Register <IStrongholdManagerLogger, StrongholdManagerLogger>();
#endregion
#region Barbarian Tribe
container.Register <IBarbarianTribeManager, BarbarianTribeManager>(Lifestyle.Singleton);
container.Register <IBarbarianTribeConfigurator, BarbarianTribeWeightedConfigurator>(Lifestyle.Singleton);
container.Register <IBarbarianTribeFactory, BarbarianTribeFactory>();
container.Register <BarbarianTribeChecker>(Lifestyle.Singleton);
#endregion
#region City
container.Register <ICityChannel, CityChannel>(Lifestyle.Singleton);
container.Register <ICityFactory, CityFactory>(Lifestyle.Singleton);
container.Register <IGameObjectFactory, GameObjectFactory>(Lifestyle.Singleton);
#endregion
var allTypes = this.GetType().Assembly.GetTypes();
var allRegistrations = container.GetCurrentRegistrations().ToDictionary(p => p.ServiceType, p => p.Registration);
foreach (var factoryInterfaceType in allTypes.Where(type => type.IsInterface && type.Name.EndsWith("Factory")))
{
var implementingTypes = allTypes.Where(type => type.IsInterface == false &&
type.IsAbstract == false &&
type.IsGenericTypeDefinition == false &&
factoryInterfaceType.IsAssignableFrom(type))
.ToArray();
if (implementingTypes.Length == 0)
{
throw new Exception(string.Format("Factory without any implementations. Implement type {0}", factoryInterfaceType.Name));
}
// Check if already registered
if (allRegistrations.ContainsKey(factoryInterfaceType))
{
continue;
}
if (implementingTypes.Length > 1)
{
throw new Exception(string.Format("Found interface factory that has more than 1 implementation and was not registered {0}", factoryInterfaceType.Name));
}
container.Register(factoryInterfaceType, implementingTypes.First(), Lifestyle.Singleton);
}
}
public MiniMapRegion(DefaultMultiObjectLock.Factory lockerFactory, IGlobal global)
{
this.lockerFactory = lockerFactory;
this.global = global;
}
public CallbackLock(DefaultMultiObjectLock.Factory multiObjectLockFactory)
{
this.multiObjectLockFactory = multiObjectLockFactory;
}
