public void _Hide()
{
isOn = false;
UIMainControl.EnableInput();
UIMainControl.FadeOut(canvasGroup, 0.25f, thisObj);
}
public Vector3 GetScreenPos(Vector3 worldPos)
{
Vector3 screenPos = Camera.main.WorldToScreenPoint(worldPos) * UIMainControl.GetScaleFactor();
screenPos.z = 0;
return(screenPos);
}
// Update is called once per frame
void LateUpdate()
{
if (unit == null)
{
if (thisObj.activeInHierarchy)
{
thisObj.SetActive(false);
}
return;
}
if (unit.IsDestroyed() || (unit.HP >= unit.GetFullHP() && unit.shield >= unit.GetFullShield()))
{
UIUnitOverlayManager.RemoveUnit(unit);
unit = null;
thisObj.SetActive(false);
return;
}
if (!thisObj.activeInHierarchy)
{
return;
}
Vector3 screenPos = Camera.main.WorldToScreenPoint(unit.thisT.position + new Vector3(0, 1, 0));
screenPos.z = 0;
rectT.localPosition = screenPos * UIMainControl.GetScaleFactor();
sliderHP.value = (unit.HP / unit.GetFullHP());
sliderShield.value = (unit.shield / unit.GetFullShield());
}
void Start()
{
if (!UIMainControl.EnableHPOverlay())
{
gameObject.SetActive(false);
}
}
void Update()
{
if (BuildManager.UseDragNDrop() || !UIMainControl.UsePieMenu())
{
return;
}
if (buildInfo == null)
{
return;
}
Vector3 screenPos = Camera.main.WorldToScreenPoint(buildInfo.position) * UIMainControl.GetScaleFactor();
List <Vector3> pos = GetPieMenuPos(activeButtonList.Count, screenPos, 120, 50);
for (int i = 0; i < activeButtonList.Count; i++)
{
if (i < pos.Count)
{
activeButtonList[i].rectT.localPosition = pos[i];
}
else
{
activeButtonList[i].rectT.localPosition = new Vector3(0, 9999, 0);
}
}
}
private int currentButtonID = -1; //last touched button, for touch mode only
public void OnTowerButton(GameObject butObj, int pointerID = -1)
{
int ID = GetButtonID(butObj);
if (UIMainControl.InTouchMode() && !BuildManager.UseDragNDrop())
{
if (currentButtonID >= 0)
{
buttonList[currentButtonID].imgHighlight.enabled = false;
}
if (currentButtonID != ID)
{
currentButtonID = ID;
buttonList[ID].imgHighlight.enabled = true;
OnHoverButton(butObj);
return;
}
ClearTouchModeButton();
}
string exception = BuildManager.BuildTower(ID, buildInfo, pointerID);
if (exception != "")
{
UIMessage.DisplayMessage(exception);
return;
}
buildInfo = null;
if (!BuildManager.UseDragNDrop())
{
Hide();
}
}
private int currentButtonID = -1; //last touched button, for touch mode only
public void OnAbilityButton(GameObject butObj, int pointerID = -1)
{
int ID = GetButtonID(butObj);
if (UIMainControl.InTouchMode())
{
if (currentButtonID >= 0)
{
buttonList[currentButtonID].imgHighlight.enabled = false;
}
if (currentButtonID != ID)
{
//OnAbilitySelectingTarget(true); //to turn on cancel button
butCancelCanvasG.alpha = 1;
butCancelCanvasG.interactable = true;
currentButtonID = ID;
buttonList[ID].imgHighlight.enabled = true;
OnHoverButton(butObj);
return;
}
ClearTouchModeButton();
}
string exception = AbilityManager.SelectAbility(ID, pointerID);
if (exception != "")
{
UIMessage.DisplayMessage(exception);
}
}
void NewTextOverlay(TextOverlay overlayInstance)
{
if (!UIMainControl.EnableTextOverlay())
{
return;
}
Text txt = GetUnusedTextOverlay();
txt.text = overlayInstance.msg;
if (overlayInstance.useColor)
{
txt.color = overlayInstance.color;
}
else
{
txt.color = defaultColor;
}
txt.fontSize = (int)Mathf.Round(defaultFontSize * overlayInstance.scale);
txt.transform.localPosition = GetScreenPos(overlayInstance.pos);
txt.gameObject.SetActive(true);
StartCoroutine(TextOverlayRoutine(overlayInstance.pos, txt));
}
public void OnUpgradeButton(int index)
{
if (UIMainControl.InTouchMode())
{
if (currentState != 2)
{
currentState = 2;
SetCurrentStateToTwo(index);
return;
}
else
{
if (currentUpgradeIndex == index)
{
ClearState();
OnExitUpgradeButton();
}
else
{
SetCurrentStateToTwo(index);
return;
}
}
}
string exception = currentTower.Upgrade(index);
if (exception != "")
{
UIMessage.DisplayMessage(exception);
}
}
public void _Show(bool won){
if(won) lbTitle.text="Level Cleared!";
else lbTitle.text="Level Lost";
if(!(UIMainControl.AlwaysShowNextButton() || won) && buttonNext!=null) buttonNext.SetActive(false);
UIMainControl.FadeIn(canvasGroup, 0.25f, thisObj);
}
public void _Hide()
{
if (UIMainControl.InTouchMode())
{
ClearTouchModeButton();
}
UIMainControl.FadeOut(canvasGroup, 0.25f);
StartCoroutine(DelayHide());
}
public void _Show()
{
UpdatePerkItemList();
UpdateDisplay();
isOn = true;
rectT.localPosition = Vector3.zero;
UIMainControl.FadeIn(canvasGroup, 0.25f);
}
void Start()
{
if (!AbilityManager.IsOn() || AbilityManager.GetAbilityCount() == 0)
{
thisObj.SetActive(false);
return;
}
List <Ability> abList = AbilityManager.GetAbilityList();
for (int i = 0; i < abList.Count; i++)
{
if (i == 0)
{
buttonList[0].Init();
}
else if (i > 0)
{
buttonList.Add(UIButton.Clone(buttonList[0].rootObj, "AbilityButton" + (i + 1)));
}
buttonList[i].imgIcon.sprite = abList[i].icon;
buttonList[i].imgHighlight.enabled = false;
buttonList[i].label.text = "";
if (abList[i].usedRemained > 0)
{
buttonList[i].label.text = abList[i].usedRemained.ToString();
}
//else buttonList[i].label.text="∞";
if (UIMainControl.InTouchMode())
{
buttonList[i].SetCallback(null, null, this.OnAbilityButton, null);
}
else
{
buttonList[i].SetCallback(this.OnHoverButton, this.OnExitButton, this.OnAbilityButton, null);
}
}
tooltipRscItem.Init();
butCancelCanvasG = butCancelObj.AddComponent <CanvasGroup>();
OnAbilitySelectingTarget(false);
UIItemCallback cancelCallback = butCancelObj.AddComponent <UIItemCallback>();
cancelCallback.SetDownCallback(this.OnCancelAbilityButton);
//cancelCallback.SetUpCallback(up);
tooltipObj.SetActive(false);
}
public void _Show()
{
if (!thisObj.activeInHierarchy)
{
return;
}
rectT.localPosition = new Vector3(0, 0, 0);
UIMainControl.FadeIn(canvasGroup, 0.25f);
//thisObj.SetActive(true);
}
public void _Hide()
{
if (!thisObj.activeInHierarchy)
{
return;
}
UIMainControl.FadeOut(canvasGroup, 0.25f);
StartCoroutine(DelayHide());
//thisObj.SetActive(false);
}
public void _Show()
{
OnSwitchWeapon();
lbReloading.text = "";
isOn = true;
buttonExit.SetActive(true);
UIMainControl.DisableInput();
UIMainControl.FadeIn(canvasGroup, 0.25f, thisObj);
}
public void _Hide()
{
if (!thisObj.activeInHierarchy)
{
return;
}
currentTower = null;
GameControl.SelectTower(null);
UIMainControl.FadeOut(canvasGroup, 0.25f);
StartCoroutine(DelayHide());
}
public void _Show(UnitTower tower)
{
bool fadeIn = currentTower == null;
currentTower = tower;
UpdateDisplay();
//buttonParent.localPosition=buttonParentDefaultPos;
thisT.localPosition = Vector3.zero;
if (fadeIn)
{
UIMainControl.FadeIn(canvasGroup, 0.25f);
}
}
public void _Show(BuildInfo bInfo = null)
{
if (bInfo != null)
{
ClearTouchModeButton();
buildInfo = bInfo; //BuildManager.GetBuildInfo();
UpdateActiveBuildButtonList();
}
else
{
return;
}
rectT.localPosition = new Vector3(0, 0, 0);
UIMainControl.FadeIn(canvasGroup, 0.25f, thisObj);
}
public List <Vector3> GetPieMenuPos(float num, Vector3 screenPos, float cutoff, int size)
{
List <Vector3> points = new List <Vector3>();
if (num == 1)
{
points.Add(screenPos * UIMainControl.GetScaleFactor() + new Vector3(0, 50, 0));
return(points);
}
//if there's only two button to be displayed, then normal calculation doesnt apply
if (num <= 2)
{
points.Add(screenPos * UIMainControl.GetScaleFactor() + new Vector3(50, 10, 0));
points.Add(screenPos * UIMainControl.GetScaleFactor() + new Vector3(-50, 10, 0));
return(points);
}
//create a dummy transform which we will use to do the calculation
if (piePosDummyT == null)
{
piePosDummyT = new GameObject().transform;
piePosDummyT.parent = transform;
piePosDummyT.name = "PiePosDummy";
}
int cutoffOffset = cutoff > 0 ? 1:0;
//calculate the spacing of angle and distance of button from center
float spacing = (float)((360f - cutoff) / (num - cutoffOffset));
//float dist=Mathf.Max((num+1)*10, 50);
float dist = 0.35f * num * size; //UIMainControl.GetScaleFactor();
piePosDummyT.rotation = Quaternion.Euler(0, 0, cutoff / 2);
piePosDummyT.position = screenPos; //Vector3.zero;
//rotate the dummy transform using the spacing interval, then sample the end point
//these end point will be our button position
for (int i = 0; i < num; i++)
{
points.Add(piePosDummyT.TransformPoint(new Vector3(0, -dist, 0)));
piePosDummyT.Rotate(Vector3.forward * spacing);
}
return(points);
}
IEnumerator DisplayItemRoutine(UIMsgItem item)
{
item.rectT.SetAsFirstSibling();
UIMainControl.FadeIn(item.canvasG, 0.1f, item.rootObj);
StartCoroutine(ScaleRectTRoutine(item.rectT, .1f, scale, scaleZoomed));
yield return(StartCoroutine(UIMainControl.WaitForRealSeconds(.1f)));
//yield return new WaitForSeconds(0.1f);
StartCoroutine(ScaleRectTRoutine(item.rectT, .25f, scaleZoomed, scale));
yield return(StartCoroutine(UIMainControl.WaitForRealSeconds(.8f)));
//yield return new WaitForSeconds(0.8f);
UIMainControl.FadeOut(item.canvasG, 1.0f, item.rootObj);
}
void Start()
{
List <Rsc> rscList = ResourceManager.GetResourceList();
for (int i = 0; i < rscList.Count; i++)
{
if (i == 0)
{
rscItemList[0].Init();
}
else
{
rscItemList.Add(UIObject.Clone(rscItemList[0].rootObj, "Rsc" + (i + 1)));
}
rscItemList[i].imgRoot.sprite = rscList[i].icon;
rscItemList[i].label.text = rscList[i].value.ToString();
}
rscPanelObj.SetActive(false);
//buttonParentDefaultPos=buttonParent.localPosition;
towerPanelPosX = towerPanelRectT.localPosition.x;
if (UIMainControl.InTouchMode())
{
butSell.SetCallback(null, null, this.OnSellButton, null);
butUpgrade1.SetCallback(null, null, this.OnUpgradeButton1, null);
butUpgrade2.SetCallback(null, null, this.OnUpgradeButton2, null);
}
else
{
butSell.SetCallback(this.OnHoverSellButton, this.OnExitSellButton, this.OnSellButton, null);
butUpgrade1.SetCallback(this.OnHoverUpgradeButton1, this.OnExitUpgradeButton, this.OnUpgradeButton1, null);
butUpgrade2.SetCallback(this.OnHoverUpgradeButton2, this.OnExitUpgradeButton, this.OnUpgradeButton2, null);
}
butSell.imgHighlight.enabled = false;
butUpgrade1.imgHighlight.enabled = false;
butUpgrade2.imgHighlight.enabled = false;
//thisObj.SetActive(false);
}
public IEnumerator BuildingBarRoutine(UnitTower tower)
{
Slider bar = buildingBarList[GetUnusedBuildingBarIndex()];
Transform barT = bar.transform;
bar.gameObject.SetActive(true);
while (tower != null && tower.IsInConstruction())
{
bar.value = tower.GetBuildProgress();
Vector3 screenPos = Camera.main.WorldToScreenPoint(tower.thisT.position + new Vector3(0, 0, 0));
barT.localPosition = (screenPos + new Vector3(0, -20, 0)) * UIMainControl.GetScaleFactor();
yield return(null);
}
bar.gameObject.SetActive(false);
}
public void _OnUnitDamaged(Unit unit)
{
if (!UIMainControl.EnableHPOverlay())
{
return;
}
if (unitList.Contains(unit))
{
return;
}
unitList.Add(unit);
int index = GetUnusedUnitOverlayIndex();
unitOverlayList[index].SetUnit(unit);
unitOverlayList[index].gameObject.SetActive(true);
}
public void _Show(UnitTower tower)
{
if (UIMainControl.InTouchMode())
{
ClearState();
rscPanelObj.SetActive(false);
}
bool fadeIn = currentTower == null;
currentTower = tower;
UpdateDisplay();
//buttonParent.localPosition=buttonParentDefaultPos;
thisT.localPosition = Vector3.zero;
if (fadeIn)
{
UIMainControl.FadeIn(canvasGroup, 0.25f);
}
}
public void OnSellButton(GameObject butObj = null, int index = -1)
{
if (UIMainControl.InTouchMode())
{
if (currentState != 1)
{
ClearState();
OnHoverSellButton();
currentState = 1;
butSell.imgHighlight.enabled = true;
return;
}
else
{
ClearState();
OnExitSellButton();
}
}
currentTower.Sell();
Hide();
}
public void _Hide()
{
UIMainControl.FadeOut(canvasGroup, 0.25f);
StartCoroutine(DelayHide());
}
public void _Show()
{
rectT.localPosition = new Vector3(0, 0, 0);
UIMainControl.FadeIn(canvasGroup, 0.25f);
}
public void OnResumeButton()
{
UIMainControl.ResumeGame();
}
// Update is called once per frame
void Update()
{
if (fpsOn)
{
return;
}
if (Time.timeScale == 1)
{
deltaT = Time.deltaTime;
}
else if (Time.timeScale > 1)
{
deltaT = Time.deltaTime / Time.timeScale;
}
else
{
deltaT = 0.015f;
}
#if UNITY_IPHONE || UNITY_ANDROID || UNITY_WP8 || UNITY_BLACKBERRY
if (!UI.IsCursorOnUI(0) && !BuildManager.InDragNDrop())
{
if (enableTouchPan)
{
Quaternion camDir = Quaternion.Euler(0, transform.eulerAngles.y, 0);
if (Input.touchCount == 1)
{
Touch touch = Input.touches[0];
if (touch.phase == TouchPhase.Moved)
{
Vector3 deltaPos = touch.position;
if (lastTouchPos != new Vector3(9999, 9999, 9999))
{
deltaPos = deltaPos - lastTouchPos;
moveMagnitude = new Vector3(deltaPos.x, 0, deltaPos.y).magnitude *0.1f;
moveDir = new Vector3(deltaPos.x, 0, deltaPos.y).normalized *-1;
}
lastTouchPos = touch.position;
if (moveMagnitude > 10)
{
UIMainControl.ClearSelectedTower();
}
}
}
else
{
lastTouchPos = new Vector3(9999, 9999, 9999);
}
Vector3 dir = thisT.InverseTransformDirection(camDir * moveDir) * moveMagnitude;
thisT.Translate(dir * panSpeed * deltaT);
moveMagnitude = moveMagnitude * (1 - deltaT * 10);
}
if (enableTouchZoom)
{
if (Input.touchCount == 2)
{
Touch touch1 = Input.touches[0];
Touch touch2 = Input.touches[1];
//~ Vector3 zoomScreenPos=(touch1.position+touch2.position)/2;
if (touch1.phase == TouchPhase.Moved && touch1.phase == TouchPhase.Moved)
{
Vector3 dirDelta = (touch1.position - touch1.deltaPosition) - (touch2.position - touch2.deltaPosition);
Vector3 dir = touch1.position - touch2.position;
float dot = Vector3.Dot(dirDelta.normalized, dir.normalized);
if (Mathf.Abs(dot) > 0.7f)
{
touchZoomSpeed = dir.magnitude - dirDelta.magnitude;
}
}
}
currentZoom += Time.deltaTime * zoomSpeed * touchZoomSpeed;
touchZoomSpeed = touchZoomSpeed * (1 - Time.deltaTime * 15);
}
if (enableTouchRotate)
{
if (Input.touchCount == 2)
{
Touch touch1 = Input.touches[0];
Touch touch2 = Input.touches[1];
Vector2 delta1 = touch1.deltaPosition.normalized;
Vector2 delta2 = touch2.deltaPosition.normalized;
Vector2 delta = (delta1 + delta2) / 2;
float rotX = thisT.rotation.eulerAngles.x - delta.y * rotationSpeed;
float rotY = thisT.rotation.eulerAngles.y + delta.x * rotationSpeed;
rotX = Mathf.Clamp(rotX, minRotateAngle, maxRotateAngle);
thisT.rotation = Quaternion.Euler(rotX, rotY, 0);
}
}
}
#endif
#if UNITY_EDITOR || !(UNITY_IPHONE && UNITY_ANDROID && UNITY_WP8 && UNITY_BLACKBERRY)
//mouse and keyboard
if (enableMouseRotate)
{
if (Input.GetMouseButtonDown(1))
{
initialMousePosX = Input.mousePosition.x;
initialMousePosY = Input.mousePosition.y;
initialRotX = thisT.eulerAngles.y;
initialRotY = thisT.eulerAngles.x;
}
if (Input.GetMouseButton(1))
{
float deltaX = Input.mousePosition.x - initialMousePosX;
float deltaRotX = (.1f * (initialRotX / Screen.width));
float rotX = deltaX * rotationSpeed + deltaRotX;
float deltaY = initialMousePosY - Input.mousePosition.y;
float deltaRotY = -(.1f * (initialRotY / Screen.height));
float rotY = deltaY * rotationSpeed + deltaRotY;
float y = rotY + initialRotY;
//limit the rotation
if (y > maxRotateAngle)
{
initialRotY -= (rotY + initialRotY) - maxRotateAngle;
y = maxRotateAngle;
}
else if (y < minRotateAngle)
{
initialRotY += minRotateAngle - (rotY + initialRotY);
y = minRotateAngle;
}
thisT.rotation = Quaternion.Euler(y, rotX + initialRotX, 0);
}
}
Quaternion direction = Quaternion.Euler(0, thisT.eulerAngles.y, 0);
if (enableKeyPanning)
{
if (Input.GetButton("Horizontal"))
{
Vector3 dir = transform.InverseTransformDirection(direction * Vector3.right);
thisT.Translate(dir * panSpeed * deltaT * Input.GetAxisRaw("Horizontal"));
}
if (Input.GetButton("Vertical"))
{
Vector3 dir = transform.InverseTransformDirection(direction * Vector3.forward);
thisT.Translate(dir * panSpeed * deltaT * Input.GetAxisRaw("Vertical"));
}
}
if (enableMousePanning)
{
Vector3 mousePos = Input.mousePosition;
Vector3 dirHor = transform.InverseTransformDirection(direction * Vector3.right);
if (mousePos.x <= 0)
{
thisT.Translate(dirHor * panSpeed * deltaT * -3);
}
else if (mousePos.x <= mousePanningZoneWidth)
{
thisT.Translate(dirHor * panSpeed * deltaT * -1);
}
else if (mousePos.x >= Screen.width)
{
thisT.Translate(dirHor * panSpeed * deltaT * 3);
}
else if (mousePos.x > Screen.width - mousePanningZoneWidth)
{
thisT.Translate(dirHor * panSpeed * deltaT * 1);
}
Vector3 dirVer = transform.InverseTransformDirection(direction * Vector3.forward);
if (mousePos.y <= 0)
{
thisT.Translate(dirVer * panSpeed * deltaT * -3);
}
else if (mousePos.y <= mousePanningZoneWidth)
{
thisT.Translate(dirVer * panSpeed * deltaT * -1);
}
else if (mousePos.y >= Screen.height)
{
thisT.Translate(dirVer * panSpeed * deltaT * 3);
}
else if (mousePos.y > Screen.height - mousePanningZoneWidth)
{
thisT.Translate(dirVer * panSpeed * deltaT * 1);
}
}
if (enableMouseZoom)
{
float zoomInput = Input.GetAxis("Mouse ScrollWheel");
if (zoomInput != 0)
{
currentZoom += zoomSpeed * zoomInput;
currentZoom = Mathf.Clamp(currentZoom, -maxZoomDistance, -minZoomDistance);
}
}
#endif
if (avoidClipping)
{
Vector3 aPos = thisT.TransformPoint(new Vector3(0, 0, currentZoom));
Vector3 dirC = aPos - thisT.position;
float dist = Vector3.Distance(aPos, thisT.position);
RaycastHit hit;
obstacle = Physics.Raycast(thisT.position, dirC, out hit, dist);
if (!obstacle)
{
currentZoom = Mathf.Clamp(currentZoom, -maxZoomDistance, -minZoomDistance);
float camZ = Mathf.Lerp(camT.localPosition.z, currentZoom, Time.deltaTime * 4);
camT.localPosition = new Vector3(camT.localPosition.x, camT.localPosition.y, camZ);
}
else
{
dist = Vector3.Distance(hit.point, thisT.position) * 0.85f;
float camZ = Mathf.Lerp(camT.localPosition.z, -dist, Time.deltaTime * 50);
camT.localPosition = new Vector3(camT.localPosition.x, camT.localPosition.y, camZ);
}
}
else
{
currentZoom = Mathf.Clamp(currentZoom, -maxZoomDistance, -minZoomDistance);
float camZ = Mathf.Lerp(camT.localPosition.z, currentZoom, Time.deltaTime * 4);
camT.localPosition = new Vector3(camT.localPosition.x, camT.localPosition.y, camZ);
}
float x = Mathf.Clamp(thisT.position.x, minPosX, maxPosX);
float z = Mathf.Clamp(thisT.position.z, minPosZ, maxPosZ);
thisT.position = new Vector3(x, thisT.position.y, z);
}
