public override bool CheckPass()
{
m_targetActor = ActorFilter.GetNearestActor(Engine.ActorFilter.GetActors(new ActorFilter.FilteCondition()
{
filteBy = ActorFilter.FilteBy.Type,
compareCondition = ActorFilter.CompareCondition.Is,
actorType = ActorFilter.ActorType.All,
value = 0
}), m_aiActor);
switch (m_targetType)
{
case ActorFilter.ActorType.Normal:
{
return(m_targetActor is NormalActor && !(m_targetActor is ShooterActor));
}
case ActorFilter.ActorType.Shooter:
{
return(m_targetActor is ShooterActor);
}
case ActorFilter.ActorType.Zombie:
{
return(m_targetActor is ZombieActor);
}
}
return(false);
}
private void SetActorByType()
{
switch (m_targetType)
{
case Target.NearestNormal:
{
m_targetActor = ActorFilter.GetNearestActor(ActorFilter.ActorType.Normal, m_aiActor);
break;
}
case Target.NearestShooter:
{
m_targetActor = ActorFilter.GetNearestActor(ActorFilter.ActorType.Normal, m_aiActor);
break;
}
case Target.NearestZombie:
{
m_targetActor = ActorFilter.GetNearestActor(ActorFilter.ActorType.Normal, m_aiActor);
break;
}
case Target.Player:
{
m_targetActor = GameManager.Player;
break;
}
case Target.Self:
{
m_targetActor = m_aiActor;
break;
}
}
}
public static object GetData(this IQueryable <Actor> query, ActorFilter filter, string sort, string[] fields, int page, int limit, int total)
{
query = query.Filter(filter);
query = query.Pagination(page, limit);
query = query.Sort(sort);
var result = query.SelectField(fields, total);
return(result);
}
public object GetDetail(ActorFilter filter, string sort, string[] fields, int page, int limit)
{
var query = Get();
int totalPage = 0;
if (limit > -1)
{
totalPage = query.Count() / limit;
}
return(query.GetData(filter, sort, fields, page, limit, totalPage));
}
private void Start()
{
m_actorManager = new ActorManager(m_actors);
m_gameManager = new GameManager(m_objects);
m_actorFilter = new ActorFilter();
m_networkManager = new NetworkManager(m_isLocalhost);
Inited = true;
if (OnEngineInited != null)
{
OnEngineInited();
}
}
public override void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new Settings()
{
ActorFilter = ActorFilter,
Shape = Shape,
Dimensions = Shape switch
{
Shape.Box => (fix2)BoxSize,
Shape.Circle => new fix2((fix)CircleRadius),
_ => throw new NotImplementedException()
}
});
public async Task <ServiceResponse <List <Actor> > > Get(ActorFilter model)
{
ExpressionStarter <Actor> expression = PredicateBuilder.New <Actor>(true);
if (model.Name.Length > 0)
{
expression = expression.And(prop => model.Name.Contains(prop.FullName));
}
var responseD = _actorRepo.Pagining(expression, ((model.PageNumber - 1) * model.PageSize), model.PageSize, model.OrderColumn, (OrderDirection)model.OrderBy, true);
var response = await responseD.ToListAsync();
return(new ServiceResponse <List <Actor> >(response, true));
}
public async Task <IEnumerable <ActorDTO> > GetActorsByFilterData([FromBody] ActorFilter model)
{
var actors = await _context.actors.ToListAsync();
switch (model.Filter)
{
case "country":
var result = actors.Where(t => model.Data.Any(s => s == t.Country)).ToList();
return(_mapper.Map <List <Actor>, List <ActorDTO> >(actors));
default:
return(null);
}
}
public IActionResult Get([FromQuery] ActorFilter filter)
{
try
{
var result = _service.Get(filter);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
catch (Exception e)
{
try { _logService.SendLogError(e); } catch (System.Exception ex) { return(StatusCode(503, ex)); }
return(StatusCode(503, e));
}
}
private static IQueryable <Actor> Filter(this IQueryable <Actor> query, ActorFilter filter)
{
if (filter.Ids != null)
{
query = query.Where(s => filter.Ids.Contains(s.ActorId));
}
if (filter.Name != null && filter.Name.Length > 0)
{
query = query.Where(s => s.ActorName.Contains(filter.Name));
}
if (filter.username != null)
{
query = query.Where(s => s.Username.Equals(filter.username));
}
return(query);
}
public IActorFilter <TComponent> GetFilter <TComponent>() where TComponent : IComponent
{
var filterId = Typeof <IActorFilter <TComponent> > .Id;
IActorFilter filter;
using (Lock.Enter(_filters))
{
// ReSharper disable once InvertIf
if (!_filters.TryGetValue(filterId, out filter))
{
filter = new ActorFilter <TComponent>(this);
_filters.Add(filterId, filter);
}
}
return((IActorFilter <TComponent>)filter);
}
public IActionResult Get([FromQuery] ActorFilter filter,
[FromQuery] string sort,
[FromQuery] string[] fields,
[FromQuery] int page = 0,
[FromQuery] int limit = -1)
{
try
{
var domain = _uow.GetService <ActorDomain>();
if (fields.Length == 0)
{
fields = new string[] { ActorFieldsDetail.INFO };
}
var result = domain.GetDetail(filter, sort, fields, page, limit);
return(Success(result));
}
catch (Exception ex)
{
return(Error(ex.Message));
}
}
private void SetTarget()
{
switch (m_targetType)
{
case Target.AwayFromPlayer:
case Target.Player:
{
m_targetActor = GameManager.Player;
break;
}
case Target.AwayFromNearestNormal:
case Target.NearestNormal:
{
m_targetActor = ActorFilter.GetNearestActor(ActorFilter.ActorType.Normal, m_aiActor);
break;
}
case Target.AwayFromNearestShooter:
case Target.NearestShooter:
{
m_targetActor = ActorFilter.GetNearestActor(ActorFilter.ActorType.Shooter, m_aiActor);
break;
}
case Target.AwayFromNearestZombie:
case Target.NearestZombie:
{
m_targetActor = ActorFilter.GetNearestActor(ActorFilter.ActorType.Zombie, m_aiActor);
break;
}
case Target.Random:
{
m_targetActor = m_aiActor;
break;
}
}
}
public async Task <ServiceResponse <List <Actor> > > Get([FromQuery] ActorFilter request)
{
return(await _actorService.Get(request));
}
public static bool ActorFilterMatches(ActorFilterInfo actorA, ActorFilterInfo actorB, ActorFilter filter)
{
return(((filter & ActorFilter.Allies) != 0 && actorA.Team == actorB.Team) ||
((filter & ActorFilter.Enemies) != 0 && actorA.Team != actorB.Team) ||
((filter & ActorFilter.Terrain) != 0 && actorB.IsTerrain));
}
