private void OnToggleLocalSpaceIconClicked(Event inputEvent)
{
DrawGUI.Use(inputEvent);
SetUsingLocalSpace(!UsingLocalSpace);
GUI.changed = true;
SelectHeaderPart((HeaderPart)TransformHeaderPart.ToggleLocalSpaceButton);
}
/// <summary>
/// fill out lastDrawPosition for Draw
/// </summary>
protected override void GetDrawPositions(Rect position)
{
lastDrawPosition = position;
lastDrawPosition.height = Height;
localDrawAreaOffset = DrawGUI.GetLocalDrawAreaOffset();
}
/// <inheritdoc/>
public override bool OnRightClick(Event inputEvent)
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(!inspector.IgnoreToolbarMouseInputs(), GetType().Name + ".HandleOnBeingActivated called with IgnoreToolbarMouseInputs " + StringUtils.True);
Debug.Assert(inputEvent != null);
Debug.Assert(inputEvent.type != EventType.Used);
#endif
switch (mouseoveredPart)
{
case SearchBoxPart.Dropdown:
DrawGUI.Use(inputEvent);
OpenFilteringMethodMenu(dropdownButtonRect);
return(true);
case SearchBoxPart.TextField:
// don't consume right click event, let filterDrawer handle that
return(false);
case SearchBoxPart.ClearButton:
DrawGUI.Use(inputEvent);
ClearFilterField(false);
return(true);
default:
return(base.OnRightClick(inputEvent));
}
}
/// <inheritdoc/>
protected override void Setup()
{
filterDrawer = new FilterField(OpenFilteringMethodMenu);
graphics = inspector.Preferences.graphics;
inspector.OnFilterChanging += SyncFilterFromInspectorState;
if (ClearButtonWidth <= 0f)
{
#if SAFE_MODE
if (Event.current == null)
{
#if DEV_MODE
Debug.LogWarning(GetType().Name + ".Setup called with Event.current null. This is dangerous because can't reference many GUI related methods.");
#endif
DrawGUI.OnNextBeginOnGUI(() => ClearButtonWidth = InspectorPreferences.Styles.ToolbarCancel.CalcSize(GUIContent.none).x, false);
}
else
#endif
{
ClearButtonWidth = InspectorPreferences.Styles.ToolbarCancel.CalcSize(GUIContent.none).x;
}
}
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(ClearButtonWidth > 0f, ClearButtonWidth);
#endif
}
/// <summary>
/// Determines whether current event is a mouse drag event.
///
/// True if has DragAndDropObjectReferences.
///
/// True if mouse has moved since mouse button was pressed down and last input event type is MouseDrag, DragUpdated, or MouseDown for right mouse button.
///
/// True if mouse has moved since mouse button was pressed down and current input event type is DragPerform, DragExited.
///
/// NOTE: This can return true for the remaining duration of the the frame, even after Clear has been called.
///
/// NOTE: This can return true, even if mouse down event was used.
/// </summary>
/// <returns> True if event is a mouse drag event, otherwise returns false. </returns>
public bool IsDrag()
{
if (DrawGUI.IsUnityObjectDrag)
{
return(true);
}
if (isClick)
{
return(false);
}
switch (DrawGUI.LastInputEventType)
{
case EventType.DragPerform:
case EventType.DragExited:
return(Event.current != null && Event.current.Equals(DrawGUI.LastInputEvent()));
case EventType.MouseDrag:
case EventType.DragUpdated:
return(true);
case EventType.ContextClick:
case EventType.MouseDown:
var lastInputEvent = DrawGUI.LastInputEvent();
return(lastInputEvent != null && lastInputEvent.button == 1);
default:
return(false);
}
}
private void OnToggleSnapToGridIconRightClicked(IUnityObjectDrawer containingDrawer, Rect buttonRect, Event inputEvent)
{
var menu = Menu.Create();
menu.Insert(0, "Edit Snap Settings...", () => DrawGUI.ExecuteMenuItem("Edit/Snap Settings..."));
ContextMenuUtility.OpenAt(menu, buttonRect, this, (Part)TransformHeaderPart.ToggleSnapToGridButton);
}
/// <inheritdoc />
protected override void GetDrawPositions(Rect position)
{
lastDrawPosition = position;
lastDrawPosition.height = Height;
lastDrawPosition.GetLabelAndControlRects(label, out labelLastDrawPosition, out textFieldDrawPosition);
textAreaDrawPosition = lastDrawPosition;
DrawGUI.AddMarginsAndIndentation(ref textAreaDrawPosition);
DrawGUI.RemoveFirstLine(ref textAreaDrawPosition);
if (textArea)
{
labelLastDrawPosition = lastDrawPosition;
DrawGUI.AddMargins(ref labelLastDrawPosition);
labelLastDrawPosition.height = DrawGUI.SingleLineHeight;
controlLastDrawPosition = textAreaDrawPosition;
}
else
{
controlLastDrawPosition = textFieldDrawPosition;
}
localDrawAreaOffset = DrawGUI.GetLocalDrawAreaOffset();
}
private void GetDrawPositions(Rect openPosition)
{
width = openPosition.width;
viewRect = openPosition;
viewRect.width = width;
viewRect.height = TotalHeight;
viewRect.x = 0f;
viewRect.y = 0f;
filterFieldRect = viewRect;
filterFieldRect.height = FilterAreaHeight;
filterFieldRect.x += 7f;
filterFieldRect.y = 6f;
filterFieldRect.width -= 16f + 14f;
filterDiscardRect = filterFieldRect;
filterDiscardRect.x += filterFieldRect.width;
filterDiscardRect.width = 16f;
filterDiscardRect.y += 1f;
headerRect = viewRect;
headerRect.y += FilterAreaHeight;
headerRect.height = NavigationBarHeight;
backArrowRect = headerRect;
backArrowRect.width = 13f;
backArrowRect.height = 13f;
backArrowRect.x += 3f;
backArrowRect.y += 5f;
headerLabelRect = headerRect;
float labelOffset = backArrowRect.xMax - headerRect.x;
headerLabelRect.x += labelOffset;
headerLabelRect.width -= labelOffset;
dividerRect = headerRect;
dividerRect.y = TopPartHeight;
dividerRect.height = 1f;
dividerRect.width = width;
viewRect.y = TopPartHeight;
viewRect.height = ScrollAreaHeight;
contentRect = viewRect;
contentRect.y = 0f;
contentRect.height = currentViewItemCount * DrawGUI.SingleLineHeight;
bool hasVerticalScrollBar = contentRect.height > ScrollAreaHeight;
if (hasVerticalScrollBar)
{
contentRect.width = width - DrawGUI.ScrollBarWidth;
}
viewRect.y = TopPartHeight;
localDrawAreaOffset = DrawGUI.GetLocalDrawAreaOffset();
}
private static void ShowWelcomeScreen()
{
showWelcomeScreenErrorsEncountered = false;
UnityEngine.Application.logMessageReceived += OnMessageLoggedToConsole;
try
{
DrawGUI.ExecuteMenuItem(PowerInspectorMenuItemPaths.WelcomeScreen);
}
#if DEV_MODE
catch (System.Exception e)
{
UnityEngine.Debug.LogError(e);
#else
catch
{
#endif
showWelcomeScreenErrorsEncountered = true;
}
UnityEngine.Application.logMessageReceived -= OnMessageLoggedToConsole;
// if any errors possibly prevented welcome screen from being shown, then don't set WelcomeScreenShown true
if (!showWelcomeScreenErrorsEncountered)
{
EditorPrefs.SetBool("PI.WelcomeScreenShown", true);
}
}
/// <inheritdoc/>
public virtual bool OnClick(Event inputEvent)
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(!inspector.IgnoreToolbarMouseInputs());
#endif
if (mouseoverVisibleItemIndex != -1)
{
if (!IsSelected)
{
inspector.Manager.Select(inspector, InspectorPart.Toolbar, ReasonSelectionChanged.ControlClicked);
}
var item = visibleItems[mouseoverVisibleItemIndex];
if (item.Selectable && SelectedItem != item)
{
SetSelectedItem(item, ReasonSelectionChanged.ControlClicked);
}
if (item.Clickable && item.OnClick(inputEvent))
{
GUIUtility.ExitGUI();
return(true);
}
return(false);
}
else
{
DrawGUI.Use(inputEvent);
KeyboardControlUtility.SetKeyboardControl(0, 3);
}
inspector.Manager.Select(inspector, InspectorPart.Toolbar, ReasonSelectionChanged.ThisClicked);
SetSelectedItem(-1, ReasonSelectionChanged.ThisClicked);
return(true);
}
/// <inheritdoc />
public override bool OnKeyboardInputGiven(Event inputEvent, KeyConfigs keys)
{
if (InspectorUtility.ActiveInspector.Preferences.keyConfigs.addComponent.DetectAndUseInput(inputEvent))
{
Select(ReasonSelectionChanged.KeyPressShortcut);
Open();
return(true);
}
switch (Event.current.keyCode)
{
case KeyCode.Return:
case KeyCode.KeypadEnter:
GUI.changed = true;
DrawGUI.Use(inputEvent);
if (!open)
{
Open();
}
return(true);
//TO DO: implement "opening" namespace or going back one level
case KeyCode.LeftArrow:
case KeyCode.RightArrow:
DrawGUI.Use(inputEvent);
return(true);
default:
return(base.OnKeyboardInputGiven(inputEvent, keys));
}
}
/// <inheritdoc />
public override void OnMouseover()
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(Clickable);
#endif
if (MouseOverPart == PrefixedControlPart.Control)
{
if (!ReadOnly)
{
DrawGUI.DrawMouseoverEffect(ControlPosition, localDrawAreaOffset);
}
}
else if (MouseOverPart == PrefixedControlPart.Prefix)
{
if (InspectorUtility.Preferences.mouseoverEffects.prefixLabel)
{
DrawGUI.DrawLeftClickAreaMouseoverEffect(PrefixLabelPosition, localDrawAreaOffset);
}
if (IsReorderable)
{
DrawGUI.Active.SetCursor(MouseCursor.MoveArrow);
}
}
}
/// <inheritdoc />
public override void DrawSelectionRect()
{
var rect = buttonRect;
rect.x += 1f;
DrawGUI.DrawControlSelectionIndicator(rect, localDrawAreaOffset);
}
/// <inheritdoc />
public override bool Draw(Rect position)
{
if (Event.current.type == EventType.Layout)
{
OnLayoutEvent(position);
}
else if (splitterRect.height < 1f)
{
GetDrawPositions(position);
Inspector.RefreshView();
}
DrawGUI.DrawLine(splitterRect, inspector.Preferences.theme.ComponentSeparatorLine);
GenerateControlId();
if (Event.current.type == EventType.Repaint)
{
GUI.Button(buttonRect, "Add Component", "AC Button");
}
DrawGUI.LayoutSpace(Height);
return(false);
}
/// <inheritdoc cref="IDrawer.OnMouseover" />
public override void OnMouseover()
{
base.OnMouseover();
if (draggableMemberVisible)
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(!ReadOnly);
#endif
DrawGUI.Active.SetCursor(MouseCursor.SlideArrow);
var color = Inspector.Preferences.theme.CanDragPrefixToAdjustValueTint;
// highlight the control even when mouseovering the prefix
// to make it clear than dragging will change the value of that field
var draggingTargets = DraggingTargetsMembers;
for (int n = draggingTargets.Length - 1; n >= 0; n--)
{
int index = draggingTargets[n];
var draggableMember = (IDraggablePrefix <float>)members[index];
if (draggableMember.ShouldShowInInspector)
{
DrawGUI.DrawMouseoverEffect(draggableMember.ControlPosition, color, localDrawAreaOffset);
}
}
}
}
/// <inheritdoc />
protected override void BuildContextMenu(ref Menu menu, bool extendedMenu)
{
if (BuildContextMenuItemsStartingFromBaseClass)
{
base.BuildContextMenu(ref menu, extendedMenu);
}
if (!ReadOnly && !IsPrefab)
{
menu.AddSeparatorIfNotRedundant();
menu.Add("Align With NavMesh", AlignWithNavMesh);
menu.Add("Align With Ground", AlignWithGround);
}
menu.AddSeparatorIfNotRedundant();
menu.Add("Snapping", () => SetSnapToGrid(!UsingSnapping), UsingSnapping);
menu.Add("Edit Snap Settings...", () => DrawGUI.ExecuteMenuItem("Edit/Snap Settings..."));
menu.Add("Use World Space", () => SetUsingLocalSpace(!UsingLocalSpace), !UsingLocalSpace);
if (!BuildContextMenuItemsStartingFromBaseClass)
{
base.BuildContextMenu(ref menu, extendedMenu);
}
var resetIndex = menu.IndexOf("Reset");
if (resetIndex != -1)
{
menu.Insert(resetIndex + 1, "Reset Without Affecting Children", ResetWithoutAffectingChildren);
}
}
public static void OnCustomEnabledControlClicked(IComponentDrawer drawer, Event inputEvent)
{
DrawGUI.Use(inputEvent);
var targets = drawer.Components;
var firstBehaviour = targets[0] as Behaviour;
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(firstBehaviour != null, "createCustomEnabledFlag was true but target was not a Behaviour");
#endif
bool setEnabled = !firstBehaviour.enabled;
var changed = targets;
for (int n = targets.Length - 1; n >= 1; n--)
{
if (((Behaviour)targets[n]).enabled == setEnabled)
{
changed = changed.RemoveAt(n);
}
}
UndoHandler.RegisterUndoableAction(changed, changed.Length == 1 ? (setEnabled ? "Enable Component" : "Disable Component") : (setEnabled ? "Enable Components" : "Disable Components"));
firstBehaviour.enabled = setEnabled;
for (int n = targets.Length - 1; n >= 1; n--)
{
((Behaviour)targets[n]).enabled = setEnabled;
}
}
/// <inheritdoc />
public sealed override bool OnKeyboardInputGiven(Event e, KeyConfigs keys)
{
if (DrawGUI.EditingTextField)
{
return(false);
}
switch (e.keyCode)
{
case KeyCode.LeftArrow:
case KeyCode.KeypadPlus:
GUI.changed = true;
DrawGUI.Use(e);
TValue value = Value;
TValue decreased = RoundedAndClamped(Convert.ToDouble(value) - (e.shift ? step * 10d : step));
if (decreased.CompareTo(value) != 0)
{
Value = decreased;
}
return(true);
case KeyCode.RightArrow:
case KeyCode.KeypadMinus:
GUI.changed = true;
DrawGUI.Use(e);
value = Value;
TValue increased = RoundedAndClamped(Convert.ToDouble(value) + (e.shift ? step * 10d : step));
if (increased.CompareTo(value) != 0)
{
Value = increased;
}
return(true);
}
return(base.OnKeyboardInputGiven(e, keys));
}
public virtual void OnPrefixDragged(Event inputEvent)
{
var values = GetValues();
var mouseDownValues = MouseDownValues;
float mouseDelta = this.GetMouseDelta(inputEvent, MouseDownPosition);
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(values.Length == mouseDownValues.Length);
Debug.Assert(mouseDownValues.Length > 0);
#endif
bool changed = false;
for (int n = values.Length - 1; n >= 0; n--)
{
var valueWas = (TValue)values[n];
var mouseDownValue = (TValue)MouseDownValues[n];
var setValue = valueWas;
OnPrefixDragged(ref setValue, mouseDownValue, mouseDelta);
if (!setValue.Equals(valueWas))
{
values[n] = setValue;
changed = true;
}
}
if (changed)
{
SetValues(values);
}
// highlight the control when prefix is being dragged
// to make it clear that it is being dragged
DrawGUI.DrawMouseoverEffect(ControlPosition, Inspector.Preferences.theme.CanDragPrefixToAdjustValueTint, localDrawAreaOffset);
}
/// <inheritdoc/>
protected override void GetDrawPositions(Rect position)
{
lastDrawPosition = position;
float totalHeight = Height;
lastDrawPosition.height = totalHeight;
lastDrawPosition = position;
if (DrawInSingleRow)
{
lastDrawPosition.GetLabelAndControlRects(label, out labelLastDrawPosition, out bodyLastDrawPosition);
}
else
{
labelLastDrawPosition = position;
float headerHeight = HeaderHeight;
labelLastDrawPosition.height = headerHeight;
bodyLastDrawPosition = position;
bodyLastDrawPosition.y += headerHeight;
bodyLastDrawPosition.height = totalHeight - headerHeight;
}
localDrawAreaOffset = DrawGUI.GetLocalDrawAreaOffset();
}
/// <inheritdoc cref="IDrawer.OnMiddleClick" />
public override void OnMiddleClick(Event inputEvent)
{
base.OnMiddleClick(inputEvent);
var typeValue = Value;
if (typeValue != null && inputEvent.type != EventType.Used)
{
var monoScript = FileUtility.FindScriptFile(typeValue);
if (monoScript != null)
{
#if DEV_MODE && UNITY_EDITOR
Debug.Log("Pinging script asset " + UnityEditor.AssetDatabase.GetAssetPath(monoScript) + "...", monoScript);
#endif
DrawGUI.Active.PingObject(monoScript);
DrawGUI.Use(inputEvent);
return;
}
#if DEV_MODE
Debug.Log("script by type " + typeValue.FullName + " not found...");
#endif
}
#if DEV_MODE
else
{
Debug.Log("typeValue=" + StringUtils.ToString(typeValue) + ", Event.type=" + inputEvent.type);
}
#endif
}
/// <inheritdoc cref="IDrawer.OnKeyboardInputGiven" />
public override bool OnKeyboardInputGiven(Event inputEvent, KeyConfigs keys)
{
#if DEV_MODE && DEBUG_KEYBOARD_INPUT
Debug.Log(ToString() + ".OnKeyboardInputGiven(" + StringUtils.ToString(inputEvent) + ")");
#endif
if (DrawToggleNullButton)
{
switch (inputEvent.keyCode)
{
case KeyCode.F2:
var textFieldMember = ValueDrawer as ITextFieldDrawer;
if (textFieldMember != null)
{
DrawGUI.Use(inputEvent);
textFieldMember.StartEditingField();
return(true);
}
return(false);
case KeyCode.Return:
case KeyCode.Space:
case KeyCode.KeypadEnter:
if (inputEvent.modifiers == EventModifiers.None)
{
OnNullToggleButtonClicked();
GUI.changed = true;
DrawGUI.Use(inputEvent);
return(true);
}
break;
}
}
return(base.OnKeyboardInputGiven(inputEvent, keys));
}
public void DrawSelectionRect()
{
if (drawSelectionRect)
{
DrawGUI.DrawControlSelectionIndicator(rect);
}
}
//Enable this if not running a client on the server machine
// MasterServer.dedicatedServer = true;
public MasterServerGUI()
{
connectedGUI = new DrawGUI(this.ConnectedGUI);
disconnectedGUI = new DrawGUI(this.DisconnectedGUI);
guiDelegate = new DrawGUI(this.ShowGUI);
subGUIDelegate = this.disconnectedGUI;
}
public static void HandleFieldFocus(string id, ref int focusField)
{
if (focusField > 0)
{
// Trigger a Layout event.
GUI.changed = true;
GUI.SetNextControlName(id);
if (Event.current.type == EventType.Layout)
{
// Only call FocusControl at the lastest possible moment to prevent issue where keyboard focus would visibly jump between multiple controls.
if (focusField == 1)
{
DrawGUI.FocusControl(id);
}
focusField--;
#if DEV_MODE && DEBUG_FOCUS_FIELD
Debug.Log(StringUtils.ToColorizedString("focusing field " + id + ", repeats=", focusField, ", Event=", StringUtils.ToString(Event.current)));
#endif
}
}
}
// Use this for initialization
public void Start(GUIDone doneDelegate)
{
Debug.Log("Start");
guiDelegate = disconnectedGUI;
guiDone = doneDelegate;
LoadClient();
}
/// <inheritdoc />
public void OnBeingReordered(float yOffset)
{
var rect = SelectionRect;
rect.y += yOffset;
DrawGUI.DrawMouseoverEffect(rect, localDrawAreaOffset);
}
//GUI to show when we're disconnected.
void DisconnectedGUI()
{
//Connect to a server
if (GUI.Button(new Rect(10, 10, 100, 30), "Connect"))
{
Network.Connect(remoteIP, remotePort);
guiDelegate = connectedGUI;
}
//Start a server
if (GUI.Button(new Rect(10, 50, 100, 30), "Start Server"))
{
Network.InitializeServer(this.maxConnections, this.listenPort, this.useNAT);
GameObject [] objects = GameObject.FindObjectsOfType(typeof(GameObject)) as GameObject[];
//Alert game objects
foreach (GameObject obj in objects)
{
obj.SendMessage("OnNetworkLoadedLevel", SendMessageOptions.DontRequireReceiver);
}
}
//Allow user to manually enter connection info
remoteIP = GUI.TextField(new Rect(120, 10, 100, 20), remoteIP);
string port = GUI.TextField(new Rect(230, 10, 40, 20), remotePort.ToString());
//If text box is empty, make it '0'
try
{
remotePort = int.Parse(port);
}
catch
{
remotePort = 0;
}
}
/// <summary>
/// Determines whether current event is a mouse drag event.
///
/// True if has DragAndDropObjectReferences.
///
/// True if mouse has moved since mouse button was pressed down and last input event type is MouseDrag, DragUpdated, or MouseDown for left mouse button.
///
/// True if mouse has moved since mouse button was pressed down and current input event type is DragPerform, DragExited.
///
/// NOTE: This can return true for the remaining duration of the the frame, even after MouseDownInfo.Clear(true) has been called.
///
/// NOTE: This can return true, even if mouse down event was used.
/// </summary>
/// <returns> True if event is a mouse drag event, otherwise returns false. </returns>
public bool IsDrag()
{
//UPDATE: The DragAndDropObjectReferences check is important
//as without it the check would fail at random times when dragging
//a MonoScript from the Project view on the custom InspectorWindow
if (DrawGUI.IsUnityObjectDrag)
{
return(true);
}
if (isClick)
{
return(false);
}
switch (DrawGUI.LastInputEventType)
{
case EventType.DragPerform:
case EventType.DragExited:
return(Event.current != null && Event.current.Equals(DrawGUI.LastInputEvent()));
case EventType.MouseDrag:
case EventType.DragUpdated:
return(true);
case EventType.MouseDown:
var lastInputEvent = DrawGUI.LastInputEvent();
return(lastInputEvent != null && lastInputEvent.button == 0);
default:
return(false);
}
}
/// <summary> Call this when a text field control is clicked. </summary>
/// <param name="subject"> The clicked text field drawer. </param>
/// <param name="inputEvent"> The current input event. </param>
public static void OnControlClicked(ITextFieldDrawer subject, Event inputEvent)
{
bool canStartEditing = CanStartEditing(subject);
// if field was already selected when it was clicked, don't use the event
// this way Unity can handle positioning the cursor in a specific point on the text field etc.
if (subject.Selected)
{
#if DEV_MODE && DEBUG_EDITING_TEXT_FIELD
Debug.Log(StringUtils.ToColorizedString("TextFieldUtility.OnControlClicked - DrawGUI.EditingTextField = ", canStartEditing, " (because was selected)"));
#endif
DrawGUI.EditingTextField = canStartEditing;
return;
}
DrawGUI.Use(inputEvent);
subject.HandleOnClickSelection(inputEvent, ReasonSelectionChanged.ControlClicked);
if (canStartEditing)
{
#if DEV_MODE && DEBUG_EDITING_TEXT_FIELD
Debug.Log(StringUtils.ToColorizedString("TextFieldUtility.OnControlClicked - Calling StartEditingField (not selected and can start editing)"));
#endif
subject.StartEditingField();
}
else
{
#if DEV_MODE && DEBUG_EDITING_TEXT_FIELD
Debug.Log(StringUtils.ToColorizedString("TextFieldUtility.OnControlClicked - DrawGUI.EditingTextField = ", false, " (because was can start editing was ", false, ")"));
#endif
DrawGUI.EditingTextField = false;
}
}
/// <inheritdoc />
public override void DrawFilterHighlight(SearchFilter filter, Color color)
{
if (lastPassedFilterTestType == FilterTestType.Value)
{
DrawGUI.DrawControlFilteringEffect(ControlPosition, color, localDrawAreaOffset);
}
}
// Use this for initialization
void Start()
{
masterServerGUI = new MasterServerGUI();
udpConnectionGUI = new UDPConnectionGUI();
guiDelegate = new DrawGUI(this.MainMenu);
internalGUIDelegate = new DrawGUI(this.MainMenu);
guiDone = new GUIDone(this.OnGUIDone);
currentGUI = null;
}
void MainMenu()
{
GUI.Label(new Rect((Screen.width/2)-80,(Screen.height/2)-130,200,50),"SELECT CONNECTION TYPE");
GUI.Label(new Rect((Screen.width-220),(Screen.height-30),220,30),"MULTIPLAYER DEMO");
if(GUI.Button(new Rect((Screen.width/2)-100,(Screen.height/2)-100,200,50),"Master Server Connection"))
{
currentGUI = masterServerGUI;
currentGUI.Start(this.guiDone);
guiDelegate = currentGUI.GetDrawGUIDelegate();
}
if(GUI.Button(new Rect((Screen.width/2)-100,(Screen.height/2)-40,200,50),"Direct Connection"))
{
//Network.InitializeServer(this.maxConnections, this.listenPort, this.useNAT);
masterServerGUI.Stop();
udpConnectionGUI.Stop ();
Application.LoadLevel("MainGame");
}
if(GUI.Button(new Rect((Screen.width/2)-100,(Screen.height/2)+20,200,50),"UDPConnection"))
{
currentGUI = udpConnectionGUI;
currentGUI.Start(this.guiDone);
guiDelegate = currentGUI.GetDrawGUIDelegate();
}
}
void OnGUIDone()
{
currentGUI.Stop();
guiDelegate = this.internalGUIDelegate;
}
void DisconnectedGUI()
{
//Start new server
if(GUI.Button (new Rect(10, 10, 90, 30), "Start Server"))
{
Network.InitializeServer(maxPlayers, serverPort, !Network.HavePublicAddress());
MasterServer.updateRate = 3;
MasterServer.RegisterHost(gameName, "stuff", "profas chat test");
subGUIDelegate = this.connectedGUI;
}
//Refresh hosts
if(GUI.Button (new Rect(10, 40, 210, 30), "Refresh Available Servers") ||
Time.realtimeSinceStartup > lastHostListRequest + hostListRefreshTimeout)
{
MasterServer.ClearHostList();
MasterServer.RequestHostList(gameName);
lastHostListRequest = Time.realtimeSinceStartup;
Debug.Log("Refresh Click");
}
if(GUI.Button (new Rect(10, 70, 210, 30), "Main Menu"))
{
Network.Disconnect();
MasterServer.UnregisterHost();
guiDone();
//Stop();
//Application.LoadLevel("ServerChoose");
}
HostData [] hostData = MasterServer.PollHostList();
int count = 0;
foreach(HostData data in hostData)
{
//Do not display NAT enabled games if we cannot do NAT punchthrough
if(!(filterNATHosts && data.useNat))
{
string name = System.String.Format("{0} {1}/{2}",
data.gameName, data.connectedPlayers, data.playerLimit);
string hostInfo = "[";
foreach(string host in data.ip)
hostInfo += (host + ":" + data.port + " ");
hostInfo += "]";
if(GUI.Button(new Rect(20, (count * 50) + 100, 400, 40), hostInfo))
{
//Enable NAT functionality based on what the hosts are configured to do
Network.Connect(data);
}
}
}
}
void ConnectedGUI()
{
if (GUI.Button (new Rect(10,10,90,30),"Disconnect"))
{
Network.Disconnect();
MasterServer.UnregisterHost();
subGUIDelegate = this.disconnectedGUI;
}
}
