private void ClearWave(Allegiance allegiance, int wave)
{
if (wave < 0)
{
return;
}
Dictionary <int, List <BaseCreature> > list;
if (allegiance == Allegiance.Myrmidex)
{
list = MyrmidexTeam;
}
else
{
list = TribeTeam;
}
if (list.ContainsKey(wave))
{
ColUtility.ForEach(list[wave].Where(bc => bc.Alive), bc => bc.Delete());
ColUtility.Free(list[wave]);
list.Remove(wave);
}
}
public int GetFriendlyOnPad()
{
int result;
if (this.OwnerIndex == -1 || !base.Level.Session.MatchSettings.TeamMode)
{
result = -1;
}
else
{
Allegiance allegiance = base.Level.Session.MatchSettings.Teams [this.OwnerIndex];
using (List <Entity> .Enumerator enumerator = base.Level.Players.GetEnumerator()) {
while (enumerator.MoveNext())
{
Player player = (Player)enumerator.Current;
if (!player.Dead && player.Allegiance == allegiance && base.CollideCheck(player, this.Position - Vector2.UnitY))
{
result = player.PlayerIndex;
return(result);
}
}
}
result = -1;
}
return(result);
}
/// <summary>
/// Enables the allegiance's cities to perform an action.
/// </summary>
private void ResetCityActions(Allegiance allegiance)
{
foreach (City city in MapManager.instance.cities)
{
city.ResetAction();
}
}
/// <summary>
/// Initialize unit using selected alllegiance.
/// </summary>
/// <param name="allegiance">Allegiance.</param>
public void Initialize(Allegiance allegiance)
{
Allegiance = allegiance;
flagColorRenderer.color = allegiance == Allegiance.Player ? Color.green : Color.red;
CurrentHealth = MaxHealth;
MovementTilesInRange = new HashSet <Tile>();
}
public void Initialize(Creature template, Allegiance allegiance)
{
_template = template;
_allegiance = allegiance;
Health = _template.InitialHealth;
}
/// <summary>
/// Called when a player joins/exits an Allegiance
/// </summary>
public static void Rebuild(Allegiance allegiance)
{
if (allegiance == null)
{
return;
}
RemoveCache(allegiance);
// rebuild allegiance
allegiance = GetAllegiance(allegiance.Monarch.Player);
// relink players
foreach (var member in allegiance.Members.Keys)
{
var player = PlayerManager.FindByGuid(member);
if (player == null)
{
continue;
}
LoadPlayer(player);
}
// update dynamic properties
allegiance.UpdateProperties();
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int v = reader.ReadInt();
_AllegianceType = (Allegiance)reader.ReadInt();
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
reader.ReadInt();
Allegiance = (Allegiance)reader.ReadInt();
}
public IActionResult Deny([FromRoute] int AllegianceId)
{
Allegiance Model = Context.Allegiances.Where(a => a.Id == AllegianceId).Single();
Model.AlliedOrNot = FriendOrFo.ENEMY;
Model.Accepted = false;
Model.Pending = false;
Context.Allegiances.Update(Model);
Context.SaveChanges();
Clan RequestingClan = Context.Clans.Where(c => c.Id == Model.ClanId).Single();
Clan RequesteeClan = Context.Clans.Where(c => c.Id == Model.ClanId_2).Single();
User User = Context.Users.Where(u => u.ClanId == RequestingClan.Id && u.Role == Clan.Roles.Founder).Single();
if (User != null)
{
Notification NewNotification = new Notification()
{
CreatedAt = DateTime.Now,
Text = $"{RequesteeClan.Name} has denied your alliance request!",
Type = NotificationType.CLAN,
UserId = User.Id,
Unread = true,
};
Context.Notifications.Add(NewNotification);
Context.SaveChanges();
}
return(Ok(Model));
}
/// <summary>
/// Returns the full allegiance structure for any player
/// </summary>
/// <param name="player">A player at any level of an allegiance</param>
public static Allegiance GetAllegiance(IPlayer player)
{
var monarch = GetMonarch(player);
if (monarch == null)
{
return(null);
}
// is this allegiance already loaded / cached?
if (Players.ContainsKey(monarch.Guid))
{
return(Players[monarch.Guid].Allegiance);
}
var allegiance = new Allegiance(monarch.Guid);
if (allegiance.TotalMembers == 1)
{
return(null);
}
AddPlayers(allegiance);
return(allegiance);
}
/// <summary>
/// Removes an Allegiance from the Players lookup table cache
/// </summary>
public static void RemoveCache(Allegiance allegiance)
{
foreach (var member in allegiance.Members)
{
Players.Remove(member.Key);
}
}
public IActionResult New([FromBody] Allegiance Model)
{
Clan RequestingClan = Context.Clans.Where(c => c.Id == Model.ClanId).Single();
Clan RequesteeClan = Context.Clans.Where(c => c.Id == Model.ClanId_2).Single();
if (RequesteeClan != null && RequestingClan != null)
{
Context.Allegiances.Add(Model);
Context.SaveChanges();
Notification NewNotification = new Notification()
{
CreatedAt = DateTime.Now,
Text = $"{RequestingClan.Name} has requested and Alliance with you!",
Type = NotificationType.CLAN,
UserId = (int)HttpContext.Session.GetInt32("UserId"),
Unread = true,
};
Context.Notifications.Add(NewNotification);
Context.SaveChanges();
return(Ok(Model));
}
else
{
return(BadRequest("Missing or Invalid ClanId(s)"));
}
}
public MatchTeamsState(MatchTeams teams)
{
Player1Team = teams.player1Team;
Player2Team = teams.player2Team;
Player3Team = teams.player3Team;
Player4Team = teams.player4Team;
}
public CreatureData(BJCreature creature, int level, List <Skill> skills,
Item soulstone, RankColor rankColor, bool isSummoned)
{
Creature = creature;
Name = creature.Name;
Allegiance = creature.Allegiance;
Level = level;
Creature.Level = Level;
// MaxHP = creature.MaxHP;
// HP = creature.MaxHP;
Attack = creature.BaseDamage;
Soulstone = soulstone;
LevelCosts = Player.Instance.DataBase.LevelCosts;
LevelGoldCosts = Player.Instance.DataBase.LevelGoldCosts;
StatNames = new List <string> {
"MaxHP", "Attack", "Armor", "Speed"
};
RankColor = rankColor;
if (skills != null)
{
Skills = new List <Skill> (skills);
}
else
{
Skills = new List <Skill> ();
}
IsSummoned = isSummoned;
}
public RulerGivenSkillContainerSkill(IRulerGivenSkill InnerSkill, Allegiance al)
{
innerSkillType = InnerSkill.GetType();
Allegiance = al;
masterList = new Dictionary<Player, IRulerGivenSkill>();
var trigger = new AutoNotifyPassiveSkillTrigger(
this,
DistributeSkills,
TriggerCondition.OwnerIsSource
) { IsAutoNotify = false, AskForConfirmation = false };
var trigger2 = new AutoNotifyPassiveSkillTrigger(
this,
(p, e, a) =>
{
if (a.Source.Allegiance == Allegiance && !masterList.ContainsKey(a.Source))
{
DistributeSkills(Owner, null, null);
}
if (a.Source.Allegiance != Allegiance && masterList.ContainsKey(a.Source))
{
ISkill skill = masterList[a.Source];
masterList.Remove(a.Source);
Game.CurrentGame.PlayerLoseAdditionalSkill(a.Source, skill, true);
}
},
TriggerCondition.Global
) { IsAutoNotify = false, AskForConfirmation = false };
Triggers.Add(GameEvent.PlayerGameStartAction, trigger);
Triggers.Add(GameEvent.PlayerChangedAllegiance, trigger2);
IsAutoInvoked = null;
IsRulerOnly = true;
}
/// <summary>
/// Returns the full allegiance structure for any player
/// </summary>
/// <param name="player">A player at any level of an allegiance</param>
public static Allegiance GetAllegiance(IPlayer player)
{
if (player == null)
{
return(null);
}
var monarch = GetMonarch(player);
if (monarch == null)
{
return(null);
}
// is this allegiance already loaded / cached?
if (Players.ContainsKey(monarch.Guid))
{
return(Players[monarch.Guid].Allegiance);
}
// try to load biota
var allegianceID = DatabaseManager.Shard.BaseDatabase.GetAllegianceID(monarch.Guid.Full);
var biota = allegianceID != null?DatabaseManager.Shard.BaseDatabase.GetBiota(allegianceID.Value) : null;
Allegiance allegiance;
if (biota != null)
{
var entityBiota = ACE.Database.Adapter.BiotaConverter.ConvertToEntityBiota(biota);
allegiance = new Allegiance(entityBiota);
}
else
{
allegiance = new Allegiance(monarch.Guid);
}
if (allegiance.TotalMembers == 1)
{
return(null);
}
if (biota == null)
{
allegiance = WorldObjectFactory.CreateNewWorldObject("allegiance") as Allegiance;
allegiance.MonarchId = monarch.Guid.Full;
allegiance.Init(monarch.Guid);
allegiance.SaveBiotaToDatabase();
}
AddPlayers(allegiance);
//if (!Allegiances.ContainsKey(allegiance.Guid))
//Allegiances.Add(allegiance.Guid, allegiance);
Allegiances[allegiance.Guid] = allegiance;
return(allegiance);
}
public override void SetAllegiance(Allegiance allegiance)
{
base.SetAllegiance(allegiance);
foreach (var attackComponent in AttackComponents)
{
attackComponent.SetAllegiance(allegiance);
}
}
public IActionResult RemoveAllegiance([FromRoute] int AllegianceId)
{
Allegiance allegiance = Context.Allegiances.Where(a => a.Id == AllegianceId).Single();
Context.Allegiances.Remove(allegiance);
Context.SaveChanges();
return(Ok());
}
private void WriteAllegiance(Allegiance allegiance)
{
writer.Write("ally ");
writer.Write(allegiance.T5Code);
writer.Write(" ");
writer.Write(allegiance.Name);
writer.WriteLine();
}
public void GameOver(Allegiance winner)
{
mState = GameState.GameOver;
// zu faul neue variablen einzuführen...
// OptionsMenu = gewonnen
// MainMenu = verloren
mMenuState = winner == Allegiance.Player ? MenuState.OptionsMenu : MenuState.MainMenu;
}
public Hero(string name, bool isMale, Allegiance a, int health, List<ISkill> skills)
{
Allegiance = a;
Skills = skills;
Name = name;
MaxHealth = health;
IsMale = isMale;
}
public Hero(string name, bool isMale, Allegiance a, int health, params ISkill[] skills)
{
Allegiance = a;
Skills = new List<ISkill>(skills);
Name = name;
MaxHealth = health;
IsMale = isMale;
}
public Emperor(string leaderName, Allegiance allegiance)
{
this.allegiance = allegiance;
this.leaderName = leaderName;
this.gold = 100;
this.brain = new EmperorBrain(this);
}
public override bool TeamCheckForRoundOver(out Allegiance surviving)
{
if (this.Session.CurrentLevel.LivingPlayers == 0)
{
surviving = Allegiance.Neutral;
return(true);
}
bool[] array = new bool[2];
bool gottaBustGhosts = ((MyMatchVariants)(this.Session.MatchSettings.Variants)).GottaBustGhosts;
List <Entity> players = this.Session.CurrentLevel[GameTags.Player];
for (int i = 0; i < players.Count; i++)
{
MyPlayer player = (MyPlayer)players[i];
if (!player.Dead || (gottaBustGhosts && player.spawningGhost))
{
array[(int)player.Allegiance] = true;
}
}
List <Entity> playerCorpses = this.Session.CurrentLevel[GameTags.Corpse];
for (int i = 0; i < playerCorpses.Count; i++)
{
MyPlayerCorpse playerCorpse = (MyPlayerCorpse)playerCorpses[i];
if (playerCorpse.Revived || (gottaBustGhosts && playerCorpse.spawningGhost))
{
array[(int)playerCorpse.Allegiance] = true;
}
}
if (gottaBustGhosts && players.Count >= 1)
{
List <Entity> playerGhosts = this.Session.CurrentLevel[GameTags.PlayerGhost];
for (int i = 0; i < playerGhosts.Count; i++)
{
PlayerGhost playerGhost = (PlayerGhost)playerGhosts[i];
if (playerGhost.State != 3)
{ // Ghost not dead
array[(int)playerGhost.Allegiance] = true;
}
}
}
if (array[0] == array[1])
{
surviving = Allegiance.Neutral;
}
else if (array[0])
{
surviving = Allegiance.Blue;
}
else
{
surviving = Allegiance.Red;
}
return(!array[0] || !array[1]);
}
public void AddUnits(UnitType type, Vector3 location, int count, Allegiance allegiance)
{
if (count == 0)
{
return;
}
if (mSquadMembers == null)
{
mSquadMembers = new List <Unit>();
}
mAllegiance = allegiance;
this.transform.position = location;
GameObject unitPrefab = TextureResource.GetUnitPrefab(type, (allegiance == Allegiance.Rodelle));
List <Vector3> randomPositions = this.RandomSectionLocations(count, kSquadMemberWidth * 1.5f);
for (int i = 0; i < count; ++i)
{
// instantiate the unit from the prefab
GameObject o = (GameObject)Instantiate(unitPrefab);
Unit u = (Unit)o.GetComponent <Unit>();
u.Squad = this;
mSquadMembers.Add(u);
u.Allegiance = mAllegiance;
// offset from squad center
Vector3 memberPosition = this.transform.position;
memberPosition += randomPositions [i];
u.transform.position = memberPosition;
}
float squadSpeed = UnitStats.GetStat(SquadLeader.UnitType, UnitStat.MovementSpeed);
// Sets the speed of the squad to the speed of the squad leader
for (int i = 0; i < mSquadMembers.Count; ++i)
{
// TODO refactor this process. Remove the public access to MoveSpeed and implement a better method of
// modifying a unit's base stats
mSquadMembers[i].MoveSpeed = squadSpeed;
}
if (SquadLeader.Allegiance == Allegiance.AI) // Reduce the sight range of armed enemy peasants
{
SquadLeader.SightRange = UnitStats.GetStat(UnitType.Peasant, UnitStat.SightRange);
}
float sightRadius = SquadLeader.SightRange;
this.GetComponent <CircleCollider2D> ().radius = 3;
this.GetComponent <SpriteRenderer>().transform.localScale = new Vector3(sightRadius / 3, sightRadius / 3, 0f);
this.SetDestination(this.RallyPoint);
this.ShowSelector(false);
}
/// <summary>
/// Creates a minion which automatically has a starting planet and a target planet.
/// </summary>
/// <param name="initialContainer"></param>
/// <param name="targetContainer"></param>
/// <param name="allegiance"></param>
/// <param name="count">The amount of minions that are covered by this game object</param>
public Minion(IMinionContainer initialContainer, IMinionContainer targetContainer, Allegiance allegiance, int count)
: base(initialContainer.Position, allegiance)
{
Count = count;
mTargetReached = false;
mTargetContainer = targetContainer;
mMovement = new MinionMovement(initialContainer, targetContainer, this);
mVisibility = new Visibility(this);
}
public void OnTeamRevive(Player player)
{
Allegiance allegiance = default(Allegiance);
if (!((MyRoundLogic)base.Session.RoundLogic).TeamCheckForRoundOver(out allegiance))
{
base.Session.CurrentLevel.Ending = false;
}
}
public void SwapTurnIndicator(Allegiance newTeamTurn)
{
HideTurnIndicator(() =>
{
m_TurnIndicator.UpdateTurnIndicator(newTeamTurn);
m_TurnIndicatorImage.color = m_TurnIndicatorColors[(int)newTeamTurn];
ShowTurnIndicator();
});
}
private MyPlayerCorpse(string corpseSpriteID, Allegiance teamColor, Vector2 position, Facing facing, int playerIndex, int killerIndex) : base(corpseSpriteID, teamColor, position, facing, playerIndex, killerIndex)
{
// ADDED--
if (this.TeamColor != teamColor)
{
teamColor = this.TeamColor;
}
// --ADDED
}
public Entity SetAllegiance(Allegiance allegiance)
{
Allegiance = allegiance;
foreach (var component in Components)
{
component.Value.SetAllegiance(Allegiance);
}
return(this);
}
public Hero(string name, bool isMale, Allegiance a, int health, params ISkill[] skills)
{
Allegiance = a;
Skills = new List <ISkill>(skills);
Name = name;
MaxHealth = health;
IsMale = isMale;
HeroConvertFrom = string.Empty;
}
public IEnumerable <PlayerMobile> GetPlayers(Allegiance allegiance)
{
if (BattleRegion == null)
{
return(null);
}
return(BattleRegion.GetEnumeratedMobiles().OfType <PlayerMobile>().Where(p => MyrmidexInvasionSystem.IsAlliedWith(p, allegiance)));
}
public Predator(Vector2 initialPosition, Allegiance allegiance)
: base(initialPosition, allegiance)
{
Health = GlobalValues.GetInstance().PredatorHealth;
mMovement = new FreeMovement(this);
mSpaceshipAttackBehaviour = new SpaceshipAttackBehaviour(this);
mMinionAttackBehaviour = new MinionAttackBehaviour(this);
mVisibility = new Visibility(this);
}
public CardData(string name, Allegiance allegiance, int initiative, int hp, List <CardAbility> abilities, CardAbility[] slottedAbilities)
{
_name = name;
_allegiance = allegiance;
_baseInitiative = initiative;
_baseHp = hp;
_baseAbilities = abilities;
_slottedAbilities = slottedAbilities;
}
public Planet(Vector2 initialPosition, Allegiance allegiance, PlanetSize size, int numberOfMinions)
: base(initialPosition, allegiance)
{
MinionIncrementPerSecond = Global.MinionIncrementPerSecond[size];
mSize = size;
Shield = 0;
MinionCount = numberOfMinions;
mObstruction = new Obstruction(initialPosition, CollisionRadius);
mVisibility = new Visibility(this);
}
public static List <Group> ParseArmy(string armyDefinition, Allegiance allegiance)
{
var army = new List <Group>();
var lines = armyDefinition.Trim().Split("\n");
var i = 0;
// First line contains the army's name - skip
foreach (var line in lines.Skip(1))
{
var regex = new Regex(@"(\d+) units each with (\d+) hit points (\((.*)\) )?with an attack that does (\d+) (\w+) damage at initiative (\d+)");
var match = regex.Match(line.Trim());
var unitCount = int.Parse(match.Groups[1].Value);
var hitPoints = int.Parse(match.Groups[2].Value);
var attackDamage = int.Parse(match.Groups[5].Value);
var initiative = int.Parse(match.Groups[7].Value);
var attackType = ParseAttackType(match.Groups[6].Value);
var group = new Group
{
Allegiance = allegiance,
Id = i,
UnitCount = unitCount,
HitPoints = hitPoints,
AttackDamage = attackDamage,
Initiative = initiative,
AttackType = attackType
};
// Immunities and weaknesses are hard to regex.
// One, both or neither may be present, and the order is unpredictable.
var immunitiesAndWeaknesses = match.Groups[4].Value;
var parts = immunitiesAndWeaknesses.Split("; ");
var immunityPart = parts.SingleOrDefault(p => p.Contains("immune to"));
var weaknessPart = parts.SingleOrDefault(p => p.Contains("weak to"));
if (immunityPart != null)
{
group.Immunities = immunityPart.Replace("immune to ", "").Split(", ").Select(ParseAttackType).Aggregate((at, at2) => at | at2);
}
if (weaknessPart != null)
{
group.Weaknesses = weaknessPart.Replace("weak to ", "").Split(", ").Select(ParseAttackType).Aggregate((at, at2) => at | at2);
}
army.Add(group);
i++;
}
return(army);
}
/*
* //Needs to happen in GameSetup
* void Start () {
* resourceDictionary = new Dictionary<Allegiance, int>();
* resourceDictionary.Add(Allegiance.Team1, 0);
* resourceDictionary.Add(Allegiance.Team2, 0);
* Display = "Resources: ";
* DisplayAlt = "Enemy: ";
* countText = GameObject.Find("CountText").GetComponent<Text>();
* countTextAlt = GameObject.Find("EnemyCountText").GetComponent<Text>();
* SetResourceText(Allegiance.Team1);
* SetResourceText(Allegiance.Team2);
* }
*/
// Create a standalone function that can update the 'countText' UI and check if the required amount to win has been achieved
public static void SetResourceText(Allegiance allegience)
{
if (allegience == Allegiance.Team1)
{
countText.text = Display + resourceDictionary[allegience].ToString();
}
else
{
countTextAlt.text = DisplayAlt + resourceDictionary[allegience].ToString();
}
}
public void GetAllSquads(Allegiance allegiance)
{
this.squads.Clear();
foreach (Squad s in GameObject.FindObjectsOfType<Squad>())
{
if (s.squadAllegiance == allegiance)
{
this.squads.Add(s);
}
this.squads = squads.OrderBy(go => go.name).ToList();
}
///TODO Sort squads by numeric order in gameobjects names
}
public DeathStar(Vector2 initialPosition, Allegiance allegiance, int minionCount)
: base(initialPosition, allegiance)
{
MinionCount = minionCount;
mMovementMode = false;
Shield = 0;
AttackTimer = 0;
mSpaceshipAttackMode = false;
mMovementMode = false;
mPlanetAttackMode = false;
mSpaceshipAttackBehaviour = new SpaceshipAttackBehaviour(this);
mPlanetAttackBehaviour = new PlanetAttackBehaviour(this, AttackSpeedPlanet);
mMovement = new FreeMovement(this);
mVisibility = new Visibility(this);
}
// Use this for initialization
void Start ()
{
this.energy = 100;
this.allegiance = this.GetComponent<AllegianceDesignator>().Allegiance;
this.energyConsum = new EnergyConsumtionMsg()
{
Allegiance = allegiance,
EnergyConsumed = 0,
Station = Stations.Pilot
};
this.sendConsumtionAt = Time.time + CONSUMTION_SEND_RATE;
CoreNetwork.Instance.Subscribe(this);
}
public void ChangeAllegiance(IGameObject unit, Allegiance newAllegiance)
{
if (unit is IVisible)
{
IVisible visible = (IVisible) unit;
Allegiance oldAllegiance = visible.Allegiance;
if (oldAllegiance != Allegiance.Player)
PlayerFogManager.UnregisterUnit(visible);
if (oldAllegiance != Allegiance.Computer)
PcFogManager.UnregisterUnit(visible);
if (newAllegiance != Allegiance.Player)
PlayerFogManager.RegisterUnit(visible);
if (newAllegiance != Allegiance.Computer)
PcFogManager.RegisterUnit(visible);
}
}
public void trigger(Allegiance allIn)
{
if (allIn == allegance)
{
intensity+=intensityIncrement;
}
else
{
intensity-=intensityIncrement;
if (intensity < 0)
{
allegance = allIn;
intensity = intensityIncrement;
}
}
}
Allegiance? handleAllegiance(Allegiance allegianceIn)
{
List<Allegiance> allegianceKeys = new List<Allegiance>(allegiances.Keys);
foreach(Allegiance allegiance in allegianceKeys )
{
if (allegiance == allegianceIn)
allegiances[allegiance] = allegiances[allegiance] + allegianceIncValue;
else
allegiances[allegiance] = allegiances[allegiance] - allegianceDecValue ;
Mathf.Clamp(allegiances[allegiance], 0f, 100f);
}
if ( allegiances[allegianceIn] > allegianceThreshold )
return allegianceIn;
else
return null;
}
// Use this for initialization
void Start()
{
ui = this.GetComponent<UIController> ();
if(GameObject.Find ("Settings") != null){
myAllegiance = GameObject.Find ("Settings").GetComponent<Settings> ().playerAllegiances [this.GetComponent<PlayerController> ().player-1];
//Debug.Log(string.Format("{0}_{1}", this.GetComponent<PlayerController> ().player,myAllegiance));
}
this.GetComponent<SpriteRenderer> ().sprite = conf.Sprite [Array.IndexOf (conf.Allegiance, myAllegiance)];
this.BaseSpace.setAllegiance(this.myAllegiance);
this.transform.position = this.BaseSpace.transform.position;
try{
this.GetComponent<PlayerController> ().startAnimation ();
}catch(Exception e){
}
}
public override List<int> GetPlayersOfAllegiance(Allegiance allegiance)
{
List<int> list = new List<int>();
if ((this.player1Team == allegiance) && TFGame.Players[0])
{
list.Add(0);
}
if ((this.player2Team == allegiance) && TFGame.Players[1])
{
list.Add(1);
}
if ((this.player3Team == allegiance) && TFGame.Players[2])
{
list.Add(2);
}
if ((this.player4Team == allegiance) && TFGame.Players[3])
{
list.Add(3);
}
if ((this.player5Team == allegiance) && TFGame.Players[4])
{
list.Add(4);
}
if ((this.player6Team == allegiance) && TFGame.Players[5])
{
list.Add(5);
}
if ((this.player7Team == allegiance) && TFGame.Players[6])
{
list.Add(6);
}
if ((this.player8Team == allegiance) && TFGame.Players[7])
{
list.Add(7);
}
return list;
}
private void WriteAllegiance(Allegiance allegiance)
{
writer.Write("ally ");
writer.Write(allegiance.T5Code);
writer.Write(" ");
writer.Write(allegiance.Name);
writer.WriteLine();
}
protected Spaceship(Vector2 position, Allegiance allegiance)
: base(position, allegiance)
{
Halt();
AttackTimer = 0;
}
/// <summary>Called whenever a unit changes allegiance. Unit still has
/// old allegiance at call.</summary>
public void AllegianceChanged(IGameObject unit, Allegiance newAllegiance)
{
if (unit.Allegiance != Allegiance.Computer && newAllegiance == Allegiance.Computer)
AddAiUnit(unit);
else if (unit.Allegiance == Allegiance.Computer && newAllegiance != Allegiance.Computer)
RemoveAiUnit(unit);
}
public GameObject(Vector2 initialPosition, Allegiance allegiance)
{
Position = initialPosition;
Allegiance = allegiance;
Alive = true;
}
public override Allegiance this[int index]
{
get
{
switch (index)
{
case -1:
return Allegiance.Red;
case 0:
return this.player1Team;
case 1:
return this.player2Team;
case 2:
return this.player3Team;
case 3:
return this.player4Team;
case 4:
return this.player5Team;
case 5:
return this.player6Team;
case 6:
return this.player7Team;
case 7:
return this.player8Team;
}
throw new Exception("Index out of bounds!");
}
set
{
switch (index)
{
case 0:
this.player1Team = value;
return;
case 1:
this.player2Team = value;
return;
case 2:
this.player3Team = value;
return;
case 3:
this.player4Team = value;
return;
case 4:
this.player5Team = value;
return;
case 5:
this.player6Team = value;
return;
case 6:
this.player7Team = value;
return;
case 7:
this.player8Team = value;
return;
}
throw new Exception("Index out of bounds!");
}
}
public override int GetAmountOfPlayersOfAllegiance(Allegiance allegiance)
{
int num = 0;
if ((this.player1Team == allegiance) && TFGame.Players[0])
{
num++;
}
if ((this.player2Team == allegiance) && TFGame.Players[1])
{
num++;
}
if ((this.player3Team == allegiance) && TFGame.Players[2])
{
num++;
}
if ((this.player4Team == allegiance) && TFGame.Players[3])
{
num++;
}
if ((this.player5Team == allegiance) && TFGame.Players[4])
{
num++;
}
if ((this.player6Team == allegiance) && TFGame.Players[5])
{
num++;
}
if ((this.player7Team == allegiance) && TFGame.Players[6])
{
num++;
}
if ((this.player8Team == allegiance) && TFGame.Players[7])
{
num++;
}
return num;
}
public void setAllegiance(Allegiance a)
{
this.Allegiance = a;
this.GetComponentInChildren<BannerSelector> ().SetBanner (conf.CrestSprite[Array.IndexOf(conf.Allegiance, this.Allegiance)]);
}
public MyMatchTeams(Allegiance start)
: base(start)
{
this.player1Team = this.player2Team = this.player3Team = this.player4Team = this.player5Team = this.player6Team = this.player7Team = this.player8Team = start;
}
// Use this for initialization
void Start ()
{
this.allegiance = this.GetComponent<AllegianceDesignator>().Allegiance;
this.nextTargetsUpdate = Time.time + UPDATE_SEND_RATE;
}
public MyPlayer(int playerIndex, Vector2 position, Allegiance allegiance, Allegiance teamColor, PlayerInventory inventory, Player.HatStates hatState, bool frozen, bool flash, bool indicator)
: base(playerIndex, position, allegiance, teamColor, inventory, hatState, frozen, flash, indicator)
{
}
// Stats for conquered Planets
public void PlanetAllegianceChange(Allegiance currentAllegiance, Allegiance newAllegiance)
{
// Debug.WriteLine("Planet Allegiance Changed");
// Player is attacking
if (newAllegiance == Allegiance.Player)
{
if (currentAllegiance == Allegiance.Neutral)
{
// Debug.WriteLine("Player conquered natural planet");
mConqueredNeutralPlanetsPlayer++;
}
if (currentAllegiance == Allegiance.Computer)
{
// Debug.WriteLine("Player conquered enemy planet");
mConqueredEnemyPlanetsPlayer++;
}
if (currentAllegiance == Allegiance.Player)
Debug.WriteLine("BUG: This should never happen.");
}
// Computer is attacking
else if (newAllegiance == Allegiance.Computer)
{
if (currentAllegiance == Allegiance.Neutral)
{
// Debug.WriteLine("AI conquered neutral planet.");
mConqueredNeutralPlanetsKi++;
}
if (currentAllegiance == Allegiance.Player)
{
// Debug.WriteLine("AI conquered player planet.");
mConqueredEnemyPlanetsKi++;
}
}
}
private void WriteBorder(Border border, Allegiance alleg)
{
if (border.ShowLabel && (border.Label != null || alleg != null))
{
writer.Write("label ");
writer.Write(border.LabelPositionHex);
writer.Write(" ");
writer.Write(border.Label ?? alleg.Name);
writer.WriteLine();
}
writer.Write("border ");
writer.Write(border.PathString);
SectorStylesheet.StyleResult ssr = sector.ApplyStylesheet("border", alleg?.T5Code);
Color? color = border.Color ?? ssr.GetColor("color");
if (color.HasValue)
{
writer.Write(" ");
writer.Write(ColorTranslator.ToHtml(color.Value).ToLowerInvariant());
}
writer.WriteLine();
}
void Awake()
{
// Player not found
if (!target1) {
Debug.Log("Player 1 not found!");
} else if (!target2) {
Debug.Log("Player 2 not found!");
}
// Grab Animation component and keep a reference to it
anim = GetComponent<Animator>();
// No Animator component found
if (!anim)
Debug.Log("Animator not found!");
// Grab NavMeshAgent component and keep a reference to it
navAgent = GetComponent<NavMeshAgent>();
// No NavMeshAgent component found
if (!navAgent)
Debug.Log("NavMeshAgent not found!");
scoreScript = gameManager.GetComponent<GameManager>();
allegiance = Allegiance.Neutral;
gameObject.transform.position = neutralSpawns[Random.Range(0, 6)].position;
}
void OnTriggerEnter(Collider c)
{
if (c.gameObject.CompareTag("Projectile")) {
string killer = c.gameObject.GetComponent<Projectile>().shooter;
if ((killer == "Player" && allegiance == Allegiance.Red) ||
(killer == "Player2" && allegiance == Allegiance.Blue) ||
(allegiance == Allegiance.Neutral && (killer == "Player" || killer == "Player2"))) {
health -= c.gameObject.GetComponent<Projectile>().projectileDamage;
bulletHit.Play();
if (health <= 0 && !dead) {
dead = true;
if (allegiance == Allegiance.Neutral) {
if (killer == "Player") {
scoreScript.blueScore++;
allegiance = Allegiance.Blue;
} else if (killer == "Player2") {
scoreScript.redScore++;
allegiance = Allegiance.Red;
}
} else {
allegiance = Allegiance.Neutral;
if (killer == "Player") {
scoreScript.blueScore += 2;
} else if (killer == "Player2") {
scoreScript.redScore += 2;
}
}
}
}
}
}
public void AllegianceChanged(IVisible unit, Allegiance newAllegiance)
{
Point sector = GetSector(unit.Position);
UpdateCounters(unit, sector.X, sector.Y, -1);
UpdateCounters(unit, newAllegiance, sector.X, sector.Y, +1);
}
