1076 lines
33 KiB
C#
1076 lines
33 KiB
C#
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using Mirror;
|
|
using System.Linq;
|
|
using UnityEngine.UI;
|
|
using System.Collections;
|
|
using CustomExtensions;
|
|
using Debug = CustomLogger.Debug;
|
|
|
|
public class SpaceshipController : NetworkBehaviour
|
|
{
|
|
public LayerMask pickupsLayer;
|
|
[SyncVar]
|
|
public bool ready;
|
|
public SpriteRenderer playerImg;
|
|
public SkinsData skins;
|
|
[SyncVar(hook = nameof(OnSkinChanged))]
|
|
public string skinName = null;
|
|
[SyncVar(hook = nameof(OnPnameChanged))]
|
|
public string pname;
|
|
[SyncVar(hook = nameof(OnScoresChanged))]
|
|
public int Scores;
|
|
[SyncVar(hook = nameof(OnKillsChanged))]
|
|
public int Kills;
|
|
[SyncVar(hook = nameof(OnTrailTimeChanged))]
|
|
public float trailTime;
|
|
public float minTrailTime;
|
|
public float maxTrailTime;
|
|
[SyncVar]
|
|
public int moonsCollected;
|
|
public float trailIncrementRate = 0.5f;
|
|
[SyncVar]
|
|
public bool dead;
|
|
[SyncVar]
|
|
public float speed;
|
|
|
|
[SyncVar]
|
|
public float speedMultiplier;
|
|
[SyncVar]
|
|
public float boostConsumption;
|
|
[SyncVar]
|
|
public float energyGain;
|
|
public float _scaleMultiplier = 1;
|
|
public Text pnameTxt;
|
|
public Transform body;
|
|
public TrailMgr trailMgr;
|
|
public float movingSpeed = 0.1f;
|
|
public float turningSmoothFactor = 0.1f;
|
|
public Joystick joystick;
|
|
[SyncVar]
|
|
public bool boosting;
|
|
public bool boosting_local;
|
|
|
|
[Header("Client Prediction")]
|
|
private Vector2 input;
|
|
[SyncVar]
|
|
public Vector2 m_Input;
|
|
[SerializeField]private float rubberbandSmoothness = 0.3f;
|
|
private float timer;
|
|
private int currentTick;
|
|
private float minTimeBetweenTicks;
|
|
private const float SERVER_TICK_RATE = 30f;
|
|
private const int BUFFER_SIZE = 2048;
|
|
private const bool CUSTOM_NET_TRANSFORM = true;
|
|
private float ERROR_THRESHOLD =0.25f;
|
|
private int MIN_ERROR_COUNT = 10;
|
|
public bool showDebugHUD = false;
|
|
private double clientNetworkRTT;
|
|
|
|
public InputState[] clientInputBuffer;
|
|
public Queue<InputState> inputQueue;
|
|
public PlayerState[] stateBuffer;
|
|
|
|
public GameObject DeathEffect;
|
|
public GameObject debrisEffect;
|
|
// public GameObject boostStartEffect;
|
|
public ParticleSystem[] boostStartEffect;
|
|
public ParticleSystem[] boostEffects;
|
|
// public GameObject PickupEffect;
|
|
|
|
public float distanceFromCenter = 0;
|
|
RocketLevel rocketStats;
|
|
[Header("AudioFX")]
|
|
public AudioSource engineAudio;
|
|
public float normalPitch,boostedPitch;
|
|
public void SetReady(bool value)
|
|
{
|
|
if (isServer)
|
|
{
|
|
ready = value;
|
|
}
|
|
else
|
|
{
|
|
CmdSetReady(value);
|
|
}
|
|
}
|
|
|
|
[Command]
|
|
void CmdSetReady(bool value)
|
|
{
|
|
ready = value;
|
|
}
|
|
|
|
[Command]
|
|
void CmdSetPname(string value)
|
|
{
|
|
pname = value;
|
|
}
|
|
void OnPnameChanged(string oldName, string newName)
|
|
{
|
|
pnameTxt.text = newName;
|
|
Debug.Log(pname + " Joined the game");
|
|
}
|
|
|
|
[Command]
|
|
void CmdSetSkin(string newSkin)
|
|
{
|
|
skinName = newSkin;
|
|
}
|
|
|
|
[Command]
|
|
void CmdSetStats(float _speed, float _energy, float _boost)
|
|
{
|
|
speedMultiplier = _speed;
|
|
energyGain = _energy;
|
|
boostConsumption = _boost;
|
|
}
|
|
|
|
void OnSkinChanged(string oldSkin, string newSkin)
|
|
{
|
|
ChangeSkin(newSkin);
|
|
}
|
|
|
|
void ChangeSkin(string name)
|
|
{
|
|
Sprite newSprite = SkinManagerHelper.getSkinSprite(name, skins);
|
|
playerImg.sprite = newSprite;
|
|
}
|
|
|
|
|
|
void OnScoresChanged(int oldScores, int newScores)
|
|
{
|
|
Debug.Log($"Add scores {newScores - oldScores}, (total: {newScores})");
|
|
}
|
|
bool isBoostAvailable {get{ return trailTime > minTrailTime;}}
|
|
void OnTrailTimeChanged(float oldValue, float newValue)
|
|
{
|
|
trailMgr.trail.time = newValue;
|
|
if (isLocalPlayer)
|
|
{
|
|
|
|
// SceneData.holder.boostBtn.gameObject.SetActive(isBoostAvailable);
|
|
SceneData.holder.boostBtn.transform.GetChild(0).gameObject.SetActive(isBoostAvailable);
|
|
SceneData.holder.boostBtn.transform.GetChild(0).GetChild(0).gameObject.SetActive(trailTime > maxTrailTime/2f);
|
|
SceneData.holder.boostBtn.transform.GetChild(0).GetChild(1).gameObject.SetActive(trailTime > maxTrailTime* 0.8f);
|
|
SceneData.holder.boostBtn.transform.GetChild(0).GetChild(2).gameObject.SetActive(trailTime >= maxTrailTime);
|
|
SceneData.holder.boostBtn.transform.GetChild(0).Find("Slider").GetComponent<Image>().fillAmount = Mathf.Clamp(0.73f - ((trailTime /maxTrailTime)*0.73f),0f,0.73f);
|
|
|
|
|
|
if (!isBoostAvailable && boosting)
|
|
{
|
|
CmdSetBoosting(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnBoostDown()
|
|
{
|
|
if(!isBoostAvailable){return; }
|
|
if (isLocalPlayer)
|
|
{
|
|
boosting_local = true;
|
|
AudioManager.instnace.Boost();
|
|
if (isServer)
|
|
{
|
|
boosting = true;
|
|
}
|
|
else
|
|
{
|
|
CmdSetBoosting(true);
|
|
}
|
|
|
|
CameraFollower.instance.ShakeBoost();
|
|
Vibrate();
|
|
|
|
// GameObject fx = EffectPool.Spawn(boostStartEffect, transform.position);
|
|
foreach(ParticleSystem particle in boostStartEffect){
|
|
particle.Play();
|
|
}
|
|
}
|
|
}
|
|
void Vibrate(){
|
|
#if UNITY_ANDROID
|
|
if(ControlSettings.HapticEnabled){
|
|
Handheld.Vibrate();
|
|
}
|
|
#endif
|
|
}
|
|
void OnBoostUp()
|
|
{
|
|
if (isLocalPlayer)
|
|
{
|
|
boosting_local = false;
|
|
if (isServer)
|
|
{
|
|
boosting = false;
|
|
}
|
|
else
|
|
{
|
|
CmdSetBoosting(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Command]
|
|
void CmdSetBoosting(bool value)
|
|
{
|
|
boosting = value;
|
|
}
|
|
[SyncVar]
|
|
public double startedTime = 0;
|
|
|
|
void ResetStats()
|
|
{
|
|
startedXp = DBmanager.Xp;
|
|
startedMetal = DBmanager.Metal;
|
|
}
|
|
|
|
void Start()
|
|
{
|
|
clientInputBuffer = new InputState[BUFFER_SIZE];
|
|
inputQueue = new Queue<InputState>();
|
|
stateBuffer = new PlayerState[BUFFER_SIZE];
|
|
|
|
minTimeBetweenTicks = 1f / SERVER_TICK_RATE;
|
|
string[] args = System.Environment.GetCommandLineArgs();
|
|
for (int i = 0; i < args.Length; i++)
|
|
{
|
|
// Debug.Log("ARG " + i + ": " + args[i]);
|
|
if (args[i] == "-et")
|
|
{
|
|
ERROR_THRESHOLD =float.Parse(args[i+1]);
|
|
}
|
|
if(args[i] == "-grace"){
|
|
MIN_ERROR_COUNT = int.Parse(args[i+1]);
|
|
}
|
|
}
|
|
|
|
if (isLocalPlayer)
|
|
{
|
|
ResetStats();
|
|
if (MinigameManager.instance.isRanked)
|
|
{
|
|
DBmanager.SetMetal(DBmanager.Metal + DBmanager.CurrentRank.energyReward);
|
|
DBmanager.SetMetal(DBmanager.Metal - DBmanager.CurrentRank.entryFee);
|
|
}
|
|
if (joystick == null) { joystick = FindObjectOfType<Joystick>(); }
|
|
FindObjectOfType<CameraFollower>().SetTarget(transform);
|
|
string myName = DBmanager.DisplayName;
|
|
SceneData.localPlayer = gameObject;
|
|
SceneData.OnBoostDown.AddListener(OnBoostDown);
|
|
SceneData.OnBoostUp.AddListener(OnBoostUp);
|
|
//Set username
|
|
if (isServer) { pname = myName; }
|
|
else
|
|
{
|
|
CmdSetPname(myName);
|
|
}
|
|
|
|
//Set Skin
|
|
if (DBmanager.GetSkinIdByName(SkinShopManager.GetEquipedSkin()) < 0)
|
|
{
|
|
//False skin purchase
|
|
}
|
|
else
|
|
{
|
|
string skin = SkinShopManager.GetEquipedSkin();
|
|
SkinType rarity = SkinShopManager.GetRarityFromName(skin);
|
|
PurchasedSkin purchasedSkin = DBmanager.GetSkinByName(skin);
|
|
|
|
float m_speed = SkinShopManager.GetStatsForRarity(rarity)[purchasedSkin.speedLevel].speedMultiplier;
|
|
float m_energy = SkinShopManager.GetStatsForRarity(rarity)[purchasedSkin.energyLevel].moonMultiplier;
|
|
float m_boost = SkinShopManager.GetStatsForRarity(rarity)[purchasedSkin.boostLevel].boostConsumption;
|
|
|
|
if (isServer)
|
|
{
|
|
skinName = skin;
|
|
speedMultiplier = m_speed;
|
|
energyGain = m_energy;
|
|
boostConsumption = m_boost;
|
|
}
|
|
else
|
|
{
|
|
CmdSetSkin(skin);
|
|
CmdSetStats(m_speed, m_energy, m_boost);
|
|
}
|
|
}
|
|
|
|
pnameTxt.text = myName;
|
|
pnameTxt.gameObject.SetActive(false);
|
|
|
|
}
|
|
if (isServer)
|
|
{
|
|
startedTime = NetworkTime.time;
|
|
trailTime = 0;
|
|
DecreaseTrail(0);
|
|
}else{
|
|
if(AudioManager.SFX_enabled){
|
|
engineAudio.volume = 1;
|
|
}else{
|
|
engineAudio.volume= 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
float scale => Mathf.Clamp(1 + (trailTime * _scaleMultiplier), 1, 10);
|
|
|
|
void Update()
|
|
{
|
|
#if UNITY_EDITOR
|
|
// Debug.Log(FindObjectsOfType<PickupItem>().Length);
|
|
#endif
|
|
|
|
if (MinigameManager.instance.isRanked && !MinigameManager.instance.RankedGameStarted) { return; }
|
|
distanceFromCenter = Vector3.Distance(transform.position, Vector3.zero);
|
|
pnameTxt.rectTransform.rotation = Quaternion.Euler(Vector3.zero);
|
|
|
|
//Update size of trail and spaceship
|
|
transform.localScale = Vector3.Lerp(transform.localScale, new Vector3(scale, scale, scale), 0.1f);
|
|
trailMgr.trail.startWidth = Mathf.Lerp(trailMgr.trail.startWidth, scale, 0.1f);
|
|
|
|
if (dead) { return; }
|
|
|
|
if(isLocalPlayer){
|
|
if (joystick == null) { joystick = FindObjectOfType<Joystick>(); if(joystick==null){return;} }
|
|
|
|
input = joystick.input;
|
|
if (Input.GetKeyDown(KeyCode.F))
|
|
{
|
|
CmdCheatKills();
|
|
}
|
|
if(Input.GetKeyDown(KeyCode.Space)){
|
|
OnBoostDown();
|
|
}
|
|
if(Input.GetKeyUp(KeyCode.Space)){
|
|
OnBoostUp();
|
|
}
|
|
// Debug.Log(startedTime-NetworkTime.time);
|
|
double survivalTime = (startedTime == 0) ? 0 : NetworkTime.time - ((MinigameManager.instance.isRanked) ? MinigameManager.instance.startedTime : startedTime);
|
|
if (DBmanager.MostTime < (int)survivalTime)
|
|
{
|
|
DBmanager.SetMostTime((int)survivalTime);
|
|
}
|
|
SceneData.SetTimerTxt(survivalTime);
|
|
// Debug.Log(lastTime - currentTick);
|
|
}
|
|
|
|
|
|
timer += Time.deltaTime;
|
|
while(timer >= minTimeBetweenTicks){
|
|
timer -= minTimeBetweenTicks;
|
|
if(isServer){
|
|
HandleTick();
|
|
}else if(isLocalPlayer){
|
|
ClientHandleTick();
|
|
}
|
|
currentTick++;
|
|
}
|
|
|
|
// return;
|
|
|
|
}
|
|
|
|
void FixedUpdate(){
|
|
if(!isLocalPlayer && !isServer){
|
|
transform.position = latestServerState.Position;
|
|
transform.rotation = latestServerState.Rotation;
|
|
}
|
|
}
|
|
|
|
#region Movement
|
|
IEnumerator SendToClient(PlayerState statePayload)
|
|
{
|
|
yield return new WaitForSeconds(0.02f);
|
|
|
|
OnServerMovementState(statePayload);
|
|
}
|
|
void HandleTick(){
|
|
#region obsoleteCommented
|
|
/*
|
|
curBufferIndex = bufferIndex;
|
|
if(isLocalPlayer){
|
|
// HandleInput(input);
|
|
|
|
InputState curInputState = new InputState(){Tick=currentTick, Input = input};
|
|
PlayerState curState = new PlayerState(){Tick=currentTick, Position= transform.position, Rotation = transform.rotation};
|
|
clientInputBuffer[bufferIndex] = curInputState;
|
|
clientStateBuffer[bufferIndex] = curState;
|
|
|
|
// transform.Translate(transform.forward * input.y);
|
|
// transform.Rotate(transform.up * input.x);
|
|
UpdateStates(currentTick, NetworkTime.rtt, input, curState.Position, curState.Rotation);
|
|
|
|
// body.position = targetState.Position;
|
|
// body.rotation = targetState.Rotation;
|
|
// body.position = Vector3.Lerp(body.position,targetState.Position,MovementSmoothnessFactor * movingSpeed);
|
|
// body.rotation = Quaternion.Lerp(body.rotation, targetState.Rotation,MovementSmoothnessFactor*movingSpeed);
|
|
}else if (isServer){
|
|
HandleInput(m_Input);
|
|
if(CUSTOM_NET_TRANSFORM){
|
|
RpcUpdateOnClient(body.position, body.rotation, m_Input);
|
|
}
|
|
|
|
CheckForPickups();
|
|
}else{
|
|
//client but not localPlayer
|
|
body.position = targetState.Position;
|
|
body.rotation = targetState.Rotation;
|
|
// for(int i = 0; i < ticksGap; i++){
|
|
// HandleInput(m_Input);
|
|
// }
|
|
}
|
|
// if(isLocalPlayer){CameraFollower.UpdateFrame();}
|
|
|
|
float stateError = clientStateBuffer[bufferIndex].Difference(serverStateBuffer[latencyBufferIndex]);
|
|
foreach(ParticleSystem boostEffect in boostEffects){
|
|
if(boostEffect.isEmitting && !boosting){
|
|
boostEffect.Stop();
|
|
}else if(!boostEffect.isEmitting && boosting){
|
|
boostEffect.Play();
|
|
}
|
|
}
|
|
if(isServer){
|
|
InputState curServerInputState = new InputState(){Tick=currentTick, Input = m_Input};
|
|
PlayerState curServerState = new PlayerState(){Tick=currentTick, Position = transform.position, Rotation = transform.rotation};
|
|
serverInputBuffer[bufferIndex] = curServerInputState;
|
|
serverStateBuffer[bufferIndex] = curServerState;
|
|
|
|
if(!clientInputBuffer[bufferIndex].CloseEnough(serverInputBuffer[latencyBufferIndex],ERROR_THRESHOLD)){
|
|
ErrorInputCount++;
|
|
}
|
|
// if(!clientStateBuffer[bufferIndex].CloseEnough(serverStateBuffer[latencyBufferIndex],ERROR_THRESHOLD)){
|
|
if(stateError > ERROR_THRESHOLD){
|
|
ErrorStateCount++;
|
|
errorCounter++;
|
|
|
|
if(errorCounter> MIN_ERROR_COUNT){RpcRubberband(transform.position, transform.rotation); errorCounter=0;}
|
|
}else{
|
|
errorCounter = 0;
|
|
}
|
|
|
|
|
|
//boost check
|
|
if (boosting && scale > 1)
|
|
{
|
|
speed = movingSpeed * 2 * speedMultiplier;
|
|
DecreaseTrail(Time.deltaTime * boostConsumption * 0.5f);
|
|
// scaleMultiplier -= Time.deltaTime;
|
|
// if (scaleMultiplier < 1) { scaleMultiplier = 1; } //Clamp in case gets lower
|
|
}
|
|
else
|
|
{
|
|
speed = movingSpeed * speedMultiplier;
|
|
}
|
|
}*/
|
|
#endregion
|
|
CheckForPickups();
|
|
UpdateSpeed();
|
|
|
|
int bufferIndex = -1;
|
|
while(inputQueue.Count > 0){
|
|
InputState inputState = inputQueue.Dequeue();
|
|
|
|
bufferIndex = inputState.Tick % BUFFER_SIZE;
|
|
|
|
PlayerState statePayload = ProcessMovement(inputState);
|
|
stateBuffer[bufferIndex] = statePayload;
|
|
}
|
|
|
|
if(bufferIndex != -1){
|
|
StartCoroutine(SendToClient(stateBuffer[bufferIndex]));
|
|
}
|
|
}
|
|
|
|
void UpdateSpeed(){
|
|
if (boosting && trailTime >= minTrailTime)
|
|
{
|
|
speed = movingSpeed * 2 * speedMultiplier;
|
|
DecreaseTrail(Time.deltaTime * boostConsumption * 0.5f);
|
|
}
|
|
else
|
|
{
|
|
boosting = false;
|
|
speed = movingSpeed * speedMultiplier;
|
|
}
|
|
}
|
|
public float speedLocal = 0;
|
|
void UpdateSpeedLocal(){
|
|
if (boosting_local && trailTime >= minTrailTime)
|
|
{
|
|
speedLocal = movingSpeed * 2 * speedMultiplier;
|
|
DecreaseTrail(Time.deltaTime * boostConsumption * 0.5f);
|
|
}
|
|
else
|
|
{
|
|
boosting_local = false;
|
|
OnBoostUp();
|
|
speedLocal = movingSpeed * speedMultiplier;
|
|
}
|
|
}
|
|
|
|
void ClientHandleTick(){
|
|
if(isLocalPlayer){
|
|
UpdateSpeedLocal();
|
|
}
|
|
engineAudio.pitch = Mathf.Lerp(engineAudio.pitch, (boosting) ? boostedPitch : normalPitch, 0.1f);
|
|
|
|
if (!latestServerState.Equals(default(PlayerState)) &&
|
|
(lastProcessedState.Equals(default(PlayerState)) ||
|
|
!latestServerState.Equals(lastProcessedState)))
|
|
{
|
|
// Debug.Log("Consider Reconciliation");
|
|
HandleServerReconciliation();
|
|
}
|
|
|
|
int bufferIndex = currentTick % BUFFER_SIZE;
|
|
|
|
// Add payload to inputBuffer
|
|
InputState inputPayload = new InputState();
|
|
inputPayload.Tick = currentTick;
|
|
inputPayload.Input = joystick.input;
|
|
clientInputBuffer[bufferIndex] = inputPayload;
|
|
|
|
// Add payload to stateBuffer
|
|
stateBuffer[bufferIndex] = ProcessMovement(inputPayload);
|
|
if(isLocalPlayer){
|
|
CameraFollower.UpdateFrame();
|
|
}
|
|
// Send input to server
|
|
StartCoroutine(SendToServer(inputPayload));
|
|
}
|
|
|
|
|
|
public void OnClientInput(InputState inputPayload){
|
|
if(isServer){
|
|
m_OnClientInput(inputPayload);
|
|
}else{
|
|
CmdOnClientInput(inputPayload);
|
|
}
|
|
}
|
|
|
|
[Command]
|
|
public void CmdOnClientInput(InputState inputPayload){
|
|
m_OnClientInput(inputPayload);
|
|
}
|
|
|
|
public void m_OnClientInput(InputState inputPayload)
|
|
{
|
|
inputQueue.Enqueue(inputPayload);
|
|
}
|
|
|
|
private PlayerState latestServerState;
|
|
private PlayerState lastProcessedState;
|
|
|
|
void HandleServerReconciliation()
|
|
{
|
|
lastProcessedState = latestServerState;
|
|
|
|
int serverStateBufferIndex = latestServerState.Tick % BUFFER_SIZE;
|
|
float positionError = Vector3.Distance(latestServerState.Position, stateBuffer[serverStateBufferIndex].Position);
|
|
float rotationError = CustomExtensions.QuaternionExtensions.Difference(latestServerState.Rotation, stateBuffer[serverStateBufferIndex].Rotation);
|
|
|
|
if (positionError > 0.001f || !latestServerState.Rotation.Approximately(stateBuffer[serverStateBufferIndex].Rotation, 0.0001f))
|
|
{
|
|
Debug.Log($"We have to reconcile bro, Errors\npos:{positionError}, rot:{rotationError}");
|
|
// Rewind & Replay
|
|
transform.position = latestServerState.Position;
|
|
transform.rotation = latestServerState.Rotation;
|
|
|
|
// Update buffer at index of latest server state
|
|
stateBuffer[serverStateBufferIndex] = latestServerState;
|
|
|
|
// Now re-simulate the rest of the ticks up to the current tick on the client
|
|
int tickToProcess = latestServerState.Tick + 1;
|
|
|
|
while (tickToProcess < currentTick)
|
|
{
|
|
int bufferIndex = tickToProcess % BUFFER_SIZE;
|
|
|
|
// Process new movement with reconciled state
|
|
PlayerState statePayload = ProcessMovement(clientInputBuffer[bufferIndex]);
|
|
|
|
// Update buffer with recalculated state
|
|
stateBuffer[bufferIndex] = statePayload;
|
|
|
|
tickToProcess++;
|
|
}
|
|
}else{
|
|
// Debug.Log($"Reconciliation cancelled\n, Errors\npos:{positionError}, rot:{rotationError}");
|
|
}
|
|
}
|
|
|
|
public void m_OnServerMovementState(PlayerState serverState)
|
|
{
|
|
latestServerState = serverState;
|
|
}
|
|
|
|
public void OnServerMovementState(PlayerState serverState){
|
|
if(isServer){
|
|
RpcOnServerMovementState(serverState);
|
|
}else{
|
|
m_OnServerMovementState(serverState);
|
|
// CmdOnServerMovementState(serverState);
|
|
}
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void RpcOnServerMovementState(PlayerState serverState){
|
|
m_OnServerMovementState(serverState);
|
|
// Debug.Log(serverState.Position + ":" + transform.position);
|
|
|
|
}
|
|
|
|
IEnumerator SendToServer(InputState inputPayload)
|
|
{
|
|
yield return new WaitForSeconds(0.02f);
|
|
|
|
OnClientInput(inputPayload);
|
|
}
|
|
|
|
PlayerState ProcessMovement(InputState input)
|
|
{
|
|
// Should always be in sync with same function on Client
|
|
body.Translate(new Vector3(0, (isLocalPlayer) ? speedLocal: speed), body);
|
|
Turn(input.Input);
|
|
|
|
return new PlayerState()
|
|
{
|
|
Tick = input.Tick,
|
|
Position = transform.position,
|
|
Rotation = transform.rotation
|
|
};
|
|
}
|
|
|
|
#endregion
|
|
|
|
void CheckForPickups(){
|
|
Collider2D[] hits = Physics2D.OverlapCircleAll(transform.position, 3, pickupsLayer);
|
|
foreach(Collider2D hit in hits){
|
|
if(hit!=null ){
|
|
// Debug.Log(hit.name);
|
|
PickupItem pickupItem = hit.GetComponent<PickupItem>();
|
|
if(pickupItem !=null && pickupItem.active){
|
|
pickupItem.active=false;
|
|
pickupItem.Deactivate(transform);
|
|
CollectPickup(pickupItem.type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// void HandleInput(Vector2 _input){
|
|
// // transform.Translate(transform.forward * _input.y);
|
|
// // transform.Rotate(transform.up * _input.x);
|
|
// body.Translate(new Vector3(0, speed), body);
|
|
// Turn(_input);
|
|
// }
|
|
|
|
void Turn(Vector2 input)
|
|
{
|
|
body.rotation = Quaternion.Lerp(body.rotation, getTurnAngle(input), turningSmoothFactor * input.magnitude);
|
|
}
|
|
|
|
Quaternion getTurnAngle(Vector2 input)
|
|
{
|
|
var angle1 = Mathf.Atan2(-input.y, -input.x) * Mathf.Rad2Deg;
|
|
return Quaternion.AngleAxis(angle1 + 90, Vector3.forward);
|
|
}
|
|
|
|
|
|
[ClientRpc]
|
|
void RpcUpdateTrail(Vector3[] positions)
|
|
{
|
|
//trailMgr.trail.SetPositions(positions);
|
|
}
|
|
|
|
public float Angle(Vector2 vector2)
|
|
{
|
|
return 360 - (Mathf.Atan2(vector2.x, vector2.y) * Mathf.Rad2Deg * Mathf.Sign(vector2.x));
|
|
}
|
|
|
|
|
|
//Auto assign default variables [Editor only]
|
|
void OnValidate()
|
|
{
|
|
if (body == null)
|
|
{
|
|
body = transform;
|
|
}
|
|
if (trailMgr == null)
|
|
{
|
|
trailMgr = GetComponent<TrailMgr>();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public void TrailCollided(Collider2D hit)
|
|
{
|
|
if (!isServer)
|
|
{
|
|
Debug.Log("Got hit : " + hit.name);
|
|
// Debug.Log("This cannot run on client, That's illegal!"); // <-- What this log says
|
|
return;
|
|
}
|
|
|
|
SpaceshipController deadPlayer = hit.GetComponent<SpaceshipController>();
|
|
// Debug.Log("got hit by player? : " + (deadPlayer != null));
|
|
if (deadPlayer != null && !deadPlayer.dead && (NetworkTime.time - deadPlayer.startedTime) > 5)
|
|
{ // <-- okay we killed someone | KILLCODE
|
|
// deadPlayer.RpcShowDeathEffect(deadPlayer.transform.position);
|
|
|
|
deadPlayer.Die(pname);
|
|
Debug.Log($"{pname} killed {deadPlayer.pname}");
|
|
OnKill();
|
|
|
|
}
|
|
|
|
SpaceshipNetworkBot deadBot = hit.GetComponent<SpaceshipNetworkBot>();
|
|
// Debug.Log("got hit by bot? : " + (deadPlayer != deadBot));
|
|
|
|
if(deadBot != null){
|
|
deadBot.Die();
|
|
Kills++;
|
|
return;
|
|
}
|
|
}
|
|
public void ShowDeathEffect(Vector2 position){
|
|
if(isServer){
|
|
// MinigameManager.instance.ShowDeathEffect(position);
|
|
EffectPool.Spawn(DeathEffect, position);
|
|
RpcShowDeathEffect(position);
|
|
}else{
|
|
CmdShowDeathEffect(position);
|
|
}
|
|
}
|
|
|
|
[Command]
|
|
void CmdShowDeathEffect(Vector2 position){
|
|
EffectPool.Spawn(DeathEffect, position);
|
|
|
|
|
|
RpcShowDeathEffect(position);
|
|
}
|
|
|
|
[ClientRpc]
|
|
void RpcShowDeathEffect(Vector2 position){
|
|
EffectPool.Spawn(DeathEffect, position);
|
|
// EffectPool.Spawn(debrisEffect, position).GetComponent<DebrisEffect>().Play();
|
|
}
|
|
|
|
void OnKill()
|
|
{
|
|
Kills++;
|
|
// Scores += 10; //TODO: Need to change Scores on kills?
|
|
// scaleMultiplier += 0.05f;
|
|
// OnScaleChanged(scaleMultiplier, scaleMultiplier);
|
|
IncreaseTrail(trailIncrementRate);
|
|
RpcOnKill();
|
|
}
|
|
|
|
[ClientRpc]
|
|
void RpcOnKill()
|
|
{
|
|
Vibrate();
|
|
}
|
|
|
|
void OnKillsChanged(int oldVal, int newVal)
|
|
{
|
|
if (isLocalPlayer)
|
|
{
|
|
Debug.Log("Show kills for " + newVal);
|
|
KillText.Show(newVal);
|
|
}
|
|
}
|
|
|
|
void IncreaseTrail(float rate)
|
|
{
|
|
trailTime = Mathf.Clamp(trailMgr.trail.time + rate, minTrailTime, maxTrailTime);
|
|
trailMgr.trail.time = trailTime;
|
|
// Debug.Log("Increasing trail of" + pname);
|
|
}
|
|
|
|
public void DecreaseTrail(float rate)
|
|
{
|
|
trailTime = Mathf.Clamp(trailMgr.trail.time - rate, minTrailTime, maxTrailTime);
|
|
trailMgr.trail.time = trailTime;
|
|
// Debug.Log("Decreasing trail of" + pname);
|
|
}
|
|
|
|
[Command]
|
|
void CmdCheatKills()
|
|
{
|
|
OnKill();
|
|
}
|
|
|
|
public void CollectPickup(PickupItem.PickupType type)
|
|
{
|
|
if (!isServer) { Debug.Log("Server function ran on client. That's illegal!"); } // <-- What this log says
|
|
|
|
if(type == PickupItem.PickupType.Moon1 || type == PickupItem.PickupType.Moon2|| type == PickupItem.PickupType.Moon3|| type == PickupItem.PickupType.Moon4|| type == PickupItem.PickupType.Moon5){
|
|
//Moon!
|
|
IncreaseTrail(trailIncrementRate);
|
|
// scaleMultiplier += 0.05f;
|
|
moonsCollected++;
|
|
Scores += 2;
|
|
}else {
|
|
IncreaseTrail(trailIncrementRate / 2f);
|
|
Scores += 1;
|
|
}
|
|
|
|
RpcCollectPickup(type);
|
|
}
|
|
|
|
[ClientRpc]
|
|
void RpcCollectPickup(PickupItem.PickupType type)
|
|
{
|
|
|
|
if (isLocalPlayer)
|
|
{
|
|
if (type == PickupItem.PickupType.Twep)
|
|
{
|
|
DBmanager.SetTweps(DBmanager.Tweps + 1);
|
|
}
|
|
else
|
|
{
|
|
int gainedEnergy = (int)(energyGain * type.GetEnergy());
|
|
|
|
MinigameManager.instance.GainMetals(gainedEnergy);
|
|
}
|
|
|
|
AudioManager.instnace.CollectMoon(trailTime,maxTrailTime);
|
|
}
|
|
|
|
}
|
|
|
|
public void Die(string killer)
|
|
{
|
|
|
|
MinigameManager.instance.SpawnLeftoverPickups(transform.position, (int)((float)Scores / 4f));
|
|
|
|
RpcShowDeathEffect(transform.position);
|
|
Debug.Log($"Sending death signal to {pname} by {killer}");
|
|
|
|
//Handle Respawning
|
|
// OnScaleChanged(scaleMultiplier, 1);
|
|
// scaleMultiplier = 1;
|
|
dead = true;
|
|
Scores = 0;
|
|
Kills = 0;
|
|
startedTime = NetworkTime.time;
|
|
DecreaseTrail(trailTime);
|
|
trailMgr.trail.time = trailTime;
|
|
RpcDie(killer);
|
|
gameObject.SetActive(false);
|
|
//MinigameManager.instance.SetRespawn(gameObject);
|
|
}
|
|
|
|
private int startedXp;
|
|
private int startedMetal;
|
|
|
|
bool RewardedRankedMetal = false;
|
|
|
|
[ClientRpc]
|
|
public void RpcDie(string killer)
|
|
{
|
|
Debug.Log($"{killer} killed {pname} : isItMe? -> {isLocalPlayer}");
|
|
KillfeedMgr.instance.AddNewEntry($"<b>{pname}</b> was killed by <b>{killer}</b>");
|
|
gameObject.SetActive(false);
|
|
if (isLocalPlayer)
|
|
{
|
|
//TODO: Death message goes here
|
|
SceneData.holder.ShowDeadscreen(DBmanager.Xp - startedXp, DBmanager.Metal - startedMetal, NetworkTime.time - startedTime);
|
|
if (MinigameManager.instance.isRanked && RankedSplash.instance.gameObject.activeSelf)
|
|
{
|
|
// MinigameManager.instance.rankedSummary.ShowLoss();
|
|
// StartCoroutine(ShowRankedResults());
|
|
if (MinigameManager.instance.winnerId <= 0)
|
|
{
|
|
Debug.LogError("Winner ID not synced yet");
|
|
checkWinner(1000);
|
|
}
|
|
if (MinigameManager.instance.winnerId != netId)
|
|
{
|
|
//LOSER!
|
|
MinigameManager.instance.rankedSummary.ShowLoss();
|
|
AudioManager.instnace.MinigameLost();
|
|
|
|
}
|
|
else
|
|
{
|
|
MinigameManager.instance.rankedSummary.ShowWin();
|
|
AudioManager.instnace.MinigameWon();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async void checkWinner(int delay){
|
|
await System.Threading.Tasks.Task.Delay(delay);
|
|
|
|
if (MinigameManager.instance.winnerId != netId)
|
|
{
|
|
//LOSER!
|
|
MinigameManager.instance.rankedSummary.ShowLoss();
|
|
AudioManager.instnace.MinigameLost();
|
|
|
|
}
|
|
else
|
|
{
|
|
MinigameManager.instance.rankedSummary.ShowWin();
|
|
AudioManager.instnace.MinigameWon();
|
|
|
|
}
|
|
}
|
|
|
|
IEnumerator ShowRankedResults()
|
|
{
|
|
while (MinigameManager.instance.winnerId <= 0)
|
|
{
|
|
yield return new WaitForFixedUpdate();
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public void Respawn(Vector3 respawnPoint)
|
|
{
|
|
Debug.Log("Respawning " + pname);
|
|
|
|
if (isServer)
|
|
{
|
|
respawn(respawnPoint);
|
|
}
|
|
else
|
|
{
|
|
CmdRespawn(respawnPoint);
|
|
}
|
|
}
|
|
|
|
[Command]
|
|
void CmdRespawn(Vector3 respawnPoint)
|
|
{
|
|
respawn(respawnPoint);
|
|
}
|
|
|
|
public void respawn(Vector3 respawnPoint)
|
|
{
|
|
dead = false;
|
|
trailMgr.trail.emitting = false;
|
|
trailMgr.trail.Clear();
|
|
RpcRespawn(respawnPoint);
|
|
transform.position = respawnPoint;
|
|
trailMgr.trail.emitting = true;
|
|
gameObject.SetActive(true);
|
|
}
|
|
|
|
[ClientRpc]
|
|
public void RpcRespawn(Vector3 respawnPoint)
|
|
{
|
|
|
|
GetComponent<NetworkTrail>().enableValidation = false;
|
|
trailMgr.trail.Clear();
|
|
trailMgr.positions = new Vector3[0];
|
|
trailMgr.trail.emitting = false;
|
|
transform.position = respawnPoint;
|
|
trailMgr.trail.emitting = true;
|
|
GetComponent<NetworkTrail>().enableValidation = true;
|
|
gameObject.SetActive(true);
|
|
|
|
if (isLocalPlayer)
|
|
{
|
|
SceneData.holder.deadScreen.SetActive(false);
|
|
ResetStats();
|
|
}
|
|
}
|
|
[Command]
|
|
public void CmdWonRanked()
|
|
{
|
|
WonRanked();
|
|
}
|
|
|
|
[Command]
|
|
public void CmdLostRanked()
|
|
{
|
|
LostRanked();
|
|
}
|
|
public void WonRanked()
|
|
{
|
|
if (!isServer)
|
|
{
|
|
return;
|
|
}
|
|
|
|
RpcWonRanked();
|
|
Die("server");
|
|
}
|
|
|
|
[ClientRpc]
|
|
void RpcWonRanked()
|
|
{
|
|
if (isLocalPlayer)
|
|
{
|
|
DBmanager.SetMetal(DBmanager.Metal + 500);
|
|
MinigameManager.instance.rankedSummary.ShowWin();
|
|
//Add trophies
|
|
DBmanager.SetTrophies(DBmanager.Trophies + 30);
|
|
}
|
|
}
|
|
|
|
public void LostRanked()
|
|
{
|
|
if (!isServer)
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
RpcLostRanked();
|
|
Die("server");
|
|
}
|
|
[ClientRpc]
|
|
void RpcLostRanked()
|
|
{
|
|
if (isLocalPlayer)
|
|
{
|
|
DBmanager.SetMetal(DBmanager.Metal + 250);
|
|
|
|
MinigameManager.instance.rankedSummary.ShowLoss();
|
|
// DBmanager.SetTrophies(Mathf.Clamp(DBmanager.Trophies - 15, 0, int.MaxValue));
|
|
DBmanager.SetTrophies(Mathf.Clamp(DBmanager.Trophies - DBmanager.CurrentRank.trophieLoss, 0, int.MaxValue));
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//Emojis
|
|
public void ShowEmoji(int index, Vector3 position){
|
|
if(isServer){
|
|
RpcShowEmoji(index, position);
|
|
}else{
|
|
CmdShowEmoji(index, position);
|
|
EmojiButton.instance.showEmoji(index,position);
|
|
}
|
|
}
|
|
|
|
[Command]
|
|
void CmdShowEmoji(int index, Vector3 position){
|
|
RpcShowEmoji(index,position);
|
|
}
|
|
|
|
[ClientRpc]
|
|
void RpcShowEmoji(int index, Vector3 position){
|
|
if(isLocalPlayer){ Debug.Log("ClientRPC for emoji received. I already showed it");return;}
|
|
EmojiButton.instance.showEmoji(index, position);
|
|
}
|
|
} |