private void networkSyncDroneSpawn(GameObject droneInstance)
{
if (GlobalSettings.SinglePlayer)
{
return;
}
if (Network.peerType != NetworkPeerType.Server)
{
throw new UnityException("Function may only be used by the server.");
}
//Debug.Log("Spawned and network sycned a drone:");
int id = this.guidGenerator.GenerateID();
ObjectSync objSync = droneInstance.GetComponent <ObjectSync>();
//Debug.Log(ownObjectSync.Owner == null);
objSync.AssignID(ownObjectSync.Owner, id);
objSync.Type = ObjectSyncType.Drone;
this.objectTables.AddPlayerObject(objSync.Owner, id, droneInstance);
ObjectRPC.CreateDrone(this.networkControl.ThisPlayer, id, droneInstance.transform.position, droneInstance.layer);
}
// Makes the drone shoot
void Shoot()
{
///////////////
// ROADBLOCK //
///////////////
if (target == null || target.transform == null)
{
TriggerLeave(null);
}
if (target == null || target.transform == null)
{
return;
}
bool startedShooting = false;
// In case we are in shoot radius, shoot shoot shoot.
if ((transform.position - target.transform.position).magnitude < shootRadius)
{
startedShooting = true;
if (first)
{
GetGunScript();
first = false;
}
foreach (Shooter s in gunScripts)
{
// Do not yet shoot
s.Shoot();
}
}
///
/// Network Code
///
if (Network.peerType == NetworkPeerType.Server)
{
if (startedShooting && !this.KeepShooting)
{
this.KeepShooting = true;
ObjectRPC.DroneShoot(this.objectSync.Owner, this.objectSync.GlobalID, true);
}
else if (!startedShooting && this.KeepShooting)
{
this.KeepShooting = false;
ObjectRPC.DroneShoot(this.objectSync.Owner, this.objectSync.GlobalID, false);
}
}
///
/// End Network Code
///
}
void Update()
{
//If outside, count the time
if (outside)
{
curOutsideTime += Time.deltaTime;
//Check for death
if (curOutsideTime > maxOutsideTime)
{
ObjectSync objSync = this.GetComponent <ObjectSync>();
ObjectRPC.KillObject(objSync.Owner, objSync.GlobalID);
Debug.Log("Out of boundary call.");
//healthControl.Die();
outside = false;
}
}
}
void Update()
{
if (Network.peerType == NetworkPeerType.Server || GlobalSettings.SinglePlayer)
{
if (this.waitingForRespawn)
{
this.respawnTimer -= Time.deltaTime;
if (this.respawnTimer <= 0)
{
if (!GlobalSettings.SinglePlayer)
{
ObjectRPC.RespawnObject(this.objSync.Owner, this.objSync.GlobalID);
}
this.Respawn();
}
}
}
}
protected override void SyncFunction()
{
base.SyncFunction();
if (!base.IsIDAssigned)
{
throw new UnityException("ID not assigned.");
}
if (Network.isServer)
{
Vector3 pos = this.transform.position;
Vector3 orientation = this.transform.eulerAngles;
if (pos != this.previousPos || orientation != this.previousOrientation)
{
ObjectRPC.ObjectPosition(base.Owner, base.GlobalID, pos, orientation);
this.previousPos = pos;
this.previousOrientation = orientation;
}
}
if (base.IsOwner)
{
Vector3 translation = this.objectTransformer.Translation;
Vector3 rotation = this.objectTransformer.Rotation;
if (translation != this.previousTranslation || rotation != this.previousRotation)
{
if (Network.peerType == NetworkPeerType.Server)
{
ObjectRPC.ObjectVelocityServer(base.Owner, base.GlobalID, translation, rotation);
}
else if (Network.peerType == NetworkPeerType.Client)
{
ObjectRPC.ObjectVelocityClient(base.Owner, base.GlobalID, translation, rotation);
}
this.previousTranslation = translation;
this.previousRotation = rotation;
}
}
}
private void OnPlayerConnected(NetworkPlayer networkPlayer)
{
if (!this.firstPlayerJoined)
{
ObjectRPC.LoadLevel(0);
}
else
{
ObjectRPC.LoadLevel(networkPlayer, 0);
}
Debug.Log("A new player has joined.");
Debug.Log("Current number of players: " + base.Players.Count);
foreach (Player p in base.Players.Values)
{
PlayerRPC.NewPlayerJoined(networkPlayer, p.NetworkPlayerInfo, p.ID);
}
// Generate a viewID for the new player.
NetworkViewID viewID = Network.AllocateViewID();
// Notice everyone that the new player has joined.
PlayerRPC.NewPlayerJoined(networkPlayer, viewID);
Player newPlayer = base.Players[viewID];
// Tell the new player the teams of all the other players.
foreach (Player p in base.Players.Values)
{
if (!(p.ID == base.NetworkControl.LocalViewID || p.ID == newPlayer.ID))
{
PlayerRPC.SetPlayerTeam(newPlayer.NetworkPlayerInfo, p.ID, (int)p.Team);
}
}
this.assignTeam(newPlayer);
// Sync the existing game world with the new player.
this.CurrentLevel.SyncNewPlayer(newPlayer);
}
protected override void SyncFunction()
{
base.SyncFunction();
if (Network.peerType == NetworkPeerType.Server)
{
if (this.SyncHealth)
{
//Debug.Log("Syncing health: " + this.Type);
//Debug.Log(base.Owner == null);
//Debug.Log(base.GlobalID == null);
float health = this.healthControl.CurrentHealth;
float shield = this.healthControl.CurrentShields;
ObjectRPC.SetObjectHealth(base.Owner, base.GlobalID, health, shield);
this.SyncHealth = false;
}
}
}
public virtual void TakeDamage(float hullDamage, float shieldDamage)
{
if (this.IsDead)
{
return;
}
if (Network.peerType != NetworkPeerType.Server && !GlobalSettings.SinglePlayer)
{
return;
}
currentShieldDelay = ShieldRechargeDelay;
shieldStrength = Mathf.Max(0, shieldStrength - shieldDamage);
health = Mathf.Max(0, health - hullDamage);
//Debug.Log("Taking damage! " + health + " " + shieldStrength);
this.objSync.RequestHealthSync();
if (!this.CheckIfAlive())
{
// Notify others that the object should start 'dying'.
if (!GlobalSettings.SinglePlayer)
{
if (!this.IsDead)
{
ObjectRPC.KillObject(this.objSync.Owner, this.objSync.GlobalID);
}
// Die() will be called using RPCs on both the client and server.
//if (this.objSync.IsDisposed)
// throw new UnityException("ObjectSync has already been disposed.");
}
else
{
Die();
}
}
}
public override void SyncNewPlayer(Player newPlayer)
{
base.SyncNewPlayer(newPlayer);
// Sync the objects that are not associated with any player.
ObjectTable serverTable = base.ObjectTables.GetPlayerTable(base.NetworkControl.ThisPlayer);
ICollection <GameObject> serverObjects = serverTable.GetAllObjects();
Debug.Log("Number of server objects: " + serverObjects.Count);
foreach (GameObject obj in serverObjects)
{
ObjectSync objSync = obj.GetComponent <ObjectSync>();
switch (objSync.Type)
{
case ObjectSyncType.Mothership:
ObjectRPC.CreateMothership(newPlayer.NetworkPlayerInfo, objSync.Owner, objSync.GlobalID, obj.layer);
// Temporary mothership positions.
if (obj.layer == (int)Layers.Team1Mothership)
{
ObjectRPC.ObjectPosition(objSync.Owner, objSync.GlobalID, new Vector3(1000, 0, 0), Vector3.zero);
}
else
{
ObjectRPC.ObjectPosition(objSync.Owner, objSync.GlobalID, new Vector3(-1000, 0, 0), Vector3.zero);
}
break;
case ObjectSyncType.Drone:
ObjectRPC.CreateDrone(newPlayer.NetworkPlayerInfo, objSync.Owner, objSync.GlobalID, obj.transform.position, obj.layer);
break;
case ObjectSyncType.Asteroid:
ObjectRPC.CreateAsteroid(newPlayer.NetworkPlayerInfo, objSync.Owner, objSync.GlobalID, obj.transform.position, obj.transform.localScale, obj.name);
break;
}
}
// Sync the objects that belong to other players.
foreach (Player p in base.Players.Values)
{
// Skip all objects for the server player (already synced) and the new player (empty).
if (!(p.ID == base.NetworkControl.LocalViewID || p.ID == newPlayer.ID))
{
// Sync player ships and player spawnpoints
PlayerObjects playerObjects = base.ObjectTables.PlayerObjects[p];
GameObject spawnPoint = base.GetObject(p, playerObjects.PlayerSpawnPointID);
ObjectRPC.CreatePlayerSpawnpoint(
newPlayer.NetworkPlayerInfo
, p
, playerObjects.PlayerSpawnPointID
, spawnPoint.transform.position);
GameObject playerShip = base.GetObject(p, playerObjects.PlayerShipID);
PlayerShipRPC.CreatePlayerShip(newPlayer.NetworkPlayerInfo, p, playerObjects.PlayerShipID);
//ObjectRPC.SetObjectLayer(newPlayer.NetworkPlayerInfo, p, playerObjects.PlayerShipID, (Layers)playerShip.layer);
}
}
// Create the objects for the new player.
int spawnPointID = base.GUIDGenerator.GenerateID();
int playerShipID = base.GUIDGenerator.GenerateID();
GameObject mothership = base.GetMothership(newPlayer.Team);
Vector3 spawnPointPos = mothership.transform.position + new Vector3(0, 500, 0);
// The order in which the following RPCs are sent is critical!
ObjectRPC.CreatePlayerSpawnpoint(newPlayer, spawnPointID, spawnPointPos);
PlayerShipRPC.CreatePlayerShip(newPlayer, playerShipID);
PlayerShipRPC.SpawnPlayerShip(newPlayer, spawnPointID, playerShipID);
}
public void chooseOutputFolder(D options, ObjectRPC.PayloadDelegate reply)
{
var dialog = new System.Windows.Forms.FolderBrowserDialog();
string initial = (string)options["initial"];
if (initial != null)
dialog.SelectedPath = initial;
System.Windows.Forms.DialogResult result = dialog.ShowDialog();
if (result == System.Windows.Forms.DialogResult.OK)
{
reply(new D { {"ok", true}, {"path", dialog.SelectedPath } });
}
else
{
reply(new D { {"ok", false } });
}
}
