public void NextTurn()
{
ActivateCharacter(m_ActiveCharacter, false);
do
{
if (CheckAllDead())
{
StartCoroutine(Event_GameOver(null));
}
NextCharacter();
} while (!m_ActiveTeamStats[m_ActiveCharacterIndex].IsAlive());
m_ActiveCharacter = m_ActiveTeamControllers[m_ActiveCharacterIndex];
ActivateCharacter(m_ActiveCharacter, true);
TurnTimer.Instance.ResetTimer();
if (!m_Freeplay)
{
TeamHandler lastTeam = CheckLastTeamAlive();
if (lastTeam != null)
{
StartCoroutine(Event_GameOver(lastTeam));
}
}
TurnTimer.Instance.RunTimer();
if (m_ProjectileCamera && m_ProjectileCamera.depth > 0)
{
m_ProjectileCamera.depth = 0;
}
}
public IActionResult TeamInfo(int id)
{
var regSeasonRecords = TeamRecordHandler.GetFinalRegularSeasonTeamRecordsForEachYear(id);
var regSeasonCareerRecord = regSeasonRecords.Aggregate((total, next) =>
{
return(new TeamRecord
{
Win = total.Win + next.Win,
Loss = total.Loss + next.Loss,
PointsFor = total.PointsFor + next.PointsFor,
PointsAgainst = total.PointsAgainst + next.PointsAgainst
});
});
var h2hRecords = TeamRecordHandler.GetAccumulatedHead2HeadRecords(id).OrderByDescending(h2h => h2h.Pct).ToList();
var playoffFinalRecords = TeamRecordHandler.GetFinalTeamRecordsForEachYear(id).Where(tr => tr.IsPlayoffs).ToList();
return(View(new TeamInfo
{
Team = TeamHandler.GetById(id),
RegularSeasonRecords = regSeasonRecords,
RegularSeasonCareerRecord = regSeasonCareerRecord,
H2HRecords = h2hRecords,
PlayoffFinalRecords = playoffFinalRecords
}));
}
public virtual void InitAbility(Transform caster)
{
if (initTimes > 0)
{
return;
}
thisTransform = this.transform;
casterT = caster;
casterIDName = casterT.name + casterT.GetComponent <AIBase>().id.ToString();
if (teamHandler == null) //så den inte behöver hämtas flera gånger
{
teamHandler = GameObject.FindGameObjectWithTag("TeamHandler").GetComponent <TeamHandler>();
}
eLayers = new string[0];
fLayers = new List <string>();
teamHandler.GetFriendsAndFoes(LayerMask.LayerToName(caster.gameObject.layer), ref fLayers, ref eLayers);
for (int i = 0; i < eLayers.Length; i++)
{
enemyLayermask |= (1 << LayerMask.NameToLayer(eLayers[i]));
}
for (int i = 0; i < fLayers.Count; i++)
{
friendlyLayermask |= (1 << LayerMask.NameToLayer(fLayers[i]));
}
ApplyToolTipValues();
initTimes++;
}
private void addTeamButton_Click(object sender, EventArgs e)
{
if (teamNameTextBox.Text != "" && teamSymbolTextBox.Text != "")
{
DialogResult dr = MessageBox.Show(string.Format("Are you sure to add team '{0}' with symbol '{1}' to the database?", teamNameTextBox.Text, teamSymbolTextBox.Text), "Confirm?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (dr == DialogResult.Yes)
{
if (TeamHandler.AddTeam(teamNameTextBox.Text, teamSymbolTextBox.Text))
{
MessageBox.Show("Successfully added team.");
}
else
{
MessageBox.Show("Unique team name and symbols should be entered.");
}
teamSymbolTextBox.Text = "";
teamNameTextBox.Text = "";
teamGrid.DataSource = TeamHandler.GetViewAbleTeams();
}
}
else
{
MessageBox.Show("Enter team name and symbol.");
}
}
public void GetFriendsAndFoes()
{
TeamHandler th = GameObject.FindGameObjectWithTag("TeamHandler").gameObject.GetComponent <TeamHandler>();
th.GetFriendsAndFoes(LayerMask.LayerToName(this.transform.gameObject.layer), ref friendlyLayers, ref enemyLayers);
InitializeLayerMask();
}
public virtual void Init()
{
thisTransform = this.transform;
teamHandler = GameObject.FindGameObjectWithTag("TeamHandler").GetComponent <TeamHandler>();
damageHandler = GameObject.FindGameObjectWithTag("DamageHandler").GetComponent <DamageHandler>();
normalColor = spellButtons[0].image.color;
playerTeam = teamHandler.playerTeam;
playerLayerMask = LayerMask.NameToLayer("Nothing");
playerLayerMask = ~playerLayerMask;
playerLayerMask |= (1 << LayerMask.NameToLayer(playerTeam));
playerLayer = LayerMask.NameToLayer(playerTeam);
potDoubleClick = false;
doubleClickTimer = 0.0f;
Cursor.SetCursor(moveCursor, hotspot, cursorMode);
for (int i = 0; i < groundMarkerPoolSize; i++)
{
GameObject temp = GameObject.Instantiate(groundMarkerObject.gameObject);
temp.SetActive(false);
groundMarkerPool.Add(temp.transform);
}
currTargetGroupIndex = 0;
InitSpellUI();
//selMask = selectLayerMask.value;
}
private void RefreshUI()
{
StackPanel = (TeamHandler.ProvideUI() ?? new Core.TeamHandlerUI()).GetStackPanel();
StackPanel.Margin = new Thickness(10, 10, 0, 0);
Children.Add(StackPanel);
Selected?.Invoke(this, new EventArgs());
}
// Use this for initialization
void Start()
{
//denna ordningen är ganska viktig
teamHandler = GameObject.FindGameObjectWithTag("TeamHandler").GetComponent <TeamHandler>();
selector = GameObject.FindGameObjectWithTag("PlayerHandler").GetComponent <Selector>();
builder = GameObject.FindGameObjectWithTag("PlayerHandler").GetComponent <Builder>();
enemyHandler = GameObject.FindGameObjectWithTag("EnemyHandler").GetComponent <EnemyHandler>();
abilityManager = GameObject.FindGameObjectWithTag("AbilityManager").GetComponent <AbilityManager>();
teamHandler.Init();
selector.Init();
builder.Init();
enemyHandler.Init();
abilityManager.Init();
Health[] healths = (Health[])FindObjectsOfType(typeof(Health));
for (int i = 0; i < healths.Length; i++)
{
healths[i].Init();
}
AIBase[] aiBases = (AIBase[])FindObjectsOfType(typeof(AIBase));
for (int i = 0; i < aiBases.Length; i++)
{
aiBases[i].Init();
}
UnitSpellHandler[] unitSH = (UnitSpellHandler[])FindObjectsOfType(typeof(UnitSpellHandler));
for (int i = 0; i < unitSH.Length; i++)
{
unitSH[i].Init();
}
}
public IActionResult TeamInfoSeason(int id, int year)
{
var weekRecords = TeamRecordHandler.GetTeamRecordsByTeamAndYear(id, year);
var h2hRecords = weekRecords.Last().Head2HeadRecords
.Where(h2h => h2h.GamesPlayed > 0)
.OrderBy(h2h => h2h.Opponent.Name)
.ToList();
var games = GameHandler.GetGamesByYearAndTeam(year, id);
var players = RosterHandler.GetByTeamAndYearGroupedByPlayer(id, year).Select(list =>
{
return(new TeamPlayerInfo
{
Player = list.First().Player,
RosterEntries = list
});
}).ToList();
return(View(new TeamInfoSeason
{
Team = TeamHandler.GetById(id),
Year = year,
WeekRecords = weekRecords,
H2HRecords = h2hRecords,
Games = games,
Players = players
}));
}
private void Setup()
{
foreach (TeamHandler team in m_Teams)
{
// Based on the number of players chosen in the lobby screen, this will remove the tanks from the current game
if (GameManager.instance != null)
{
for (int x = team.GetTeamControllers().Length; x > GameManager.instance.teamInfos[team.Team]; x--)
{
team.GetTeamControllers()[x - 1].gameObject.GetComponent <Stats>().SetAlive(false);
team.GetTeamControllers()[x - 1].gameObject.SetActive(false);
}
}
foreach (TankController controller in team.GetTeamControllers())
{
ActivateCharacter(controller, false);
if (controller.isActiveAndEnabled)
{
IgnoreCollisionsWithOtherPlayers(controller.gameObject);
}
}
}
m_ActiveTeam = m_Teams[m_ActiveTeamIndex];
m_ActiveTeamControllers = m_ActiveTeam.GetTeamControllers();
m_ActiveTeamStats = m_ActiveTeam.GetTeamStats();
m_ActiveCharacter = m_ActiveTeamControllers[m_ActiveCharacterIndex];
ActivateCharacter(m_ActiveCharacter, true);
m_TimerCoroutine = StartCoroutine(TurnTimer.Instance.StartTimer());
TurnTimer.Instance.PauseTimer();
m_ProjectileCamera.depth = -10;
}
public bool Ready(Team team)
{
if ((TeamHandler.GetCamps(team).Count == _maxCamps) && (TeamHandler.GetUnits(team).Count == _maxUnits))
{
team.Ready = true;
return(true);
}
return(false);
}
private void ExcuteViewCommand(object o)
{
TeamHandler teams = new TeamHandler();
teams.AppendTeamsBuild(0);
RandomCommands commands = new RandomCommands();
commands.DataContext = new VMRandomComannds();
}
private async void RunHandler(EventMessageBase message, Mock <IBotState> mockState)
{
var handler = new TeamHandler();
handler.BotState = mockState.Object;
var result = await handler.HandleMessageAsync(message);
mockState.Verify();
}
void Start()
{
teamHandler = GetComponent <TeamHandler>();
units = teamHandler.friendlyUnits;
human = 0; tiefling = 0; dueler = 0; caster = 0; enchanter = 0; brawler = 0; ranger = 0; rogue = 0;
CheckOrigins(units);
CheckClasses(units);
}
public virtual List <IUnit> GetAllTargets(int row, int col)
{
if (Unit.CurrentCoolDown > 0)
{
return(null);
}
var team = BoardHandler.GetOpponent(Unit.Team);
var enemies = TeamHandler.GetUnitsAround(team, row, col, Unit.Range);
return(enemies);
}
private Instance()
{
contextDB = new ContextDB();
Session = new Session();
SessionHandler = new SessionHandler();
AdministratorHandler = new AdministratorHandler();
ColaboratorHandler = new ColaboratorHandler();
TeamHandler = new TeamHandler();
BlackboardHandler = new BlackboardHandler();
UserHandler = new UserHandler();
}
public bool StartGame()
{
if (_boardHandler.LowerTeam.Ready && _boardHandler.UpperTeam.Ready)
{
State = GameState.Playing;
_currentTeam = _boardHandler.LowerTeam;
_currentTeam.ActionableUnits.AddRange(TeamHandler.GetUnits(_currentTeam));
_currentTeam.CanMoveUnit = true;
return(true);
}
return(false);
}
public static void AddFromFile(string file, bool force = false)
{
if (string.IsNullOrEmpty(file))
{
return;
}
Console.WriteLine($"Adding playoff probabilities from: {file}");
var playoffProbs = JsonConvert.DeserializeObject <Models.Import.PlayoffProbabilities>(File.ReadAllText(file));
var weekExists = PlayoffProbabilityHandler.WeekExists(playoffProbs.Year, playoffProbs.Week);
if (weekExists)
{
if (force)
{
PlayoffProbabilityHandler.DeleteWeek(playoffProbs.Year, playoffProbs.Week);
}
else
{
return;
}
}
var teams = TeamHandler.GetAllTeams();
var playoffProbsToAdd = new List <PlayoffProbability>();
foreach (var playoffProb in playoffProbs.Probability)
{
Console.WriteLine($" Adding playoff prob for {playoffProb.Team}");
if (playoffProb.ExcludingTiebreakers > playoffProb.IncludingTiebreakers)
{
throw new ArgumentException($"Excluding ({playoffProb.ExcludingTiebreakers}) > Including ({playoffProb.IncludingTiebreakers})");
}
var team = teams.Find(t => t.Name == playoffProb.Team);
playoffProbsToAdd.Add(new PlayoffProbability
{
Year = playoffProbs.Year,
Week = playoffProbs.Week,
TeamId = team.Id,
IncludingTiebreaker = playoffProb.IncludingTiebreakers,
ExcludingTiebreaker = playoffProb.ExcludingTiebreakers
});
}
PlayoffProbabilityHandler.Add(playoffProbsToAdd);
}
private void AddCommand(object sender, RoutedEventArgs e)
{
TeamHandler teamHandl = new TeamHandler();
string name = NameCommand.Text;
Team team = new Team();
team.Name = name;
team.TeamColor = System.Drawing.Color.Red;
List <ITeam> list = new List <ITeam>();
list.Add(team);
teamHandl.BuildTeams(list, 0);
}
private void CandidateForm_Load(object sender, EventArgs e)
{
List <ViewAbleTeams> vTeams = TeamHandler.GetViewAbleTeams();
List <ViewAbleDistricts> vDists = DistrictHandler.GetViewAbleDistricts();
foreach (ViewAbleTeams vteam in vTeams)
{
teamComboBox.Items.Add(vteam.TeamName);
}
foreach (ViewAbleDistricts vdist in vDists)
{
selectDistrictComboBox.Items.Add(vdist.DistrictName);
districtComboBox.Items.Add(vdist.DistrictName);
}
}
private void deleteTeamButton_Click(object sender, EventArgs e)
{
if (teamGrid.DataSource != null)
{
int rowIndex = teamGrid.CurrentRow.Index;
string teamName = teamGrid.Rows[rowIndex].Cells[0].Value.ToString();
DialogResult dr = MessageBox.Show(string.Format("Are you sure to delete '{0}' from the database?", teamName), "Confirm?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (dr == DialogResult.Yes)
{
TeamHandler.DeleteTeam(teamName);
MessageBox.Show("Deleted");
teamGrid.DataSource = TeamHandler.GetViewAbleTeams();
}
}
}
public IActionResult Index()
{
var teams = TeamHandler.GetAllTeams();
teams.Sort((t1, t2) => t1.Name.CompareTo(t2.Name));
var model = teams.Select(t => new TeamOverallInfo
{
Team = t,
YearsActive = TeamRecordHandler.GetYearsActive(t.Id),
NumChampion = SeasonInfoHandler.GetNumChampion(t.Id),
CareerRecord = TeamRecordHandler.GetCareerRecord(t.Id)
}).ToList();
return(View(model));
}
public override List <IUnit> GetAllTargets(int row, int col)
{
if (Unit.CurrentCoolDown > 0)
{
return(null);
}
var team = BoardHandler.GetOpponent(Unit.Team);
var adjacents = TeamHandler.GetUnitsAround(team, row, col, 1);
if (adjacents != null && adjacents.Count > 0)
{
return(null);
}
return(base.GetAllTargets(row, col));
}
public static async Task <GameModel> CreateAsync(Game game)
{
var stream = await EntityStream.CreateAsync(DatabaseProvider.Connection, game.Id);
var teamHandler = new TeamHandler();
await stream.ExecuteAsync(teamHandler);
var counterTerrorists = await DatabaseProvider.MapPlayersAsync(teamHandler.CounterTerroristIds);
var terrorists = await DatabaseProvider.MapPlayersAsync(teamHandler.TerroristIds);
return(new GameModel
{
Game = game,
CounterTerrorists = counterTerrorists,
Terrorists = terrorists,
});
}
private void NextCharacter()
{
if (m_ActiveCharacterIndex + 1 < m_ActiveTeam.GetTeamControllers().Length)
{
m_ActiveCharacterIndex++;
}
else
{
do
{
m_ActiveTeamIndex = (m_ActiveTeamIndex + 1) % m_Teams.Count;
m_ActiveTeam = m_Teams[m_ActiveTeamIndex];
m_ActiveTeamControllers = m_ActiveTeam.GetTeamControllers();
m_ActiveTeamStats = m_ActiveTeam.GetTeamStats();
m_ActiveCharacterIndex = 0;
} while (m_ActiveTeamControllers.Length <= 0);
}
}
public IEnumerator Event_GameOver(TeamHandler winningTeam)
{
ActivateTankControls(m_ActiveCharacter, false);
StopCoroutine(m_TimerCoroutine);
LargeCenterText centerText = LargeCenterText.Instance;
if (winningTeam != null)
{
Enum team = winningTeam.Team;
centerText.Text = team.ToString() + " Team Won";
switch (winningTeam.Team)
{
case unikincTanks.Teams.BLUE: centerText.TextColor = Color.blue; break;
case unikincTanks.Teams.GREEN: centerText.TextColor = Color.green; break;
case unikincTanks.Teams.RED: centerText.TextColor = Color.red; break;
case unikincTanks.Teams.YELLOW: centerText.TextColor = Color.yellow; break;
default: centerText.TextColor = Color.white; break;
}
}
else
{
centerText.Text = "Game Over";
}
foreach (GameObject gObj in GameObject.FindGameObjectsWithTag("GameUI"))
{
gObj.SetActive(false);
}
centerText.ShowWidescreenBars(true);
centerText.ShowText(true);
yield return(new WaitForSeconds(3.0f));
SceneManager.LoadScene("Main Menu");
}
public GameSocket(ISerializer serializer) : base(serializer)
{
_bagHandler = new BagHandler(this);
_battleHandler = new BattleHandler(this);
_dailyActivityHandler = new DailyActivityHandler(this);
_equipHandler = new EquipHandler(this);
_itemHandler = new ItemHandler(this);
_messageHandler = new MessageHandler(this);
_npcHandler = new NpcHandler(this);
_petHandler = new PetHandler(this);
_petNewHandler = new PetNewHandler(this);
_playerHandler = new PlayerHandler(this);
_prepaidHandler = new PrepaidHandler(this);
_resourceHandler = new ResourceHandler(this);
_skillHandler = new SkillHandler(this);
_skillKeysHandler = new SkillKeysHandler(this);
_taskHandler = new TaskHandler(this);
_teamHandler = new TeamHandler(this);
_entryHandler = new EntryHandler(this);
_roleHandler = new RoleHandler(this);
}
private void Start()
{
uim = GameObject.FindGameObjectWithTag("BoardUI").GetComponent <UIManager>();
allTeam = GameObject.FindGameObjectWithTag("Team").GetComponent <Team>();
gm = FindObjectOfType <GameManager>();
gt = GetComponent <GenerateTiles>();
teams = TeamInformationHandler.GetComponent <TeamHandler>();
em = TeamInformationHandler.GetComponent <EnemyManager>();
traits = TeamInformationHandler.GetComponent <TraitBonuses>();
GameObject StoredTiles = new GameObject("StoredTiles");
map = new Grid(x, y, cellSize, tile, StoredTiles); // creates grid
gt.SpawnTiles(x, y, cellSize);
playerTurn = 1;
allTeam.LoadArtifacts();
}
public void CanHandleTeamMessages()
{
var handler = new TeamHandler();
bool result = false;
var messageTestCases = new List<EventMessageBase>
{
new PrefChange { Type = EventType.PrefChange },
new UserChange { Type = EventType.UserChange },
new TeamJoin { Type = EventType.TeamJoin },
new TeamPrefChange { Type = EventType.TeamPrefChange },
new TeamRename { Type = EventType.TeamRename },
new TeamDomainChange { Type = EventType.TeamDomainChange },
new EmailDomainChanged { Type = EventType.EmailDomainChanged }
};
foreach (var messageTestCase in messageTestCases)
{
result = handler.CanHandle(messageTestCase);
Assert.True(result);
}
}
public bool PlaceUnit(string teamName, IUnit unit, int row, int col)
{
var team = _boardHandler.GetTeamByName(teamName);
if (team != null)
{
var availBlocks = _boardHandler.GetInitArea(team);
if (availBlocks.Exists(b => b.Column == col && b.Row == row))
{
if (((unit is Camp) && TeamHandler.GetCamps(team).Count < _maxCamps) ||
(!(unit is Camp) && TeamHandler.GetUnits(team).Count < _maxUnits))
{
unit.Row = row;
unit.Column = col;
unit.Team = team;
team.Units.Add(unit);
return(true);
}
}
}
return(false);
}
private TeamHandler CheckLastTeamAlive()
{
bool AtLeastOneTeamAlive = false;
TeamHandler lastTeam = null;
foreach (TeamHandler team in m_Teams)
{
foreach (Stats charStat in team.GetTeamStats())
{
if (charStat.IsAlive() && !AtLeastOneTeamAlive)
{
AtLeastOneTeamAlive = true;
lastTeam = team;
break;
}
else if (charStat.IsAlive() && AtLeastOneTeamAlive)
{
return(null);
}
}
}
return(lastTeam);
}
private async void RunHandler(EventMessageBase message, Mock<IBotState> mockState)
{
var handler = new TeamHandler();
handler.BotState = mockState.Object;
var result = await handler.HandleMessageAsync(message);
mockState.Verify();
}
