private IActorRef CreateActor(WorldActorState state, CreatePlayerEntityActorMessage message)
{
//Create the actor and tell it to initialize.
IActorRef actorRef = state.WorldActorFactory.ActorOf(Resolver.Create <DefaultPlayerEntityActor>(), message.EntityGuid.RawGuidValue.ToString());
DefaultPlayerEntityActor.InitializeActor(actorRef, new DefaultPlayerEntityActorState(EntityDataMappable.RetrieveEntity(message.EntityGuid), message.EntityGuid, InterestMappable.RetrieveEntity(message.EntityGuid), SendServiceMappable.RetrieveEntity(message.EntityGuid)));
//Actors aren't removed from this
//they are just replaced with nobody.
if (ActorRefMappable.ContainsKey(message.EntityGuid))
{
//If nobody, all good. Otherwise THIS SHOULD NEVER HAPPEN
if (ActorRefMappable[message.EntityGuid].IsNobody())
{
ActorRefMappable.ReplaceObject(message.EntityGuid, actorRef);
}
else
{
throw new InvalidOperationException($"World attempted to spawn multiple of the same player actor/"); //this will literally kill the world actor.
}
}
else
{
ActorRefMappable.AddObject(message.EntityGuid, actorRef);
}
if (Logger.IsInfoEnabled)
{
Logger.Info($"Created Player Actor: {typeof(DefaultPlayerEntityActor)} for Entity: {message.EntityGuid}");
}
return(actorRef);
}
public void MultipleValuesFoundTest()
{
ApplicationContext context = new ApplicationContext();
context.Resolvers.Add(Resolver.Create(new Func <int>(() => 10)));
context.Resolvers.Add(Resolver.Create(new Func <int>(() => 10)));
context.Resolve <int>();
}
private IStream <SearchDeviceState> CreateStateStream()
{
if (_stream != null)
{
return(_stream);
}
var taskRunService = Task.Create(_service.RunService);
var taskStartSearching = Task.Create(_service.StartSearching);
var taskStopSearching = Task.Create(_service.StopSearching);
var taskStopService = Task.Create(_service.StopService);
var resolveRunService =
Resolver.Create <SearchDeviceState>(previous => previous == SearchDeviceState.STOP_SERVICE);
var resolveStartSearching =
Resolver.Create <SearchDeviceState>(
(previous) => {
return((previous == SearchDeviceState.RUN_SERVICE) || (previous == SearchDeviceState.STOP_SEARCHING));
});
var resolveStopSearching =
Resolver.Create <SearchDeviceState>(
previous => previous == SearchDeviceState.START_SEARCHING
);
var resolveStopService =
Resolver.Create <SearchDeviceState>(
previous => previous != SearchDeviceState.STOP_SERVICE
);
var transitions = TransitionPool.Create(
new Dictionary <SearchDeviceState, ITransition <SearchDeviceState> > {
{
SearchDeviceState.RUN_SERVICE,
Transition.Create <SearchDeviceState>(
SearchDeviceState.RUN_SERVICE, taskRunService, resolveRunService
)
}, {
SearchDeviceState.START_SEARCHING,
Transition.Create <SearchDeviceState>(
SearchDeviceState.START_SEARCHING, taskStartSearching, resolveStartSearching
)
}, {
SearchDeviceState.STOP_SEARCHING,
Transition.Create <SearchDeviceState>(
SearchDeviceState.STOP_SEARCHING, taskStopSearching, resolveStopSearching
)
}, {
SearchDeviceState.STOP_SERVICE,
Transition.Create <SearchDeviceState>(
SearchDeviceState.STOP_SERVICE, taskStopService, resolveStopService
)
}
}
);
return(Stream.Create(SearchDeviceState.RUN_SERVICE, transitions));
}
public void DependencyTest()
{
ApplicationContext context = new ApplicationContext();
context.Resolvers.Add(Resolver.Create(new Func <int, double>((a) => 10.1)));
context.Resolvers.Add(Resolver.Create(new Func <int>(() => 5)));
double value = context.Resolve <double>();
Assert.AreEqual(10.1, value);
}
public void PrototypeTest()
{
ApplicationContext context = new ApplicationContext();
context.Resolvers.Add(Resolver.Create(new Func <object>(() => new object()), Scope.Prototype));
object first = context.Resolve <object>();
object second = context.Resolve <object>();
Assert.AreNotSame(first, second);
}
public void MergedDependencySingletonsTest()
{
ApplicationContext firstContext = new ApplicationContext();
firstContext.Resolvers.Add(Resolver.Create(new Func <int, double>((a) => 10.1)));
ApplicationContext context = firstContext.WithSingletons(5);
double value = context.Resolve <double>();
Assert.AreEqual(10.1, value);
}
public void ResolveAllWithListTypeTest()
{
ApplicationContext context = new ApplicationContext();
context.Resolvers.Add(Resolver.Create(new Func <int>(() => 10)));
context.Resolvers.Add(Resolver.Create(new Func <int>(() => 5)));
List <int> values = context.Resolve <List <int> >();
Assert.IsTrue(values.Contains(10));
Assert.IsTrue(values.Contains(5));
}
public App()
{
// initialize DI container
Resolver.Create();
ProcessService = new LauncherProcessService();
Logger = Resolver.Kernel.Get <ILog>();
SettingsService = Resolver.Kernel.Get <ISettingsService>();
VersionService.SetVersion(new LauncherVersion("beta"));
}
public void ResolveAllSubclassTest()
{
ApplicationContext context = new ApplicationContext();
context.Resolvers.Add(Resolver.Create(new Func <A>(() => new A())));
context.Resolvers.Add(Resolver.Create(new Func <B>(() => new B())));
context.Resolvers.Add(Resolver.Create(new Func <C>(() => new C())));
List <A> aValues = context.ResolveAll <A>();
List <B> bValues = context.ResolveAll <B>();
List <I> iValues = context.ResolveAll <I>();
Assert.AreEqual(2, aValues.Count);
Assert.AreEqual(1, bValues.Count);
Assert.AreEqual(3, iValues.Count);
}
public virtual object Create()
{
if (container.registeredTypes.ContainsKey(ToType))
{
Resolver nextResolver = container.registeredTypes[ToType];
if (nextResolver != this)
{
return(nextResolver.Create());
}
else
{
return(container.Create(ToType));
}
}
return(container.Create(ToType));
}
private void CreateActor(WorldActorState state, CreateGameObjectEntityActorMessage message)
{
//Even visual objects now get actors
EntityActorCreationResult actorCreationData = EntityActorFactory.Create(message.EntityGuid);
//Create the actor and tell it to initialize.
IActorRef actorRef = state.WorldActorFactory.ActorOf(Resolver.Create(actorCreationData.DesiredActorType), message.EntityGuid.RawGuidValue.ToString());
actorRef.Tell(actorCreationData.InitializationMessage);
ActorRefMappable.AddObject(message.EntityGuid, actorRef);
if (Logger.IsInfoEnabled)
{
Logger.Info($"Created GameObject Actor: {actorCreationData.DesiredActorType} for Entity: {message.EntityGuid}");
}
}
private void CreateActor(WorldActorState state, CreateCreatureEntityActorMessage message)
{
//Create the actor and tell it to initialize.
IActorRef actorRef = state.WorldActorFactory.ActorOf(Resolver.Create <DefaultCreatureEntityActor>(), message.EntityGuid.RawGuidValue.ToString());
//TODO: Move to factory.
CreatureInstanceModel instanceModel = CreatureInstanceMappable.RetrieveEntity(message.EntityGuid);
CreatureTemplateModel templateModel = CreatureTemplateMappable.RetrieveEntity(message.EntityGuid);
DefaultCreatureEntityActor.InitializeActor(actorRef, new DefaultCreatureActorState(EntityDataMappable.RetrieveEntity(message.EntityGuid), message.EntityGuid, instanceModel, templateModel, InterestMappable.RetrieveEntity(message.EntityGuid)));
ActorRefMappable.AddObject(message.EntityGuid, actorRef);
if (Logger.IsInfoEnabled)
{
Logger.Info($"Created Creature Actor: {typeof(DefaultCreatureEntityActor)} for Entity: {message.EntityGuid}");
}
}
static void Main(string[] args)
{
Resolver resolver = new Resolver();
resolver.Register <IBaseConfig>(() =>
{
return(new BaseConfig());
}, LifeTimeType.SingletonFunc);
var f1 = new Func <IBaseHandler> (() =>
{
return(new BaseHandler(resolver.Create <IBaseConfig>()));
});
var f = new TimedSingleton(new System.TimeSpan(0, 0, 4)).SingletonFunc <IBaseHandler>(f1);
resolver.Register(
new TimedSingleton(new System.TimeSpan(0, 0, 4))
.SingletonFunc(
new Func <IBaseHandler>(
() =>
{
return(new BaseHandler(resolver.Create <IBaseConfig>()));
})
));
var handler = resolver.Create <IBaseHandler>();
handler.Handle();
var handler2 = resolver.Create <IBaseHandler>();
handler2.Handle();
System.Threading.Thread.Sleep(5000);
var handler3 = resolver.Create <IBaseHandler>();
handler3.Handle();
var handler4 = resolver.Create <IBaseHandler>();
handler4.Handle();
}
