public void Update()
{
HoverOver hoverOver = HoverManager.main.getHoverOver();
if (gameMode != GameMode.PlaceBuilding)
{
if (hoverOver == HoverOver.UI)
{
gameMode = GameMode.Menu;
}
else
{
gameMode = GameMode.Normal;
}
}
switch (gameMode)
{
case GameMode.Normal:
GameMode_NormalUpdate();
break;
case GameMode.Menu:
GameMode_MenuUpdate();
break;
case GameMode.PlaceBuilding:
GameMode_PlaceBuilding();
break;
}
//Update Cursors
switch (interactionMode)
{
case InteractionMode.Nothing:
CursorManager.main.ChangeCursor(CursorID.Normal);
break;
case InteractionMode.Select:
CursorManager.main.ChangeCursor(CursorID.Selectable);
break;
case InteractionMode.Move:
CursorManager.main.ChangeCursor(CursorID.Moveable);
break;
case InteractionMode.Attack:
CursorManager.main.ChangeCursor(CursorID.Attackable);
break;
case InteractionMode.Build:
CursorManager.main.ChangeCursor(CursorID.Build);
break;
}
}
private void CalculateInteraction(HoverOver hoveringOver, ref InteractionState interactionState)
{
switch (hoveringOver)
{
case HoverOver.Menu:
case HoverOver.Land:
//Normal Interaction
interactionState = InteractionState.Nothing;
break;
case HoverOver.FriendlyBuilding:
//Select interaction
interactionState = InteractionState.Select;
//Unless a support item is selected
if (m_GuiManager.GetSupportSelected == Const.MAINTENANCE_Sell)
{
//Sell
if (currentObject.GetComponent <Building>().CanSell())
{
interactionState = InteractionState.Sell;
}
else
{
interactionState = InteractionState.CantSell;
}
}
else if (m_GuiManager.GetSupportSelected == Const.MAINTENANCE_Fix)
{
//Fix
if (currentObject.GetComponent <Building>().GetHealthRatio() < 1)
{
interactionState = InteractionState.Fix;
}
else
{
interactionState = InteractionState.CantFix;
}
}
else if (m_GuiManager.GetSupportSelected == Const.MAINTENANCE_Disable)
{
//Disable
}
break;
case HoverOver.FriendlyUnit:
case HoverOver.EnemyUnit:
case HoverOver.EnemyBuilding:
//Select Interaction
interactionState = InteractionState.Select;
break;
}
}
private void CalculateInteraction(List <IOrderable> list, HoverOver hoveringOver, ref InteractionState interactionState)
{
foreach (IOrderable obj in list)
{
if (obj.ShouldInteract(hoveringOver))
{
CalculateInteraction(obj, hoveringOver, ref interactionState);
return;
}
}
CalculateInteraction(hoveringOver, ref interactionState);
}
public void Init (CardDescriptor card, int index)
{
this.Inject ();
hoverOver = GetComponent<HoverOver> ();
hoverOver.Reset (hoverEnabled: true);
Card = card;
Index = index;
_cardDescription = transform.FindChild ("Card Description");
transform.FindChild ("Text").GetComponent<Text> ().text = Card.Name;
transform.FindChild ("Image").GetComponent<Image> ().sprite = cardAssetsProvider.GetSpriteFromPath (Card.CardImage);
RemoveOldIcons ();
AddCardAttributeIcons (Card.CardAttributes);
}
public bool ShouldInteract(HoverOver hoveringOver)
{
switch (hoveringOver)
{
case HoverOver.Land:
return(m_IsMoveable);
case HoverOver.EnemyBuilding:
case HoverOver.EnemyUnit:
return(m_IsAttackable);
case HoverOver.FriendlyUnit:
return(m_IsDeployable && ManagerResolver.Resolve <IUIManager>().IsCurrentUnit(this));
default:
return(false);
}
}
public bool ShouldInteract(HoverOver hoveringOver)
{
switch (hoveringOver) {
case HoverOver.Land:
return m_IsMoveable;
case HoverOver.EnemyBuilding:
case HoverOver.EnemyUnit:
return m_IsAttackable;
case HoverOver.FriendlyUnit:
return m_IsDeployable && ManagerResolver.Resolve<IUIManager>().IsCurrentUnit (this);
default:
return false;
}
}
private void ModeNormalBehaviour()
{
//Handle all non event, and non gui UI elements here
hoverOver = HoverOver.Land;
InteractionState interactionState = InteractionState.Nothing;
//Are we hovering over the GUI or the main screen?
if (Input.mousePosition.x < Screen.width-m_GuiWidth)
{
//We're over the main screen, let's raycast
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast (ray, out hit, Mathf.Infinity, ~(1 << 16)))
{
currentObject = hit.collider.gameObject;
switch (currentObject.layer)
{
case 8:
case 9:
if (currentObject.layer == primaryPlayer.controlledLayer)
{
hoverOver = HoverOver.FriendlyUnit;
}
else
{
hoverOver = HoverOver.EnemyUnit;
}
break;
case 11:
case 17:
//Terrain or shroud
hoverOver = HoverOver.Land;
break;
case 12:
//Friendly Building
hoverOver = HoverOver.FriendlyBuilding;
break;
case 13:
//Enemy building
hoverOver = HoverOver.EnemyBuilding;
break;
}
}
}
else
{
//Mouse is over GUI
hoverOver = HoverOver.Menu;
}
if (hoverOver == HoverOver.Menu || m_SelectedManager.ActiveObjectsCount() == 0 || m_GuiManager.GetSupportSelected != 0)
{
//Nothing orderable Selected or mouse is over menu or support is selected
CalculateInteraction (hoverOver, ref interactionState);
}
else if (m_SelectedManager.ActiveObjectsCount() == 1)
{
//One object selected
CalculateInteraction (m_SelectedManager.FirstActiveObject(), hoverOver, ref interactionState);
}
else
{
//Multiple objects selected, need to find which order takes precedence
CalculateInteraction (m_SelectedManager.ActiveObjectList(), hoverOver, ref interactionState);
}
//Tell the cursor manager to update itself based on the interactionstate
CursorManager.main.UpdateCursor (interactionState);
}
// TODO:
// Break the loop and return the desired interaction
private void CalculateInteraction(List<IOrderable> list, HoverOver hoveringOver, ref InteractionState interactionState)
{
foreach (IOrderable obj in list)
{
bool ShouldInterractB = obj.ShouldInteract(hoveringOver);
if (ShouldInterractB)
{
if (hoveringOver == HoverOver.EnemyUnit)
{
CalculateInteraction(obj, hoveringOver, ref interactionState);
return;
}
}
}
CalculateInteraction (hoveringOver, ref interactionState);
}
private void CalculateInteraction(IOrderable obj, HoverOver hoveringOver, ref InteractionState interactionState)
{
if (obj.IsAttackable())
{
if (hoverOver == HoverOver.EnemyUnit || hoverOver == HoverOver.EnemyBuilding)
{
//Attack Interaction
interactionState = InteractionState.Attack;
return;
}
}
if (obj.IsDeployable())
{
if (((RTSObject)obj).gameObject.Equals (currentObject))
{
//Deploy Interaction
interactionState = InteractionState.Deploy;
return;
}
}
if (obj.IsInteractable ())
{
if (hoverOver == HoverOver.FriendlyUnit)
{
//Check if object can interact with unit (carry all for example)
if (((IInteractable)obj).InteractWith(currentObject))
{
//Interact Interaction
interactionState = InteractionState.Interact;
return;
}
}
}
if (obj.IsMoveable())
{
if (hoverOver == HoverOver.Land)
{
//Move Interaction
interactionState = InteractionState.Move;
return;
}
}
if (hoverOver == HoverOver.FriendlyBuilding)
{
//Check if building can interact with object (repair building for example)
if (currentObject.GetComponent<Building>().InteractWith (obj))
{
//Interact Interaction
interactionState = InteractionState.Interact;
return;
}
}
if (hoverOver == HoverOver.FriendlyUnit || hoverOver == HoverOver.FriendlyBuilding || hoverOver == HoverOver.EnemyUnit || hoverOver == HoverOver.EnemyBuilding)
{
//Select Interaction
interactionState = InteractionState.Select;
return;
}
//Invalid interaction
interactionState = InteractionState.Invalid;
}
private void CalculateInteraction(HoverOver hoveringOver, ref InteractionState interactionState)
{
switch (hoveringOver)
{
case HoverOver.Menu:
case HoverOver.Land:
//Normal Interaction
interactionState = InteractionState.Nothing;
break;
case HoverOver.FriendlyBuilding:
//Select interaction
interactionState = InteractionState.Select;
//Unless a support item is selected
if (m_GuiManager.GetSupportSelected == Const.MAINTENANCE_Sell)
{
//Sell
if (currentObject.GetComponent<Building>().CanSell ())
{
interactionState = InteractionState.Sell;
}
else
{
interactionState = InteractionState.CantSell;
}
}
else if (m_GuiManager.GetSupportSelected == Const.MAINTENANCE_Fix)
{
//Fix
if (currentObject.GetComponent<Building>().GetHealthRatio () < 1)
{
interactionState = InteractionState.Fix;
}
else
{
interactionState = InteractionState.CantFix;
}
}
else if (m_GuiManager.GetSupportSelected == Const.MAINTENANCE_Disable)
{
//Disable
}
break;
case HoverOver.FriendlyUnit:
case HoverOver.EnemyUnit:
case HoverOver.EnemyBuilding:
interactionState = InteractionState.Select;
break;
}
}
private void ModeNormalBehaviour()
{
//Handle all non event, and non gui UI elements here
hoverOver = HoverOver.Land;
InteractionState interactionState = InteractionState.Nothing;
//Are we hovering over the GUI or the main screen?
if (Input.mousePosition.x < Screen.width - m_GuiWidth)
{
//We're over the main screen, let's raycast
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, Mathf.Infinity, ~(1 << 16)))
{
currentObject = hit.collider.gameObject;
switch (hit.collider.gameObject.layer)
{
case 8:
//Friendly unit
hoverOver = HoverOver.FriendlyUnit;
break;
case 9:
//Enemy Unit
hoverOver = HoverOver.EnemyUnit;
break;
case 11:
case 17:
//Terrain or shroud
hoverOver = HoverOver.Land;
break;
case 12:
//Friendly Building
hoverOver = HoverOver.FriendlyBuilding;
break;
case 13:
//Enemy building
hoverOver = HoverOver.EnemyBuilding;
break;
}
}
}
else
{
//Mouse is over GUI
hoverOver = HoverOver.Menu;
}
if (hoverOver == HoverOver.Menu || m_SelectedManager.ActiveObjectsCount() == 0 || m_GuiManager.GetSupportSelected != 0)
{
//Nothing orderable Selected or mouse is over menu or support is selected
CalculateInteraction(hoverOver, ref interactionState);
}
else if (m_SelectedManager.ActiveObjectsCount() == 1)
{
//One object selected
CalculateInteraction(m_SelectedManager.FirstActiveObject(), hoverOver, ref interactionState);
}
else
{
//Multiple objects selected, need to find which order takes precedence
CalculateInteraction(m_SelectedManager.ActiveObjectList(), hoverOver, ref interactionState);
}
//Tell the cursor manager to update itself based on the interactionstate
CursorManager.main.UpdateCursor(interactionState);
}
private void CalculateInteraction(IOrderable obj, HoverOver hoveringOver, ref InteractionState interactionState)
{
if (obj.IsAttackable())
{
if (hoverOver == HoverOver.EnemyUnit || hoverOver == HoverOver.EnemyBuilding)
{
//Attack Interaction
interactionState = InteractionState.Attack;
return;
}
}
if (obj.IsDeployable())
{
if (((RTSObject)obj).gameObject.Equals(currentObject))
{
//Deploy Interaction
interactionState = InteractionState.Deploy;
return;
}
}
if (obj.IsInteractable())
{
if (hoverOver == HoverOver.FriendlyUnit)
{
//Check if object can interact with unit (carry all for example)
if (((IInteractable)obj).InteractWith(currentObject))
{
//Interact Interaction
interactionState = InteractionState.Interact;
return;
}
}
}
if (obj.IsMoveable())
{
if (hoverOver == HoverOver.Land)
{
//Move Interaction
interactionState = InteractionState.Move;
return;
}
}
if (hoverOver == HoverOver.FriendlyBuilding)
{
//Check if building can interact with object (repair building for example)
if (currentObject.GetComponent <Building>().InteractWith(obj))
{
//Interact Interaction
interactionState = InteractionState.Interact;
return;
}
}
if (hoverOver == HoverOver.FriendlyUnit || hoverOver == HoverOver.FriendlyBuilding || hoverOver == HoverOver.EnemyUnit || hoverOver == HoverOver.EnemyBuilding)
{
//Select Interaction
interactionState = InteractionState.Select;
return;
}
//Invalid interaction
interactionState = InteractionState.Invalid;
}
public override void DrawSeriesAndAxis(FivePointNine.Windows.Graphics.Graphics2 g)
{
if (dsCollection == null)
{
return;
}
string YUnit = dsCollection[0].YUnits.Name;
string unit = dsCollection[0].YUnits.Unit;
bool noUnit = false;
for (int i = 1; i < dsCollection.Count; i++)
{
if (!dsCollection[i].Enabled)
{
continue;
}
if (unit != dsCollection[i].YUnits.Unit)
{
noUnit = true;
break;
}
if (!YUnit.Contains(dsCollection[i].YUnits.Name))
{
YUnit += ", " + dsCollection[i].YUnits.Name;
}
}
if (noUnit)
{
YUnit = "Error -- Incompatible units";
}
else
{
YUnit += " (" + dsCollection[0].YUnits.Unit + ")";
}
var yLabelSz = g.MeasureString(YUnit, Font);
var xLabelSz = g.MeasureString(XUnit, Font);
YLabelWidth = yLabelSz.Height * 2;
XLabelHeight = xLabelSz.Height * 2;
g.Clip = new Region(DrawPlotArea);
g.DrawString(YUnit, Font, Color.Black, Width - YLabelWidth / 2 * 1.5F, (Height - XLabelHeight) / 2 + yLabelSz.Width / 2, -90);
g.DrawString(XUnit, Font, Color.Black, (Width - YLabelWidth) / 2, Height - XLabelHeight * 1.5F / 2.0F);
g.SmoothingMode = SmoothingMode.AntiAlias;
foreach (var DataSeries in dsCollection.SeriesList)
{
if (DataSeries != null)
{
if (DataSeries.Enabled)
{
if (DataSeries != HoverOver)
{
DataSeries.Draw(g, (int)DrawPlotArea.Width, (int)(Height - XLabelHeight), xOffsetG, yOffsetG, XPPU, YPPU, false);
}
}
}
}
if (HoverOver != null)
{
HoverOver.Draw(g, (int)DrawPlotArea.Width, (int)DrawPlotArea.Height, xOffsetG, yOffsetG, XPPU, YPPU, false);
}
g.Clip = new Region(new RectangleF(0, 0, Width, Height));
}
public void Update()
{
//Reset variables
currentHoverGameObject = null;
currentHoverRTSObject = null;
isHoverRTSObject = false;
hoverOver = HoverOver.Nothing;
//2D Raycast
PointerEventData pointerData = new PointerEventData(EventSystem.current);
pointerData.position = Input.mousePosition;
List <RaycastResult> results = new List <RaycastResult>();
EventSystem.current.RaycastAll(pointerData, results);
if (results.Count > 0)
{
if (results[0].gameObject.layer == LayerMask.NameToLayer("UI"))
{
//string dbg = "Root Element: {0} \n GrandChild Element: {1}";
//Debug.Log(string.Format(dbg, results[results.Count-1].gameObject.name, results[0].gameObject.name));
//results.Clear();
hoverOver = HoverOver.UI;
}
}
//3D Raycast with all objects
{
int rayLength = 50;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit[] hits = Physics.RaycastAll(ray, rayLength);
for (int i = 0; i < hits.Length; i++)
{
RaycastHit hit = hits[i];
//Layer only
if (hit.collider.gameObject.layer == LayerMask.NameToLayer("Terrain"))
{
hoverTerrainPosision = hit.point;
}
}
}
//3D Raycast
if (hoverOver == HoverOver.Nothing)
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, Mathf.Infinity)) //LayerMask.NameToLayer("GameObject")
{
currentHoverGameObject = hit.collider.gameObject;
//If the gameObject is the terrain
if (currentHoverGameObject.layer == LayerMask.NameToLayer("Terrain"))
{
hoverOver = HoverOver.Terrain;
}
//If the gameObject is a RTSGameObject
else if (currentHoverGameObject.GetComponent <RTSGameObject>() != null)
{
currentHoverRTSObject = currentHoverGameObject.GetComponent <RTSGameObject>();
isHoverRTSObject = true;
if (TeamManager.main.player1.IsRTSAlly(currentHoverRTSObject))
{
if (currentHoverRTSObject.unitType == UnitType.Unit)
{
hoverOver = HoverOver.UnitFriendly;
}
else if (currentHoverRTSObject.unitType == UnitType.Building)
{
hoverOver = HoverOver.BuildingFriendly;
}
}
else if (TeamManager.main.player1.IsRTSEnemy(currentHoverRTSObject))
{
if (currentHoverRTSObject.unitType == UnitType.Unit)
{
hoverOver = HoverOver.UnitEnemy;
}
else if (currentHoverRTSObject.unitType == UnitType.Building)
{
hoverOver = HoverOver.BuildingEnemy;
}
}
else
{
hoverOver = HoverOver.Nothing;
}
currentHoverRTSObject.OnHover(); //RTS method message
}
}
}
}
//------------------------------Game Mode Updates------------------------------
private void GameMode_NormalUpdate()
{
//Set variables
interactionMode = InteractionMode.Nothing;
HoverOver hoverOver = HoverManager.main.getHoverOver();
List <RTSGameObject> allSelectedUnits = SelectedManager.main.GetSelectedObjects();
//Is their any selected RTSGameObjects
if (SelectedManager.main.GetSelectedObjectsCount() > 0)
{
RTSGameObject firstSelectedObject = SelectedManager.main.GetFirstSelectedObject();
//Is the RTSGameObject able to attack
if (firstSelectedObject.canAttack)
{
if (hoverOver == HoverOver.UnitEnemy || hoverOver == HoverOver.BuildingEnemy)
{
interactionMode = InteractionMode.Attack;
return;
}
}
//Is the RTSGameObject a Unit
if (firstSelectedObject.GetComponent <Unit>())
{
Unit unit = (Unit)firstSelectedObject;
//Can the Unit move
if (unit.canMove)
{
if (hoverOver == HoverOver.Terrain)
{
interactionMode = InteractionMode.Move;
return;
}
}
//Can the Unit interact
if (unit.canInteract)
{
if (hoverOver == HoverOver.UnitFriendly)
{
//Check if Unit can interact with another Unit (Heal another unit for example)
}
if (hoverOver == HoverOver.BuildingFriendly)
{
//Check if Unit can interact with Building (Repair building for example)
}
}
}
//Is the RTSGameObject a Worker
if (firstSelectedObject.GetComponent <Worker>())
{
Worker worker = (Worker)firstSelectedObject;
//Can the Worker build
if (worker.canBuild)
{
if (hoverOver == HoverOver.BuildingFriendly)
{
Building building = (Building)HoverManager.main.currentHoverRTSObject;
if (building.buildingMode == BuildingMode.Construction)
{
interactionMode = InteractionMode.Build;
}
}
}
}
}
//To select any kind of unit
else if (hoverOver == HoverOver.UnitFriendly || hoverOver == HoverOver.BuildingFriendly || hoverOver == HoverOver.UnitEnemy || hoverOver == HoverOver.BuildingEnemy)
{
//Select Interaction
interactionMode = InteractionMode.Select;
return;
}
}
