/// <summary>
/// A constructor for the user interface. It reads in the inital team information.
/// </summary>
public UserInterface()
{
InitializeComponent();
StreamReader sr = new StreamReader("TEAMABR.csv");
while (sr.EndOfStream != true)
{
string currentLine = sr.ReadLine();
string[] sArray = new string[5];
sArray = currentLine.Split(',');
TeamData tData = new TeamData(sArray);
_teamInformation.Add(sArray[0], tData);
}
}
public static void WritePairing(TeamData red, TeamData blue)
{
var color = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(" {0,-24} ({1:0000})", red.Name, red.Rating);
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" - ");
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write("{0,-24} ({1:0000})", blue.Name, blue.Rating);
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" : ");
Console.ForegroundColor = color;
}
public EventAnalysis(FrcEvent frc) : this()
{
Event = frc;
EventName = frc.EventName;
foreach (Team t in frc.AllTeams)
{
TeamAnalysis ta = new TeamAnalysis(Event, t);
ta.CalculateSafe();
TeamData.Add(ta);
}
foreach (Match m in frc.Matches)
{
MatchAnalysis ma = new MatchAnalysis(Event, m, TeamData);
ma.CalculatePregame();
MatchData.Add(ma);
}
}
/// <summary>
/// 添加英雄到编队
/// </summary>
/// <param name="heroInfo">添加的英雄</param>
public static void Add(RowHeroDate heroInfo)
{
TeamData teamData = ReadTeamModel();
int armorType = heroInfo.ArmorType == "重型" ? 0 : 1;
if (armorType == 1)
{
teamData.fowardHeroList.Add(heroInfo);
}
else
{
teamData.backHeroList.Add(heroInfo);
}
AddAttribute(heroInfo, ref teamData);
PlayerPrefs.SetString("Team", JsonMapper.ToJson(teamData));
}
private void del_team_button_Click(object sender, EventArgs e)
{
if (null == TeamProjectInfo)
{
Common.ErrAlert("请选择项目后再操作！");
return;
}
if (team_dataGridView.SelectedRows.Count == 0)
{
Common.ErrAlert("请选择一行再修改！");
return;
}
TeamData teamData = teamDatas.ToList()[team_dataGridView.SelectedRows[0].Index];
if (null == teamData)
{
Common.ErrAlert("加载选择的班组数据发生错误！");
return;
}
if (MessageBox.Show(string.Format("真的要删除班组 {0} 吗？", teamData.teamName), "提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) != DialogResult.OK)
{
return;
}
CommonResponseData commonResponse = new CommonResponseData();
TeamRequestService.RequestDelAction(teamData, loginUser, ref commonResponse);
if (null != commonResponse)
{
if (commonResponse.success)
{
Common.SuccessAlert("删除操作成功！");
TeamDataGridViewLoad();
}
else
{
Common.ErrAlert("删除失败！\n" + commonResponse.message);
}
}
else
{
Common.ErrAlert("删除操作异常，请检查网络连接或联系管理员！");
}
}
public void HandlesValidEmailDomainChanged()
{
var team = new TeamData {
EmailDomain = "team.com"
};
var mockState = new Mock <IBotState>();
mockState.Setup(s => s.Team).Returns(team).Verifiable();
var message = new EmailDomainChanged
{
Type = EventType.EmailDomainChanged,
EmailDomain = "team2.com"
};
RunHandler(message, mockState);
Assert.Equal("team2.com", team.EmailDomain);
}
public void HandlesValidTeamRename()
{
var team = new TeamData {
Name = "Team1"
};
var mockState = new Mock <IBotState>();
mockState.Setup(s => s.Team).Returns(team).Verifiable();
var message = new TeamRename
{
Type = EventType.TeamRename,
Name = "Team1b"
};
RunHandler(message, mockState);
Assert.Equal("Team1b", team.Name);
}
//----------------------------------------------------------------------
// ゴールのメッシュに当たったらその時点でゴール
//----------------------------------------------------------------------
// @Param collider 当たったオブジェクトの当たり判定
// @Return none
// @Date 2014/12/9 @Update 2014/12/9 @Author T.Kawashita
//----------------------------------------------------------------------
void OnTriggerEnter(Collider collider)
{
if (collider.gameObject == GameObject.Find("SoccerBall"))
{
// グローバルのゴールのデータに追加
TeamData.AddLog(CGameManager.m_nowTime, CSoccerBallManager.m_shootPlayerNo, CSoccerBallManager.m_shootTeamNo, 1, true);
CGameManager.m_redPoint++;
CGameManager.m_nowStatus = CGameManager.eSTATUS.eGOAL;
// サポーター追加
int redSupporter = 0;
int blueSupporter = 0;
// オウンゴールではない場合
if (CSoccerBallManager.m_shootTeamNo != 2)
{
// 同点に追いつくシュート
if (TeamData.GetTeamScore(0) == TeamData.GetTeamScore(1))
{
redSupporter += CSupporterData.m_getDrawPointSupporter;
}
// 同点から逆転するシュート
else if (TeamData.GetTeamScore(0) - 1 == TeamData.GetTeamScore(1))
{
redSupporter += CSupporterData.m_getDrawReversPointSupporter;
}
redSupporter += CSupporterData.m_getPointSupporter;
}
// オウンゴールの場合は点数は入る
else if (CSoccerBallManager.m_shootTeamNo == 2)
{
blueSupporter += CSupporterData.m_getPointSupporter;
}
// 最後にサポーター追加
CSupporterManager.AddSupporter(redSupporter, blueSupporter, true);
collider.gameObject.transform.GetComponent <CSoccerBall>().StopTrail();
}
}
/// <summary>
/// 初始化NPC
/// </summary>
public void InitNpcTeams(List <string> teamDatas, Action execOK)
{
foreach (string teamItem in teamDatas)
{
if (LogicConst.BattleType == BattleType.FreeBattle)
{
var items = teamItem.ToList <uint>('-');
var teamid = items[0];
var turnNum = items[1];
var maxNum = items[2];
TeamData itemData = configMgr.GetTeamData(teamid);
if (itemData != null)
{
for (int i = 0; i < turnNum; i++)
{
TeamData newItem = new TeamData();
newItem.id = itemData.id;
newItem.teamNpcs = new List <TeamNpcData>();
for (int j = 0; j < maxNum; j++)
{
int index = LogicUtil.Random(0, itemData.teamNpcs.Count);
var teamNpc = itemData.teamNpcs[index];
newItem.teamNpcs.Add(teamNpc);
}
turnTeams.Enqueue(newItem);
}
}
}
else
{
uint teamid = teamItem.ToUint();
TeamData item = configMgr.GetTeamData(teamid);
if (item != null)
{
turnTeams.Enqueue(item);
}
}
}
if (execOK != null)
{
execOK();
}
}
/// <summary>
/// 取得車隊活動列表
/// </summary>
/// <param name="teamCommand">teamCommand</param>
/// <returns>Tuple(EventInfoDtos, string)</returns>
public async Task <Tuple <IEnumerable <EventSimpleInfoDto>, string> > GetEventListOfTeam(TeamCommandDto teamCommand)
{
try
{
bool verifyTeamCommandResult = this.VerifyTeamCommand(teamCommand, false, true, false, false, false, false);
if (!verifyTeamCommandResult)
{
this.logger.LogError($"Get Event List Of Team Fail For Verify TeamCommand >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID}");
return(Tuple.Create <IEnumerable <EventSimpleInfoDto>, string>(null, "取得車隊活動列表失敗."));
}
TeamData teamData = await this.teamRepository.GetTeamData(teamCommand.TeamID);
if (teamData == null)
{
return(Tuple.Create <IEnumerable <EventSimpleInfoDto>, string>(null, "車隊不存在."));
}
if (!teamData.TeamLeaderID.Equals(teamCommand.TargetID) && !teamData.TeamPlayerIDs.Contains(teamCommand.TargetID))
{
return(Tuple.Create <IEnumerable <EventSimpleInfoDto>, string>(null, "該會員非車隊隊員."));
}
string memberID = teamCommand.TargetID;
IEnumerable <EventData> eventDatas = await this.eventRepository.GetEventDataListOfTeam(teamCommand.TeamID);
IEnumerable <EventSimpleInfoDto> eventInfos = this.mapper.Map <IEnumerable <EventSimpleInfoDto> >(eventDatas);
bool isExaminer = teamData.TeamLeaderID.Equals(memberID) || teamData.TeamViceLeaderIDs.Contains(memberID);
foreach (EventSimpleInfoDto eventInfo in eventInfos)
{
eventInfo.TeamName = teamData.TeamName;
eventInfo.TeamPhoto = teamData.TeamPhoto;
eventInfo.EventSettingType = (isExaminer || eventInfo.CreatorID.Equals(memberID)) ? (int)TeamEventSettingType.Edit : (int)TeamEventSettingType.None;
}
return(Tuple.Create(eventInfos, string.Empty));
}
catch (Exception ex)
{
this.logger.LogError($"Get Event List Of Team Error >>> TeamID:{teamCommand.TeamID} TargetID:{teamCommand.TargetID}\n{ex}");
return(Tuple.Create <IEnumerable <EventSimpleInfoDto>, string>(null, "取得車隊活動列表發生錯誤."));
}
}
/// <summary>
/// チームの状態フラグ設定
/// </summary>
/// <param name="teamId"></param>
/// <param name="flag"></param>
/// <param name="sw"></param>
public void SetFlag(int teamId, uint flag, bool sw)
{
if (teamId < 0)
{
return;
}
TeamData data = teamDataList[teamId];
bool oldvalid = data.IsActive();
data.SetFlag(flag, sw);
bool newvalid = data.IsActive();
if (oldvalid != newvalid)
{
// アクティブチーム数カウント
activeTeamCount += newvalid ? 1 : -1;
}
teamDataList[teamId] = data;
}
//----------------------------------------------------------------------
// コンストラクタ
//----------------------------------------------------------------------
// @Param none
// @Return none
// @Date 2014/12/10 @Update 2014/12/10 @Author T.Kawashita
//----------------------------------------------------------------------
void Start()
{
m_status = eSTATUS_VICTORYPERFORMANCE.eFADE_IN;
if (TeamData.GetWinTeamNo() == 0 || TeamData.GetWinTeamNo() == 1)
{
GameObject.Instantiate(Resources.Load("Prefab/Result/player_victory"));
}
else if (TeamData.GetWinTeamNo() == 2)
{
GameObject.Instantiate(Resources.Load("prefab/Result/player_draw_1"));
}
m_soundPlayer = new CSoundPlayer();
m_soundPlayer.ChangeSEVolume(0.2f);
m_soundPlayer.PlaySE("result/supoter_finish");
// パネル取得
m_mainUIPanel = GameObject.Find("MainUI").transform.FindChild("Camera").transform.FindChild("Anchor").transform.FindChild("Panel").gameObject;
m_1p2pUIPanel = GameObject.Find("1p2pUI").transform.FindChild("Camera").transform.FindChild("Anchor").transform.FindChild("Panel").gameObject;
m_3p4pUIPanel = GameObject.Find("3p4pUI").transform.FindChild("Camera").transform.FindChild("Anchor").transform.FindChild("Panel").gameObject;
m_mainUIPanel.transform.FindChild("BlackOut").gameObject.AddComponent <CFadeIn> ();
m_1p2pUIPanel.transform.FindChild("BlackOut").gameObject.AddComponent <CFadeIn> ();
m_3p4pUIPanel.transform.FindChild("BlackOut").gameObject.AddComponent <CFadeIn> ();
if (TeamData.GetWinTeamNo() == 0 || TeamData.GetWinTeamNo() == 1)
{
m_motionPlayer = GameObject.Find("player_victory(Clone)").gameObject;
}
else if (TeamData.GetWinTeamNo() == 2)
{
m_motionPlayer = GameObject.Find("player_draw_1(Clone)").gameObject;
}
m_mainCamera = GameObject.Find("MainCamera").gameObject;
m_1p2pCamera = GameObject.Find("1p2pCamera").gameObject;
m_3p4pCamera = GameObject.Find("3p4pCamera").gameObject;
m_flame = 0.0f;
// m_motionPlayer.animation.Stop ();
}
public void OnClickBattleStart()
{
if (m_CurrentTeam.Creatures.Count == 0)
{
Tooltip.Instance.ShowMessageKey("PVPTeamCountZero");
return;
}
if (CheckSkill() == false)
{
return;
}
if (m_CurrentTeam.LeaderCreature == null && m_CurrentTeam.Creatures.Any(c => c.creature.TeamSkill != null))
{
OnLeaderSkill();
return;
}
bool save = false;
TeamData pvp_team = TeamDataManager.Instance.GetTeam(pe_Team.PVP);
if (pvp_team == null)
{
TeamDataManager.Instance.AddTeam(m_CurrentTeam, true);
save = true;
}
else if (pvp_team.IsEqual(m_CurrentTeam) == false)
{
pvp_team.Set(m_CurrentTeam);
save = true;
}
C2G.PvpEnterBattle packet = new C2G.PvpEnterBattle();
packet.enemy_account_idx = Network.PVPBattleInfo.enemy_info.account_idx;
if (save)
{
packet.team_data = m_CurrentTeam.CreateSaveData();
}
Network.GameServer.JsonAsync <C2G.PvpEnterBattle, C2G.PvpEnterBattleAck>(packet, OnPvpEnterBattle);
}
public static void RequestTeam(this PhotonPlayer player)
{
#if (UNITY_EDITOR)
if (!PhotonNetwork.connectedAndReady)
{
Debug.LogWarning("JoinTeam was called in state: " + PhotonNetwork.connectionStateDetailed + ". Not connectedAndReady.");
return;
}
#endif
TeamID newTeam = player.GetTeam();
int maxIterations = TeamData.GetMaxTeams(PhotonNetwork.room.MaxPlayers);
do
{
if (maxIterations <= 0)
{
newTeam = TeamID.NotSet;
break;
}
maxIterations--;
newTeam = TeamData.GetNextTeam(newTeam);
#if (UNITY_EDITOR)
Debug.Log(newTeam);
#endif
} while(RoomTeams.PlayersPerTeam[newTeam].Count >= TeamData.GetMaxPlayersPerTeam(PhotonNetwork.room.MaxPlayers));
if (newTeam == TeamID.NotSet)
{
#if (UNITY_EDITOR)
Debug.Log("ERROR: No empty team found!");
#endif
}
else
{
player.SetCustomProperties(new Hashtable()
{
{ RoomTeams.TeamPlayerProp, (byte)newTeam }
});
}
}
override public void Show()
{
base.Show();
teamData = MainController.Instance.UserTeam.CopyTeam();
formationData = GameData.Instance.Formations;
List <PlayerData> squadList = new List <PlayerData>(teamData.Squad);
List <PlayerData> subsList = new List <PlayerData>(teamData.Substitutes);
field.Reset();
field.PopulatePlayers(squadList, teamData.Formation, this);
substitutes.Clear();
substitutes.Populate(subsList, this);
UpdateFormationDropdown();
UpdateStrategyDropdown();
hasChanged = false;
}
/// <summary>
/// 驗證活動審查者權限
/// </summary>
/// <param name="teamData">teamData</param>
/// <param name="eventData">eventData</param>
/// <param name="examinerID">examinerID</param>
/// <returns>bool</returns>
private bool VerifyEventExaminerAuthority(TeamData teamData, EventData eventData, string examinerID)
{
if (string.IsNullOrEmpty(examinerID))
{
return(false);
}
if (!teamData.TeamLeaderID.Equals(examinerID))
{
if (!teamData.TeamViceLeaderIDs.Equals(examinerID))
{
if (!eventData.CreatorID.Equals(examinerID))
{
return(false);
}
}
}
return(true);
}
public static void quickSaveData()
{
if (!Directory.Exists(quickpath))
{
Directory.CreateDirectory(quickpath);
}
if (team == null)
{
team = new TeamData();
}
if (inventory == null)
{
inventory = new InventoryData();
}
SaveObj <TeamData>(quickpath + "/team.json", team);
SaveObj <InventoryData>(quickpath + "/inventory.json", inventory);
SaveObj <GameInfo>(quickpath + "/info.json", info);
}
private void SpawnPlayers(TeamData _team, List <MatchPlayer> _list, Vector2 _spawnPoint, MatchZonesContainer _zones)
{
PlayerData[] players = _team.Squad;
FormationData formation = _team.Formation;
for (int i = 0; i < players.Length; i++)
{
MatchPlayer player = Instantiate(playerTemplate, playersContainer);
player.transform.localPosition = _spawnPoint;
player.Populate(players[i], (i + 1).ToString());
player.gameObject.SetActive(true);
_list.Add(player);
}
for (int j = 0; j < formation.Zones.Length; j++)
{
Zone zone = formation.Zones[j];
_list[j].MoveTo(GetZone(zone, _zones).transform.position, 1f, 0.1f * j);
}
}
public TeamData CreateTeam(TeamData data)
{
List <TeamData> teams = TeamFile.FullFilePath().LoadFile().ConvertToTeam(PersonFile);
int currentId = 1;
if (teams.Count > 0)
{
currentId = teams.OrderByDescending(x => x.Id).First().Id + 1;
}
data.Id = currentId;
//Lägga till nya data med ett nytt ID (+1)
teams.Add(data);
//konvertera till list<string>
//spara list<string> till textfilen
teams.SaveToTeamFile(TeamFile);
return(data);
}
/// <summary>
/// Initialises the class.
/// </summary>
private void Start()
{
if (s_Singleton != null)
{
Destroy(this);
return;
}
s_Singleton = this;
m_AmountOfTeams = TeamData.GetMaxTeams(PhotonNetwork.room.MaxPlayers);
MasterClientStart();
m_Treasures = new List <Treasure>();
m_NextMoneyUpdateTime = m_MoneyUpdateTimeInterval;
m_GameLength = (int)PhotonNetwork.room.CustomProperties[RoomManager.RoomGameDurationProp];
#if (UNITY_EDITOR)
Debug.Log("Game will take: " + m_GameLength + "seconds");
#endif
}
private void SetTeam(TeamData team)
{
var hasTeam = team != null;
deleteTeamButton.IsVisible = hasTeam;
createTeamButton.IsVisible = !hasTeam;
teamPanel.IsVisible = hasTeam;
if (team == null)
{
return;
}
for (var i = 0; i < characterCount; i++)
{
var character = team.Characters[i];
teamPanel.Components.Add(new Button {
Text = character.Name, OnTapped = CharacterButton_Tapped, Id = character.Id.ToString()
});
}
}
/// <summary>
/// Updates a record in the Team table.
/// </summary>
/// <param name=""></param>
public static void Update(TeamData data, SqlTransaction transaction)
{
// Create and execute the command
SqlCommand cmd = GetSqlCommand(CONNECTION_STRING_KEY, "spTeam_Update", CommandType.StoredProcedure, COMMAND_TIMEOUT, transaction);
//Create the parameters and append them to the command object
cmd.Parameters.Add(new SqlParameter("@TeamId", SqlDbType.Int, 0, ParameterDirection.Input, false, 10, 0, "TeamId", DataRowVersion.Proposed, data.TeamId.DBValue));
cmd.Parameters.Add(new SqlParameter("@RegistrationKey", SqlDbType.VarChar, 6, ParameterDirection.Input, false, 0, 0, "RegistrationKey", DataRowVersion.Proposed, data.RegistrationKey.DBValue));
cmd.Parameters.Add(new SqlParameter("@Status", SqlDbType.Char, 1, ParameterDirection.Input, false, 0, 0, "Status", DataRowVersion.Proposed, data.Status.DBValue));
cmd.Parameters.Add(new SqlParameter("@TournamentId", SqlDbType.Int, 0, ParameterDirection.Input, false, 10, 0, "TournamentId", DataRowVersion.Proposed, data.TournamentId.DBValue));
// Execute the query
cmd.ExecuteNonQuery();
// do not close the connection if it is part of a transaction
if (transaction == null)
{
cmd.Connection.Close();
}
}
public void Populate(TournamentData _data)
{
Data = _data;
titleLabel.text = Data.Name;
_teamAmountLabel.text = Data.Teams.Count + " TEAMS";
List <TeamData> list;
if (Data.CurrentRound == 0)
{
list = Data.SortTeamsBy("Name");
}
else
{
list = Data.SortTeamsBy("Points");
}
int max = 2;
if (list.Count > 3)
{
max = 3;
}
team_2.text = "";
score_2.text = "";
TMP_Text[] team = new TMP_Text[3] {
team_0, team_1, team_2
};
TMP_Text[] score = new TMP_Text[3] {
score_0, score_1, score_2
};
for (int i = 0; i < max; i++)
{
TeamData tData = list[i];
team[i].text = tData.Name + " (" + tData.OveralRating + ")";
if (tData.TournamentStatistics.ContainsKey(Data.Id))
{
score[i].text = tData.TournamentStatistics[Data.Id].Points + " pts";
}
}
}
public override void Create()
{
base.Create();
var levelMgr = ScriptThread.GetOrAddExtension <LevelManager>();
var sessMgr = ScriptThread.GetOrAddExtension <SessionManager>();
LevelSpawn spawnPoint = levelMgr.GetSpawnPoint(Info.Sess.TeamNum);
// spawn above to avoid collision with teammates.
Vector3 position = Utility.EnsureValidSpawnPos(spawnPoint.Position + new Vector3(0, 0, 2.0f));
Model model = new Model(VehicleHash.Lazer);
if (!model.IsLoaded)
{
model.Request(1000);
}
var vehicle = World.CreateVehicle(model, position, spawnPoint.Heading);
vehicle.LodDistance = 2000;
vehicle.EngineRunning = true;
vehicle.BodyHealth = 1000;
vehicle.MaxSpeed = 280.0f;
Function.Call(Hash.SET_VEHICLE_EXPLODES_ON_HIGH_EXPLOSION_DAMAGE, vehicle, true);
Ped ped = Game.Player.Character;
TeamData team = sessMgr.GetTeamByIndex(Info.Sess.TeamNum);
ped.RelationshipGroup = team.RelationshipGroup;
ped.SetIntoVehicle(vehicle, VehicleSeat.Driver);
Manage(ped, vehicle);
}
bool TryFindNextInputEventTime(TeamData team, float startTime, out float nextTime)
{
nextTime = 0f;
bool bFoundFirst = false;
foreach (DialRoutineScoreData data in team.JudgesScores)
{
foreach (DialInputData input in data.DialInputs)
{
if (input.TimeSeconds > startTime && (!bFoundFirst || input.TimeSeconds < nextTime))
{
bFoundFirst = true;
nextTime = input.TimeSeconds;
break;
}
}
}
return(bFoundFirst);
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
}
Application.targetFrameRate = 60;
QualitySettings.vSyncCount = 0;
User.CurrentYear = 2021;
UserTeam = initialData.UserTeam;
AllPlayers = initialData.AllPlayers;
AllTeams = initialData.AllTeams;
AllTournaments = initialData.AllTournaments;
ActiveTournaments = new List <string>();
UserTeam.Reset();
initialData = null;
}
private IEnumerator LoadTeams()
{
mainController.AllTeams = new List <TeamData>();
string[] files = Directory.GetFiles(CombinePaths(userFolder, "Teams"));
totalTeams = files.Length;
foreach (string file in files)
{
TeamAttributes data = LoadFile <TeamAttributes>(file);
TeamData team = ScriptableObject.CreateInstance <TeamData>();
team.Attributes = data;
team.Initialize(true);
if (team.IsUserControlled)
{
mainController.UserTeam = team;
}
mainController.AllTeams.Add(team);
teamsLoaded++;
}
yield return(null);
}
public static bool MemberOfTeam(int memberUniqueId, int leaderUniqueId, out TeamData data)
{
data = null;
foreach (var kvp in Teams)
{
if (kvp.Value.Leader.UniqueId != leaderUniqueId)
{
continue;
}
if (!kvp.Value.Members.ContainsKey(memberUniqueId))
{
continue;
}
data = kvp.Value;
return(true);
}
return(false);
}
// Start is called before the first frame update
void Start()
{
mouseController = FindObjectOfType <TargetMouseSelected>();
myRigidbody = GetComponent <Rigidbody2D>();
myAnimator = GetComponent <Animator>();
selectable = GetComponent <Selectable>();
teamData = GetComponent <TeamData>();
unitParent = transform.parent.parent.GetChild(2).gameObject;
health = GetComponent <Health>();
sellProfit = buyCost / 2;
currentUnits = new Health[3];
if (teamData.GetTeamBelonging() == Team.TeamRed)
{
spawnTimeInSeconds -= GlobalUpgrades.instance.GetUpgradeValueOnUpgradesIndex(1); // Index 1 is spawnTimeUpgrade
unitManager = FindObjectOfType <UnitManagerPanel>();
}
if (dwellingUpgrader == null)
{
dwellingUpgrader = GetComponentInChildren <DwellingUpgrader>();
}
}
private void TeamGrid_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
TeamStats team;
string selectedSeason = SeasonsGrid.SelectedItem.ToString();
if ((sender as DataGrid).Name == "TeamGridWest")
{
team = (TeamGridWest.SelectedItem as TeamStats);
}
else
{
team = (TeamGridEast.SelectedItem as TeamStats);
}
List <string> selectedTeamsSeasons =
TeamData.GetActiveSeasons(teamData.Where(p => p.TeamID == team.TeamID).ToList());
TeamWindow teamWindow = new TeamWindow(team, selectedTeamsSeasons, selectedSeason, teamData);
teamWindow.ShowDialog();
}
void Start()
{
#if UNITY_EDITOR && !BUILD_MODE
AssetDatabase.Refresh();
#endif
// Spawn everyone
for (int ti = 0; ti < MatchData.Instance.teamDatas.Length; ++ti)
{
TeamData teamData = MatchData.Instance.teamDatas[ti];
for (int bi = 0; bi < teamData.BotCount; ++bi)
{
BotData botData = teamData.GetBotData(bi);
if (botData != null)
{
Transform spawn = ti == 0 ? t0Spawns[bi] : t1Spawns[bi];
Controller.CreateBot(botPrefab, botData, ti, spawn.position, spawn.rotation);
}
}
}
}
public void UpdateCharacterInfo()
{
TeamData team_data = TeamDataManager.Instance.GetTeam(pe_Team.Main); //得到队伍的信息
for (int i = 0; i < m_MainLayout.m_Characters.Length; i++)
{
if (m_ListCharacterInfos.Count <= i)
{
UICharacterInfo info = NGUITools.AddChild(m_CharacterInfoIndicator[i], m_CharacterInfoPrefab).GetComponent <UICharacterInfo>(); //添加角色信息的预设体
m_ListCharacterInfos.Add(info); //往数组里面添加角色额信息
}
if (team_data != null && i < team_data.Creatures.Count)
{
m_ListCharacterInfos[i].UpdateInfo(team_data.Creatures[i].creature, 5); //绘制或者更新角色的信息
}
else
{
m_ListCharacterInfos[i].UpdateInfo(null, 5);
}
}
}
void Start()
{
Suicidals = new TeamData(Team.Suicidials);
Rescuers = new TeamData(Team.Rescuers);
if (isServer)
SecondsToGameEnd = SecondsToRescuersWin;
}
public bool Run(TeamData red, TeamData blue)
{
using (var engine = new CloudBallEngine(red.CreateInstance(), blue.CreateInstance()))
{
CloudBallScore score = null;
ConsoleX.WritePairing(red, blue);
var sw = Stopwatch.StartNew();
try
{
score = engine.Run();
}
catch (SimulationFailedException)
{
ConsoleX.WriteError("crashed");
return false;
}
ConsoleX.WriteResult(red, blue, score, sw);
red.Results.GoalsFor += score.Red;
red.Results.GoalsAgainst += score.Blue;
blue.Results.GoalsFor += score.Blue;
blue.Results.GoalsAgainst += score.Red;
if (score.RedWins)
{
red.Results.Wins++;
blue.Results.Loses++;
}
else if (score.BlueWins)
{
blue.Results.Wins++;
red.Results.Loses++;
}
else
{
red.Results.Draws++;
blue.Results.Draws++;
}
if (ArenaSettings.Instance.ReplayDirectory.Exists)
{
var file = new FileInfo(Path.Combine(
ArenaSettings.Instance.ReplayDirectory.FullName,
string.Format("{0}-{1} {2:00}-{3:00} {4:yyyy-MM-dd_hh_mm_ss}.cbr",
red.Name, blue.Name, score.Red, score.Blue, DateTime.Now)));
engine.Save(file);
}
var zScore = Elo.GetZScore(red.Rating, blue.Rating);
var kR = red.GetK(ArenaSettings.Instance.K, ArenaSettings.Instance.Stabilizer);
red.Rating += kR * ((double)score.RedScore - zScore);
var kB = blue.GetK(ArenaSettings.Instance.K, ArenaSettings.Instance.Stabilizer);
blue.Rating += kB * ((double)score.BlueScore - (1d - zScore));
ArenaData.Instance.Sort();
ArenaData.Instance.SaveRankings(ArenaSettings.Instance.RankingsFile);
ArenaData.Instance.Save(ArenaSettings.Instance.DataFile);
return true;
}
}
/// <summary>
/// Recursively navigates the tree to build a JSON string.
/// </summary>
/// <param name="tree">The parent tree.</param>
/// <param name="parentNode">The parent node.</param>
/// <param name="indexPath">Used for creating IDs for nodes.</param>
void RecursiveBuild(Dictionary<string, ListDictionary> tree, Node parentNode, string indexPath)
{
var index = 0;
foreach (var treeLevel in tree)
{
// Determine the current level.
const char levelSplitter = GlobalManager.LevelSplitter;
var currentLevel = indexPath.Count(character => character == levelSplitter);
var groupLevel = _globalManager.TreeLevels[currentLevel];
// Determine the node's ID.
var idPrefix = GetIdPrefix(groupLevel);
var newIndexPath = indexPath + levelSplitter + index++;
var nodeId = idPrefix + newIndexPath;
// Determine the node's name.
var groupKey = treeLevel.Key;
string nodeName;
switch (groupLevel)
{
case "Sprint": // Needs to happen here for sorting by key purposes before this.
var sprintIndex = groupKey.IndexOf("Sprint", StringComparison.Ordinal);
nodeName = sprintIndex == -1 ? groupKey : groupKey.Substring(sprintIndex);
break;
case "Quarter":
case "Team":
case "Product":
case "Theme":
nodeName = groupKey;
break;
case "PBI": // Cut off the PBI's ID # that was added to guarantee uniqueness.
nodeName = groupKey.Substring(0, groupKey.LastIndexOf(levelSplitter));
break;
default:
throw new Exception("Work item type: " + groupLevel + ", is not supported.");
}
// Determine the node's effort.
var effort = (double)treeLevel.Value["effort"];
// Determine the node's size.
double size;
var sizeType = _globalManager.SizeLevels[currentLevel];
if (sizeType == "Effort")
{
size = effort == 0 ? 1 : effort;
}
else // "Aligning" and "Nothing".
{
size = 1;
}
// Determine the node's color.
var color = "";
if (groupLevel != "PBI" && groupLevel != "Theme") // PBIs and Themes have special color systems.
{
color = _globalManager.GetColor(groupLevel, groupKey);
}
// Make the appropriate data object.
Data nodeData;
switch (groupLevel)
{
case "PBI":
var pbi = (SimpleWorkItem)treeLevel.Value["simpleWorkItem"];
color = GlobalManager.GetPbiColor(pbi);
nodeData = new PbiData(size, color, pbi.Effort, pbi.Id, pbi.Priority, pbi.State);
break;
case "Theme":
var mainTheme = (string)treeLevel.Value["mainTheme"];
color = _globalManager.GetMainThemeColor(mainTheme);
var priority = _globalManager.GetMainThemePriority(mainTheme);
nodeData = new ThemeData(size, color, effort, priority);
break;
case "Team":
var velocity = (double)treeLevel.Value["velocity"];
nodeData = new TeamData(size, color, effort, velocity);
break;
case "Product":
case "Sprint":
case "Quarter":
nodeData = new Data(size, color, effort);
break;
default:
throw new Exception("Work item type: " + groupLevel + ", is not supported.");
}
// Build the node and add it to the parent node.
var childNode = new Node { children = new List<Node>(), data = nodeData, id = nodeId, name = nodeName };
parentNode.children.Add(childNode);
// Continue recursion if there are more nested lists.
var unsortedChildren = treeLevel.Value["children"] as Dictionary<string, ListDictionary>;
if (unsortedChildren != null && unsortedChildren.Count > 0) // Count check is needed when multiple levels have "Aligning".
{
var nextLevel = currentLevel + 1;
var sortedChildren = SortManager.SortCollection(unsortedChildren, _globalManager.TreeLevels[nextLevel], _globalManager.SortLevels[nextLevel]);
RecursiveBuild(sortedChildren, childNode, newIndexPath);
}
}
}
public static void WriteResult(TeamData red, TeamData blue, CloudBallScore score, Stopwatch timer)
{
var color = Console.ForegroundColor;
if /**/ (score.RedWins) { Console.ForegroundColor = ConsoleColor.Red; }
else if (score.BlueWins) { Console.ForegroundColor = ConsoleColor.Blue; }
else { Console.ForegroundColor = ConsoleColor.White; }
Console.Write(score);
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("{0,4}s", timer.Elapsed.TotalSeconds.ToString("0.0"));
Console.ForegroundColor = color;
}
