private void UpdateMovement()
{
var forwardDelta = Input.GetAxis("Vertical") * Time.deltaTime * ExperimentModel.getMovementSpeed();
Vector3 forwardVector;
if (PlayerMovementMode == MovementMode.BodyRelatve)
{
forwardVector = transform.forward * forwardDelta;
}
else
{
Vector3 fakeForward = headTransform.forward;
fakeForward.y = 0;
fakeForward.Normalize();
forwardVector = fakeForward * forwardDelta;
}
if (UnityEngine.XR.XRSettings.enabled)
{
GetComponent <SphereCollider>().center = headTransform.localPosition;
}
transform.position += forwardVector;
}
/// <summary>
/// GET: /Experiment/
/// </summary>
/// <returns>The index view</returns>
public ActionResult Index()
{
ExperimentModel model = new ExperimentModel();
model.Experiment = this.experimentService.InitialiseExperiment();
return(this.View(model));
}
public static void UpdateGameOptions(this ExperimentModel experiment, GameOptions options)
{
//Okay, this probably isn't the optimal structure. Maybe this shouldn't be an extension
//method.
foreach (var variableName in experiment.Variables.Keys)
{
ApplyVariable(experiment, variableName, options);
}
}
public async Task <IActionResult> CreateExperiment(ExperimentModel experimentModel)
{
if (ModelState.IsValid)
{
var mappedExperiment = mapper.Map <Experimet>(experimentModel);
mappedExperiment.StatusExperiment = StatusExperiment.NotStarted;
var experiment = await experimentService.CreateNewExperiment(mappedExperiment);
return(RedirectToAction(nameof(ExperimentProcess), new { id = experiment.Id }));
}
return(View());
}
public async Task <IActionResult> CreateExperiment(string researchId)
{
var research = await researchService.GetResearchAsync(Guid.Parse(researchId));
var experimentModel = new ExperimentModel()
{
Research = research,
ResearchId = research.Id
};
return(View(experimentModel));
}
public async Task <IActionResult> StratProcessing(ExperimentModel exp)
{
if (ModelState.IsValid)
{
var kmc = new KMC();
var experiment = await experimentService.GetExperimentAsync(exp.Id);
var processedData = kmc.BuildAcidDictionary(exp.Kmer, experiment.Data);
experiment.JsonResult = JsonConvert.SerializeObject(processedData);
experiment.StatusExperiment = StatusExperiment.Done;
await experimentService.UpdeteExperiment(experiment);
return(RedirectToAction(nameof(ExperimentProcess), new { id = experiment.Id }));
}
return(RedirectToAction(nameof(ExperimentProcess), new { id = exp.Id }));
}
/// <summary>
/// POST: /Experiment/Save
/// </summary>
/// <param name="model">The experiment model which stores the experiment values to save</param>
/// <returns>The Save view</returns>
public ActionResult Save(ExperimentModel model)
{
Experiment expToUpdate = this.experimentService.Get(model.Experiment.Id);
expToUpdate.XPosition = model.Experiment.XPosition;
expToUpdate.YPosition = model.Experiment.YPosition;
expToUpdate.StartTime = model.Experiment.StartTime;
expToUpdate.EndTime = model.Experiment.EndTime;
expToUpdate.ReactionTime = model.Experiment.EndTime - model.Experiment.StartTime;
expToUpdate.EndDiameter = model.Experiment.EndDiameter;
expToUpdate.EndOpacity = model.Experiment.EndOpacity;
this.experimentService.Save(expToUpdate);
model.Experiment = expToUpdate;
return(this.View(model));
}
public async Task <Result> DeleteExperimentCommand(ExperimentModel value)
{
using var schemaRegistry = new CachedSchemaRegistryClient(schemaRegistryConfig);
using var producerBuilder = new ProducerBuilder <Null, ExperimentModel>(producerConfig)
.SetValueSerializer(new JsonSerializer <ExperimentModel>(schemaRegistry, jsonSerializerConfig))
.Build();
{
try
{
var producer = await producerBuilder.ProduceAsync("DeleteExperimentCommand", new Message <Null, ExperimentModel> {
Value = value
});
}
catch (ProduceException <Null, ExperimentModel> produceException)
{
return(Result.Failure(produceException.Message));
}
}
return(Result.Ok());
}
public async Task <Result> ExperimentDeletedEvent(ExperimentModel value)
{
using var schemaRegistry = new CachedSchemaRegistryClient(schemaRegistryConfig);
using var producerBuilder = new ProducerBuilder <Null, ExperimentModel>(producerConfig)
.SetValueSerializer(new JsonSerializer <ExperimentModel>(schemaRegistry, jsonSerializerConfig))
.Build();
{
try
{
var currentTicks = DateTime.Now.Ticks.ToString();
var producer = await producerBuilder.ProduceAsync("ExperimentDeletedEvent", new Message <Null, ExperimentModel> {
Value = value
});
}
catch (ProduceException <Null, ExperimentModel> produceException)
{
return(Result.Failure(produceException.Message));
}
}
return(Result.Ok());
}
public Result CreateExperimentCommand(ExperimentModel value)
{
var task = Task.Run(() =>
{
using var schemaRegistry = new CachedSchemaRegistryClient(schemaRegistryConfig);
using var producerBuilder = new ProducerBuilder <Null, ExperimentModel>(producerConfig)
.SetValueSerializer(new JsonSerializer <ExperimentModel>(schemaRegistry, jsonSerializerConfig))
.Build();
try
{
var producer = producerBuilder.ProduceAsync("CreateExperimentCommand", new Message <Null, ExperimentModel> {
Value = value
});
}
catch (ProduceException <Null, ExperimentModel> produceException)
{
}
});
return(Result.Ok());
}
public Result ExperimentCreatedEvent(ExperimentModel value)
{
var task = Task.Run(async() =>
{
using var schemaRegistry = new CachedSchemaRegistryClient(schemaRegistryConfig);
using var producerBuilder = new ProducerBuilder <Null, ExperimentModel>(producerConfig)
.SetValueSerializer(new JsonSerializer <ExperimentModel>(schemaRegistry, jsonSerializerConfig))
.Build();
try
{
var currentTicks = DateTime.Now.Ticks.ToString();
var producer = await producerBuilder.ProduceAsync("ExperimentCreatedEvent", new Message <Null, ExperimentModel> {
Value = value
});
}
catch (ProduceException <Null, ExperimentModel> produceException)
{
}
});
return(Result.Ok());
}
private static void ApplyVariable(ExperimentModel experiment, string variableName, GameOptions options)
{
var value = experiment.Variables[variableName];
switch (variableName.ToLower())
{
case "lynchrule":
options.LynchRules = value.ToEnum <LynchRules>();
break;
case "seercount":
options.SeerCount = value.ToInt32();
break;
case "huntercount":
options.HunterCount = value.ToInt32();
break;
case "seerpercentscannedthreshold":
options.SeerPercentScannedThreshold = value.ToDecimal();
break;
case "seerwolfpercentthreshold":
options.SeerWolfPercentThreshold = value.ToDecimal();
break;
case "seerwolfcountthreshold":
options.SeerWolfCountThreshold = value.ToInt32();
break;
case "seerlivingscancountthreshold":
options.SeerLivingScanCountThreshold = value.ToInt32();
break;
default:
throw new InvalidOperationException("Unexpected Variable Name: " + variableName);
}
}
public async Task <Result> Delete([FromBody] ExperimentModel value)
{
return(await _experimentCommandsService.DeleteExperimentCommand(value));
}
public async Task <Result> Put(long id, [FromBody] ExperimentModel value)
{
return(await _experimentCommandsService.UpadateExperimentCommand(id, value));
}
public Result Post([FromBody] ExperimentModel value)
{
return(_experimentCommandsService.CreateExperimentCommand(value));
}
