public void TearDown()
{
this.handler = null;
this.buildContext = null;
this.testObject = null;
this.mocks = null;
}
void Awake()
{
kf = GetComponent <KeyboardFunctions>();
grid = GetComponent <Grid>();
bhandler = GetComponent <BuildHandler> ();
bank = GetComponent <Bank>();
pathfind = GetComponent <PathFind>();
pn = GetComponent <PlayerNetworking> ();
wallGhostLoaded = (GameObject)(Resources.Load("Walls/WallGhost"));
wallIcon = Resources.Load <Sprite> ("Sprites/WallIcon");
orbIcon = Resources.Load <Sprite> ("Sprites/OrbIcon");
cannonIcon = Resources.Load <Sprite> ("Sprites/CannonIcon");
laserIcon = Resources.Load <Sprite> ("Sprites/LaserIcon");
iceIcon = Resources.Load <Sprite> ("Sprites/IceIcon");
lightIcon = Resources.Load <Sprite> ("Sprites/LightIcon");
magicIcon = Resources.Load <Sprite> ("Sprites/MagicIcon");
rangeIndicator = (GameObject)(Resources.Load("UI/RangeIndicator"));
highlightCastleMaterial = (Material)(Resources.Load("Materials/Outlined_Object"));
BuildFX = (AudioClip)(Resources.Load("Sounds/BuildingPlacement", typeof(AudioClip)));
needMoneySound = (AudioClip)(Resources.Load("Sounds/needMoney", typeof(AudioClip)));
cannotBuildSound = (AudioClip)(Resources.Load("Sounds/CannotBuild", typeof(AudioClip)));
selectSound = Resources.Load <AudioClip> ("Sounds/CarDoorClose");
sourceSFX = Camera.main.GetComponent <AudioSource>();
}
internal static TemplateServices CreateTestTemplateServices()
{
BuildHandler buildHandler = new BuildHandler();
TagServices tagServices = new TagServices(buildHandler);
return(new TemplateServices(buildHandler, tagServices));
}
public void SetUp()
{
this.mocks = new MockRepository();
this.buildContext = this.mocks.StrictMock <IMemberBuildContext>();
this.builder = this.mocks.StrictMock <IMemberBuilder>();
this.type = this.builder.GetType();
this.handlerReturn = false;
handler = (e) => { return(this.handlerReturn); };
this.testObject = new BuildHandler(this.type, handler, typeof(EmptyBuildParameters));
}
public void CreateInstanceTest()
{
this.type = typeof(MyMemberBuilder);
this.testObject = new BuildHandler(this.type, handler, typeof(EmptyBuildParameters));
mocks.ReplayAll();
var actual = testObject.CreateInstance(this.buildContext);
Assert.IsNotNull(actual);
Assert.IsInstanceOfType <MyMemberBuilder>(actual);
var actualMemberBuilder = (MyMemberBuilder)actual;
Assert.AreEqual(this.buildContext, actualMemberBuilder.Context);
Assert.AreEqual(0, actualMemberBuilder.BuildCalled);
Assert.AreEqual(0, actualMemberBuilder.GetTestNameCalled);
mocks.VerifyAll();
}
public override void OnInspectorGUI()
{
//base.OnInspectorGUI();
BuildHandler buildHandler = (BuildHandler)target;
buildHandler.GridShowMod = (BuildHandler.BuildGridShowMod)EditorGUILayout.EnumPopup("Grid show mod", buildHandler.GridShowMod);
if (buildHandler.GridShowMod == BuildHandler.BuildGridShowMod.Gizmos)
{
buildHandler.GizmosGridColor = EditorGUILayout.ColorField("Gizmos color", buildHandler.GizmosGridColor);
}
buildHandler.UseSecureSizes = EditorGUILayout.Toggle("Use secure size", buildHandler.UseSecureSizes);
buildHandler.SpacingCountX = EditorGUILayout.IntField("Spacing count X", buildHandler.SpacingCountX);
buildHandler.SpacingCountY = EditorGUILayout.IntField("Spacing count Y", buildHandler.SpacingCountY);
}
/// <summary>
/// Command Line implementation of HTMLinjector
/// </summary>
/// <param name="args">The command-line arguments.</param>
public static void Main(string[] args)
{
Console.WriteLine("\r\nHTMLinjector v" + Assembly.GetEntryAssembly().GetCustomAttribute <AssemblyInformationalVersionAttribute>().InformationalVersion + "\r\n");
if (args == null || args.Length != 2)
{
Console.WriteLine("Expected 2 arguments, source folder and output folder");
return;
}
string sourceFolderPath = args[0];
string outputFolderPath = args[1];
if (String.IsNullOrEmpty(sourceFolderPath))
{
Console.WriteLine("Missing source folder\r\n");
return;
}
if (String.IsNullOrEmpty(outputFolderPath))
{
Console.WriteLine("Missing output folder\r\n");
return;
}
Console.WriteLine("Source folder: " + sourceFolderPath);
Console.WriteLine("Output folder: " + outputFolderPath + "\r\n");
CLFolder sourceFolder = new CLFolder(sourceFolderPath);
CLFolder outputFolder = new CLFolder(outputFolderPath);
// Hook up to the build events so that we can display build progress to the user
BuildHandler buildHandler = new BuildHandler();
buildHandler.BuildEvent += (sender, e) => { Console.WriteLine(e.EventMessage); };
// Start the build
HTMLinjector htmlInjector = new HTMLinjector();
htmlInjector.ProcessFiles(sourceFolder, outputFolder, buildHandler).Wait();
}
void Update()
{
if (myPlayer == null)
{
myPlayer = gm.MyLocalPlayer();
}
else
{
if (kf == null)
{
kf = myPlayer.GetComponent <KeyboardFunctions> ();
}
if (mf == null)
{
mf = myPlayer.GetComponent <MouseFunctions> ();
}
if (bhandler == null)
{
bhandler = myPlayer.GetComponent <BuildHandler> ();
}
}
if (runTimer == true)
{
buttonHoldTime += Time.deltaTime;
if (buttonHoldTime >= buttonThresholdTime)
{
SellSelected();
runTimer = false;
buttonHoldTime = 0;
}
}
}
public static int Main(string[] args)
{
Console.WriteLine("Started");
var app = new CommandLineApplication();
var groupByType = GroupByType.Concern;
app.HelpOption();
var operationType = app.Option(
"-ot|--operationType <TYPE>",
"Can either be [command] or [query]",
CommandOptionType.SingleValue);
var concern = app.Option(
"-c|--concern <NAME>",
"Name of the concern",
CommandOptionType.SingleValue);
var operation = app.Option(
"-o|--operation <NAME>",
"Name of the operation",
CommandOptionType.SingleValue);
var groupBy = app.Option(
"-g|--groupBy <TYPE>",
"Group domain objects by [C] for concerns or [O] for operations, defaults to concerns",
CommandOptionType.SingleValue);
app.OnExecute(() =>
{
if (!operationType.HasValue())
{
LogUtility.Error("Invalid operation type parameter: must specify [c] for command or [q] for query");
return(0);
}
if (!concern.HasValue())
{
LogUtility.Error("Invalid concern parameter: concern must be specified");
return(0);
}
if (!operation.HasValue())
{
LogUtility.Error("Invalid operation parameter: operation must be specified");
return(0);
}
if (groupBy.HasValue())
{
groupByType = (groupBy.Value().ToLower()) switch
{
"c" => GroupByType.Concern,
"o" => GroupByType.Operation,
_ => GroupByType.Concern
};
}
var operationTypeBuilderResult = OperationTypeResolver.Resolve(operationType.Value());
if (operationTypeBuilderResult == OperationType.UNSUPPORTED)
{
LogUtility.Error("Invalid operation type parameter: must specify [c] for command or [q] for query");
return(0);
}
BuildResponse.Build(concern.Value(), operation.Value(), groupByType);
switch (operationTypeBuilderResult)
{
case OperationType.COMMAND:
BuildCommand.Build(concern.Value(), operation.Value(), groupByType);
break;
case OperationType.QUERY:
BuildQuery.Build(concern.Value(), operation.Value(), groupByType);
break;
case OperationType.UNSUPPORTED:
LogUtility.Error("Invalid operation type parameter: must specify [c] for command or [q] for query");
break;
default:
LogUtility.Error("Invalid operation type parameter: must specify [c] for command or [q] for query");
break;
}
;
BuildHandler.Build(concern.Value(), operation.Value(), operationTypeBuilderResult, groupByType);
return(0);
});
return(app.Execute(args));
}
public void Listen()
{
_listener.Prefixes.Add("http://127.0.0.1:14801/register/");
_listener.Prefixes.Add("http://127.0.0.1:14801/build/");
_listener.Prefixes.Add("http://127.0.0.1:14801/references/");
_listener.Prefixes.Add("http://127.0.0.1:14801/update/");
_listener.Start();
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
while (true)
{
try
{
var context = _listener.GetContext();
var request = context.Request;
var response = context.Response;
var url = request.Url;
Console.WriteLine("URL: " + url.AbsolutePath);
using (var reader = new StreamReader(request.InputStream))
{
Handler handler = null;
switch (url.AbsolutePath)
{
case "/register/":
handler = new RegistrationHandler(reader.ReadToEnd());
break;
case "/references/":
handler = new ReferencesHandler(reader.ReadToEnd());
break;
case "/update/":
handler = new UpdateHandler(reader.ReadToEnd());
break;
case "/build/":
handler = new BuildHandler(reader.ReadToEnd());
break;
}
if (handler != null)
{
var writer = new StreamWriter(response.OutputStream);
writer.Write(handler.Execute());
writer.Close();
}
}
}
catch (Exception e)
{
Console.WriteLine($"exception: {e.Message}");
}
}
}).Start();
}
private static int RunScaffolding(string[] args)
{
var app = new CommandLineApplication
{
Name = "Scaffolding CLI",
Description = "A CQRS and Mediator scaffolding CLI",
AllowArgumentSeparator = true,
};
app.HelpOption(true);
//Top level command which can split into two directions
app.Command("new", configCmd =>
{
configCmd.OnExecute(() =>
{
Console.WriteLine("Scaffold a new solution or extend the domain");
configCmd.ShowHelp();
return(1);
});
//Split 1: sln
configCmd.Command("sln", setCmd =>
{
setCmd.Description =
"Scaffold a new solution including the API, Logic, DB, Unit and Integration test projects";
var nameArgument = setCmd.Option("-n| --name <NAME>", "Name of the solution", CommandOptionType.SingleValue).IsRequired();
setCmd.OnExecute(() =>
{
var path = Directory.GetCurrentDirectory();
BuilderSolution.Build(nameArgument.Value());
BuildStartup.Build($"{path}/API");
BuildCorsExtension.Build($"{path}/API/Extensions");
BuildHealthCheckExtensions.Build($"{path}/API/Extensions");
BuildDatabaseServiceCollectionExtensions.Build($"{path}/DB/Configuration");
BuildLogicServiceCollectionExtensions.Build($"{path}/Logic/Configuration");
Console.WriteLine(ExecuteCommandUtility.Run($"echo [92mDONE[0m"));
});
});
//Split 2: domain
configCmd.Command("domain", setCmd =>
{
setCmd.Description = "Extent the domain with new handlers";
var operationType = setCmd.Option(
"-ot|--operationType <TYPE>",
"Can either be [command] or [query]",
CommandOptionType.SingleValue)
.IsRequired(false,
"Must specify an operation type: Can either be [command] or [query] i.e -ot|--operationType <TYPE>");
var concern = setCmd.Option(
"-c|--concern <NAME>",
"Name of the concern",
CommandOptionType.SingleValue)
.IsRequired(false, "Name of the concern: -c|--concern <NAME>");
var operation = setCmd.Option(
"-o|--operation <NAME>",
"Name of the operation",
CommandOptionType.SingleValue)
.IsRequired(false, "Name of the operation: -o|--operation <NAME>");
var groupBy = setCmd.Option(
"-g|--groupBy <TYPE>",
"Group domain objects by [C] for concerns or [O] for operations, defaults to concerns",
CommandOptionType.SingleValue);
setCmd.OnExecute(() =>
{
var groupByType = GroupByType.Concern;
if (groupBy.HasValue())
{
groupByType = (groupBy.Value()?.ToLower()) switch
{
"c" => GroupByType.Concern,
"o" => GroupByType.Operation,
_ => GroupByType.Concern
};
}
var operationTypeBuilderResult = OperationTypeResolver.Resolve(operationType.Value());
if (operationTypeBuilderResult == OperationType.UNSUPPORTED)
{
LogUtility.Error("Invalid operation type parameter: must specify [c] for command or [q] for query");
return(0);
}
BuildResponse.Build(concern.Value(), operation.Value(), groupByType);
switch (operationTypeBuilderResult)
{
case OperationType.COMMAND:
BuildCommand.Build(concern.Value(), operation.Value(), groupByType);
break;
case OperationType.QUERY:
BuildQuery.Build(concern.Value(), operation.Value(), groupByType);
break;
case OperationType.UNSUPPORTED:
LogUtility.Error(
"Invalid operation type parameter: must specify [c] for command or [q] for query");
break;
default:
LogUtility.Error(
"Invalid operation type parameter: must specify [c] for command or [q] for query");
break;
}
;
BuildHandler.Build(concern.Value(), operation.Value(), operationTypeBuilderResult, groupByType);
return(0);
});
void Awake()
{
myCamera = GetComponent <Camera> ();
buildHandler = FindObjectOfType <BuildHandler> ();
}
private void Awake()
{
buildHandler = GameObject.FindGameObjectWithTag("BuildingParent").GetComponent <BuildHandler>();
}
