public void Create(int id, InputsHandler ip)
{
_index = id;
Input = ip;
_facing = Facing.None;
_playerRB = GetComponent <Rigidbody2D>();
GameObject GO_temp = new GameObject("Feet");
_feet = GO_temp.transform;
_feet.SetParent(transform);
_feet.localPosition = Vector3.down * (transform.Find("Image").GetComponent <SpriteRenderer>().size.y *_p._distanceMultiplier);
Gradient trailGrad = transform.Find("Image").Find("Trail").GetComponent <TrailRenderer>().colorGradient;
GradientColorKey[] cK = trailGrad.colorKeys;
Color playerColor = (GameManager.Instance.level) ? GameManager.Instance.blackboard.GetPlayerDataWithId(id).playerColor : (Color)ColorsExtension.Red;
transform.Find("Image").GetComponent <SpriteRenderer>().color = playerColor;
transform.Find("Image").GetComponent <SpriteRenderer>().material.SetColor("_BaseColor", playerColor);
transform.Find("Image").GetComponent <SpriteRenderer>().material.SetColor("_EmissionColor", (Color)playerColor * Mathf.Pow(2f, _p._bloomBase));
cK[0].color = playerColor;
trailGrad.colorKeys = cK;
transform.Find("Image").Find("Trail").GetComponent <TrailRenderer>().colorGradient = trailGrad;
}
// Update is called once per frame
void Update()
{
Vector2 vScreenPosition = new Vector2();
if (IsInputTriggered(ref vScreenPosition))
{
RectTransform rectTransform = m_CanvasGUI.GetComponent <RectTransform>();
RectTransformUtility.ScreenPointToLocalPointInRectangle(m_CanvasGUI.transform as RectTransform, vScreenPosition, m_CanvasGUI.worldCamera, out vScreenPosition);
//
// Beware, coordinate system is x+ towards left and y+ towards up
if (null == m_currentInputHandler)
{
if (vScreenPosition.x > -rectTransform.rect.width * 0.5f &&
vScreenPosition.x < rectTransform.rect.width * 0.5f &&
vScreenPosition.y > -rectTransform.rect.height * 0.5f &&
vScreenPosition.y < rectTransform.rect.height * 0.5f)
{
//
// Retrieve height of different GUI components
float fPanelGameGUIHeight = m_PanelGameGUI.GetComponent <RectTransform>().rect.height;
float fPanelCameraInputHeight = m_PanelCameraInputs.GetComponent <RectTransform>().rect.height;
//
// GameGUI first
if (vScreenPosition.y < -rectTransform.rect.height * 0.5f + fPanelGameGUIHeight)
{
m_currentInputHandler = m_GameGUIInputsHandler;
}
// Camera inputs
else if (vScreenPosition.y < -rectTransform.rect.height * 0.5f + fPanelCameraInputHeight)
{
m_currentInputHandler = m_CameraInputsHandler;
}
else // GameCanvas inputs
{
m_currentInputHandler = m_CanvasGameInputsHandler;
}
}
}
if (null != m_currentInputHandler)
{
m_currentInputHandler.HandleInputs(vScreenPosition);
}
}
else if (null != m_currentInputHandler)
{
m_currentInputHandler.InputsStopped();
m_currentInputHandler = null;
}
}
public void Setup(Player.Types type, Genome model = null)
{
if (type.Equals(Player.Types.AI))
{
Assert.IsNotNull(model, "AI model cannot be null for this type of vehicle control.");
ann = new ANN(model);
inputsHandler = GetInputsFromANN;
sensor = GetComponent <RaySensor3D>();
sensor.AutoSetup(model.InputNodeNumber, 60f);
sensor.SetDrawLines(true);
}
else
{
inputsHandler = GetInputsFromKB;
}
}
// Start is called before the first frame update
void Start()
{
m_currentInputHandler = null;
Debug.Assert(null != m_PanelCameraInputs);
Debug.Assert(null != m_CameraInputsHandler);
Debug.Assert(null != m_CanvasGameInputsHandler);
Debug.Assert(null != m_CanvasGUI);
Debug.Assert(null != m_CanvasGame);
//
// Setup input handlers
m_CanvasGameInputsHandler.SetGamePlaySelection(m_GamePlaySelection);
m_CanvasGameInputsHandler.SetCanvasGame(m_CanvasGame);
m_CanvasGameInputsHandler.SetCanvasGUI(m_CanvasGUI);
m_CanvasGameInputsHandler.SetCameraInputsHandler(m_CameraInputsHandler);
m_CanvasGameInputsHandler.SetImageCameraGame(m_ImageCameraGame);
m_CameraInputsHandler.SetCameraGame(m_CameraGame);
m_CameraInputsHandler.SetCanvasGUI(m_CanvasGUI);
m_CameraInputsHandler.SetGameGrid(m_GameGrid);
m_CameraInputsHandler.SetCanvasGUIPanelCameraInputs(m_PanelCameraInputs);
m_CameraInputsHandler.SetCanvasGUIPanelGUI(m_PanelGUI);
}
public IEnumerator LevelUpdate()
{
while (GameManager.Instance.CurrentState() == StateType.PRACTICE || GameManager.Instance.CurrentState() == StateType.ENDPRACTICE)
{
switch (State)
{
case LevelState.FIRSTLOAD:
{
for (int i = 0; i < GameManager.Instance.blackboard.players; i++)
{
InputsHandler ih = default;
if (i == 0)
{
ih = PlayerInput.Instantiate(_PrefabInputPlayer, controlScheme: "WASD", pairWithDevice: Keyboard.current).transform.GetComponent <InputsHandler>();
}
else if (i == 1)
{
ih = PlayerInput.Instantiate(_PrefabInputPlayer, controlScheme: "Arrows", pairWithDevice: Keyboard.current).transform.GetComponent <InputsHandler>();
}
_Inputs.Add(ih);
}
State = LevelState.LOADINGDATA;
break;
}
case LevelState.LOADINGDATA:
{
Blocks = new List <BlockController>();
_Terrain = Instantiate(_PrefabTerrain);
CurrentData = _Terrain.GetComponent <LevelData>();
_MatBlock.SetColor("_BaseColor", Color.black);
_MatBeat.SetColor("_EmissionColor", CurrentData._ScenaryColor);
if (_Terrain.transform.Find("Blocks"))
{
Blocks.AddRange(_Terrain.transform.Find("Blocks").GetComponentsInChildren <BlockController>());
Blocks.Shuffle();
}
_Bullets = new GameObject("Bullets");
GameManager.Instance.blackboard.BulletContainer = _Bullets.transform;
_Players = new List <GameObject>();
_playerInputManager = GetComponent <PlayerInputManager>();
_PlayerSpawner = _Terrain.GetComponentsInChildren <PlayerSpawner>();
_BotSpawners = _Terrain.GetComponentsInChildren <BotSpawner>();
State = LevelState.UPDATINGBACKGROUND;
break;
}
case LevelState.UPDATINGBACKGROUND:
{
Gradient meshCurrentGradient = _Background.GetComponent <MeshGenerator>()._lineGradient;
GradientColorKey[] bgck = CurrentData._BackgroundGradient.colorKeys;
int nextNumKeys = bgck.Length;
GradientColorKey[] gck = new GradientColorKey[nextNumKeys];
GradientAlphaKey[] gak = meshCurrentGradient.alphaKeys;
FindObjectsOfType <AudioPeer>()[0].SetMatColor(CurrentData._BarsMainColor, CurrentData._BarsSecondColor);
for (int i = 0; i < nextNumKeys; i++)
{
gck[i] = new GradientColorKey(meshCurrentGradient.Evaluate(bgck[i].time), bgck[i].time);
yield return(null);
}
meshCurrentGradient.SetKeys(gck, gak);
while (gck[0].color != bgck[0].color)
{
for (int i = 0; i < nextNumKeys; i++)
{
Color mcg = gck[i].color;
mcg = Color.Lerp(mcg, bgck[i].color, Time.deltaTime * 35f);
gck[i] = new GradientColorKey(mcg, gck[i].time);
yield return(null);
}
meshCurrentGradient.SetKeys(gck, gak);
_Background.GetComponent <MeshGenerator>().SetGradient(meshCurrentGradient);
yield return(new WaitForSeconds(secondsBetweenBlock * 0.5f));
}
_Background.GetComponent <MeshGenerator>().SetGradient(CurrentData._BackgroundGradient);
State = LevelState.LOADINGLEVEL;
break;
}
case LevelState.LOADINGLEVEL:
{
foreach (BlockController bc in Blocks)
{
bc.Move();
yield return(new WaitForSeconds(secondsBetweenBlock));
}
while (Blocks[Blocks.Count - 1].HasToMove || Blocks[Blocks.Count - 1].IsOut)
{
yield return(null);
}
State = LevelState.LOADINGPLAYERS;
break;
}
case LevelState.LOADINGPLAYERS:
{
Color tempColor = Color.black;
while (tempColor != CurrentData._ScenaryColor)
{
tempColor = Color.Lerp(tempColor, CurrentData._ScenaryColor, Time.deltaTime * 10f);
_MatBeat.SetColor("_EmissionColor", tempColor * Mathf.Pow(2f, AudioPeer._AmplitudeBuffer));
yield return(null);
}
int startPlayerSpawner = Random.Range(0, _PlayerSpawner.Length - 1);
GameObject go = Instantiate(_PrefabPlayer);
go.transform.position = _PlayerSpawner[startPlayerSpawner].GetPosition();
PlayerController pc = go.GetComponent <PlayerController>();
pc.Create(0, _Inputs[0]);
_Players.Add(go);
State = LevelState.PLAYING;
break;
}
case LevelState.PLAYING:
{
_MatBeat.SetColor("_EmissionColor", CurrentData._ScenaryColor * Mathf.Pow(2f, AudioPeer._AmplitudeBuffer));
foreach (GameObject pl in _Players)
{
if (pl.GetComponent <PlayerController>())
{
PlayerController pc = pl.GetComponent <PlayerController>();
if (pc.IsDead)
{
_Players.Remove(pl);
Destroy(pl);
_UI.RemPoint(0);
Reset = true;
break;
}
}
yield return(null);
}
if (Reset)
{
Reset = false;
State = LevelState.LOADINGPLAYERS;
}
break;
}
case LevelState.REMOVINGLEVEL:
{
foreach (GameObject go in _Players)
{
go.SetActive(false);
}
for (int i = 0; i < Blocks.Count; i++)
{
Blocks[i].Move();
yield return(new WaitForSeconds(secondsBetweenBlock));
}
while (Blocks[Blocks.Count - 1].transform.position.y > -3f)
{
yield return(null);
}
State = LevelState.RESETINGLEVEL;
break;
}
case LevelState.RESETINGLEVEL:
{
foreach (GameObject go in _Players)
{
Destroy(go);
}
if (_Terrain)
{
Destroy(_Terrain);
}
if (_Bullets)
{
Destroy(_Bullets);
}
Blocks.Clear();
State = LevelState.SEEDING;
break;
}
case LevelState.ENDGAME:
{
while (GameManager.Instance.TimeScale > SlowmoMinScale)
{
GameManager.Instance.TimeScale -= Time.deltaTime * SlowmoMultiplier;
yield return(null);
}
GameManager.Instance.TimeScale = SlowmoMinScale;
Material winnerBg = _UIEnd.transform.Find("Background").GetComponent <UnityEngine.UI.Image>().material;
float blurVal = 0;
winnerBg.SetFloat("_BlurValue", blurVal);
_UIEnd.transform.Find("Background").gameObject.SetActive(true);
while (winnerBg.GetFloat("_BlurValue") < 0.002f)
{
blurVal += Time.deltaTime * 0.025f;
winnerBg.SetFloat("_BlurValue", blurVal);
yield return(null);
}
winnerBg.SetFloat("_BlurValue", 0.002f);
string playerWinner = "YOU GOT " + GameManager.Instance.blackboard.Player1Score + " POINT/S\n IN " + GameManager.Instance.blackboard.timerPractice + " SECONDS";
_UIEnd.transform.Find("Winner").GetComponent <UnityEngine.UI.Text>().text = playerWinner;
_UIEnd.transform.Find("Winner").gameObject.SetActive(true);
yield return(new WaitForSeconds(2.5f * SlowmoMinScale));
while (!Input.anyKey)
{
yield return(null);
}
GameManager.Instance.CurrentState(StateType.MENU);
break;
}
case LevelState.WAITING:
{
break;
}
}
yield return(null);
}
yield return(null);
}
public PlayerData(InputDevice id, PlayerInput pi)
{
inputDevice = id;
playerInput = pi;
inputsHandler = pi.GetComponent <InputsHandler>();
}
