public DGRPImg(GraphicsDevice Device, Iff Parent, FileReader Reader, uint Version)
{
m_Graphics = Device;
m_SBatch = new SpriteBatch(m_Graphics);
if (Version == 20000 || Version == 20001)
{
SpriteCount = Reader.ReadUShort();
Direction = (DirectionFlags)Reader.ReadByte();
ZoomLevel = Reader.ReadByte();
for (int i = 0; i < SpriteCount; i++)
{
SpriteInfo Info = new SpriteInfo(Reader, this, Version);
m_Sprites.Add(new DrawGroupSprite(Device, Info,
Parent.GetSprite((ushort)Info.SPRChunkID).GetFrame(Info.SPRFrameNum)));
}
}
else
{
Direction = (DirectionFlags)Reader.ReadUInt32();
ZoomLevel = Reader.ReadUInt32();
SpriteCount = Reader.ReadUInt32();
for (int i = 0; i < SpriteCount; i++)
{
SpriteInfo Info = new SpriteInfo(Reader, this, Version);
m_Sprites.Add(new DrawGroupSprite(Device, Info,
Parent.GetSprite((ushort)Info.SPRChunkID).GetFrame(Info.SPRFrameNum)));
}
}
}
public void Set(DirectionFlags dir, Type type)
{
dirs |= dir;
switch (dir)
{
case DirectionFlags.W: edgeW = type; break;
case DirectionFlags.SW: edgeSW = type; break;
case DirectionFlags.S: edgeS = type; break;
case DirectionFlags.SE: edgeSE = type; break;
case DirectionFlags.E: edgeE = type; break;
case DirectionFlags.NE: edgeNE = type; break;
case DirectionFlags.N: edgeN = type; break;
case DirectionFlags.NW: edgeNW = type; break;
case DirectionFlags.None:
case DirectionFlags.All:
default: Debug.LogWarning("Warning Called Set on GameVertex.Line with a dir not set to a single direction"); break;
}
}
internal virtual void cheat(Game_Unit unit, DirectionFlags dir)
{
if (Cheat != null)
{
if (Cheat(unit, dir))
{
Global.game_system.play_se(System_Sounds.Menu_Move2);
}
}
}
/// <summary>
/// Constructor. Used for platform symbol files.
/// </summary>
/// <param name="loadOrdinal">Indicates the order in which the defining platform
/// symbol file was loaded. Higher numbers indicate later loading, which translates
/// to higher priority.</param>
/// <param name="fileIdent">Platform symbol file identifier, for the Info panel.</param>
public DefSymbol(string label, int value, Source source, Type type,
FormatDescriptor.SubType formatSubType, int width, bool widthSpecified,
string comment, DirectionFlags direction, MultiAddressMask multiMask, string tag,
int loadOrdinal, string fileIdent)
: this(label, value, source, type, formatSubType, width, widthSpecified,
comment, direction, multiMask, tag)
{
LoadOrdinal = loadOrdinal;
FileIdentifier = fileIdent;
}
private static uint IOCreate(DirectionFlags dir, int number, int length)
{
long v =
((byte)dir << 30) |
((byte)'E' << 8) |
(number << 0) |
(length << 16);
return((uint)v);
}
/// <summary>
/// Create a DefSymbol given a Symbol, FormatDescriptor, and a few other things. Used
/// for deserialization.
/// </summary>
/// <param name="sym">Base symbol.</param>
/// <param name="dfd">Format descriptor.</param>
/// <param name="widthSpecified">Set if a width was explicitly specified.</param>
/// <param name="comment">End-of-line comment.</param>
/// <param name="direction">I/O direction.</param>
/// <param name="multiMask">Bit mask to apply before comparisons.</param>
public static DefSymbol Create(Symbol sym, FormatDescriptor dfd, bool widthSpecified,
string comment, DirectionFlags direction, MultiAddressMask multiMask)
{
int width = dfd.Length;
if (widthSpecified && sym.SymbolType == Type.Constant &&
sym.SymbolSource != Source.Variable)
{
// non-variable constants don't have a width; override arg
Debug.WriteLine("Overriding constant DefSymbol width");
widthSpecified = false;
}
Debug.Assert(dfd.FormatType == FormatDescriptor.Type.NumericLE);
return(new DefSymbol(sym.Label, sym.Value, sym.SymbolSource, sym.SymbolType,
dfd.FormatSubType, width, widthSpecified, comment, direction, multiMask, string.Empty));
}
public static DirectionFlags GetFlagsTowardsRegion(int x, int z, int regionStartX, int regionEndX, int regionStartZ, int regionEndZ)
{
DirectionFlags directionX;
DirectionFlags directionZ;
if (x < regionStartX)
{
directionX = DirectionFlags.East | DirectionFlags.NorthEast | DirectionFlags.SouthEast;
}
else if (x >= regionEndX)
{
directionX = DirectionFlags.West | DirectionFlags.NorthWest | DirectionFlags.SouthWest;
}
else
{
directionX = DirectionFlags.All; // don't really care
}
DirectionFlags directionXMask = directionX | (DirectionFlags.North | DirectionFlags.South);
if (z < regionStartZ)
{
directionZ = DirectionFlags.North | DirectionFlags.NorthEast | DirectionFlags.NorthWest;
}
else if (z >= regionEndZ)
{
directionZ = DirectionFlags.South | DirectionFlags.SouthEast | DirectionFlags.SouthWest;
}
else
{
directionZ = DirectionFlags.All; // don't really care
}
DirectionFlags directionZMask = directionZ | (DirectionFlags.East | DirectionFlags.West);
var result = (directionX & directionZMask) | (directionZ & directionXMask);
return(result);
}
/// <summary>
/// Constructor. General form.
/// </summary>
/// <param name="label">Symbol's label.</param>
/// <param name="value">Symbol's value.</param>
/// <param name="source">Symbol source (general point of origin).</param>
/// <param name="type">Symbol type.</param>
/// <param name="formatSubType">Format descriptor sub-type, so we know how the
/// user wants the value to be displayed.</param>
/// <param name="width">Variable width.</param>
/// <param name="widthSpecified">True if width was explicitly specified. If this is
/// <param name="comment">End-of-line comment.</param>
/// <param name="direction">I/O direction.</param>
/// <param name="multiMask">Bit mask to apply before comparisons.</param>
/// <param name="tag">Symbol tag, used for grouping platform symbols.</param>
/// false, the value of the "width" argument is ignored.</param>
public DefSymbol(string label, int value, Source source, Type type,
LabelAnnotation labelAnno, FormatDescriptor.SubType formatSubType,
int width, bool widthSpecified, string comment,
DirectionFlags direction, MultiAddressMask multiMask, string tag)
: this(label, value, source, type, labelAnno)
{
Debug.Assert(comment != null);
Debug.Assert(tag != null);
if (widthSpecified && type == Type.Constant && source != Source.Variable)
{
// non-variable constants don't have a width; override arg
Debug.WriteLine("Overriding constant DefSymbol width");
widthSpecified = false;
}
HasWidth = widthSpecified;
if (!widthSpecified)
{
width = DEFAULT_WIDTH;
}
Debug.Assert(width >= MIN_WIDTH && width <= MAX_WIDTH);
DataDescriptor = FormatDescriptor.Create(width,
FormatDescriptor.Type.NumericLE, formatSubType);
Comment = comment;
Debug.Assert(((int)direction & ~(int)DirectionFlags.ReadWrite) == 0);
Direction = direction;
// constants don't have masks
if (type != Type.Constant)
{
MultiMask = multiMask;
}
Tag = tag;
}
public override DirectionFlags dir_triggered()
{
DirectionFlags dir = DirectionFlags.None;
if (repeated(Inputs.Down))
{
dir |= DirectionFlags.Down;
}
else if (repeated(Inputs.Up))
{
dir |= DirectionFlags.Up;
}
if (repeated(Inputs.Left))
{
dir |= DirectionFlags.Left;
}
else if (repeated(Inputs.Right))
{
dir |= DirectionFlags.Right;
}
return(dir);
}
static uint IOCreate(DirectionFlags dir, int number, int length)
{
long v =
((byte)dir << 30) |
((byte)'E' << 8) |
(number << 0) |
(length << 16);
return (uint)v;
}
public static int UnsetDirectionFlag(int startValue, DirectionFlags directionFlag)
{
return(startValue ^ ~((int)directionFlag));
}
public static int SetDirectionFlag(int startValue, DirectionFlags directionFlag)
{
return(startValue | (int)directionFlag);
}
public static bool HasDirectionFlag(int testValue, DirectionFlags directionFlag)
{
return((testValue & (int)directionFlag) > 0);
}
public Stack <Vector2Int> FindPath()
{
NodeInfo curNode = new NodeInfo();
NodeInfo[] nextNodes = new NodeInfo[(int)DirectionFlags.COUNT];
List <NodeInfo> .Enumerator enumerator;
curNode.NodeId = m_startPoint;
m_closeNodeList.Add(curNode);
while (curNode.NodeId != m_endPoint && !(curNode.NodeId != m_startPoint && m_openNodeList.Count == 0))
{
for (DirectionFlags e = DirectionFlags.RIGHT; e < DirectionFlags.COUNT; e++)
{
nextNodes[(int)e] = new NodeInfo();
nextNodes[(int)e].ParentId = curNode.NodeId;
switch (e)
{
case DirectionFlags.RIGHT:
nextNodes[(int)DirectionFlags.RIGHT].NodeId = new Vector2Int(curNode.NodeId.x + 1, curNode.NodeId.y);
break;
case DirectionFlags.LEFT:
nextNodes[(int)DirectionFlags.LEFT].NodeId = new Vector2Int(curNode.NodeId.x - 1, curNode.NodeId.y);
break;
case DirectionFlags.DOWN:
nextNodes[(int)DirectionFlags.DOWN].NodeId = new Vector2Int(curNode.NodeId.x, curNode.NodeId.y - 1);
break;
case DirectionFlags.UP:
nextNodes[(int)DirectionFlags.UP].NodeId = new Vector2Int(curNode.NodeId.x, curNode.NodeId.y + 1);
break;
}
enumerator = m_closeNodeList.GetEnumerator();
bool isDuplicated = false;
while (enumerator.MoveNext())
{
if (enumerator.Current.NodeId == nextNodes[(int)e].NodeId)
{
isDuplicated = true;
break;
}
}
if (isDuplicated)
{
continue;
}
if (m_wayPointManager.GetWayPoint(nextNodes[(int)e].NodeId) != null)
{
nextNodes[(int)e].ScoreG += curNode.ScoreG + 1;
nextNodes[(int)e].ScoreH = Vector2.Distance(curNode.NodeId, m_endPoint);
enumerator = m_openNodeList.GetEnumerator();
bool isExist = false;
while (enumerator.MoveNext())
{
NodeInfo openNode = enumerator.Current;
if (openNode.NodeId == nextNodes[(int)e].NodeId &&
openNode.ScoreF > nextNodes[(int)e].ScoreF)
{
openNode.ScoreG = nextNodes[(int)e].ScoreG;
openNode.ScoreH = nextNodes[(int)e].ScoreH;
openNode.ParentId = nextNodes[(int)e].ParentId;
isExist = true;
break;
}
}
if (!isExist)
{
m_openNodeList.Add(nextNodes[(int)e]);
}
}
else
{
continue;
}
}//for
enumerator = m_openNodeList.GetEnumerator();
enumerator.MoveNext();
curNode = enumerator.Current;
while (enumerator.MoveNext())
{
NodeInfo nextNode = enumerator.Current;
if (curNode.ScoreF > nextNode.ScoreF)
{
curNode = nextNode;
}
}
m_openNodeList.Remove(curNode);
m_closeNodeList.Add(curNode);
}
NodeInfo[] closeNodes = m_closeNodeList.ToArray();
Stack <Vector2Int> pathStack = new Stack <Vector2Int>();
pathStack.Push(closeNodes[closeNodes.Length - 1].NodeId);
pathStack.Push(closeNodes[closeNodes.Length - 1].ParentId);
for (int i = closeNodes.Length - 2; i > 0; i--)
{
if (closeNodes[i].NodeId == pathStack.Peek())
{
pathStack.Push(closeNodes[i].ParentId);
}
}
return(pathStack);
}
public static bool AnySouth(this DirectionFlags f)
{
return((f & (DirectionFlags.South | DirectionFlags.SouthEast | DirectionFlags.SouthWest)) != 0);
}
protected void update_input()
{
bool not_minimap_centered = false;
// Mouse controls
if (Input.IsControllingOnscreenMouse &&
(Global.game_map.scrolling || Global.Input.mouseMoved))
{
Vector2 target_loc = mouse_loc;
if (should_move_to_direct_input_loc(ref target_loc))
{
//Global.game_system.play_se(System_Sounds.Cursor_Move); //Debug
if (Global.game_temp.minimap_call)
{
if (Loc != center_cursor_loc(false))
{
not_minimap_centered = true;
}
}
Instant_Movement = true;
Loc = target_loc; //new Vector2((int)target_loc.X, (int)target_loc.Y); //already made made int values //Debug
((Scene_Map)Global.scene).update_info_image(true);
if (not_minimap_centered)
{
center_cursor();
}
}
return;
}
// Touch controls
else if (Input.ControlScheme == ControlSchemes.Touch)
{
bool not_manual_target_window = Global.game_state.is_menuing &&
((Scene_Map)Global.scene).target_window_up &&
!((Scene_Map)Global.scene).manual_targeting;
if (!not_manual_target_window &&
Global.Input.touch_triggered() &&
Global.game_map.screen_loc_in_view(
Global.Input.touchPressPosition))
{
Vector2 target_loc = touch_loc;
if (should_move_to_direct_input_loc(ref target_loc))
{
Instant_Movement = true;
Loc = target_loc; //new Vector2((int)target_loc.X, (int)target_loc.Y); //already made made int values //Debug
((Scene_Map)Global.scene).update_info_image(true);
}
}
if (Global.Input.gesture_triggered(TouchGestures.FreeDrag))
{
Global.game_map.scroll_vel(
-Global.Input.freeDragVector / TILE_SIZE);
}
return;
}
// Button controls
if (ScrollingMovementBlocked && !Global.game_map.scrolling)
{
ScrollingMovementBlocked = false;
}
DirectionFlags dir8 = Input.direction_to_flag(Global.Input.dir8());
if (dir8 == DirectionFlags.None)
{
LockedInputs = DirectionFlags.None;
}
// If moving normally
if (!Global.game_temp.minimap_call && !speed_up_input())
{
dir8 = Global.Input.dir_triggered();
}
if (LockedInputs != DirectionFlags.None)
{
if (dir8 == LockedInputs)
{
dir8 = DirectionFlags.None;
}
}
if ((dir8 != DirectionFlags.None || !is_on_square) && Global.game_temp.minimap_call)
{
if (Loc != center_cursor_loc(false))
{
not_minimap_centered = true;
}
}
bool moved = false;
switch (dir8)
{
case DirectionFlags.DownLeft:
moved = move_down_left();
break;
case DirectionFlags.Down:
moved = move_down();
break;
case DirectionFlags.DownRight:
moved = move_down_right();
break;
case DirectionFlags.Left:
moved = move_left();
break;
case DirectionFlags.Right:
moved = move_right();
break;
case DirectionFlags.UpLeft:
moved = move_up_left();
break;
case DirectionFlags.Up:
moved = move_up();
break;
case DirectionFlags.UpRight:
moved = move_up_right();
break;
}
if (moved)
{
start_movement();
}
if (Global.game_temp.minimap_call && (dir8 != 0 || !is_on_square))
{
if (not_minimap_centered)
{
center_cursor();
}
}
}
protected void range_edge_check()
{
if (Global.game_temp.menuing)
{
return;
}
int selected_unit_id = Global.game_system.Selected_Unit_Id;
if (selected_unit_id == -1)
{
return;
}
//@Debug
//if (!Global.game_map.active_team.Contains(selected_unit_id))
// return; //Multi
Vector2 test_vector = Vector2.Zero;
Directions dir = Global.Input.dir8();
switch (dir)
{
// Down left
case Directions.DownLeft:
test_vector = new Vector2(is_left_edge() ? 0 : -1, is_bottom_edge() ? 0 : 1);
break;
// Down
case Directions.Down:
test_vector = new Vector2(0, 1);
break;
// Down right
case Directions.DownRight:
test_vector = new Vector2(is_right_edge() ? 0 : 1, is_bottom_edge() ? 0 : 1);
break;
// Left
case Directions.Left:
test_vector = new Vector2(-1, 0);
break;
// Right
case Directions.Right:
test_vector = new Vector2(1, 0);
break;
// Up left
case Directions.UpLeft:
test_vector = new Vector2(is_left_edge() ? 0 : -1, is_on_top() ? 0 : -1);
break;
// Up
case Directions.Up:
test_vector = new Vector2(0, -1);
break;
// Up right
case Directions.UpRight:
test_vector = new Vector2(is_right_edge() ? 0 : 1, is_top_edge() ? 0 : -1);
break;
}
if (!Global.game_map.move_range.Contains(Loc + test_vector) &&
Global.game_map.move_range.Contains(Loc))
{
LockedInputs = Input.direction_to_flag(dir);
}
}
protected override void UpdateMenu(bool active)
{
update_map_sprite();
update_direction();
// Black Screen
update_black_screen();
// Inputs
bool input = active && Delay == 0 && !Closing && Black_Screen_Timer <= 0;
#if DEBUG
if (Help_Window != null && input && Global.Input.pressed(Inputs.X))
{
DirectionFlags dir = Global.Input.dir_triggered();
if (dir != DirectionFlags.None)
{
StatusNodes[page].ActiveNode.cheat(this.unit, dir);
move_to(Help_Index);
Help_Window.add_remaining_text();
foreach (var status_page in Pages)
{
status_page.refresh(this.unit);
}
foreach (StatusUINode node in TopPanelNodes)
{
node.refresh(unit);
}
}
input = false;
}
#endif
// Cancel button
CancelButton.Update(input);
StatusNodes[page].Update(!input ? ControlSet.None :
(Help_Window != null ?
ControlSet.Movement : (ControlSet.Mouse | ControlSet.Touch)));
if (input)
{
if (Help_Window == null)
{
update_input();
var help_index = StatusNodes[page].consume_triggered(
MouseButtons.Left, TouchGestures.Tap);
if (help_index.IsNothing)
{
help_index = StatusNodes[page].consume_triggered(
TouchGestures.LongPress);
}
if (help_index.IsSomething)
{
Help_Index = StatusNodes[page][help_index].HelpLabel;
open_help();
}
}
else
{
if (StatusNodes[page].ActiveNode.HelpLabel != Help_Index)
{
move_to(StatusNodes[page].ActiveNode.HelpLabel);
}
var help_index = StatusNodes[page].consume_triggered(
MouseButtons.Left, TouchGestures.Tap);
var help_cancel_index = StatusNodes[page].consume_triggered(
TouchGestures.LongPress);
if (Global.Input.triggered(Inputs.B) ||
Global.Input.triggered(Inputs.R) ||
Global.Input.mouse_click(MouseButtons.Right) ||
help_cancel_index.IsSomething ||
CancelButton.consume_trigger(MouseButtons.Left) ||
CancelButton.consume_trigger(TouchGestures.Tap))
{
close_help();
}
/* //Debug
* if (Global.Input.repeated(Inputs.Down))
* {
* if (move(2))
* {
*
* }
* }
* if (Global.Input.repeated(Inputs.Up))
* {
* if (move(8))
* {
*
* }
* }
* if (Global.Input.repeated(Inputs.Right))
* {
* if (move(6))
* {
*
* }
* }
* if (Global.Input.repeated(Inputs.Left))
* {
* if (move(4))
* {
*
* }
* }
* else if (Global.Input.triggered(Inputs.R) || Global.Input.triggered(Inputs.B))
* {
* close_help();
* }*/
}
StatusCursors[page].update();
}
if (Help_Window != null)
{
Help_Window.update();
}
Background.update();
// Top Panel
Top_Panel.update();
foreach (TextSprite label in Battle_Stat_Labels)
{
label.update();
}
// Pages
foreach (Status_Page status_page in Pages)
{
status_page.update();
}
Left_Page_Arrow.update();
Right_Page_Arrow.update();
}
// Granulometry on binary images
public static Numa pixRunHistogramMorph(this Pix pixs, RunlengthFlagsForGranulometry runtype, DirectionFlags direction, int maxsize)
{
if (null == pixs)
{
throw new ArgumentNullException("pixs cannot be null.");
}
var pointer = Native.DllImports.pixRunHistogramMorph((HandleRef)pixs, (int)runtype, (int)direction, maxsize);
if (IntPtr.Zero == pointer)
{
return(null);
}
else
{
return(new Numa(pointer));
}
}
public DirectionFlags AllToOne(DirectionFlags mask)
{
return(dirs & mask);
}
public static bool AnyWest(this DirectionFlags f)
{
return((f & (DirectionFlags.West | DirectionFlags.NorthWest | DirectionFlags.SouthWest)) != 0);
}
