//-------------------------------------------------------------------
void ReadyCountChanged(VirtualNetworkController ctrl)
{
if (null != ConnectionReadyText)
{
ConnectionReadyText.text = "Ready: " + HopperNetwork.GetReadyCount();
}
}
//---------------------------------------------------------------------
void UpdateKnib(Vector2 pos)
{
Vector2 localPos;
if (!RectTransformUtility.ScreenPointToLocalPointInRectangle((RectTransform)transform, pos, Camera.main, out localPos))
{
return;
}
Vector2 offset = localPos - new Vector2(Origin.transform.localPosition.x, Origin.transform.localPosition.y);
float length = offset.magnitude;
Vector2 dir = Vector2.zero;
if (length > .1f)
{
dir = offset / length;
length = Mathf.Clamp(length, 0.0f, MaxRadius);
offset = dir * length;
}
Knib.transform.localPosition = Origin.localPosition + new Vector3(offset.x, offset.y, 0.0f);
VirtualNetworkController controller = HopperNetwork.GetMyController();
if (controller != null)
{
Vector2 movement = dir * (length / MaxRadius);
UpdateMovementKnib(movement);
controller.SetMovement(movement);
}
}
//---------------------------------------------------------------------
void ProcessTouch(Touch touch)
{
if (ActiveFingerID == touch.fingerId)
{
if ((touch.phase == TouchPhase.Ended) || (touch.phase == TouchPhase.Canceled))
{
ActiveFingerID = -1;
VirtualNetworkController controller = HopperNetwork.GetMyController();
if (controller != null)
{
controller.SetMovement(Vector2.zero);
}
Knib.transform.localPosition = Origin.transform.localPosition;
}
else if (touch.phase == TouchPhase.Moved)
{
UpdateKnib(touch.position);
}
return;
}
if (touch.phase == TouchPhase.Began)
{
if ((ActiveFingerID == -1) && InMoveArea(touch.position))
{
// Okay, starting a touch;
ActiveFingerID = touch.fingerId;
UpdateKnib(touch.position);
}
else if (InActionArea(touch.position))
{
UpdateAction(touch);
}
}
}
//----------------------------------------------------------------------
public void SetMovement(Vector2 v)
{
Movement = v;
if (HopperNetwork.IsClient())
{
CmdMovement(v);
}
}
//----------------------------------------------------------------------
public void DoAction()
{
++ActionCount;
if (HopperNetwork.IsClient())
{
CmdAction();
}
}
//----------------------------------------------------------------------
public void SetReady(bool ready)
{
SetReadyInternal(ready);
if (HopperNetwork.IsClient())
{
CmdSetReady(ready);
}
}
//---------------------------------------------------------------------
void UpdateAction(Touch touch)
{
VirtualNetworkController controller = HopperNetwork.GetMyController();
if (controller != null)
{
DoAction();
}
}
//-------------------------------------------------------------------------------------------------
// Unity
//-------------------------------------------------------------------------------------------------
private void Start()
{
m_rigidbody = GetComponent <Rigidbody2D>();
m_animator = m_visualReference.GetComponent <Animator>();
m_attackAreaCollider = m_attackAreaReference.GetComponent <CircleCollider2D>();
m_attackAreaFilter = new ContactFilter2D();
m_attackAreaFilter.NoFilter();
int count = HopperNetwork.GetPlayerCount();
m_gameDigestSpeed = m_foodDigestSpeed + (float)count * m_foodDigestSpeedPerBunny;
}
//-------------------------------------------------------------------
public void UpdateDiscovery()
{
var state = HopperNetwork.GetState();
if (state == HopperNetwork.eState.CLIENT_READY)
{
Controller = HopperNetwork.GetMyController();
SetState(eClientState.LOBBY);
}
else if (!HopperNetwork.Instance.isNetworkActive)
{
JoinUI.SetActive(true);
}
}
//------------------------------------------------------
public void Discover()
{
Initialize();
FoundAddress = false;
if (HopperNetwork.IsHost())
{
Debug.Log("Broadcast as Server");
StartAsServer();
}
else
{
StartAsClient();
}
}
// Update is called once per frame
void Update()
{
if (NetworkManager.singleton.isNetworkActive)
{
AddressText.gameObject.SetActive(true);
AddressText.text = HopperNetwork.Instance.networkAddress + ":" + HopperNetwork.Instance.networkPort;
}
else
{
AddressText.gameObject.SetActive(false);
}
HopperNetwork.eState state = HopperNetwork.GetState();
switch (state)
{
case HopperNetwork.eState.DISCONNECTED:
StatusText.text = "DISCONNECTED";
break;
case HopperNetwork.eState.CLIENT_JOINED:
StatusText.text = "JOINING: " + HopperNetwork.Instance.networkAddress;
break;
case HopperNetwork.eState.CLIENT_LOOKING:
StatusText.text = "SEARCHING...";
break;
case HopperNetwork.eState.CLIENT_READY:
VirtualNetworkController me = HopperNetwork.GetMyController();
if (me.ClientIsReady)
{
StatusText.text = "READY";
}
else
{
StatusText.text = "NOT READY";
}
break;
default:
StatusText.text = "UNKNOWN: " + state;
break;
}
}
//-------------------------------------------------------------------
public void UpdateInGame()
{
VirtualNetworkController controller = HopperNetwork.GetMyController();
if (!controller.IsInGame())
{
SetState(eClientState.LOBBY);
return;
}
if (controller.IsWolf)
{
ActionImage.sprite = WolfAction;
}
else
{
ActionImage.sprite = BunnyAction;
}
}
//-------------------------------------------------------------------
public static eState GetState()
{
HopperNetwork net = (HopperNetwork)NetworkManager.singleton;
if (!net.isNetworkActive)
{
if (net.Discovery.IsRunning())
{
return(eState.CLIENT_LOOKING);
}
else
{
return(eState.DISCONNECTED);
}
}
if (IsHost())
{
return(eState.HOSTING);
}
NetworkConnection conn = GetMyConnection();
if (conn == null)
{
return(eState.CLIENT_LOOKING);
}
else
{
if (conn.playerControllers.Count > 0)
{
return(eState.CLIENT_READY);
}
else
{
return(eState.CLIENT_JOINED);
}
}
}
//---------------------------------------------------------------------
void DoAction()
{
ActionAnimator.SetTrigger("DoAction");
VirtualNetworkController controller = HopperNetwork.GetMyController();
if (controller != null)
{
controller.DoAction();
if (controller.IsInGame())
{
if (controller.IsWolf)
{
AudioManager.Play(eSoundType.FOX_BITE);
}
else
{
AudioManager.Play(eSoundType.BUNNY_LAUGH);
}
}
}
}
//-------------------------------------------------------------------------------------------------
private void RemovePlayer(VirtualNetworkController controller)
{
//Find controller if it was a prey
GameObject[] preys = GameObject.FindGameObjectsWithTag(TAG_PREY);
for (int preyIndex = 0; preyIndex < preys.Length; ++preyIndex)
{
PreyController prey = preys[preyIndex].GetComponent <PreyController>();
if (prey != null)
{
if (prey.m_netController == controller)
{
// C4 - ghosts were multiplying really fast
GameObject.Destroy(prey.gameObject);
}
}
if (m_firstGame && (HopperNetwork.GetPlayerCount() == 0))
{
m_UIJoin.SetActive(true);
m_UIInstructions.SetActive(false);
}
}
//Find controller if it was a predator
GameObject[] predators = GameObject.FindGameObjectsWithTag(TAG_PREDATOR);
for (int predatorIndex = 0; predatorIndex < predators.Length; ++predatorIndex)
{
PredatorController predator = predators[predatorIndex].GetComponent <PredatorController>();
if (predator != null)
{
if (predator.m_netController == controller)
{
Destroy(predator);
return;
}
}
}
}
// Update is called once per frame
void Update()
{
if (NetworkManager.singleton == null)
{
SetStateText(false, false);
}
else
{
NetworkManager mgr = NetworkManager.singleton;
bool isActive = mgr.isNetworkActive;
bool isServer = HopperNetwork.IsHost();
SetStateText(isActive, isServer);
SetHostText(mgr.networkAddress.ToString(), mgr.networkPort);
SetBroadcasting(Discoverer.isServer || Discoverer.isClient);
}
if (Discoverer.FoundAddress)
{
Discoverer.Stop();
NetworkManager.singleton.StartClient();
}
}
//-------------------------------------------------------------------
public void UpdateDebugText()
{
if (DebugText == null)
{
return;
}
DebugText.gameObject.SetActive(true);
VirtualNetworkController controller = HopperNetwork.GetMyController();
if (controller == null)
{
DebugText.text = "No Controller";
return;
}
string str = "";
str += "Ready: " + (controller.ClientIsReady ? "Y" : "N") + "\n";
str += "Game: " + (controller.IsInGame() ? "Y" : "N") + "\n";
str += "Wolf: " + (controller.IsWolf ? "Y" : "N") + "\n";
DebugText.text = str;
}
//-------------------------------------------------------------------
public void UpdateLobby()
{
// this state, just wait around until server tells us to move on
VirtualNetworkController control = HopperNetwork.GetMyController();
if (control.ConsumeAllActions())
{
ToggleReady();
}
if (Controller.IsInGame())
{
SetState(eClientState.IN_GAME);
}
if (Controller.ClientIsReady)
{
ActionImage.sprite = ReadyBunny;
}
else
{
ActionImage.sprite = SleepyBunny;
}
}
//---------------------------------------------------------------------
// Update is called once per frame
void Update()
{
if ((Application.platform == RuntimePlatform.WindowsEditor) || (Application.platform == RuntimePlatform.WindowsEditor))
{
VirtualNetworkController controller = HopperNetwork.GetMyController();
if (controller != null)
{
float x = Input.GetAxis("Horizontal");
float y = Input.GetAxis("Vertical");
bool action = Input.GetButtonDown("Fire1");
Vector2 move = new Vector2(x, y);
if (move.sqrMagnitude > 1.0f)
{
move.Normalize();
}
UpdateMovementKnib(move);
controller.SetMovement(move);
if (action)
{
DoAction();
}
}
}
if (!Input.touchSupported)
{
// fake touch
if (Input.GetMouseButton(0) && (!HackActionDown || (ActiveFingerID >= 0)))
{
HackActionDown = true;
Touch touch = new Touch();
touch.fingerId = 1;
if (ActiveFingerID == -1)
{
touch.phase = TouchPhase.Began;
}
else
{
touch.phase = TouchPhase.Moved;
}
touch.position = Input.mousePosition;
ProcessTouch(touch);
}
else if (HackActionDown && !Input.GetMouseButton(0))
{
Touch touch = new Touch();
touch.phase = TouchPhase.Ended;
touch.fingerId = ActiveFingerID;
touch.position = Input.mousePosition;
ProcessTouch(touch);
HackActionDown = false;
}
}
if (Input.touches.Length > 0)
{
for (int i = 0; i < Input.touches.Length; ++i)
{
ProcessTouch(Input.touches[i]);
}
}
}
//-------------------------------------------------------------------------------------------------
private void UpdateState(eGameState state)
{
if (state == eGameState.WAIT_FOR_READY)
{
bool isReady = HopperNetwork.IsEveryoneReady();
bool isEnoughPlayers = HopperNetwork.GetPlayerCount() >= 3;
m_UIReadyUp.SetActive(false);
m_UIPlayersRequired.SetActive(false);
if (isReady && isEnoughPlayers)
{
HopperNetwork.StartGame();
TransformRandomPrey();
ChangeState(eGameState.IN_GAME);
int count = HopperNetwork.GetPlayerCount();
m_gameDuration = m_gameDurationBase + m_gameDurationAdditionalPerRabbit * (count - 1);
m_UIInstructions.SetActive(false);
m_firstGame = false;
}
else
{
if (m_currentState == eGameState.WAIT_FOR_READY)
{
if (HopperNetwork.GetPlayerCount() < 3)
{
m_UIPlayersRequired.SetActive(true);
}
else
{
m_UIReadyUp.SetActive(true);
}
}
}
}
else if (state == eGameState.IN_GAME)
{
m_gameTimer += Time.deltaTime;
int preyCount = GetHumanPreyAliveCount();
//No players left wolf wins
if (preyCount == 0)
{
m_preyWins = false;
ChangeState(eGameState.GAME_OVER);
}
//Times up, bunnies win
if (m_gameTimer >= m_gameDuration)
{
m_preyWins = true;
ChangeState(eGameState.GAME_OVER);
}
}
else if (state == eGameState.GAME_OVER)
{
m_gameOverTimer += Time.deltaTime;
//Game over time expires
if (m_gameOverTimer >= m_gameOverDuration)
{
HopperNetwork.EndGame();
ReviveAndTransformBack();
ChangeState(eGameState.WAIT_FOR_READY);
}
}
}
