public override Entity FactoryMethod(Resources resources, Vector2 position)
{
ISimpleTileBuilder builder = new PlatformBuilder(resources, position);
director.Construct(builder);
return(builder.GetResult());
}
private void OnSceneGUI()
{
platform = target as PlatformBuilder;
Vector2 point = platform.GetEndPoint();
float size = HandleUtility.GetHandleSize(point);
Handles.color = Color.white;
if (selected)
{
EditorGUI.BeginChangeCheck();
point = Handles.PositionHandle(point, Quaternion.identity);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(platform, "Move Point");
EditorUtility.SetDirty(platform);
platform.SetLengthFromEndPoint(point);
}
}
else if (Handles.Button(point, Quaternion.identity, size * handleSize, size * pickSize, Handles.DotCap))
{
selected = true;
Repaint();
}
Handles.color = Color.gray;
Handles.DrawLine(platform.transform.position, point);
}
public static PlatformBuilder StartupAction(this PlatformBuilder builder, Func <IPlatform, Task> func)
{
builder.AddStartupActions(async provider =>
{
var platform = provider.GetService <IPlatform>();
await func(platform);
});
return(builder);
}
private void InitializeBuilders()
{
platformBuilder = new PlatformBuilder(platformParent, platformsStats.Platform, platformsStats.Corner, platformsStats.Finish,
platformsStats.LengthOfPlatform, platformsStats.WidthOfPlatform);
coinBuilder = new CoinBuilder(coinsParent, coinsStats.CoinsPrefab, maxLengthAmountCoins,
maxWidthAmountCoins, coinsStats.CoinsSide, PositionToSpawn.AfterObstacles);
obstacleBuilder = new ObstacleBuilder(obstaclesParent, obstaclesStats.ObstaclesPrefab, obstaclesStats.SideOfObstacles);
cubeBuilder = new CubeBuilder(cubesParent, cubesStats.CubesPrefab, cubesStats.SideCubes, PositionToSpawn.BeforeObstacles);
}
protected PlatformexTestKit()
{
var loggerFactory = new LoggerFactory();
Silo.AddService <ILoggerFactory>(loggerFactory);
Platform = new TestPlatform();
Builder = new PlatformBuilder(Platform);
Silo.AddService <IPlatform>(Platform);
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
PlatformBuilder myScript = (PlatformBuilder)target;
if (GUILayout.Button("Build Object"))
{
myScript.BuildObject();
}
}
public DevicePlatform(PlatformBuilder platformBuilder)
{
deviceType = platformBuilder.deviceType;
deviceId = platformBuilder.deviceId;
os = platformBuilder.os;
osVersion = platformBuilder.osVersion;
screenResolution = platformBuilder.screenResolution;
location = platformBuilder.location;
mobileInfo = platformBuilder.mobileInfo;
browserInfo = platformBuilder.browserInfo;
}
public static PlatformBuilder ConfigureWebApi(this PlatformBuilder builder, Action <PlatformexWebApiOptions> optionsBuilder)
{
var options = new PlatformexWebApiOptions("api");
optionsBuilder(options);
builder.AddConfigureServicesActions(collection =>
{
collection.AddSingleton(options);
});
return(builder);
}
public static PlatformBuilder WithConsole(this PlatformBuilder builder, Action <PlatformexGraphQlConsoleOptions> builderOptions)
{
var options = new PlatformexGraphQlConsoleOptions("graphql-console");
builderOptions(options);
builder.AddConfigureServicesActions(services =>
{
services.AddSingleton(options);
});
return(builder);
}
private void Awake()
{
Time.timeScale = 1f;
platformBuilder = new PlatformBuilder(platformPrefab, platformParent, platformsAmount, platformLength, cam);
StartCoroutine(platformBuilder.ChangePlatformsPosition());
FindBiggestLengthOfObstacle(out var length);
objectsBuilder =
new ObjectsBuilder(obstaclesPrefabs, coinsPrefabs, length, obstacleParent, amountOfChunks, platformLength, cam);
StartCoroutine(objectsBuilder.ChangeObstaclesPosition());
}
void OnGUI()
{
if (GUILayout.Button("Open Documentation"))
{
Application.OpenURL("https://github.com/horsley86/platform-builder-pro/wiki");
}
GUILayout.Space(20f);
material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), false);
if (GUILayout.Button("Create New"))
{
var sceneCameraTransform = SceneView.lastActiveSceneView.camera.transform;
PlatformHelper.CreateNewPlatform(material, sceneCameraTransform.position + sceneCameraTransform.forward * 10f);
}
if (Selection.activeTransform != null)
{
var platform = Selection.activeTransform.root.GetComponentInChildren <Platform>();
if (platform != null)
{
GUILayout.Space(20f);
GUILayout.Label("Platform Operations");
GUILayout.Space(5f);
if (platform.strategies == null || platform.strategies[0] == null)
{
platform.strategies = PlatformBuilder.GetStrategies();
}
//iterate through the platform's strategies and paint the active gui
for (var i = 0; i < platform.strategies.Length; i++)
{
if (GUILayout.Button(platform.strategies[i].GuiTitle))
{
//if (activeStrategyIndex != i)
//{
// platform.SetStrategy(platform.strategies[i]);
//}
platform.SetStrategy(platform.strategies[i]);
activeStrategyIndex = i;
}
if (activeStrategyIndex == i)
{
GUILayout.BeginVertical("box");
platform.strategies[i].DrawGui();
GUILayout.EndVertical();
}
}
}
}
}
private static void ConfigBuilderConfigService(IServiceCollection services, PlatformBuilder builder)
{
services.AddSingleton(new PlatformConfigContext
{
JwtConfig = builder.JwtConfigBuilder
});
services.AddSingleton <Hcs.Platform.PlatformModule.IPlatformFunctionService>(builder);
services.AddDbContext <PlatformDbContext>(builder.DbOptions);
services.AddDistributedMemoryCache(options => builder.distributedMemoryCacheOptions?.Invoke(options));
services.AddMemoryCache();
ConfigAuthorizaion(services, builder);
ConfigAuthentication(services, builder);
ConfigDataProcessorTasks(services, builder.GenericDataProcessorEntityTasks, services.BuildServiceProvider());
}
public static PlatformBuilder ConfigureGraphQl(this PlatformBuilder builder, Action <PlatformexGraphQlOptions> optionsBuilder)
{
var options = new PlatformexGraphQlOptions("graphql");
builder.AddConfigureServicesActions(services =>
{
optionsBuilder?.Invoke(options);
services.AddSingleton(options);
//services.AddSingleton<IDocumentExecuter, DocumentExecuter>();
//services.AddSingleton<IDocumentWriter, DocumentWriter>();
services.AddSingleton <Root>();
services.AddSingleton <ISchema, GraphSchemaInternal>();
services.AddGraphQL(_ =>
{
_.EnableMetrics = true;
//_.ExposeExceptions = true;
})
.AddSystemTextJson()
.AddErrorInfoProvider(opt => opt.ExposeExceptionStackTrace = true);
//services.AddTransient<IGraphQLRequestDeserializer, GraphQLRequestDeserializer>();
foreach (var query in builder.Definitions.Queries)
{
var handlerType = typeof(GraphQueryHandler <,>).MakeGenericType(query.Value.QueryType, query.Value.ResultType);
var handlerFullType = typeof(IGraphQueryHandler <,>).MakeGenericType(query.Value.QueryType, query.Value.ResultType);
services.AddSingleton(handlerFullType, handlerType);
//services.AddSingleton(provider => (IGraphQueryHandler) provider.GetService(handlerFullType));
}
});
UseExtensions.AddPreUseAction(app =>
{
if (app.ApplicationServices.GetService(typeof(PlatformexGraphQlOptions)) is PlatformexGraphQlOptions optionsGraphQl)
{
app.UseGraphQL <ISchema>("/" + optionsGraphQl.BasePath.Trim('/'));
}
if (app.ApplicationServices.GetService(typeof(PlatformexGraphQlConsoleOptions)) is PlatformexGraphQlConsoleOptions optionsConsole)
{
app.UseGraphQLPlayground("/" + optionsConsole.BasePath.Trim('/'));
}
});
return(builder);
}
public static PlatformBuilder ConfigureServices(this PlatformBuilder builder, Action <IServiceCollection, IConfiguration> configAction)
{
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.AddJsonFile($"appsettings.{environment}.json", optional: true)
.AddEnvironmentVariables()
.Build();
builder.AddConfigureServicesActions(collection =>
{
configAction(collection, configuration);
});
return(builder);
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
platform = target as PlatformBuilder;
if (GUILayout.Button("Build"))
{
platform.Build();
}
if (GUILayout.Button("Clear"))
{
platform.Clear();
}
if (GUILayout.Button("Create New Platform on End"))
{
GameObject newPlatform = Object.Instantiate(platform.gameObject, platform.transform.parent);
newPlatform.transform.position = platform.GetEndPoint();
PlatformBuilder pb = newPlatform.GetComponent <PlatformBuilder>();
pb.Clear();
pb.length = 5f;
Selection.activeGameObject = newPlatform;
}
}
public static PlatformBuilder ConfigureIdentity(this PlatformBuilder builder, Action <PlatformexIdentityOptions> optionsBuilder)
{
var opt = new PlatformexIdentityOptions {
IdentityServerUri = "https://localhost:5000"
};
builder.AddConfigureServicesActions(services =>
{
optionsBuilder?.Invoke(opt);
//services.AddAuthentication("Bearer")
// .AddIdentityServerAuthentication("Bearer", options =>
// {
// // required audience of access tokens
// options.ApiName = "platformex";
// // auth server base endpoint (this will be used to search for disco doc)
// options.Authority = opt.IdentityServerUri;
// });
services.AddAuthentication("Bearer")
.AddJwtBearer("Bearer", options =>
{
options.Authority = opt.IdentityServerUri;
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateAudience = false,
NameClaimType = JwtClaimTypes.Subject,
RoleClaimType = JwtClaimTypes.Role
};
});
});
UseExtensions.AddPreUseAction(app =>
{
app.UseAuthentication();
app.UseAuthorization();
});
return(builder);
}
public static PlatformBuilder AddBasicModule(this PlatformBuilder builder)
{
builder.AddModule <Hcs.PlatformModule.Basic.PlatformModule>();
return(builder);
}
/// <summary>
/// add platform components here
/// </summary>
/// <param name="builder"></param>
public static void DefaultConfig(PlatformBuilder builder)
{
builder.AddModule <PlatformModule>();
}
public static PlatformBuilder WithOpenApi(this PlatformBuilder builder, Action <PlatformexOpenApiOptions> optionsBuilder)
{
var options = new PlatformexOpenApiOptions("swagger", Assembly.GetEntryAssembly()?.GetName().Name);
optionsBuilder(options);
builder.AddConfigureServicesActions(services =>
{
services.AddSingleton(options);
services.TryAdd(ServiceDescriptor
.Transient <IApiDescriptionGroupCollectionProvider,
CommandsApiDescriptionGroupCollectionProvider>());
services.AddSingleton <IApiDescriptionGroupCollectionProvider,
CommandsApiDescriptionGroupCollectionProvider>();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = options.Name + " API", Version = "v1"
});
c.OperationFilter <DescriptionFilter>();
c.OperationFilter <AuthorizeCheckOperationFilter>();
c.SchemaFilter <ReadOnlyFilter>();
c.CustomSchemaIds(i => i.FullName);
c.AddSecurityDefinition("oauth2", new OpenApiSecurityScheme
{
Type = SecuritySchemeType.OAuth2,
Flows = new OpenApiOAuthFlows
{
AuthorizationCode = new OpenApiOAuthFlow
{
AuthorizationUrl = new Uri("https://localhost:5000/connect/authorize"),
TokenUrl = new Uri("https://localhost:5000/connect/token"),
Scopes = new Dictionary <string, string>
{
{ "openid", "User Profile" },
{ "platformex", "Platformex API - full access" }
}
}
}
});
c.DocInclusionPredicate((docName, apiDesc)
=> apiDesc.TryGetMethodInfo(out _) && apiDesc.HttpMethod != null);
/*var basePath = AppDomain.CurrentDomain.BaseDirectory;
* var files = Directory.GetFiles(basePath, "*.xml");
* foreach (var file in files)
* {
* c.IncludeXmlComments(file);
* }*/
});
});
UseExtensions.AddPreUseAction(app =>
{
app.UseSwagger();
var apiOptions = app.ApplicationServices.GetRequiredService <PlatformexOpenApiOptions>();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/" + apiOptions.Url.Trim('/') + "/v1/swagger.json", apiOptions.Name);
c.OAuthClientId("swagger");
c.OAuthAppName("Platformex Open API");
c.OAuthUsePkce();
});
});
return(builder);
}
public static PlatformBuilder ConfigureWebApi(this PlatformBuilder builder)
{
builder.ConfigureWebApi(_ => { });
return(builder);
}
void Awake()
{
m = this;
grid = new PlatformGrid();
}
