public MultiplayerBase(string address, int port, PGGI.PGGIProvider provider)
{
ISpriteBatchService spriteService = Atom.Shared.Globals.Engine.GetService<ISpriteBatchService>();
IInputService inputService = Atom.Shared.Globals.Engine.GetService<IInputService>();
contract = inputService.CreateContract();
contract.Enabled = true;
contract.SubscribedTouchEvents = TouchStates.OnDoubleTap | TouchStates.OnDrag | TouchStates.OnTap;
contract.TouchEventHandler += contract_TouchEventHandler;
spriteBatch = spriteService.SpriteBatch;
SelectionState = SelectionState.Selection;
GameState = MultiplayerGameState.Connecting;
GameCounter = 0;
client = new Client();
client.OnConnection += new EventHandler<ConnectionArgs>(ClientOnConnection);
client.OnPacketRecieved += new EventHandler<PacketRecievedArgs>(ClientOnPacket);
Packet ConnectionPacket = new Packet();
ConnectionPacket.Write(provider.PGGI);
ConnectionPacket.Write(provider.Token);
client.Connect(new System.Net.DnsEndPoint(address, port), ConnectionPacket);
Syncing = false;
FramesToSpin = int.MaxValue;
Manager = new MultiplayerGameManager();
Content = new ContentManager(Atom.Shared.Globals.Engine, "Content");
Fleet = Content.Load<Texture2D>("Graphics/Fleets/1");
}
private StarSelectorState GetSelectorState(SelectionState state)
{
if (state == SelectionState.Disabled) return disabled;
else if (state == SelectionState.Highlighted) return highlighted;
else if (state == SelectionState.Pressed) return pressed;
return normal;
}
protected virtual void DoStateTransition(SelectionState state, bool instant)
{
Color normalColor;
Sprite highlightedSprite;
string normalTrigger;
switch (state)
{
case SelectionState.Normal:
normalColor = this.m_Colors.normalColor;
highlightedSprite = null;
normalTrigger = this.m_AnimationTriggers.normalTrigger;
break;
case SelectionState.Highlighted:
normalColor = this.m_Colors.highlightedColor;
highlightedSprite = this.m_SpriteState.highlightedSprite;
normalTrigger = this.m_AnimationTriggers.highlightedTrigger;
break;
case SelectionState.Pressed:
normalColor = this.m_Colors.pressedColor;
highlightedSprite = this.m_SpriteState.pressedSprite;
normalTrigger = this.m_AnimationTriggers.pressedTrigger;
break;
case SelectionState.Disabled:
normalColor = this.m_Colors.disabledColor;
highlightedSprite = this.m_SpriteState.disabledSprite;
normalTrigger = this.m_AnimationTriggers.disabledTrigger;
break;
default:
normalColor = Color.black;
highlightedSprite = null;
normalTrigger = string.Empty;
break;
}
if (base.gameObject.activeInHierarchy)
{
switch (this.m_Transition)
{
case Transition.ColorTint:
this.StartColorTween((Color) (normalColor * this.m_Colors.colorMultiplier), instant);
break;
case Transition.SpriteSwap:
this.DoSpriteSwap(highlightedSprite);
break;
case Transition.Animation:
this.TriggerAnimation(normalTrigger);
break;
}
}
}
protected override void DoStateTransition(SelectionState state, bool instant)
{
base.DoStateTransition(state, instant);
StarSelectorState sState = GetSelectorState(state);
if(this.state != sState)
{
previousState = this.state;
this.state = sState;
stateTimer = 0;
}
}
//the following two overridden methods are what are known to perform sprite swaps in selectable
protected override void DoStateTransition(SelectionState state, bool instant)
{
base.DoStateTransition(state, instant);
if (transition == Transition.ColorTint)
{
if (state == SelectionState.Normal && _isOnTab)
SetSelected(_isOnTab);
if (state == SelectionState.Highlighted && _isOnTab)
SetSelected(_isOnTab);
}
else
SetSelected(_isOnTab);
}
protected override void DoStateTransition(SelectionState state, bool instant)
{
base.DoStateTransition(state, instant);
// Check if the script is enabled
if (!this.enabled || !this.gameObject.activeInHierarchy)
return;
switch (state)
{
case SelectionState.Normal:
if (this.m_NameTextComponent != null) this.m_NameTextComponent.canvasRenderer.SetColor(this.m_NameNormalColor);
if (this.m_ClassTextComponent != null) this.m_ClassTextComponent.canvasRenderer.SetColor(this.m_ClassNormalColor);
if (this.m_LevelTextComponent != null) this.m_LevelTextComponent.canvasRenderer.SetColor(this.m_LevelNormalColor);
break;
case SelectionState.Highlighted:
if (this.m_NameTextComponent != null) this.m_NameTextComponent.canvasRenderer.SetColor(this.m_NameHighlightColor);
if (this.m_ClassTextComponent != null) this.m_ClassTextComponent.canvasRenderer.SetColor(this.m_ClassHighlightColor);
if (this.m_LevelTextComponent != null) this.m_LevelTextComponent.canvasRenderer.SetColor(this.m_LevelHighlightColor);
break;
}
}
void Update()
{
Selected.RemoveAll(view => view == null || view.gameObject == null);
if (mSelectionState == SelectionState.Boxing && Input.GetMouseButtonUp((int)MouseButton.LeftMouse))
{
SelectionManager.FinishBoxSelection(Input.GetKey(KeyCode.LeftShift), Input.mousePosition);
mSelectionState = SelectionState.Idle;
}
SelectionManager.Update(Input.mousePosition);
if (EventSystem.current.IsPointerOverGameObject())
{
return;
}
if (mCurrentAction != null && !EventSystem.current.IsPointerOverGameObject())
{
var mapHit = mRaycaster.Raycast <MapView>(Input.mousePosition);
if (mapHit.IsEmpty())
{
return;
}
var mapPoint = GameUtils.GetFlatPosition(mapHit.HitPoint);
mCurrentAction.Move(mapPoint);
if (Input.GetMouseButtonDown((int)MouseButton.LeftMouse))
{
try
{
mCurrentAction.Resolve(mapPoint);
}
finally
{
mCurrentAction = null;
}
return;
}
if (Input.GetMouseButtonDown((int)MouseButton.RightMouse))
{
try
{
mCurrentAction.Cancel();
}
finally
{
mCurrentAction = null;
}
return;
}
return;
}
if (mSelectionState == SelectionState.Idle && Input.GetMouseButtonDown((int)MouseButton.LeftMouse))
{
mSelectionState = SelectionState.Choose;
}
if (mSelectionState == SelectionState.Choose)
{
if (Vector2.Distance(Input.mousePosition, mLastMousePosition) > 1)
{
SelectionManager.StartBoxSelection(Input.mousePosition);
mSelectionState = SelectionState.Boxing;
}
else if (Input.GetMouseButtonUp((int)MouseButton.LeftMouse))
{
SelectionManager.SelectSingle(Input.GetKey(KeyCode.LeftShift), Input.mousePosition);
mSelectionState = SelectionState.Idle;
}
}
if (Input.GetMouseButtonDown((int)MouseButton.RightMouse))
{
var viewHit = mRaycaster.Raycast <SelectableView>(Input.mousePosition);
if (!viewHit.IsEmpty())
{
foreach (var view in Selected)
{
if (!view.IsControlable)
{
continue;
}
if (viewHit.Object.IsControlable)
{
view.OnRightClick(viewHit.Object);
}
else
{
view.OnEnemyRightClick(viewHit.Object);
}
}
return;
}
var mapHit = mRaycaster.Raycast <MapView>(Input.mousePosition);
if (!mapHit.IsEmpty())
{
var mapPoint = GameUtils.GetFlatPosition(mapHit.HitPoint);
ForwardRightClick(mapPoint);
return;
}
}
mLastMousePosition = Input.mousePosition;
}
/// <summary>
/// Not called when the Item handles the Down event.
/// </summary>
// 6 //
private void List_ButtonDownEvent(object sender, MouseButtonEventArgs e)
{
if (_currentSelectionState == null) _currentSelectionState = new SelectionState();
_currentSelectionState.HandledEvent = e;
if (_currentSelectionState.ListViewItemEvent == null
&& _currentSelectionState.HandledEvent != null
&& _currentSelectionState.PreviewedEvent != null
&& _currentSelectionState.HandledEvent.Timestamp == _currentSelectionState.PreviewedEvent.Timestamp)
{
SelectListViewItems(_currentSelectionState.HandledEvent);
}
}
protected override void DoStateTransition(SelectionState state, bool instant) {
if(isHighlightDisabled) {
Color tintColor = _disabledHighlightedColor;
Sprite transitionSprite = _disabledHighlightedSprite;
string triggerName = _disabledHighlightedTrigger;
if(gameObject.activeInHierarchy) {
switch(this.transition) {
case Transition.ColorTint:
StartColorTween(tintColor * colors.colorMultiplier, instant);
break;
case Transition.SpriteSwap:
DoSpriteSwap(transitionSprite);
break;
case Transition.Animation:
TriggerAnimation(triggerName);
break;
}
}
} else {
base.DoStateTransition(state, instant);
}
}
public static void Selection(D2DMapEditor d2d, Map map, MapInfo mapInfo, int layerIndex, SelectionState state)
{
switch (state)
{
case SelectionState.StartSelection:
mapInfo.Selection = new SelectionTool();
mapInfo.Selection.IsDragging = true;
mapInfo.Selection.StartDrag = new Point(InputHelper.MapPosition.X, InputHelper.MapPosition.Y);
mapInfo.Selection.StopDrag = new Point(InputHelper.MapPosition.X, InputHelper.MapPosition.Y);
break;
case SelectionState.Dragging:
if (mapInfo.Selection.IsDragging)
{
mapInfo.Selection.StopDrag = new Point(InputHelper.MapPosition.X, InputHelper.MapPosition.Y);
d2d.RenderMap();
}
break;
case SelectionState.EndSelection:
mapInfo.Selection.IsDragging = false;
mapInfo.Selection.StopDrag = new Point(InputHelper.MapPosition.X, InputHelper.MapPosition.Y);
d2d.RenderMap();
break;
case SelectionState.SelectAll:
mapInfo.Selection = new SelectionTool();
mapInfo.Selection.StartDrag = new Point(0, 0);
mapInfo.Selection.StopDrag = new Point(map.Layers[layerIndex].Width, map.Layers[layerIndex].Height);
d2d.RenderMap();
break;
case SelectionState.ClearSelection:
mapInfo.Selection = new SelectionTool();
break;
default:
break;
}
}
private void EndSelect(bool success)
{
if (success)
{
ui.Add(selectableHex);
OnSelect();
selectableArea.Clear();
}
else
{
selectionState = SelectionState.End;
selectedArea.RemoveAll((hex) => { ui.Remove(hex); return true; });
}
}
void DrawBlockSelection(IMySlimBlock block, SelectionState state, bool primarySelection = false)
{
IMyCubeGrid grid = block.CubeGrid;
MyCubeBlockDefinition def = (MyCubeBlockDefinition)block.BlockDefinition;
Color color = (state == SelectionState.InvalidButMirrorValid ? Color.Yellow : (state == SelectionState.Valid ? Color.Green : Color.Red));
MatrixD worldMatrix;
BoundingBoxD localBB;
#region Compute box
MyCubeBlock fatBlock = block.FatBlock as MyCubeBlock;
if (fatBlock != null)
{
worldMatrix = fatBlock.PositionComp.WorldMatrixRef;
if (Main.Tick % (Constants.TICKS_PER_SECOND / 4) == 0 || !LocalBBCache.TryGetValue(block, out localBB))
{
BoundingBox localAABB = fatBlock.PositionComp.LocalAABB;
localBB = new BoundingBoxD(localAABB.Min, localAABB.Max);
#region Subpart localBB inclusion
if (fatBlock.Subparts != null)
{
MatrixD transformToBlockLocal = fatBlock.PositionComp.WorldMatrixInvScaled;
foreach (VRage.Game.Entity.MyEntitySubpart s1 in fatBlock.Subparts.Values)
{
MyOrientedBoundingBoxD obbS1 = new MyOrientedBoundingBoxD(s1.PositionComp.LocalAABB, s1.PositionComp.WorldMatrixRef);
obbS1.GetCorners(Corners, 0);
for (int i = 0; i < Corners.Length; i++)
{
Vector3D corner = Corners[i];
localBB.Include(Vector3D.Transform(corner, transformToBlockLocal));
}
if (s1.Subparts != null)
{
foreach (VRage.Game.Entity.MyEntitySubpart s2 in s1.Subparts.Values)
{
MyOrientedBoundingBoxD obbS2 = new MyOrientedBoundingBoxD(s2.PositionComp.LocalAABB, s2.PositionComp.WorldMatrixRef);
obbS2.GetCorners(Corners, 0);
for (int i = 0; i < Corners.Length; i++)
{
Vector3D corner = Corners[i];
localBB.Include(Vector3D.Transform(corner, transformToBlockLocal));
}
if (s2.Subparts != null)
{
foreach (VRage.Game.Entity.MyEntitySubpart s3 in s2.Subparts.Values)
{
MyOrientedBoundingBoxD obbS3 = new MyOrientedBoundingBoxD(s3.PositionComp.LocalAABB, s3.PositionComp.WorldMatrixRef);
obbS3.GetCorners(Corners, 0);
for (int i = 0; i < Corners.Length; i++)
{
Vector3D corner = Corners[i];
localBB.Include(Vector3D.Transform(corner, transformToBlockLocal));
}
if (s3.Subparts != null)
{
foreach (VRage.Game.Entity.MyEntitySubpart s4 in s3.Subparts.Values)
{
MyOrientedBoundingBoxD obbS4 = new MyOrientedBoundingBoxD(s4.PositionComp.LocalAABB, s4.PositionComp.WorldMatrixRef);
obbS4.GetCorners(Corners, 0);
for (int i = 0; i < Corners.Length; i++)
{
Vector3D corner = Corners[i];
localBB.Include(Vector3D.Transform(corner, transformToBlockLocal));
}
}
}
}
}
}
}
}
}
#endregion
LocalBBCache[block] = localBB;
}
}
else
{
Matrix localMatrix;
block.Orientation.GetMatrix(out localMatrix);
localMatrix.Translation = new Vector3(block.Position) * grid.GridSize;
worldMatrix = localMatrix * grid.WorldMatrix;
Vector3 halfSize = def.Size * (grid.GridSize * 0.5f);
localBB = new BoundingBoxD(-halfSize, halfSize);
}
#endregion
localBB.Inflate((grid.GridSizeEnum == MyCubeSize.Large ? 0.1 : 0.03));
float lineWidth;
if (primarySelection)
{
lineWidth = (grid.GridSizeEnum == MyCubeSize.Large ? 0.02f : 0.016f);
}
else
{
lineWidth = (grid.GridSizeEnum == MyCubeSize.Large ? 0.25f : 0.1f); // thicker mirrored selections to see better in distance
}
DrawSelectionLines(ref worldMatrix, ref localBB, color, lineWidth);
}
protected override void DoStateTransition(SelectionState state, bool instant)
{
m_StateTransitions.Add(state);
base.DoStateTransition(state, instant);
}
void UpdateCaretPropertiesCore(bool forceInvalidateVisual) {
if (layer.TextView.IsClosed)
return;
StopTimer();
var line = textCaret.ContainingTextViewLine;
oldSelectionState = new SelectionState(layer.TextView.Selection);
bool oldDrawCaretShape = drawCaretShape;
drawCaretShape = line.VisibilityState != VisibilityState.Unattached;
bool drawOverwriteMode = OverwriteMode && textCaret.CurrentPosition.Position < line.End && layer.TextView.Selection.IsEmpty;
var vpos = textCaret.CurrentPosition;
if (drawOverwriteMode) {
var textBounds = line.GetExtendedCharacterBounds(vpos);
left = textBounds.Left;
width = textBounds.Width;
}
else {
if (vpos.Position != line.Start && !vpos.IsInVirtualSpace)
left = line.GetExtendedCharacterBounds(vpos.Position - 1).Trailing;
else
left = line.GetExtendedCharacterBounds(vpos).Leading;
width = SystemParameters.CaretWidth;
}
height = line.TextHeight;
if (drawCaretShape) {
if (!imeStarted && layer.TextView.VisualElement.IsKeyboardFocused && layer.TextView.VisualElement.IsVisible)
StartTimer();
top = line.TextTop;
Canvas.SetLeft(this, left);
Canvas.SetTop(this, top);
}
else {
layer.Opacity = 0;
top = double.NaN;
}
var invalidateVisual = caretGeometry.SetProperties(width, height, drawOverwriteMode);
invalidateVisual |= forceInvalidateVisual || oldDrawCaretShape != drawCaretShape;
if (invalidateVisual)
InvalidateVisual();
}
public void FixSelection()
{
_state = SelectionState.Fixed;
FireSelectionFixed();
}
private bool IsTransitionTo(int index, SelectionState selectionState)
{
return(index < m_StateTransitions.Count && m_StateTransitions[index] == selectionState);
}
public bool Equals(SelectionState other) => state == other.state;
/// <summary>
/// Selects the entities in the list of model components.
/// </summary>
/// <param name="?"></param>
public void SelectEntities(List <ModelComponent> EntityList)
{
// Filter out zombie unit from player's selected list
for (int i = 0; i < EntityList.Count; ++i)
{
if (EntityList[i] is UnitComponent)
{
if (((UnitComponent)EntityList[i]).IsZombie)
{
EntityList.Remove(EntityList[i]);
}
}
}
SelectionState selectionState = getGameModel().GetSelectionState();
selectionState.ClearSelectionState();
bool hasUnits = false;
bool hasPlayerEntities = false;
PlayerComponent player = (PlayerComponent)getPlayerList().GetChildren()[0];
foreach (ModelComponent entity in EntityList)
{
if (entity is UnitComponent)
{
hasUnits = true;
if (player.GetUnitList().GetChildren().Contains(entity))
{
hasPlayerEntities = true;
}
}
else if (entity is Building)
{
if (player.BuildingList.GetChildren().Contains(entity))
{
hasPlayerEntities = true;
}
}
}
foreach (ModelComponent entity in EntityList)
{
if (hasUnits && hasPlayerEntities)
{
if (entity is UnitComponent && player.GetUnitList().GetChildren().Contains(entity))
{
selectionState.SelectEntity(entity);
}
}
else if (hasPlayerEntities)
{
if (entity is Building && player.BuildingList.GetChildren().Contains(entity))
{
selectionState.SelectEntity(entity);
}
}
else if (hasUnits)
{
if (entity is UnitComponent)
{
selectionState.SelectEntity(entity);
}
}
else
{
selectionState.SelectEntity(entity);
}
}
}
// Use this for initialization
void Start()
{
currentSelTarget = SelectionState.DESELECTED;
HSrndr = gameObject.GetComponent <SpriteRenderer>();
HSrndr.enabled = false;
}
protected override void OnMouseMove(object sender, MouseEventArgs e)
{
if (SelectedElement == null) State = SelectionState.Idle;
if (State == SelectionState.Dragging)
{
var pos = e.GetPosition(Editor);
var newPos = Editor.PointToPinball(new Vector(pos.X, pos.Y) - delta);
SelectedElement.Location = newPos;
posChange = new TranslationChange(SelectedElement, newPos - startVector);
Editor.Invalidate();
}
else if (State == SelectionState.Shaping)
{
var pos = e.GetPosition(Editor);
currentPoint = new Point(pos.X, pos.Y);
SelectedElement.Scale = ((currentPoint - shapeData.origin).Length / (shapeData.startPoint - shapeData.origin).Length) * shapeData.initialScale;
var newLoc = Editor.PointToPinball(shapeData.origin) - SelectedElement.GetRotationOrigin();
SelectedElement.Location = new Vector(newLoc.X, newLoc.Y);
SelectedElement.BaseRotation = shapeData.initialRotation + Vector.AngleBetween(shapeData.startPoint - shapeData.origin, currentPoint - shapeData.origin);
Editor.Invalidate();
}
}
public void OnSelectionStateChanged(SelectionState state)
{
Tint.ByState(state, gameObject);
}
protected override void OnMouseDown(object sender, MouseEventArgs e)
{
// Only act if we're idle
if (State == SelectionState.Idle)
{
if (e.LeftButton == MouseButtonState.Pressed)
{
if (SelectedElement != null && Control.ModifierKeys == System.Windows.Forms.Keys.Control)
{
State = SelectionState.Shaping;
var pos = Editor.PointToEditor(SelectedElement.Location + SelectedElement.GetRotationOrigin());
shapeData.origin = new Point(pos.X, pos.Y);
shapeData.startPoint = e.GetPosition(Editor);
double factor = (shapeData.startPoint - shapeData.origin).Length / MIN_LENGTH;
if (factor < 1)
{
shapeData.startPoint += (shapeData.startPoint - shapeData.origin) * (1 / factor);
}
currentPoint = new Point(shapeData.startPoint.X, shapeData.startPoint.Y);
shapeData.initialPoint = SelectedElement.Location;
shapeData.initialScale = SelectedElement.Scale;
shapeData.initialRotation = SelectedElement.BaseRotation;
}
else
{
State = SelectionState.Dragging;
var pos = e.GetPosition(Editor);
Point loc = Editor.PointToPinball(pos);
PinballElement element = FindElement(loc);
if (element != null)
{
// Select
SelectedElement = element;
this.delta = new Vector(pos.X, pos.Y) - Editor.PointToEditor(SelectedElement.Location);
startVector = SelectedElement.Location;
}
else
{
SelectedElement = null;
}
}
}
}
}
// Use this for initialization
void Start()
{
gameState = GameState.Default;
selectionState = SelectionState.Default;
objectsDepthOffset = mainPlanet.transform.position.z;
}
protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
{
base.OnMouseLeftButtonUp(e);
if (selectionStart.Col != selectionEnd.Col || selectionStart.Row != selectionEnd.Row)
selectionState = SelectionState.Selected;
else
selectionState = SelectionState.None;
ReleaseMouseCapture();
}
public void ChangeSelectionState(SelectionState state)
{
if (selectionState != state)
{
selectionState = state;
switch (state)
{
case SelectionState.Default:
{
SpaceshipManager.instance.DeselectSpaceship();
BuildingInfoPanel.instance.OpenCloseBuildingInfoPanel(false);
SpaceportInfoPanel.instance.DisplayPanel(false);
EnemiesManager.instance.DeselectEnemy();
PlanetaryShieldControlPanel.instance.DisplayPanel(false);
CollectorControlPanel.instance.DisplayPanel(false);
DysonSphereControlPanel.instance.DisplayPanel(false);
InfrastructureManager.instance.DeselectBuilding();
break;
}
case SelectionState.SpaceshipSelected:
{
BuildingInfoPanel.instance.OpenCloseBuildingInfoPanel(false);
SpaceportInfoPanel.instance.DisplayPanel(false);
EnemiesManager.instance.DeselectEnemy();
PlanetaryShieldControlPanel.instance.DisplayPanel(false);
CollectorControlPanel.instance.DisplayPanel(false);
DysonSphereControlPanel.instance.DisplayPanel(false);
InfrastructureManager.instance.DeselectBuilding();
break;
}
case SelectionState.BuildingSelected:
{
SpaceshipManager.instance.DeselectSpaceship();
SpaceportInfoPanel.instance.DisplayPanel(false);
EnemiesManager.instance.DeselectEnemy();
PlanetaryShieldControlPanel.instance.DisplayPanel(false);
CollectorControlPanel.instance.DisplayPanel(false);
DysonSphereControlPanel.instance.DisplayPanel(false);
break;
}
case SelectionState.ShopItemSelected:
{
SpaceshipManager.instance.DeselectSpaceship();
BuildingInfoPanel.instance.OpenCloseBuildingInfoPanel(false);
SpaceportInfoPanel.instance.DisplayPanel(false);
EnemiesManager.instance.DeselectEnemy();
PlanetaryShieldControlPanel.instance.DisplayPanel(false);
CollectorControlPanel.instance.DisplayPanel(false);
DysonSphereControlPanel.instance.DisplayPanel(false);
InfrastructureManager.instance.DeselectBuilding();
break;
}
case SelectionState.EnemySelected:
{
SpaceshipManager.instance.DeselectSpaceship();
BuildingInfoPanel.instance.OpenCloseBuildingInfoPanel(false);
SpaceportInfoPanel.instance.DisplayPanel(false);
PlanetaryShieldControlPanel.instance.DisplayPanel(false);
CollectorControlPanel.instance.DisplayPanel(false);
DysonSphereControlPanel.instance.DisplayPanel(false);
InfrastructureManager.instance.DeselectBuilding();
break;
}
case SelectionState.PlanetaryShieldSelected:
{
SpaceshipManager.instance.DeselectSpaceship();
BuildingInfoPanel.instance.OpenCloseBuildingInfoPanel(false);
SpaceportInfoPanel.instance.DisplayPanel(false);
EnemiesManager.instance.DeselectEnemy();
CollectorControlPanel.instance.DisplayPanel(false);
DysonSphereControlPanel.instance.DisplayPanel(false);
InfrastructureManager.instance.DeselectBuilding();
break;
}
case SelectionState.CollectorSelected:
{
SpaceshipManager.instance.DeselectSpaceship();
BuildingInfoPanel.instance.OpenCloseBuildingInfoPanel(false);
SpaceportInfoPanel.instance.DisplayPanel(false);
EnemiesManager.instance.DeselectEnemy();
PlanetaryShieldControlPanel.instance.DisplayPanel(false);
DysonSphereControlPanel.instance.DisplayPanel(false);
InfrastructureManager.instance.DeselectBuilding();
break;
}
case SelectionState.DysonSphereSelected:
{
SpaceshipManager.instance.DeselectSpaceship();
BuildingInfoPanel.instance.OpenCloseBuildingInfoPanel(false);
SpaceportInfoPanel.instance.DisplayPanel(false);
EnemiesManager.instance.DeselectEnemy();
PlanetaryShieldControlPanel.instance.DisplayPanel(false);
CollectorControlPanel.instance.DisplayPanel(false);
InfrastructureManager.instance.DeselectBuilding();
break;
}
}
}
else
{
}
}
/// <summary>
/// Does the state transition.
/// </summary>
/// <param name="state">State.</param>
/// <param name="instant">If set to <c>true</c> instant.</param>
protected override void DoStateTransition(SelectionState state, bool instant)
{
base.DoStateTransition(state, instant);
// Check the state which we are transitioning to
if (state == SelectionState.Normal || state == SelectionState.Highlighted)
{
// Save the state
this.m_IsHighlighted = (state == SelectionState.Highlighted);
// Transition the image
if (this.m_Image != null)
{
switch (state)
{
case SelectionState.Normal:
this.m_Image.overrideSprite = (this.isOn ? this.m_ActiveSprite : null);
break;
case SelectionState.Highlighted:
this.m_Image.overrideSprite = (this.isOn ? this.m_ActiveSprite : this.m_HoverSprite);
break;
}
}
// Transition the title text
if (this.m_TitleText != null)
{
Color tColor = (!this.m_IsClosed) ? this.m_TitleNormalColor : this.m_TitleClosedColor;
if (this.m_IsHighlighted)
{
tColor = new Color(
Mathf.Clamp((tColor.r * this.m_HighlighColorMultiplier), 0f, 1f),
Mathf.Clamp((tColor.g * this.m_HighlighColorMultiplier), 0f, 1f),
Mathf.Clamp((tColor.b * this.m_HighlighColorMultiplier), 0f, 1f),
Mathf.Clamp((tColor.a * this.m_HighlighColorMultiplier), 0f, 1f)
);
}
this.m_TitleText.canvasRenderer.SetColor(tColor);
}
// Transition the closed text
if (this.m_ClosedText != null)
{
Color cColor = this.m_ClosedNormalColor;
if (this.m_IsHighlighted)
{
cColor = new Color(
Mathf.Clamp((cColor.r * this.m_HighlighColorMultiplier), 0f, 1f),
Mathf.Clamp((cColor.g * this.m_HighlighColorMultiplier), 0f, 1f),
Mathf.Clamp((cColor.b * this.m_HighlighColorMultiplier), 0f, 1f),
Mathf.Clamp((cColor.a * this.m_HighlighColorMultiplier), 0f, 1f)
);
}
this.m_ClosedText.canvasRenderer.SetColor(cColor);
}
// Transition the rest
this.ApplyStatusState();
this.ApplyPopulationState();
this.ApplyCharactersCountState();
}
}
/// <summary>
/// Transition the Selectable to the entered state.
/// </summary>
/// <param name="state">State to transition to</param>
/// <param name="instant">Should the transition occur instantly.</param>
protected virtual void DoStateTransition(SelectionState state, bool instant)
{
if (!gameObject.activeInHierarchy)
{
return;
}
Color tintColor;
Sprite transitionSprite;
string triggerName;
switch (state)
{
case SelectionState.Normal:
tintColor = m_Colors.normalColor;
transitionSprite = null;
triggerName = m_AnimationTriggers.normalTrigger;
break;
case SelectionState.Highlighted:
tintColor = m_Colors.highlightedColor;
transitionSprite = m_SpriteState.highlightedSprite;
triggerName = m_AnimationTriggers.highlightedTrigger;
break;
case SelectionState.Pressed:
tintColor = m_Colors.pressedColor;
transitionSprite = m_SpriteState.pressedSprite;
triggerName = m_AnimationTriggers.pressedTrigger;
break;
case SelectionState.Selected:
tintColor = m_Colors.selectedColor;
transitionSprite = m_SpriteState.selectedSprite;
triggerName = m_AnimationTriggers.selectedTrigger;
break;
case SelectionState.Disabled:
tintColor = m_Colors.disabledColor;
transitionSprite = m_SpriteState.disabledSprite;
triggerName = m_AnimationTriggers.disabledTrigger;
break;
default:
tintColor = Color.black;
transitionSprite = null;
triggerName = string.Empty;
break;
}
switch (m_Transition)
{
case Transition.ColorTint:
StartColorTween(tintColor * m_Colors.colorMultiplier, instant);
break;
case Transition.SpriteSwap:
DoSpriteSwap(transitionSprite);
break;
case Transition.Animation:
TriggerAnimation(triggerName);
break;
}
}
// The current visual state of the control.
protected void UpdateSelectionState(BaseEventData eventData)
{
if (IsPressed())
{
m_CurrentSelectionState = SelectionState.Pressed;
return;
}
if (IsHighlighted(eventData))
{
m_CurrentSelectionState = SelectionState.Highlighted;
return;
}
m_CurrentSelectionState = SelectionState.Normal;
}
void FixedUpdate()
{
if (mLastSelectionState != SelectionState.Pressed && currentSelectionState == SelectionState.Pressed)
{
//Debug.Log(string.Format("按下 {0}, {1}", gameObject.name, Time.frameCount));
// 按下
if (onButtonDown != null)
{
foreach (ButtonDownEvent d in onButtonDown.GetInvocationList())
{
try
{
d.Invoke();
}
catch (Exception e)
{
Debug.LogException(e);
}
}
}
}
if (mLastSelectionState == SelectionState.Pressed && currentSelectionState != SelectionState.Pressed)
{
//Debug.Log(string.Format("弹起 {0}, {1}", gameObject.name, Time.frameCount));
// 弹起
if (onButtonUp != null)
{
foreach (ButtonUpEvent d in onButtonUp.GetInvocationList())
{
try
{
d.Invoke();
}
catch (Exception e)
{
Debug.LogException(e);
}
}
}
}
if (mLastSelectionState == SelectionState.Pressed && currentSelectionState == SelectionState.Pressed)
{
//Debug.Log(string.Format("按住 {0}, {1}", gameObject.name, Time.frameCount));
// 按住
if (onButtonPress != null)
{
foreach (ButtonPressEvent d in onButtonPress.GetInvocationList())
{
try
{
d.Invoke();
}
catch (Exception e)
{
Debug.LogException(e);
}
}
}
}
mLastSelectionState = currentSelectionState;
}
void UpdateCaretPropertiesCore(bool forceInvalidateVisual) {
if (layer.HexView.IsClosed)
return;
StopTimer();
var line = hexCaret.ContainingHexViewLine;
oldSelectionState = new SelectionState(layer.HexView.Selection);
bool oldDrawCaretShape = drawCaretShape;
drawCaretShape = line.VisibilityState != VSTF.VisibilityState.Unattached;
bool drawOverwriteMode = OverwriteMode;
var valuesCaretRect = GetCaretRect(line, drawOverwriteMode, HexColumnType.Values, line.BufferLine.ValueCells.GetCell(hexCaret.CurrentPosition.ValuePosition.BufferPosition), hexCaret.CurrentPosition.ValuePosition.CellPosition);
var asciiCaretRect = GetCaretRect(line, drawOverwriteMode, HexColumnType.Ascii, line.BufferLine.AsciiCells.GetCell(hexCaret.CurrentPosition.AsciiPosition.BufferPosition), hexCaret.CurrentPosition.AsciiPosition.CellPosition);
if (drawCaretShape) {
if (!imeStarted && layer.HexView.VisualElement.IsKeyboardFocused && layer.HexView.VisualElement.IsVisible)
StartTimer();
}
else
layer.Opacity = 0;
var invalidateVisual = valuesCaretGeometry.SetProperties(valuesCaretRect, drawCaretShape, drawOverwriteMode);
invalidateVisual |= asciiCaretGeometry.SetProperties(asciiCaretRect, drawCaretShape, drawOverwriteMode);
invalidateVisual |= forceInvalidateVisual || oldDrawCaretShape != drawCaretShape;
if (invalidateVisual)
InvalidateVisual();
}
//called when setting a new target
public void setTarget (GameObject _target)
{
//if the current target has a troct, reset it
if (target.GetComponent<TruncOct>())
{
target.GetComponent<TruncOct>().ReturnToTypeColour();
}
_target.GetComponent<TruncOct>().interior.gameObject.SetActive(true);
_target.GetComponent<TruncOct>().interior.GetComponent<MeshRenderer>().material.color = Color.cyan;
target = _target;
//set nearPlane as the distance to the target
GetComponent<Camera>().nearClipPlane = (float)(Vector3.Distance(transform.position, _target.transform.position) - 2.125);
//set state to troctSelected
selectState = SelectionState.TrOctSelected;
}
protected override void DoStateTransition(SelectionState state, bool instant)
{
_pMethodInfo_DoStateTransition?.Invoke(pButton, new object[] { state, instant });
// pButton.SendMessage(nameof(DoStateTransition), new object[] {state, instant});
}
public object Convert(object value, System.Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
SelectionState state = (SelectionState)value;
return(state == SelectionState.Focused ? FocusedBrush : NormalBrush);
}
/// <summary>
/// Determines what happens when the troct is clicked.
/// </summary>
/// <param name="_troctHit">_troct hit.</param>
private void ClickTroct(GameObject _troctHit)
{
switch (selectState)
{
case SelectionState.Rotate:
if (_troctHit.GetComponent<TruncOct>().IsNextTo(selectedActor.GetComponent<ActorBase>().currentTrOct))
{
selectedActor.GetComponent<ActorBase>().TryRotate(_troctHit.transform);
selectState = SelectionState.ActorSelected;
}
break;
case SelectionState.PlanRoute:
//selectedActor.GetComponent<ActorBase>().currentPath = tentPath;
break;
default: //if not planning route or rotating, just select the troct as normal
if (_troctHit.GetComponent<TruncOct> ())
{
setTarget (_troctHit);
}
break;
}
}
protected override void DoStateTransition(SelectionState state, bool instant)
{
// Override base transition method as it doesn't apply, and assign state color manually
SetHandleColor();
}
/// <summary>
/// Selects the actor inside the current target trOct. Called by a function in GUIManager
/// </summary>
public GameObject SelectActor()
{
//tell the slection logic that is has selected an actor
selectState = SelectionState.ActorSelected;
selectedActor = target.GetComponent<TruncOct> ().containedActor;
return selectedActor;
}
void GoToNextState()
{
selectionState = nextState;
InitializeState(selectionState);
}
/// <summary>
/// make use of event tunneling for selecting items when a click event occurred in a child element
/// </summary>
/// <remarks>http://joshsmithonwpf.wordpress.com/2007/06/22/overview-of-routed-events-in-wpf/</remarks>
// 1 //
private void List_PreviewButtonDownEvent(object sender, MouseButtonEventArgs e)
{
_currentSelectionState = new SelectionState();
_currentSelectionState.PreviewedEvent = e;
}
void GoToPreviousState()
{
selectionState = previousState;
InitializeState(selectionState);
}
protected override void OnMouseUp(object sender, MouseEventArgs e)
{
if (State == SelectionState.Dragging && posChange != null)
{
Editor.History.Add(posChange);
posChange = null;
}
if (State == SelectionState.Shaping && currentPoint != shapeData.startPoint)
{
var translation = new TranslationChange(SelectedElement, SelectedElement.Location - shapeData.initialPoint);
var scale = new PropertyChange(SelectedElement, "Scale", SelectedElement.Scale, shapeData.initialScale);
var rotation = new PropertyChange(SelectedElement, "BaseRotation", SelectedElement.BaseRotation, shapeData.initialRotation);
Editor.History.Add(new CompoundChange(new IChange[] { translation, scale, rotation }));
}
State = SelectionState.Idle;
Editor.Invalidate();
}
/// <summary>
/// Does the state transition.
/// </summary>
/// <param name="state">State.</param>
/// <param name="instant">If set to <c>true</c> instant.</param>
protected override void DoStateTransition(SelectionState state, bool instant)
{
if (!this.enabled || !this.enabled || !this.gameObject.activeInHierarchy || this.selectField == null)
{
return;
}
Color color = this.selectField.optionBackgroundTransColors.normalColor;
Sprite newSprite = null;
string triggername = this.selectField.optionBackgroundAnimationTriggers.normalTrigger;
// Check if this is the disabled state before any others
if (state == Selectable.SelectionState.Disabled)
{
color = this.selectField.optionBackgroundTransColors.disabledColor;
newSprite = this.selectField.optionBackgroundSpriteStates.disabledSprite;
triggername = this.selectField.optionBackgroundAnimationTriggers.disabledTrigger;
}
else
{
// Prepare the state values
switch (state)
{
case Selectable.SelectionState.Normal:
color = (this.isOn) ? this.selectField.optionBackgroundTransColors.activeColor : this.selectField.optionBackgroundTransColors.normalColor;
newSprite = (this.isOn) ? this.selectField.optionBackgroundSpriteStates.activeSprite : null;
triggername = (this.isOn) ? this.selectField.optionBackgroundAnimationTriggers.activeTrigger : this.selectField.optionBackgroundAnimationTriggers.normalTrigger;
break;
case Selectable.SelectionState.Highlighted:
color = (this.isOn) ? this.selectField.optionBackgroundTransColors.activeHighlightedColor : this.selectField.optionBackgroundTransColors.highlightedColor;
newSprite = (this.isOn) ? this.selectField.optionBackgroundSpriteStates.activeHighlightedSprite : this.selectField.optionBackgroundSpriteStates.highlightedSprite;
triggername = (this.isOn) ? this.selectField.optionBackgroundAnimationTriggers.activeHighlightedTrigger : this.selectField.optionBackgroundAnimationTriggers.highlightedTrigger;
break;
case Selectable.SelectionState.Pressed:
color = (this.isOn) ? this.selectField.optionBackgroundTransColors.activePressedColor : this.selectField.optionBackgroundTransColors.pressedColor;
newSprite = (this.isOn) ? this.selectField.optionBackgroundSpriteStates.activePressedSprite : this.selectField.optionBackgroundSpriteStates.pressedSprite;
triggername = (this.isOn) ? this.selectField.optionBackgroundAnimationTriggers.activePressedTrigger : this.selectField.optionBackgroundAnimationTriggers.pressedTrigger;
break;
}
}
// Do the transition
switch (this.selectField.optionBackgroundTransitionType)
{
case Transition.ColorTint:
this.StartColorTween(color * this.selectField.optionBackgroundTransColors.colorMultiplier, (instant ? 0f : this.selectField.optionBackgroundTransColors.fadeDuration));
break;
case Transition.SpriteSwap:
this.DoSpriteSwap(newSprite);
break;
case Transition.Animation:
this.TriggerAnimation(triggername);
break;
}
// Do the transition of the text component
this.DoTextStateTransition(state, instant);
}
public bool Equals(SelectionState other) => state == other.state;
protected override void DoStateTransition(SelectionState state, bool instant)
{
base.DoStateTransition(state, instant);
_stateChangedCallback?.Invoke(GetState());
}
protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
{
base.OnMouseLeftButtonDown(e);
var position = e.GetPosition(this);
selectionStart = new Point((int) (position.X / CharWidth + 0.5), (int) (position.Y / CharHeight + VerticalOffset));
selectionEnd = selectionStart;
selectionState = SelectionState.Selecting;
foreach (var visual in visuals)
visual.Select(0, 0);
CaptureMouse();
}
protected override void DoStateTransition(SelectionState state, bool instant)
{
//if (forceNoInteraction)
// return;
if (stateInitialized && currentState == state)
{
return;
}
stateInitialized = true;
currentState = state;
if (state == SelectionState.Pressed)
{
StopAllCoroutines();
if (gameObject.activeInHierarchy)
{
StartCoroutine(TweenColorFromCurrent(this.colors.pressedColor, this.colors.fadeDuration));
}
else
{
InstantColorFromCurrent(this.colors.pressedColor);
}
}
else if (state == SelectionState.Highlighted)
{
//StopAllCoroutines();
if (gameObject.activeInHierarchy)
{
StartCoroutine(TweenColorFromCurrent(this.colors.highlightedColor, this.colors.fadeDuration));
}
else
{
InstantColorFromCurrent(this.colors.highlightedColor);
}
}
else if (state == SelectionState.Normal)
{
_setInteractable(true);
StopAllCoroutines();
InstantColorFromCurrent(this.colors.normalColor);
if (gameObject.activeInHierarchy)
{
StartCoroutine(TweenColorFromCurrent(this.colors.normalColor, this.colors.fadeDuration));
}
else
{
InstantColorFromCurrent(this.colors.normalColor);
}
}
else if (state == SelectionState.Disabled)
{
StopAllCoroutines();
_setInteractable(false);
}
else
{
if (gameObject.activeInHierarchy)
{
StartCoroutine(TweenColorFromCurrent(this.colors.selectedColor, this.colors.fadeDuration));
}
else
{
InstantColorFromCurrent(this.colors.selectedColor);
}
}
}
public void OnSelectionChanged(SelectionState state, Point point)
{
selectionState = state;
switch (state)
{
case SelectionState.Start:
selectStart = point;
ui.Remove(selectableHex);
break;
case SelectionState.During:
DuringSelect(point);
break;
case SelectionState.End:
EndSelect(true);
break;
}
}
public void OnDrag(Vector2 delta){
if (selectionState == SelectionState.Cancelled || selectionState == SelectionState.Completed || selectionState == SelectionState.WrongCompleted)
return;
if (selectionState == SelectionState.Pressed) {
selectionState = SelectionState.Dragging;
if(myLine!=null){
//followPoints.Clear();
VectorLine.Destroy(ref myLine);
}
}
Vector3 worldPoint = UICamera.lastWorldPosition;
worldPoint.z = transform.position.z;
Vector2 previousPoint = Vector2.zero;
if (!newWayStarted || (newWayStarted && mState == FestivalUserState.FollowingDirection)) {
previousPoint = transform.position;
}
else if (newWayStarted && mState == FestivalUserState.FollowingPoints) {
previousPoint = followPoints [followPoints.Count - 1];
}
if (UserController.instance.detectorEnabled) {
UserController.instance.SetPosition(worldPoint);
}
if (Vector2.Distance ((Vector2)worldPoint, previousPoint) > minWaypointDistance) {
//Check collisions first...
// RaycastHit2D hit = Physics2D.Raycast (previousPoint,
// ((Vector2)worldPoint - previousPoint).normalized, 30.0F);
//
// Debug.DrawLine(previousPoint,previousPoint + (((Vector2)worldPoint - previousPoint).normalized * 30.0F),Color.red);
//
// if(hit.collider != null){
// if (hit.collider.tag == "no_walkable") {
// Debug.Log("Way cancelled");
// selectionState = SelectionState.Cancelled;
//
// return;
// }
//
// if (hit.collider.tag == "targetZone") {
//
// Debug.Log("target assigned");
//
// if(hit.collider.gameObject.GetComponent<TargetZone>().type == _Data.userType){
// selectionState = SelectionState.Completed;
// }
// else{
// selectionState = SelectionState.WrongCompleted;
// }
//
// return;
// }
// }
if(UserController.instance.detector.collisionType == DetectCollision.CollisionType.Wall){
selectionState = SelectionState.Cancelled;
UserController.instance.DisableDetector();
return;
}
else if(UserController.instance.detector.collisionType == DetectCollision.CollisionType.Target){
if(UserController.instance.detector.lastObject == null){
Debug.LogWarning("Error: Se ha detectado un target pero no hay objeto vinculado...");
}
if(UserController.instance.detector.lastObject.GetComponent<TargetZone>().type == _Data.userType){
selectionState = SelectionState.Completed;
}
else selectionState = SelectionState.WrongCompleted;
UserController.instance.DisableDetector();
return;
}
bool initLine = false;
if(!newWayStarted){
UserController.instance.EnableDetector();
UserController.instance.SetPosition(transform.position);
followPoints.Clear();
initLine = true;
newWayStarted = true;
currentPoint = 0;
followPoints.Add(transform.position);
if(mState == FestivalUserState.FollowingDirection){
mState = FestivalUserState.FollowingPoints;
}
}
if(newWayStarted && mState == FestivalUserState.FollowingDirection){
followPoints.Clear();
mState = FestivalUserState.FollowingPoints;
followPoints.Add(transform.position);
currentPoint = 0;
}
//Add new point
Vector3 addPoint = UICamera.lastWorldPosition;
addPoint.z = transform.position.z;
followPoints.Add(addPoint);
if(initLine){
InitLine();
}
}
}
public void Update(GameTime gameTime)
{
// Selecting a character.
if (selectState == SelectionState.User)
{
if (input.alliedCharacter1)
{
selectedUser = leftParty.characters[0];
}
else if (input.alliedCharacter2)
{
selectedUser = leftParty.characters[1];
}
else if (input.alliedCharacter3)
{
selectedUser = leftParty.characters[2];
}
else if (input.alliedCharacter4)
{
selectedUser = leftParty.characters[3];
}
if (selectedUser != null)
{
selectState = SelectionState.Skill;
}
}
// Selecting an action for a character.
if (selectState == SelectionState.Skill)
{
if (input.alliedCharacter1)
{
selectedUser = leftParty.characters[0];
}
else if (input.alliedCharacter2)
{
selectedUser = leftParty.characters[1];
}
else if (input.alliedCharacter3)
{
selectedUser = leftParty.characters[2];
}
else if (input.alliedCharacter4)
{
selectedUser = leftParty.characters[3];
}
if (input.skill1)
{
selectedSkill = selectedUser.skills[0];
}
else if (input.skill2)
{
selectedSkill = selectedUser.skills[1];
}
else if (input.skill3)
{
selectedSkill = selectedUser.skills[2];
}
else if (input.skill4)
{
selectedSkill = selectedUser.skills[3];
}
if (selectedUser == null)
{
selectState = SelectionState.User;
}
else if (selectedSkill != null)
{
selectState = SelectionState.Target;
}
}
// Selecting the target of said action.
if (selectState == SelectionState.Target)
{
if (input.skill1)
{
selectedSkill = selectedUser.skills[0];
}
else if (input.skill2)
{
selectedSkill = selectedUser.skills[1];
}
else if (input.skill3)
{
selectedSkill = selectedUser.skills[2];
}
else if (input.skill4)
{
selectedSkill = selectedUser.skills[3];
}
if (input.enemyCharacter1)
{
selectedTarget = rightParty.characters[0];
}
else if (input.enemyCharacter2)
{
selectedTarget = rightParty.characters[1];
}
else if (input.enemyCharacter3)
{
selectedTarget = rightParty.characters[2];
}
else if (input.enemyCharacter4)
{
selectedTarget = rightParty.characters[3];
}
else if (input.alliedCharacter1)
{
selectedTarget = leftParty.characters[0];
}
else if (input.alliedCharacter2)
{
selectedTarget = leftParty.characters[1];
}
else if (input.alliedCharacter3)
{
selectedTarget = leftParty.characters[2];
}
else if (input.alliedCharacter4)
{
selectedTarget = leftParty.characters[3];
}
if (selectedSkill == null)
{
selectState = SelectionState.Skill;
}
else if (selectedTarget != null)
{
selectedSkill.target = selectedTarget;
for (int skillNum = 0; skillNum < skills.Length; skillNum++)
{
if (skills[skillNum] != null)
{
continue;
}
skills[skillNum] = selectedSkill;
break;
}
selectedUser = null;
selectedSkill = null;
selectedTarget = null;
selectState = SelectionState.User;
}
}
for (int skillNum = 0; skillNum < skills.Length; skillNum++)
{
if (skills[skillNum] == null)
{
break;
}
skills[skillNum].Cast();
skills[skillNum] = null;
}
leftParty.Update(gameTime);
rightParty.Update(gameTime);
}
// Select on enable and add to the list.
protected override void OnEnable()
{
base.OnEnable();
s_List.Add(this);
var state = SelectionState.Normal;
// The button will be highlighted even in some cases where it shouldn't.
// For example: We only want to set the State as Highlighted if the StandaloneInputModule.m_CurrentInputMode == InputMode.Buttons
// But we dont have access to this, and it might not apply to other InputModules.
// TODO: figure out how to solve this. Case 617348.
if (hasSelection)
state = SelectionState.Highlighted;
m_CurrentSelectionState = state;
InternalEvaluateAndTransitionToSelectionState(true);
}
public void OnPress(bool pressed){
Debug.Log("Pressed " + pressed.ToString());
if (!pressed){
if(selectionState != SelectionState.Cancelled &&
selectionState != SelectionState.Completed &&
selectionState != SelectionState.WrongCompleted){
OnRelease ();
}
}
else {
selectionState = SelectionState.Pressed;
newWayStarted = false;
}
}
public void SetDeselected()
{
currentSelTarget = SelectionState.DESELECTED;
HSrndr.enabled = false;
StopAllCoroutines();
}
public void OnRelease(){
selectionState = SelectionState.Released;
Debug.Log ("On Release");
}
private List <IPlayerSelectableObject> GetObjects(List <IPlayerSelectableObject> outList, SelectionState state)
{
outList.Clear();
foreach (ISelectableObjectContainer selectableObjectContainer in selectableObjectcontainers)
{
selectableObjectContainer.GetPlayerSelectableObjects(outList, state);
}
return(outList);
}
