public void UseWithJoystick()
{
if (CanUseAbility)
{
if (_tpBack == null)
{
var instantiatedItem = BoltNetwork.Instantiate(_tPBackSettings.Prefab);
var throwable = instantiatedItem.GetComponent <Throwable>();
_tpBack = instantiatedItem.GetComponent <TPBackBehaviour>();
_tpBack.Kart = transform.root;
if (_throwingDirection.CurrentDirection == Direction.Default)
{
_throwableLauncher.Throw(throwable, Direction.Backward);
}
else
{
_throwableLauncher.Throw(throwable, _throwingDirection.CurrentDirection);
}
}
else // if (_tpBack.IsEnabled())
{
StartCoroutine(CooldownRoutine());
StartCoroutine(BlinkTpBack());
}
}
}
public static void SpawnPlayerAtPosition(Player player, Vector3 position, Quaternion rotation)
{
//Make sure player controlled entities are destroyed.
PlayerManager.Instance.DestroyPlayerControlledEntities(player);
LoadOut loadOut = new LoadOut();
loadOut.itemNames = new string[] { "Scout", "PlasmaFusor", "GrenadeLauncher", "ChainGun" };
LoadOutToken loadOutToken = new LoadOutToken(loadOut);
GameObject baseMech = DatabaseManager.Instance.PrefabDatabase.GetPrefabByName("BaseMech");
BoltEntity entity = BoltNetwork.Instantiate(baseMech, loadOutToken, position, rotation);
if (entity != null)
{
Unit unit = entity.GetComponent <Unit>();
unit.Setup(player.guid, player.teamId);
unit.gameObject.AddComponent <AbilityVelocityRedirection>();
if (player.connection == null)
{
entity.TakeControl();
}
else
{
entity.AssignControl(player.connection);
}
player.SetControlledEntity(entity);
}
}
public override void SceneLoadLocalDone(string map)
{
PlayerObjectRegistry.ServerPlayer.Spawn();
var game = BoltNetwork.Instantiate(BoltPrefabs.Game);
GameManager.Instance.Game = game.GetComponent <GameBehaviour>();
}
private void Start()
{
if (PlayerPrefs.GetInt("LOGSPAWN_ENABLED", 1) == 1)
{
BoltNetwork.Instantiate(BoltPrefabs.Log, base.transform.position, base.transform.rotation);
}
}
public override void SceneLoadLocalDone(string scene, IProtocolToken token)
{
var entity = BoltNetwork.Instantiate(BoltPrefabs.MoveAndShootPlayer, SpawnPointsManager.GetSpawnPosition(),
Quaternion.identity);
entity.TakeControl();
}
public override void Attached()
{
if (entity.IsOwner)
{
tempGameBase = BoltNetwork.Instantiate(
gameBasePrefab,
transform.TransformPoint(Vector3.zero),
transform.localRotation
);
tempGameBase.transform.parent = transform;
tempArCube = BoltNetwork.Instantiate(
arCubePrefab,
transform.TransformPoint(new Vector3(0.86f, 0.917f, 0.45f)),
transform.localRotation
);
tempArCube.transform.parent = transform;
tempArCube = BoltNetwork.Instantiate(
arCubePrefab,
transform.TransformPoint(new Vector3(-0.879f, 1.189f, -0.198f)),
transform.localRotation
);
tempArCube.transform.parent = transform;
tempArCube = BoltNetwork.Instantiate(
arCubePrefab,
transform.TransformPoint(new Vector3(0.273f, 1.55f, -0.253f)),
transform.localRotation
);
tempArCube.transform.parent = transform;
}
}
public void PickupPart()
{
if (BoltNetwork.IsRunning)
{
BoltEntity entity = pickup.GetComponent <BoltEntity>();
if (!entity.IsOwner)
{
Vector3 pos = entity.gameObject.transform.position;
Quaternion rot = entity.gameObject.transform.rotation;
int tempID = entity.gameObject.GetComponent <Part>().TemplateID;
var destroy = BlockDestroy.Create(entity);
destroy.Send();
PartToken token = new PartToken();
token.TemplateID = tempID;
//token.Free = true;
//token.Position = pos;
//token.Rotation = rot;
GameObject go = BoltNetwork.Instantiate(BoltPrefabs.AbstractBlock, token, pos, rot);
pickup = go;
}
}
Pickup();
}
void Die()
{
BoltNetwork.Destroy(gameObject);
var spawnPosition = new Vector3(Random.Range(-5f, 5f), Random.Range(15f, 30f), 0f);
var player = BoltNetwork.Instantiate(BoltPrefabs.Vampire, spawnPosition, Quaternion.identity);
}
private void Update()
{
if (!connected)
{
return;
}
if (newPosRecv)
{
float thisTime = Time.time * 1000;
float dif = thisTime - lastTime;
Debug.Log("Received camera position at " + Time.time * 1000 + " ms with a delta of " + dif + " ms");
lastTime = thisTime;
newPosRecv = false;
}
if (shouldSpawnSphere)
{
shouldSpawnSphere = false;
var obj = BoltNetwork.Instantiate(BoltPrefabs.Sphere, spawnPos, Quaternion.identity);
}
RenderCamera.position = cameraPos;
RenderCamera.eulerAngles = cameraRot;
//SpherePos = ballGO.transform.position;
}
public override void Connected(BoltConnection connection)
{
if (BoltNetwork.IsClient)
{
BoltConsole.Write("Connected Client: " + connection, Color.blue);
infoPanel.gameObject.SetActive(false);
string prevMatch = PreviousMatchName();
BoltConsole.Write("Previous match if any: " + prevMatch);
if (prevMatch != matchName)
{
BoltConsole.Write("New Game");
ChangeTo(lobbyPanel);
}
else
{
BoltConsole.Write("Joining previous match");
var returnPlayerEvnt = ReturnPlayerEvent.Create(Bolt.GlobalTargets.OnlyServer);
returnPlayerEvnt.Send();
}
}
else if (BoltNetwork.IsServer)
{
BoltConsole.Write("Connected Server: " + connection, Color.blue);
BoltEntity entity = BoltNetwork.Instantiate(BoltPrefabs.CharacterSelectionEntity);
entity.AssignControl(connection);
int numPlayers = gameStateEntity.GetComponent <NetworkGameState>().onPlayerJoined();
var playerTurnEvnt = PlayerJoinedEvent.Create(Bolt.GlobalTargets.Everyone);
playerTurnEvnt.numOfPlayers = numPlayers;
playerTurnEvnt.Send();
}
}
// Spawner
private void SpawnGamePlayer()
{
playerEntity = BoltNetwork.Instantiate(BoltPrefabs.LocalPlayer);
playerEntity.TakeControl();
CrisisHandler.instance.CallCrisis(NetworkGameState.instance.getCurrentCrisis());
playerEntity.GetComponent <Player>().setup(localPlayerSpellcasterID);
}
public GameObject SpawnTower(TowerType towerType, PlayerObject player, Vector3 position)
{
TowerData data = DataManager.Instance.GetTowerData(towerType);
Vector2Int coord = GridManager.Instance.GetCoordFromPosition(position);
if (GridManager.Instance.IsEmpty(coord.x, coord.y) && player.behavior.state.Gold >= data.cost)
{
var tower = BoltNetwork.Instantiate(BoltPrefabs.BaseTower);
tower.transform.position = position;
if (GridManager.Instance.CanPlaceObject(tower))
{
GridManager.Instance.SetEmpty(coord.x, coord.y, false);
player.behavior.state.Gold -= data.cost;
SetControl(player, tower);
_towers.Add(tower);
tower.GetComponent <TowerBehaviour>().Init_Server(data);
return(tower);
}
else
{
BoltNetwork.Destroy(tower);
}
}
return(null);
}
private void Spawn()
{
if (transform.position.z < -5)
{
var spawnPosition = new Vector3(transform.position.x, 0.5f, transform.position.z - 2);
GameObject wallClone = BoltNetwork.Instantiate(BoltPrefabs.wall_Y_axis, spawnPosition, transform.rotation);
}
else
if (transform.position.z > 5)
{
var spawnPosition = new Vector3(transform.position.x, 0.5f, transform.position.z + 2);
GameObject wallClone = BoltNetwork.Instantiate(BoltPrefabs.wall_Y_axis, spawnPosition, transform.rotation);
}
else
if (transform.position.x < 0)
{
var spawnPosition = new Vector3(transform.position.x - 2, 0.5f, transform.position.z);
GameObject wallClone = BoltNetwork.Instantiate(BoltPrefabs.wall_X_axis, spawnPosition, transform.rotation);
}
else
{
var spawnPosition = new Vector3(transform.position.x + 2, 0.5f, transform.position.z);
GameObject wallClone = BoltNetwork.Instantiate(BoltPrefabs.wall_X_axis, spawnPosition, transform.rotation);
}
}
static Toolset InitializeController(GameObject preFab, Vector3 pos)
{
GameObject controller = Instantiate(preFab, pos, Quaternion.identity);
ControllerReferences.Toolset = controller.GetComponentInChildren <Toolset>();
ControllerReferences.ControllerTarget = ControllerReferences.Toolset.ControllerTarget;
ControllerReferences.Controller = controller;
if (ControllerReferences.ControllerTarget == null)
{
Debug.LogError("Controller Target not found");
}
Time.timeScale = 1;
if (BoltNetwork.IsRunning)
{
GameObject model = BoltNetwork.Instantiate(BoltPrefabs.VR_character, new Vector3(0, 1, 2), Quaternion.identity);
NetworkModelBinding binding = model.GetComponent <NetworkModelBinding>();
ControllerReferences.MultiplayerCharacter = model;
binding.Controller = GameObject.Find("FollowHead").gameObject;
if (ControllerReferences.MultiPlayerRole != null && ControllerReferences.MultiPlayerRole != "")
{
binding.MultiplayerName = ControllerReferences.MultiPlayerName + "\n(" + ControllerReferences.MultiPlayerRole + ")";
}
else
{
binding.MultiplayerName = ControllerReferences.MultiPlayerName;
}
}
return(controller.GetComponentInChildren <Toolset>());
}
private void doFastBuild()
{
GameObject gameObject;
if (BoltNetwork.isRunning)
{
gameObject = BoltNetwork.Instantiate(this.buildThis, base.transform.position, base.transform.rotation).gameObject;
}
else
{
gameObject = UnityEngine.Object.Instantiate <GameObject>(this.buildThis, base.transform.position, base.transform.rotation);
}
if (gameObject && this.newBuildingDamage > 0f)
{
gameObject.GetComponent <BuildingHealth>().DamageOnly(new LocalizedHitData
{
_damage = this.newBuildingDamage
}, 0);
}
if (gameObject && this.TreeId > -1)
{
gameObject.GetComponent <TreeStructure>().TreeId = this.TreeId;
}
UnityEngine.Object.Destroy(base.gameObject);
}
public override void Attached()
{
this.chunks = (from x in base.GetComponentsInChildren <TreeCutChunk>()
orderby int.Parse(x.transform.parent.gameObject.name)
select x).ToArray <TreeCutChunk>();
base.state.AddCallback("TreeId", delegate
{
CoopTreeId coopTreeId = CoopPlayerCallbacks.AllTrees.FirstOrDefault((CoopTreeId x) => x.Id == base.state.TreeId);
if (coopTreeId)
{
LOD_Trees component = coopTreeId.GetComponent <LOD_Trees>();
if (component)
{
component.enabled = false;
component.DontSpawn = true;
if (component.CurrentView)
{
component.Pool.Despawn(component.CurrentView.transform);
component.CurrentView = null;
component.CurrentLodTransform = null;
}
}
}
});
base.state.AddCallback("Damage", delegate
{
if (base.entity.isOwner && base.state.Damage == 16f)
{
base.entity.DestroyDelayed(10f);
BoltEntity boltEntity = BoltNetwork.Instantiate(this.CoopTree.NetworkFallPrefab, base.entity.transform.position, base.entity.transform.rotation);
boltEntity.GetState <ITreeFallState>().CutTree = base.entity;
boltEntity.GetComponent <Rigidbody>().AddForce(new Vector3(UnityEngine.Random.value * 0.01f, 0f, UnityEngine.Random.value * 0.01f), ForceMode.VelocityChange);
}
});
}
public override void SceneLoadLocalDone(string scene)
{
//Instantiate over network
GameObject player = BoltNetwork.Instantiate(BoltPrefabs.PlayerCharacter);
Globals.LocalPlayer = player.GetComponent <ViewPlayer>();
}
public override void SceneLoadLocalDone(string scene)
{
var spawnPosition = Health.RandomSpawn();
// instantiate cube
BoltNetwork.Instantiate(BoltPrefabs.MainPlayer, spawnPosition, Quaternion.identity);
}
public BoltEntity SpawnPlayer()
{
if (PlayerEntity == null)
{
if (SpawnManager.HasSpawnPoints)
{
PlayerEntity = BoltNetwork.Instantiate(BoltPrefabs.Player, SpawnManager.GetSpawnPoint(), Quaternion.identity);
}
else
{
PlayerEntity = BoltNetwork.Instantiate(BoltPrefabs.Player);
PlayerEntity.gameObject.SetActive(false);
}
if (PlayerEntity.gameObject.activeSelf)
{
if (IsServer)
{
PlayerEntity.TakeControl();
}
else
{
PlayerEntity.AssignControl(Connection);
}
}
}
return(PlayerEntity);
}
public override void SceneLoadLocalDone(string scene)
{
var spawnPos = new Vector3(Random.Range(-8, 8), 0, Random.Range(-8, 8));
//instantiate for all players
BoltNetwork.Instantiate(cubePrefab, spawnPos, Quaternion.identity);
}
private void GrabbedByChanged()
{
if (base.state.GrabbedBy)
{
if (base.state.GrabbedBy == LocalPlayer.Entity)
{
BoltEntity boltEntity = BoltNetwork.Instantiate(BoltPrefabs.MultiSledBuilt, base.transform.position, base.transform.rotation);
IMultiHolderState state = boltEntity.GetState <IMultiHolderState>();
MultiHolder[] componentsInChildren = boltEntity.GetComponentsInChildren <MultiHolder>(true);
if (componentsInChildren.Length > 0)
{
componentsInChildren[0]._contentActual = base.state.LogCount;
componentsInChildren[0]._contentTypeActual = (MultiHolder.ContentTypes)base.state.ContentType;
componentsInChildren[0].ItemCountChangedMP();
state.Replaces = base.entity;
state.LogCount = base.state.LogCount;
state.Body0 = base.state.Body0;
state.Body1 = base.state.Body1;
state.Body2 = base.state.Body2;
}
}
}
else
{
MultiHolder[] componentsInChildren2 = base.GetComponentsInChildren <MultiHolder>(true);
if (componentsInChildren2.Length > 0)
{
componentsInChildren2[0].ItemCountChangedMP();
}
}
}
public override void UpdateAbility(bool button)
{
base.UpdateAbility(button);
if (_buttonDown && _timer + _abilityInterval <= BoltNetwork.ServerFrame && (state.Energy - _cost) >= 0)
{
_timer = BoltNetwork.ServerFrame;
if (entity.HasControl)
{
_UI_cooldown.StartCooldown();
}
if (entity.IsOwner)
{
state.Energy -= _cost;
RaycastHit hit;
if (Physics.Raycast(_cam.position, _cam.transform.forward, out hit, _maxDistance, _layerMask))
{
BoltNetwork.Instantiate(BoltPrefabs.Medikit, hit.point, Quaternion.identity).GetComponent <AOE>().laucher = GetComponent <PlayerMotor>();
}
else
{
BoltNetwork.Instantiate(BoltPrefabs.Medikit, transform.position, Quaternion.identity).GetComponent <AOE>().laucher = GetComponent <PlayerMotor>();
}
}
}
}
public override void SceneLoadRemoteDone(BoltConnection connection, IProtocolToken token)
{
var entity = BoltNetwork.Instantiate(BoltPrefabs.MoveAndShootPlayer, SpawnPointsManager.GetSpawnPosition(),
Quaternion.identity);
entity.AssignControl(connection);
}
public override void BoltStartDone()
{
if (!BoltNetwork.IsRunning)
{
return;
}
if (BoltNetwork.IsServer)
{
RoomProtocolToken token = new RoomProtocolToken()
{
ArbitraryData = "My DATA",
};
BoltLog.Info("Starting Server");
// Start Photon Room
BoltNetwork.SetServerInfo(_matchName, token);
// Setup Host
infoPanel.gameObject.SetActive(false);
ChangeTo(lobbyPanel);
backDelegate = Stop;
SetServerInfo("Host", "");
// Build Server Entity
BoltEntity entity = BoltNetwork.Instantiate(BoltPrefabs.PlayerInfo);
entity.TakeControl();
}
else if (BoltNetwork.IsClient)
{
backDelegate = Stop;
SetServerInfo("Client", "");
}
}
// ------------------------------------------------- //
public void SpawnPlayer(string name)
{
Debug.Log("[GAME] Spawn " + name);
// Get random spawn point for local player.
// FOR DEBUG
Transform spawnPoint;
if (BoltNetwork.IsServer)
{
spawnPoint = spawnPoints.PlayerSpawns[1];
}
else if (BoltNetwork.IsClient)
{
spawnPoint = spawnPoints.PlayerSpawns[0];
}
else
{
spawnPoint = GetRandomSpawnPoint();
}
// Create player. They should have control immediately.
// The static BoltPrefabs class is compiled and updated by Bolt, and
// contains a unique reference to each prefab with a Bolt Entity on it.
// You can also pass in a normal GameObject reference instead.
var player = BoltNetwork.Instantiate(BoltPrefabs.FPSController, spawnPoint.position, spawnPoint.rotation);
player.name = name;
}
public override void SceneLoadLocalDone(string scene, IProtocolToken token)
{
if (BoltNetwork.IsServer)
{
BoltNetwork.Instantiate(prefabEntity.gameObject, transform.position, Quaternion.identity);
}
}
public void FireIonBeam()
{
if (!_isFiring && entity.isOwner)
{
Vector3 camPosition = _ionBeamCam.transform.position;
_ionBeamCam.GetComponent <IonBeamCamera>().enabled = false;
_ionBeamCam.GetComponentInChildren <Camera>().enabled = false;
var ionBeamLaser = BoltNetwork.Instantiate(ionBeamLaserPrefab, new Vector3(camPosition.x, 0, camPosition.z), Quaternion.identity);
var itemState = ionBeamLaser.GetComponent <BoltEntity>().GetState <IItemState>();
itemState.OwnerID = _ionBeamOwnership.OwnerID;
var laserOwnership = ionBeamLaser.GetComponent <Ownership>();
laserOwnership.Label = _ionBeamOwnership.Label;
laserOwnership.OwnerID = _ionBeamOwnership.OwnerID;
laserOwnership.OwnerNickname = _ionBeamOwnership.OwnerNickname;
laserOwnership.Team = _ionBeamOwnership.Team;
ItemThrown itemThrownEvent = ItemThrown.Create();
itemThrownEvent.OwnerNickname = _ionBeamOwnership.OwnerNickname;
itemThrownEvent.OwnerID = _ionBeamOwnership.OwnerID;
itemThrownEvent.Team = (int)_ionBeamOwnership.Team;
itemThrownEvent.Entity = ionBeamLaser;
itemThrownEvent.Send();
ionBeamLaser.transform.position = new Vector3(_ionBeamCam.transform.position.x, ionBeamLaser.transform.position.y, _ionBeamCam.transform.position.z);
_ionBeamCam.IonBeamCameraBehaviour(false);
if (entity.isOwner)
{
StartCoroutine(DelayBeforeInputsChange());
}
_isFiring = true;
}
}
public void Spawn()
{
if (!character)
{
// assign the colors/numbers etc for the player.
var playerToken = new PlayerToken();
playerToken.playerNumber = playerNumber;
playerToken.playerColor = playerColor;
playerToken.playerName = playerName;
character = BoltNetwork.Instantiate(BoltPrefabs.PlayerMultiplayer, playerToken);
if (IsServer)
{
character.TakeControl();
}
else
{
character.AssignControl(connection);
}
// move entity to random spawn position
character.transform.position = GamemanagerNetwork.instance.RandomSpawnPoint();
}
}
private void OnDestroy()
{
if (this._replaceByPrefab && (!this._onlyIfActive || base.gameObject.activeSelf) && Prefabs.Instance && !BoltNetwork.isClient)
{
Transform parent = base.transform.parent;
if (BoltNetwork.isServer && this._replaceByPrefab.GetComponent <BoltEntity>())
{
if (this._oneFrameDelay)
{
Prefabs.Instance.SpawnNextFrameMP(this._replaceByPrefab, base.transform.position, base.transform.rotation, parent);
}
else
{
BoltEntity boltEntity = BoltNetwork.Instantiate(this._replaceByPrefab.gameObject, base.transform.position, base.transform.rotation);
if (parent)
{
boltEntity.transform.parent = parent;
}
}
}
else if (this._oneFrameDelay)
{
Prefabs.Instance.SpawnNextFrame(this._replaceByPrefab, base.transform.position, base.transform.rotation, parent);
}
else
{
Transform transform = (Transform)UnityEngine.Object.Instantiate(this._replaceByPrefab, base.transform.position, base.transform.rotation);
if (parent)
{
transform.parent = parent;
}
}
}
}
void Update()
{
enemyTimeLeft -= BoltNetwork.FrameDeltaTime;
coinTimeLeft -= BoltNetwork.FrameDeltaTime;
if (enemyTimeLeft < 0)
{
while (Mathf.Abs(randPosX) < 15 && Mathf.Abs(randPosY) < 15)
{
randPosX = Random.Range(-25, 25);
randPosY = Random.Range(-25, 25);
}
var enemySpawnPosition = new Vector3(randPosX, 0.5f, randPosY);
BoltNetwork.Instantiate(BoltPrefabs.Enemy, enemySpawnPosition, Quaternion.identity);
if (difficultyTimer < 10)
{
enemyTimeLeft = 5.0f;
difficultyTimer += 1;
}
else
{
enemyTimeLeft = 3.0f;
}
randPosX = 0;
randPosY = 0;
}
if (coinTimeLeft < 0)
{
var coinSpawnPosition = new Vector3(Random.Range(-10, 10), 0.25f, Random.Range(-10, 10));
BoltNetwork.Instantiate(BoltPrefabs.Coin, coinSpawnPosition, Quaternion.identity);
coinTimeLeft = 2.0f;
}
}
