using System;

using [Link];
using [Link];
using [Link];
using [Link];
using UnityEngine;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];

public class CanvasGameText : MonoBehaviour

{
public static CanvasGameText instance;
private int Number3;

// public AdScript MyAd;

private void Awake()

{
instance = this;
[Link]<Button>().[Link](delegate ()
{
[Link]();
[Link]();

Invoke("InstButtonShow", 3f);
});
[Link]<Button>().[Link](delegate ()
{
[Link] = 25;
[Link]<Button>().interactable = false;
[Link]();
[Link]("PressButtonCollect", 1f);
});
}

private void Start()

{
[Link]();
Number3 = 1;

private void Update()

{
if ([Link])
{
[Link]();
[Link] = false;
}
}

public void InstButtonShow()

{
if (Number3 >= 5)
{
// [Link]();
 Number3 = 1;
}
Number3++;

public void PressButtonNext()

{

[Link]("ShowTextLevelComplete");
[Link]("ShowProgress");
[Link]("ShowButtonNext");
[Link]("Progress");
[Link]("ShowButtonNext");
[Link]("PlayAnimationImage");
[Link]("UpLevelButtonNext");
[Link]("PlayGiftAnimation");
[Link]("PlayGiftAnimationNow");
[Link]("ShowButtonCollect");
[Link]<Button>().interactable = false;
[Link]<ControlGame>().GameStop();
[Link]();
[Link]();
[Link]("EnterNext", 0.1f);

int reward = 20; // Reward for completing the level or action

// Add reward coins to the piggy bank

[Link](reward);

// Show the piggy bank popup with animations

// [Link]();
[Link](true);
}

public void PressButtonCollect()

{
[Link]<UIAlpha>().Disappear();
[Link]<UIScale>().Disappear();
[Link]<TextAlpha>().Disappear();
[Link]<UIAlphaNew>().Hide();
[Link]<UIScale>().Disappear();
[Link]<TextAlpha>().Disappear();
[Link]();
}

public void RewardedWillRecive()

{
[Link] = 50;
[Link]();
[Link]("PressButtonCollect", 1f);
[Link]<Button>().interactable = false;
[Link]<ButtonNext>().SetEnable(false);
[Link]();
}
 public void SetLevelUp(bool flag)
{
[Link] = flag;
}

public void SetChapters(int i)

{
[Link] = i;
}

public void ShowNext(int level)

{
[Link] = level;
[Link]();
if (level + 1 < [Link] * 10)
{
[Link]<TextLocalization>().SetInsertStrings(new
string[]
{
(level + 1).ToString()
});
[Link] = false;
}
else
{
[Link]<TextLocalization>().SetInsertStrings(new
string[]
{
(level + 1).ToString()
});
[Link] = true;
}
if ([Link])
{
[Link]<TextLocalization>().key = "Daily
Challenge Complete";
[Link]<TextLocalization>().RefreshText();
[Link]();
}
else
{
[Link]<TextLocalization>().key = "Level
Complete";

[Link]<TextLocalization>().SetInsertStrings(new
string[]
{
(level + 1).ToString()
});
}
if ([Link])
{
[Link]<ImageProgress>().SetAmount(level);
if ((level + 1) % 10 == 0)
{
[Link]<Text>().text = "10/10";
}
else
{
 [Link]<Text>().text = (level + 1) % 10 +
"/10";
}
}
[Link]("ShowTextLevelComplete", 0.5f);
[Link]();
[Link]();
}

public void CreateGiftBox()

{
[Link] = [Link]<GameObject>([Link],
[Link]).GetComponent<GiftBox>();

// ✅ Set position after instantiating

[Link] = new Vector3(0f, 13f, 0f); // ← Yahan
apni desired position daalein

// ✅ Set other properties

[Link](0.55f).SetType(1).SetParticle(true).SetContent([Link]
Win).ToIdle(1f, 1f, 1f);
}

public void PlayGiftBoxAnimation()

{
Vector3 position =
[Link]<RectTransform>().position;
[Link](false).ToMove(new Vector3(0f, position.y, 0f),
1f).OnMoveComplete(delegate
{
[Link](1f, 0.5f).OnScaleComplete(delegate
{
[Link](200f, 0.5f);
[Link]();
});
});
}

public void PlayParticleGiftBox()

{
[Link]();
[Link]();
}

public void DestroyGiftBox()

{
if ([Link] != null)
{
[Link]([Link]);
}
}

public void HideTextLevel()

{
[Link]<UIAlphaNew>().SetTargetAlpha(0f, false,
false);
///
[Link]<UIAlphaNew>().SetTargetAlpha(0f,false, false);
}

public void TextMoveDown()

{
if (![Link])
{
if ([Link] != null)
{
for (int i = 0; i < [Link]; i++)
{
if ([Link][i] != null)
{
foreach (ImageComplete imageComplete in [Link][i])
{
[Link]();
}
[Link][i].Clear();
}
}
}

[Link]<UIPosition>().MoveDown([Link]);
if ([Link] != null)
{
foreach (GameObject gameObject in [Link])
{

[Link]<UIPosition>().MoveDown([Link]);
}
}
[Link] = true;
[Link]();
}
}

public void TextMoveUp()

{

if ([Link])
{

[Link]<UIPosition>().MoveUp([Link]);
if ([Link] != null)
{
foreach (GameObject gameObject in [Link])
{
[Link]<UIPosition>().MoveUp([Link]);
}
}
[Link] = false;
}
}
public bool popfalse = false;
public void ShowTextLevelComplete()
{

[Link]<UIScale>().Display();
[Link]<TextAlpha>().Display();
 bool isAllComplete = [Link]();
bool isAllCompleteCollect = [Link]();
if ([Link])
{
[Link]("ShowProgress", 0.5f);
}
else if ([Link])
{

popfalse = true;
if (popfalse)
{
[Link](true);
[Link](true);
[Link](false);

[Link]([Link]);
}

[Link]([Link]);

[Link](true);
[Link](true);
[Link](true);
[Link](true);
[Link](false);
[Link](false);
if (!isAllComplete)
{
[Link]("ShowProgress", 0.5f);
}
else if (isAllComplete && isAllCompleteCollect)
{
[Link]("ShowProgress", 0.5f);
[Link](false);
}
else
{
[Link]("ShowButtonNext", 0.5f);

}
}
else
{
[Link]("ShowButtonNext", 0.5f);
[Link](false);
[Link](false);
}
}

public void ShowProgress()

{
if ([Link])
{
[Link]<UIAlphaNew>().SetTargetAlpha(1f,
false, false);

[Link]<UIScaleNew>().SetTargetScale([Link]);
}
 else
{
[Link]<UIAlphaNew>().SetTargetAlpha(1f,
false, false);
[Link]<UIScale>().Display();
[Link]<UIScale>().Display();
[Link]<TextAlpha>().Display();
}
[Link]("Progress", 0.5f);
[Link]("ShowButtonNext", 0.5f);
}

public void ShowButtonNext()

{
[Link]<UIAlpha>().DisplayWithoutInteractable();
[Link]<ButtonNext>().Display();
[Link]<ButtonNext>().Display();
[Link]<TextAlpha>().Display();
[Link]<Button>().interactable = false;
}

public void PlayAnimationImage()

{
[Link]<ButtonNext>().PlayAnimationImage();
}
public GameObject image;
public void ShowButtonCollect()
{
if ([Link])
{
[Link]<UIAlpha>().Display();
[Link]<UIScale>().Display();
[Link]<TextAlpha>().Display();
// Set position
RectTransform rect = [Link]<RectTransform>();
[Link] = new Vector2(-10, -602); // X, Y values
according to your layout
}
else
{
[Link]<Button>().interactable = true;
[Link]<UIAlpha>().Display();
[Link]<UIScale>().Display();
[Link]<TextAlpha>().Display();
[Link](false);
//
[Link]<RectTransform>().anchoredPosition3D = new Vector3(-
270f, -384);
// // [Link]<Button>().interactable = true;
//// [Link]<ButtonNext>().SetEnable(true);
// // [Link]<UIAlphaNew>().Show();
// [Link]<UIScale>().Display();
// [Link]<TextAlpha>().Display();
// [Link](); //shakeel

}
}
 public void HideNext()
{
[Link]<UIAlphaNew>().SetTargetAlpha(0f, false,
false);
[Link]<UIScale>().Disappear();
[Link]<UIAlpha>().DisappearWithoutInteractable();
[Link]<UIAlpha>().DisappearWithoutInteractable();
[Link]<ButtonNext>().Disappear();
[Link]<ButtonNext>().Disappear();
[Link]<TextAlpha>().Disappear();
[Link]<UIScale>().Disappear();
[Link]<TextAlpha>().Disappear();
[Link]<UIScale>().Disappear();
[Link]<TextAlpha>().Disappear();
[Link]();
[Link]("TextMoveUp", 1f);
[Link]("DestroyGiftBox", 1f);
[Link](false);
[Link](false);
}

public void EnterNext()

{
[Link]<ControlGame>().GameNext();
}

public void UpLevelButtonNext()

{
[Link]<ControlSound>().PlayLevelIncrement();
[Link]<ButtonNext>().PlayAnimation();
if ([Link])
{
[Link]<Text>().text =
[Link]("Return");
}
else
{
[Link]<TextLocalization>().SetInsertStrings(new
string[]
{
([Link] + 2).ToString()
});
}
}

public void Progress()

{
if ([Link])
{
[Link]("ShowButtonNext");
[Link]("ShowButtonCollect", 0f);
}
else
{
[Link]<ControlSound>().PlayWinProgressBar();

[Link]<ImageProgress>().SetTarget([Link] + 1);
if (([Link] + 1) % 10 == 0)
{
 [Link]("PlayGiftAnimation", 0.25f);
[Link]("ShowButtonNext");
[Link]("ShowButtonCollect", 2.5f);
}
}
}

public void PlayGiftAnimation()

{
[Link]<UIAlphaNew>().SetTargetAlpha(0f, false,
false);
[Link]<TextAlpha>().Disappear();
[Link]("PlayGiftAnimationNow", 0.25f);
}

public void PlayGiftAnimationNow()

{
[Link]();
}

public void SetSelectText(string s)

{
if ([Link] > 0)
{
[Link]<Text>().text = s;
[Link]<TextAlpha>().Display();
[Link]<UIAlpha>().Display();
[Link]("HideSelectTextNow");
}
else
{
[Link]();
}
}
// block hide with old code showtextblock
public void ShowTextBlocks(string completeText)
{
for (int i = 0; i < [Link]; i++)
{
if (words[i].[Link](completeText))
{
// 🔁 Hide preComplete letter blocks
foreach (GameObject preBlock in words[i].preCompleteBlock)
[Link](false);

// 🔁 Show full buttonComplete in the same place

foreach (GameObject btn in buttons)
{
if ([Link]<ButtonComplete>().myString ==
completeText)
{
[Link](true);
[Link]<ButtonComplete>().SetButtonEnable(true);
break;
}
}

break;
}
 }
}

// old code showtextblock

//public void ShowTextBlocks(string completeText)
//{

// for (int i = 0; i < [Link]; i++)

// {
// if (words[i].[Link](completeText))
// {
// for (int j = 0; j < words[i].[Link]; j++)
// {
// Text myText =
words[i].preCompleteBlock[j].[Link](0).GetComponent<Text>();
// Color c = [Link];
// c.a = 1f; // Set alpha (0 = transparent, 1 = opaque)
// [Link] = c;
//
words[i].preCompleteBlock[j].GetComponent<ImageComplete>().SetWhite();

// }
// }
// }

//} old function

// ... All your previous code remains unchanged ...

public List<ImageComplete> GetImages(int no)

{
[Link]("Word is complete");
no = [Link](no);
return [Link][no];

public int GetIndex(int no)

{
return [Link][no];
}

public int CompareList(List<string> ls1, List<string> ls2)

{

int num = ([Link] >= [Link]) ? [Link] : [Link];

for (int i = 0; i < num; i++)
{
if (ls1[i].Length < ls2[i].Length)
{
return -1;
}
if (ls1[i].Length > ls2[i].Length)
{
 return 1;
}
}
if ([Link] < [Link])
{
return -1;
}
if ([Link] > [Link])
{
return 1;
}
return 0;
}
public Vector3 myPos;

//[ContextMenu("SetCompleteText")]
//public void SetCompleteText(List<string> list)
//{
// bool flag = [Link] ==
[Link];
// List<RectTransform> list2 = new List<RectTransform>();
// List<RectTransform> list3 = new List<RectTransform>();
// List<RectTransform> list4 = new List<RectTransform>();
// Vector3 vector = new Vector3(-520f, -300f);
// [Link]<RectTransform>().anchoredPosition3D =
new Vector3(0f, -250f, 0f);
// int num = 0;
// int num2 = 0;
// float num3 = 0f;
// foreach (string text in list)
// {
// num2 += [Link];
// }
// if ([Link]() < 20)
// {
// num2 = (num2 - 1) / 5 + 8;
// num3 = (float)(900 / num2);
// }
// else
// {
// num2 = (num2 - 1) / 5 + 13;
// num3 = (float)(1350 / num2);
// }
// float num4 = num3 / [Link].x;
// float y =
[Link]<RectTransform>().anchoredPosition3D.y;
// float y2 = y - 100f + ([Link].x - num3) / 2f;
// vector = new Vector3(-520f, y2);
// [Link] = list;
// [Link] = new List<string>();
// List<string> list5 = new List<string>();
// List<string> list6 = new List<string>();
// List<List<string>> list7 = new List<List<string>>();
// foreach (string item in list)
// {
// [Link](item);
// }
// while ([Link] > 0)
// {
// if ([Link] == 1)
// {
// List<string> list8 = new List<string>();
// [Link](list5[0]);
// [Link]();
// [Link](list8);
// }
// else
// {
// List<string> list9 = new List<string>();
// float num5 = 0f;
// string text2 = list5[0];
// [Link](text2);
// [Link](text2);
// num5 += (float)[Link] * num3;
// for (int i = [Link] - 1; i >= 0; i--)
// {
// string text3 = list5[i];
// if (num5 + num3 * 0.3f + (float)[Link] * num3 < 1040f)
// {
// num5 = num5 + num3 * 0.3f + (float)[Link] * num3;
// [Link](text3);
// [Link](text3);
// }
// }
// for (int j = [Link] - 1; j >= 0; j--)
// {
// string text3 = list6[j];
// [Link](text3);
// }
// [Link]();
// [Link](list9);
// }
// }
// for (int k = [Link] - 1; k >= 0; k--)
// {
// for (int l = 0; l < k; l++)
// {
// if ([Link](list7[k], list7[l]) == -1)
// {
// List<string> value = list7[k];
// list7[k] = list7[l];
// list7[l] = value;
// }
// }
// }
// foreach (List<string> list10 in list7)
// {
// foreach (string item2 in list10)
// {
// [Link](item2);
// }
// }
// [Link] = new int[[Link]];
// for (int m = 0; m < [Link]; m++)
// {
// for (int n = 0; n < [Link]; n++)
// {
// if (list[m] == [Link][n])
 // {
// [Link][m] = n;
// }
// }
// }
// [Link] = new List<bool>();
// foreach (string text4 in [Link])
// {
// [Link](false);
// }
// [Link] = new List<ImageComplete>[[Link]];
// for (int num6 = 0; num6 < [Link]; num6++)
// {
// [Link][num6] = new List<ImageComplete>();
// }
// [Link] = new List<GameObject>();
// [Link] = new List<GameObject>();
// float x = 0f;
// [Link]<RectTransform>().anchoredPosition3D = new
Vector3(0f, y2, 0f);
// if (num4 > 0.71f)
// {
// [Link]<RectTransform>().localScale = new
Vector3(num4, num4, num4);
// [Link]<RectTransform>().anchoredPosition3D -=
new Vector3(0f, [Link].x * num4 * 1.3f, 0f);
// }
// else
// {
// [Link]<RectTransform>().localScale = new
Vector3(0.71f, 0.71f, 0.71f);
// [Link]<RectTransform>().anchoredPosition3D -=
new Vector3(0f, [Link].x * num4 * 1.3f, 0f);
// [Link]<RectTransform>().anchoredPosition3D -=
new Vector3(0f, ([Link].x * 0.71f * 1.3f - [Link].x * num4 *
1.3f) / 2f, 0f);
// }
// num++;
// [Link]<RectTransform>().anchoredPosition3D =
[Link]<RectTransform>().anchoredPosition3D - new Vector3(0f,
45f * num4 + 6f + 65f, 0f);
// for (int num7 = 0; num7 < [Link]; num7++)
// {
// GameObject gameObject =
[Link]<GameObject>([Link]);
// GameObject gameObject2 =
[Link]<GameObject>([Link]);
// [Link]([Link]);
// [Link]([Link]);
// if ((vector + new Vector3([Link].x * num4 *
(float)[Link][num7].Length, 0f, 0f)).x > 520f)
// {
// vector -= new Vector3([Link].x * num4 * 0.3f, 0f, 0f);
// vector -= new Vector3([Link].x * num4, 0f, 0f);
// x = (520f - vector.x) / 2f;
// foreach (RectTransform rectTransform in list2)
// {
// [Link] += new Vector3(x, 0f, 0f);
// }
 // [Link]();
// foreach (RectTransform rectTransform2 in list3)
// {
// [Link] += new Vector3(x, 0f, 0f);
// }
// [Link]();
// foreach (RectTransform rectTransform3 in list4)
// {
// [Link] += new Vector3(x, 0f, 0f);
// }
// [Link]();
// vector -= new Vector3(0f, [Link].x * num4 * 1.2f, 0f);
// vector.x = -520f;
// num++;
// [Link]<RectTransform>().anchoredPosition3D
-= new Vector3(0f, [Link].x * num4 * 1.2f, 0f);
//
[Link]<RectTransform>().anchoredPosition3D =
[Link]<RectTransform>().anchoredPosition3D - new Vector3(0f,
45f * num4 + 6f + 65f, 0f);
// }
// Vector2 sizeDelta =
[Link]<RectTransform>().sizeDelta;
// [Link]<RectTransform>().sizeDelta = new
Vector2([Link].x * (float)[Link][num7].Length + 12f,
sizeDelta.y);
// [Link]<RectTransform>().sizeDelta = new
Vector2([Link].x * (float)[Link][num7].Length + 12f,
sizeDelta.y);
// [Link]<RectTransform>().anchoredPosition3D = vector
+ myPos + new Vector3([Link].x * num4 *
((float)[Link][num7].Length / 2f - 0.5f), 0f, 0f);
// [Link]<RectTransform>().anchoredPosition3D = vector
+ new Vector3([Link].x * num4 * ((float)[Link][num7].Length / 2f
- 0.5f), 0f, 0f);
// [Link]<RectTransform>().localScale = new
Vector3(num4, num4, 1f);
// [Link]<RectTransform>().localScale = new
Vector3(num4, num4, 1f);
//
[Link]<ButtonComplete>().SetText([Link][num7]);
// [Link]<ImageCanRemove>().Hide();
// [Link](true);
// [Link](true);
// if (flag)
// {
// [Link]<ButtonComplete>().SetButtonEnable(true);
// }
// else
// {
//
[Link]<ButtonComplete>().SetButtonEnable(false);
// }
// [Link](gameObject2);
// [Link](gameObject);
// [Link]([Link]<RectTransform>());
// [Link]([Link]<RectTransform>());
// for (int num8 = 0; num8 < [Link][num7].Length; num8++)
// {
 // GameObject gameObject3 =
[Link]<GameObject>([Link]);
//
[Link]<RectTransform>().SetParent([Link]);
// // [Link]<RectTransform>().localScale = new
Vector3(num4, num4, 1f);
// // ✅ Use fixed scale 0.9f here
// [Link]<RectTransform>().localScale = new
Vector3(0.95f, 0.95f, 0.95f);

// [Link]<RectTransform>().anchorMin = new
Vector2(0.5f, 1f);
// [Link]<RectTransform>().anchorMax = new
Vector2(0.5f, 1f);
// [Link]<RectTransform>().anchoredPosition3D =
vector;
// [Link][num7].Add([Link]<ImageComplete>());
// [Link]([Link]<RectTransform>());
// vector += new Vector3([Link].x * num4, 0f, 0f);
// }
// vector += new Vector3([Link].x * num4 * 0.3f, 0f, 0f);
// if (vector.x > 520f)
// {
// vector -= new Vector3([Link].x * num4 * 0.3f, 0f, 0f);
// vector -= new Vector3([Link].x * num4, 0f, 0f);
// x = (520f - vector.x) / 2f;
// foreach (RectTransform rectTransform4 in list2)
// {
// [Link] += new Vector3(x, 0f, 0f);
// }
// [Link]();
// foreach (RectTransform rectTransform5 in list3)
// {
// [Link] += new Vector3(x, 0f, 0f);
// }
// [Link]();
// foreach (RectTransform rectTransform6 in list4)
// {
// [Link] += new Vector3(x, 0f, 0f);
// }
// [Link]();
// vector -= new Vector3(0f, [Link].x * num4 * 1.2f, 0f);
// vector.x = -520f;
// if (num7 != [Link] - 1)
// {
// num++;
//
[Link]<RectTransform>().anchoredPosition3D -= new
Vector3(0f, [Link].x * num4 * 1.2f, 0f);
//
[Link]<RectTransform>().anchoredPosition3D =
[Link]<RectTransform>().anchoredPosition3D - new Vector3(0f,
45f * num4 + 6f + 65f, 0f);
// }
// }
// }
// vector -= new Vector3([Link].x * num4 * 0.3f, 0f, 0f);
// vector -= new Vector3([Link].x * num4, 0f, 0f);
// x = (520f - vector.x) / 2f;
 // foreach (RectTransform rectTransform7 in list2)
// {
// [Link] += new Vector3(x, 0f, 0f);
// }
// [Link]();
// foreach (RectTransform rectTransform8 in list3)
// {
// [Link] += new Vector3(x, 0f, 0f);
// }
// [Link]();
// foreach (RectTransform rectTransform9 in list4)
// {
// [Link] += new Vector3(x, 0f, 0f);
// }
// [Link]();
// [Link]("Row:" + num);
// if (num > 3)
// {
// Vector3 b = new Vector3(0f, 25f, 0f);
//
[Link]<RectTransform>().anchoredPosition3D += b;
// foreach (GameObject gameObject4 in [Link])
// {
// [Link]<RectTransform>().anchoredPosition3D +=
b;
// }
// foreach (GameObject gameObject5 in [Link])
// {
// [Link]<RectTransform>().anchoredPosition3D +=
b;
// }
// foreach (List<ImageComplete> list11 in [Link])
// {
// foreach (ImageComplete imageComplete in list11)
// {
//
[Link]<RectTransform>().anchoredPosition3D += b;
// }
// }
// [Link]<RectTransform>().anchoredPosition3D +=
b;
// }
//}

[SerializeField] List<string> alreadyCompletedWords = new List<string>();

[ContextMenu("SetCompleteText")]
public void SetCompleteText(List<string> list)
{
[Link]();
[Link]();

bool flag = [Link] ==

[Link];
List<RectTransform> list2 = new List<RectTransform>();
List<RectTransform> list3 = new List<RectTransform>();
List<RectTransform> list4 = new List<RectTransform>();
Vector3 vector = new Vector3(-520f, -300f);
[Link]<RectTransform>().anchoredPosition3D =
new Vector3(0f, -240f, 0f);
int num = 0;
int num2 = 0;
float num3 = 0f;
foreach (string text in list)
{
num2 += [Link];
}
if ([Link]() < 20)
{
num2 = (num2 - 1) / 5 + 8;
num3 = (float)(900 / num2);
}
else
{
num2 = (num2 - 1) / 5 + 13;
num3 = (float)(1350 / num2);
}
float num4 = num3 / [Link].x;
float y =
[Link]<RectTransform>().anchoredPosition3D.y;
float y2 = y - 100f + ([Link].x - num3) / 2f;
vector = new Vector3(-520f, y2);
[Link] = list;
[Link] = new List<string>();
List<string> list5 = new List<string>();
List<string> list6 = new List<string>();
List<List<string>> list7 = new List<List<string>>();
foreach (string item in list)
{
[Link](item);
}
while ([Link] > 0)
{
if ([Link] == 1)
{
List<string> list8 = new List<string>();
[Link](list5[0]);
[Link]();
[Link](list8);
}
else
{
List<string> list9 = new List<string>();
float num5 = 0f;
string text2 = list5[0];
[Link](text2);
[Link](text2);
num5 += (float)[Link] * num3;
for (int i = [Link] - 1; i >= 0; i--)
{
string text3 = list5[i];
if (num5 + num3 * 0.3f + (float)[Link] * num3 < 1040f)
{
num5 = num5 + num3 * 0.3f + (float)[Link] * num3;
[Link](text3);
[Link](text3);
}
}
 for (int j = [Link] - 1; j >= 0; j--)
{
string text3 = list6[j];
[Link](text3);
}
[Link]();
[Link](list9);
}
}
for (int k = [Link] - 1; k >= 0; k--)
{
for (int l = 0; l < k; l++)
{
if ([Link](list7[k], list7[l]) == -1)
{
List<string> value = list7[k];
list7[k] = list7[l];
list7[l] = value;
}
}
}
foreach (List<string> list10 in list7)
{
foreach (string item2 in list10)
{
[Link](item2);
}
}
[Link] = new int[[Link]];
for (int m = 0; m < [Link]; m++)
{
for (int n = 0; n < [Link]; n++)
{
if (list[m] == [Link][n])
{
[Link][m] = n;

}
}
}
[Link] = new List<bool>();
foreach (string text4 in [Link])
{
[Link](false);
}
[Link] = new List<ImageComplete>[[Link]];
for (int num6 = 0; num6 < [Link]; num6++)
{
[Link][num6] = new List<ImageComplete>();
}
[Link] = new List<GameObject>();
[Link] = new List<GameObject>();
float x = 0f;
[Link]<RectTransform>().anchoredPosition3D = new
Vector3(0f, y2, 0f);
if (num4 > 0.71f)
{
[Link]<RectTransform>().localScale = new
Vector3(num4, num4, num4);
 [Link]<RectTransform>().anchoredPosition3D -=
new Vector3(0f, [Link].x * num4 * 1.3f, 0f);
}
else
{
[Link]<RectTransform>().localScale = new
Vector3(0.71f, 0.71f, 0.71f);
[Link]<RectTransform>().anchoredPosition3D -=
new Vector3(0f, [Link].x * num4 * 1.3f, 0f);
[Link]<RectTransform>().anchoredPosition3D -=
new Vector3(0f, ([Link].x * 0.71f * 1.3f - [Link].x * num4 *
1.3f) / 2f, 0f);
}
num++;

[Link]<RectTransform>().anchoredPosition3D =
[Link]<RectTransform>().anchoredPosition3D - new Vector3(0f,
45f * num4 + 6f + 65f, 0f);

for (int num7 = 0; num7 < [Link]; num7++)

{
[Link]("Completes words are " + completes[num7]);
GameObject gameObject =
[Link]<GameObject>([Link]);
GameObject gameObject2 =
[Link]<GameObject>([Link]);
[Link]([Link]);

[Link]([Link]); //shakeel
if ((vector + new Vector3([Link].x * num4 *
(float)[Link][num7].Length, 0f, 0f)).x > 420f)
{

vector -= new Vector3([Link].x * num4 * 0.3f, 0f, 0f);

vector -= new Vector3([Link].x * num4, 0f, 0f);
x = (520f - vector.x) / 2f;
foreach (RectTransform rectTransform in list2)
{
[Link] += new Vector3(x, 0f, 0f);

}
[Link]();
foreach (RectTransform rectTransform2 in list3)
{
[Link] += new Vector3(x, 0f, 0f);

}
[Link]();
foreach (RectTransform rectTransform3 in list4)
{
[Link] += new Vector3(x, 0f, 0f);

}
[Link]();
vector -= new Vector3(0f, [Link].x * num4 * 1.2f, 0f);
vector.x = -520f;
num++;
[Link]<RectTransform>().anchoredPosition3D -
= new Vector3(0f, [Link].x * num4 * 1.2f, 0f);

[Link]<RectTransform>().anchoredPosition3D =
[Link]<RectTransform>().anchoredPosition3D - new Vector3(0f,
45f * num4 + 6f + 65f, 0f);

Vector2 sizeDelta =
[Link]<RectTransform>().sizeDelta;
[Link]<RectTransform>().sizeDelta = new
Vector2([Link].x * (float)[Link][num7].Length + 12f,
sizeDelta.y);
[Link]<RectTransform>().sizeDelta = new
Vector2([Link].x * (float)[Link][num7].Length + 12f,
sizeDelta.y);

[Link]<RectTransform>().anchoredPosition3D = vector +
myPos+ new Vector3([Link].x * num4 * ((float)[Link][num7].Length
/ 2f - 0.5f), 0f, 0f);
[Link]<RectTransform>().anchoredPosition3D = vector +
new Vector3([Link].x * num4 * ((float)[Link][num7].Length / 2f -
0.5f), 0f, 0f);
[Link]<RectTransform>().localScale = new
Vector3(num4, num4, 1f);
[Link]<RectTransform>().localScale = new Vector3(num4,
num4, 1f);

[Link]<ButtonComplete>().SetText([Link][num7]);
[Link]( "Onj name is " +
[Link]<ButtonComplete>().[Link]<Text>().text +
"Vector :" +vector +", size :" + ([Link].x * num4 *
((float)[Link][num7].Length / 2f - 0.5f)));
[Link]<ImageCanRemove>().Hide();
[Link](true);
[Link](true);

if (flag)
{
[Link]<ButtonComplete>().SetButtonEnable(true);

[Link]([Link]<ButtonComplete>().myString);
}
else
{

[Link]<ButtonComplete>().SetButtonEnable(false);
}
[Link](gameObject2);

[Link](gameObject);
[Link]([Link]<RectTransform>());
[Link]([Link]<RectTransform>());

[Link]<ButtonComplete>().ShowAlphaValue();

// Create a list to hold all words' letter blocks

WordsContainer wordsContainer = new WordsContainer();
 [Link] = completes[num7];

[Link](wordsContainer);

for (int num8 = 0; num8 < [Link][num7].Length; num8++)

{
GameObject gameObject3 = Instantiate([Link]);
[Link](gameObject3);

RectTransform rt = [Link]<RectTransform>();
[Link]([Link]);
if (dailychalnge)
{
[Link] = new Vector3(1f, 1f, 1f); // precomplete block
size
[Link] = new Vector2(0.5f, 1f);
[Link] = new Vector2(0.5f, 1f);
rt.anchoredPosition3D = vector;
}
else
{
[Link] = new Vector3(1.2f, 1.2f, 1.2f); // precomplete
block size
[Link] = new Vector2(0.5f, 1f);
[Link] = new Vector2(0.5f, 1f);
rt.anchoredPosition3D = vector;
}

Text letterText = [Link]<Text>();

if (letterText != null)
{
// Set initial alpha to 0
Color c = [Link];
c.a = 0f;
[Link] = c;

[Link] = [Link][num7][num8].ToString();
}

[Link][num7].Add([Link]<ImageComplete>());
[Link](rt);

//specing block uper precomplete

if (dailychalnge)
{
vector += new Vector3([Link].x * 0.57f, 0f, 0f);
}
else
{
vector += new Vector3([Link].x * 0.7f, 0f, 0f);
}

// After full word:

if (dailychalnge)
 {
vector += new Vector3([Link].x * num4 * 0.4f, 0f,
0f); // <-- spacing between words

}
else
{
vector += new Vector3([Link].x * num4 * 0.4f, 0f,
0f); // <-- spacing between words
}

tempIndex++;

if (vector.x > 520f)

{
vector -= new Vector3([Link].x * num4 * 0.3f, 0f, 0f);
vector -= new Vector3([Link].x * num4, 0f, 0f);
x = (520f - vector.x) / 2f;
foreach (RectTransform rectTransform4 in list2)
{
[Link] += new Vector3(x, 0f, 0f);
}
[Link]();
foreach (RectTransform rectTransform5 in list3)
{
[Link] += new Vector3(x, 0f, 0f);
}
[Link]();
foreach (RectTransform rectTransform6 in list4)
{
[Link] += new Vector3(x, 0f, 0f);
}
[Link]();
vector -= new Vector3(0f, [Link].x * num4 * 1.2f, 0f);
vector.x = -520f;
if (num7 != [Link] - 1)
{
num++;

[Link]<RectTransform>().anchoredPosition3D -= new
Vector3(0f, [Link].x * num4 * 1.2f, 0f);

[Link]<RectTransform>().anchoredPosition3D =
[Link]<RectTransform>().anchoredPosition3D - new Vector3(0f,
45f * num4 + 6f + 65f, 0f);
}
}
}
vector -= new Vector3([Link].x * num4 * 0.3f, 0f, 0f);
vector -= new Vector3([Link].x * num4, 0f, 0f);
x = (520f - vector.x) / 2f;
foreach (RectTransform rectTransform7 in list2)
{
[Link] += new Vector3(x, 0f, 0f);
}
[Link]();
 foreach (RectTransform rectTransform8 in list3)
{
[Link] += new Vector3(x, 0f, 0f);
}
[Link]();
foreach (RectTransform rectTransform9 in list4)
{
[Link] += new Vector3(x, 0f, 0f);
}
[Link]();
[Link]("Row:" + num);
if (num > 3)
{
Vector3 b = new Vector3(0f, 25f, 0f);
[Link]<RectTransform>().anchoredPosition3D
+= b;
foreach (GameObject gameObject4 in [Link])
{
[Link]<RectTransform>().anchoredPosition3D += b;
}
foreach (GameObject gameObject5 in [Link])
{
[Link]<RectTransform>().anchoredPosition3D += b;
}
foreach (List<ImageComplete> list11 in [Link])
{
foreach (ImageComplete imageComplete in list11)
{

[Link]<RectTransform>().anchoredPosition3D += b;
}
}
[Link]<RectTransform>().anchoredPosition3D += b;
}
// Add this at the END of SetCompleteText()

StartCoroutine(WaitForWhile());
}
public bool dailychalnge;
[SerializeField] List<GameObject> preCompleteWords = new List<GameObject>();

IEnumerator WaitForWhile()
{
yield return new WaitForSeconds(1.5f);
tempIndex =0;
for (int i = 0; i < [Link]; i++)
{
for (int j = 0; j < words[i].[Link]; j++)
{

words[i].[Link](preCompleteWords[tempIndex]);
tempIndex++;
}
}
for (int i = 0; i < [Link]; i++)
{
if (buttons[i].GetComponent<ButtonComplete>().AlphaValue() >= 0.9)
{
 ShowTextBlocks(buttons[i].GetComponent<ButtonComplete>().myString);

}
}
}

public void ResetGame()

{
tempIndex = 0;
[Link]();
[Link]();
}

int tempIndex;

public List<WordsContainer> words;

[[Link]]
public class WordsContainer
{
public string word;
public List<GameObject> preCompleteBlock = new List<GameObject>();
}

public void ClearCompleteText()

{
[Link]("ClearCompleteTextNow", 0.2f);

public void ClearCompleteTextNow()

{
if ([Link] != null)
{
for (int i = 0; i < [Link]; i++)
{
if ([Link][i] != null)
{
foreach (ImageComplete imageComplete in [Link][i])
{
[Link]();
}
[Link][i].Clear();
}
}
}
if ([Link] != null)
{
for (int j = 0; j < [Link]; j++)
{
[Link]([Link][j]);
}
[Link]();
}
if ([Link] != null)
{
for (int k = 0; k < [Link]; k++)
 {
[Link]([Link][k]);
}
[Link]();
}
}

public void SetWord()

{
for (int i = 0; i < [Link]; i++)
{
for (int j = 0; j < [Link][i].Count; j++)
{
[Link][i][j].SetTextComplete([Link][i][j].ToString());
}

}
}

public void ShowCompleteWordHint(List<Word> list, int no, ref int magnifiterNo)

{
if (magnifiterNo == -1)
{
magnifiterNo = no;
}

int num = -1;

string targetWord = list[magnifiterNo].[Link]().ToLower();

for (int i = 0; i < [Link]; i++)

{
if ([Link][i] != null)
{
string completedWord = [Link]("",
[Link][i]).Trim().ToLower();
if (completedWord == targetWord)
{
num = i;
break;
}
}
}

if (num == -1 || [Link][num] == null)

{
[Link]("Hint word not found or images[" + num + "] is
null.");
return;
}

for (int j = 0; j < [Link][num].Length; j++)

{
if (![Link][num][j].HasText())
{
[Link][num][j].SetTextComplete([Link][num]
[j].ToString());

// ✅ Only on the last letter, show preCompleteBlock

if (j == [Link][num].Length - 1)
 {
[Link](new string([Link][num]));
[Link]<ControlGame>().HintRemove();
}

// ✅ Animation
RectTransform rect = [Link][num]
[j].[Link]<RectTransform>();
[Link]<ControlGame>().PlayItemAnimation(
[Link][num][j].[Link],
[Link].x * [Link].x);

[Link]<ControlGame>().GameSave(false);
return;
}
}

// ✅ Word already complete

[Link](new string([Link][num]));
[Link]<ControlGame>().HintRemove();
}

public void ShowCompleteWordHintWithoutAnimation(List<Word> list, int no, ref

int magnifiterNo)
{
if (magnifiterNo == -1)
{
magnifiterNo = no;
}

int num = -1;

string targetWord = list[magnifiterNo].[Link]().ToLower();

for (int i = 0; i < [Link]; i++)

{
if ([Link][i] != null)
{
string completedWord = [Link]("",
[Link][i]).Trim().ToLower();
if (completedWord == targetWord)
{
num = i;
break;
}
}
}

if (num == -1 || [Link][num] == null)

{
[Link]("Hint word not found or images[" + num + "] is
null.");
return;
}

for (int j = 0; j < [Link][num].Length; j++)

{
 if (![Link][num][j].HasText())
{
[Link][num][j].SetTextComplete([Link][num]
[j].ToString());

// ✅ Only show preCompleteBlock when last letter filled

if (j == [Link][num].Length - 1)
{
[Link](new string([Link][num]));
[Link]<ControlGame>().HintRemove();
}

return;
}
}

// ✅ Word already complete

[Link](new string([Link][num]));
[Link]<ControlGame>().HintRemove();
}

public void HideCompleteWordHint(List<Word> list, int no)

{
int num = -1;
for (int i = 0; i < [Link]; i++)
{
if ([Link][i] == list[no].word)
{
num = i;
}
}
for (int j = 0; j < [Link][num].Length; j++)
{
[Link][num][j].SetTextComplete([Link]);
}
}

public void HideSelectText()

{
[Link]("HideSelectTextNow", 0.5f);
}

public void HideSelectTextNow()

{
[Link]<UIAlpha>().Disappear();
[Link]<TextAlpha>().Disappear();
}

public void PlayAnimationVibration()

{
[Link]<ImageSelect>().PlayAnimationVibration();
}

public void PlayAnimationShake()

{
 [Link]<ImageSelect>().PlayAnimationShake();
}

public void SetText(int level, string tips)

{
if ([Link])
{
[Link]<TextLocalization>().key = "Daily
Challenge";
[Link]<TextLocalization>().RefreshText();
tips = [Link](tips);
}
else
{
[Link]<TextLocalization>().key = "Level";
[Link]<TextLocalization>().SetInsertStrings(new
string[]
{
(level + 1).ToString()
});
}
[Link]<Text>().text = tips;
}

public string GetChallengeTips(string tips)

{
char[] array = new char[[Link]];
for (int i = 0; i < [Link]; i++)
{
if (tips[i] != ' ')
{
array[i] = '?';
}
else
{
array[i] = tips[i];
}
}
return new string(array);
}

public void DisplayWithoutTextLevel()

{
[Link]<CanvasAlpha>().Display();
[Link]<CanvasAlpha>().Display(); //shakeel
}

public void Display()

{

[Link]<CanvasAlpha>().Display();
[Link]<UIAlphaNew>().SetTargetAlpha(1f, false,
false);

[Link]<CanvasAlpha>().Display(); //shakeel
}

public void Disappear()

{
 [Link]<CanvasAlpha>().Disappear();
[Link]<CanvasAlpha>().Disappear();
//shakeel
}

public void ShowButton(int no)

{
int index = [Link](no);
[Link][index].GetComponent<ButtonComplete>().SetNo(no);
[Link][index].GetComponent<ButtonComplete>().Show();

}
//sigel word start
public void ShowCompleteWordHintsingel(List<Word> list, int completes, ref int
magnifiterNo)
{
if (magnifiterNo == -1)
{
magnifiterNo = completes;
}

int num = -1;

string targetWord = list[magnifiterNo].[Link]().ToLower();

// Find the word index in completes list

for (int i = 0; i < [Link]; i++)
{
string completedWord = [Link]("",
[Link][i]).Trim().ToLower();
if (completedWord == targetWord)
{
num = i;
break;
}
}

// Show only next missing letter

for (int j = 0; j < [Link][num].Length; j++)
{
if (![Link][num][j].HasText())
{
[Link][num][j].SetTextComplete([Link][num]
[j].ToString());

// Optional: Play animation if you want

RectTransform rect = [Link][num]
[j].[Link]<RectTransform>();
[Link]<ControlGame>().PlayItemAnimation(
[Link][num][j].[Link],
[Link].x * [Link].x);
// ✅ Show blocks properly with alpha = 1 and white background
[Link](new string([Link][num]));

// If last letter hinted, remove hint UI

 if (j == [Link][num].Length - 1)
{
[Link]<ControlGame>().HintRemove();
}

[Link]<ControlGame>().GameSave(false);

return; // Stop after showing one letter

}
}

// If all letters already shown, remove hint UI

[Link]<ControlGame>().HintRemove();
}

public void ShowCompleteWordHintWithoutAnimationsingel(List<Word> list, int no,

ref int magnifiterNo)
{
if (magnifiterNo == -1)
{
magnifiterNo = no;
}

int num = -1;

string targetWord = list[magnifiterNo].[Link]().ToLower();

for (int i = 0; i < [Link]; i++)

{
string completedWord = [Link]("",
[Link][i]).Trim().ToLower();
if (completedWord == targetWord)
{
num = i;
break;
}
}

for (int j = 0; j < [Link][num].Length; j++)

{
if (![Link][num][j].HasText())
{
[Link][num][j].SetTextComplete([Link][num]
[j].ToString());
// ✅ Show blocks properly with alpha = 1 and white background
[Link](new string([Link][num]));

if (j == [Link][num].Length - 1)
{
[Link]<ControlGame>().HintRemove();
}

return;
}
}

[Link]<ControlGame>().HintRemove();
}
 public void HideCompleteWordHintsingel(List<Word> list, int no)
{
int num = -1;
string targetWord = list[no].[Link]().ToLower();

for (int i = 0; i < [Link]; i++)

{
string completedWord = [Link]("",
[Link][i]).Trim().ToLower();
if (completedWord == targetWord)
{
num = i;
break;
}
}

for (int j = 0; j < [Link][num].Length; j++)

{
[Link][num][j].SetTextComplete([Link]);
}
}

//singelword end
public void ShowCanRemove(int no)
{
no = [Link](no);
[Link][no].GetComponent<ImageCanRemove>().Show();
}

public void HideCanRemove(int no)

{
no = [Link](no);
[Link][no].GetComponent<ImageCanRemove>().Hide();
}

public void HideAllCanRemove()

{
foreach (GameObject gameObject in [Link])
{
[Link]<ImageCanRemove>().Hide();
}
}

public void PlayAnimationBonusWords()

{
[Link]("InstantiateGold", 0.1f);
}

public void InstantiateGold()

 {

for (int i = 5; i > 0; i--)

{
GameObject gameObject =
[Link]<GameObject>([Link]);

[Link]<RectTransform>().SetParent([Link])
;
if([Link] != null)
[Link]<RectTransform>().position =
[Link];

[Link]<ImageGold>().SetTargetPosition([Link]
ition);
[Link]<ImageGold>().SetGold([Link] / 5);
[Link]<ImageGold>().Move((float)i * 0.1f);
}
}

public void MoveBottomButton(float f)

{
[Link](f);
}

public void ResetBottomButton(float f)

{
[Link](-f);
}

public Vector3 GetImageSelectPosition()

{
return [Link]<RectTransform>().anchoredPosition3D;
}

public bool GetButtonNextInteractable()

{
return [Link]<ButtonNext>().GetInteractable();
}

public void Guide()

{

[Link]<RectTransform>().SetParent(this.canvasAnimation2
.transform);
}

public void ClearGuide()

{

[Link]<RectTransform>().SetParent([Link]
form);
}

public void OnClickButtonReward()

{
[Link]([Link]);
[Link]<Button>().interactable = false;
[Link]<ButtonNext>().SetEnable(false);
 [Link]();
}

public void EnableButtonReward()

{
[Link]<Image>().sprite = [Link][0];
}

public void DisableButtonReward()

{
[Link]<Image>().sprite = [Link][1];
}

public void FinishReward()

{
[Link] = true;
}

public void OnRewardComplete()

{
[Link]<Button>().interactable = false;
[Link] = 50;
[Link]();
[Link]("PressButtonCollect", 1f);
}

public void OnClickButtonClaim()

{
[Link]<UIAlphaNew>().SetTargetAlpha(0f,
false, false);

[Link]<UIScaleNew>().SetTargetScale([Link]);
[Link]<UIAlpha>().Disappear();
[Link]<UIScale>().Disappear();
[Link]<TextAlpha>().Disappear();
[Link]<ControlGame>().GameStop();
[Link]();
[Link]();
[Link]([Link]() + 1);
[Link]([Link]() + 1);
[Link]([Link]() + 1);
[Link]();
[Link](false);
[Link]<CanvasMain>().OnClickButtonStart();
}

public void ShowDailyChallengeTips()

{
float fadeTime = 1f;
[Link]<Text>().DOFade(0f,
fadeTime).OnComplete(delegate
{
int level = [Link]().level;
[Link]<Text>().text =
[Link]()[level];
[Link]<Text>().DOFade(1f, fadeTime);
});
}
public ControlMain control;

public GameObject preGold;

public GameObject imageGold;

public GameObject canvasAnimation1;

public GameObject canvasAnimation2;

public GameObject controlSound;

public GameObject canvasMain;

public GameObject canvasBackground;

public GameObject canvasGameTextButton;

public GameObject controlGame;

public GameObject buttonNext;

public GameObject buttonCollect;

public GameObject buttonClaim;

public GameObject buttonReward;

public GameObject imageLevel;

public GameObject textLevel;

public GameObject textGameTipsText;

public GameObject textNext;

public GameObject textCollect;

public GameObject textClaim;

public GameObject textReward;

public GameObject textLevelComplete;

public GameObject textProgress;

public GameObject imageProgress1;

public GameObject imageProgress2;

public GameObject imageGoldBig;

public GameObject imageSelect;

public GameObject imageUnbelievable;

public GameObject textSelect;

public GameObject preComplete;

 public GameObject preButtonComplete;

public GameObject preCanRemove;

public GameObject preGiftBox;

public GameObject preRewardWin;

public GameObject gameObjectGift,Home,bg,popup,shop, Quad;

public GameObject dailyChallengeReward;

public ParticleSystem particle1;

public ParticleSystem particle2;

public Sprite[] buttonSprites;

[SerializeField]private Vector2 completeSize = new Vector2(90f, 90f);

public List<string> completes;

private List<bool> isCompletes;

private List<ImageComplete>[] images;

public List<GameObject> buttons;

private List<GameObject> canRemoves;

[SerializeField] GiftBox giftBox;

public int[] noToIndex;

private int chapter;

private int levelNow;

private int HowMany;

private bool isDown;

private bool isLevelUp;

private bool isReturn;

private bool isFinishReward;

private int collectGold = 25;

private readonly float moveOffset;

public IEnumerable<Transform> completeTextParent { get; private set; }

}