public void Initialize(Hero hero, UpgradeTree tree, HeroUpgrade upgrade, Equipment equipment)
{
Hero = hero;
Tree = tree;
Upgrade = upgrade;
Equipment = equipment;
}
/// <summary>
/// Builds the CardData represented by this builder's parameters recursively
/// and registers it and its components with the appropriate managers.
/// </summary>
/// <returns>The newly registered CardData</returns>
public CardData BuildAndRegister(int ChampionIndex = 0)
{
var cardData = this.Build();
Trainworks.Log(LogLevel.Debug, "Adding custom card: " + cardData.GetName());
CustomCardManager.RegisterCustomCard(cardData, this.CardPoolIDs);
var Clan = cardData.GetLinkedClass();
ChampionData ClanChamp = Clan.GetChampionData(ChampionIndex);
ClanChamp.championCardData = cardData;
if (this.ChampionIconPath != null)
{
Sprite championIconSprite = CustomAssetManager.LoadSpriteFromPath(this.BaseAssetPath + "/" + this.ChampionIconPath);
ClanChamp.championIcon = championIconSprite;
}
ClanChamp.starterCardData = StarterCardData;
if (this.UpgradeTree != null)
{
ClanChamp.upgradeTree = UpgradeTree.Build();
}
ClanChamp.championSelectedCue = ChampionSelectedCue;
return(cardData);
}
//******************************************************************************************************************************
//
// FUNCTIONS
//
//******************************************************************************************************************************
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
// Called when this object is created.
/// </summary>
protected override void Start()
{
base.Start();
// Initialize
_ObjectHeight = ObjectHeight;
if (HasABuildingQueue)
{
_BuildingQueue = new List <Abstraction>();
}
// Create upgrade instances & replace the selectable reference
for (int i = 0; i < Selectables.Count; i++)
{
if (Selectables[i] != null)
{
// Check if the selectable option is an upgrade tree
UpgradeTree tree = Selectables[i].GetComponent <UpgradeTree>();
if (tree != null)
{
// Replace reference with the runtime version
UpgradeTree newTree = ObjectPooling.Spawn(tree.gameObject).GetComponent <UpgradeTree>();
Selectables[i] = newTree;
}
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
///
/// </summary>
/// <param name="selectable"></param>
public void UpdateListWithBuildables(List <Abstraction> selectable, BuildingSlot buildingSlotInFocus)
{
_BuildingSlotInstigator = buildingSlotInFocus;
// Reset button click events for all buttons
foreach (var button in _WheelButtons)
{
// Icon button defaults
button.onClick.RemoveAllListeners();
button.onClick.AddListener(() => RefreshButtons(selectable));
// Update slice button defaults
Button slice = button.GetComponent <SelectionWheelUnitRef>().RadialSliceButton;
slice.onClick.RemoveAllListeners();
slice.onClick.AddListener(() => RefreshButtons(selectable));
}
// Clear list & update
_BuildingList.Clear();
int i = 0;
foreach (var obj in selectable)
{
if (obj != null)
{
// If slot is an upgrade
UpgradeTree upgrade = obj.GetComponent <UpgradeTree>();
if (upgrade != null)
{
// Dont update wheel with this button since its the upgrade is maxed out
if (upgrade.HasMaxUpgrade())
{
continue;
}
}
// Update list with new slots
_BuildingList.Add(obj);
// Update reference unit
SelectionWheelUnitRef unitRef = _WheelButtons[i].GetComponent <SelectionWheelUnitRef>();
unitRef.AbstractRef = obj.GetComponent <Abstraction>();
// Update button click event
_WheelButtons[i].onClick.AddListener(delegate { unitRef.AbstractRef.OnWheelSelect(buildingSlotInFocus); });
unitRef.RadialSliceButton.onClick.AddListener(delegate { unitRef.AbstractRef.OnWheelSelect(buildingSlotInFocus); });
}
// No selectable reference for this button item so give it an empty slot description
else
{
// Update reference unit
SelectionWheelUnitRef unitRef = _WheelButtons[i].GetComponent <SelectionWheelUnitRef>();
unitRef.AbstractRef = null;
}
++i;
}
RefreshButtons(selectable);
}
/// <summary>
/// Sets the <c>Interactable </c> property on buttons for upgrades based on the provided <c>UpgradeTree</c>.
/// <param name="tree"><c>UpgradeTree </c> object to set button activation.</param>
/// </summary>
void SetButtonActivation(UpgradeTree tree)
{
foreach (GameObject button in upgradeButtons)
{
tree.valuePairs.TryGetValue(button.GetComponent <TowerType>().Type, out bool isActive);
button.GetComponent <Button>().interactable = isActive;
}
}
public void Initialize(Hero hero, UpgradeTree tree, HeroUpgrade upgrade, int skillIndex)
{
Hero = hero;
Tree = tree;
Upgrade = upgrade;;
Skill = hero.HeroClass.CombatSkillVariants.Find(skill =>
skill.Id == hero.HeroClass.CombatSkills[skillIndex].Id &&
skill.Level == tree.Upgrades.IndexOf(upgrade));
}
public GroupPerkClass(byte _Number, uint[] _ids, byte[] _nextids, bool _CanBeLearned, SkillTree _parent)
{
//Array.ForEach(_ids, x => (UpgradeTree.GetObject(x).Object as Perk).parent = this);
Number = _Number;
ids = _ids;
nextids = _nextids;
CanBeLearned = _CanBeLearned;
parent = _parent;
FocusedPerk = UpgradeTree.GetPerk(ids[UpgradeLevel]);
}
public UpgradeTree GetVisual(SkillType ST)
{
UpgradeTree result = null;
switch (ST)
{
case SkillType.Illusion: result = IllusionVisual; break;
case SkillType.Conjuration: result = ConjurationVisual; break;
case SkillType.Destruction: result = DestructionVisual; break;
case SkillType.Restoration: result = RestorationVisual; break;
case SkillType.Alteration: result = AlterationVisual; break;
case SkillType.Enchanting: result = EnchantingVisual; break;
case SkillType.Smithing: result = SmithingVisual; break;
case SkillType.HeavyArmor: result = HeavyArmorVisual; break;
case SkillType.Block: result = BlockVisual; break;
case SkillType.Twohanded: result = TwohandedVisual; break;
case SkillType.Onehanded: result = OnehandedVisual; break;
case SkillType.Marksman: result = MarksmanVisual; break;
case SkillType.LightArmor: result = LightArmorVisual; break;
case SkillType.Sneak: result = SneakVisual; break;
case SkillType.Lockpicking: result = LockpickingVisual; break;
case SkillType.Pickpocket: result = PickpocketVisual; break;
case SkillType.Speechcraft: result = SpeechcraftVisual; break;
case SkillType.Alchemy: result = AlchemyVisual; break;
}
return(result);
}
void Start()
{
player = GameObject.FindGameObjectWithTag("Player").GetComponent <Player>();
if (FirstPerkId != 0)
{
//Debug.Log((UpgradeTree.GetPerk(FirstPerkId)).name);
//Debug.Log(player.GetTree((UpgradeTree.GetPerk(FirstPerkId).skillType))); //.GroupPerks[0].ids[0]
ThisPerk = Array.Find(player.GetTree((UpgradeTree.GetObject(FirstPerkId).Object as Perk).skillType).GroupPerks, x => x.ids[0] == FirstPerkId);
if (ThisPerk != null)
{
lvl.text = (ThisPerk.FocusedPerk.NeededLevelToLearn) + "lvl";
PerkName.text = ThisPerk.FocusedPerk.name;
//tree = transform.GetComponentInParent<UpgradeTree>();
}
//Debug.Log(ThisPerk);
//ThisPerk = Array.Find(player.GetTree((UpgradeTree.GetObject(FirstPerkId).Object as Perk).skillType).GroupPerks, x => { uint k = Array.Find(x.ids, y => y == FirstPerkId); if (k != 0) Debug.Log("!@!"); return k != 0; });
}
//ThisPerk =
}
public bool TryLearn()
{
if (CanBeLearned == false)
{
parent.character.perkUpgradeMenu.ShowMessage("Необходимо выучить предыдущие навыки.");
}
else if (learned)
{
parent.character.perkUpgradeMenu.ShowMessage("Навык уже выучен.");
}
else if (parent.character.GetSkillValue(UpgradeTree.GetPerk(ids[UpgradeLevel]).skillType) < UpgradeTree.GetPerk(ids[UpgradeLevel]).NeededLevelToLearn)
{
parent.character.perkUpgradeMenu.ShowMessage("У вас недостаточный уровень навыка " + parent.name + "."); //ActiveSkillTree
}
else
{
UpgradeTree.GetPerk(ids[UpgradeLevel]).LearnEnd(parent.character, Number);
UpgradeLevel++;
if (nextids != null)
{
if (nextids.Length > 0)
{
if (UpgradeLevel == 1)
{
Array.ForEach(nextids, x => { if (x < parent.GroupPerks.Length)
{
if (parent.GroupPerks[x] != null)
{
parent.GroupPerks[x].CanBeLearned = true;
}
}
}); //UpgradeTree.GetPerk(x).Cas
}
}
}
return(true);
}
return(false);
}
void Start()
{
flow = new Flow();
sessionStats = new Stats();
//Load techtree
industrialTech = JsonUtility.FromJson <TechTree>(Resources.Load <TextAsset>("Techs/industrialTech").ToString());
logisticTech = JsonUtility.FromJson <TechTree>(Resources.Load <TextAsset>("Techs/logisticTech").ToString());
scientificTech = JsonUtility.FromJson <TechTree>(Resources.Load <TextAsset>("Techs/scientificTech").ToString());
workshop = JsonUtility.FromJson <UpgradeTree>(Resources.Load <TextAsset>("Techs/workshop").ToString());
//Load starting world state
save = new SaveFile();
GetComponent <Builder>().SetStartingState();
if (!save.Load())
{
GetComponent <Builder>().GenerateDeposits();
}
if (save.saveData != null && save.saveData.Count() > 0)
{
save.Restore();
}
Globals.GetInterface().LoadWorkshop();
if (GameObject.FindGameObjectsWithTag("Machine").ToList().Find((x) => x.GetComponent <Machine>().type.Equals("Storage")))
{
Camera.main.GetComponent <CameraHandler>().CenterCamera(GameObject.FindGameObjectsWithTag("Machine").ToList().Find((x) => x.GetComponent <Machine>().type.Equals("Storage")).GetComponent <Machine>().GetCenterPoint());
}
else
{
Camera.main.GetComponent <CameraHandler>().CenterCamera(save.GetGrid()[save.GetGrid().GetLength(0) / 2, save.GetGrid().GetLength(1) / 2].transform.position);
}
}
public void UpdatePurchaseSlot(Hero hero, UpgradeTree upgradeTree, HeroUpgrade upgrade, int skillIndex)
{
Tree = upgradeTree;
Upgrade = upgrade;
UpdateSkill(hero, skillIndex);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
///
/// </summary>
/// <param name="upgrade"></param>
public void SetUpgradeAttached(UpgradeTree upgrade)
{
_Upgrade = upgrade;
}
public void UpgradeDescriptionText(GroupPerkClass p)
{
PerkDescriptionText.text = (UpgradeTree.GetPerk(p.ids[p.UpgradeLevel])).Description;
}
public void ShowNeededLevelValue(GroupPerkClass group)
{
LeftInfo.text = "Необходимо : " + ((UpgradeTree.GetObject(group.ids[group.UpgradeLevel]).Object as Perk).NeededLevelToLearn);
}
