void SensorFound(Sensor sensorfounded)
{
bulletTrigger = new TriggerFilter <Bullet>(
sensorfounded,
BulletReceived,
Layers.PLAYER_BULLET,
TriggerFilter <Bullet> .TriggerType._2D);
}
public override void Init()
{
canmove = true;
shoot = new Shoot <Bullet>(Bullet.Activar, Bullet.Desactivar, Bullet.SetPoolObj, point_to_fire, 5f, bullet_model, BulletDamage);
enemyTrigger = new TriggerFilter <Bullet>(enemySensor, HitWithBUllet, Layers.ENEMY_BULLET, TriggerFilter <Bullet> .TriggerType._2D);
Life = 100;
gameObject.FindAndLink <Animator>(AnimatorFound);
}
public async Task <ICollection <Trigger> > PageAsync(TriggerFilter filter)
{
var triggerList = await ApplyFilters(filter)
.ApplyPagination(filter)
.ProjectTo <Trigger>()
.ToListAsync();
foreach (var trigger in triggerList)
{
trigger.HasDependents = await HasDependentsAsync(trigger.Id);
}
return(triggerList);
}
public async Task <ICollection <Trigger> > PageAsync(TriggerFilter filter)
{
var triggerList = await ApplyFilters(filter)
.OrderBy(_ => _.Name)
.ApplyPagination(filter)
.ProjectTo <Trigger>(_mapper.ConfigurationProvider)
.ToListAsync();
foreach (var trigger in triggerList)
{
var dependents = await DependentTriggers(trigger.Id);
trigger.HasDependents = dependents?.Count > 1;
}
return(triggerList);
}
private IQueryable <Model.Trigger> ApplyFilters(TriggerFilter filter)
{
var triggerList = DbSet
.AsNoTracking()
.Where(_ => !_.IsDeleted && _.SiteId == filter.SiteId);
if (filter.SystemIds?.Any() == true)
{
triggerList = triggerList.Where(_ => filter.SystemIds.Contains(_.RelatedSystemId));
}
if (filter.BranchIds?.Any() == true)
{
triggerList = triggerList.Where(_ => filter.BranchIds.Contains(_.RelatedBranchId));
}
if (filter.UserIds?.Any() == true)
{
triggerList = triggerList.Where(_ => filter.UserIds.Contains(_.CreatedBy));
}
if (filter.ProgramIds?.Any() == true)
{
triggerList = triggerList
.Where(_ => filter.ProgramIds.Any(p => p == _.LimitToProgramId));
}
if (!string.IsNullOrWhiteSpace(filter.Search))
{
triggerList = triggerList.Where(_ => _.Name.Contains(filter.Search) ||
_.SecretCode.Contains(filter.Search));
}
if (filter.SecretCodesOnly == true)
{
triggerList = triggerList.Where(_ => !string.IsNullOrWhiteSpace(_.SecretCode));
}
return(triggerList);
}
// honors site id, skip, and take
public async Task <int> CountAsync(TriggerFilter filter)
{
return(await ApplyFilters(filter)
.CountAsync());
}
public async Task <IActionResult> Index(string search,
int?systemId, int?branchId, bool?mine, int?programId, int page = 1)
{
var filter = new TriggerFilter(page);
if (!string.IsNullOrWhiteSpace(search))
{
filter.Search = search;
}
if (mine == true)
{
filter.UserIds = new List <int> {
GetId(ClaimType.UserId)
};
}
else if (branchId.HasValue)
{
filter.BranchIds = new List <int> {
branchId.Value
};
}
else if (systemId.HasValue)
{
filter.SystemIds = new List <int> {
systemId.Value
};
}
if (programId.HasValue)
{
if (programId.Value > 0)
{
filter.ProgramIds = new List <int?> {
programId.Value
};
}
else
{
filter.ProgramIds = new List <int?> {
null
};
}
}
var triggerList = await _triggerService.GetPaginatedListAsync(filter);
var paginateModel = new PaginateViewModel
{
ItemCount = triggerList.Count,
CurrentPage = page,
ItemsPerPage = filter.Take.Value
};
if (paginateModel.PastMaxPage)
{
return(RedirectToRoute(
new
{
page = paginateModel.LastPage ?? 1
}));
}
foreach (var trigger in triggerList.Data)
{
trigger.AwardBadgeFilename =
_pathResolver.ResolveContentPath(trigger.AwardBadgeFilename);
var graEvent = (await _eventService.GetRelatedEventsForTriggerAsync(trigger.Id))
.FirstOrDefault();
if (graEvent != null)
{
trigger.RelatedEventId = graEvent.Id;
trigger.RelatedEventName = graEvent.Name;
}
}
var systemList = (await _siteService.GetSystemList())
.OrderByDescending(_ => _.Id == GetId(ClaimType.SystemId)).ThenBy(_ => _.Name);
var viewModel = new TriggersListViewModel
{
Triggers = triggerList.Data,
PaginateModel = paginateModel,
Search = search,
SystemId = systemId,
BranchId = branchId,
ProgramId = programId,
Mine = mine,
SystemList = systemList,
ProgramList = await _siteService.GetProgramList()
};
if (mine == true)
{
viewModel.BranchList = (await _siteService.GetBranches(GetId(ClaimType.SystemId)))
.OrderByDescending(_ => _.Id == GetId(ClaimType.BranchId))
.ThenBy(_ => _.Name);
viewModel.ActiveNav = "Mine";
}
else if (branchId.HasValue)
{
var branch = await _siteService.GetBranchByIdAsync(branchId.Value);
viewModel.BranchName = branch.Name;
viewModel.SystemName = systemList
.SingleOrDefault(_ => _.Id == branch.SystemId)?.Name;
viewModel.BranchList = (await _siteService.GetBranches(branch.SystemId))
.OrderByDescending(_ => _.Id == GetId(ClaimType.BranchId))
.ThenBy(_ => _.Name);
viewModel.ActiveNav = "Branch";
}
else if (systemId.HasValue)
{
viewModel.SystemName = systemList
.SingleOrDefault(_ => _.Id == systemId.Value)?.Name;
viewModel.BranchList = (await _siteService.GetBranches(systemId.Value))
.OrderByDescending(_ => _.Id == GetId(ClaimType.BranchId))
.ThenBy(_ => _.Name);
viewModel.ActiveNav = "System";
}
else
{
viewModel.BranchList = (await _siteService.GetBranches(GetId(ClaimType.SystemId)))
.OrderByDescending(_ => _.Id == GetId(ClaimType.BranchId))
.ThenBy(_ => _.Name);
viewModel.ActiveNav = "All";
}
if (programId.HasValue)
{
if (programId.Value > 0)
{
viewModel.ProgramName =
(await _siteService.GetProgramByIdAsync(programId.Value)).Name;
}
else
{
viewModel.ProgramName = "Not Limited";
}
}
return(View(viewModel));
}
/// <summary>
/// Checks to see if the string supplied contains at least one substring that is a trigger.
/// The supplied string will be broken apart by a static internal logic to perform this
/// check.
/// </summary>
/// <param name="input">
/// The input string to search for triggers.
/// </param>
/// <param name="firstMatchCategory">
/// The category of the first discovered trigger. Will be -1 on failure.
/// </param>
/// <param name="rebuildAndTestFragments">
/// If no match is found from a single substring fragment, and this parameter is set to true,
/// the function will begin reconstructing new ordered sentences dynamically from all
/// extracted fragments to see if a combination of substrings forms a trigger.
/// </param>
/// <param name="maxRebuildLen">
/// If the rebuildAndTestFragments parameter is set to true, this can be set to the maximum
/// number of substrings to combine in search for a match. By leaving the parameter at its
/// default value, -1, every possible combination in every length will be tried. For example,
/// if you're only wanting to match 3 works like "I dont care", you would set this parameter
/// to a value of 3.
///
/// Note that there are contraints on how long these combinations can be, so regardless of
/// what the value is here, strings created from joins internally will be skipped when they
/// exceed internal database column limits.
/// </param>
/// <returns>
/// True if the supplied text contained one or more substrings that were indentified as a
/// trigger.
/// </returns>
public bool ContainsTrigger(string input, out short firstMatchCategory, out string matchedTrigger, Func <short, bool> categoryAppliesCb, bool rebuildAndTestFragments = false, int maxRebuildLen = -1)
{
firstMatchCategory = -1;
matchedTrigger = null;
if (!m_hasTriggers)
{
return(false);
}
var split = Split(input);
/*using (FileStream debugStream = new FileStream(@"C:\ProgramData\CloudVeil\textTriggerDebug.txt", FileMode.Append))
* using (StreamWriter writer = new StreamWriter(debugStream))*/
using (var myConn = new SqliteConnection(m_connection.ConnectionString))
{
myConn.Open();
int itr = 0;
SqliteCommand triggerCommand = null;
using (var tsx = myConn.BeginTransaction())
using (var cmd = myConn.CreateCommand())
{
cmd.CommandText = @"SELECT * from FirstWordIndex where FirstWordText = $trigger";
var domainSumParam = new SqliteParameter("$trigger", System.Data.DbType.String);
cmd.Parameters.Add(domainSumParam);
bool skippingTags = false;
bool skippingScript = false;
bool quoteReached = false;
bool collectingImportantAttributes = false;
bool isClosingTag = false;
List <string> newSplit = new List <string>();
List <List <string> > wordLists = new List <List <string> >();
List <List <string> > listsToRemove = new List <List <string> >(maxRebuildLen);
foreach (var s in split)
{
// Completely skip closing tags.
if (s.Length > 2 && s[0] == '<' && s[1] == '/' && s[s.Length - 1] == '>')
{
isClosingTag = true;
}
// We require some more complex determinations for opening tags as they may have important
// text inside them.
if (s.Length >= 2 && s[0] == '<' && s[1] != '/' && s.Length > 1 && s.Length < 10)
{
skippingTags = true;
}
switch (s.ToLower())
{
case "<script":
case "<style":
skippingScript = true;
break;
case "</script>":
case "</style>":
skippingScript = false;
break;
case ">":
skippingTags = false;
break;
case "alt":
case "title":
case "href":
collectingImportantAttributes = true;
break;
case "\"":
case "\'":
quoteReached = !quoteReached;
if (!quoteReached)
{
collectingImportantAttributes = false;
}
break;
}
if (isClosingTag)
{
isClosingTag = false;
continue;
}
if (collectingImportantAttributes)
{
newSplit.Add(s);
itr++;
}
else if (!skippingTags && !skippingScript && s != ">")
{
newSplit.Add(s);
itr++;
}
if (skippingTags && !collectingImportantAttributes)
{
continue;
}
listsToRemove.Clear();
// Check word lists.
foreach (var list in wordLists)
{
if (list.Count >= maxRebuildLen)
{
listsToRemove.Add(list);
}
else
{
list.Add(s);
}
}
foreach (var l in listsToRemove)
{
wordLists.Remove(l);
}
// Check word lists.
foreach (var list in wordLists)
{
string triggerCandidate = string.Join(" ", list);
if (!TriggerFilter.Contains(triggerCandidate))
{
continue;
}
if (triggerCommand == null)
{
triggerCommand = myConn.CreateCommand();
triggerCommand.CommandText = "SELECT * FROM TriggerIndex WHERE TriggerText = $trigger";
var wholeTriggerDomainSumParam = new SqliteParameter("$trigger", System.Data.DbType.String);
wholeTriggerDomainSumParam.Value = input.ToLower();
triggerCommand.Parameters.Add(wholeTriggerDomainSumParam);
}
triggerCommand.Parameters[0].Value = triggerCandidate;
using (var triggerReader = triggerCommand.ExecuteReader())
{
while (triggerReader.Read())
{
var thisCat = triggerReader.GetInt16(1);
if (categoryAppliesCb(thisCat))
{
firstMatchCategory = thisCat;
matchedTrigger = string.Join(" ", list);
return(true);
}
}
}
}
// TODO: Apply bloom filters to this problem.
// We need a bloom filter for first words and a bloom filter for triggers for maximum effect.
if (!FirstWordFilter.Contains(s))
{
continue;
}
cmd.Parameters[0].Value = s;
using (var reader = cmd.ExecuteReader())
{
if (!reader.HasRows)
{
continue;
}
while (reader.Read())
{
var isWholeTrigger = reader.GetInt16(1);
if (isWholeTrigger > 0)
{
var thisCat = reader.GetInt16(2);
if (categoryAppliesCb(thisCat))
{
firstMatchCategory = thisCat;
matchedTrigger = s;
return(true);
}
}
else
{
var newList = new List <string>(maxRebuildLen);
newList.Add(s);
wordLists.Add(newList);
break;
}
}
}
}
tsx.Commit();
}
}
return(false);
}
public async Task <DataWithCount <ICollection <Trigger> > > GetPaginatedListAsync(TriggerFilter filter)
{
VerifyManagementPermission();
filter.SiteId = GetCurrentSiteId();
return(new DataWithCount <ICollection <Trigger> >
{
Data = await _triggerRepository.PageAsync(filter),
Count = await _triggerRepository.CountAsync(filter)
});
}
private void SensorFound(Sensor obj)
{
filter = new TriggerFilter <Player>(obj, PlayerFound, Layers.PLAYER, TriggerFilter <Player> .TriggerType._2D);
}
private void SensorFound(Sensor _sensorFounded)
{
filter = new TriggerFilter <GameObject>(_sensorFounded, ChocoPared, Layers.WORLD, TriggerFilter <GameObject> .TriggerType._2D);
}
public TriggerFilter2Csv(TriggerFilter original)
{
Type = original.type;
Key = original.parameter.Find("arg0").GetValue;
Value = original.parameter.Find("arg1").GetValue;
}
