public void Sort(string propertyName, string direction)
{
if (string.IsNullOrEmpty(propertyName))
{
CurrentPageNumber = 1;
Calculate(CurrentPageNumber);
return;
}
Func <T, object> propertyGetter;
if (!sortCache.TryGetValue(propertyName, out propertyGetter))
{
var prop = typeof(T).GetProperty(propertyName);
propertyGetter = obj => prop.GetValue(obj, null);
if (prop == null)
{
CurrentPageNumber = 1;
Calculate(CurrentPageNumber);
return;
}
}
if (string.IsNullOrEmpty(direction) || direction.ToLower() == "descending")
{
AllObjects = new ObservableCollection <T>(AllObjects.OrderByDescending(propertyGetter));
}
else
{
AllObjects = new ObservableCollection <T>(AllObjects.OrderBy(propertyGetter));
}
CurrentPageNumber = 1;
Calculate(CurrentPageNumber);
}
private void SpawnInitialWallMaster()
{
for (int i = 0; i < wallMasterCounter; i++)
{
AllObjects.Spawn(new Hand(spriteBatch, GenerateRandomWallMasterSpawnPoint(), roomToJumpTo));
}
}
/// <summary>
/// This is a method thar runs on the initialization of the class
/// to load all objects using the service class
/// </summary>
/// <returns></returns>
protected override async Task LoadAll()
{
try
{
if (AllObjects?.Count > 0)
{
AllObjects.Clear();
}
if (FilteredCollection?.Count > 0)
{
FilteredCollection.Clear();
}
await RunMethodAsync(() =>
{
var allObjects = service.GetAll() ?? new List <T>();
AllObjects = FilteredCollection = new ObservableCollection <T>(allObjects);
}, () => IsBusy);
}
catch (Exception e)
{
toaster.ShowErrorToast(Toaster.ErrorTitle, e.Message);
}
}
public virtual void Add(T item)
{
AllObjects.Add(item);
currentPageNumber = TotalPagesNumber;
Calculate(currentPageNumber);
OnTotalChange();
}
private void MapPayer(IPlayer player, bool newWorld = false)
{
if (!AllObjects.TryGetValue(player.Guid, out var item))
{
item = new AllObjectsDictionaryItem
{
ItemFromServer = player
};
AllObjects.Add(player.Guid, item);
item.Controller = Instantiate(PlayerControllerBase, new Vector3(player.X, player.Y, 0), Quaternion.identity);
PlayerController = item.Controller as PlayerController;
}
if (newWorld)
{
// ReSharper disable once PossibleNullReferenceException
(item.Controller as PlayerController).UpdateFromServer(player);
}
else
{
Player.IsMoving = player.IsMoving;
Player.MoveToX = player.MoveToX;
Player.MoveToY = player.MoveToY;
Player.WorldGuid = player.WorldGuid;
Player.VisibleCities = player.VisibleCities;
}
item.Updated = true;
}
public override void OnUpdate()
{
// time between updates
float dt = stopwatch.ElapsedMilliseconds;
foreach (BasePhysicObject pyhsicObject in AllObjects.OfType <BasePhysicObject>())
{
pyhsicObject.ApplyForce(Gravity, dt);
}
distanceTraveled += previousPos.X - player3.Position.X;
previousPos = new Vector2(player3.Position.X, 0);
if (SpacePressed)
{
player3.ApplyForce(Jump, dt);
}
CameraPosition.X = -player3.Position.X + Resolution.X / 2;
text.Position.X = player3.Position.X - 15;
text.Position.Y = 15;
text.Text = distanceTraveled.ToString();
stopwatch.Restart();
}
protected void Calculate(int pageNumber)
{
var upperLimit = pageNumber * PageSize;
CurrentPageItems =
new ObservableCollection <T>(
AllObjects.Where(x => AllObjects.IndexOf(x) > upperLimit - (PageSize + 1) && AllObjects.IndexOf(x) < upperLimit));
}
public AccessObjectFunctionCollectionModel(AllObjects functions)
{
try
{
Initialize(functions);
}
catch
{ }
}
private void SpawnWalls()
{
AllObjects.Spawn(new SecretRoomWall(RoomConstants.LeftWallRectangle));
AllObjects.Spawn(new SecretRoomWall(RoomConstants.MiddleWallRectangle));
AllObjects.Spawn(new SecretRoomWall(RoomConstants.RightWallRectangle));
AllObjects.Spawn(new SecretRoomWall(RoomConstants.TopWallRectangle));
AllObjects.Spawn(new RoomChangeTrigger(Constants.Direction.Stairs, RoomConstants.SecretRoomRoomChangeTrigger));
}
static MainApiController()
{
_cleaner = new Timer(
obj => { AllObjects.Clear(); },
null,
new TimeSpan(1, 0, 0),
new TimeSpan(1, 0, 0)
);
}
//public void OnGUI()
//{
// int nbTwippies = GetAll<Twippie>().Count;
// GUI.Label(new Rect(Screen.width / 2 - 50, 10, 100, 20), "Twippies : " + nbTwippies.ToString());
//}
public void AddObject(ManageableObjet obj)
{
if (AllObjects.Contains(obj))
{
return;
}
AllObjects.Add(obj);
//Debug.Log(obj.name + " ajouté à la liste globale");
}
public override void Update()
{
if (!spawnedKey && AllObjects.NpcList.Count == 0 && key != null)
{
AllObjects.Spawn(key);
spawnedKey = true;
}
base.Update();
}
public ProgramMetadataResult GetProgramMetadata(OracleProgramIdentifier identifier, int parameterCount, bool forceBuiltInFunction, bool hasAnalyticClause, bool includePlSqlObjects)
{
var result = new ProgramMetadataResult();
OracleSchemaObject schemaObject;
IEnumerable <OracleProgramMetadata> programMetadataSource = new List <OracleProgramMetadata>();
if (String.IsNullOrEmpty(identifier.Package) && (forceBuiltInFunction || String.IsNullOrEmpty(identifier.Owner)))
{
var builtInProgramPackage = OracleObjectIdentifier.IdentifierBuiltInFunctionPackage;
var programIdentifier = OracleProgramIdentifier.CreateFromValues(builtInProgramPackage.Owner, builtInProgramPackage.Name, identifier.Name);
if (AllObjects.TryGetValue(builtInProgramPackage, out schemaObject))
{
programMetadataSource = BuiltInPackageProgramMetadata[programIdentifier];
}
result.Metadata = TryFindProgramOverload(programMetadataSource, identifier.Name, parameterCount, hasAnalyticClause, !forceBuiltInFunction && includePlSqlObjects);
if (result.Metadata == null)
{
if (includePlSqlObjects && AllObjects.TryGetValue(OracleObjectIdentifier.IdentifierDbmsStandard, out schemaObject))
{
programIdentifier = OracleProgramIdentifier.CreateFromValues(builtInProgramPackage.Owner, OracleObjectIdentifier.PackageDbmsStandard, identifier.Name);
programMetadataSource = BuiltInPackageProgramMetadata[programIdentifier];
result.Metadata = TryFindProgramOverload(programMetadataSource, identifier.Name, parameterCount, hasAnalyticClause, true);
}
if (result.Metadata == null)
{
var nonSchemaBuiltInFunctionIdentifier = OracleProgramIdentifier.CreateBuiltIn(identifier.Name);
result.Metadata = TryFindProgramOverload(NonSchemaBuiltInFunctionMetadata[nonSchemaBuiltInFunctionIdentifier], identifier.Name, parameterCount, hasAnalyticClause, includePlSqlObjects);
}
}
result.SchemaObject = schemaObject;
}
if (result.Metadata == null)
{
var schemaObjectFound = (String.IsNullOrWhiteSpace(identifier.Package) && AllObjects.TryGetValue(OracleObjectIdentifier.Create(identifier.Owner, identifier.Name), out schemaObject)) ||
AllObjects.TryGetValue(OracleObjectIdentifier.Create(identifier.Owner, identifier.Package), out schemaObject);
if (!schemaObjectFound || !TryGetSchemaObjectProgramMetadata(schemaObject, out programMetadataSource))
{
return(result);
}
result.SchemaObject = schemaObject;
var programName = String.IsNullOrEmpty(identifier.Package) ? schemaObject.GetTargetSchemaObject().Name : identifier.Name;
result.Metadata = TryFindProgramOverload(programMetadataSource, programName, parameterCount, hasAnalyticClause, includePlSqlObjects);
}
return(result);
}
private void OnRemovePerson()
{
var selectedSearchable = SelectedObject as ISearchable;
if (selectedSearchable == null)
{
return;
}
AllObjects.Remove(selectedSearchable);
}
public override void Update()
{
spawnDelayCounter++;
if (spawnDelayCounter >= wallMasterSpawnDelay && wallMasterCounter <= wallMasterToSpawn)
{
AllObjects.Spawn(new Hand(spriteBatch, GenerateRandomWallMasterSpawnPoint(), roomToJumpTo));
spawnDelayCounter = 0;
wallMasterCounter++;
}
base.Update();
}
private void CheckForCollisions()
{
IEnumerable <EnemyShip> collisions = AllObjects
.Select((m) => m as EnemyShip)
.Where((m) => CollidesWith(m));
foreach (EnemyShip enemy in collisions)
{
enemy.Explode();
}
}
private void Shoot()
{
IEnumerable <Cannon> cannons = AllObjects
.Select((m) => m as Cannon)
.Where((m) => m != null);
foreach (Cannon cannon in cannons)
{
cannon.Shoot();
}
}
public double Distance(String ob1, String ob2)
{
if (!AllObjects.ContainsKey(ob1) || !AllObjects.ContainsKey(ob2))
{
return(-1);
}
Vec3D ob1V = new Vec3D(AllObjects[ob1].Location);
Vec3D ob2V = new Vec3D(AllObjects[ob2].Location);
return(ob1V.ScalerDistanceTo(ob2V));
}
public ISchemaBase Find(int id)
{
try
{
string full = AllObjects.GetFullName(id);
return(Find(full));
}
catch
{
return(null);
}
}
protected override void FilterCollections(object obj)
{
var filter = obj as string;
var cards = AllObjects
.Where(c => c.CardType.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0)
.ToList();
FilteredCollection = new ObservableCollection <Card>(cards);
ChangeStyle(filter);
}
public IEnumerable <ClrObject> EnumerateClrObjects(string typeName)
{
if (typeName.Contains("*"))
{
var regex = new Regex($"^{Regex.Escape(typeName).Replace("\\*", ".*")}$",
RegexOptions.Compiled | RegexOptions.IgnoreCase);
return(AllObjects.Where(item => regex.IsMatch(item.TypeName)));
}
return(AllObjects.Where(item => item.TypeName == typeName));
}
public override void Update()
{
if (!openedDoor && AllObjects.NpcList.Count == 0)
{
GetDoor(Constants.Direction.Right).OpenDoor();
openedDoor = true;
if (heartContainer != null)
{
AllObjects.Spawn(heartContainer);
}
}
base.Update();
}
internal void ViewProStopObjectUpdate(SimulationEvent ev)
{
String id = ((StringValue)ev["ObjectID"]).value;
if (AllObjects.ContainsKey(id))
{
AllObjects[id].ShouldProject = false;
}
if (PlayerAgent != null)
{
PlayerAgent.ViewProStopObjectUpdate(ev);
}
}
public SearchResults SearchInDb(string query = "", ObjectTypes searchIn = ObjectTypes.All, Sort sort = Sort.asc)
{
Results = new SearchResults();
if (DB == null || !DB.IsConnected)
{
Results.Error = true;
Results.ErrorMessage = "There is no database connection!";
return(Results);
}
SearchQuery = query;
if (AllObjects == null)
{
AllObjects = DB.GetObjects().ToList();
}
Results.FoundDbObjects = AllObjects.Where(o =>
o is Table <T> && (searchIn.HasFlag(ObjectTypes.Tables) | searchIn.HasFlag(ObjectTypes.Columns)) ||
o is View <T> && searchIn.HasFlag(ObjectTypes.Views) ||
o is StoredProcedure <T> && searchIn.HasFlag(ObjectTypes.StoredProcedures)
).ToList();
if (query != "")
{
var foundColumns = searchIn.HasFlag(ObjectTypes.Columns) ? DB.FindColumn(query) : null;
var foundScripts = (searchIn.HasFlag(ObjectTypes.StoredProcedures) | searchIn.HasFlag(ObjectTypes.Views)) ? DB.FindInScripts(query) : null;
Results.FoundDbObjects = Results.FoundDbObjects.Where(o =>
(searchIn.HasFlag(ObjectTypes.Tables) && o.Name.ToLowerInvariant().Contains(query.ToLowerInvariant()))
|| (searchIn.HasFlag(ObjectTypes.Columns) && foundColumns.Any(a => a == o.Name))
//|| (searchIn.HasFlag(EDbObjects.Triggers) && o is Table<T> && ((Table<T>)o).Triggers.Any(t => t.Name.ToLowerInvariant().Contains(query.ToLowerInvariant())))
|| ((searchIn.HasFlag(ObjectTypes.StoredProcedures) | searchIn.HasFlag(ObjectTypes.Views)) && foundScripts.Any(a => a == o.Name))
).ToList();
}
if (sort != Sort.none)
{
Results.FoundDbObjects = sort == Sort.asc ?
Results.FoundDbObjects.OrderBy(o => o.Name).ToList() :
Results.FoundDbObjects.OrderByDescending(o => o.Name).ToList();
}
return(Results);
}
public void Sort(string propertyName, string direction)
{
PropertyInfo prop;
string[] arrProp = propertyName.Split('.');
if (arrProp.Length > 1)
{
//Type.GetType("DA.BE.Usuario, DA.BE")
//Type tipoBase = Type.GetType("DA.BE."+arrProp[0]+", DA.BE");
// prop = tipoBase.GetRuntimeProperty(arrProp[1]);
prop = typeof(T).GetProperty(arrProp[0]);
}
else
{
prop = typeof(T).GetProperty(propertyName);
}
if (prop != null)
{
try
{
Type propertyType = Type.GetType(prop.PropertyType.FullName + ", " +
prop.PropertyType.FullName.Split('.')[0] + "." +
prop.PropertyType.FullName.Split('.')[1]);
if (string.IsNullOrEmpty(direction) || direction.ToLower() == "descending")
{
AllObjects = new ObservableCollection <T>(AllObjects.OrderByDescending(x => prop.GetValue(x, null)).ToList());
}
else
{
// var list = AllObjects.OrderBy(x => Convert.ChangeType(prop.GetValue(x, null), propertyType));
//var list = AllObjects.OrderBy(x => (propertyType) prop.GetValue(x, null));
// var list2 = AllObjects.OrderBy(x => prop.GetValue(x, null)).ToList();
AllObjects = new ObservableCollection <T>(AllObjects.OrderBy(x => prop.GetValue(x, null)).ToList());
}
CurrentPageNumber = 1;
SetCurrentPageItems();
}
catch (Exception e)
{
Logger.Log.Error("Error en el ordenamiento: " + e.Message);
}
}
}
public IEnumerable <ClrObject> EnumerateClrObjects(string typeName)
{
if (typeName.Contains("*"))
{
string typeNameRegex = "^" + Regex.Escape(typeName).Replace("\\*", ".*") + "$";
Regex regex = new Regex(typeNameRegex, RegexOptions.Compiled | RegexOptions.IgnoreCase);
return(AllObjects.Where(item => regex.IsMatch(item.Type.Name)));
}
typeName = ObfuscateType(typeName);
return(AllObjects.Where(item => item.Type.Name == typeName));
}
private void CheckForPowerUps()
{
IEnumerable <PowerUp> pups = AllObjects
.Select((m) => m as PowerUp)
.Where((m) => CollidesWith(m));
foreach (PowerUp pup in pups)
{
if (pup != null)
{
pup.ApplyOn(this);
}
}
}
private void MapCity(ICity city, IPlayer player)
{
if (!AllObjects.TryGetValue(city.Guid, out var item))
{
item = new AllObjectsDictionaryItem {
ItemFromServer = city
};
AllObjects.Add(city.Guid, item);
item.Controller = Instantiate(CityControllerBase, new Vector3(city.X, city.Y, 0), Quaternion.identity);
}
// ReSharper disable once PossibleNullReferenceException
(item.Controller as CityController).UpdateFromServer(city, player);
item.Updated = true;
}
private void CheckForPowerUps()
{
PowerUp[] pups = AllObjects.Select(m => m as PowerUp).ToArray();
foreach (PowerUp pup in pups)
{
if (pup != null)
{
if (CollidesWith(pup))
{
pup.ApplyOn(this);
}
}
}
}
private async Task OnAddPersonAsync()
{
var addPersonViewModel = new AddPersonViewModel();
if (await _uiVisualizerService.ShowDialogAsync(addPersonViewModel) ?? false)
{
var person = addPersonViewModel.Person;
var searchable = _dataGenerationService.GenerateSearchable(person);
_searchService.AddObjects(new[] { searchable });
AllObjects.Add(searchable);
_searchService.Search(Filter);
}
}
