IEnumerator startCountdown()
{
int count = 3;
while (count > 0)
{
resultText.color = colors[count - 1];
resultText.text = "" + count;
count--;
yield return(new WaitForSeconds(1));
}
resultText.color = Color.red;
raceState = RaceState.RACING;
startTime = Time.time;
resultText.text = "GO!";
foreach (CarController car in cars)
{
car.MaxSpeed = 50;
}
yield return(new WaitForSeconds(1));
resultText.color = defaultColor;
resultText.text = "";
resultText.enabled = false;
// what even is this line lmao
resultText.gameObject.transform.parent.gameObject.SetActive(false);
}
public void StartCountdown(double startTimestamp)
{
Debug.Log("Countdown");
state = RaceState.COUNTDOWN;
// sets
this.startTimestamp = startTimestamp;
}
public void SwitchRaceState(RaceState state)
{
_raceState = state;
//Update UI
RaceUI.instance.UpdateUIPanels();
}
public void Begin()
{
compteurDepart = temps;
startCheckpoint.gameObject.SetActive(true);
state = RaceState.STARTING;
raceUI.RenderFor(this);
}
public void Reset()
{
currentTime = 0;
state = RaceState.NOT_STARTED;
startCheckpoint.Reset();
startCheckpoint.gameObject.SetActive(false);
}
private static DriverFinishStatus FromPCarStatus(RaceState finishStatus)
{
switch (finishStatus)
{
case RaceState.RaceStateInvalid:
return(DriverFinishStatus.Na);
case RaceState.RaceStateNotStarted:
return(DriverFinishStatus.Dns);
case RaceState.RaceStateRacing:
return(DriverFinishStatus.None);
case RaceState.RaceStateFinished:
return(DriverFinishStatus.Finished);
case RaceState.RaceStateDisqualified:
return(DriverFinishStatus.Dnq);
case RaceState.RaceStateRetired:
return(DriverFinishStatus.Dnf);
case RaceState.RaceStateDnf:
return(DriverFinishStatus.Dnf);
case RaceState.RaceStateMax:
return(DriverFinishStatus.Na);
default:
return(DriverFinishStatus.Na);
}
}
public Task <IEnumerable <Race> > GetByRaceStateAsync(RaceState raceState)
{
var query = this.Query()
.Where(nameof(Race.RaceState), raceState);
return(this.QueryAsync(query));
}
private void SetupInstant()
{
m_State = RaceState.WaitForStart;
m_RaceTime = 0f;
winnerNumber = 0;
foreach (var characterRun in m_Runners)
{
characterRun.Setup();
#if SET_FLAG_ON_START
characterRun.GetComponentOrFail <FlagBearer>().Setup();
#endif
}
#if SET_FLAG_ON_START
int firstRunnerIndex = RandomlySortStartPositions();
GiveFlagToRunner(firstRunnerIndex);
#else
SpawnRunners();
#endif
foreach (var animationScript in m_FixedUpdateAnimationScripts)
{
animationScript.Setup();
}
// setup camera after spawning runners to target their initial position (including on Restart)
m_InGameCamera.Setup();
}
public void OnLeftRoom()
{
if (mRaceState != RaceState.Finished)
{
mRaceState = RaceState.Aborted;
}
}
public void CleanUp()
{
PlayGamesPlatform.Instance.RealTime.LeaveRoom();
TearDownTrack();
mRaceState = RaceState.Aborted;
sInstance = null;
}
private void UpdateUi(RaceState raceState)
{
if (gameArena.InvokeRequired)
{
gameArena.Invoke(new MethodInvoker(() => { UpdateUi(raceState); }));
return;
}
gameArena.SetRaceState(raceState);
gameArena.Refresh();
labelRound.Text = raceState.Round.ToString();
labelTime.Text = string.Format("{0,8:0.000}", raceState.Time);
//labelPlayerARounds.Text = string.Format("{0}/{1}", raceState.PodRacerRaceStates[teamA.PodRacers[0]].RoundsFinished, raceState.PodRacerRaceStates[teamA.PodRacers[1]].RoundsFinished);
labelPlayerARounds.Text = string.Format("{0}", raceState.PodRacerRaceStates[teamA.PodRacers[0]].RoundsFinished);
labelPlayerATimeout.Text = raceState.TeamRaceStates[teamA].Timeout.ToString();
if (raceState.PodRacerRaceStates[teamA.PodRacers[0]].CurrentCheckPoint != null)
{
labelPlayerACheckpoint1.Text = raceState.PodRacerRaceStates[teamA.PodRacers[0]].CurrentCheckPoint.ToString();
labelPlayerACheckpoint2.Text = raceState.PodRacerRaceStates[teamA.PodRacers[0]].PodRacer.ToString();
}
//labelPlayerBRounds.Text = string.Format("{0}/{1}", raceState.PodRacerRaceStates[teamB.PodRacers[0]].RoundsFinished, raceState.PodRacerRaceStates[teamB.PodRacers[1]].RoundsFinished);
//labelPlayerBTimeout.Text = raceState.TeamRaceStates[teamB].Timeout.ToString();
//if (raceState.PodRacerRaceStates[teamB.PodRacers[0]].CurrentCheckPoint != null)
//{
// labelPlayerBCheckpoint1.Text = raceState.PodRacerRaceStates[teamB.PodRacers[0]].CurrentCheckPoint.ToString();
// labelPlayerBCheckpoint2.Text = raceState.PodRacerRaceStates[teamB.PodRacers[1]].CurrentCheckPoint.ToString();
//}
}
protected virtual void ProcessLap(NascarRaceLap vehicle, RaceState state)
{
switch (state)
{
case RaceState.PreRace:
{
throw new ArgumentException($"Invalid state in LapService.ProcessLap: {state.ToString()}");
}
case RaceState.GreenFlag:
case RaceState.WhiteFlag:
case RaceState.Checkered:
case RaceState.Overdrive:
{
ProcessGreenFlagLap(vehicle);
break;
}
case RaceState.EndOfStage:
case RaceState.Caution:
case RaceState.OneToGo:
{
ProcessCautionFlagLap(vehicle);
break;
}
default:
{
throw new ArgumentException($"Unknown race state in LapService.ProcessLap: {state.ToString()}", nameof(state));
}
}
}
public void StartingAFinishedRaceTogglesState([Values(RaceState.Lowest, RaceState.Highest)]
RaceState startingState)
{
var numberOfCubes = 0;
if (startingState == RaceState.Lowest)
{
numberOfCubes = 1;
}
else if (startingState == RaceState.Highest)
{
numberOfCubes = 2;
}
m_NumCubesInBag = 10;
CreateRace(numberOfCubes);
m_RaceLogic.NewGame();
var expectedState = ToggleState(startingState);
Assert.That(m_RaceLogic.State, Is.EqualTo(startingState));
CompleteTestRace(numberOfCubes);
Assert.That(m_FinishRaceCallCount, Is.EqualTo(1), "Finish Race was not called once");
StartRace();
Assert.That(m_RaceLogic.State, Is.EqualTo(expectedState));
m_FinishRaceCallCount = 0;
startingState = expectedState;
expectedState = ToggleState(startingState);
Assert.That(m_RaceLogic.State, Is.EqualTo(startingState));
CompleteTestRace(numberOfCubes);
Assert.That(m_FinishRaceCallCount, Is.EqualTo(1), "Finish Race was not called once");
StartRace();
Assert.That(m_RaceLogic.State, Is.EqualTo(expectedState));
}
public JsonResult GetRaceState()
{
_logger.LogInformation("GET /GetRaceState");
try
{
RaceState state = _raceManager.GetRaceState();
ResponseObject.State stateResponse = new ResponseObject.State
{
responseMessage = "success",
state = state,
stateName = state.ToString()
};
return(Json(stateResponse));
}
catch (Exception error)
{
_logger.LogError("RaceTimer/GetRaceState Exception: " + error.Message);
ResponseObject.State stateResponse = new ResponseObject.State
{
responseMessage = "error.Message",
state = 0,
stateName = "error getting state"
};
return(new JsonResult(stateResponse)
{
StatusCode = (int)HttpStatusCode.BadRequest
});
}
}
public void Put(string id, [FromQuery] string key)
{
var state = new RaceState {
RiderId = id, RiderKey = key
};
Update(id, key, state);
}
void Finish()
{
StopCoroutine(startCountdown());
raceState = RaceState.FINISHED;
scoreManager.setTime((Time.time - startTime),
SceneManager.GetActiveScene().buildIndex);
SceneManager.LoadScene(0);
}
public void FinishRace()
{
if (CurrentState == RaceState.IN_PROGRESS)
{
CurrentState = RaceState.FINISHED;
OnRaceStateChanged.Invoke(CurrentState);
}
}
public void StartRace()
{
// Set our starting race state.
CurrentState = RaceState.STARTING;
// Assign the starting time.
StartingTime = Time.time;
}
// Start is called before the first frame update
void Start()
{
//Sets the state
if (RaceHorses.Count <= 0)
{
CurrentState = RaceState.SETUP;
}
}
public async Task GetByRaceStateValidTest(RaceState state, int amount)
{
var raceLogic = this.GetRaceLogic();
var result = (await raceLogic.GetByRaceStateAsync(state)).ToList();
Assert.Equal(amount, result.Count);
}
void Start()
{
// Set to time trial for now
thisEvent = RaceInformation.Event.Trial;
// Set Race State to Overview
raceProgress = RaceState.Overview;
}
public int GetNextFinishPoition()
{
//If all horses have crosed the line
if (nextFinishPosition == AmountOfHorses)
{
CurrentState = RaceState.FINISHED;
}
return(nextFinishPosition++);
}
protected virtual void OnRaceStateChanged(RaceState state)
{
var handler = RaceStateChanged;
if (handler != null)
{
handler.Invoke(this, state);
}
}
void Update()
{
if (state == RaceState.STARTING)
{
int tempsRestant = Mathf.FloorToInt(compteurDepart);
if (tempsRestant == 0)
{
raceUI.tempsDepart.text = "GO!";
}
else
{
raceUI.tempsDepart.text = tempsRestant.ToString();
}
if (player == null)
{
player = GameObject.FindGameObjectWithTag("MainPlayer");
}
player.GetComponent <Rigidbody>().constraints = RigidbodyConstraints.FreezeAll;
compteurDepart -= Time.deltaTime;
if (compteurDepart <= 0)
{
player.GetComponent <Rigidbody>().constraints = RigidbodyConstraints.None;
raceUI.tempsDepart.text = "";
state = RaceState.STARTED;
}
}
if (state != RaceState.STARTED)
{
return;
}
currentTime += Time.deltaTime;
if (Input.GetButton("Respawn"))
{
RespawnInRace();
}
if (currentTime <= maxWinTime && startCheckpoint.IsCourseCompleted())
{
state = RaceState.WON;
GameObject Message = Instantiate(messagePrefab);
messageFin msg = Message.GetComponent <messageFin>();
msg.nombreSecondes = 3;
msg.messageCourse.text = "Course reussie!";
}
if (currentTime >= maxWinTime && !startCheckpoint.IsCourseCompleted())
{
Reset();
GameObject Message = Instantiate(messagePrefab);
messageFin msg = Message.GetComponent <messageFin>();
msg.nombreSecondes = 3;
msg.messageCourse.text = "Course perdue! Reassayez!";
}
}
private IEnumerator WaitForStart()
{
// Wait until the race can start.
yield return(new WaitUntil(() => TimeBeforeStart <= 0f));
// Assign new race state.
CurrentState = RaceState.IN_PROGRESS;
yield break;
}
private void Start()
{
CurrentState = RaceState.Waiting;
//In online mode, send a RaceStartMessage as soon as the track is loaded (which is now)
if (matchManager.OnlineMode)
{
messenger.SendMessage(new StartRaceMessage());
}
}
private void StartRace()
{
m_State = RaceState.Started;
// m_RaceTime should have been set to 0f on SetupRace
foreach (var characterRun in m_Runners)
{
characterRun.StartRunning();
}
}
void Update()
{
raceTime += Time.deltaTime;
SortCars();
switch (state)
{
case RaceState.WAIT_ANOTHERPLAYER:
if (PhotonNetwork.isMasterClient)
{
CheckCountdown();
}
break;
case RaceState.COUNTDOWN:
countdownText.text = "" + (1 + (int)(startTimestamp - PhotonNetwork.time));
if (PhotonNetwork.time >= startTimestamp)
{
StartRace();
}
break;
case RaceState.RACING:
if (raceTime > 3)
{
countdownText.text = "";
}
else
{
countdownText.text = "GO!";
}
break;
case RaceState.FINISHED:
UpdatePlayerPanel(endPanel);
break;
}
if (race.state == RaceState.FINISHED)
{
state = RaceState.FINISHED;
raceEndPanel.gameObject.SetActive(true);
}
UpdatePlayerPanel(playersPanel);
}
private List <RaceState> GenerateRaceStatesFor25FPS(RaceResult raceResult)
{
List <RaceState> raceStates;
raceStates = new List <RaceState>();
RaceState raceStateA;
RaceState raceStateB;
int raceStateIndex = 0;
double time = 0;
double stopTime = Math.Ceiling(raceResult.RaceStates.Last().Time);
int timeIndex = 0;
raceStateA = raceResult.RaceStates[0];
raceStateB = raceResult.RaceStates[1];
while (time < stopTime)
{
int frameIndex;
for (frameIndex = 0; frameIndex < 25; frameIndex++)
{
time = timeIndex + frameIndex / 25.0;
while (((raceStateIndex + 1) < raceResult.RaceStates.Count) && (time >= raceResult.RaceStates[raceStateIndex + 1].Time))
{
raceStateIndex++;
if (raceStateIndex < raceResult.RaceStates.Count)
{
raceStateA = raceStateB;
raceStateB = raceResult.RaceStates[raceStateIndex + 1];
}
}
RaceState raceStateForFrame;
//raceStateForFrame = raceResult.RaceStates[raceStateIndex].Copy();
//raceStateForFrame.Time = time;
raceStateForFrame = RaceState.CreateInterpolation(raceStateA, raceStateB, time);
//raceStateA = raceResult.RaceStates[raceStateIndex];
//raceStateB = raceResult.RaceStates[raceStateIndex + 1];
raceStates.Add(raceStateForFrame);
}
timeIndex++;
time = timeIndex;
}
return(raceStates);
}
void SRLClient_StateChanged(object sender, RaceState state)
{
if (IsDisposed)
{
return;
}
Action action = () =>
{
if (state == RaceState.EnteredRace)
{
chkReady.Enabled = true;
chkReady.Checked = false;
btnJoinQuit.Text = "Quit Race";
btnJoinQuit.Enabled = true;
}
else if (state == RaceState.EnteredRaceAndReady)
{
chkReady.Enabled = true;
chkReady.Checked = true;
btnJoinQuit.Text = "Quit Race";
btnJoinQuit.Enabled = true;
}
else if (state == RaceState.NotInRace)
{
chkReady.Enabled = false;
chkReady.Checked = false;
btnJoinQuit.Text = "Enter Race";
btnJoinQuit.Enabled = true;
}
else if (state == RaceState.RaceEnded)
{
chkReady.Enabled = false;
chkReady.Checked = true;
btnJoinQuit.Text = "Rejoin Race";
btnJoinQuit.Enabled = true;
}
else if (state == RaceState.RaceStarted)
{
chkReady.Enabled = false;
chkReady.Checked = true;
btnJoinQuit.Text = "Forfeit Race";
btnJoinQuit.Enabled = true;
}
};
if (InvokeRequired)
{
Invoke(action);
}
else
{
action();
}
}
public void OnPeersDisconnected(string[] peers)
{
foreach (string peer in peers)
{
// if this peer has left and hasn't finished the race,
// consider them to have abandoned the race (0 score!)
mGotFinalScore.Add(peer);
mRacerScore[peer] = 0;
RemoveCarFor(peer);
}
// if, as a result, we are the only player in the race, it's over
List<Participant> racers = GetRacers();
if (mRaceState == RaceState.Playing && (racers == null || racers.Count < 2))
{
mRaceState = RaceState.Aborted;
}
}
public void OnLeftRoom()
{
if (mRaceState != RaceState.Finished)
{
mRaceState = RaceState.Aborted;
}
}
public void OnRoomConnected(bool success)
{
if (success)
{
mRaceState = RaceState.Playing;
mMyParticipantId = GetSelf().ParticipantId;
SetupTrack();
}
else
{
mRaceState = RaceState.SetupFailed;
}
}
public void StartCountdown(double startTimestamp) {
Debug.Log ("Countdown");
state = RaceState.COUNTDOWN;
// sets
this.startTimestamp = startTimestamp;
}
public void StartRace() {
Debug.Log ("Start");
state = RaceState.RACING;
GameObject[] cars = GameObject.FindGameObjectsWithTag ("Player");
foreach (GameObject go in cars) {
carControllers.Add(go.GetComponent<CarRaceControl>());
go.GetComponent<CarInput>().enabled = true;
go.GetComponent<CarRaceControl>().currentWaypoint = GameObject.Find("Checkpoint1").GetComponent<Checkpoint>();
}
car.GetComponent<CarInput>().controlable = true;
raceTime = 0;
}
public void CleanUp()
{
PlayGamesPlatform.Instance.RealTime.LeaveRoom();
TearDownTrack();
mRaceState = RaceState.Aborted;
sInstance = null;
}
private void FinishRace()
{
mGotFinalScore.Add(mMyParticipantId);
mRaceState = RaceState.Finished;
UpdateMyRank();
// send final score packet to peers
mFinalPacket[0] = (byte)'F'; // final update
mFinalPacket[1] = (byte)mRacerScore[mMyParticipantId];
PlayGamesPlatform.Instance.RealTime.SendMessageToAll(true, mFinalPacket);
}
void SRLClient_StateChanged(object sender, RaceState state)
{
if (IsDisposed)
return;
this.InvokeIfRequired(() =>
{
if (state == RaceState.EnteredRace)
{
chkReady.Enabled = true;
chkReady.Checked = false;
btnJoinQuit.Text = "Quit Race";
btnJoinQuit.Enabled = true;
}
else if (state == RaceState.EnteredRaceAndReady)
{
chkReady.Enabled = true;
chkReady.Checked = true;
btnJoinQuit.Text = "Quit Race";
btnJoinQuit.Enabled = true;
}
else if (state == RaceState.NotInRace)
{
chkReady.Enabled = false;
chkReady.Checked = false;
btnJoinQuit.Text = "Enter Race";
btnJoinQuit.Enabled = true;
}
else if (state == RaceState.RaceEnded)
{
chkReady.Enabled = false;
chkReady.Checked = true;
btnJoinQuit.Text = "Rejoin Race";
btnJoinQuit.Enabled = true;
}
else if (state == RaceState.RaceStarted)
{
chkReady.Enabled = false;
chkReady.Checked = true;
btnJoinQuit.Text = "Forfeit Race";
btnJoinQuit.Enabled = true;
}
});
}
