void MinionSpawn()
{
if (GameObject.FindGameObjectWithTag("minion") == null)
{
if (abilityMinion)
{
if (minionSpawns)
{
Debug.Log("spawnMinion");
if (minionCDCounter <= 0)
{
Debug.Log("cdMinion");
Instantiate(minionObject, transform.position, Quaternion.identity).GetComponent <Rigidbody2D>().AddForce(new Vector2(transform.position.x + Random.Range(-1, 1), transform.position.y + Random.Range(-1, 1)));
minionCDCounter = minionCD;
}
}
if (minionCDCounter > 0)
{
//grayscale
minionRenderer.SetColor(Color.black);
minionCDCounter -= Time.deltaTime;
}
else
{
minionRenderer.SetColor(Color.white);
//shiny
}
}
else
{
//no more skill
}
}
}
private void SetActive(bool value)
{
interactable = Game.Data.Get($"btn_{key}_active", true);
var color = interactable ? Color.white : Color.gray / 2;
mat.SetColor(color);
}
//tame gauge process
private void tameGaugeProcess()
{
if (tameGaugeDisp == true)
{
//scale
float tmpmax = (float)tameGaugeMaxCnt;
float tmpcnt = (float)tameGaugeCnt;
float tmpval = (tmpcnt / tmpmax);
if (tmpval >= 1.0f)
{
tmpval = 1.0f;
}
cashRectTransform_tg.localScale = new Vector3(tmpval, 1.0f, 1.0f);
//color
if (tameGaugeCnt >= tameGaugeMaxCnt)
{
if (tameGaugeColCnt % 3 == 0)
{
cashCanvasRenderer_tg.SetColor(new Color(255.0f / 255.0f, 255.0f / 255.0f, 255.0f / 255.0f, 255.0f / 255.0f)); //wt
}
else if (tameGaugeColCnt % 3 == 1)
{
cashCanvasRenderer_tg.SetColor(new Color(255.0f / 255.0f, 0.0f / 255.0f, 0.0f / 255.0f, 255.0f / 255.0f)); //rd
// } else if (tameGaugeColCnt % 4 == 2){
// cashCanvasRenderer_tg.SetColor (new Color (236.0f / 255.0f, 210.0f / 255.0f, 231.0f / 255.0f, 255.0f / 255.0f)); //pink
}
else if (tameGaugeColCnt % 3 == 2)
{
cashCanvasRenderer_tg.SetColor(new Color(255.0f / 255.0f, 255.0f / 255.0f, 0.0f / 255.0f, 255.0f / 255.0f)); //ye
}
tameGaugeColCnt++;
}
}
}
private void ChangeStars()
{
if (myStars == 3)
{
star1.SetColor(Color.yellow);
star2.SetColor(Color.yellow);
star3.SetColor(Color.yellow);
}
else if (myStars == 2)
{
star1.SetColor(Color.yellow);
star2.SetColor(Color.yellow);
star3.SetColor(Color.white);
}
else if (myStars == 1)
{
star1.SetColor(Color.yellow);
star2.SetColor(Color.white);
star3.SetColor(Color.white);
}
else
{
star1.SetColor(Color.white);
star2.SetColor(Color.white);
star3.SetColor(Color.white);
}
}
public override void OnCursorInit(Cursor cursor)
{
base.OnCursorInit(cursor);
oldColor = canvasRenderer.GetColor();
pageSelectCursor = cursor;
canvasRenderer.SetColor(overlayColor);
}
public void OnEnable()
{
if (oldColor == new Color())
{
oldColor = canvasRenderer.GetColor();
}
canvasRenderer.SetColor(overlayColor);
}
void Update()
{
if ((source.GetTime() & (1 << id)) != 0)
{
spr.SetColor(new Color(1, 1, 1, 1));
}
else
{
spr.SetColor(new Color(0, 0, 0, 1));
}
}
public void decreaseEnergy(float value)
{
energy -= value;
if (energy < 0)
{
energy = 0;
canFire = false;
sliderBackground.SetColor(Color.red);
sliderFill.SetColor(Color.red);
}
}
public void setState(bool newState)
{
state = newState;
if (canvas != null)
{
if (state)
{
canvas.SetColor(selectedColor);
}
else
{
canvas.SetColor(normalColor);
}
}
}
public void EnergySliderUpdater(float ratioEnergyCurrentOnMax)
{
energySlider.value = ratioEnergyCurrentOnMax;
if (ratioEnergyCurrentOnMax >= 1f)
{
energySliderFill.SetColor(Color.white);
}
else if (ratioEnergyCurrentOnMax < 0f)
{
energySliderFill.SetColor(Color.red);
}
energySliderBackground.SetColor(Color.grey);
}
static public IEnumerator ColorTo(this CanvasRenderer inRenderer, Color inColor, float inTime, bool inbPreserveAlpha = true, AnimationCurve inCurve = null)
{
Color currentColor = inRenderer.GetColor();
float currentPercentage = 0.0f;
float percentageIncrement = 1.0f / inTime;
while (currentPercentage < 1)
{
yield return(null);
currentPercentage += Time.deltaTime * percentageIncrement;
if (currentPercentage > 1)
{
currentPercentage = 1;
}
float curvedPercentage = currentPercentage;
if (inCurve != null)
{
curvedPercentage = inCurve.Evaluate(curvedPercentage);
}
Color nextColor = Color.LerpUnclamped(currentColor, inColor, curvedPercentage);
if (inbPreserveAlpha)
{
nextColor.a = currentColor.a;
}
inRenderer.SetColor(nextColor);
}
}
internal static void UpdateColorBall()
{
CanvasRenderer canvasRenderer = newColorItem.GetComponent <CanvasRenderer>();
Color newColor = GetColorFromSliders();
canvasRenderer.SetColor(newColor);
}
static IEnumerator UF_ICrossRenderColor(GameObject target, Color vfrom, Color vto, float duration, bool ingoreTimeScale)
{
List <CanvasRenderer> array = ListCache <CanvasRenderer> .Acquire();
target.GetComponentsInChildren <CanvasRenderer>(true, array);
CanvasRenderer coloreffect = null;
if (array != null && array.Count > 0)
{
float progress = 0;
float tickBuff = 0;
while (progress < 1)
{
float delta = ingoreTimeScale ? GTime.DeltaTime : GTime.UnscaleDeltaTime;
tickBuff += delta;
progress = Mathf.Clamp01(tickBuff / duration);
Color current = progress * vto + (1 - progress) * vfrom;
for (int k = 0; k < array.Count; k++)
{
coloreffect = array[k];
if (coloreffect != null)
{
coloreffect.SetColor(current);
}
}
yield return(null);
}
}
ListCache <CanvasRenderer> .Release(array);
}
public void ShowNumberOfStars(int numberOfStars)
{
stars = numberOfStars;
if (numberOfStars == 0)
{
startStarEffect1 = false;
star1.SetColor(Color.white);
}
else if (numberOfStars == 1)
{
startStarEffect1 = true;
star1.SetColor(Color.yellow);
}
}
void UpdatePlaque()
{
var color = StakeColors[use];
plaqueBackgroundRenderer.SetColor(color);
plaqueTextRenderer.SetColor(color);
plaqueText.text = (bound ? "B" : "D") + StakeUses_short[use];
}
public void init(float cellSize)
{
this.cellSize = cellSize;
canvasRenderer = this.gameObject.AddComponent <CanvasRenderer>();
tileImage = this.gameObject.AddComponent <Image>(); //Add the Image Component script
canvas = this.gameObject.AddComponent <Canvas>();
this.gameObject.GetComponent <RectTransform>().sizeDelta = new Vector2(cellSize, cellSize);
canvasRenderer.SetColor(new Color(1f, 1f, 1f, 0f));// is about 100 % transparent(Cant be seen at all, but still active)
}
IEnumerator fadeOut()
{
for (float i = 1.0f; i >= 0.0f; i = i - 0.1f)
{
canvasRenderer.SetColor(new Color(i, i, i, i));
yield return(new WaitForSeconds(0.25f));
}
StartCoroutine(loadLevel());
}
void SetColor(CanvasRenderer renderer, int index)
{
if (renderer == null || color == null || index < 0 || index > color.Length)
{
return;
}
renderer.SetColor(color[index]);
}
public void ApplyTween(float inPercent)
{
Color final = UnityEngine.Color.LerpUnclamped(m_Start, m_Target, inPercent);
if (m_Update == ColorUpdate.PreserveAlpha)
{
final.a = m_Renderer.GetAlpha();
}
m_Renderer.SetColor(final);
}
public void HealthSliderUpdater(float ratioHealthCurrentOnMax)
{
healthSlider.value = ratioHealthCurrentOnMax;
if (ratioHealthCurrentOnMax > 0.6f)
{
healthSliderFill.SetColor(Color.green);
}
else if (ratioHealthCurrentOnMax > 0.2f)
{
healthSliderFill.SetColor(Color.yellow);
}
else
{
healthSliderFill.SetColor(Color.red);
}
healthSliderBackground.SetColor(Color.grey);
}
public void ApplyTween(float inPercent)
{
Color final = m_Gradient.Evaluate(inPercent);
if (m_Update == ColorUpdate.PreserveAlpha)
{
final.a = m_Renderer.GetAlpha();
}
m_Renderer.SetColor(final);
}
void Update()
{
if (durationScale <= 0)
{
return;
}
if (!loop)
{
transform.localScale = Vector3.one * scale.Evaluate(Time.time);
transform.localRotation = Quaternion.Euler(0, 0, rotation.Evaluate(Time.time) * 360);
canvasRenderer.SetColor(color.Evaluate(Time.time / durationScale));
}
else
{
transform.localScale = Vector3.one * scale.Evaluate(Time.time % durationScale);
transform.localRotation = Quaternion.Euler(0, 0, rotation.Evaluate(Time.time % durationRotation) * 360);
canvasRenderer.SetColor(color.Evaluate((Time.time % durationScale) / durationScale));
}
}
public TileMapObject(int t_x, int t_y, float cellSize)
{
tileGameObject = new GameObject("TileGameObject");
this.cellSize = cellSize;
canvasRenderer = tileGameObject.AddComponent <CanvasRenderer>();
tileImage = tileGameObject.AddComponent <Image>(); //Add the Image Component script
canvas = tileGameObject.AddComponent <Canvas>();
tileGameObject.GetComponent <RectTransform>().sizeDelta = new Vector2(cellSize, cellSize);
tileGameObject.GetComponent <RectTransform>().localScale.Set(1, 1, 1);
canvasRenderer.SetColor(new Color(1f, 1f, 1f, 0f));// is about 100 % transparent(Cant be seen at all, but still active)
}
// Fade from black to clear method using an IEnumerator which stops the rest of the program until this method is complete
private IEnumerator FadeToClear()
{
// Sets the overlay GameObjet to active and sets it colour to black
overlay.gameObject.SetActive(true);
overlay.SetColor(Color.black);
// Declares and sets the rate and progress of the fade
float rate = 1.0f / fadeTime;
float progress = 0.0f;
// While the progress is less than 1 Lerp the Colour from black to clear (using Alpha) while increasing the progress and executing through each frame
while (progress < 1.0f)
{
overlay.SetColor(Color.Lerp(Color.black, Color.clear, progress));
progress += rate * Time.deltaTime;
yield return(null);
}
// Sets the Overlay to clear and then deactivates it when not seen
overlay.SetColor(Color.clear);
overlay.gameObject.SetActive(false);
}
//アクティブ時のアニメーション
void OnEnable()
{
board.transform.localPosition = new Vector3(800.0f, 800.0f, 0);
board.transform.eulerAngles = new Vector3(0, 0, 150.0f);
enemy.transform.localPosition = initEnemyPosition + Vector3.up * 800.0f;
coverBG.SetColor(new Color(0, 0, 0, 0));
coverBG.gameObject.SetActive(false);
battleButton.transform.localPosition -= Vector3.down * -200.0f;
iTween.MoveTo(board.gameObject, iTween.Hash(
"position", Vector3.zero,
"islocal", true,
"time", 0.5f,
"easetype", iTween.EaseType.easeOutBack
));
iTween.RotateTo(board.gameObject, iTween.Hash(
"rotation", Vector3.zero,
"islocal", true,
"time", 0.5f,
"easetype", iTween.EaseType.easeOutQuad
));
iTween.MoveTo(enemy.gameObject, iTween.Hash(
"position", initEnemyPosition,
"islocal", true,
"time", 0.5f,
"oncomplete", "OnCompleteAnimation",
"oncompletetarget", gameObject,
"easetype", iTween.EaseType.easeInQuart
));
iTween.MoveTo(battleButton.gameObject, iTween.Hash(
"position", initButtonPosition,
"islocal", true,
"time", 0.3f,
"delay", 0.4f,
"easetype", iTween.EaseType.easeOutQuart
));
}
public virtual void SetColor(Color color)
{
if (_barFill != null)
{
if (_fillRenderer == null)
{
_fillRenderer = _barFill.GetComponent <CanvasRenderer>();
}
if (_fillRenderer != null)
{
_fillRenderer.SetColor(color);
}
}
}
void Start()
{
if (m_ActorNode == null)
{
return;
}
m_Renderer = GetComponent <CanvasRenderer>();
m_Renderer.Clear();
m_Renderer.SetAlpha(1.0f);
m_Renderer.SetColor(Color.white);
m_Renderer.SetMesh(m_Mesh);
m_Renderer.materialCount = 1;
m_Renderer.SetMaterial(m_Material, 0);
m_VertexPositionBuffer = m_ActorNode.MakeVertexPositionBuffer();
}
void Canvas_willRenderCanvases()
{
if (!IsDirty || Mesh == null)
{
return;
}
IsDirty = false;
Mesh.vertices = Vertices;
Mesh.triangles = Indices;
CanvasRenderer.SetMesh(Mesh);
CanvasRenderer.SetColor(Color);
CanvasRenderer.materialCount = 1;
CanvasRenderer.SetMaterial(Canvas.GetDefaultCanvasMaterial(), 0);
CanvasRenderer.SetTexture(Texture2D.whiteTexture);
CanvasRenderer.SetAlpha(0.5f);
}
public static IEnumerator UIColorFade(CanvasRenderer renderer, Color start, Color end, float duration, EaseType easeType, Action callback)
{
float t = 0f;
while (t < 1f)
{
t += Time.unscaledDeltaTime * (1f / duration);
renderer.SetColor(Color.Lerp(start, end, Ease(t, easeType)));
yield return(null);
}
if (callback != null)
{
callback();
}
}
IEnumerator FadeOut(GameObject obj, float delay)
{
obj.SetActive(true);
yield return(new WaitForSeconds(delay));
CanvasRenderer renderer = obj.GetComponent <CanvasRenderer>();
for (int i = 0; i < 100; i++)
{
Color color = renderer.GetColor();
color.a = 1 - (i * 0.01F);
renderer.SetColor(color);
yield return(new WaitForSeconds(0.01F));
}
obj.SetActive(false);
}
