void LoadLoggerConfig()
{
DataElement loggerConfig = GetConfiguration("logger");
if (loggerConfig.IsNull)
{
return;
}
int defaultThreshold = 0;
DataElement defaultModule = loggerConfig[CoreLogger.DefaultModuleName];
if (!defaultModule.IsNull)
{
defaultThreshold = CoreLogger.Severity.ParseSeverity(defaultModule);
}
CoreLogger.LogDebug(LoggerModules.GameApplication, "/////////////////////////// setting logger thresholds ////////////////////////");
foreach (string moduleName in CoreLogger.Modules)
{
CoreLogger.SetThreshold(moduleName, defaultThreshold);
}
CoreLogger.SetThreshold(defaultThreshold);
foreach (KeyValuePair <string, DataElement> kvp in loggerConfig.GetDataPairs())
{
string moduleName = kvp.Key;
int moduleThreshold = CoreLogger.Severity.ParseSeverity(kvp.Value);
CoreLogger.SetThreshold(moduleName, moduleThreshold);
}
}
public override void Execute()
{
CoreLogger.LogDebug(LoggerModules.SocialServices, "Execute IsLoggedIn " + isLoggedIn);
socialStateModel.WaitingForSocialLogin = false;
if (!isLoggedIn)
{
//toggleLoadingDialogSignal.Dispatch(false);
return;
}
SocialConnectData socialConnectData = new SocialConnectData();
socialConnectData.network = SocialNetwork.Facebook;
socialConnectData.email = socialNetworkService.Email;
socialConnectData.photoUrl = socialNetworkService.PhotoUrl;
socialConnectData.userName = socialNetworkService.UserName;
socialConnectData.userId = socialNetworkService.UserId;
socialConnectData.userToken = socialNetworkService.UserToken;
socialConnectData.initiatedByUser = true;
socialSync.ConnectToNetwork(socialConnectData);
}
public override void Execute()
{
CoreLogger.LogDebug("LoadBindingsCommand", "Execute");
List <BindingData> bindings = gsdkConfigModel.GetBindings();
foreach (BindingData binding in bindings)
{
try
{
string json = LitJson.JsonMapper.ToJson(new List <BindingData> {
binding
});
injectionBinder.ConsumeBindings(json);
Debug.Log("BindingLoading - Successfully binded: " + binding.ToString());
}
catch (InjectionException ex)
{
Debug.Log("BindingLoading - did not load binding: " + binding);
}
catch (BinderException ex)
{
Debug.Log("BindingLoading - did not load binding: " + binding);
Debug.LogWarning(ex.ToString());
}
}
LoadNullBindings();
}
void EnqueueServiceResolution <TService>(System.Action <TService> setter, bool blocking)
where TService : class, IService
{
if (blocking)
{
_taskQueue.Enqueue(() => {
TService service = _serviceResolver.Get <TService>();
setter(service);
});
return;
}
bool found = false;
TService foundService = null;
_taskQueue.Enqueue(() => {
_serviceResolver.Get <TService>((result, service) => {
foundService = service;
setter(service);
found = true;
});
});
_taskQueue.Parallelize(() => found, -1, string.Format("find service {0}", typeof(TService).Name)).Done += result => {
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("done preparing service {0}: {1}; provider is: {2}", typeof(TService).Name, result,
foundService == null ? "null" : foundService.GetType().Name));
};
}
/// <summary>
/// This is the part of the initialization sequence which is always synchronous -
/// it merely creates an instance of the GameApplication object, without doing any
/// initialization - there's no need to make it async., since it's fast anyway.
/// It's called by both the sync. and asnyc. versions of the CreateInstance method.
/// </summary>
/// <returns>The or get.</returns>
public static GameApplication CreateOrGet()
{
//if an instance has already been created, don't create a new one
s_instance = FindObjectOfType <GameApplication>();
if (s_instance != null)
{
CoreLogger.LogDebug(LoggerModules.GameApplication, "an instance of GameApplication has miraculously appeared...");
return(s_instance);
}
//we want to create the instance as it is defined in the resources folder
GameApplication instance;
Object prefab = LoadFrameworkResource(s_applicationResourceName);
if (prefab == null)
{
//no prefab found - we can still create a default
Debug.LogError(string.Format("Unable to load {0}.prefab - creating object with defaults", s_applicationResourceName));
GameObject appObj = new GameObject();
instance = appObj.AddComponent <GameApplication>();
}
else
{
GameObject appObj = Instantiate(prefab) as GameObject;
instance = appObj.GetComponent <GameApplication>();
}
GameObject.DontDestroyOnLoad(instance);
return(instance);
}
/*
* private ServerTime _serverTime;
* public ServerTime ServerTime { get { return _serverTime; } }
*
* private ModelSyncService _modelSyncService;
* public ModelSyncService ModelSyncService { get { return _modelSyncService; } }
*/
protected override IEnumerator ModuleInitializer()
{
Debug.Log("GameDbInitializer - ModuleInitializer start --------------------------------------------1");
_gameDB = new GameDB();
if (Application.loadedLevelName.Contains("Upload") && Application.isEditor)
{
_gameDB.InitLocalDB();
}
else
{
_gameDB.InitDB();
}
/*
* _serverTime = new ServerTime();
*
* _modelSyncService = new ModelSyncService();
* _modelSyncService.Init(_gameDB,this,_serverTime);
* //yield return StartCoroutine(_modelSyncService.PregameConnect());
* //StartCoroutine(_modelSyncService.AsyncLoop());
*
* _modelSyncService.Start();
*
* yield return StartCoroutine(_modelSyncService.WaitForState(ModelSyncService.SyncLoopState.Connected));
*/
CoreLogger.LogDebug("GameDbInitializer", "done with Init");
Debug.Log("GameDbInitializer - ModuleInitializer end --------------------------------------------2");
yield break;
}
IEnumerator Loop()
{
CoreLogger.LogDebug(LoggerModules.Tasks, string.Format("dispatcher {0} starting up!", name));
while (true)
{
int count = 0;
while (_news.Count > 0 && (count < actionsPerIteration || actionsPerIteration < 0))
{
_post.Add(_news.Dequeue());
count++;
}
foreach (Entry entry in _post)
{
entry.delay--;
if (entry.delay == 0)
{
try
{
entry.action();
} catch (System.Exception ex)
{
CoreLogger.LogError(LoggerModules.Tasks, string.Format("Error in Dispatcher Action: {0}\n Stack Trace:{1}", ex.Message, ex.StackTrace));
}
}
}
_post.RemoveAll(e => e.delay == 0);
yield return(null);
}
}
public void Get <TService>(System.Action <TaskEnding, TService> handler)
where TService : IService
{
IService service = FetchService(typeof(TService));
if (service != null)
{
handler(TaskEnding.Done, (TService)service);
return;
}
//no active provider - see if we can activate a dormant provider
CoreLogger.LogDebug(_loggerModule, string.Format("adding service {0}, now looking for provider...", typeof(TService).Name));
_taskFactory.FromEnumerableAction(() =>
ActivateServiceProvider(typeof(TService), s => {
if (s == null)
{
handler(TaskEnding.Cancelled, default(TService));
}
else
{
handler(TaskEnding.Done, (TService)s);
}
})).Start(-1);
}
IService FetchService(Type serviceType)
{
//an active provider already assigned to this service?
IService serviceProvider;
if (_serviceProviders.TryGetValue(serviceType, out serviceProvider))
{
return(serviceProvider);
}
//do we even know this service?
if (!_unprovidedServices.Contains(serviceType))
{
CoreLogger.LogNotice(_loggerModule, string.Format("requested service {0} is not known to this container!", serviceType.Name));
return(null);
}
//do we have an active provider for this service? an active provider is probably already providing other services,
//but can provide this as well
IService activeProvider = _activeProviders.Where(p => p.GetType().GetInterfaces().Contains(serviceType)).FirstOrDefault();
if (activeProvider != null)
{
CoreLogger.LogDebug(_loggerModule, string.Format("adding service {0}, provided by {1}", serviceType.Name, activeProvider.GetType().Name));
_serviceProviders[serviceType] = activeProvider;
return(activeProvider);
}
return(null);
}
void EnqueueAddProviders()
{
_taskQueue.Enqueue(() => {
_serviceResolver.AddProviders(GetComponentsInChildren(typeof(IService)).Cast <IService>());
}, "Add Service Providers to Service Resolver").Done += result => {
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("done finding service providers: {0}", result));
};
}
public override void Execute()
{
CoreLogger.LogDebug("ShowRateUsCommand", "Execute");
if (rateUsService.ShouldShowRateUs())
{
modalityManager.Add(new AppModalHandle("GamePopups/RateUsModal", IModalMaskType.Masked), true);
}
}
public TModule Get <TModule>()
where TModule : IModule
{
IModule module;
if (_modules.TryGetValue(typeof(TModule), out module))
{
return((TModule)module);
}
if (!_availableModules.TryGetValue(typeof(TModule), out module))
{
return(default(TModule));
}
if (_modulesInInitState.ContainsKey(module))
{
CoreLogger.LogError(LoggerModules.GameApplication, string.Format("module {0} is initializing and cannot be retrieved at the moment", module.GetType().Name));
return(default(TModule));
}
ITask init = module.GetInitializer(this);
if (init == null)
{
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("unable to retrieve initializer for module {0} failed", module.GetType().Name));
_failedModules[typeof(TModule)] = module;
_availableModules.Remove(typeof(TModule));
return(default(TModule));
}
_modulesInInitState[module] = init;
TaskEnding result = init.Handle();
_modulesInInitState.Remove(module);
if (result.IsOk())
{
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("successfully initialized module {0}", module.GetType().Name));
_modules[typeof(TModule)] = module;
_availableModules.Remove(typeof(TModule));
}
else
{
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("failed to initialize module {0}", module.GetType().Name));
_failedModules[typeof(TModule)] = module;
_availableModules.Remove(typeof(TModule));
return(default(TModule));
}
if (_started)
{
module.StartModule();
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("starting module {0}", module.GetType().Name));
}
return((TModule)module);
}
void EnqueueCreateResolvers()
{
_taskQueue.Enqueue(() => {
CreateServiceResolver();
CreateModuleContainer();
}, "Create Resolvers").Done += result => {
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("done creating module containers: {0}", result));
};
}
public void Init(int fromStage, int toStage, System.Action handler)
{
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("requesgted non blocking initialization of modules stages {0} to {1}; total available: {2}", fromStage, toStage, _availableModules.Count));
int pending = 0;
ICollection <ITask> tasks = new List <ITask>();
IList <KeyValuePair <Type, IModule> > modulesToRemove = new List <KeyValuePair <Type, IModule> >();
foreach (KeyValuePair <Type, IModule> kvp in _availableModules.Where(kvp => (kvp.Value.Stage >= fromStage) && (kvp.Value.Stage <= toStage)))
{
//always remember to create a local-scoped variable within foreach loops that use lambdas!!!
IModule localModule = kvp.Value;
if (!_modules.ContainsKey(localModule.GetType()))
{
ITask init = localModule.GetInitializer(this);
if (init != null)
{
tasks.Add(init);
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("located module {0} - starting init", localModule.GetType().Name));
init.Done += result => {
if (result.IsOk())
{
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("successfully done with module {0} ({1}); {2} modules remaining", localModule.GetType().Name, result, pending));
_modules[localModule.GetType()] = localModule;
}
else
{
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("failed with module {0} ({1}); {2} modules remaining", localModule.GetType().Name, result, pending));
_failedModules[localModule.GetType()] = localModule;
}
};
}
else
{
CoreLogger.LogError(LoggerModules.GameApplication, string.Format("failed to retrieve initializer for module {0}", localModule.GetType().Name));
_failedModules[localModule.GetType()] = localModule;
}
}
}
_taskFactory.Parallelize(tasks).Start(result => {
handler();
});
foreach (KeyValuePair <Type, IModule> toRemove in modulesToRemove)
{
_availableModules.Remove(toRemove);
}
}
IService ActivateServiceProvider(Type serviceType)
{
//non-active providers that implement the requested interface, sorted by priority
List <ProviderWithPriority> dormantProviders = _dormantProviders.Where(p => p.Provider.GetType().GetInterfaces().Contains(serviceType)).ToList();
dormantProviders.Sort((p1, p2) => p1.Priority.CompareTo(p2.Priority));
// IEnumerable<TBase> dormantProviders = _dormantProviders.Where(p => p.Provider.GetType().GetInterfaces().Contains(serviceType))
// .OrderBy(p => p.Priority).Select(p => p.Provider);
foreach (IService dormantProvider in dormantProviders.Select(p => p.Provider))
{
if (InitNow(dormantProvider))
{
CoreLogger.LogDebug(_loggerModule, string.Format("successfully iniialized provider {0} for service {1}", dormantProvider.GetType().Name, serviceType.Name));
_serviceProviders[serviceType] = dormantProvider;
_dormantProviders.Remove(_dormantProviders.First(p => p.Provider == dormantProvider));
_activeProviders.Add(dormantProvider);
_unprovidedServices.Remove(serviceType);
return(dormantProvider);
}
else
{
CoreLogger.LogDebug(_loggerModule, string.Format("failed to initalize provider {0} for service {1}", dormantProvider.GetType().Name, serviceType.Name));
_dormantProviders.Remove(_dormantProviders.First(p => p.Provider == dormantProvider));
_failedProviders.Add(dormantProvider);
}
}
foreach (KeyValuePair <Type, System.Func <IService> > kvp in _providerFactories)
{
if (kvp.Key.GetInterfaces().Contains(serviceType))
{
IService provider = kvp.Value();
if (provider != null)
{
if (InitNow(provider))
{
CoreLogger.LogDebug(_loggerModule, string.Format("successfully iniialized provider {0} for service {1}", provider.GetType().Name, serviceType.Name));
_serviceProviders[serviceType] = provider;
_activeProviders.Add(provider);
_unprovidedServices.Remove(serviceType);
return(provider);
}
else
{
CoreLogger.LogDebug(_loggerModule, string.Format("failed to initalize provider for service {0}", serviceType.Name));
}
}
}
}
return(null);
}
private IEnumerator ShowSplashScreen()
{
_renderer.sprite = null;
int numTasks = Count;
CoreLogger.LogDebug(_loggerModule, string.Format("starting with {0} sprites and {1} tasks...", segments.Length, numTasks));
if (segments.Length < 1)
{
while (TasksPending)
{
yield return(new WaitForEndOfFrame());
}
CoreLogger.LogDebug(_loggerModule, string.Format("finished with 0 sprites and {0} tasks", numTasks));
Done();
yield break;
}
int i = 0;
while (TasksPending)
{
_captureCamera.Capture();
if (_renderer.sprite != null)
{
_switchTime = Time.time;
}
yield return(null);
SplashScreenSegment segment = segments[_splashIndex];
float waitTime = SetSprite(segment);
yield return(new WaitForSeconds(waitTime));
i++;
if (cyclic)
{
_splashIndex = (_splashIndex + 1) % segments.Length;
}
else
{
_splashIndex = Mathf.Min(_splashIndex + 1, segments.Length - 1);
}
}
CoreLogger.LogDebug(_loggerModule, string.Format("done showing {0} sprites out of {1}, with {2} tasks", i, segments.Length, numTasks));
Done();
}
public void StartProviders()
{
CoreLogger.LogDebug(_loggerModule, string.Format("resolver starting all providers..."));
foreach (Type serviceType in _unprovidedServices)
{
IService provider = Get(serviceType);
if (provider != null)
{
CoreLogger.LogDebug(_loggerModule, string.Format("resolver will now provide for service {0} with {1}", serviceType.Name, provider.GetType().Name));
}
}
}
public override void Execute()
{
CoreLogger.LogDebug("AchievementsButtonCommand", "Execute");
socialService.ShowAchievements();
//socialNetworkService.Init();
// GeneralDialogData data = new GeneralDialogData();
// data.buttons.Add(new BasicDialogButtonData("button1"));
// data.isCloseOnOutSideTap=false;
// generalDialog.Show(data);
}
public void AddProvider(IService provider, int priority = 0)
{
//check if it is already here - either as an active provider, or as a dormant one
if (IsProviderKnown(provider))
{
CoreLogger.LogDebug(_loggerModule, string.Format("provider {0} already handled by this container", provider.GetType().Name));
return;
}
//if not, it is first a dormant one
_dormantProviders.Add(new ProviderWithPriority {
Provider = provider, Priority = priority
});
}
public IService Get(Type serviceType)
{
IService service = FetchService(serviceType);
if (service != null)
{
return(service);
}
//no active provider - see if we can activate a dormant provider
CoreLogger.LogDebug(_loggerModule, string.Format("adding service {0}, now looking for provider...", serviceType.Name));
return(ActivateServiceProvider(serviceType));
}
public void Connect()
{
if (_socket != null)
{
_socket.Disconnect(false);
_socket = null;
}
CoreLogger.LogDebug("ServerLoggerProvider", "creating socket...");
try {
AddressFamily addressFamily = AddressFamily.InterNetwork;
SocketType socketType = SocketType.Stream;
ProtocolType protocolType = ProtocolType.Tcp;
_socket = new Socket(addressFamily, socketType, protocolType);
CoreLogger.LogInfo("ServerLoggerProvider", "socket created");
_socket.SendTimeout = sendTimeout;
} catch (Exception ex) {
CoreLogger.LogWarning("ServerLoggerProvider", string.Format("failed to create socket: {0}, stack: {1} - reverting to previous logger", ex.Message, ex.StackTrace));
_socket = null;
return;
}
IPEndPoint remoteEndPoint = GetRemoteEndPoint();
CoreLogger.LogInfo("ServerLoggerProvider", string.Format("server is in {0}", remoteEndPoint));
try {
_socket.Connect(remoteEndPoint);
} catch (Exception ex) {
CoreLogger.LogWarning("ServerLoggerProvider", "failed to connect to socket: " + ex.Message);
_socket = null;
return;
}
foreach (string module in CoreLogger.Modules)
{
string msg = string.Format("+node|{0}|TabTaleLog\r\n", module);
int sent = _socket.Send(msg.ToByteArray(Encoding.ASCII));
if (sent != msg.Length)
{
_oldLogWarning("ServerLoggerProvider", "failed to send registraion of module " + module);
}
}
LogDebug("ServerLoggerProvider", "provider set");
}
void OnApplicationPause(bool pauseStatus)
{
CoreLogger.LogDebug("GameDbInitializer", "OnApplicationPause " + pauseStatus);
if (Application.platform.IsEditor())
{
return;
}
/*
* if(!pauseStatus && _modelSyncService!=null){
* _modelSyncService.RestartFlowAfterBackground();
*
* }
*/
}
public override void Execute()
{
CoreLogger.LogDebug("ShowAppShelfCommand : Attempting to show app shelf");
if (locationManager.IsReady(ApplicationLocation.MoreApps))
{
Retain();
popupHandle = locationManager.Get(ApplicationLocation.MoreApps);
popupHandle.Closed.AddListener(HandleCloseResult);
popupHandle.Open(HandleShowResult);
}
else
{
Debug.LogWarning("ShowAppShelfCommand - Will not show app shelf, location not ready");
}
}
public void StartModule()
{
CoreLogger.LogDebug("StrangeRoot", string.Format("StartModule"));
_mainContext = new MainContext(this);
context = _mainContext;
GameObject go = new GameObject();
go.name = "GameRoot";
_gameRoot = go.AddComponent <GameRoot>();
_gameRoot.Init(this.gameObject);
//HookupApplicationEvents(); //TODO: Uncomment
StartCoroutine(StartCoro());
}
/// <summary>
/// This initializes the GameApplication singleton as a blocking call - it means
/// that access to Instance is valied immediately as this method returns.
/// </summary>
public static GameApplication CreateInstanceSync()
{
#if UNITY_EDITOR
s_requestingScene = "";
#endif
if (s_instance != null)
{
CoreLogger.LogError(LoggerModules.GameApplication, "calling GameApplication sync init while in async init - this is a serious error, unless in a special debug mode!!");
return(s_instance);
}
CoreLogger.LogDebug(LoggerModules.GameApplication, "creating GameApplication instance synchronously");
GameApplication instance = CreateOrGet();
if (instance == null)
{
CoreLogger.LogCritical(LoggerModules.GameApplication, "unable to obtain kernel instance!");
return(null);
}
if (!instance.AllowSynchronousCreation)
{
if (instance.synchronousCreationFallbackScene != null && instance.synchronousCreationFallbackScene != "")
{
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("synchronous creation not allowed in this game - " +
"reverting to scene {0}", instance.synchronousCreationFallbackScene));
string scene = instance.synchronousCreationFallbackScene;
DestroyObject(instance.gameObject);
#if UNITY_EDITOR
GameApplication.Init(scene);
#endif
return(null);
}
CoreLogger.LogCritical(LoggerModules.GameApplication, "synchrnous creation not allowed in this Game!!!");
return(null);
}
IEnumerator steps = instance.Init(true);
while (steps.MoveNext())
{
}
return(instance);
}
/// <summary>
/// Go over all existing modules, and initialize them, if possible immediately.
/// </summary>
public void Init(int fromStage, int toStage)
{
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("requested blocking initialization of modules stages {0} to {1}", fromStage, toStage));
IList <KeyValuePair <Type, IModule> > modulesToRemove = new List <KeyValuePair <Type, IModule> >();
foreach (KeyValuePair <Type, IModule> kvp in _availableModules.Where(kvp => (kvp.Value.Stage >= fromStage) && (kvp.Value.Stage <= toStage)))
{
IModule module = kvp.Value;
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("located module {0}", module.GetType().Name));
modulesToRemove.Add(kvp);
if (!_modules.ContainsKey(module.GetType()))
{
ITask init = module.GetInitializer(this);
if (init != null)
{
TaskEnding result = init.Handle();
if (result.IsOk())
{
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("successfully initialized module {0}", module.GetType().Name));
_modules[module.GetType()] = module;
}
else
{
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("failed to initalize module {0}: {1}", module.GetType().Name, result));
_failedModules[module.GetType()] = module;
}
}
else
{
CoreLogger.LogError(LoggerModules.GameApplication, string.Format("failed to retrieve initializer for module {0}", module.GetType().Name));
_failedModules[module.GetType()] = module;
}
}
}
foreach (KeyValuePair <Type, IModule> toRemove in modulesToRemove)
{
_availableModules.Remove(toRemove);
}
}
/// <summary>
/// Sets the next sprite on the splash, handling
/// transition effects if defined.
/// </summary>
/// <returns>Amount of seconds which are the minimum wait time for this sprite.</returns>
/// <param name="sprite">Sprite.</param>
private float SetSprite(SplashScreenSegment segment)
{
if (_renderer.sprite == segment.sprite)
{
return(0f);
}
CoreLogger.LogDebug(_loggerModule, "setting new sprite");
_renderer.sprite = segment.sprite;
if (autoFit)
{
AutoFit();
}
float waitTime = (_processor != null ? Mathf.Max(segment.delay, transition.duration) : segment.delay);
return(waitTime);
}
/// <summary>
/// Adds a managed service to this resolver. If a provider is present, the
/// resolver will now know how to return it in response to requests for this
/// service. The service must derive from TBase.
/// </summary>
/// <returns><c>true</c>, if service was added, <c>false</c> otherwise. A service will
/// not be added if it does not derive from TBase</returns>
/// <param name="serviceType">Service type.</param>
public bool AddService(Type serviceType)
{
//check if service is relevant
if (!typeof(IService).IsAssignableFrom(serviceType))
{
CoreLogger.LogWarning(_loggerModule, string.Format("cannot add incompatible type {0} to loader of {1}", serviceType.Name, typeof(IService).Name));
return(false);
}
//if so, check if it's already here
if (IsServiceKnown(serviceType))
{
CoreLogger.LogDebug(_loggerModule, string.Format("service {0} already handled by this container", serviceType.Name));
return(true);
}
//now add it
_unprovidedServices.Add(serviceType);
return(true);
}
public static void Init(string initSceneName)
{
if (s_instance != null)
{
return;
}
if (initSceneName == null || initSceneName == "")
{
CoreLogger.LogDebug(LoggerModules.GameApplication, "request to init GameApplication synchronously");
IGameApplication app = GameApplication.Instance;
if (app == null)
{
CoreLogger.LogCritical(LoggerModules.GameApplication, "failed to create GameApplication!");
return;
}
}
s_requestingScene = Application.loadedLevelName;
Application.LoadLevel(initSceneName);
}
public void Start()
{
if (_started)
{
CoreLogger.LogWarning(LoggerModules.GameApplication, "Start called twice!");
return;
}
foreach (IModule module in _modules.Values)
{
CoreLogger.LogDebug(LoggerModules.GameApplication, string.Format("starting module {0}", module.GetType().Name));
try
{
module.StartModule();
} catch (Exception ex)
{
CoreLogger.LogError(LoggerModules.GameApplication, string.Format("failed to initialize module {0}:{1}", module.GetType().Name, ex));
}
}
_started = true;
}
