public TechTree(TechTree baseTree)
{
root = new List <TechBranch>();
root.AddRange(baseTree.root);
unlockedBranches = new List <int>();
SetInitialUnlockedBranches();
}
void INotifyCreated.Created(Actor self)
{
health = self.TraitOrDefault <IHealth>();
layer = self.World.WorldActor.TraitOrDefault <BuildableTerrainLayer>();
bi = self.World.WorldActor.Trait <BuildingInfluence>();
techTree = self.Owner.PlayerActor.TraitOrDefault <TechTree>();
}
public override void Initialize()
{
var highDensityAutomation = TechTree.CreateTech(TECH_HIGHDENSITYAUTOMATION);
TechTree.AddRequirement(highDensityAutomation, TechTree.GetTech("ParallelAutomation"));
TechTree.AddRequirement(highDensityAutomation, TechTree.GetTech("DupeTrafficControl"));
}
// Update is called once per frame
void Update()
{
if (Game.GetSelected() != null && !Game.GetSelected().Used())
{
canvas.enabled = true;
}
else
{
canvas.enabled = false;
}
if (TechTree.researchCompleted)
{
foreach (Transform child in content.transform)
{
GameObject.Destroy(child.gameObject);
}
foreach (Tower t in TechTree.GetAvailable())
{
GameObject button = Instantiate(buttonPrefab);
PurchaseButtonScript pbs = button.GetComponent <PurchaseButtonScript>();
pbs.tower = t;
button.transform.SetParent(content.transform);
}
TechTree.researchCompleted = false;
}
}
public static TechTree LoadTechTree()
{
TextAsset textAsset = (TextAsset)Resources.Load("TechTree");
XmlSerializer serializer = new XmlSerializer(typeof(TechTree));
TechTree test = serializer.Deserialize(new StringReader(textAsset.text)) as TechTree;
return(test);
/*XmlSerializer serializer = new XmlSerializer(typeof(TechTree));
* FileStream stream = new FileStream(Application.persistentDataPath + "/techtree.xml", FileMode.Create);
*
* TechTree test = new TechTree();
*
* TechBranch root = new TechBranch();
* root.id = 0;
* root.name = "test0";
* root.costTechPoints = 20;
*
* TechBranch tb = new TechBranch();
* tb.id = 1;
* tb.name = "child";
* tb.costTechPoints = 40;
*
* root.children.Add(tb);
*
* test.tree.Add(root);
* test.tree.Add(tb);
*
* serializer.Serialize(stream, test);
* stream.Close();*/
}
protected override void Apply(AttributeLoader loader, object wrapperObj)
{
if (!(wrapperObj is FactionAttributesWrapper w))
{
throw new System.InvalidCastException();
}
loader.ApplyPPatch(FactionName, () => w.FactionName);
loader.ApplyPPatch(ID, () => w.ID);
loader.ApplyPPatch(VOName, () => w.VOName);
loader.ApplyPPatch(VOAssetBundle, () => w.VOAssetBundle);
loader.ApplyPPatch(MusicTrigger, () => w.MusicTrigger);
loader.ApplyPPatch(ScaleWithDynamicDifficulty, () => w.ScaleWithDynamicDifficulty);
if (TechTree != null)
{
using (loader.logger.BeginScope($"TechTree:"))
{
var w2 = new TechTreeAttributesWrapper(w.TechTree);
TechTree.Apply(loader, w2, null);
w.TechTree = w2;
}
}
if (GlobalBuffs != null)
{
var l = w.GlobalBuffs?.Select(x => new UnitTypeBuffWrapper(x)).ToList() ?? new List <UnitTypeBuffWrapper>();
loader.ApplyLPatch(GlobalBuffs, l, () => new UnitTypeBuffWrapper(), nameof(UnitTypeBuff));
w.GlobalBuffs = l.Where(x => x != null).ToArray();
}
}
// Use this for initialization
void Start()
{
Tiles tiles = new Tiles(tilePrefab);
Tile center = tiles.GetTile(Tiles.SIZE / 2, Tiles.SIZE / 2);
GameObject tower = Instantiate(towerPrefab, new Vector3(Tiles.SIZE / 2 * 15, 0f, Tiles.SIZE / 2 * 15), towerPrefab.transform.rotation);
Tower baseTower = new Tower(0, "Base", 100, 100, 0);
TowerInstance towerInstance = new TowerInstance(baseTower, center, tower);
TowerScript script = tower.GetComponent <TowerScript>();
script.tower = towerInstance;
script.tile = center;
center.SetUsed(true);
center.Hold(towerInstance);
TechTree.AddTower(false, new AttackTower(10, "Basic Tower", 10, 0, 35, 5, 10));
TechTree.AddTower(false, new ResourceTower(10, "Small Tree", 10, 10, 200, 1));
TechTree.AddTower(false, new UpgradeTower(25, "Upgrade Tower", 35, 0, 25));
TechTree.AddTower(true, new AttackTower(25, "Better Tower", 15, 0, 75, 10, 15));
}
private IEnumerator InvasionCoroutine()
{
bool victory = false;
bool defeat = false;
while (!victory && !defeat)
{
victory = BacteriasManager.singleton.livingBacteriasCount == 0;
defeat = PlayerCore.singleton.dead;
yield return(null);
}
if (victory && defeat)
{
Debug.Log("Draw !");
}
else if (victory)
{
Debug.Log("Victory !");
}
else
{
Debug.Log("Defeat !");
}
if (victory)
{
PlayerCore.singleton.RegenerateAfterWave();
m_playerResources *= 1 + m_cellularDivisionFactor * TechTree.TechRank(TechID.Adapt_CellDivision);
}
SetGamePhase(GamePhase.Preparation);
}
void Start()
{
Instance = this;
Nodes = new List<TechNode>();
ModifyingTree = true;
}
protected override void Created(Actor self)
{
// Special case handling is required for the Player actor.
// Created is called before Player.PlayerActor is assigned,
// so we must query other player traits from self, knowing that
// it refers to the same actor as self.Owner.PlayerActor
var playerActor = self.Info.Name == "player" ? self : self.Owner.PlayerActor;
techTree = playerActor.Trait <TechTree>();
var validFactions = self.TraitOrDefault <ValidFactions>();
// if ValidFactions trait is present and the current faction is not listed in it, switch the faction to a valid one if a player of that faction exists in the game
if (
validFactions != null &&
Info.Factions.Any() &&
!validFactions.Info.Factions.Contains(faction))
{
var players = self.World.Players.Where(p => !p.NonCombatant && p.Playable);
foreach (var p in players)
{
if (validFactions.Info.Factions.Contains(p.Faction.InternalName))
{
faction = p.Faction.InternalName;
break;
}
}
}
Update();
base.Created(self);
}
public TechTreeWrapper(TechTree other)
{
Tiers = other.Tiers?.ToArray();
Upgrades = other.Upgrades?.ToArray();
TechTreeName = other.TechTreeName;
IconSpriteName = other.IconSpriteName;
}
void Start()
{
Instance = this;
Nodes = new List <TechNode>();
ModifyingTree = true;
}
public GameDefinition(int complexity, int seed, TechTree techTree, Battlefield battlefield, Objective[] objectives)
{
Complexity = complexity;
Seed = seed;
TechTree = techTree;
Battlefield = battlefield;
Objectives = objectives;
}
public Research(StrategyGame game)
{
InitializeComponent();
_game = game;
_tree = game.TechTree[0];
RefreshItems();
}
void Start()
{
tree = aihandler.player.techTree;
aibuilding = aihandler.aibuilding;
airesource = aihandler.airesource;
InvokeRepeating("Recalculate", 7 + Random.value * 3, 10);
}
void INotifyCreated.Created(Actor self)
{
developerMode = self.Owner.PlayerActor.Trait<DeveloperMode>();
techTree = self.Owner.PlayerActor.Trait<TechTree>();
productionTraits = self.TraitsImplementing<BuilderUnit>().ToArray();
CacheProducibles(self.Owner.PlayerActor);
}
protected override void OnDealDamage(Unit unit, float damagesDealt)
{
base.OnDealDamage(unit, damagesDealt);
if (TechTree.TechRank(TechID.Evol_Defense) > 0)
{
RecoverHealth(damagesDealt * TechTree.TechRank(TechID.Evol_Defense) * m_techLeechFactor);
}
}
public static void Translate(Vote vote, string raw)
{
Dictionary <TechTeam, ResearchFrame> parsedVote = new Dictionary <TechTeam, ResearchFrame>();
/* Assumes Federation will be first Entity listed, and the tech tree used by the Federation the first tech tree listed.
* Otherwise the Entity needs to be passed in or defined in a static member somewhere, and the Entity needs to store the
* tech tree it is using. */
TechTree usedTree = Master.MasterTreeList[0];
Entity votedOn = Master.MasterEntityList[0];
using (var sr = new System.IO.StringReader(raw))
{
string line;
while ((line = sr.ReadLine()) != null)
{
if (line.Contains(":"))
{
string[] split = line.Split(':');
int start = split[0].LastIndexOf(']') + 1;
string team = split[0].Substring(start, split[0].Length - start);
string newProject;
if (split[1].Contains("->"))
{
string[] projects = split[1].Split(new[] { "->" }, StringSplitOptions.None);
newProject = projects[1];
}
else
{
newProject = split[1];
}
team.Trim();
newProject.Trim();
TechTeam techTeam = votedOn.Teams.Find(tt => tt.IdTag == team);
ResearchFrame frame = usedTree.Find(newProject);
if (techTeam != null && frame != null)
{
parsedVote.Add(techTeam, frame);
}
}
else if (line.Contains("[BOOST]"))
{
int start = line.LastIndexOf(']') + 1;
string[] teams = line.Substring(start, line.Length - start).Split(',');
foreach (String team in teams)
{
team.Trim();
TechTeam techTeam = votedOn.Teams.Find(tt => tt.IdTag == team);
if (techTeam != null)
{
techTeam.AssignedBoosts += 1;
}
}
}
}
}
}
public static TechTree FindTechTree()
{
if (!_techTree)
{
_techTree = GameObject.Find("TechTree").GetComponent <TechTree>();
}
return(_techTree);
}
public void OnOwnerChanged(Actor self, Player oldOwner, Player newOwner)
{
techTree = newOwner.PlayerActor.Trait <TechTree>();
if (Info.ResetOnOwnerChange)
{
faction = newOwner.Faction.InternalName;
Reset(self);
}
}
public static void Cleanup(ProgressFrame frame, TechTree researcher)
{
// If all Lines are complete, we can mark the frame itself as complete.
if (frame.Lines.All(x => x.Progress >= x.Line.RequiredResearch))
{
frame.IsComplete = true;
frame.IsActive = false;
frame.IsAccessible = false;
}
}
//==============================================================================
// applyEffects
//==============================================================================
public void applyEffects(TechTree techTree)
{
long count = mTechEffects.Count;
for (int i = 0; i < count; i++)
{
TechEffect techEffect = mTechEffects[i];
techEffect.apply(techTree);
}
}
private void Awake()
{
m_previousNode = transform.parent.GetComponent <TechNode>();
m_root = GetComponentInParent <TechTree>();
m_material = GetComponent <Renderer>().material;
if (m_previousNode == null)
{
InitDepth();
}
}
private void UpdateBuffs()
{
m_staminaBuff = TechTree.TechRank(TechID.Fight_Stamina) * m_staminaBuffFactor;
m_strengthBuff = TechTree.TechRank(TechID.Fight_Strength) * m_strengthBuffFactor;
m_speedBuff = TechTree.TechRank(TechID.Fight_Speed) * m_speedBuffFactor;
m_regenerationBuff = TechTree.TechRank(TechID.Fight_Regeneration) * m_regenerationBuffFactor;
m_armorBuff = TechTree.TechRank(TechID.Fight_Armor) * m_armorBuffFactor;
m_cooperationBuff = TechTree.TechRank(TechID.Fight_Cooperation) * m_cooperationBuffFactor;
m_leechBuff = TechTree.TechRank(TechID.Fight_Leech) * m_leechBuffFactor;
m_berserkBuff = TechTree.TechRank(TechID.Fight_Berserk) * m_berserkBuffFactor;
m_immortalBuff = TechTree.TechRank(TechID.Fight_Immortals) * m_immortalBuffFactor;
}
public override void Initialize()
{
// create techs
var techChemSynth = TechTree.CreateTech(Techs.CHEMICAL_SYNTHESIS);
TechTree.AddRequirement(techChemSynth, TechTree.GetTech("Plastics"));
// var techCarpentry1 = TechTree.CreateTech(TECH_CARPENTRY1);
// TechTree.AddRequirement(techCarpentry1, TechTree.GetTech("BasicRefinement"));
// TechTree.AddRequirement(techCarpentry1, TechTree.GetTech("Agriculture"));
}
protected override void Created(Actor self)
{
// Special case handling is required for the Player actor.
// Created is called before Player.PlayerActor is assigned,
// so we must query other player traits from self, knowing that
// it refers to the same actor as self.Owner.PlayerActor
var playerActor = self.Info.Name == "player" ? self : self.Owner.PlayerActor;
techTree = playerActor.Trait <TechTree>();
base.Created(self);
}
public TreeBuildingView(TechTree techTree, BuildingType buildingType)
: base(buildingType)
{
Builds = techTree.Units
.Where(kvp => buildingType.Builds.Contains(kvp.Key))
.Select(kvp => new TreeUnitView(kvp.Value))
.ToArray();
Researches = techTree.Research
.Where(kvp => kvp.Value.PerformedAt == buildingType)
.Select(kvp => new ResearchView(kvp.Value))
.ToArray();
}
public TechNodeViewModel AddNode(Point pos)
{
var node = new TechNode(GenerateNodeName())
{
Pos = pos
};
var nodeViewModel = new TechNodeViewModel {
TechNode = node
};
TechTree.Add(nodeViewModel);
return(nodeViewModel);
}
protected virtual void Start()
{
buildSpaceRend = buildSpace.GetComponent <Renderer> ();
SelectionUnits = new List <Unit> ();
AddStartResourceLimits();
AddStartResources();
if (isServer && !human && !mother)
{
techTree = (TechTree)Instantiate(ResourceManager.GetTechTree(clan), transform.position, transform.rotation);
techTree.player = this;
InitSpawning();
}
}
protected override void OnDie(Unit killer)
{
base.OnDie(killer);
float bonusFactor = 1;
if (TechTree.TechMaxed(TechID.Evol_NoWaste) && (killer == PlayerCore.singleton))
{
bonusFactor = 2;
}
GameManager.singleton.AddDeadBacteriaResourcesValue(resourcesValue * bonusFactor);
}
public Research(TechTree tree, int[] unlockedTechIds, int currency)
{
InitializeComponent();
FormBorderStyle = FormBorderStyle.FixedDialog;
MaximizeBox = false;
OkButton.Visible = CancelSetButton.Visible = CurrencyPoints.Visible = CurrencyTitle.Visible = true;
_game = null;
_tree = tree;
Currency = currency;
CurrencyPoints.Text = $"{Currency}";
RefreshItems();
}
void Awake()
{
_techTree = this;
}
public CanPowerDown(ActorInitializer init)
{
PowerManager = init.self.Owner.PlayerActor.Trait<PowerManager>();
TechTree = init.self.Owner.PlayerActor.Trait<TechTree>();
normalPower = init.self.Info.Traits.Get<BuildingInfo>().Power;
}
public void OnCapture(Actor self, Actor captor, Player oldOwner, Player newOwner)
{
PowerManager = newOwner.PlayerActor.Trait<PowerManager>();
TechTree = newOwner.PlayerActor.Trait<TechTree>();
}
