public async Task FindRoutes(string method, string path, string aResult)
{
HorseMvc mvc = new HorseMvc();
mvc.Init();
mvc.CreateRoutes(Assembly.GetExecutingAssembly());
mvc.Use();
HttpRequest request = new HttpRequest();
request.Method = method;
request.Path = path;
HttpResponse response = new HttpResponse();
RouteMatch match = mvc.RouteFinder.Find(mvc.Routes, request);
Assert.NotNull(match);
HorseController controller = mvc.ControllerFactory.CreateInstance(mvc,
match.Route.ControllerType,
request,
response,
mvc.ServiceProvider.CreateScope());
MvcConnectionHandler handler = new MvcConnectionHandler(mvc, null);
var parameters = (await handler.FillParameters(request, match)).Select(x => x.Value).ToArray();
Task <IActionResult> task = (Task <IActionResult>)match.Route.ActionType.Invoke(controller, parameters);
IActionResult result = task.Result;
string url = Encoding.UTF8.GetString(((MemoryStream)result.Stream).ToArray());
url.Should().Be(aResult);
}
private void OnCollisionEnter(Collision collision)
{
Debug.Log("Horses should eat hay now");
//if(_fullFeederRender == null)
//{
// Debug.Log("fullFeederRender is null");
//}
Debug.Log(fullFeeder.gameObject.name);
Debug.Log(collision.gameObject.name);
if (collision.gameObject.CompareTag(hayTag))
{
collision.gameObject.SetActive(false);
//Destroy(collision.gameObject);
_fullFeederRender.enabled = true;
//_emptyFeederRender.enabled = false;
//fullFeeder.SetActive(true);
HorseController horseController1 = horse1.GetComponent <HorseController>();
horseController1.UpdateFoodState(true);
}
//HorseController horseController2 = horse2.GetComponent<HorseController>();
//horseController1.SetFeederPos();
}
private async Task ExecuteAction(RouteMatch match, FilterContext context, HorseController controller, ActionDescriptor descriptor, HttpResponse response)
{
if (match.Route.IsAsyncMethod)
{
Task <IActionResult> task = (Task <IActionResult>)match.Route.ActionType.Invoke(controller, descriptor.Parameters.Select(x => x.Value).ToArray());
// ReSharper disable once PossibleNullReferenceException
await task;
await CompleteActionExecution(match, context, response, controller, descriptor, task.Result);
}
else
{
TaskCompletionSource <bool> source = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
ThreadPool.QueueUserWorkItem(async t =>
{
try
{
IActionResult ar = (IActionResult)match.Route.ActionType.Invoke(controller, descriptor.Parameters.Select(x => x.Value).ToArray());
await CompleteActionExecution(match, context, response, controller, descriptor, ar);
source.SetResult(true);
}
catch (Exception e)
{
source.SetException(e.InnerException ?? e);
}
});
await source.Task;
}
}
private void OnTriggerEnter(Collider other)
{
HorseController horseController = other.transform.GetComponent <HorseController>();
if (horseController.IsRunning)
{
int horseNumber = other.transform.GetComponent <HorseController>().HorseNumber;
gameController.Goal(horseNumber);
}
}
public override void findHorse(HorseController horse)
{
HorseCntler = horse;
if (HorseCntler == null)
{
RiderLink = null;
}
else
{
RiderLink = HorseCntler.RidersLink;
}
}
/// <summary>
/// Completes action execution, calls after actions and writes response
/// </summary>
private async Task CompleteActionExecution(RouteMatch match,
FilterContext context,
HttpResponse response,
HorseController controller,
ActionDescriptor descriptor,
IActionResult actionResult)
{
if (actionResult == null)
{
return;
}
//IActionResult actionResult = match.Route.ActionType.Invoke(controller, descriptor.Parameters.Select(x => x.Value).ToArray()) as IActionResult;
context.Result = actionResult;
if (match.Route.HasActionExecutedFilter)
{
//find controller filters
IActionExecutedFilter[] filters = (IActionExecutedFilter[])match.Route.ActionType.GetCustomAttributes(typeof(IActionExecutedFilter), true);
//call AfterCreated methods of controller attributes
foreach (IActionExecutedFilter filter in filters)
{
await filter.OnExecuted(controller, descriptor, actionResult, context);
}
}
if (match.Route.HasControllerExecutedFilter)
{
//find controller filters
IActionExecutedFilter[] filters = (IActionExecutedFilter[])match.Route.ControllerType.GetCustomAttributes(typeof(IActionExecutedFilter), true);
//call AfterCreated methods of controller attributes
foreach (IActionExecutedFilter filter in filters)
{
await filter.OnExecuted(controller, descriptor, actionResult, context);
}
}
await controller.CallActionExecuted(descriptor, context, actionResult);
WriteResponse(response, actionResult);
}
// ----------------------------------------------Find a horse when triggers the mount colliders on a near horse---------------------------------------
public void findHorse(HorseController horse)
{
HorseCntler = horse;
if (HorseCntler == null)
{
RiderLink = null;
leftIKFoot = null;
rightIKFoot = null;
leftIKKnee = null;
rightIKKnee = null;
}
else
{
RiderLink = HorseCntler.RidersLink;
leftIKFoot = HorseCntler.LeftIK;
rightIKFoot = HorseCntler.RightIK;
leftIKKnee = HorseCntler.LeftKnee;
rightIKKnee = HorseCntler.RightKnee;
}
}
/// <summary>
/// Handles the request in MVC pattern
/// </summary>
private async Task RequestMvc(IHorseServer server, HttpRequest request, HttpResponse response, IServiceScope scope)
{
//find file route
if (Mvc.FileRoutes.Count > 0)
{
IActionResult fileResult = Mvc.RouteFinder.FindFile(Mvc.FileRoutes, request);
if (fileResult != null)
{
response.SuppressContentEncoding = true;
WriteResponse(response, fileResult);
return;
}
}
if (Mvc.ActionRoutes.Count > 0)
{
ActionRoute actionRoute = Mvc.RouteFinder.FindAction(Mvc.ActionRoutes, request);
if (actionRoute != null)
{
IActionResult actionResult = null;
if (actionRoute.Action != null)
{
actionResult = actionRoute.Action(request);
}
else if (actionRoute.AsyncAction != null)
{
actionResult = await actionRoute.AsyncAction(request);
}
if (actionResult != null)
{
WriteResponse(response, actionResult);
return;
}
}
}
//find controller route
RouteMatch match = Mvc.RouteFinder.Find(Mvc.Routes, request);
if (match?.Route == null)
{
WriteResponse(response, Mvc.NotFoundResult);
return;
}
//read user token
ClaimsPrincipal user = null;
if (Mvc.ClaimsPrincipalValidator != null)
{
user = Mvc.ClaimsPrincipalValidator.Get(request);
}
FilterContext context = new FilterContext
{
Server = server,
Request = request,
Response = response,
Result = null,
User = user
};
if (!CheckControllerAuthority(match, context, response))
{
return;
}
if (!await ExecuteBeforeControllerFilters(match, context, response))
{
return;
}
HorseController controller = Mvc.ControllerFactory.CreateInstance(Mvc, match.Route.ControllerType, request, response, scope);
if (controller == null)
{
WriteResponse(response, Mvc.NotFoundResult);
return;
}
controller.User = user;
if (!await ExecuteAfterControllerFilters(match, context, response, controller))
{
return;
}
//fill action descriptor
ActionDescriptor descriptor = new ActionDescriptor
{
Controller = controller,
Action = match.Route.ActionType,
Parameters = await FillParameters(request, match)
};
if (!CheckActionAuthority(match, context, response, descriptor))
{
return;
}
if (!await CheckActionExecutingFilters(match, context, response, controller, descriptor))
{
return;
}
await controller.CallActionExecuting(descriptor, context);
if (context.Result != null)
{
WriteResponse(response, context.Result);
return;
}
await ExecuteAction(match, context, controller, descriptor, response);
}
public void makeNPC(HorseController aOtherHorse) {
if (this.ownerID == 0) {
this.name = "NPC Horse Name "+this.horseIndex;
this.acceleration = aOtherHorse.acceleration;
this.behindBoost = aOtherHorse.behindBoost;
this.deceleration = aOtherHorse.deceleration;
this.easeEffect= aOtherHorse.easeEffect;
this.endSpeed = aOtherHorse.endSpeed;
this.infrontBoost = aOtherHorse.infrontBoost;
this.jumpSpeed = aOtherHorse.jumpSpeed;
this.level = aOtherHorse.level;
this.midSpeed = aOtherHorse.midSpeed;
this.ownerID = 0;
this.staminaPerFrame = aOtherHorse.staminaPerFrame;
this.stamina = aOtherHorse.stamina;
this.whipEffect = aOtherHorse.whipEffect;
this.startSpeed = aOtherHorse.startSpeed;
this.horseID = this.horseIndex*-1;
}
}
// Use this for initialization
void Start()
{
HorseC = GetComponentInParent <HorseController>();
}
