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));
