public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { //find the first postproc that is a GridRoom postproc and add this to its special rooms //NOTE: if a room-based generator is not found as the generation step, it will just skip this floor but treat it as though it was placed. if (SpreadPlan.CheckIfDistributed(zoneContext, context)) { //TODO: allow arbitrary components to be added RoomGenOption genDuo = Spawns.Pick(context.Rand); SetGridSpecialRoomStep <MapGenContext> specialStep = new SetGridSpecialRoomStep <MapGenContext>(); SetSpecialRoomStep <ListMapGenContext> listSpecialStep = new SetSpecialRoomStep <ListMapGenContext>(); specialStep.Filters = genDuo.Filters; if (specialStep.CanApply(context)) { specialStep.Rooms = new PresetPicker <RoomGen <MapGenContext> >(genDuo.GridOption); specialStep.RoomComponents.Set(new ImmutableRoom()); queue.Enqueue(PriorityGrid, specialStep); } else if (listSpecialStep.CanApply(context)) { listSpecialStep.Rooms = new PresetPicker <RoomGen <ListMapGenContext> >(genDuo.ListOption); listSpecialStep.RoomComponents.Set(new ImmutableRoom()); PresetPicker <PermissiveRoomGen <ListMapGenContext> > picker = new PresetPicker <PermissiveRoomGen <ListMapGenContext> >(); picker.ToSpawn = new RoomGenAngledHall <ListMapGenContext>(0); listSpecialStep.Halls = picker; queue.Enqueue(PriorityList, listSpecialStep); } } }
public void AddEventsToQueue <T>(StablePriorityQueue <GameEventPriority, EventQueueElement <T> > queue, Priority maxPriority, ref Priority nextPriority, PriorityList <T> effectList, Character targetChar) where T : GameEvent { foreach (Priority priority in effectList.GetPriorities()) { //if an item has the same priority variable as the nextPriority, enqueue it //if an item has a higher priority variable than nextPriority, ignore it //if an item has a lower priority variable than nextPriority, check against maxPriority for (int ii = 0; ii < effectList.GetCountAtPriority(priority); ii++) { if (priority == nextPriority) { GameEventPriority gameEventPriority = new GameEventPriority(priority, GameEventPriority.USER_PORT_PRIORITY, GetEventCause(), GetID(), ii); EventQueueElement <T> eventQueueElement = new EventQueueElement <T>(this, null, effectList.Get(priority, ii), targetChar); queue.Enqueue(gameEventPriority, eventQueueElement); } else if (priority < nextPriority || nextPriority == Priority.Invalid) { //if the item has a lower priority variable than maxPriority, ignore it //if the item has a higher priority variable than maxPriority, clear the queue and add the new item if (priority > maxPriority || maxPriority == Priority.Invalid) { nextPriority = priority; queue.Clear(); GameEventPriority gameEventPriority = new GameEventPriority(priority, GameEventPriority.USER_PORT_PRIORITY, GetEventCause(), GetID(), ii); EventQueueElement <T> eventQueueElement = new EventQueueElement <T>(this, null, effectList.Get(priority, ii), targetChar); queue.Enqueue(gameEventPriority, eventQueueElement); } } } } }
private void preCalculateCoverage(StablePriorityQueue <int, Loc> tilesToHit, int delay) { Loc leftDiff, rightDiff; if (Dir.IsDiagonal()) { leftDiff = DirExt.AddAngles(Dir, Dir8.UpRight).GetLoc(); rightDiff = DirExt.AddAngles(Dir, Dir8.UpLeft).GetLoc(); } else { leftDiff = DirExt.AddAngles(Dir, Dir8.Right).GetLoc(); rightDiff = DirExt.AddAngles(Dir, Dir8.Left).GetLoc(); } Loc candTile = StartPoint; for (int ii = 0; ii < MaxDistance; ii++) { candTile += Dir.GetLoc(); tilesToHit.Enqueue(calculateTimeToHit(StartPoint, candTile) + delay, candTile); if (Wide) { tilesToHit.Enqueue(calculateTimeToHit(StartPoint + leftDiff, candTile + leftDiff) + delay, candTile + leftDiff); tilesToHit.Enqueue(calculateTimeToHit(StartPoint + rightDiff, candTile + rightDiff) + delay, candTile + rightDiff); } } }
public void AddEventsToQueue <T>(StablePriorityQueue <GameEventPriority, Tuple <GameEventOwner, Character, T> > queue, Priority maxPriority, ref Priority nextPriority, PriorityList <T> effectList) where T : GameEvent { foreach (Priority priority in effectList.GetPriorities()) { //if an item has the same priority variable as the nextPriority, enqueue it //if an item has a higher priority variable than nextPriority, ignore it //if an item has a lower priority variable than nextPriority, check against maxPriority for (int ii = 0; ii < effectList.GetCountAtPriority(priority); ii++) { if (priority == nextPriority) { queue.Enqueue(new GameEventPriority(priority, PortPriority, Passive.GetEventCause(), Passive.GetID(), ii), new Tuple <GameEventOwner, Character, T>(Passive, EventChar, effectList.Get(priority, ii))); } else if (priority < nextPriority || nextPriority == Priority.Invalid) { //if the item has a lower priority variable than maxPriority, ignore it //if the item has an equal or higher priority variable than maxPriority, clear the queue and add the new item if (priority > maxPriority || maxPriority == Priority.Invalid) { nextPriority = priority; queue.Clear(); queue.Enqueue(new GameEventPriority(priority, PortPriority, Passive.GetEventCause(), Passive.GetID(), ii), new Tuple <GameEventOwner, Character, T>(Passive, EventChar, effectList.Get(priority, ii))); } } } } }
public void TestIntQueueUpdatePriority() { StablePriorityQueue <Node> stableQueue = new StablePriorityQueue <Node>(100); Node n1 = new Node(); Node n2 = new Node(); Node n3 = new Node(); Node n4 = new Node(); stableQueue.Enqueue(n1, 1); stableQueue.Enqueue(n2, 1); stableQueue.Enqueue(n3, 1); stableQueue.Enqueue(n4, 1); Node node = stableQueue.First; Assert.IsTrue(node == n1); stableQueue.UpdatePriority(n1, 1); node = stableQueue.First; Assert.IsTrue(node == n1); stableQueue.UpdatePriority(n1, 2); node = stableQueue.First; Assert.IsTrue(node == n2); stableQueue.UpdatePriority(n1, 1); node = stableQueue.First; Assert.IsTrue(node == n1); stableQueue.Dequeue(); node = stableQueue.First; Assert.IsTrue(node == n2); stableQueue.Dequeue(); node = stableQueue.First; Assert.IsTrue(node == n3); }
private void preCalculateCoverage(StablePriorityQueue <int, Loc> tilesToHit, int delay) { Loc topLeft = Origin - new Loc(MaxRadius); bool[][] connectionGrid = new bool[MaxRadius * 2 + 1][]; for (int xx = 0; xx < connectionGrid.Length; xx++) { connectionGrid[xx] = new bool[MaxRadius * 2 + 1]; } connectionGrid[Origin.X - topLeft.X][Origin.Y - topLeft.Y] = true; tilesToHit.Enqueue(calculateTimeToHit(Origin) + delay, Origin); Loc backup = Origin; if (MaxRadius > 0 && ZoneManager.Instance.CurrentMap.TileBlocked(Origin, true)) { backup += Dir.Reverse().GetLoc(); } Grid.FloodFill(new Rect(Origin - new Loc(MaxRadius), new Loc(MaxRadius * 2 + 1)), (Loc testLoc) => { if (connectionGrid[testLoc.X - topLeft.X][testLoc.Y - topLeft.Y]) { return(true); } if (!Collision.InBounds(ZoneManager.Instance.CurrentMap.Width, ZoneManager.Instance.CurrentMap.Height, testLoc)) { return(true); } if (!IsInSquareHitbox(testLoc, Origin, MaxRadius, HitArea, Dir)) { return(true); } if (ZoneManager.Instance.CurrentMap.TileBlocked(testLoc, true)) { return(true); } return(false); }, (Loc testLoc) => { return(false); }, (Loc fillLoc) => { if (fillLoc != Origin) { connectionGrid[fillLoc.X - topLeft.X][fillLoc.Y - topLeft.Y] = true; tilesToHit.Enqueue(calculateTimeToHit(fillLoc) + delay, fillLoc); } }, backup); }
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { int id = zoneContext.CurrentID; foreach (int floorId in SpreadPlan.DropPoints) { if (floorId != zoneContext.CurrentID) { continue; } foreach (IGenPriority vaultStep in VaultSteps) { queue.Enqueue(vaultStep.Priority, vaultStep.GetItem()); } { SpawnList <MapItem> itemListSlice = Items.GetSpawnList(id); PickerSpawner <ListMapGenContext, MapItem> constructedSpawns = new PickerSpawner <ListMapGenContext, MapItem>(new LoopedRand <MapItem>(itemListSlice, ItemAmount[id])); List <IStepSpawner <ListMapGenContext, MapItem> > steps = new List <IStepSpawner <ListMapGenContext, MapItem> >(); steps.Add(constructedSpawns); if (ItemSpawners.ContainsItem(id)) { IStepSpawner <ListMapGenContext, MapItem> treasures = ItemSpawners[id].Copy(); steps.Add(treasures); } PresetMultiRand <IStepSpawner <ListMapGenContext, MapItem> > groupRand = new PresetMultiRand <IStepSpawner <ListMapGenContext, MapItem> >(steps.ToArray()); RandomRoomSpawnStep <ListMapGenContext, MapItem> detourItems = ItemPlacements[id].Copy(); detourItems.Spawn = new MultiStepSpawner <ListMapGenContext, MapItem>(groupRand); queue.Enqueue(ItemPriority, detourItems); } SpawnList <MobSpawn> mobListSlice = Mobs.GetSpawnList(id); if (mobListSlice.CanPick) { //secret enemies SpecificTeamSpawner specificTeam = new SpecificTeamSpawner(); MobSpawn newSpawn = mobListSlice.Pick(context.Rand).Copy(); specificTeam.Spawns.Add(newSpawn); //use bruteforce clone for this PlaceRandomMobsStep <ListMapGenContext> secretMobPlacement = MobPlacements[id].Copy(); secretMobPlacement.Spawn = new LoopedTeamSpawner <ListMapGenContext>(specificTeam, MobAmount[id]); queue.Enqueue(MobPriority, secretMobPlacement); } } }
public IMessage PublishByNumber(Type type, IEventArgs args, int priority = MessageUrgency.Common) { var message = _pool.Get(); message.Begin(); message.SetArgs(args).SetType(type); if (priority < 0) { HandleMessage(message); } else { using (new LockWait(ref _lock_message)) { if (_queue.count == _queue.capcity) { _queue.Resize(_queue.capcity * 2); } var node = nodePool.Get(); _queue.Enqueue(node, priority); excuteMap.Add(node, message); _list.Add(node); } } return(message); }
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { ItemSpawnStep <BaseMapGenContext> spawnStep = new ItemSpawnStep <BaseMapGenContext>(); spawnStep.Spawns = Spawns.GetSpawnList(zoneContext.CurrentID); queue.Enqueue(Priority, spawnStep); }
private void addToQueue(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { int id = zoneContext.CurrentID; IMonsterHouseBaseStep monsterHouseStep = HouseStepSpawns.Pick(context.Rand).CreateNew(); SpawnList <MapItem> itemListSlice = Items.GetSpawnList(id); for (int jj = 0; jj < itemListSlice.Count; jj++) { monsterHouseStep.Items.Add(new MapItem(itemListSlice.GetSpawn(jj)), itemListSlice.GetSpawnRate(jj)); } SpawnList <ItemTheme> itemThemeListSlice = ItemThemes.GetSpawnList(id); for (int jj = 0; jj < itemThemeListSlice.Count; jj++) { monsterHouseStep.ItemThemes.Add(itemThemeListSlice.GetSpawn(jj).Copy(), itemThemeListSlice.GetSpawnRate(jj)); } SpawnList <MobSpawn> mobListSlice = Mobs.GetSpawnList(id); for (int jj = 0; jj < mobListSlice.Count; jj++) { MobSpawn newSpawn = mobListSlice.GetSpawn(jj).Copy(); monsterHouseStep.Mobs.Add(newSpawn, mobListSlice.GetSpawnRate(jj)); } SpawnList <MobTheme> mobThemeListSlice = MobThemes.GetSpawnList(id); for (int jj = 0; jj < mobThemeListSlice.Count; jj++) { monsterHouseStep.MobThemes.Add(mobThemeListSlice.GetSpawn(jj).Copy(), mobThemeListSlice.GetSpawnRate(jj)); } queue.Enqueue(Priority, monsterHouseStep); }
public void Add(T task) { lock (LockObject) { queue.Enqueue(task, task.Priority); } }
public IMessage PublishByNumber(Type type, IEventArgs args, int priority = MessageUrgency.Common) { var message = Framework.GlobalAllocate <Message>(); message.Begin(); message.SetArgs(args).SetType(type); if (priority < 0) { HandleMessage(message); } else { using (new LockWait(ref _lock_message)) { if (_priorityQueue.count == _priorityQueue.capcity) { _priorityQueue.Resize(_priorityQueue.capcity * 2); } StablePriorityQueueNode node = Framework.GlobalAllocate <StablePriorityQueueNode>(); _priorityQueue.Enqueue(node, priority); excuteMap.Add(node, message); _updatelist.Add(node); } } return(message); }
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { if (SpreadPlan.CheckIfDistributed(zoneContext, context)) { IGenPriority genStep = Spawns.Pick(context.Rand); queue.Enqueue(genStep.Priority, genStep.GetItem()); } }
public void Enqueue(T item, float priority) { SimpleNode node = new SimpleNode(item); if (queue.Count == queue.MaxSize) { queue.Resize(queue.MaxSize * 2 + 1); } queue.Enqueue(node, priority); }
private void preCalculateCoverage(StablePriorityQueue <int, Loc> tilesToHit, int delay) { HashSet <Loc> hitTiles = new HashSet <Loc>(); HashSet <Loc> returnTiles = new HashSet <Loc>(); Loc candTile = StartPoint; for (int ii = 0; ii < MaxDistance; ii++) { candTile = candTile + Dir.GetLoc(); tilesToHit.Enqueue(calculateTimeToHit(candTile, false) + delay, candTile); } if (Boomerang) { for (int ii = 0; ii < MaxDistance - 1; ii++) { candTile = candTile - Dir.GetLoc(); tilesToHit.Enqueue(calculateTimeToHit(candTile, true) + delay, candTile); } } }
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { TileSpawnStep <BaseMapGenContext> spawnStep = new TileSpawnStep <BaseMapGenContext>(); SpawnList <EffectTile> spawner = Spawns.GetSpawnList(zoneContext.CurrentID); for (int ii = 0; ii < spawner.Count; ii++) { spawnStep.Spawns.Add(spawner.GetSpawn(ii), spawner.GetSpawnRate(ii)); } queue.Enqueue(Priority, spawnStep); }
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { int id = zoneContext.CurrentID; foreach (int floorId in SpreadPlan.DropPoints) { if (floorId != zoneContext.CurrentID) { continue; } { SpawnList <AddBossRoomStep <ListMapGenContext> > bossListSlice = BossSteps.GetSpawnList(id); if (!bossListSlice.CanPick) { return; } AddBossRoomStep <ListMapGenContext> bossStep = bossListSlice.Pick(context.Rand).Copy(); queue.Enqueue(BossRoomPriority, bossStep); } foreach (IGenPriority vaultStep in VaultSteps) { queue.Enqueue(vaultStep.Priority, vaultStep.GetItem()); } { SpawnList <MapItem> itemListSlice = Items.GetSpawnList(id); PickerSpawner <ListMapGenContext, MapItem> constructedSpawns = new PickerSpawner <ListMapGenContext, MapItem>(new LoopedRand <MapItem>(itemListSlice, ItemAmount[id])); IStepSpawner <ListMapGenContext, MapItem> treasures = ItemSpawners[id].Copy(); PresetMultiRand <IStepSpawner <ListMapGenContext, MapItem> > groupRand = new PresetMultiRand <IStepSpawner <ListMapGenContext, MapItem> >(constructedSpawns, treasures); RandomRoomSpawnStep <ListMapGenContext, MapItem> detourItems = ItemPlacements[id].Copy(); detourItems.Spawn = new MultiStepSpawner <ListMapGenContext, MapItem>(groupRand); queue.Enqueue(RewardPriority, detourItems); } } }
public void UpdateHitQueue(StablePriorityQueue <int, HitboxHit> hitTargets) { //when updating, the base will update the time elapsed //when this method is reached, hits will be delegated accordingly while (TilesToHit.Count > 0 && (Finished || time >= TilesToHit.FrontPriority())) { int priority = TilesToHit.FrontPriority(); Loc tile = TilesToHit.Dequeue(); //filter out the hitboxes that are not wanted TargetHitType type = IsValidTileTarget(tile); if (type == TargetHitType.Burst) { hitTargets.Enqueue(priority, new HitboxHit(tile, true)); } else if (type == TargetHitType.Tile) { hitTargets.Enqueue(priority, new HitboxHit(tile, false)); } } }
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { GameProgress progress = DataManager.Instance.Save; if (progress != null && progress.Rescue != null && progress.Rescue.Rescuing) { if (progress.Rescue.SOS.Goal.ID == zoneContext.CurrentZone && progress.Rescue.SOS.Goal.StructID.Segment == zoneContext.CurrentSegment && progress.Rescue.SOS.Goal.StructID.ID == zoneContext.CurrentID) { queue.Enqueue(Priority, new RescueSpawner <BaseMapGenContext>()); } } }
/// <summary> /// 按批量方式进行资源的加载 /// 如果指定使用标签进行资源加载,则会忽略<paramref name="addresses"/>的值 /// </summary> /// <param name="label">加载设定指定标签的资源</param> /// <param name="addresses">资源加载地址</param> /// <param name="isInstance">是否需要实例化</param> /// <param name="complete">单个资源加载完毕后回调</param> /// <param name="batchComplete">所有资源加载完毕后回调</param> /// <param name="progress">单个资源加载进度回调</param> /// <param name="batchProgress">所有资源加载进度回调</param> /// <param name="priority">优先级</param> /// <param name="userData">自定义参数</param> /// <returns></returns> internal AssetHandler LoadBatchAssetAsync( string label, string[] addresses, bool isInstance, OnAssetLoadComplete complete, OnBatchAssetLoadComplete batchComplete, OnAssetLoadProgress progress, OnBatchAssetsLoadProgress batchProgress, AssetLoaderPriority priority, SystemObject userData) { //如果指定按标签加载资源,则查找标记为指定标签的所有资源 if (!string.IsNullOrEmpty(label)) { addresses = addressConfig.GetAddressesByLabel(label); DebugLog.Debug(AssetConst.LOGGER_NAME, $"AssetLoader::LoadBatchAssetAsync->Load asset by label.label = {label},addresses = {string.Join(",",addresses)}"); } if (addresses == null || addresses.Length == 0) { DebugLog.Error(AssetConst.LOGGER_NAME, "AAssetLoader::LoadBatchAssetAsync->addresses is null"); return(null); } //获取资源真实的路径 string[] paths = addressConfig.GetPathsByAddresses(addresses); if (paths == null || paths.Length == 0) { DebugLog.Error(AssetConst.LOGGER_NAME, "AssetLoader::LoadBatchAssetAsync->paths is null"); return(null); } else { DebugLog.Debug(AssetConst.LOGGER_NAME, $"AssetLoader::LoadBatchAssetAsync->find assetPath by address.addresses = {string.Join(",", addresses)},path = {string.Join(",",paths)}"); } if (dataWaitingQueue.Count >= dataWaitingQueue.MaxSize) { dataWaitingQueue.Resize(dataWaitingQueue.MaxSize * 2); DebugLog.Debug(AssetConst.LOGGER_NAME, "AssetLoader::LoadBatchAssetAsync->Reset the queue size."); } AssetLoaderData data = dataPool.Get(); data.InitData(label, addresses, paths, isInstance, complete, progress, batchComplete, batchProgress, userData); data.State = AssetLoaderDataState.Waiting; dataWaitingQueue.Enqueue(data, (float)priority); return(data.Handler); }
private void preCalculateCoverage(StablePriorityQueue <int, Loc> tilesToHit, int delay) { for (int ii = -MaxRadius; ii <= MaxRadius; ii++) { for (int jj = -MaxRadius; jj <= MaxRadius; jj++) { Loc candTile = new Loc(ii, jj) + Origin; if (IsInSquareHitbox(candTile, Origin, MaxRadius, HitArea, Dir) && Collision.InBounds(ZoneManager.Instance.CurrentMap.Width, ZoneManager.Instance.CurrentMap.Height, candTile)) { tilesToHit.Enqueue(calculateTimeToHit(candTile) + delay, candTile); } } } }
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { MobSpawnStep <BaseMapGenContext> spawnStep = new MobSpawnStep <BaseMapGenContext>(); PoolTeamSpawner spawner = new PoolTeamSpawner(); spawner.Spawns = Spawns.GetSpawnList(zoneContext.CurrentID); spawner.TeamSizes = TeamSizes.GetSpawnList(zoneContext.CurrentID); spawnStep.Spawns.Add(spawner, spawner.Spawns.SpawnTotal); SpawnList <SpecificTeamSpawner> specificSpawner = SpecificSpawns.GetSpawnList(zoneContext.CurrentID); for (int ii = 0; ii < specificSpawner.Count; ii++) { spawnStep.Spawns.Add(specificSpawner.GetSpawn(ii), specificSpawner.GetSpawnRate(ii)); } queue.Enqueue(Priority, spawnStep); }
public IEnumerator <YieldInstruction> BeforeExplosion(BattleContext context) { EventEnqueueFunction <BattleEvent> function = (StablePriorityQueue <GameEventPriority, Tuple <GameEventOwner, Character, BattleEvent> > queue, Priority maxPriority, ref Priority nextPriority) => { DataManager.Instance.UniversalEvent.AddEventsToQueue(queue, maxPriority, ref nextPriority, DataManager.Instance.UniversalEvent.BeforeExplosions); context.Data.AddEventsToQueue <BattleEvent>(queue, maxPriority, ref nextPriority, context.Data.BeforeExplosions); StablePriorityQueue <int, Character> charQueue = new StablePriorityQueue <int, Character>(); foreach (Character character in ZoneManager.Instance.CurrentMap.IterateCharacters()) { if (!character.Dead) { charQueue.Enqueue(-character.Speed, character); } } int portPriority = 0; while (charQueue.Count > 0) { Character character = charQueue.Dequeue(); foreach (PassiveContext effectContext in character.IterateProximityPassives(context.User, context.ExplosionTile, portPriority)) { effectContext.AddEventsToQueue(queue, maxPriority, ref nextPriority, ((ProximityData)effectContext.EventData).BeforeExplosions); } portPriority++; } }; foreach (Tuple <GameEventOwner, Character, BattleEvent> effect in IterateEvents <BattleEvent>(function)) { yield return(CoroutineManager.Instance.StartCoroutine(effect.Item3.Apply(effect.Item1, effect.Item2, context))); if (context.CancelState.Cancel) { yield break; } } }
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { SpawnDict <string, SpawnList <InvItem> > spawns = new SpawnDict <string, SpawnList <InvItem> >(); //contains all LISTS that intersect the current ID foreach (string key in Spawns.Keys) { //get all items within the spawnrangelist that intersect the current ID SpawnList <InvItem> slicedList = Spawns[key].Spawns.GetSpawnList(zoneContext.CurrentID); // add the spawnlist under the current key, with the key having the spawnrate for this id if (slicedList.CanPick && Spawns[key].SpawnRates.ContainsItem(zoneContext.CurrentID) && Spawns[key].SpawnRates[zoneContext.CurrentID] > 0) { spawns.Add(key, slicedList, Spawns[key].SpawnRates[zoneContext.CurrentID]); } } ItemSpawnStep <BaseMapGenContext> spawnStep = new ItemSpawnStep <BaseMapGenContext>(); spawnStep.Spawns = spawns; queue.Enqueue(Priority, spawnStep); }
private static void Update_OPTICS(ref Dictionary <PointD, Tuple <bool, double?> > DictionnaryOfOPTICS, List <PointD> list_of_neighbors, PointD point, ref StablePriorityQueue <PointDQueue> seeds, double epsilon, int min_points) { double?core_dist = Core_distance(DictionnaryOfOPTICS, point, epsilon, min_points); foreach (PointD O in list_of_neighbors) { if (DictionnaryOfOPTICS[O].Item1 == false) { double?reachability = Reachability_distance(DictionnaryOfOPTICS, point, O, epsilon, min_points); if (DictionnaryOfOPTICS[O].Item2 == null) { DictionnaryOfOPTICS[O] = new Tuple <bool, double?>(DictionnaryOfOPTICS[O].Item1, reachability); seeds.Enqueue(new PointDQueue(O.X, O.Y), (float)reachability); } else if (reachability < DictionnaryOfOPTICS[O].Item2) { DictionnaryOfOPTICS[O] = new Tuple <bool, double?>(DictionnaryOfOPTICS[O].Item1, reachability); seeds.UpdatePriority(new PointDQueue(O.X, O.Y), (float)reachability); } } } }
public IGenContext GenMap(ZoneGenContext zoneContext) { //it will first create the instance of the context, //and set up a local List<GenPriority<IGenStep>> variable //the zonecontext members include runtime zonepostprocs //that will appreciate a IGenContext + List<GenPriority<IGenStep>> being passed into them //then, gensteps will continue on as per usual T map = (T)Activator.CreateInstance(typeof(T)); map.InitSeed(zoneContext.Seed); GenContextDebug.DebugInit(map); //postprocessing steps: StablePriorityQueue <Priority, IGenStep> queue = new StablePriorityQueue <Priority, IGenStep>(); foreach (Priority priority in GenSteps.GetPriorities()) { foreach (IGenStep genStep in GenSteps.GetItems(priority)) { queue.Enqueue(priority, genStep); } } foreach (ZonePostProc zoneStep in zoneContext.ZoneSteps) { zoneStep.Apply(zoneContext, map, queue); } ApplyGenSteps(map, queue); map.FinishGen(); return(map); }
private GameAction DumbAvoid(Character controlledChar, bool preThink, List <Character> seenCharacters, CharIndex ownIndex, IRandom rand) { StablePriorityQueue <double, Dir8> candidateDirs = new StablePriorityQueue <double, Dir8>(); //choose the single direction that avoids other characters the most bool respectPeers = !preThink; for (int ii = -1; ii < DirExt.DIR8_COUNT; ii++) { Loc checkLoc = controlledChar.CharLoc + ((Dir8)ii).GetLoc(); double dirDistance = 0; //iterated in increasing character indices foreach (Character seenChar in seenCharacters) { if (RunFromAllies && !RunFromFoes) { //only avoid if their character index is lower than this one, aka higher ranking member CharIndex seenIndex = ZoneManager.Instance.CurrentMap.GetCharIndex(seenChar); if (seenIndex.Team > ownIndex.Team) { break; } else if (seenIndex.Team == ownIndex.Team) { if (seenIndex.Char > ownIndex.Char && seenChar.MemberTeam.LeaderIndex != seenIndex.Char) { continue; } } } dirDistance += Math.Sqrt((checkLoc - seenChar.CharLoc).DistSquared()); } candidateDirs.Enqueue(-dirDistance, (Dir8)ii); } Grid.LocTest checkDiagBlock = (Loc testLoc) => { return(ZoneManager.Instance.CurrentMap.TileBlocked(testLoc, controlledChar.Mobility, true)); //enemy/ally blockings don't matter for diagonals }; Grid.LocTest checkBlock = (Loc testLoc) => { if (ZoneManager.Instance.CurrentMap.TileBlocked(testLoc, controlledChar.Mobility)) { return(true); } if ((IQ & AIFlags.TrapAvoider) != AIFlags.None) { Tile tile = ZoneManager.Instance.CurrentMap.Tiles[testLoc.X][testLoc.Y]; if (tile.Effect.ID > -1) { TileData entry = DataManager.Instance.GetTile(tile.Effect.ID); if (entry.StepType == TileData.TriggerType.Trap || entry.StepType == TileData.TriggerType.Site || entry.StepType == TileData.TriggerType.Switch) { return(true); } } } if (respectPeers && BlockedByChar(testLoc, Alignment.Self | Alignment.Foe)) { return(true); } return(false); }; //try each direction from most appealing to least appealing, stopping if we get to "none" while (candidateDirs.Count > 0) { Dir8 highestDir = candidateDirs.Dequeue(); if (highestDir == Dir8.None) { if (AbortIfCornered)//this plan will be aborted, try the next plan in the list { return(null); } else//cry in a corner { return(new GameAction(GameAction.ActionType.Wait, Dir8.None)); } } else { //check to see if we can walk this way if (!Grid.IsDirBlocked(controlledChar.CharLoc, highestDir, checkBlock, checkDiagBlock)) { return(TrySelectWalk(controlledChar, highestDir)); } } } if (AbortIfCornered)//this plan will be aborted, try the next plan in the list { return(null); } else//cry in a corner { return(new GameAction(GameAction.ActionType.Wait, Dir8.None)); } }
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { queue.Enqueue(Priority, new MapNameIDStep <BaseMapGenContext>(zoneContext.CurrentID, LocalText.FormatLocalText(Name, (zoneContext.CurrentID + 1).ToString()))); }
public override void Apply(ZoneGenContext zoneContext, IGenContext context, StablePriorityQueue <Priority, IGenStep> queue) { RandRange amount = new RandRange(chosenStart + chosenAdd * zoneContext.CurrentID); queue.Enqueue(Priority, new MoneySpawnStep <BaseMapGenContext>(amount)); }