public void SelectItem()
{
var menu = new SelectionMenu();
menu.AddItem(new SelectionMenuItem(string.Empty, "[None]", () =>
{
ReferenceItem.SetInput(null);
}));
menu.ConvertAndAdd(ReferenceItem.GetAllowed().OfType <IItem>(), _ =>
{
var item = _ as IValueItem;
if (item == null)
{
return;
}
if (IsInput)
{
ReferenceItem.SetInput(item);
}
else
{
ReferenceItem.SetOutput(item);
}
});
InvertApplication.SignalEvent <IShowSelectionMenu>(_ => _.ShowSelectionMenu(menu));
//InvertGraphEditor.WindowManager.InitItemWindow(ReferenceItem.GetAllowed().ToArray(), _ =>
//{
// InvertApplication.Execute(new LambdaCommand("Set Item", () =>
// {
// }));
//});
}
// Use this for initialization
void Start()
{
mMapNames.Add("Maps/map_one");
mMapNames.Add("Maps/map_two");
mMapNames.Add("Maps/map_three");
mSelectionMenu = new SelectionMenu();
mGameplayState = new GameplayState();
SetupWorld();
SetupPlayerSpawns();
mSpawningPlayers = false;
mGameplay = true;
WHATEVER = GameObject.FindGameObjectWithTag("MenuScene");
MenuHandler mh = WHATEVER.GetComponent <MenuHandler>();
mGameplayState.Start(mh.mTankNames, mSpawnPositions);
Destroy(WHATEVER);
GameObject musicGO = (GameObject)Instantiate(Resources.Load("gameplay_music"));
mAudioSources = musicGO.GetComponents <AudioSource>();
song = Random.Range(0, 3);
mAudioSources[song].Play();
}
public void Show(DiagramViewModel diagramViewModel, ConnectorViewModel startConnector, Vector2 position)
{
var selectionMenu = new SelectionMenu();
Signal <IQueryPossibleConnections>(_ => _.QueryPossibleConnections(selectionMenu, diagramViewModel, startConnector, position));
Signal((IShowSelectionMenu _) => _.ShowSelectionMenu(selectionMenu, position));
}
private void OnValidate()
{
if (Menu == this)
{
Menu = null;
Debug.LogError("Menu cannot be set to itself!", this);
}
}
internal void SetSize(float width, float height, string btn = " ")
{
if (btn.Equals("right"))
{
if (width > -1)
{
if (SelectionMenu.GetType().Equals(typeof(GroupShapeImpl)))
{
((GroupShape)SelectionMenu).GroupReSizeWidth(width);
}
else
{
SelectionMenu.Width = width;
}
}
if (height > -1)
{
if (SelectionMenu.GetType().Equals(typeof(GroupShapeImpl)))
{
((GroupShape)SelectionMenu).GroupReSizeHeight(height);
}
else
{
SelectionMenu.Height = height;
}
}
}
else
{
foreach (var item in Selection)
{
if (width > -1)
{
if (item.GetType().Equals(typeof(GroupShapeImpl)))
{
((GroupShape)item).GroupReSizeWidth(width);
}
else
{
item.Width = width;
}
}
if (height > -1)
{
if (item.GetType().Equals(typeof(GroupShapeImpl)))
{
((GroupShape)item).GroupReSizeHeight(height);
}
else
{
item.Height = height;
}
}
}
}
}
public void ShowSelectionMenu(SelectionMenu menu, Vector2?position = null, bool useWindow = false)
{
HideSelection();
TreeModel = ConstructViewModel(menu);
SearchCriteria = null;
EnableContent = true;
RequestPosition = position;
_focusNeeded = true;
}
protected TreeViewModel ConstructViewModel(SelectionMenu items)
{
var result = new TreeViewModel
{
Data = items.Items,
Submit = SelectItem
};
return(result);
}
static void Main(string[] args)
{
SelectionMenu homeMenu = new SelectionMenu(new List <IElement>()
{
new ElementImportDb(),
new ElementListStations(),
new ElementBestHolidayPlace(),
new ElementExit()
});
homeMenu.Show();
}
//
//
//
void Button5Click(object sender, EventArgs e)
{
/*
* opens the testing menu, user selects test items from this menu
*/
database = "adm_test";
Hide();
SelectionMenu select = new SelectionMenu();
select.ShowDialog();
Show();
}
public void Execute(SelectTypeCommand command)
{
var menu = new SelectionMenu();
if (command.AllowNoneType)
{
menu.AddItem(new SelectionMenuItem("", "None", () =>
{
command.Item.RelatedType = null;
}));
}
// var types = GetRelatedTypes(command).ToArray();
foreach (var item in GetRelatedTypes(command))
{
var type1 = item;
if (command.Filter == null || command.Filter(item))
{
menu.AddItem(new SelectionMenuItem(item.Group, TypedItemViewModel.TypeAlias(item.TypeName), () =>
{
var record = type1 as IDataRecord;
if (record != null)
{
command.Item.RelatedType = record.Identifier;
}
else
{
// TODO: Change RelatedType from FullName to TypeName, not sure if there is any bug
command.Item.RelatedType = type1.TypeName;//type1.FullName;
}
if (command.OnSelectionFinished != null)
{
command.OnSelectionFinished();
}
}));
}
}
if (!command.AllowNoneType)
{
menu.OnCancel = () => {
if (String.IsNullOrEmpty(command.Item.RelatedType))
{
command.Item.Node.Repository.Remove(command.Item);
}
};
}
Signal <IShowSelectionMenu>(_ => _.ShowSelectionMenu(menu));
}
public void QueryPossibleConnections(SelectionMenu menu, DiagramViewModel diagramViewModel, ConnectorViewModel startConnector, Vector2 mousePosition)
{
if (startConnector.ConnectorForType == typeof(ElementNode))
{
menu.Items.Clear();
var vm = InvertGraphEditor.CurrentDiagramViewModel;
var category = new SelectionMenuCategory()
{
Title = "Connect"
};
menu.AddItem(category);
menu.AddItem(new SelectionMenuItem("Connect", "Create View Node and Connect to : Element", () =>
{
ViewNode viewNode = new ViewNode();
viewNode.Name = String.Format("{0}View", vm.Title);
vm.AddNode(viewNode, vm.LastMouseEvent.LastMousePosition);
diagramViewModel.GraphData.AddConnection(startConnector.ConnectorFor.DataObject as IConnectable, viewNode.ElementInputSlot);
}), category);
ElementNode elementNode = (ElementNode)startConnector.ConnectorFor.InputConnector.DataObject;
if (elementNode.BaseNode != null)
{
ViewNode firstBaseViewNode =
diagramViewModel.GraphData.Repository.All <ViewNode>()
.FirstOrDefault(graphViewNode =>
{
return(graphViewNode.Element == elementNode.BaseNode);
});
if (firstBaseViewNode != null)
{
menu.AddItem(new SelectionMenuItem("Connect", "Create Inherited View Node and Connect to : Element", () =>
{
ViewNode viewNode = new ViewNode();
viewNode.Name = String.Format("{0}View", vm.Title);
vm.AddNode(viewNode, vm.LastMouseEvent.LastMousePosition);
diagramViewModel.GraphData.AddConnection(startConnector.ConnectorFor.DataObject as IConnectable, viewNode.ElementInputSlot);
diagramViewModel.GraphData.AddConnection(firstBaseViewNode, viewNode);
IFilterItem viewNodeFilterItem = diagramViewModel.GraphData.CurrentFilter.FilterItems.First(item => item.Node == viewNode);
diagramViewModel.GraphData.CurrentFilter.ShowInFilter(firstBaseViewNode, viewNodeFilterItem.Position - new Vector2(250, 0));
}), category);
}
}
}
}
/// <summary>
/// Writes a selection menu which allows the user to select an item by using the up- and down-arrow keys and to accept the selection by pressing Enter.
/// </summary>
/// <param name="menuItems">The items to be available for selection.</param>
/// <returns>Returns the index of the selected item.</returns>
/// <example>
/// Console.WriteLine($"How old are you?");
/// var items = new string[5] { "0-20", "21-40", "41-60", "61-80", "81+" };
/// var selectedIndex = ConsoleUtilities.WriteSelectionMenu(items);
/// Console.WriteLine($"You have selected: {items[selectedIndex]}".);
/// </example>
public static int WriteSelectionMenu(string[] menuItems)
{
if (menuItems == null)
{
throw new ArgumentNullException(nameof(menuItems));
}
if (menuItems.Length == 0)
{
throw new ArgumentException($"{nameof(menuItems)} cannot be empty");
}
var menu = new SelectionMenu(menuItems);
var selectedIndex = menu.AwaitSelection();
return(selectedIndex);
}
public void Execute(ChangeHandlerEventCommand command)
{
var selectionMenu = new SelectionMenu();
foreach (var item in uFrameECS.Events)
{
var item1 = item;
selectionMenu.AddItem(new SelectionMenuItem(item.Value, () =>
{
command.Node.MetaType = item1.Value.FullName;
}));
}
Signal <IShowSelectionMenu>(_ => _.ShowSelectionMenu(selectionMenu));
}
internal void SetOpacity(int opacity, string btn = " ")
{
if (btn.Equals("right"))
{
SelectionMenu.GroupOpacity(opacity);
SelectionMenu.Opacity = opacity;
}
else
{
foreach (var item in Selection)
{
item.GroupOpacity(opacity);
item.Opacity = opacity;
}
}
}
internal void SetBorderWidth(float borderWidth, string btn = " ")
{
if (btn.Equals("right"))
{
SelectionMenu.GroupBorderWidth(borderWidth);
SelectionMenu.BorderWidth = borderWidth;
}
else
{
foreach (var item in Selection)
{
item.GroupBorderWidth(borderWidth);
item.BorderWidth = borderWidth;
}
}
}
public void Rotate(float angle, string btn = " ")
{
if (btn.Equals("right"))
{
SelectionMenu.GroupRotate(angle);
SelectionMenu.Angle = angle;
}
else
{
if (Selection.Count != 0)
{
foreach (var item in Selection)
{
item.GroupRotate(angle);
item.Angle = angle;
}
}
}
}
public void Execute(SelectTypeCommand command)
{
var menu = new SelectionMenu();
if (command.AllowNone)
{
menu.AddItem(new SelectionMenuItem("", "None", () =>
{
command.Item.RelatedType = null;
}));
}
// var types = GetRelatedTypes(command).ToArray();
foreach (var item in GetRelatedTypes(command))
{
var type1 = item;
if (command.Filter == null || command.Filter(item))
{
menu.AddItem(new SelectionMenuItem(item, () =>
{
var record = type1 as IDataRecord;
if (record != null)
{
command.Item.RelatedType = record.Identifier;
}
else
{
// TODO: Change RelatedType from FullName to TypeName, not sure if there is any bug
command.Item.RelatedType = type1.TypeName;//type1.FullName;
}
if (command.OnSelectionFinished != null)
{
command.OnSelectionFinished();
}
}));
}
}
Signal <IShowSelectionMenu>(_ => _.ShowSelectionMenu(menu));
}
public void QueryPossibleConnections(SelectionMenu menu, DiagramViewModel diagramViewModel, ConnectorViewModel startConnector, Vector2 mousePosition)
{
if (startConnector.ConnectorForType.FullName == typeof(ElementNode).FullName)
{
menu.Items.Clear();
var vm = InvertGraphEditor.CurrentDiagramViewModel;
var category = new SelectionMenuCategory()
{
Title = "Connect"
};
menu.AddItem(category);
menu.AddItem(new SelectionMenuItem("Connect", "Create View Node and Connect to : Element", () =>
{
ViewNode viewNode = new ViewNode();
vm.AddNode(viewNode, vm.LastMouseEvent.LastMousePosition);
diagramViewModel.GraphData.AddConnection(startConnector.ConnectorFor.DataObject as IConnectable, viewNode.ElementInputSlot);
}), category);
}
}
//
void createToggle()
{
t = PrefabUtility.InstantiatePrefab(w.prefabs[0]) as GameObject;
// add name to new weapon
string ttt = toggleName;
t.name = ttt;
toggles.Add(t.name); // add new toggle to "Weapons" ScriptableObject.
//t = new
GameObject WeaponsPanel = GameObject.Find("WeaponsPanel");
t.transform.SetParent(WeaponsPanel.transform);
WeaponsPanel.GetComponent <MyToggleGroup>().toggles.Add(t.GetComponent <Toggle>());
int chc = t.transform.childCount;
Transform Chc = t.transform.GetChild(chc - 1);
Chc.GetComponent <Image>().sprite = ToggleWeaponImage;
Toggle tuggen = t.GetComponent <Toggle>();
SelectionMenu SelMenu = FindObjectOfType <SelectionMenu>();
UnityAction <string> action = new UnityAction <string>(SelMenu.SelectWeapon);
UnityEventTools.AddStringPersistentListener(tuggen.onValueChanged, action, WeaponToggleNumber);
PrefabUtility.DisconnectPrefabInstance(t);
}
public virtual void DrawInspector(Rect rect, PropertyFieldViewModel d, GUIStyle labelStyle)
{
var colorCache = GUI.color;
GUI.color = Color.white;
var labelArea = rect.LeftHalf();
var fieldArea = rect.RightHalf();
var labelWidtho = GUILayout.Width(140);
if (d.InspectorType == InspectorType.GraphItems)
{
var item = d.CachedValue as IGraphItem;
var text = "--Select--";
if (item != null)
{
text = item.Label;
}
if (GUI.Button(rect, d.Label + ": " + text, ElementDesignerStyles.ButtonStyle))
{
var type = d.Type;
var items = InvertGraphEditor.CurrentDiagramViewModel.CurrentRepository.AllOf <IGraphItem>().Where(p => type.IsAssignableFrom(p.GetType()));
var menu = new SelectionMenu();
menu.AddItem(new SelectionMenuItem(string.Empty, "[None]", () =>
{
InvertApplication.Execute(() =>
{
d.Setter(d.DataObject, null);
});
}));
foreach (var graphItem in items)
{
var graphItem1 = graphItem;
menu.AddItem(new SelectionMenuItem(graphItem1, () =>
{
InvertApplication.Execute(() =>
{
d.Setter(d.DataObject, graphItem1);
});
}));
}
InvertApplication.SignalEvent <IShowSelectionMenu>(_ => _.ShowSelectionMenu(menu));
}
SetTooltipForRect(rect, d.InspectorTip);
GUI.color = colorCache;
return;
}
if (d.Type == typeof(string))
{
if (d.InspectorType == InspectorType.TextArea)
{
labelArea = rect.WithHeight(17).InnerAlignWithUpperRight(rect);
fieldArea = rect.Below(labelArea).Clip(rect).PadSides(2);
EditorGUI.LabelField(labelArea, d.Name, labelStyle);
SetTooltipForRect(rect, d.InspectorTip);
EditorGUI.BeginChangeCheck();
d.CachedValue = EditorGUI.TextArea(fieldArea, (string)d.CachedValue, TextWrappingTextArea);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
if (Event.current.isKey && Event.current.keyCode == KeyCode.Return)
{
InvertApplication.Execute(() =>
{
});
}
}
else if (d.InspectorType == InspectorType.TypeSelection)
{
if (GUI.Button(rect, (string)d.CachedValue))
{
d.NodeViewModel.Select();
// TODO 2.0 Open Selection?
}
SetTooltipForRect(rect, d.InspectorTip);
}
else
{
EditorGUI.BeginChangeCheck();
EditorGUI.LabelField(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.TextField(fieldArea, (string)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
}
else
{
if (d.Type == typeof(int))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.IntField(fieldArea, (int)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(float))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.FloatField(fieldArea, (float)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector2))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.Vector2Field(fieldArea, string.Empty, (Vector2)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector3))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.Vector3Field(fieldArea, string.Empty, (Vector3)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Color))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.ColorField(fieldArea, (Color)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector4))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.Vector4Field(fieldArea, string.Empty, (Vector4)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(bool))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.Toggle(fieldArea, (bool)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (typeof(Enum).IsAssignableFrom(d.Type))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.EnumPopup(fieldArea, (Enum)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
InvertApplication.Execute(() =>
{
d.Setter(d.DataObject, d.CachedValue);
});
}
}
else if (d.Type == typeof(Type))
{
//InvertGraphEditor.WindowManager.InitTypeListWindow();
}
}
GUI.color = colorCache;
}
public virtual void DrawInspector(PropertyFieldViewModel d, GUIStyle labelStyle)
{
var labelWidth = 140;
var labelWidtho = GUILayout.ExpandWidth(true);
var colorCache = GUI.color;
GUI.color = Color.white;
if (d.InspectorType == InspectorType.GraphItems)
{
var item = d.CachedValue as IGraphItem;
var text = "--Select--";
if (item != null)
{
text = item.Label;
}
//GUILayout.BeginHorizontal();
if (GUILayout.Button(d.Label + ": " + text, ElementDesignerStyles.ButtonStyle))
{
var type = d.Type;
var items = InvertGraphEditor.CurrentDiagramViewModel.CurrentRepository.AllOf <IGraphItem>().Where(p => type.IsAssignableFrom(p.GetType()));
var menu = new SelectionMenu();
foreach (var graphItem in items)
{
var graphItem1 = graphItem;
menu.AddItem(new SelectionMenuItem(graphItem, () =>
{
InvertApplication.Execute(() =>
{
d.Setter(d.DataObject, graphItem1);
});
}));
}
InvertApplication.SignalEvent <IShowSelectionMenu>(_ => _.ShowSelectionMenu(menu));
//
// InvertGraphEditor.WindowManager.InitItemWindow(items,
//
// },true);
}
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
GUI.color = colorCache;
//GUILayout.EndHorizontal();
return;
}
if (d.Type == typeof(string))
{
if (d.InspectorType == InspectorType.TextArea)
{
EditorGUILayout.LabelField(d.Name, labelWidtho);
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
EditorGUI.BeginChangeCheck();
d.CachedValue = EditorGUILayout.TextArea((string)d.CachedValue, GUILayout.Height(50));
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
if (Event.current.isKey && Event.current.keyCode == KeyCode.Return)
{
InvertApplication.Execute(() =>
{
});
}
}
else if (d.InspectorType == InspectorType.TypeSelection)
{
GUILayout.BeginHorizontal();
//GUILayout.Label(d.ViewModel.Name);
if (GUILayout.Button((string)d.CachedValue))
{
d.NodeViewModel.Select();
// TODO 2.0 Open Selection?
}
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
GUILayout.EndHorizontal();
}
else
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle);
d.CachedValue = EditorGUILayout.TextField((string)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
}
else
{
if (d.Type == typeof(int))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.IntField((int)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(float))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.FloatField((float)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector2))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.Vector2Field(string.Empty, (Vector3)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector3))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.Vector3Field(string.Empty, (Vector3)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Color))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.ColorField((Color)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector4))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.Vector4Field(string.Empty, (Vector4)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(bool))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.Toggle((bool)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (typeof(Enum).IsAssignableFrom(d.Type))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.EnumPopup((Enum)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
InvertApplication.Execute(() =>
{
d.Setter(d.DataObject, d.CachedValue);
});
}
}
else if (d.Type == typeof(Type))
{
//InvertGraphEditor.WindowManager.InitTypeListWindow();
}
}
GUI.color = colorCache;
}
/// <summary>
/// Pushes a selection menu GameObject to selection stack
/// </summary>
/// <param name="menu"></param>
public void PushSelectionMenu(SelectionMenu menu)
{
Push(menu);
}
public void UpdateMenu(SelectionMenu menu)
{
GameObject activeSelector = null;
switch (menu)
{
case SelectionMenu.None:
mainSelectionMenu.SetActive(false);
characterSelectionMenu.SetActive(false);
inventorySelectionMenu.SetActive(false);
battleEndPanel.SetActive(false);
activeSelector = characterSelectionMenu;
break;
case SelectionMenu.Main:
mainSelectionMenu.SetActive(true);
characterSelectionMenu.SetActive(false);
inventorySelectionMenu.SetActive(false);
battleEndPanel.SetActive(false);
activeSelector = mainSelectionMenu;
menuHistory = new List <SelectionMenu>();
historyIndex = 0;
if (!menuHistory.Contains(SelectionMenu.Main))
{
menuHistory.Add(SelectionMenu.Main);
}
break;
case SelectionMenu.Character:
mainSelectionMenu.SetActive(false);
characterSelectionMenu.SetActive(true);
inventorySelectionMenu.SetActive(false);
battleEndPanel.SetActive(false);
activeSelector = characterSelectionMenu;
if (!menuHistory.Contains(SelectionMenu.Character))
{
menuHistory.Add(SelectionMenu.Character);
historyIndex++;
}
break;
case SelectionMenu.Inventory:
mainSelectionMenu.SetActive(false);
characterSelectionMenu.SetActive(false);
inventorySelectionMenu.SetActive(true);
battleEndPanel.SetActive(false);
activeSelector = inventorySelectionMenu;
if (!menuHistory.Contains(SelectionMenu.Inventory))
{
menuHistory.Add(SelectionMenu.Inventory);
historyIndex++;
}
break;
case SelectionMenu.End:
mainSelectionMenu.SetActive(false);
characterSelectionMenu.SetActive(false);
inventorySelectionMenu.SetActive(false);
battleEndPanel.SetActive(true);
break;
default:
print("Uh Oh!");
break;
}
selectionMenu = menu;
if (menu == SelectionMenu.Main)
{
InitSelectionMenuSelect(activeSelector.transform.Find("Selections"));
}
else if (menu == SelectionMenu.End)
{
currentSelectionParent = null;
}
else
{
currentSelectionParent = activeSelector.transform;
}
}
private void Awake()
{
Instance = this;
}
public BGSceneViewOverlayMenuSelection(BGSceneViewOverlay overlay, BGCurveEditorPointsSelection editorSelection)
: base(overlay, editorSelection)
{
menu = new SelectionMenu(overlay, editorSelection);
}
public virtual void DrawInspector(PropertyFieldViewModel d, GUIStyle labelStyle)
{
var labelWidth = 140;
var labelWidtho = GUILayout.ExpandWidth(true);
var colorCache = GUI.color;
GUI.color = Color.white;
if (d.InspectorType == InspectorType.GraphItems)
{
var item = d.CachedValue as IGraphItem;
var text = "--Select--";
if (item != null)
{
text = item.Label;
}
//GUILayout.BeginHorizontal();
if (GUILayout.Button(d.Label + ": " + text, ElementDesignerStyles.ButtonStyle))
{
var type = d.Type;
var items = InvertGraphEditor.CurrentDiagramViewModel.CurrentRepository.AllOf<IGraphItem>().Where(p => type.IsAssignableFrom(p.GetType()));
var menu = new SelectionMenu();
foreach (var graphItem in items)
{
var graphItem1 = graphItem;
menu.AddItem(new SelectionMenuItem(graphItem, () =>
{
InvertApplication.Execute(() =>
{
d.Setter(d.DataObject, graphItem1);
});
}));
}
InvertApplication.SignalEvent<IShowSelectionMenu>(_ => _.ShowSelectionMenu(menu));
//
// InvertGraphEditor.WindowManager.InitItemWindow(items,
//
// },true);
}
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
GUI.color = colorCache;
//GUILayout.EndHorizontal();
return;
}
if (d.Type == typeof(string))
{
if (d.InspectorType == InspectorType.TextArea)
{
EditorGUILayout.LabelField(d.Name, labelWidtho);
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
EditorGUI.BeginChangeCheck();
d.CachedValue = EditorGUILayout.TextArea((string)d.CachedValue, GUILayout.Height(50));
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
if (Event.current.isKey && Event.current.keyCode == KeyCode.Return)
{
InvertApplication.Execute(() =>
{
});
}
}
else if (d.InspectorType == InspectorType.TypeSelection)
{
GUILayout.BeginHorizontal();
//GUILayout.Label(d.ViewModel.Name);
if (GUILayout.Button((string)d.CachedValue))
{
d.NodeViewModel.Select();
// TODO 2.0 Open Selection?
}
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
GUILayout.EndHorizontal();
}
else
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle);
d.CachedValue = EditorGUILayout.TextField((string)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
}
else
{
if (d.Type == typeof(int))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.IntField((int)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(float))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.FloatField((float)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector2))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.Vector2Field(string.Empty, (Vector3)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector3))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.Vector3Field(string.Empty, (Vector3)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Color))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.ColorField((Color)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector4))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.Vector4Field(string.Empty, (Vector4)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(bool))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.Toggle((bool)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (typeof(Enum).IsAssignableFrom(d.Type))
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal();
GUILayout.Label(d.Name, labelStyle, labelWidtho);
d.CachedValue = EditorGUILayout.EnumPopup((Enum)d.CachedValue);
GUILayout.EndHorizontal();
SetTooltipForRect(GUILayoutUtility.GetLastRect(), d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
InvertApplication.Execute(() =>
{
d.Setter(d.DataObject, d.CachedValue);
});
}
}
else if (d.Type == typeof(Type))
{
//InvertGraphEditor.WindowManager.InitTypeListWindow();
}
}
GUI.color = colorCache;
}
public void QueryPossibleConnections(SelectionMenu menu, DiagramViewModel diagramViewModel,
ConnectorViewModel startConnector,
Vector2 mousePosition)
{
var currentGraph = InvertApplication.Container.Resolve <WorkspaceService>().CurrentWorkspace.CurrentGraph;
var allowedFilterNodes = FilterExtensions.AllowedFilterNodes[currentGraph.CurrentFilter.GetType()];
foreach (var item in allowedFilterNodes)
{
if (item.IsInterface)
{
continue;
}
if (item.IsAbstract)
{
continue;
}
//if(item.FullName == "uFrame.MVVM.ViewNode") continue;
var node = Activator.CreateInstance(item) as IDiagramNode;
node.Repository = diagramViewModel.CurrentRepository;
node.GraphId = currentGraph.Identifier;
var vm = InvertGraphEditor.Container.GetNodeViewModel(node, diagramViewModel) as DiagramNodeViewModel;
if (vm == null)
{
continue;
}
vm.IsCollapsed = false;
var connectors = new List <ConnectorViewModel>();
vm.GetConnectors(connectors);
var config = InvertGraphEditor.Container.Resolve <NodeConfigBase>(item.Name);
var name = config == null ? item.Name : config.Name;
foreach (var connector in connectors)
{
foreach (var strategy in InvertGraphEditor.ConnectionStrategies)
{
var connection = strategy.Connect(diagramViewModel, startConnector, connector);
if (connection == null)
{
continue;
}
var node1 = node;
var message = string.Format("Create {0}", name);
//if (!string.IsNullOrEmpty(connector.Name))
//{
// message += string.Format(" and connect to {0}", connector.Name);
//}
var value = new KeyValuePair <IDiagramNode, ConnectionViewModel>(node1, connection);
var qaItem = new SelectionMenuItem("Connect", message, () =>
{
diagramViewModel.AddNode(value.Key, mousePosition);
connection.Apply(value.Value as ConnectionViewModel);
value.Key.IsSelected = true;
value.Key.IsEditing = true;
value.Key.Name = "";
});
menu.AddItem(qaItem);
}
}
}
}
public void ShowSelectionMenu(SelectionMenu menu, Vector2? position = null, bool useWindow = false)
{
HideSelection();
TreeModel = ConstructViewModel(menu);
SearchCriteria = null;
EnableContent = true;
RequestPosition = position;
_focusNeeded = true;
}
protected TreeViewModel ConstructViewModel(SelectionMenu items)
{
var result = new TreeViewModel
{
Data = items.Items,
Submit = SelectItem
};
return result;
}
public virtual void DrawInspector(Rect rect, PropertyFieldViewModel d, GUIStyle labelStyle)
{
var colorCache = GUI.color;
GUI.color = Color.white;
var labelArea = rect.LeftHalf();
var fieldArea = rect.RightHalf();
var labelWidtho = GUILayout.Width(140);
if (d.InspectorType == InspectorType.GraphItems)
{
var item = d.CachedValue as IGraphItem;
var text = "--Select--";
if (item != null)
{
text = item.Label;
}
//GUILayout.BeginHorizontal();
if (GUI.Button(rect, d.Label + ": " + text, ElementDesignerStyles.ButtonStyle))
{
var type = d.Type;
var items = InvertGraphEditor.CurrentDiagramViewModel.CurrentRepository.AllOf<IGraphItem>().Where(p => type.IsAssignableFrom(p.GetType()));
var menu = new SelectionMenu();
menu.AddItem(new SelectionMenuItem(string.Empty,"[None]", () =>
{
InvertApplication.Execute(() =>
{
d.Setter(d.DataObject, null);
});
}));
foreach (var graphItem in items)
{
var graphItem1 = graphItem;
menu.AddItem(new SelectionMenuItem(graphItem1, () =>
{
InvertApplication.Execute(() =>
{
d.Setter(d.DataObject, graphItem1);
});
}));
}
InvertApplication.SignalEvent<IShowSelectionMenu>(_ => _.ShowSelectionMenu(menu));
//
// InvertGraphEditor.WindowManager.InitItemWindow(items,
//
// },true);
}
SetTooltipForRect(rect, d.InspectorTip);
GUI.color = colorCache;
//GUILayout.EndHorizontal();
return;
}
if (d.Type == typeof(string))
{
if (d.InspectorType == InspectorType.TextArea)
{
labelArea = rect.WithHeight(17).InnerAlignWithUpperRight(rect);
fieldArea = rect.Below(labelArea).Clip(rect).PadSides(2);
EditorGUI.LabelField(labelArea, d.Name, labelStyle);
SetTooltipForRect(rect, d.InspectorTip);
EditorGUI.BeginChangeCheck();
d.CachedValue = EditorGUI.TextArea(fieldArea, (string)d.CachedValue, TextWrappingTextArea);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
if (Event.current.isKey && Event.current.keyCode == KeyCode.Return)
{
InvertApplication.Execute(() =>
{
});
}
}
else if (d.InspectorType == InspectorType.TypeSelection)
{
if (GUI.Button(rect, (string)d.CachedValue))
{
d.NodeViewModel.Select();
// TODO 2.0 Open Selection?
}
SetTooltipForRect(rect, d.InspectorTip);
}
else
{
EditorGUI.BeginChangeCheck();
EditorGUI.LabelField(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.TextField(fieldArea, (string)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
}
else
{
if (d.Type == typeof(int))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.IntField(fieldArea, (int)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(float))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.FloatField(fieldArea, (float)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector2))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.Vector2Field(fieldArea, string.Empty, (Vector2)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector3))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.Vector3Field(fieldArea, string.Empty, (Vector3)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Color))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.ColorField(fieldArea, (Color)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(Vector4))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.Vector4Field(fieldArea, string.Empty, (Vector4)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (d.Type == typeof(bool))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.Toggle(fieldArea, (bool)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
d.Setter(d.DataObject, d.CachedValue);
}
}
else if (typeof(Enum).IsAssignableFrom(d.Type))
{
EditorGUI.BeginChangeCheck();
GUI.Label(labelArea, d.Name, labelStyle);
d.CachedValue = EditorGUI.EnumPopup(fieldArea, (Enum)d.CachedValue);
SetTooltipForRect(rect, d.InspectorTip);
if (EditorGUI.EndChangeCheck())
{
InvertApplication.Execute(() =>
{
d.Setter(d.DataObject, d.CachedValue);
});
}
}
else if (d.Type == typeof(Type))
{
//InvertGraphEditor.WindowManager.InitTypeListWindow();
}
}
GUI.color = colorCache;
}
public override void Update()
{
Terr = (Terrain)Objects.ObjFind <Terrain>(0);
if (!EditorMode)
{
Vector2 movement = Vector2.Zero;
// Movement.
if (Controls.KeyCheck(Controls.KeyUp))
{
movement.Y += -1;
}
if (Controls.KeyCheck(Controls.KeyDown))
{
movement.Y += 1;
}
if (Controls.KeyCheck(Controls.KeyLeft))
{
movement.X += -1;
}
if (Controls.KeyCheck(Controls.KeyRight))
{
movement.X += 1;
}
// Movement.
_movementAlarm.Update();
if (movement != Vector2.Zero)
{
if (!_movementAlarm.Active)
{
_movementAlarm.Set(1f / WalkSpd);
_movementAlarm.Triggered = true;
}
}
else
{
_movementAlarm.Reset();
}
if (_movementAlarm.Triggered)
{
TryTriggeringObjects(Pos + movement);
if (Terr.GetTile(new Vector2(Pos.X + movement.X, Pos.Y)).IsPassable())
{
Pos.X += movement.X;
}
if (Terr.GetTile(new Vector2(Pos.X, Pos.Y + movement.Y)).IsPassable())
{
Pos.Y += movement.Y;
}
if (RandomEncountersEnabled && RandomEncountersCooldown <= 0)
{
if (GameplayController.Random.NextDouble() <= RandomEncountersChance)
{
int arenaId = (int)(GameplayController.Random.NextDouble() * RandomEncounterArenas.Count);
new ArenaAppearEffect(RandomEncounterArenas[arenaId]);
RandomEncountersCooldown = RandomEncountersMaxCooldown;
}
}
RandomEncountersCooldown -= 1;
if (RandomEncountersCooldown < 0)
{
RandomEncountersCooldown = 0;
}
}
if (Controls.KeyCheckPress(Controls.KeyA))
{
foreach (Vector2 rot in Rotation)
{
TryTriggeringObjects(Pos + rot);
}
}
#region Menu
if (Controls.KeyCheckPress(Microsoft.Xna.Framework.Input.Keys.Escape))
{
new Pause();
}
if (Controls.KeyCheckPress(Controls.KeyB))
{
_menu = new SelectionMenu(Strings.PlayerMenu, _menuOptions, _menuPos, _menuSize);
}
if (_menu != null && _menu.Activated)
{
Inventory inv = (Inventory)Objects.ObjFind <Inventory>(0);
Objects.Destroy(_menu);
switch (_menu.SelectedItem)
{
case 0:
inv.ShowItems();
break;
case 1:
inv.ShowPotions();
break;
case 2:
SoundController.PlaySound(SoundController.Back);
break;
}
_menu = null;
}
#endregion Menu
#region Camera
Camera currentCamera = DrawCntrl.Cameras[0];
Vector2 screenPos = (Pos - new Vector2(Terrain.HorCamBorder, Terrain.VerCamBorder)) * GameConsole.CharSize - new Vector2(currentCamera.X, currentCamera.Y);
Vector2 screenSize = new Vector2(GameConsole.W - 1 - Terrain.HorCamBorder * 2, GameConsole.H - 1 - Terrain.VerCamBorder * 2) * GameConsole.CharSize;
if (screenPos.X < 0)
{
currentCamera.X += screenPos.X;
}
if (screenPos.Y < 0)
{
currentCamera.Y += screenPos.Y;
}
if (screenPos.X >= screenSize.X)
{
currentCamera.X += screenPos.X - screenSize.X;
}
if (screenPos.Y >= screenSize.Y)
{
currentCamera.Y += screenPos.Y - screenSize.Y;
}
if (currentCamera.X / GameConsole.CharSize.X < Terrain.CamMinPos.X)
{
currentCamera.X = Terrain.CamMinPos.X * GameConsole.CharSize.X;
}
if (currentCamera.Y / GameConsole.CharSize.Y < Terrain.CamMinPos.Y)
{
currentCamera.Y = Terrain.CamMinPos.Y * GameConsole.CharSize.Y;
}
if (currentCamera.X / GameConsole.CharSize.X + GameConsole.W > Terrain.CamMaxPos.X)
{
currentCamera.X = (Terrain.CamMaxPos.X - GameConsole.W) * GameConsole.CharSize.X;
}
if (currentCamera.Y / GameConsole.CharSize.Y + GameConsole.H > Terrain.CamMaxPos.Y)
{
currentCamera.Y = (Terrain.CamMaxPos.Y - GameConsole.H) * GameConsole.CharSize.Y;
}
#endregion Camera
}
}
