public ComponentSet(World world) { entities = new SparseSet(); components = new PagedArray <T>(); world.OnEntityRemoved += OnEntityRemoved; }
public void SparseSet_Stress_Test() { var set = new SparseSet(1000, 1000); var random = new Random(); var testCollection = Enumerable.Range(0, 1000) .OrderBy(x => random.Next()) .ToList(); foreach (var element in testCollection) { set.Add(element); } foreach (var element in testCollection) { Assert.IsTrue(set.HasItem(element)); } foreach (var element in testCollection) { Assert.IsTrue(set.HasItem(element)); set.Remove(element); Assert.IsFalse(set.HasItem(element)); } }
/// <summary> /// Creates a factory that provides ECS funcitonality. /// </summary> /// <param name="entityCapacity">The total of amount of entities supported by this factory.</param> /// <param name="componentCapacity">The total of amount of unique <see cref="IComponent"/> types supported by this factory.</param> /// <param name="systemCapacity">The total of amount of unique <see cref="MorroSystem"/> types supported by this factory.</param> public MorroFactory(uint entityCapacity, uint componentCapacity, uint systemCapacity) { EntityCapacity = entityCapacity; ComponentCapacity = componentCapacity; SystemCapacity = systemCapacity; componentAddition = new Queue <Tuple <uint, IComponent[]> >((int)EntityCapacity); componentSubtraction = new Queue <Tuple <uint, Type[]> >((int)EntityCapacity); entityRemovalQueue = new SparseSet(EntityCapacity); // System Setup systems = new MorroSystem[SystemCapacity]; systemLookup = new Dictionary <Type, uint>((int)SystemCapacity); // Component Setup componentData = new IComponent[ComponentCapacity][]; componentLookup = new Dictionary <Type, uint>((int)ComponentCapacity); for (int i = 0; i < ComponentCapacity; i++) { componentData[i] = new IComponent[EntityCapacity]; } // Entity Setup attachedComponents = new SparseSet[EntityCapacity]; attachedSystems = new SparseSet[EntityCapacity]; vacancies = new Queue <uint>((int)EntityCapacity); for (int i = 0; i < EntityCapacity; i++) { attachedComponents[i] = new SparseSet(ComponentCapacity); attachedSystems[i] = new SparseSet(SystemCapacity); } }
// Constructors /////////////////////////// public Archetype(EntityType type) { this.type = type; entities = new SparseSet <int, EntityId>(i => i, this.MoveDataRow); data = SparseEntitySet <ComponentArray>(); free = new Queue <int>(); edges = SparseEntitySet <Archetype>(); }
// Constructors /////////////////////////// public EntityIndex() { root = new Archetype(new EntityType()); archetypes = new List <Archetype>(); index = SparseEntitySet <Record>(); dataTypes = SparseEntitySet <Type>(); archetypes.Add(root); }
public Factory(uint capacity) { Capacity = capacity; workers = new Worker[Capacity]; behaviorAddition = new Queue <Tuple <uint, Trade[]> >((int)capacity); behaviorSubtraction = new Queue <Tuple <uint, Type[]> >((int)capacity); vacancies = new Queue <uint>((int)capacity); entityRemoval = new SparseSet(capacity); }
public void SparseSet_Smoke_Test() { var set = new SparseSet(15, 10); set.Add(6); set.Add(15); set.Add(0); set.Remove(15); Assert.IsTrue(set.HasItem(6)); Assert.AreEqual(2, set.Length); }
public void SparseSet_Smoke_Test() { var set = new SparseSet(15, 10); set.Add(6); set.Add(15); set.Add(0); //IEnumerable test Assert.AreEqual(set.Count, set.Count()); set.Remove(15); Assert.IsTrue(set.HasItem(6)); Assert.AreEqual(2, set.Count); //IEnumerable test Assert.AreEqual(set.Count, set.Count()); }
/// <summary> /// Does the actual solving. /// </summary> /// <param name="problem"></param> /// <returns></returns> protected override IRoute DoSolve(IProblem problem) { // convert to a symetric problem if needed. IProblem _problem = problem; if (!_problem.Symmetric) { _problem = Convertor.ConvertToSymmetric(_problem); _was_asym = true; } // create the list of customers. _customers = new List <int>(); for (int customer = 0; customer < _problem.Size; customer++) { _customers.Add(customer); } _sparse_set = SparseSetHelper.CreateNearestNeighourSet(_problem, _customers, _customers.Count / 10); //_sparse_set = SparseSetHelper.CreateNonSparseSet(_problem, _customers); // construct a route from the customers. //FixedSymmetricRoute init_route = new FixedSymmetricRoute(_customers); // construct a random route using best-placement. ArbitraryInsertionSolver bp_solver = new ArbitraryInsertionSolver(); IRoute bp_route = bp_solver.Solve(_problem); FixedSymmetricRoute init_route = new FixedSymmetricRoute(bp_route); double init_route_weight = LinKernighanSolver.Weight(_problem, init_route); RouteFound route = new RouteFound() { Route = init_route, RouteWeight = init_route_weight }; Console.WriteLine("Route {0}:{1}", route.Route.ToString(), route.RouteWeight); // step 2. EdgeSet X = new EdgeSet(); EdgeSet Y = new EdgeSet(); IList <int> untried_t_1 = new List <int>(route.Route); while (untried_t_1.Count > 0) { // select t1. int t_1 = untried_t_1[0]; untried_t_1.RemoveAt(0); // search route with t_1. RouteFound t_1_route = this.AfterSelectt1(_problem, route, X, Y, t_1); // select the better route. if (t_1_route.RouteWeight < route.RouteWeight) { untried_t_1 = new List <int>(route.Route); route = RouteFound.SelectBest(route, t_1_route); X = new EdgeSet(); Y = new EdgeSet(); } } // step 2 and step 12. // convert back to asym solution if needed. //result.RemoveAt(result.Count - 1); if (_was_asym) { return(this.ConvertToASymRoute(new List <int>(route.Route))); } return(route.Route); }
public ComponentStore(uint maxComponents) { Set = new SparseSet(maxComponents); instances = new T[maxComponents]; }
public SparseSetResolver() { indices = new SparseSet(10); handlers = new List <IHandler <IMessage> >(); }