public void Awake()
{
InitialiseLoggers();
Instance = this;
MainMenuOpen = false;
if (Application.isMobilePlatform)
{
CurrentPlatform = Platform.Android;
Configuration = new AndroidConfiguration();
}
else
{
CurrentPlatform = Platform.PC;
Configuration = new PCConfiguration();
}
Guard.CheckIsNull(BuilderManager, "BuilderManager");
Guard.CheckIsNull(BuilderManager, "RoomManager");
Guard.CheckIsNull(BuilderManager, "PathfindingGrid");
Guard.CheckIsNull(AstarGO, "AstarGO");
DrawBuildingTilesGizmos = true;
DrawDoorLocationGizmos = false;
DrawGridVectorCoordinates = false;
DrawGridCoordinates = true;
}
/// <summary>
/// Construct OrganizationApi instance.
/// </summary>
/// <param name="authenticationContext"></param>
/// <param name="platformConfiguration"></param>
/// <param name="hierarchyApi"></param>
public OrganizationApi(IAuthenticationContext authenticationContext, IPlatformConfiguration platformConfiguration, IHierarchyApi hierarchyApi)
: base(authenticationContext)
{
this.authenticationContext = authenticationContext;
this.platformConfiguration = platformConfiguration;
this.hierarchyApi = hierarchyApi;
}
public PlatformProxy(IWebClientBuilder webClientBuilder, IPlatformConfiguration platformConfiguration, IPlatformTokenProvider platformTokenProvider, IPlatformHashProvider platformHashProvider, IPlatformParameterTranslator platformParameterTranslator)
{
_webClientBuilder = webClientBuilder;
_platformConfiguration = platformConfiguration;
_platformTokenProvider = platformTokenProvider;
_platformHashProvider = platformHashProvider;
_platformParameterTranslator = platformParameterTranslator;
}
/// <summary>
/// Gets the platform configuration.
/// </summary>
/// <returns>IPlatformConfiguration.</returns>
private IPlatformConfiguration GetPlatformConfiguration()
{
if (platformConfiguration == null)
{
platformConfiguration = DIResolver.Get <IPlatformConfiguration>();
}
return(platformConfiguration);
}
/// <summary>
/// Construct SiteMapApi instance
/// </summary>
/// <param name="authenticationContext"></param>
/// <param name="roleApi"></param>
/// <param name="organizationApi"></param>
/// <param name="permissionApi"></param>
/// <param name="platformConfiguration"></param>
/// <param name="siteMapFilePath"></param>
public SiteMapApi(IAuthenticationContext authenticationContext, IRoleApi roleApi, IOrganizationApi organizationApi, IPermissionApi permissionApi, IPlatformConfiguration platformConfiguration, string siteMapFilePath)
{
this.authenticationContext = authenticationContext;
this.roleApi = roleApi;
this.organizationApi = organizationApi;
this.permissionApi = permissionApi;
this.platformConfiguration = platformConfiguration;
this.siteMapFilePath = siteMapFilePath;
}
protected CodeBrixApplication(IPlatformConfiguration platformConfig)
: base(platformConfig?.Initializer)
{
//Important: The following code won't run until the base constructor has completed;
// so the PlatformConfiguration property may be null during the earliest parts of application startup.
PlatformConfiguration = platformConfig ?? throw new ArgumentNullException(nameof(platformConfig));
if (PlatformConfiguration.Container == null)
{
throw new ArgumentException("The 'Container' property of the platform configuration cannot be null.", nameof(platformConfig));
}
AppResourceHelper.SetApplication(this);
}
/// <summary>
/// Construct PermissionApi instance
/// </summary>
/// <param name="authenticationContext"></param>
/// <param name="membershipApi"></param>
/// <param name="roleApi"></param>
/// <param name="organizationApi"></param>
/// <param name="platformConfiguration"></param>
/// <param name="permissionConfigurationReader"></param>
public PermissionApi(IAuthenticationContext authenticationContext,
IMembershipApi membershipApi,
IRoleApi roleApi,
IOrganizationApi organizationApi,
IPlatformConfiguration platformConfiguration,
IPermissionConfigurationReader permissionConfigurationReader)
: base(authenticationContext)
{
this.authenticationContext = authenticationContext;
this.membershipApi = membershipApi;
this.roleApi = roleApi;
this.organizationApi = organizationApi;
this.platformConfiguration = platformConfiguration;
this.permissionConfigurationReader = permissionConfigurationReader;
}
/// <summary>
/// Initializes a new instance of the <see cref="OptionsControlViewModel" /> class.
/// </summary>
/// <param name="platformConfiguration">The platform configuration.</param>
/// <param name="modService">The mod service.</param>
/// <param name="positionSettingsService">The position settings service.</param>
/// <param name="externalEditorService">The external editor service.</param>
/// <param name="idGenerator">The identifier generator.</param>
/// <param name="logger">The logger.</param>
/// <param name="notificationAction">The notification action.</param>
/// <param name="localizationManager">The localization manager.</param>
/// <param name="updater">The updater.</param>
/// <param name="updaterService">The updater service.</param>
/// <param name="gameService">The game service.</param>
/// <param name="fileDialogAction">The file dialog action.</param>
public OptionsControlViewModel(IPlatformConfiguration platformConfiguration, IModService modService, INotificationPositionSettingsService positionSettingsService,
IExternalEditorService externalEditorService, IIDGenerator idGenerator, ILogger logger,
INotificationAction notificationAction, ILocalizationManager localizationManager, IUpdater updater,
IUpdaterService updaterService, IGameService gameService, IFileDialogAction fileDialogAction)
{
this.positionSettingsService = positionSettingsService;
this.gameService = gameService;
this.fileDialogAction = fileDialogAction;
this.updaterService = updaterService;
this.updater = updater;
this.localizationManager = localizationManager;
this.notificationAction = notificationAction;
this.logger = logger;
this.idGenerator = idGenerator;
this.externalEditorService = externalEditorService;
this.modService = modService;
this.platformConfiguration = platformConfiguration;
UpdatesAllowed = !platformConfiguration.GetOptions().Updates.Disable;
LeftMargin = new Thickness(20, 0, 0, 0);
LeftChildMargin = new Thickness(20, 10, 0, 0);
}
public App(IPlatformConfiguration platformConfig) : base(platformConfig)
{
}
//CODEBRIX-CONVERSION-NOTE: The original App() constructor (commented out below) was replaced
// with this standard constructor - and the InitializeComponent() call and navigate-to-MainPage
// logic has been moved to the (new) overridden OnInitialized() method.
public App(IPlatformConfiguration config = null) : base(config)
{
}
public PlatformHashProvider(IPlatformConfiguration platformConfiguration, IPlatformTokenProvider platformTokenProvider)
{
_platformConfiguration = platformConfiguration;
_platformTokenProvider = platformTokenProvider;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="applicationApi"></param>
/// <param name="platformConfiguration"></param>
public CredentialInstaller(IApplicationApi applicationApi, IPlatformConfiguration platformConfiguration)
{
this.applicationApi = applicationApi;
this.platformConfiguration = platformConfiguration;
}
public void Awake()
{
Instance = this;
Logger.Log(Logger.Initialisation, $"Our game mode is {GameRules.GameMode}");
Guard.CheckIsNull(GridGO, "GridGO", gameObject);
Guard.CheckIsNull(_mazeLevelManagerPrefab, "MazeLevelManagerPrefab", gameObject);
Guard.CheckIsNull(_mazeCharacterManagerPrefab, "_mazeCharacterManagerPrefab", gameObject);
Guard.CheckIsNull(_overworldCharacterManagerPrefab, "_overworldCharacterManagerPrefab", gameObject);
Guard.CheckIsNull(_mazeLevelSpriteManagerPrefab, "_mazeLevelSpriteManagerPrefab", gameObject);
Guard.CheckIsNull(_overworldSpriteManagerPrefab, "_overworldSpriteManagerPrefab", gameObject);
Guard.CheckIsNull(_overworldManagerPrefab, "_overworldManagerPrefab", gameObject);
Guard.CheckIsNull(_cameraContainerPrefab, "_cameraContainerPrefab", gameObject);
InitialiseLoggers();
if (PhotonNetwork.PlayerList.Length == 0)
{
if (GameRules.GamePlayerType != GamePlayerType.SplitScreenMultiplayer)
{
GameRules.SetGamePlayerType(GamePlayerType.SinglePlayer);
}
}
else
{
GameRules.SetGamePlayerType(GamePlayerType.NetworkMultiplayer);
}
PersistentGameManager.CurrentSceneType = _thisSceneType;
Logger.Warning($"We set the game type to {GameRules.GamePlayerType} in a {PersistentGameManager.CurrentSceneType} scene. The scene loading origin is {PersistentGameManager.SceneLoadOrigin}");
if (Application.isMobilePlatform)
{
PersistentGameManager.CurrentPlatform = Platform.Android;
Configuration = new AndroidConfiguration();
}
else
{
PersistentGameManager.CurrentPlatform = Platform.PC;
Configuration = new PCConfiguration();
}
KeyboardConfiguration = new KeyboardConfiguration();
switch (PersistentGameManager.CurrentSceneType)
{
case SceneType.Overworld:
Instantiate(_overworldSpriteManagerPrefab, transform);
Instantiate(_overworldCharacterManagerPrefab, transform);
Instantiate(_overworldManagerPrefab, transform);
break;
case SceneType.Maze:
Instantiate(_mazeLevelSpriteManagerPrefab, transform);
Instantiate(_mazeCharacterManagerPrefab, transform);
Instantiate(_mazeLevelManagerPrefab, transform);
break;
default:
Logger.Error($"Scenetype {PersistentGameManager.CurrentSceneType} is not implemented yet");
break;
}
Instantiate(_cameraContainerPrefab);
}
private static List <Target> MergeTargets(BuilderParameters parameters)
{
ValidateParameters(parameters);
List <Target> result = new List <Target>();
foreach (KeyValuePair <string, IApplicationConfiguration> applicationItem in parameters.ApplicationsConfiguration)
{
IApplicationConfiguration applicationConfiguration = applicationItem.Value;
IReadOnlyDictionary <string, ITargetConfiguration> applicationTargets = null;
IReadOnlyDictionary <string, ITargetConfiguration> targets;
if (applicationConfiguration.Targets.Count > 0) // does the application define specific targets or not ?
{
applicationTargets = applicationConfiguration.Targets;
targets = FilterTargets(parameters.TargetsConfiguration, applicationTargets); //filter global list of targets to be restricted to the ones accepted by the application
}
else //if not, use all defined target in the global configuration
{
targets = parameters.TargetsConfiguration;
}
//on each targets
foreach (KeyValuePair <string, ITargetConfiguration> targetItem in targets)
{
string targetName = targetItem.Key;
ITargetConfiguration targetConfiguration = targetItem.Value;
ITargetConfiguration applicationTargetConfiguration = applicationTargets?[targetName];
IReadOnlyDictionary <string, IPlatformConfiguration> applicationTargetPlatforms = null;
IReadOnlyDictionary <string, IPlatformConfiguration> targetPlatforms = null;
IReadOnlyDictionary <string, IPlatformConfiguration> platforms;
if (applicationTargetConfiguration != null && applicationTargetConfiguration.Platforms.Count > 0)
{
applicationTargetPlatforms = applicationTargetConfiguration.Platforms;
if (targetConfiguration.Platforms.Count > 0)
{
targetPlatforms = FilterPlatforms(targetConfiguration.Platforms, applicationTargetPlatforms); //filter list of platforms in target to the ones defined by the application
}
platforms = FilterPlatforms(parameters.PlatformsConfiguration, applicationTargetPlatforms); //filter global list of platforms to the ones defined in the application
}
else if (targetConfiguration.Platforms.Count > 0)
{
targetPlatforms = targetConfiguration.Platforms;
platforms = FilterPlatforms(parameters.PlatformsConfiguration, targetPlatforms); //filter global list of platforms to be restricted to the ones accepted by the target
}
else
{
platforms = parameters.PlatformsConfiguration;
}
foreach (KeyValuePair <string, IPlatformConfiguration> platformItem in platforms)
{
string platformName = platformItem.Key;
IPlatformConfiguration platformConfiguration = platformItem.Value;
IPlatformConfiguration targetPlatformConfiguration = targetPlatforms?[platformName];
IPlatformConfiguration applicationTargetPlatformConfiguration = applicationTargetPlatforms?[platformName];
IConfiguration rootLevel = parameters.RootConfiguration;
IConfiguration switchLevel = parameters.SwitchConfiguration;
IConfiguration platformLevel = platformConfiguration;
IConfiguration targetLevel = targetConfiguration;
IConfiguration applicationLevel = applicationConfiguration;
// merge platform specific detail in target level
if (targetPlatformConfiguration != null)
{
targetLevel = targetLevel.Merge(targetPlatformConfiguration);
}
// merge target and platform specific detail in application level
if (applicationTargetConfiguration != null)
{
IConfiguration applicationTargetLevel = applicationTargetConfiguration;
if (applicationTargetPlatformConfiguration != null)
{
applicationTargetLevel = applicationTargetLevel.Merge(applicationTargetPlatformConfiguration);
}
applicationLevel = applicationLevel.Merge(applicationTargetLevel);
}
IConfiguration configuration = rootLevel.Merge(switchLevel.Merge(platformLevel.Merge(targetLevel.Merge(applicationLevel))));
result.Add(new Target(applicationItem.Key, targetItem.Key, platformItem.Key, configuration));
}
}
}
return(result);
}
public void AddPlatform(string name, IPlatformConfiguration platformConfiguration)
{
_platformConfigurations.Add(name, platformConfiguration);
}
