public void Move(string name) { if (string.IsNullOrEmpty(name)) { Unload(); GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>().backgroundColor = Color.black; MapChanged?.Invoke(null); return; } var map = Maps.FirstOrDefault(m => m.gameObject.name == name); if (map == null) { throw new ArgumentException($"{name} というマップが見つかりませんでした."); } Unload(); currentMapObject = Instantiate(map.gameObject) as GameObject; CurrentMap = map; CurrentMap.Initialize(this); CurrentMapSize = CurrentMap.Size; GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>().backgroundColor = map.BackColor; MapChanged?.Invoke(map); }
public void Start() { var timeToBreak = false; foreach (var line in _gameMap) { var j = 0; foreach (var isWall in line) { timeToBreak = !isWall; if (timeToBreak) { for (var k = 0; k < j; ++k) { _player.MoveRight(); } break; } ++j; } if (timeToBreak) { break; } _player.MoveDown(); } if (!timeToBreak) { throw new ArgumentException("Not a single cell for a player on the map. Argh!"); } MapChanged?.Invoke(this, new GameMapChangedArgs(_gameMap, _player)); GameContinues?.Invoke(this, EventArgs.Empty); }
public ImageSegment AddSegment(ImageSegment segNew) { ImageSegment seg; if (!TryFindSegment(segNew.Address, out seg)) { EnsureSegmentSize(segNew); segments.Add(segNew.Address, segNew); MapChanged.Fire(this); //DumpSections(); return(segNew); } long delta = segNew.Address - seg.Address; Debug.Assert(delta >= 0); if (delta > 0) { // Need to split the segment if it has a size // x86 real mode segments don't have sizes, and can overlap. var segSplit = new ImageSegment(segNew.Name, segNew.Address, segNew.MemoryArea, segNew.Access); segSplit.Size = (uint)(seg.Size - delta); seg.Size = (uint)delta; segments.Add(segNew.Address, segSplit); // And split any items in the segment MapChanged.Fire(this); //DumpSections(); return(segSplit); } return(seg); }
public ImageMapSegment AddSegment(Address addr, string segmentName, AccessMode access) { ImageMapSegment seg; if (!TryFindSegment(addr, out seg)) { ImageMapSegment segNew = new ImageMapSegment(segmentName, access); segNew.Address = addr; segNew.Size = ~0U; segments.Add(segNew.Address, segNew); MapChanged.Fire(this); return(segNew); } long delta = addr - seg.Address; Debug.Assert(delta >= 0); if (delta > 0) { // Need to split the segment. //$REVIEW: or do we? x86 segments can overlap. var segNew = new ImageMapSegment(segmentName, access); segNew.Address = addr; segNew.Size = (uint)(seg.Size - delta); seg.Size = (uint)delta; segments.Add(segNew.Address, segNew); // And split any items in the segment. AddItem(addr, new ImageMapItem()); MapChanged.Fire(this); return(segNew); } return(seg); }
/// <summary> /// Map assets loading task /// </summary> /// <param name="map">Map to be loaded</param> /// <param name="mapMetaData">Map meta data to be loaded</param> private async Task LoadMapAssets(AssetModel map, MapMetaData mapMetaData) { var loading = true; try { var callback = new Action <bool, string, string>((isDone, sceneName, mapBundlePath) => { var scene = SceneManager.GetSceneByName(sceneName); SceneManager.SetActiveScene(scene); CurrentMapMetaData = mapMetaData; if (Loader.Instance.SimConfig != null) { Loader.Instance.SimConfig.MapName = CurrentMapMetaData.name; } CurrentMapBounds = CalculateMapBounds(scene); LaneSnapping.Initialize(); loadedSceneName = sceneName; PlayerPrefs.SetString(MapPersistenceKey, CurrentMapMetaData.name); loading = false; MapChanged?.Invoke(CurrentMapMetaData); }); Loader.LoadMap(map.AssetGuid, map.Name, LoadSceneMode.Additive, callback); while (loading) { await Task.Delay(100); } } catch (Exception ex) { ScenarioManager.Instance.logPanel.EnqueueError(ex.Message); } }
private void Compute() { int range = WinMax - WinMin; if (range < 1) { range = 1; } double factor = (float)(IntMax - IntMin) / range; int i; for (i = 0; i < 65536; ++i) { if (i <= WinMin) { _lut[i] = (byte)IntMin; } else if (i >= WinMax) { _lut[i] = (byte)IntMax; } else { _lut[i] = (byte)(IntMin + (i - WinMin) * factor); } } MapChanged?.Invoke(); }
/// <summary> /// Передает изменения игрового поля юниту /// </summary> /// <param name="FieldMatrix">Матрица игрового поля</param> /// <param name="MarkedCells">Список "отмеченных" ячеек игрового поля</param> public void SetChanges(FieldPoint[,] FieldMatrix, List <FieldPoint> MarkedCells) { MapChanged.Invoke(FieldMatrix); if (MarkedCells != null) { SendMarkedPointsToUnits(); } }
/// <summary> /// Adds an image map item at the specified address. /// </summary> /// <param name="addr"></param> /// <param name="itemNew"></param> /// <returns></returns> public ImageMapItem AddItem(Address addr, ImageMapItem itemNew) { itemNew.Address = addr; ImageMapItem item; if (!TryFindItem(addr, out item)) { // Outside of range. Items.Add(itemNew.Address, itemNew); MapChanged.Fire(this); return(itemNew); } else { long delta = addr - item.Address; Debug.Assert(delta >= 0, "TryFindItem is supposed to find a block whose address is <= the supplied address"); if (delta > 0) { if (delta < item.Size) { // Need to split the item. itemNew.Size = (uint)(item.Size - delta); item.Size = (uint)delta; Items.Add(itemNew.Address, itemNew); MapChanged.Fire(this); return(itemNew); } else { Items.Add(itemNew.Address, itemNew); MapChanged.Fire(this); return(itemNew); } } else { if (itemNew.Size > 0 && itemNew.Size != item.Size) { Debug.Assert(item.Size >= itemNew.Size); item.Size -= itemNew.Size; item.Address += itemNew.Size; Items[itemNew.Address] = itemNew; Items[item.Address] = item; MapChanged.Fire(this); return(itemNew); } if (item.GetType() != itemNew.GetType()) //$BUGBUG: replaces the type. { Items[itemNew.Address] = itemNew; itemNew.Size = item.Size; } MapChanged.Fire(this); return(item); } } }
public void UnpauseEventHandler() { mapChangedEventHandlerPaused = false; if (mapChangedPendingEvents) { MapChanged.Fire(this); } mapChangedPendingEvents = false; }
/// <summary> /// Fires the <see cref="ObservableDictionary{TKey,TValue}.DictionaryChanged"/> and <see cref="MapChanged"/> events when a change occurs. /// </summary> protected override void OnDictionaryChanged(CollectionChange change, TKey key, TValue value) { // Fire base dictionary event base.OnDictionaryChanged(change, key, value); // Fire map changed event // The portable base dictionary change value matches the Windows Store collection value MapChanged?.Invoke(this, new MapChangedEventArgs <TKey>((global::Windows.Foundation.Collections.CollectionChange)(int) change, key)); }
/// <summary> /// Add entry to the dictionary with given key and value. /// </summary> /// <param name="key">Key of the entry.</param> /// <param name="value">Value of the entry.</param> public void Add(string key, object value) { _underlyingSet.Add(key, value); MapChanged?.Invoke(this, new SettingsManagerItemChanedEventArgs( key, CollectionChange.ItemInserted)); }
/// <summary> /// Add entry to the dictionary. /// </summary> /// <param name="item">Instance of <see cref="KeyValuePair{string, object}"/></param> public void Add(KeyValuePair <string, object> item) { _underlyingSet.Add(item); MapChanged?.Invoke(this, new SettingsManagerItemChanedEventArgs( item.Key, CollectionChange.ItemInserted)); }
/// <summary> /// Clear the dictionary. /// </summary> public void Clear() { _underlyingSet.Clear(); MapChanged?.Invoke(this, new SettingsManagerItemChanedEventArgs( null, CollectionChange.Reset)); }
private void FireMapChanged() { if (!mapChangedEventHandlerPaused) { MapChanged.Fire(this); } else { mapChangedPendingEvents = true; } }
public new bool TryAdd(string key, object value) { base.AddOrUpdate(key, value, (s, o) => value); if (EnableUpdates) { MapChanged?.Invoke(this, new MapChangedEventArgs <string>(key, DistributedCollectionChange.ItemInserted)); } return(true); }
public void Add(string key, object value) { if (ContainsKey(key)) { throw new ArgumentException("An item with the same key has already been added."); } if (value != null) { ApplicationDataContainerInterop.SetValue(_locality, key, DataTypeSerializer.Serialize(value)); MapChanged?.Invoke(this, null); } }
public void AddItemWithSize(Address addr, ImageMapItem itemNew) { ImageMapItem item; if (!TryFindItem(addr, out item)) { throw new ArgumentException(string.Format("Address {0} is not within the image range.", addr)); } long delta = addr - item.Address; Debug.Assert(delta >= 0, "Should have found an item at the supplied address."); if (delta > 0) { int afterOffset = (int)(delta + itemNew.Size); ImageMapItem itemAfter = null; if (item.Size > afterOffset) { itemAfter = new ImageMapItem { Address = addr + itemNew.Size, Size = (uint)(item.Size - afterOffset), DataType = ChopBefore(item.DataType, afterOffset), }; } item.Size = (uint)delta; item.DataType = ChopAfter(item.DataType, (int)delta); // Shrink the existing mofo. Items.Add(addr, itemNew); if (itemAfter != null) { Items.Add(itemAfter.Address, itemAfter); } } else { if (!(item.DataType is UnknownType) && !(item.DataType is CodeType)) { throw new NotSupportedException("Haven't handled this case yet."); } Items.Remove(item.Address); item.Address += itemNew.Size; item.Size -= itemNew.Size; Items.Add(addr, itemNew); if (item.Size > 0 && !Items.ContainsKey(item.Address)) { Items.Add(item.Address, item); } } MapChanged.Fire(this); }
/// <summary> /// Remove entry with the given key. /// </summary> /// <param name="key">Key of the entry to be removed.</param> /// <returns>Value indicates the operation result.</returns> public bool Remove(string key) { var opResult = _underlyingSet.Remove(key); if (opResult) { MapChanged?.Invoke(this, new SettingsManagerItemChanedEventArgs( key, CollectionChange.ItemRemoved)); } return(opResult); }
/// <summary> /// Remove an entry from the dictionary. /// </summary> /// <param name="item">Instance of <see cref="KeyValuePair{string, object}"/></param> /// <returns>Value indicates the operation result.</returns> public bool Remove(KeyValuePair <string, object> item) { var opResult = _underlyingSet.Remove(item); if (opResult) { MapChanged?.Invoke(this, new SettingsManagerItemChanedEventArgs( item.Key, CollectionChange.ItemRemoved)); } return(opResult); }
/// <summary> /// Set value of item with given key. If key doesn't exist, a new entry will be created. /// </summary> /// <param name="value">Value to set.</param> /// <param name="key">Key of the item to set.</param> public void SetValue(object value, [CallerMemberName] string key = null) { if (_underlyingSet.ContainsKey(key)) { _underlyingSet[key] = value; } else { _underlyingSet.Add(key, value); } MapChanged?.Invoke(this, new SettingsManagerItemChanedEventArgs( key, CollectionChange.ItemChanged)); }
//public void UpdateCell(int x, int y, string state, Player player) //{ // Map[y] = Map[y].Substring(0, x) + Convert.ToChar(state) + Map[y].Substring(x + 1); // Players[player.Index] = player; // CellChanged?.Invoke(this, new CellChangedEvent {State = state, X = x, Y = y}); //} public void UpdateMap(IList <string> map, Point tecman, IList <Point> ghosts, IList <Point> ghostsOld, bool iAmTecman) { int width = map[0].Length; int height = map.Count; Map = new CellState[height, width]; for (int row = 0; row < height; row++) { ParseRow(row, map[row]); } Tecman = tecman; TecmanNext = tecman; SetFlag(tecman, CellState.Tecman); SetFlag(tecman, CellState.TecmanNext); Ghost = ghosts.ToArray(); GhostNext = ghosts.ToArray(); CellState flg = CellState.Ghost1 | CellState.Ghost1Next; foreach (Point p in Ghost) { SetFlag(p, flg); flg = (CellState)((ushort)flg * 2); } GhostOld = ghostsOld.ToArray(); //flg = CellState.Ghost1Old; //foreach (Point p in GhostOld) //{ // SetFlag(p, flg); // flg = (CellState)((ushort)flg * 2); //} if (iAmTecman) { Actors = new MapActor[] { new MapActor(0, "Tc", Tecman, true) }; } else { Actors = Ghost.Select((p, i) => new MapActor(i, "G" + (i + 1), p, false)).ToList(); } MapChanged?.Invoke(this, new MapChangedEventArgs { Map = Map }); }
public void SyncToModel() { (List <NodeViewModel> addedNodes, List <NodeViewModel> removedNodes) = SyncNodes(); (List <EdgeViewModel> addedEdges, List <EdgeViewModel> removedEdges) = SyncEdges(); Arrange(); if (addedNodes.Count == 0 && removedNodes.Count == 0 && addedEdges.Count == 0 && removedEdges.Count == 0) { return; } var mapChangedArgs = new MapChangedEventArgs() { AddedNodes = addedNodes, RemovedNodes = removedNodes, AddedEdges = addedEdges, RemovedEdges = removedEdges }; MapChanged.Invoke(this, mapChangedArgs); }
public ImageSegment AddSegment(ImageSegment segNew) { ImageSegment seg; if (!TryFindSegment(segNew.Address, out seg)) { EnsureSegmentSize(segNew); segments.Add(segNew.Address, segNew); AddItem(segNew.Address, new ImageMapItem(segNew.Size) { DataType = new UnknownType() }); MapChanged.Fire(this); Debug.Print("== New segment {0}", segNew.Name); DumpSections(); return(segNew); } long delta = segNew.Address - seg.Address; Debug.Assert(delta >= 0); if (delta > 0) { // Need to split the segment. //$REVIEW: or do we? x86 segments can overlap. var segSplit = new ImageSegment(segNew.Name, segNew.Address, segNew.MemoryArea, segNew.Access); segSplit.Size = (uint)(seg.Size - delta); seg.Size = (uint)delta; segments.Add(segNew.Address, segSplit); // And split any items in the segment AddItem(segSplit.Address, new ImageMapItem()); MapChanged.Fire(this); Debug.Print("== Split segment into {0} and {1}", seg.Name, segSplit.Name); DumpSections(); return(segSplit); } return(seg); }
public void RemoveItem(Address addr) { ImageMapItem item; if (!TryFindItemExact(addr, out item)) { return; } item.DataType = new UnknownType(); ImageMapItem mergedItem = item; // Merge with previous item ImageMapItem prevItem; if (Items.TryGetLowerBound((addr - 1), out prevItem) && prevItem.DataType is UnknownType && prevItem.EndAddress.Equals(item.Address)) { mergedItem = prevItem; mergedItem.Size = (uint)(item.EndAddress - mergedItem.Address); Items.Remove(item.Address); } // Merge with next item ImageMapItem nextItem; if (Items.TryGetUpperBound((addr + 1), out nextItem) && nextItem.DataType is UnknownType && mergedItem.EndAddress.Equals(nextItem.Address)) { mergedItem.Size = (uint)(nextItem.EndAddress - mergedItem.Address); Items.Remove(nextItem.Address); } MapChanged.Fire(this); }
public void Move(string name) { var map = Maps.FirstOrDefault(m => m.gameObject.name == name); if (map == null) { throw new ArgumentException($"{name} というマップが見つかりませんでした."); } if (currentMapObject) { Destroy(currentMapObject); } currentMapObject = Instantiate(map.gameObject) as GameObject; CurrentMap = map; var tmaps = map.gameObject.GetComponentsInChildren <Tilemap>(); var cs = map.gameObject.GetComponent <Grid>().cellSize; var rect = Rect.zero; foreach (var tmap in tmaps) { tmap.CompressBounds(); var b = tmap.cellBounds; float x = cs.x, y = cs.y; var r = Rect.MinMaxRect(b.xMin * x, b.yMin * y, b.xMax * x, b.yMax * y); // 取得したものが大きければその分広げる rect.xMin = r.xMin < rect.xMin ? r.xMin : rect.xMin; rect.yMin = r.yMin < rect.yMin ? r.yMin : rect.yMin; rect.xMax = rect.xMax < r.xMax ? r.xMax : rect.xMax; rect.yMax = rect.yMax < r.yMax ? r.yMax : rect.yMax; } CurrentMapSize = rect; GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>().backgroundColor = map.BackColor; MapChanged?.Invoke(map); }
private static void OnBigFuckingPacket(Packet p)//0xBF { switch (p.ReadUShort()) { case 6: //party switch (p.ReadByte()) { case 1: { byte count = p.ReadByte(); for (int i = 0; i < 10; i++) { party[i] = i < count?p.ReadUInt() : 0; } } break; case 2: { byte count = p.ReadByte(); p.Skip(4); for (int i = 0; i < 10; i++) { party[i] = i < count?p.ReadUInt() : 0; } } break; } break; case 8: //map change Map = (Map)p.ReadByte(); MapChanged.Raise(); break; } }
public void NewGameIteration(object sender, KeyPressedArgs args) { switch (args.GameChange) { case KeyPressedArgs.GameChangeEnum.NewPosition: { Actions[args.Key].React(_gameMap, _player); break; } case KeyPressedArgs.GameChangeEnum.Cancel: { return; } default: { Console.WriteLine("Wrong key, result ignored. Remind: Q to exit, arrows to move."); return; } } MapChanged?.Invoke(this, new GameMapChangedArgs(_gameMap, _player)); GameContinues?.Invoke(this, EventArgs.Empty); }
private void RaiseMapChanged(CollectionChange change, K key) { MapChanged?.Invoke(this, new ObservableDictionaryChangedEventArgs(change, key)); }
private void OnMapChanged(ValueEventArgs <int> e) => MapChanged?.Invoke(this, e);
/// <summary> /// Raising a map changed event. /// </summary> /// <param name="n"></param> private void OnMapChanged(int n) => MapChanged?.Invoke(this, new MapChangedEventArgs(n));