private void SaveAndExit(MyCockpit cockpit)
{
MyTerminalControls.Static.CustomControlGetter -= CustomControlGetter;
cockpit.RebuildControls();
m_onComplete(m_selected.Select(item => (IMyMotorStator)item.UserData), m_sensitivity, MathHelper.ToRadians(m_trim));
}
public override bool HasBuildingMaterials(MyEntity builder)
{
if (MySession.Static.CreativeMode || (MySession.Static.IsAdminModeEnabled(Sync.MyId) && builder == MySession.Static.LocalCharacter))
{
return(true);
}
if (builder == null)
{
return(false);
}
var inventory = GetBuilderInventory(builder);
if (inventory == null)
{
return(false);
}
MyInventory shipInventory = null;
MyCockpit cockpit = null;
long identityId = MySession.Static.LocalPlayerId;
if (builder is MyCharacter)
{//construction cockpit?
cockpit = (builder as MyCharacter).IsUsing as MyCockpit;
if (cockpit != null)
{
shipInventory = cockpit.GetInventory();
identityId = cockpit.ControllerInfo.ControllingIdentityId;
}
else
if ((builder as MyCharacter).ControllerInfo != null)
{
identityId = (builder as MyCharacter).ControllerInfo.ControllingIdentityId;
}
else
{
Debug.Fail("failed to get identityId");
}
}
bool result = true;
foreach (var entry in m_materialList.RequiredMaterials)
{
result &= inventory.GetItemAmount(entry.Key) >= entry.Value;
if (!result && shipInventory != null)
{
result = shipInventory.GetItemAmount(entry.Key) >= entry.Value;
if (!result)
{
//MyGridConveyorSystem.ItemPullRequest((MySession.Static.ControlledEntity as MyCockpit), shipInventory, MySession.Static.LocalPlayerId, entry.Key, entry.Value);
result = MyGridConveyorSystem.ConveyorSystemItemAmount(cockpit, shipInventory, identityId, entry.Key) >= entry.Value;
}
}
if (!result)
{
break;
}
}
return(result);
}
public static IMySourceVoice PlaySound(MyGuiSounds sound)
{
if (MyFakes.ENABLE_NEW_SOUNDS && MySession.Static != null && MySession.Static.Settings.RealisticSound && MySession.Static.LocalCharacter != null &&
MySession.Static.LocalCharacter.OxygenComponent != null && MySession.Static.LocalCharacter.OxygenComponent.HelmetEnabled == false)
{
MySoundData soundData = MyAudio.Static.GetCue(m_sounds[sound].SoundId);
if (soundData != null && soundData.CanBeSilencedByVoid)
{
MyCockpit cockpit = MySession.Static.LocalCharacter.Parent as MyCockpit;
if ((cockpit == null || !cockpit.BlockDefinition.IsPressurized) && MySession.Static.LocalCharacter.EnvironmentOxygenLevel <= 0)
{
return(null);//disables hud sound when in realistic mode in space without helmet
}
}
}
if (CheckForSynchronizedSounds(sound))
{
return(MyAudio.Static.PlaySound(m_sounds[sound].SoundId));
}
else
{
return(null);
}
}
public void Init(MyObjectBuilder_Toolbar builder, MyEntity owner, bool skipAssert = false)
{
// TODO: remove skipAssert when spectator is MyEntity
Debug.Assert(skipAssert || owner != null, "Toolbar has no owner");
Owner = owner;
if (builder == null)
{
return;
}
if (builder.Slots != null)
{
Clear();
foreach (var slot in builder.Slots)
{
SetItemAtSerialized(slot.Index, slot.Item, slot.Data);
}
}
MyCockpit cockpit = Owner as MyCockpit;
if (cockpit != null && cockpit.CubeGrid != null)
{
cockpit.CubeGrid.OnBlockClosed += OnBlockClosed;
}
}
private void ItemSelected(MyCockpit cockpit, List <MyGuiControlListbox.Item> selected)
{
m_selected.Clear();
foreach (MyGuiControlListbox.Item item in selected)
{
m_selected.Add(item);
}
}
public override void OnAttachedToShipController(MyCockpit newShipController)
{
base.OnAttachedToShipController(newShipController);
if (this.m_subgridLookupCounter <= 0)
{
this.RegisterGridCallbacks();
}
}
private static bool EnergyNoWarningMethod(out MyGuiSounds cue, out MyStringId text)
{
cue = MyGuiSounds.None;
text = MySpaceTexts.Blank;
if (!IsEnergyUnderTreshold(0f))
{
return(false);
}
if (MySession.Static.ControlledEntity.Entity is MyCharacter)
{
cue = MyGuiSounds.HudVocEnergyNo;
text = MySpaceTexts.NotificationEnergyNo;
}
else if (MySession.Static.ControlledEntity.Entity is MyCockpit)
{
MyCockpit cockpit = (MyCockpit)MySession.Static.ControlledEntity.Entity;
bool hasReactor = false;
List <MyCubeGrid> connectedGroups = MyCubeGridGroups.Static.Logical.GetGroupNodes(cockpit.CubeGrid);
if (connectedGroups == null || connectedGroups.Count == 0)
{
return(false);
}
foreach (var grid in connectedGroups)
{
if (grid.NumberOfReactors > 0)
{
hasReactor = true;
break;
}
}
if (hasReactor)
{
if (cockpit.CubeGrid.IsStatic)
{
cue = MyGuiSounds.HudVocStationFuelNo;
}
else
{
cue = MyGuiSounds.HudVocShipFuelNo;
}
text = MySpaceTexts.NotificationFuelNo;
}
else
{
return(false);
}
}
else
{
return(false);
}
return(true);
}
public FlightControlAssist(MyCockpit cockpit)
{
this.m_cockpit = cockpit;
this.m_aileron = m_elevator = m_rudder = new FlightControlStator[0];
CubeGridCache cache = CubeGridCache.GetFor(m_grid);
Pseudo = new PseudoBlock(cockpit);
Update.UpdateManager.Register(10, Update10, m_grid);
}
public static void SendCharacterCreated(MyObjectBuilder_Character character, MyCockpit cockpit)
{
MySyncCreate.SendEntityCreated(character);
AttachToCockpitMsg msg = new AttachToCockpitMsg();
msg.CharacterEntityId = character.EntityId;
msg.CockpitEntityId = cockpit.EntityId;
Sync.Layer.SendMessageToAll(msg);
}
private void ListContent(MyCockpit cockpit, ICollection <MyGuiControlListbox.Item> items, ICollection <MyGuiControlListbox.Item> selected)
{
foreach (MyGuiControlListbox.Item item in m_allItems)
{
items.Add(item);
}
foreach (MyGuiControlListbox.Item item in m_selected)
{
selected.Add(item);
}
}
private static void RotorButtonRudder(MyCockpit block)
{
CockpitTerminal cockpitTerminal;
if (!Registrar.TryGetValue(block, out cockpitTerminal))
{
Logger.AlwaysLog("Failed lookup of block: " + block.getBestName(), Logger.severity.WARNING);
return;
}
new RotorPicker(block, "Rudder", cockpitTerminal.m_controlHelper.RudderParams, cockpitTerminal.m_controlHelper.SetRudders);
}
static void OnAttachToCockpit(MySyncCharacter sync, ref AttachToCockpitMsg msg, MyNetworkClient sender)
{
MyCharacter character = sync.Entity;
MyCockpit cockpit = MyEntities.GetEntityById(msg.CockpitEntityId) as MyCockpit;
Debug.Assert(cockpit != null);
if (cockpit == null)
{
return;
}
cockpit.AttachPilot(character, false);
}
private static void UseCockpit(MyCockpit cockpit)
{
if (MySession.Static.LocalHumanPlayer == null)
{
return;
}
// Leave current cockpit if controlling any
if (MySession.Static.ControlledEntity is MyCockpit)
{
MySession.Static.ControlledEntity.Use();
}
cockpit.RequestUse(UseActionEnum.Manipulate, MySession.Static.LocalHumanPlayer.Identity.Character);
cockpit.RemoveOriginalPilotPosition();
}
public override List <MyHudEntityParams> GetHudParams(bool allowBlink)
{
base.m_hudParams.Clear();
if ((((base.CubeGrid != null) && !base.CubeGrid.MarkedForClose) && !base.CubeGrid.Closed) && base.IsWorking)
{
List <MyHudEntityParams> hudParams = this.GetHudParams(allowBlink && base.HasLocalPlayerAccess());
StringBuilder hudText = this.HudText;
if (this.ShowShipName || (hudText.Length > 0))
{
StringBuilder text = hudParams[0].Text;
text.Clear();
if (!string.IsNullOrEmpty(base.GetOwnerFactionTag()))
{
text.Append(base.GetOwnerFactionTag());
text.Append(".");
}
if (this.ShowShipName)
{
text.Append(base.CubeGrid.DisplayName);
text.Append(" - ");
}
text.Append(hudText);
}
base.m_hudParams.AddList <MyHudEntityParams>(hudParams);
if (base.HasLocalPlayerAccess() && (base.SlimBlock.CubeGrid.GridSystems.TerminalSystem != null))
{
base.SlimBlock.CubeGrid.GridSystems.TerminalSystem.NeedsHudUpdate = true;
foreach (MyTerminalBlock block in base.SlimBlock.CubeGrid.GridSystems.TerminalSystem.HudBlocks)
{
if (!ReferenceEquals(block, this))
{
base.m_hudParams.AddList <MyHudEntityParams>(block.GetHudParams(true));
}
}
}
MyEntityController entityController = MySession.Static.Players.GetEntityController(base.CubeGrid);
if (entityController != null)
{
MyCockpit controlledEntity = entityController.ControlledEntity as MyCockpit;
if ((controlledEntity != null) && (controlledEntity.Pilot != null))
{
base.m_hudParams.AddList <MyHudEntityParams>(controlledEntity.GetHudParams(true));
}
}
}
return(base.m_hudParams);
}
public static void UseNextShip()
{
MyCockpit first = null;
object previous = null;
foreach (var g in MyEntities.GetEntities().OfType <MyCubeGrid>())
{
//if (g.GridSizeEnum == CommonLib.ObjectBuilders.MyCubeSize.Large)
{
foreach (var cockpit in g.GetBlocks().Select(s => s.FatBlock as MyCockpit).Where(s => (s != null)))
{
if (first == null && cockpit.Pilot == null)
{
first = cockpit;
}
if (previous == MySession.Static.ControlledEntity)
{
if (cockpit.Pilot == null)
{
UseCockpit(cockpit);
return;
}
}
else
{
previous = cockpit;
}
}
}
}
if (first != null)
{
UseCockpit(first);
}
}
public override void Update()
{
if (Sync.IsServer)
{
if (this.m_subgridLookupCounter > 0)
{
int num = this.m_subgridLookupCounter - 1;
this.m_subgridLookupCounter = num;
if (num == 0)
{
MyCubeGrid cubeGrid = base.ShipController.CubeGrid;
MyGroups <MyCubeGrid, MyGridLogicalGroupData> .Group group = MyCubeGridGroups.Static.Logical.GetGroup(cubeGrid);
this.m_gridIds = (from x in group.Nodes select x.NodeData.EntityId).ToArray <long>();
this.RegisterGridCallbacks();
}
}
MyCockpit shipController = base.ShipController;
if (shipController != null)
{
int num1;
if ((MySandboxGame.TotalGamePlayTimeInMilliseconds - this.m_spawnTime) <= SHIP_LIFESPAN_MILLISECONDS)
{
num1 = (int)((shipController.PositionComp.GetPosition() - this.m_destination).Dot(this.m_direction) > 0.0);
}
else
{
num1 = 1;
}
if ((num1 != 0) && !this.IsPlayerNearby())
{
base.ShipController.RemoveAutopilot(true);
this.ForEachGrid(grid => grid.Close());
}
}
}
}
public MyDebugRenderComponentCockpit(MyCockpit cockpit)
: base(cockpit)
{
m_cockpit = cockpit;
}
public void SpawnAtShip(MyPlayer player, string respawnShipId, MyBotDefinition botDefinition)
{
Debug.Assert(Sync.IsServer, "Spawning can only be called on the server!");
if (!Sync.IsServer)
{
return;
}
ResetRespawnCooldown(player.Id);
if (Sync.MultiplayerActive)
{
SyncCooldownToPlayer(player.Id.SteamId, player.Id.SteamId == Sync.MyId);
}
MyCharacter character = null;
MyCockpit cockpit = null;
List <MyCubeGrid> respawnGrids = new List <MyCubeGrid>();
var respawnShipDef = MyDefinitionManager.Static.GetRespawnShipDefinition(respawnShipId);
MyPrefabDefinition prefabDef = respawnShipDef.Prefab;
// Deploy ship
Vector3D position = Vector3D.Zero;
float planetSpawnHeightRatio = 0.3f;
float spawnRangeMin = 500f;
float spawnRangeMax = 650f;
if (prefabDef.CubeGrids != null && prefabDef.CubeGrids.Length > 0)
{
MyObjectBuilder_CubeGrid firstGrid = prefabDef.CubeGrids[0];
if (firstGrid.UsePositionForSpawn)
{
position = new Vector3D(
firstGrid.PositionAndOrientation.Value.Position.x,
firstGrid.PositionAndOrientation.Value.Position.y,
firstGrid.PositionAndOrientation.Value.Position.z);
}
planetSpawnHeightRatio = MyMath.Clamp(firstGrid.PlanetSpawnHeightRatio, 0.05f, 0.95f); // Clamped to prevent crazy data
spawnRangeMin = firstGrid.SpawnRangeMin;
spawnRangeMax = firstGrid.SpawnRangeMax;
}
Vector3D forward = Vector3.Forward;
Vector3D up = Vector3D.Up;
GetSpawnPosition(prefabDef.BoundingSphere.Radius, ref position, out forward, out up, planetSpawnHeightRatio, spawnRangeMin, spawnRangeMax);
MyPrefabManager.Static.SpawnPrefab(
respawnGrids,
prefabDef.Id.SubtypeName,
position,
forward,
up,
spawningOptions: VRage.Game.ModAPI.SpawningOptions.RotateFirstCockpitTowardsDirection,
updateSync: true);
// Find cockpits
List <MyCockpit> shipCockpits = new List <MyCockpit>();
foreach (MyCubeGrid grid in respawnGrids)
{
foreach (MyCockpit gridCockpit in grid.GetFatBlocks <MyCockpit>())
{
// Ignore non-functional cockpits
if (!gridCockpit.IsFunctional)
{
continue;
}
shipCockpits.Add(gridCockpit);
}
}
// First sort cockpits by order: Ship controlling cockpits set to main, then ship controlling cockpits not set to main, lastly whatever remains, e.g. CryoChambers and Passenger Seats
if (shipCockpits.Count > 1)
{
shipCockpits.Sort(delegate(MyCockpit cockpitA, MyCockpit cockpitB)
{
int controlCompare = cockpitB.EnableShipControl.CompareTo(cockpitA.EnableShipControl);
if (controlCompare != 0)
{
return(controlCompare);
}
int mainCompare = cockpitB.IsMainCockpit.CompareTo(cockpitA.IsMainCockpit);
if (mainCompare != 0)
{
return(mainCompare);
}
return(0);
});
}
// Finally, select the most important cockpit
if (shipCockpits.Count > 0)
{
cockpit = shipCockpits[0];
}
System.Diagnostics.Debug.Assert(cockpit != null, "character is spawning in ship without cockpit !");
// Create character
MatrixD matrix = MatrixD.Identity;
if (cockpit != null)
{
matrix = cockpit.WorldMatrix;
matrix.Translation = cockpit.WorldMatrix.Translation - Vector3.Up - Vector3.Forward;
}
else if (respawnGrids.Count > 0)
{
matrix.Translation = respawnGrids[0].PositionComp.WorldAABB.Center + respawnGrids[0].PositionComp.WorldAABB.HalfExtents;
}
character = MyCharacter.CreateCharacter(matrix, Vector3.Zero, player.Identity.DisplayName, player.Identity.Model, null, botDefinition, cockpit: cockpit, playerSteamId: player.Id.SteamId);
CloseRespawnShip(player);
foreach (var respawnGrid in respawnGrids)
{
respawnGrid.ChangeGridOwnership(player.Identity.IdentityId, MyOwnershipShareModeEnum.None);
respawnGrid.IsRespawnGrid = true;
player.RespawnShip.Add(respawnGrid.EntityId);
}
if (cockpit != null)
{
cockpit.AttachPilot(character, false);
MyMultiplayer.ReplicateImmediatelly(MyExternalReplicable.FindByObject(cockpit.CubeGrid), new EndpointId(player.Id.SteamId));
}
if (cockpit == null)
{
Sync.Players.SetPlayerCharacter(player, character, null);
}
else
{
character.SetPlayer(player);
Sync.Players.SetPlayerToCockpit(player, cockpit);
}
Sync.Players.RevivePlayer(player);
}
private void SpawnPrefabInternalSetProperties(
List <MyCubeGrid> resultList,
Vector3D position,
Vector3 forward,
Vector3 up,
Vector3 initialLinearVelocity,
Vector3 initialAngularVelocity,
String beaconName,
SpawningOptions spawningOptions,
long ownerId,
bool updateSync)
{
int rngSeed = 0;
using (updateSync ? MyRandom.Instance.PushSeed(rngSeed = MyRandom.Instance.CreateRandomSeed()) : new MyRandom.StateToken())
{
MyCockpit firstCockpit = null;
bool rotateToCockpit = spawningOptions.HasFlag(SpawningOptions.RotateFirstCockpitTowardsDirection);
bool spawnCargo = spawningOptions.HasFlag(SpawningOptions.SpawnRandomCargo);
bool setNeutralOwner = spawningOptions.HasFlag(SpawningOptions.SetNeutralOwner);
bool needsToIterateThroughBlocks = spawnCargo || rotateToCockpit || setNeutralOwner || beaconName != null;
long owner = ownerId;
if (updateSync && spawningOptions.HasFlag(SpawningOptions.SetNeutralOwner) && resultList.Count != 0)
{
string npcName = "NPC " + MyRandom.Instance.Next(1000, 9999);
var identity = Sync.Players.CreateNewIdentity(npcName);
owner = identity.IdentityId;
}
bool setOwnership = owner != 0;
List <MyCockpit> shipCockpits = new List <MyCockpit>();
foreach (var grid in resultList)
{
grid.ClearSymmetries();
if (spawningOptions.HasFlag(SpawningOptions.DisableDampeners))
{
var thrustComp = grid.Components.Get <MyEntityThrustComponent>();
if (thrustComp != null)
{
thrustComp.DampenersEnabled = false;
}
}
if ((spawningOptions.HasFlag(SpawningOptions.DisableSave)))
{
grid.Save = false;
}
if (needsToIterateThroughBlocks || spawningOptions.HasFlag(SpawningOptions.TurnOffReactors))
{
ProfilerShort.Begin("Iterate through blocks");
foreach (var block in grid.GetBlocks())
{
if (block.FatBlock is MyCockpit && block.FatBlock.IsFunctional)
{
shipCockpits.Add(block.FatBlock as MyCockpit);
}
else if (block.FatBlock is MyCargoContainer && spawnCargo)
{
MyCargoContainer container = block.FatBlock as MyCargoContainer;
container.SpawnRandomCargo();
}
else if (block.FatBlock is MyBeacon && beaconName != null)
{
MyBeacon beacon = block.FatBlock as MyBeacon;
beacon.SetCustomName(beaconName);
}
else if (spawningOptions.HasFlag(SpawningOptions.TurnOffReactors) && block.FatBlock != null && block.FatBlock.Components.Contains(typeof(MyResourceSourceComponent)))
{
var sourceComp = block.FatBlock.Components.Get <MyResourceSourceComponent>();
if (sourceComp != null)
{
if (sourceComp.ResourceTypes.Contains(MyResourceDistributorComponent.ElectricityId))
{
sourceComp.Enabled = false;
}
}
}
if (setOwnership && block.FatBlock != null && block.BlockDefinition.RatioEnoughForOwnership(block.BuildLevelRatio))
{
block.FatBlock.ChangeOwner(owner, MyOwnershipShareModeEnum.None);
}
}
ProfilerShort.End();
}
}
// First sort cockpits by order: Ship controlling cockpits set to main, then ship controlling cockpits not set to main, lastly whatever remains, e.g. CryoChambers and Passenger Seats
if (shipCockpits.Count > 1)
{
shipCockpits.Sort(delegate(MyCockpit cockpitA, MyCockpit cockpitB)
{
int controlCompare = cockpitB.EnableShipControl.CompareTo(cockpitA.EnableShipControl);
if (controlCompare != 0)
{
return(controlCompare);
}
int mainCompare = cockpitB.IsMainCockpit.CompareTo(cockpitA.IsMainCockpit);
if (mainCompare != 0)
{
return(mainCompare);
}
return(0);
});
}
if (shipCockpits.Count > 0)
{
firstCockpit = shipCockpits[0];
}
// Try to rotate to the first cockpit
Matrix transform = Matrix.Identity;
if (rotateToCockpit)
{
System.Diagnostics.Debug.Assert(firstCockpit != null, "cockpit in prefab ship is missing !");
if (firstCockpit != null)
{
Matrix cockpitTransform = firstCockpit.WorldMatrix;
Matrix cockpitInvertedTransform = Matrix.Invert(cockpitTransform);
transform = Matrix.Multiply(cockpitInvertedTransform, Matrix.CreateWorld(firstCockpit.WorldMatrix.Translation, forward, up));
}
}
foreach (var grid in resultList)
{
if (firstCockpit != null && rotateToCockpit)
{
grid.WorldMatrix = grid.WorldMatrix * transform;
}
if (grid.Physics != null)
{
grid.Physics.LinearVelocity = initialLinearVelocity;
grid.Physics.AngularVelocity = initialAngularVelocity;
}
ProfilerShort.Begin("Add entity");
//MyEntities.Add(grid);
ProfilerShort.End();
}
}
}
public virtual void OnAttachedToShipController(MyCockpit newShipController)
{
this.ShipController = newShipController;
}
private void PutPlayerInRespawnGrid(MyPlayer player, List <MyCubeGrid> respawnGrids, MyBotDefinition botDefinition)
{
MyCharacter character = null;
MyCockpit cockpit = null;
// Find cockpits
List <MyCockpit> shipCockpits = new List <MyCockpit>();
foreach (MyCubeGrid grid in respawnGrids)
{
foreach (MyCockpit gridCockpit in grid.GetFatBlocks <MyCockpit>())
{
// Ignore non-functional cockpits
if (!gridCockpit.IsFunctional)
{
continue;
}
shipCockpits.Add(gridCockpit);
}
}
// First sort cockpits by order: Ship controlling cockpits set to main, then ship controlling cockpits not set to main, lastly whatever remains, e.g. CryoChambers and Passenger Seats
if (shipCockpits.Count > 1)
{
shipCockpits.Sort(delegate(MyCockpit cockpitA, MyCockpit cockpitB)
{
int controlCompare = cockpitB.EnableShipControl.CompareTo(cockpitA.EnableShipControl);
if (controlCompare != 0)
{
return(controlCompare);
}
int mainCompare = cockpitB.IsMainCockpit.CompareTo(cockpitA.IsMainCockpit);
if (mainCompare != 0)
{
return(mainCompare);
}
return(0);
});
}
// Finally, select the most important cockpit
if (shipCockpits.Count > 0)
{
cockpit = shipCockpits[0];
}
System.Diagnostics.Debug.Assert(cockpit != null, "character is spawning in ship without cockpit !");
// Create character
MatrixD matrix = MatrixD.Identity;
if (cockpit != null)
{
matrix = cockpit.WorldMatrix;
matrix.Translation = cockpit.WorldMatrix.Translation - Vector3.Up - Vector3.Forward;
}
else if (respawnGrids.Count > 0)
{
matrix.Translation = respawnGrids[0].PositionComp.WorldAABB.Center + respawnGrids[0].PositionComp.WorldAABB.HalfExtents;
}
character = MyCharacter.CreateCharacter(matrix, Vector3.Zero, player.Identity.DisplayName, player.Identity.Model, null, botDefinition, cockpit: cockpit, playerSteamId: player.Id.SteamId);
CloseRespawnShip(player);
foreach (var respawnGrid in respawnGrids)
{
respawnGrid.ChangeGridOwnership(player.Identity.IdentityId, MyOwnershipShareModeEnum.None);
respawnGrid.IsRespawnGrid = true;
respawnGrid.m_playedTime = 0;
player.RespawnShip.Add(respawnGrid.EntityId);
}
//SaveRespawnShip(player);
if (cockpit != null)
{
cockpit.AttachPilot(character, false);
MyMultiplayer.ReplicateImmediatelly(MyExternalReplicable.FindByObject(cockpit.CubeGrid), new EndpointId(player.Id.SteamId));
}
if (cockpit == null)
{
Sync.Players.SetPlayerCharacter(player, character, null);
}
else
{
character.SetPlayer(player);
Sync.Players.SetPlayerToCockpit(player, cockpit);
}
Sync.Players.RevivePlayer(player);
}
private void TakeMaterialsFromBuilder(MyEntity builder)
{
// CH: TODO: Please refactor this to not be so ugly. Especially, calling the Solve function multiple times on the component combiner is bad...
if (builder == null)
{
return;
}
var inventory = GetBuilderInventory(builder);
if (inventory == null)
{
return;
}
MyInventory shipInventory = null;
MyCockpit cockpit = null;
long identityId = long.MaxValue;
if (builder is MyCharacter)
{//construction cockpit?
cockpit = (builder as MyCharacter).IsUsing as MyCockpit;
if (cockpit != null)
{
shipInventory = cockpit.GetInventory();
identityId = cockpit.ControllerInfo.ControllingIdentityId;
}
else
if ((builder as MyCharacter).ControllerInfo != null)
{
identityId = (builder as MyCharacter).ControllerInfo.ControllingIdentityId;
}
else
{
Debug.Fail("failed to get identityId");
}
}
VRage.MyFixedPoint hasAmount, hasAmountCockpit;
foreach (var entry in m_materialList.RequiredMaterials)
{
VRage.MyFixedPoint toRemove = entry.Value;
hasAmount = inventory.GetItemAmount(entry.Key);
if (hasAmount > entry.Value)
{
inventory.RemoveItemsOfType(toRemove, entry.Key);
continue;
}
if (hasAmount > 0)
{
inventory.RemoveItemsOfType(hasAmount, entry.Key);
toRemove -= hasAmount;
}
if (shipInventory != null)
{
hasAmountCockpit = shipInventory.GetItemAmount(entry.Key);
if (hasAmountCockpit >= toRemove)
{
shipInventory.RemoveItemsOfType(toRemove, entry.Key);
continue;
}
if (hasAmountCockpit > 0)
{
shipInventory.RemoveItemsOfType(hasAmountCockpit, entry.Key);
toRemove -= hasAmountCockpit;
}
var transferred = MyGridConveyorSystem.ItemPullRequest(cockpit, shipInventory, identityId, entry.Key, toRemove, true);
Debug.Assert(transferred == toRemove, "Cannot pull enough materials to build, " + transferred + "!=" + toRemove);
}
else
{
Debug.Assert(toRemove == 0, "Needs more materials and ship inventory is null");
}
}
}
/// <summary>
/// This will just spawn new character, to take control, call respawn on player
/// </summary>
public static MyCharacter CreateCharacter(MatrixD worldMatrix, Vector3 velocity, string characterName, string model, Vector3? colorMask, MyBotDefinition botDefinition, bool findNearPos = true, bool AIMode = false, MyCockpit cockpit = null, bool useInventory = true, ulong playerSteamId = 0)
{
Vector3D? characterPos = null;
if (findNearPos)
{
characterPos = MyEntities.FindFreePlace(worldMatrix.Translation, 2, 200, 5, 0.5f);
// Extended search
if (!characterPos.HasValue)
{
characterPos = MyEntities.FindFreePlace(worldMatrix.Translation, 2, 200, 5, 5);
}
}
// Use default position
if (characterPos.HasValue)
{
worldMatrix.Translation = characterPos.Value;
}
MyCharacter character = CreateCharacterBase(worldMatrix, ref velocity, characterName, model, colorMask, AIMode, useInventory, botDefinition);
if (cockpit == null && Sync.IsServer && MyPerGameSettings.BlockForVoxels == false)
{
MyMultiplayer.ReplicateImmediatelly(MyExternalReplicable.FindByObject(character), new EndpointId(playerSteamId));
}
return character;
}
private void SpawnPrefabInternal(
List <MyCubeGrid> resultList,
String prefabName,
Vector3D position,
Vector3 forward,
Vector3 up,
Vector3 initialLinearVelocity,
Vector3 initialAngularVelocity,
String beaconName,
SpawningOptions spawningOptions,
bool updateSync)
{
Debug.Assert(Vector3.IsUnit(ref forward));
Debug.Assert(Vector3.IsUnit(ref up));
Debug.Assert(Vector3.ArePerpendicular(ref forward, ref up));
int rngSeed = 0;
using (updateSync ? MyRandom.Instance.PushSeed(rngSeed = MyRandom.Instance.CreateRandomSeed()) : new MyRandom.StateToken())
{
bool spawnAtOrigin = spawningOptions.HasFlag(SpawningOptions.UseGridOrigin);
CreateGridsFromPrefab(resultList, prefabName, MatrixD.CreateWorld(position, forward, up), spawnAtOrigin);
MyCockpit firstCockpit = null;
bool rotateToCockpit = spawningOptions.HasFlag(SpawningOptions.RotateFirstCockpitTowardsDirection);
bool spawnCargo = spawningOptions.HasFlag(SpawningOptions.SpawnRandomCargo);
bool setNeutralOwner = spawningOptions.HasFlag(SpawningOptions.SetNeutralOwner);
bool needsToIterateThroughBlocks = spawnCargo || rotateToCockpit || setNeutralOwner || beaconName != null;
long owner = 0;
if (updateSync && spawningOptions.HasFlag(SpawningOptions.SetNeutralOwner) && resultList.Count != 0)
{
string npcName = "NPC " + MyRandom.Instance.Next(1000, 9999);
var identity = Sync.Players.CreateNewIdentity(npcName);
owner = identity.IdentityId;
}
foreach (var grid in resultList)
{
grid.ClearSymmetries();
if (spawningOptions.HasFlag(SpawningOptions.DisableDampeners))
{
grid.GridSystems.ThrustSystem.DampenersEnabled = false;
}
if ((spawningOptions.HasFlag(SpawningOptions.DisableSave)))
{
grid.Save = false;
}
if (needsToIterateThroughBlocks || spawningOptions.HasFlag(SpawningOptions.TurnOffReactors))
{
ProfilerShort.Begin("Iterate through blocks");
foreach (var block in grid.GetBlocks())
{
if (block.FatBlock is MyCockpit && rotateToCockpit && firstCockpit == null)
{
firstCockpit = (MyCockpit)block.FatBlock;
}
else if (block.FatBlock is MyCargoContainer && spawnCargo)
{
MyCargoContainer container = block.FatBlock as MyCargoContainer;
container.SpawnRandomCargo();
}
else if (block.FatBlock is MyBeacon && beaconName != null)
{
MyBeacon beacon = block.FatBlock as MyBeacon;
beacon.SetCustomName(beaconName);
}
else if (spawningOptions.HasFlag(SpawningOptions.TurnOffReactors) && block.FatBlock is IMyPowerProducer)
{
(block.FatBlock as IMyPowerProducer).Enabled = false;
}
if (setNeutralOwner && block.FatBlock != null && block.BlockDefinition.RatioEnoughForOwnership(block.BuildLevelRatio))
{
block.FatBlock.ChangeOwner(owner, MyOwnershipShareModeEnum.None);
}
}
ProfilerShort.End();
}
}
Matrix transform = default(Matrix);
if (rotateToCockpit)
{
System.Diagnostics.Debug.Assert(firstCockpit != null, "cockpit in prefab ship is missing !");
if (firstCockpit != null)
{
Matrix cockpitTransform = firstCockpit.WorldMatrix;
Matrix cockpitInvertedTransform = Matrix.Invert(cockpitTransform);
transform = Matrix.Multiply(cockpitInvertedTransform, Matrix.CreateWorld(firstCockpit.WorldMatrix.Translation, forward, up));
}
}
foreach (var grid in resultList)
{
if (firstCockpit != null)
{
grid.WorldMatrix = grid.WorldMatrix * transform;
}
if (grid.Physics != null)
{
grid.Physics.LinearVelocity = initialLinearVelocity;
grid.Physics.AngularVelocity = initialAngularVelocity;
}
ProfilerShort.Begin("Add entity");
MyEntities.Add(grid);
ProfilerShort.End();
}
if (updateSync == true)
{
MySyncPrefabManager.SendPrefabSpawned(prefabName, new MyPositionAndOrientation(position, forward, up), initialLinearVelocity, initialAngularVelocity, beaconName, spawningOptions, rngSeed);
}
}
}
public CockpitTerminal(IMyCubeBlock cockpit)
{
this.m_cockpit = (MyCockpit)cockpit;
Registrar.Add(this.m_cockpit, this);
}
private static bool EnergyCritWarningMethod(out MyGuiSounds cue, out MyStringId text)
{
cue = MyGuiSounds.None;
text = MySpaceTexts.Blank;
if (!IsEnergyUnderTreshold(MyBattery.EnergyCriticalThreshold))
{
return(false);
}
if (MySession.Static.ControlledEntity.Entity is MyCharacter || MySession.Static.ControlledEntity == null)
{
cue = MyGuiSounds.HudVocEnergyCrit;
if (MySession.Static.LocalCharacter != null && MySession.Static.LocalCharacter.OxygenComponent != null &&
MySession.Static.LocalCharacter.OxygenComponent.NeedsOxygenFromSuit && MySession.Static.Settings.EnableOxygen)
{
text = MySpaceTexts.NotificationSuitEnergyCriticalNoDamage;
}
else
{
text = MySpaceTexts.NotificationSuitEnergyCritical;
}
}
else if (MySession.Static.ControlledEntity.Entity is MyCockpit)
{
MyCockpit cockpit = (MyCockpit)MySession.Static.ControlledEntity.Entity;
bool hasReactor = false;
List <MyCubeGrid> connectedGroups = MyCubeGridGroups.Static.Logical.GetGroupNodes(cockpit.CubeGrid);
if (connectedGroups == null || connectedGroups.Count == 0)
{
return(false);
}
foreach (var grid in connectedGroups)
{
if (grid.NumberOfReactors > 0)
{
hasReactor = true;
break;
}
}
if (hasReactor)
{
if (cockpit.CubeGrid.IsStatic)
{
cue = MyGuiSounds.HudVocStationFuelCrit;
}
else
{
cue = MyGuiSounds.HudVocShipFuelCrit;
}
}
else
{
return(false);
}
if (MySession.Static.LocalCharacter != null && MySession.Static.LocalCharacter.OxygenComponent != null &&
MySession.Static.LocalCharacter.OxygenComponent.NeedsOxygenFromSuit && MySession.Static.Settings.EnableOxygen)
{
text = MySpaceTexts.NotificationShipEnergyCriticalNoDamage;
}
else
{
text = MySpaceTexts.NotificationShipEnergyCritical;
}
}
else
{
return(false);
}
return(true);
}
private void UpdateOxygen()
{
MyOxygenRoom room;
List <MyEntity> result = new List <MyEntity>();
BoundingBoxD worldAABB = base.Character.PositionComp.WorldAABB;
bool enableOxygen = MySession.Static.Settings.EnableOxygen;
bool noOxygenDamage = MySession.Static.Settings.EnableOxygen;
bool isInEnvironment = true;
bool flag4 = false;
if (!Sync.IsServer)
{
goto TR_000A;
}
else
{
base.Character.EnvironmentOxygenLevelSync.Value = MyOxygenProviderSystem.GetOxygenInPoint(base.Character.PositionComp.GetPosition());
base.Character.OxygenLevelAtCharacterLocation.Value = base.Character.EnvironmentOxygenLevel;
room = null;
if (!MySession.Static.Settings.EnableOxygen)
{
goto TR_000C;
}
else
{
GasData data;
if (this.TryGetGasData(OxygenId, out data))
{
float num = (MySession.Static.GameplayFrameCounter - data.LastOutputTime) * 0.01666667f;
flag4 = (this.CharacterGasSink.CurrentInputByType(OxygenId) * num) > this.Definition.OxygenConsumption;
if (flag4)
{
noOxygenDamage = false;
enableOxygen = false;
}
}
MyCockpit parent = base.Character.Parent as MyCockpit;
bool flag5 = false;
if ((parent != null) && parent.BlockDefinition.IsPressurized)
{
if ((!this.HelmetEnabled && (MySession.Static.SurvivalMode && !flag4)) && (parent.OxygenAmount >= (this.Definition.OxygenConsumption * this.Definition.OxygenConsumptionMultiplier)))
{
parent.OxygenAmount -= this.Definition.OxygenConsumption * this.Definition.OxygenConsumptionMultiplier;
noOxygenDamage = false;
enableOxygen = false;
}
base.Character.EnvironmentOxygenLevelSync.Value = parent.OxygenFillLevel;
isInEnvironment = false;
flag5 = true;
}
if (!flag5 || (MyFakes.ENABLE_NEW_SOUNDS && MySession.Static.Settings.RealisticSound))
{
base.Character.OxygenSourceGridEntityId.Value = 0L;
Vector3D center = base.Character.PositionComp.WorldAABB.Center;
MyGamePruningStructure.GetTopMostEntitiesInBox(ref worldAABB, result, MyEntityQueryType.Both);
using (List <MyEntity> .Enumerator enumerator = result.GetEnumerator())
{
while (true)
{
while (true)
{
if (enumerator.MoveNext())
{
MyCubeGrid current = enumerator.Current as MyCubeGrid;
if (current == null)
{
continue;
}
if (current.GridSystems.GasSystem == null)
{
continue;
}
MyOxygenBlock safeOxygenBlock = current.GridSystems.GasSystem.GetSafeOxygenBlock(center);
if (safeOxygenBlock == null)
{
continue;
}
if (safeOxygenBlock.Room == null)
{
continue;
}
room = safeOxygenBlock.Room;
if ((room.OxygenLevel(current.GridSize) > this.Definition.PressureLevelForLowDamage) && !this.HelmetEnabled)
{
enableOxygen = false;
}
if (!room.IsAirtight)
{
float environmentOxygen = room.EnvironmentOxygen;
base.Character.OxygenLevelAtCharacterLocation.Value = environmentOxygen;
if (flag5)
{
break;
}
base.Character.EnvironmentOxygenLevelSync.Value = environmentOxygen;
if (this.HelmetEnabled)
{
break;
}
if (base.Character.EnvironmentOxygenLevelSync.Value <= (this.Definition.OxygenConsumption * this.Definition.OxygenConsumptionMultiplier))
{
break;
}
noOxygenDamage = false;
}
else
{
float num2 = room.OxygenLevel(current.GridSize);
if (!flag5)
{
base.Character.EnvironmentOxygenLevelSync.Value = num2;
}
base.Character.OxygenLevelAtCharacterLocation.Value = num2;
base.Character.OxygenSourceGridEntityId.Value = current.EntityId;
if (room.OxygenAmount <= (this.Definition.OxygenConsumption * this.Definition.OxygenConsumptionMultiplier))
{
break;
}
if (!this.HelmetEnabled)
{
noOxygenDamage = false;
safeOxygenBlock.PreviousOxygenAmount = safeOxygenBlock.OxygenAmount() - (this.Definition.OxygenConsumption * this.Definition.OxygenConsumptionMultiplier);
safeOxygenBlock.OxygenChangeTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;
if (!flag4)
{
room.OxygenAmount -= this.Definition.OxygenConsumption * this.Definition.OxygenConsumptionMultiplier;
}
}
}
goto TR_000D;
}
else
{
goto TR_000D;
}
break;
}
isInEnvironment = false;
}
}
}
}
}
goto TR_000D;
TR_000A:
this.CharacterGasSink.Update();
if (Sync.IsServer && !MySession.Static.CreativeMode)
{
this.RefillSuitGassesFromBottles();
if (MySession.Static.Settings.EnableOxygen)
{
this.UpdateSuitOxygen(enableOxygen, noOxygenDamage, isInEnvironment);
}
foreach (GasData data2 in this.m_storedGases)
{
base.Character.UpdateStoredGas(data2.Id, data2.FillLevel);
}
}
return;
TR_000C:
this.UpdateGassesFillLevelsAndAmounts(room);
goto TR_000A;
TR_000D:
this.m_oldSuitOxygenLevel = this.SuitOxygenLevel;
goto TR_000C;
}
public void SpawnAtShip(MyPlayer player, string respawnShipId)
{
Debug.Assert(Sync.IsServer, "Spawning can only be called on the server!");
if (!Sync.IsServer)
{
return;
}
ResetRespawnCooldown(player.Id);
if (Sync.MultiplayerActive)
{
SyncCooldownToPlayer(player.Id.SteamId);
}
MyCharacter character = null;
MyCockpit cockpit = null;
List <MyCubeGrid> respawnGrids = new List <MyCubeGrid>();
var respawnShipDef = MyDefinitionManager.Static.GetRespawnShipDefinition(respawnShipId);
Debug.Assert(respawnShipDef != null);
if (respawnShipDef == null)
{
return;
}
var prefabDef = respawnShipDef.Prefab;
Debug.Assert(prefabDef != null);
if (prefabDef == null)
{
return;
}
if (prefabDef.CubeGrids == null)
{
MyDefinitionManager.Static.ReloadPrefabsFromFile(prefabDef.PrefabPath);
prefabDef = MyDefinitionManager.Static.GetPrefabDefinition(prefabDef.Id.SubtypeName);
}
// Deploy ship
Vector3 direction, position;
GetSpawnPosition(prefabDef.BoundingSphere.Radius, out direction, out position);
MyPrefabManager.Static.SpawnPrefab(
respawnGrids,
prefabDef.Id.SubtypeName,
position,
-direction,
Vector3.CalculatePerpendicularVector(-direction),
spawningOptions: Sandbox.ModAPI.SpawningOptions.RotateFirstCockpitTowardsDirection,
updateSync: true);
// Find cockpit
foreach (var grid in respawnGrids)
{
foreach (var block in grid.GetBlocks())
{
if (block.FatBlock is MyCockpit)
{
cockpit = (MyCockpit)block.FatBlock;
break;
}
}
if (cockpit != null)
{
break;
}
}
System.Diagnostics.Debug.Assert(cockpit != null, "character is spawning in ship without cockpit !");
// Create character
Matrix matrix = Matrix.Identity;
if (cockpit != null)
{
matrix = cockpit.WorldMatrix;
matrix.Translation = cockpit.WorldMatrix.Translation - Vector3.Up - Vector3.Forward;
}
else if (respawnGrids.Count > 0)
{
matrix.Translation = respawnGrids[0].PositionComp.WorldAABB.Center + respawnGrids[0].PositionComp.WorldAABB.HalfExtents;
}
character = MyCharacter.CreateCharacter(matrix, Vector3.Zero, player.Identity.DisplayName, player.Identity.Model, null, cockpit: cockpit);
if (cockpit != null)
{
cockpit.AttachPilot(character, false);
}
CloseRespawnShip(player);
foreach (var respawnGrid in respawnGrids)
{
respawnGrid.ChangeGridOwnership(player.Identity.IdentityId, MyOwnershipShareModeEnum.None);
player.RespawnShip.Add(respawnGrid.EntityId);
}
Sync.Players.SetPlayerCharacter(player, character, cockpit);
Sync.Players.RevivePlayer(player);
}
public MySyncCockpit(MyCockpit cockpit) :
base(cockpit)
{
}
