public void SetObstacleDifficutly(string state)
{
switch (state)
{
case "easy":
Current_Obstacle_Difficulty = OBSTACLEDIFF_EASY;
break;
case "medium":
Current_Obstacle_Difficulty = OBSTACLEDIFF_MEDIUM;
break;
case "hard":
Current_Obstacle_Difficulty = OBSTACLEDIFF_HARD;
break;
case "off":
default:
Current_Obstacle_Difficulty = OBSTACLEDIFF_OFF;
break;
}
Debug.Log("Obstacle difficulty set to: " + state);
ExecuteOnMainThread.AddAction(() => { roomMover.SpawnObstacles(); });
}
public void ToggleCogCursor(bool state)
{
Display_COG_Cursor = state;
ExecuteOnMainThread.AddAction(() => { image_cogCursor.gameObject.SetActive(Display_COG_Cursor); });
Debug.Log("Display cog cursor set to: " + Display_COG_Cursor);
}
public void Start()
{
Debug.Log("Starting server");
handlers = new Dictionary <Type, ServerNetworkEventHandler>()
{
{ typeof(BoostUseEvent), FindObjectOfType <BoostUseHandler>() },
{ typeof(BulletSpawnEvent), FindObjectOfType <BulletSpawnHandler>() },
{ typeof(GameStartEvent), FindObjectOfType <GameStartHandler>() },
{ typeof(PlayerDisconnectEvent), FindObjectOfType <PlayerDisconnectHandler>() },
{ typeof(PlayerLoadEvent), FindObjectOfType <PlayerLoadHandler>() },
{ typeof(PlayerPositionEvent), FindObjectOfType <PlayerPositionHandler>() },
{ typeof(PongEvent), FindObjectOfType <PongHandler>() },
{ typeof(RoomJoinEvent), FindObjectOfType <RoomJoinHandler>() },
};
for (int i = 0; i < 4; i++)
{
NetworkData player = new NetworkData();
var spawners = GameObject.FindGameObjectsWithTag("Spawner");
var p = Instantiate(playerPrefab);
p.transform.position = spawners[i].transform.position;
var np = p.GetComponent <NetworkPlayer>();
player.NetworkID = i;
player.player = np;
clientList.Add(player);
}
_ExecuteOnMainThread = GameObject.FindGameObjectWithTag("MainThread").GetComponent <ExecuteOnMainThread>();
_server = new UdpClient(25575);
new Thread(ServerThread).Start();
}
private void ToggleTargetArea(bool state)
{
Display_TargetArea = state;
ExecuteOnMainThread.AddAction(() => { image_targetArea.gameObject.SetActive(Display_TargetArea); });
Debug.Log("Display target area set to: " + Display_TargetArea);
}
public void Start()
{
Debug.Log("Starting client");
handlers = new Dictionary <Type, ClientNetworkEventHandler>()
{
{ typeof(BoostEndEvent), FindObjectOfType <BoostEndHandler>() },
{ typeof(BoostSpawnEvent), FindObjectOfType <BoostSpawnHandler>() },
{ typeof(BoostUsedEvent), FindObjectOfType <BoostUsedHandler>() },
{ typeof(BulletSpawnedEvent), FindObjectOfType <BulletSpawnedHandler>() },
{ typeof(GameStartedEvent), FindObjectOfType <GameStartedHandler>() },
{ typeof(PingEvent), FindObjectOfType <PingHandler>() },
{ typeof(PlayerDamageEvent), FindObjectOfType <PlayerDamageHandler>() },
{ typeof(PlayerDeathEvent), FindObjectOfType <PlayerDeathHandler>() },
{ typeof(PlayerDisconnectedEvent), FindObjectOfType <PlayerDisconnectedHandler>() },
{ typeof(PlayerLoadedEvent), FindObjectOfType <PlayerLoadedHandler>() },
{ typeof(PlayerPositionedEvent), FindObjectOfType <PlayerPositionedHandler>() },
{ typeof(RoomJoinedEvent), FindObjectOfType <RoomJoinedHandler>() },
{ typeof(RoomPlayerJoinedEvent), FindObjectOfType <RoomPlayerJoinedHandler>() },
};
_udp = new UdpClient();
_ExecuteOnMainThread = GameObject.FindGameObjectWithTag("MainThread").GetComponent <ExecuteOnMainThread>();
DontDestroyOnLoad(this);
}
public void ToggleInvisibleComplianceMode(string state)
{
InvisibleComplianceMode = (state.ToLower() == "on");
ExecuteOnMainThread.AddAction(() => {
image_targetArea.GetComponent <SpriteRenderer>().enabled = InvisibleComplianceMode;
image_cogCursor.GetComponent <SpriteRenderer>().enabled = InvisibleComplianceMode;
});
Debug.Log("invisible compliance mode set to " + InvisibleComplianceMode);
}
private void Awake()
{
if (singleton != null && singleton != this)
{
Destroy(this.gameObject);
}
singleton = this;
DontDestroyOnLoad(this.gameObject);
executeOnMainTHread = GetComponent <ExecuteOnMainThread>();
}
void LoadFromStream(StreamReader reader)
{
// Create OBJ reader
ObjReader objReader = new ObjReader();
Vector3 [][] polylines = objReader.GetPolylinesFromStreamReader(reader);
// Make sure to lock to avoid multithreading problems
lock (_enque) {
// Run the generation of polylines in the Main Thread
ExecuteOnMainThread.Enqueue(() => { StartCoroutine(AfterLoading()); });
ExecuteOnMainThread.Enqueue(() => { StartCoroutine(Generate(polylines)); });
};
}
void LoadFromFile()
{
// Create OBJ reader
try {
ObjReader objReader = new ObjReader();
Vector3 [][] polylines = objReader.GetPolylinesFromFilePath(path);
// Make sure to lock to avoid multithreading problems
lock (_enque) {
// Run the generation of polylines in the Main Thread
ExecuteOnMainThread.Enqueue(() => { StartCoroutine(AfterLoading()); });
ExecuteOnMainThread.Enqueue(() => { StartCoroutine(Generate(polylines)); });
};
}
catch (Exception e) {
Debug.Log(e);
OnError();
}
}
private void UpdateProtocolData(ProtocolData d)
{
if (d.TestRunning != isRunning)
{
ExecuteOnMainThread.AddAction(() => { StartStopTest(d.TestRunning); });
}
float x = d.COGX * Current_Movement_Gain;
float y = -d.COGY * Current_Movement_Gain;
if (Math.Abs(x) < 0.003)
{
x = 0;
}
if (Math.Abs(y) < 0.003)
{
y = 0;
}
ExecuteOnMainThread.AddAction(() => { HandleBPCursor(x, y); });
if (swayAngleCount >= swayAngleCountNeeded)
{
float newSwayAngle = d.SwayAngle - swayAngleOffset;
if (newSwayAngle != currentSwayAngle)
{
currentSwayAngle = newSwayAngle;
ExecuteOnMainThread.AddAction(() => { SwayAngleChanged(); });
}
}
else
{
swayAngleSum += d.SwayAngle;
++swayAngleCount;
if (swayAngleCount == swayAngleCountNeeded)
{
swayAngleOffset = swayAngleSum / (float)swayAngleCountNeeded;
}
}
}
// Update is called once per frame
void Update()
{
ExecuteOnMainThread.ProcessActions();
#region Keyboard Inputs
//quit
if (Input.GetKeyDown(KeyCode.Escape))
{
Application.Quit();
}
//level 3 toggle invisible compliance mode
if (Input.GetKeyDown(KeyCode.V))
{
ToggleInvisibleComplianceMode(InvisibleComplianceMode ? "off" : "on");
}
//reset compliance
if (Input.GetKeyDown(KeyCode.R))
{
TargetArea.Reset();
ObstaclesHit = 0;
}
#endregion
if (isRunning)
{
roomMover.Move();
}
//for now...
//update compliance
float comp = (TargetArea.counter / TargetArea.TimeSinceReset) * 100;
text_compliance.text = "CoG: " + comp.ToString("00") + "%\nObst: " + ObstaclesHit;
}
// Start is called before the first frame update
void Start()
{
_executeOnMainThread = GameObject.FindWithTag("MainThread").GetComponent <ExecuteOnMainThread>();
}
public override void OnJSONEvent(JObject json)
{
base.OnJSONEvent(json);
// Debug.Log("message : " + json);
var message = json["message"].ToString();
#region acknowledge
if (message.Equals("acknowledged"))
{
Verify(json["packageId"].ToObject <int>(), json["scheduleId"].ToObject <int>());
}
#endregion
#region unit-arrival
else if (message.Equals("unit-arrival"))
{
ScheduleAt("unit-arrival", json["scheduleId"].ToObject <long>(), json["packageId"].ToObject <int>(), () =>
{
var uid = json["uid"].ToObject <int>();
Registry.Ships[uid].GetComponent <PlayMakerFSM>().SendEvent("Arrive");
});
}
#endregion
#region move-unit
else if (message.Equals("move-unit"))
{
var target = Registry.Islands[json["target"].ToObject <int>()];
foreach (var shipUid in json["ships"].Select(shipId => shipId.ToObject <int>()))
{
var uid = shipUid;
ScheduleAt("move-unit", json["scheduleId"].ToObject <long>(), json["packageId"].ToObject <int>(), () =>
{
// 1) add move component to ship
var move = Registry.Ships[uid].AddComponent <MoveToTargetMp>();
// 2) change speed
move.Velocity = 150f;
// 3) set move destination
move.Target = target;
Debug.Log("move " + uid + " to " + target.GetComponent <IslandData>().Uid);
});
}
}
#endregion
#region spawn-units
else if (message.Equals("spawn-unit"))
{
foreach (var spawn in json["spawns"])
{
var ship = (JObject)spawn;
Debug.Log("spawn units scheduled at: " + json["scheduleId"]);
ScheduleAt("spawn-unit", json["scheduleId"].ToObject <long>(), json["packageId"].ToObject <int>(), () =>
{
var shipUid = ship["uid"].ToObject <int>();
var island = Registry.Islands[ship["island_uid"].ToObject <int>()];
var islandData = island.GetComponent <IslandData>();
// 1) create ship by type
var go = GameObjectFactory.CreateShip(shipUid, islandData.ShipType, islandData.PlayerData.playerType);
// 2) append ship at island
go.transform.Translate(island.transform.position);
go.transform.parent = island.transform;
go.transform.localScale = new Vector3(1f, 1f, 1f);
// 3) set ship data
var shipData = go.AddComponent <ShipData>();
shipData.shipType = islandData.ShipType;
shipData.uid = shipUid;
shipData.PlayerData = islandData.PlayerData;
// 4) colorize @see http://answers.unity3d.com/questions/483419/changing-color-of-children-of-instantiated-prefab.html
//go.GetComponentInChildren<Renderer>().material.color = island.renderer.material.color;
// 5) life data
var lifeData = go.AddComponent <LifeData>();
lifeData.CurrentHp = lifeData.MaxHp = 10;
// 6) host fires attacks
if (IsHost())
{
go.AddComponent <Assault>();
shipData.AttackDamage = 2;
shipData.AttackSpeed = 1000;
go.AddComponent <Defence>();
}
// 7) re-enable spawning
island.GetComponentInChildren <SpawnUnitsMp>().ResetSpawnTimer();
// Debug.Log("spawn [uid=" + shipUid + "|type=" + shipData.shipType + "] at [uid=" + islandData.Uid + "|type=" + islandData.IslandType + "] for player [" + shipData.PlayerData.uid + "]");
});
}
}
#endregion
#region game-data
else if (message.Equals("game-data"))
{
var gameData = json["game-data"];
var playerDatas = gameData["players"];
HostUid = gameData["host-uid"].ToString();
Debug.Log("Player " + HostUid + " is host.");
foreach (var playerDataRaw in playerDatas)
{
var raw = (JObject)playerDataRaw;
ExecuteOnMainThread.Enqueue(() =>
{
var player = GameObjectFactory.CreatePlayer(raw["uid"].ToString());
var playerData = player.GetComponent <PlayerData>();
playerData.playerType = PlayerData.GetPlayerType(raw["type"].ToString());
var islands = raw["islands"];
foreach (var data in islands)
{
var island = (JObject)data;
var islandUid = island["uid"].ToObject <int>();
var islandType = island["type"].ToObject <int>();
var islandMaxSpawn = island["max-spawn"].ToObject <int>();
// 1) create island by type
var go = GameObjectFactory.CreateIsland(islandUid, islandType);
// 2) set island transformation
var position = island["position"]; // island position
go.transform.position = new Vector3(position[0].ToObject <float>(), position[1].ToObject <float>(), position[2].ToObject <float>());
go.transform.localScale = new Vector3(Scale, Scale, Scale);
// 3) colorize
go.renderer.material.color = World.GetNextPlayerColor();
// 4) add meta data
var islandData = go.GetComponent <IslandData>();
// 4.1) set uid
islandData.Uid = islandUid;
// 4.2) island type
islandData.IslandType = islandType;
// 4.3) set ownership
islandData.PlayerData = playerData;
// Debug.Log(islandData.gameObject.name + " belongs to " + islandData.PlayerData.uid);
islandData.MaxSpawn = islandMaxSpawn;
// 4.4) life data
go.AddComponent <LifeData>();
// 4.5) set spawning ship types
islandData.ShipType = island["ship-type"].ToObject <int>();
// 4.6) host handles spawnings
if (IsHost())
{
var spawnunits = go.transform.GetComponentInChildren <SpawnUnitsMp>();
spawnunits.Island = islandData;
islandData.SpawnRate = 3f;
spawnunits.enabled = true;
}
// 4.7) set prototype ship
}
});
}
// when done, send client-game-ready command
ExecuteOnMainThread.Enqueue(() => SocketHandler.Emit("client-game-ready", PackageFactory.CreateClientGameReadyMessage()));
}
#endregion
#region authentification
else if (message.Equals("Welcome!"))
{
ClientUid = json["uid"].ToString();
SocketHandler.Emit("message", PackageFactory.CreateJoinQueueMessage(ClientUid));
// create
SocketHandler.Emit("join-game", PackageFactory.CreateGameTypeGameMessage("join-game", "game1vs1"));
// join
// SocketHandler.SharedConnection.Emit("create-game", PackageFactory.CreateGameTypeGameMessage("create-game", "game1vs1"));
}
#endregion
#region handled somewhere else
else if (message.Equals("latency"))
{
// handled in networkview
}
else if (message.Equals("ping"))
{
// handled in networkview
}
#endregion
else
{
// todo more events
Debug.Log("Unhandled Message: " + json);
}
}
// Do something if error
protected override void OnError()
{
ExecuteOnMainThread.Enqueue(() => { StartCoroutine(ErrorMessage()); });
}
