// Use this for initialization
void Start()
{
AbilitiesManager.playerLoadedInLobby = false;
lobbyInst = this;
cDT = NetworkMessageEncoder.encoders[(int)NetworkEncoderTypes.CUSTOM_DATA_TRASMIT] as PlayerCustomDataTrasmitter;
iDT = NetworkMessageEncoder.encoders[(int)NetworkEncoderTypes.IMAGE_DATA_TRANSMIT] as ImageDependenciesTransfer;
mE = NetworkMessageEncoder.encoders[(int)NetworkEncoderTypes.MANIFEST] as ManifestEncoder;
ResetGameplayNetworkHelpers();
lobbyText = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(TextWrapper));
lobbyText.script.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.5f, 0.9f));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(lobbyText).text = "Lobby";
progressOfFiles = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(TextWrapper));
progressOfFiles.script.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.5f, 0.5f));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(progressOfFiles).verticalOverflow = VerticalWrapMode.Overflow;
startGame = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
startGame.script.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.5f, 0.1f));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(startGame, "Text").text = "Start Game";
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(startGame).onClick.AddListener(() => {
ServerChannel sC = NetworkMessageEncoder.encoders[(int)NetworkEncoderTypes.SERVER_CHANNEL] as ServerChannel;
sC.CommunicateServerSide(ServerSideMethods.START_GAME);
});
}
static public void ToggleItem(int givenID, bool shouldRefresh = true)
{
if (Data.mode == mode)
{
if (shopMode == 0)
{
if (!blueprintsPurchased.Contains(givenID))
{
itemsClicked.Add(new List <float>()
{
givenID, Time.time
});
if (itemsClicked.Count == 2)
{
if (itemsClicked[0][0] == itemsClicked[1][0] && itemsClicked[1][1] - itemsClicked[0][1] <= doubleClickWindow)
{
int itemTier = Data.GetItemTier(givenID);
if (scrap[itemTier] >= prices[itemTier])
{
blueprintsPurchased.Add(givenID);
scrap[itemTier] -= prices[itemTier];
SetScrapStarting();
UIDrawerShop.PurchaseItem(givenID);
if (shouldRefresh)
{
Data.SaveConfigProfile();
UIDrawer.Refresh();
}
}
}
itemsClicked.RemoveAt(0);
}
}
}
else if (shopMode == 1)
{
if (canDisablePurchasedBlueprints)
{
if (itemsToDrop[Data.profile[mode]].Contains(givenID))
{
itemsToDrop[Data.profile[mode]].Remove(givenID);
if (shouldRefresh)
{
Data.SaveConfigProfile();
UIDrawer.Refresh();
}
}
else
{
itemsToDrop[Data.profile[mode]].Add(givenID);
if (shouldRefresh)
{
Data.SaveConfigProfile();
UIDrawer.Refresh();
}
}
}
}
}
}
private void RotateAndMoveArrowToMatchDrawerDirection(UIDrawer drawer)
{
rotator.localRotation = Quaternion.identity;
switch (drawer.drawerCloseDirection)
{
case SimpleSwipe.Left:
RectTransform.SetParent(drawer.leftDrawerArrowHolder);
rotator.localRotation = Quaternion.Euler(0, 0, 90);
break;
case SimpleSwipe.Right:
RectTransform.SetParent(drawer.rightDrawerArrowHolder);
rotator.localRotation = Quaternion.Euler(0, 0, 90);
break;
case SimpleSwipe.Up:
RectTransform.SetParent(drawer.upDrawerArrowHolder);
rotator.localRotation = Quaternion.Euler(0, 0, 0);
break;
case SimpleSwipe.Down:
RectTransform.SetParent(drawer.downDrawerArrowHolder);
rotator.localRotation = Quaternion.Euler(0, 0, 0);
break;
}
RectTransform.anchoredPosition = Vector2.zero;
UpdateLocalScale(drawer.arrowScale);
UpdateArrowColor(drawer);
}
void Start()
{
// Applies pending data that was recieved while loading.
Debug.Log("Updating " + pendingData.Count + " messages while loading.");
for (int i = 0; i < pendingData.Count; i++)
{
(NetworkMessageEncoder.encoders[(int)NetworkEncoderTypes.UPDATE_ABILITY_DATA] as UpdateAbilityDataEncoder).ParseMessage(pendingData[i]);
}
pendingData.Clear();
playerLoadedInLobby = true;
// Creates global variables for this player.
aData[ClientProgram.clientId].abilties[""].InputCallback(0);
// Creates player main character.
string priCharacterId = aData[ClientProgram.clientId].abilityManifest[(int)AbilityManifest.PRIMARY_CHARACTER];
aData[ClientProgram.clientId].abilties[priCharacterId].InputCallback(0);
abilities = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(LinearLayout));
(abilities.script as LinearLayout).o = LinearLayout.Orientation.X;
abilities.script.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.1f,0.1f));
AssignInputKeys();
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
static public void BuyItem(int itemID)
{
bool boughtItem = false;
for (int transactionIndex = 0; transactionIndex < Data.buyMultiplier; transactionIndex++)
{
if (userPoints >= Data.GetItemPrice(itemID))
{
if (!itemsPurchased[Data.profile[Data.mode]].ContainsKey(itemID))
{
itemsPurchased[Data.profile[Data.mode]].Add(itemID, 0);
}
itemsPurchased[Data.profile[Data.mode]][itemID] += 1;
userPoints -= Data.GetItemPrice(itemID);
boughtItem = true;
}
else
{
break;
}
}
if (boughtItem)
{
Data.MakeDirectoryExist();
Data.SaveConfigProfile();
UIDrawer.Refresh();
}
}
static public void SellItem(int itemID)
{
bool soldItem = false;
for (int transactionIndex = 0; transactionIndex < Data.buyMultiplier; transactionIndex++)
{
if (itemsPurchased[Data.profile[Data.mode]].ContainsKey(itemID))
{
itemsPurchased[Data.profile[Data.mode]][itemID] -= 1;
if (itemsPurchased[Data.profile[Data.mode]][itemID] == 0)
{
itemsPurchased[Data.profile[Data.mode]].Remove(itemID);
}
soldItem = true;
}
else
{
break;
}
}
if (soldItem)
{
Data.MakeDirectoryExist();
Data.SaveConfigProfile();
UIDrawer.Refresh();
}
}
void GenerateMenuElements()
{
SpawnerOutput topText = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(TextWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(topText).text = "Abilities";
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(topText).color = Color.white;
topText.script.transform.position = UIDrawer.UINormalisedPosition(new Vector2(0.5f, 0.9f));
commandText = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(TextWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(commandText).text = "";
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(commandText).color = Color.white;
commandText.script.transform.position = UIDrawer.UINormalisedPosition(new Vector2(0.5f, 0.75f));
SpawnerOutput addAbility = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(addAbility).onClick.AddListener(() => { CreateAbility(); });
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(addAbility, "Text").text = "Create Ability";
addAbility.script.transform.position = UIDrawer.UINormalisedPosition(new Vector2(0.15f, 0.1f));
SpawnerOutput setNewPrimary = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(setNewPrimary).onClick.AddListener(() => { ChangeButtonMode(AbilityButtonMode.CHANGE_PRIMARY_CHARACTER); });
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(setNewPrimary, "Text").text = "Set new primary";
setNewPrimary.script.transform.position = UIDrawer.UINormalisedPosition(new Vector2(0.9f, 0.8f));
lL = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(LinearLayout));
lL.script.transform.position = UIDrawer.UINormalisedPosition(new Vector2(0.1f, 0.75f));
}
static public void OpenStartingItems()
{
DataShop.shopMode = 0;
Data.RefreshInfo();
UIDrawer.DrawUI();
UIDrawer.rootTransform.transform.parent.GetComponent <CanvasGroup>().blocksRaycasts = true;
}
/// <summary> Rotates the Rotator according to the UIDrawer's settings </summary>
/// <param name="drawer"> UIDrawer that controls this animator </param>
private void RotateAndMoveArrowToMatchDrawerDirection(UIDrawer drawer)
{
Rotator.localRotation = Quaternion.identity;
switch (drawer.CloseDirection)
{
case SimpleSwipe.Left:
RectTransform.SetParent(drawer.Arrow.Left.Root);
Rotator.localRotation = Quaternion.Euler(0, 0, 90);
break;
case SimpleSwipe.Right:
RectTransform.SetParent(drawer.Arrow.Right.Root);
Rotator.localRotation = Quaternion.Euler(0, 0, 90);
break;
case SimpleSwipe.Up:
RectTransform.SetParent(drawer.Arrow.Up.Root);
Rotator.localRotation = Quaternion.Euler(0, 0, 0);
break;
case SimpleSwipe.Down:
RectTransform.SetParent(drawer.Arrow.Down.Root);
Rotator.localRotation = Quaternion.Euler(0, 0, 0);
break;
}
RectTransform.anchoredPosition = Vector2.zero;
UpdateLocalScale(drawer.Arrow.Scale);
UpdateArrowColor(drawer);
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
static public void SetShopMode(int givenMode)
{
if (shopMode != givenMode)
{
shopMode = givenMode;
UIDrawer.DrawUI();
}
}
static public void OpenStartingItems()
{
Data.buyMultiplier = 1;
Data.RefreshInfo();
UIDrawer.DrawUI();
DrawRecentPanel();
rootTransform.transform.parent.GetComponent <CanvasGroup>().blocksRaycasts = true;
}
public void ResetComponent(UIDrawer drawer)
{
drawer.CloseDirection = CloseDirection;
drawer.CloseSpeed = CloseSpeed;
drawer.CustomStartAnchoredPosition = CustomStartAnchoredPosition;
drawer.DetectGestures = DetectGestures;
drawer.OpenSpeed = OpenSpeed;
drawer.UseCustomStartAnchoredPosition = UseCustomStartAnchoredPosition;
}
static public Dictionary <int, int> GenerateRandomItemList()
{
List <int> storeItems = UIDrawer.GetStoreItems();
Dictionary <int, int> itemPrices = new Dictionary <int, int>();
List <int> allPrices = new List <int>()
{
Data.tier1Price,
Data.tier2Price,
Data.tier3Price,
Data.bossPrice,
Data.lunarPrice,
Data.equipmentPrice,
Data.lunarEquipmentPrice,
Data.eliteEquipmentPrice,
};
List <int> equipmentPrices = new List <int>()
{
Data.equipmentPrice,
Data.lunarEquipmentPrice,
Data.eliteEquipmentPrice,
};
foreach (int itemID in storeItems)
{
int itemPrice = Data.GetItemPrice(itemID);
itemPrices.Add(itemID, itemPrice);
}
int points = GetPoints();
Dictionary <int, int> itemsPurchased = new Dictionary <int, int>();
bool equipmentGiven = false;
System.Random random = new System.Random();
ReduceItemList(points, equipmentGiven, allPrices, equipmentPrices, itemPrices);
while (allPrices.Count > 0)
{
List <int> availableItems = itemPrices.Keys.ToList();
int nextItem = availableItems[random.Next(availableItems.Count)];
if (!itemsPurchased.ContainsKey(nextItem))
{
itemsPurchased.Add(nextItem, 0);
}
int itemPrice = Data.GetItemPrice(nextItem);
int itemsGiven = random.Next(1, Mathf.Min(Mathf.FloorToInt(points / itemPrice) + 1, GetCountRange(nextItem) + 1));
itemsPurchased[nextItem] += itemsGiven;
points -= itemPrice * itemsGiven;
if (Data.allEquipmentIDs.ContainsKey(nextItem))
{
equipmentGiven = true;
}
ReduceItemList(points, equipmentGiven, allPrices, equipmentPrices, itemPrices);
}
return(itemsPurchased);
}
public void ChangeWindowsContentSize(Vector2 size)
{
(windowsGraphic.transform as RectTransform).sizeDelta = new Vector2(size.x + contentOffset.z + contentOffset.w, size.y + contentOffset.x + contentOffset.y);
deleteButton.transform.position = UIDrawer.UINormalisedPosition(windowsGraphic.transform as RectTransform, new Vector2(0.95f, 1f)) - new Vector3(0, contentOffset.x / 2);
windowsText.transform.position = UIDrawer.UINormalisedPosition(windowsGraphic.transform as RectTransform, new Vector2(0.5f, 1f)) - new Vector3(0, contentOffset.x / 2);
(windowsText.transform as RectTransform).sizeDelta = new Vector2(size.x - contentOffset.z - contentOffset.w, contentOffset.x * 0.9f);
content.transform.position = UIDrawer.UINormalisedPosition(windowsGraphic.transform as RectTransform, new Vector2(0f, 1f)) - new Vector3(-contentOffset.z, contentOffset.x);
windowsSize = size;
}
public UIDrawer()
{
if (Singleton == null)
{
Singleton = this;
}
else
{
throw new System.Exception(); //if singleton exist, throw a Exception
}
}
static public void CreateMenuButton()
{
if (logbookButton != null)
{
GameObject button = ButtonCreator.SpawnBlueButton(logbookButton.transform.parent.gameObject, new Vector2(0, 1), new Vector2(320, 48), "Item Drops", TMPro.TextAlignmentOptions.Left, new List <Image>());
button.transform.SetSiblingIndex(logbookButton.transform.GetSiblingIndex());
float localScale = logbookButton.GetComponent <RectTransform>().rect.width / 320;
button.GetComponent <RectTransform>().localScale = new Vector3(localScale, localScale, 1);
button.GetComponent <RoR2.UI.HGButton>().onClick.AddListener(() => {
UIDrawer.SetMenuStartingItems();
});
}
}
/// <summary> Updates the UIDrawerArrow color according to the UIDrawer's settings </summary>
/// <param name="drawer"> UIDrawer that controls this animator </param>
public void UpdateArrowColor(UIDrawer drawer)
{
if (!drawer.Arrow.OverrideColor)
{
return;
}
if (LeftBar == null || RightBar == null)
{
return;
}
Color color = Color.white;
if (drawer.IsDragged)
{
color = Color.Lerp(drawer.Arrow.ClosedColor, drawer.Arrow.OpenedColor, drawer.VisibilityProgress);
}
else
{
switch (drawer.Visibility)
{
case VisibilityState.Visible:
color = drawer.Arrow.OpenedColor;
break;
case VisibilityState.Showing:
color = Color.Lerp(drawer.Arrow.ClosedColor, drawer.Arrow.OpenedColor, drawer.VisibilityProgress);
break;
case VisibilityState.Hiding:
color = Color.Lerp(drawer.Arrow.OpenedColor, drawer.Arrow.ClosedColor, 1 - drawer.VisibilityProgress);
break;
case VisibilityState.NotVisible:
color = drawer.Arrow.ClosedColor;
break;
}
}
if (m_leftBarImage != null)
{
m_leftBarImage.color = color;
}
if (m_rightBarImage != null)
{
m_rightBarImage.color = color;
}
}
/// <summary> Fire the 'Back' button event (if it can be executed and is enabled) </summary>
public void Execute()
{
if (!DoozySettings.Instance.UseBackButton)
{
return;
}
if (!CanExecuteBackButton)
{
return;
}
if (BackButtonDisabled)
{
return;
}
if (UIPopup.AnyPopupVisible)
{
UIPopup lastShownPopup = UIPopup.LastShownPopup;
if (lastShownPopup.HideOnBackButton)
{
lastShownPopup.Hide();
}
if (lastShownPopup.BlockBackButton)
{
return;
}
}
if (UIDrawer.AnyDrawerOpened)
{
UIDrawer openedDrawer = UIDrawer.OpenedDrawer;
if (openedDrawer.HideOnBackButton)
{
openedDrawer.Close();
}
if (openedDrawer.BlockBackButton)
{
return;
}
}
Message.Send(new UIButtonMessage(NAME, UIButtonBehaviorType.OnClick));
m_lastBackButtonPressTime = Time.realtimeSinceStartup;
}
private void ExecuteActions()
{
// ReSharper disable once SwitchStatementMissingSomeCases
switch (Action)
{
case DrawerAction.Open:
UIDrawer.Open(DrawerName, DebugMode);
break;
case DrawerAction.Close:
UIDrawer.Close(DrawerName, DebugMode);
break;
case DrawerAction.Toggle:
UIDrawer.Toggle(DrawerName, DebugMode);
break;
}
}
public void UpdateArrowColor(UIDrawer drawer)
{
if (!drawer.overrideArrowColor)
{
return;
}
if (leftBar == null || rightBar == null)
{
return;
}
if (drawer.IsDragged)
{
leftBarImage.color = Color.Lerp(drawer.arrowColorWhenClosed, drawer.arrowColorWhenOpened, drawer.Visibility);
rightBarImage.color = Color.Lerp(drawer.arrowColorWhenClosed, drawer.arrowColorWhenOpened, drawer.Visibility);
return;
}
switch (drawer.CurerntDrawerState)
{
case UIDrawer.DrawerState.Opened:
leftBarImage.color = drawer.arrowColorWhenOpened;
rightBarImage.color = drawer.arrowColorWhenOpened;
break;
case UIDrawer.DrawerState.IsOpening:
leftBarImage.color = Color.Lerp(drawer.arrowColorWhenClosed, drawer.arrowColorWhenOpened, drawer.Visibility);
rightBarImage.color = Color.Lerp(drawer.arrowColorWhenClosed, drawer.arrowColorWhenOpened, drawer.Visibility);
break;
case UIDrawer.DrawerState.Closed:
leftBarImage.color = Color.Lerp(drawer.arrowColorWhenOpened, drawer.arrowColorWhenClosed, 1 - drawer.Visibility);
rightBarImage.color = Color.Lerp(drawer.arrowColorWhenOpened, drawer.arrowColorWhenClosed, 1 - drawer.Visibility);
break;
case UIDrawer.DrawerState.IsClosing:
leftBarImage.color = drawer.arrowColorWhenClosed;
rightBarImage.color = drawer.arrowColorWhenClosed;
break;
}
}
void Start()
{
mPos = new Vector2();
rcs = 16;
dimensions = 450;
PNGDimensions = 1024;
CalibrateEditor();
SpawnerOutput sO = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(sO).onClick.AddListener(SavePNG);
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(sO, "Text").text = "Save Art";
SpawnerOutput nO = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(InputFieldWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <InputField>(nO).onValueChanged.AddListener((s) => {
name = s;
});
sO.script.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.1f, 0.9f));
nO.script.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.1f, 0.8f));
GeneratePixels();
pointer = CreatePixel();
/*colors = new Color[1000];
* for (int i = 0; i < colors.Length; i++)
* if (i < 500)
* colors[i] = Color.red;
* else
* colors[i] = Color.black;
*
* colorTest = new Texture2D(100, 10);
* colorTest.SetPixels(colors);
*
* File.WriteAllBytes(Application.dataPath + "/../test6.png", colorTest.EncodeToPNG());*/
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
static public void ToggleItem(int givenID, bool shouldRefresh = true)
{
if (Data.mode == mode)
{
if (itemsToDrop[Data.profile[mode]].Contains(givenID))
{
itemsToDrop[Data.profile[mode]].Remove(givenID);
if (shouldRefresh)
{
Data.SaveConfigProfile();
UIDrawer.Refresh();
}
}
else
{
itemsToDrop[Data.profile[mode]].Add(givenID);
if (shouldRefresh)
{
Data.SaveConfigProfile();
UIDrawer.Refresh();
}
}
}
}
void DrawRenameGameObjectButton(float width)
{
QUI.BeginHorizontal(width);
{
if (QUI.GhostButton("Rename GameObject to Drawer Name", QColors.Color.Gray, width, 18))
{
if (serializedObject.isEditingMultipleObjects)
{
Undo.RecordObjects(targets, "Renamed Multiple Objects");
for (int i = 0; i < targets.Length; i++)
{
UIDrawer uid = (UIDrawer)targets[i];
uid.gameObject.name = "UID - " + uid.GetDrawerName();
}
}
else
{
Undo.RecordObject(Drawer.gameObject, "Renamed GameObject");
Drawer.gameObject.name = "UID - " + Drawer.GetDrawerName();
}
}
}
QUI.EndHorizontal();
}
SpawnerOutput CreateVariableButtons(ActionType aT, int[] id)
{
SpawnerOutput linkageButton = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(linkageButton, "Text").text = "";
UIDrawer.ChangeUISize(linkageButton, new Vector2(20, 20));
switch (aT)
{
case ActionType.RECIEVE:
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(linkageButton).onClick.AddListener(() => {
CreateLinkage(id);
});
break;
case ActionType.SEND:
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(linkageButton).onClick.AddListener(() => {
prevPath = id;
});
break;
}
return(linkageButton);
}
/// <summary> Sets the target UIDrawer that this animator belongs to </summary>
/// <param name="drawer"> Target UIDrawer</param>
public void SetTargetDrawer(UIDrawer drawer)
{
Drawer = drawer;
RotateAndMoveArrowToMatchDrawerDirection(Drawer);
}
void SceneLoadSetup()
{
UIDrawer.CreateCanvas();
UIVanilla.GetObjectsFromScene();
UIVanilla.CreateMenuButton();
}
void Start()
{
string cData = FileSaver.sFT[FileSaverTypes.PLAYER_GENERATED_DATA].GenericLoadTrigger(new string[] { AbilityPageScript.selectedAbility }, 0);
string wData = FileSaver.sFT[FileSaverTypes.PLAYER_GENERATED_DATA].GenericLoadTrigger(new string[] { AbilityPageScript.selectedAbility }, 2);
if (cData != "")
{
abilityData = new UIAbilityData(LoadedData.GetSingleton <JSONFileConvertor>().ConvertToData(JsonConvert.DeserializeObject <StandardJSONFileFormat[]>(cData)), JsonConvert.DeserializeObject <float[][]>(wData));
}
else
{
abilityData = new UIAbilityData();
}
abilityWindows = new AutoPopulationList <EditableWindow>();
lineData = new AutoPopulationList <LineData>();
SpawnUIFromData();
mainClassSelection = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(LinearLayout));
SpawnerOutput name = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(InputFieldWrapper));
name.script.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.5f, 0.9f));
InputField castedName = LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <InputField>(name);
string data = FileSaver.sFT[FileSaverTypes.PLAYER_GENERATED_DATA].GenericLoadTrigger(new string[] { AbilityPageScript.selectedAbility }, 1);
abilityDescription = JsonConvert.DeserializeObject <AbilityInfo>(data);
castedName.text = abilityDescription.n;
castedName.onValueChanged.AddListener((s) => {
abilityDescription.n = s;
});
SpawnerOutput[] buttons = new SpawnerOutput[LoadedData.loadedNodeInstance.Count];
foreach (KeyValuePair <Type, AbilityTreeNode> entry in LoadedData.loadedNodeInstance)
{
SpawnerOutput button = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
Button butInst = LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(button);
// Need another way to get elements within spawner output...
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(button, "Text").text = entry.Key.Name;
butInst.onClick.AddListener(() => {
selectedType = entry.Key;
windowSpawner.script.gameObject.SetActive(true);
mMode = MouseMode.CREATE_NODE;
});
(mainClassSelection.script as LinearLayout).Add(butInst.transform as RectTransform);
}
classSelectionScrollRect = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ScrollRectWrapper));
(classSelectionScrollRect.script as ScrollRectWrapper).ChangeScrollRectSize(new Vector2(100, 600));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <UIMule>(classSelectionScrollRect, "Content").GetRectTransform().sizeDelta = (mainClassSelection.script.transform as RectTransform).sizeDelta;
classSelectionScrollRect.script.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.1f, 0.6f));
mainClassSelection.script.transform.SetParent(LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <UIMule>(classSelectionScrollRect, "Content").transform);
mainClassSelection.script.transform.localPosition = new Vector2(-(mainClassSelection.script.transform as RectTransform).sizeDelta.x / 2, 0);
windowSpawner = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(Image));
windowSpawner.script.gameObject.SetActive(false);
SpawnerOutput optLL = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(LinearLayout));
SpawnerOutput normConnButt = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(normConnButt, "Text").text = "Normal Conection";
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Image>(normConnButt, "Image").color = Color.green;
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(normConnButt).onClick.AddListener(() => {
mMode = MouseMode.EDIT_CONN;
lMode = LinkMode.NORMAL;
});
SpawnerOutput sigConnButt = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(sigConnButt, "Text").text = "Signal Conection";
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Image>(sigConnButt, "Image").color = Color.red;
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(sigConnButt).onClick.AddListener(() => {
mMode = MouseMode.EDIT_CONN;
lMode = LinkMode.SIGNAL;
});
SpawnerOutput rmConnButt = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(rmConnButt,"Text").text = "Remove Conection";
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(rmConnButt).onClick.AddListener(() => {
mMode = MouseMode.REMOVE_CONN;
});
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <LinearLayout>(optLL).Add(normConnButt.script.transform as RectTransform);
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <LinearLayout>(optLL).Add(sigConnButt.script.transform as RectTransform);
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <LinearLayout>(optLL).Add(rmConnButt.script.transform as RectTransform);
optLL.script.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.9f,0.9f));
SpawnerOutput saveButton = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper));
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Button>(saveButton).onClick.AddListener(() => {
int[] aEle = abilityData.subclasses.ReturnActiveElementIndex();
AbilityDataSubclass[] cAD = abilityData.RelinkSubclass();
string[] imgDependencies = AbilityDataSubclass.GetImageDependencies(cAD);
// Gets all window locations.
float[][] windowLocations = new float[cAD.Length][];
for (int i = 0; i < windowLocations.Length; i++)
{
windowLocations[i] = new float[2];
windowLocations[i][0] = abilityWindows.l[aEle[i]].transform.position.x;
windowLocations[i][1] = abilityWindows.l[aEle[i]].transform.position.y;
}
FileSaver.sFT[FileSaverTypes.PLAYER_GENERATED_DATA].GenericSaveTrigger(new string[] { AbilityPageScript.selectedAbility },0,JsonConvert.SerializeObject(LoadedData.GetSingleton <JSONFileConvertor>().ConvertToStandard(cAD)));
FileSaver.sFT[FileSaverTypes.PLAYER_GENERATED_DATA].GenericSaveTrigger(new string[] { AbilityPageScript.selectedAbility }, 1, JsonConvert.SerializeObject(abilityDescription));
FileSaver.sFT[FileSaverTypes.PLAYER_GENERATED_DATA].GenericSaveTrigger(new string[] { AbilityPageScript.selectedAbility }, 2, JsonConvert.SerializeObject(windowLocations));
FileSaver.sFT[FileSaverTypes.PLAYER_GENERATED_DATA].GenericSaveTrigger(new string[] { AbilityPageScript.selectedAbility }, 3, JsonConvert.SerializeObject(imgDependencies));
});
LoadedData.GetSingleton <UIDrawer>().GetTypeInElement <Text>(saveButton, "Text").text = "Save JSON";
saveButton.script.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.5f, 0.1f));
// Creates dropdown for input.
kcDdL = new KeyCodeDropdownList(abilityDescription.kC);
kcDdL.ReturnDropdownWrapper().transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.75f, 0.9f));
kcDdL.ReturnDropdownWrapper().dropdown.onValueChanged.AddListener((v) => {
abilityDescription.kC = KeyCodeDropdownList.inputValues[v];
});
// Creates dropdown for startnode.
//DropdownWrapper sNDW = LoadedData.GetSingleton<UIDrawer>().CreateScriptedObject(typeof(DropdownWrapper)).script as DropdownWrapper;
ButtonWrapper addOptionsButton = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper)).script as ButtonWrapper;
addOptionsButton.button.onClick.AddListener(() => CreateWindowForAdditionalOptions());
addOptionsButton.text.text = "Additional Options";
addOptionsButton.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.1f, 0.2f));
ButtonWrapper exitBlueprintMaker = LoadedData.GetSingleton <UIDrawer>().CreateScriptedObject(typeof(ButtonWrapper)).script as ButtonWrapper;
exitBlueprintMaker.button.onClick.AddListener(() => SceneTransitionData.LoadScene("AbilityPage"));
exitBlueprintMaker.text.text = "Exit";
exitBlueprintMaker.transform.position = UIDrawer.UINormalisedPosition(new Vector3(0.1f, 0.1f));
}
void DrawArrow(float width)
{
QUI.BeginHorizontal(width);
{
QUI.QToggle("Show Arrow", showArrow);
QUI.FlexibleSpace();
}
QUI.EndHorizontal();
showArrowAnimBool.target = showArrow.boolValue;
if (QUI.BeginFadeGroup(showArrowAnimBool.faded))
{
QUI.BeginVertical(width);
{
QUI.Space(SPACE_2 * showArrowAnimBool.faded);
QUI.BeginHorizontal(width);
{
QUI.QObjectPropertyField("Arrow", arrow, width - 4 - 100, 20, true);
QUI.Space(SPACE_4 * showArrowAnimBool.faded);
QUI.QObjectPropertyField("Scale", arrowScale, 100, 20, false);
QUI.FlexibleSpace();
}
QUI.EndHorizontal();
QUI.BeginHorizontal(width);
{
QUI.QToggle("Override Arrow Color", overrideArrowColor);
QUI.Space(SPACE_2);
if (overrideArrowColor.boolValue)
{
tempFloat = (width - 152) / 2; //color fields width
QUI.QObjectPropertyField("Closed", arrowColorWhenClosed, tempFloat, 20, false);
QUI.Space(SPACE_2);
QUI.QObjectPropertyField("Opened", arrowColorWhenOpened, tempFloat, 20, false);
}
QUI.FlexibleSpace();
}
QUI.EndHorizontal();
QUI.Space(SPACE_2);
QUI.BeginHorizontal(width);
{
if (QUI.GhostButton("Reset Arrow Holder Pos", QColors.Color.Gray, (width - 4) / 3, 18))
{
Undo.RecordObject(Drawer.leftDrawerArrowHolder, "Update Arrow Holder");
switch (Drawer.drawerCloseDirection)
{
case Gestures.SimpleSwipe.Left: UIDrawer.ResetArrowHolder(Drawer.leftDrawerArrowHolder, Drawer.drawerCloseDirection); break;
case Gestures.SimpleSwipe.Right: UIDrawer.ResetArrowHolder(Drawer.rightDrawerArrowHolder, Drawer.drawerCloseDirection); break;
case Gestures.SimpleSwipe.Up: UIDrawer.ResetArrowHolder(Drawer.upDrawerArrowHolder, Drawer.drawerCloseDirection); break;
case Gestures.SimpleSwipe.Down: UIDrawer.ResetArrowHolder(Drawer.downDrawerArrowHolder, Drawer.drawerCloseDirection); break;
}
}
QUI.Space(SPACE_2);
if (QUI.GhostButton("Reset Closed Arrow Pos", QColors.Color.Gray, (width - 4) / 3, 18))
{
Undo.RecordObject(Drawer.leftDrawerArrowClosedPosition, "Update Closed Arrow");
switch (Drawer.drawerCloseDirection)
{
case Gestures.SimpleSwipe.Left: UIDrawer.ResetClosedArrow(Drawer.leftDrawerArrowClosedPosition, Drawer.drawerCloseDirection); break;
case Gestures.SimpleSwipe.Right: UIDrawer.ResetClosedArrow(Drawer.rightDrawerArrowClosedPosition, Drawer.drawerCloseDirection); break;
case Gestures.SimpleSwipe.Up: UIDrawer.ResetClosedArrow(Drawer.upDrawerArrowClosedPosition, Drawer.drawerCloseDirection); break;
case Gestures.SimpleSwipe.Down: UIDrawer.ResetClosedArrow(Drawer.downDrawerArrowClosedPosition, Drawer.drawerCloseDirection); break;
}
}
QUI.Space(SPACE_2);
if (QUI.GhostButton("Reset Opened Arrow Pos", QColors.Color.Gray, (width - 4) / 3, 18))
{
Undo.RecordObject(Drawer.leftDrawerArrowOpenedPosition, "Update Opened Arrow");
switch (Drawer.drawerCloseDirection)
{
case Gestures.SimpleSwipe.Left: UIDrawer.ResetOpenedArrow(Drawer.leftDrawerArrowOpenedPosition, Drawer.drawerCloseDirection); break;
case Gestures.SimpleSwipe.Right: UIDrawer.ResetOpenedArrow(Drawer.rightDrawerArrowOpenedPosition, Drawer.drawerCloseDirection); break;
case Gestures.SimpleSwipe.Up: UIDrawer.ResetOpenedArrow(Drawer.upDrawerArrowOpenedPosition, Drawer.drawerCloseDirection); break;
case Gestures.SimpleSwipe.Down: UIDrawer.ResetOpenedArrow(Drawer.downDrawerArrowOpenedPosition, Drawer.drawerCloseDirection); break;
}
}
}
QUI.EndHorizontal();
QUI.Space(SPACE_2);
QUI.BeginHorizontal(width);
{
if (QUI.GhostButton("Copy - Opened Arrow Position - to - Closed Arrow Position", QColors.Color.Gray, width, 18))
{
Undo.RecordObject(Drawer.leftDrawerArrowOpenedPosition, "Update Opened Arrow");
switch (Drawer.drawerCloseDirection)
{
case Gestures.SimpleSwipe.Left: UIDrawer.MatchRectTransform(Drawer.leftDrawerArrowClosedPosition, Drawer.leftDrawerArrowOpenedPosition); break;
case Gestures.SimpleSwipe.Right: UIDrawer.MatchRectTransform(Drawer.rightDrawerArrowClosedPosition, Drawer.rightDrawerArrowOpenedPosition); break;
case Gestures.SimpleSwipe.Up: UIDrawer.MatchRectTransform(Drawer.upDrawerArrowClosedPosition, Drawer.upDrawerArrowOpenedPosition); break;
case Gestures.SimpleSwipe.Down: UIDrawer.MatchRectTransform(Drawer.downDrawerArrowClosedPosition, Drawer.downDrawerArrowOpenedPosition); break;
}
}
}
QUI.EndHorizontal();
QUI.Space(SPACE_2);
QUI.BeginHorizontal(width);
{
if (QUI.GhostButton("Copy - Closed Arrow Position - to - Opened Arrow Position", QColors.Color.Gray, width, 18))
{
Undo.RecordObject(Drawer.leftDrawerArrowClosedPosition, "Update Closed Arrow");
switch (Drawer.drawerCloseDirection)
{
case Gestures.SimpleSwipe.Left: UIDrawer.MatchRectTransform(Drawer.leftDrawerArrowOpenedPosition, Drawer.leftDrawerArrowClosedPosition); break;
case Gestures.SimpleSwipe.Right: UIDrawer.MatchRectTransform(Drawer.rightDrawerArrowOpenedPosition, Drawer.rightDrawerArrowClosedPosition); break;
case Gestures.SimpleSwipe.Up: UIDrawer.MatchRectTransform(Drawer.upDrawerArrowOpenedPosition, Drawer.upDrawerArrowClosedPosition); break;
case Gestures.SimpleSwipe.Down: UIDrawer.MatchRectTransform(Drawer.downDrawerArrowOpenedPosition, Drawer.downDrawerArrowClosedPosition); break;
}
}
}
QUI.EndHorizontal();
QUI.Space(SPACE_2);
if (QUI.GhostBar("Show Arrow References", showArrowReferences.target ? QColors.Color.Blue : QColors.Color.Gray, showArrowReferences, width * showArrowAnimBool.faded, MiniBarHeight))
{
showArrowReferences.target = !showArrowReferences.target;
}
QUI.BeginHorizontal(width);
{
QUI.Space(SPACE_8 * showArrowReferences.faded);
if (QUI.BeginFadeGroup(showArrowReferences.faded))
{
QUI.BeginVertical(width - SPACE_8);
{
QUI.Space(SPACE_4 * showArrowReferences.faded);
QUI.QObjectPropertyField("Arrow Container", arrowContainer, width - SPACE_8, 20, true);
QUI.Space(SPACE_2 * showArrowReferences.faded);
DrawArrowHolder("Left", leftDrawerArrowHolder, leftDrawerArrowClosedPosition, leftDrawerArrowOpenedPosition, width);
QUI.Space(SPACE_2 * showArrowReferences.faded);
DrawArrowHolder("Right", rightDrawerArrowHolder, rightDrawerArrowClosedPosition, rightDrawerArrowOpenedPosition, width);
QUI.Space(SPACE_2 * showArrowReferences.faded);
DrawArrowHolder("Up", upDrawerArrowHolder, upDrawerArrowClosedPosition, upDrawerArrowOpenedPosition, width);
QUI.Space(SPACE_2 * showArrowReferences.faded);
DrawArrowHolder("Down", downDrawerArrowHolder, downDrawerArrowClosedPosition, downDrawerArrowOpenedPosition, width);
QUI.Space(SPACE_2 * showArrowReferences.faded);
}
QUI.EndVertical();
}
QUI.EndFadeGroup();
}
QUI.EndHorizontal();
QUI.Space(SPACE_2 * showArrowAnimBool.faded);
}
QUI.EndVertical();
}
QUI.EndFadeGroup();
}
/// <summary>
/// Initializes a new instance of the class with reference to the UIDrawer and the UIDrawerBehaviorType,
/// of the UIDrawerBehavior, that triggered that sent this message
/// </summary>
/// <param name="drawer"> Reference to the UIDrawer that sent this message </param>
/// <param name="type"> UIDrawerBehaviorType of the UIDrawerBehavior that triggered the UIDrawer to send this message </param>
public UIDrawerMessage(UIDrawer drawer, UIDrawerBehaviorType type)
{
Drawer = drawer;
Type = type;
}
void Awake()
{
main = this;
SetUpChildrenObj();
}
