void IMyUseObject.Use(UseActionEnum actionEnum, MyCharacter user)
{
var relation = Block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);
if (relation != Common.MyRelationsBetweenPlayerAndBlock.Owner && relation != Common.MyRelationsBetweenPlayerAndBlock.FactionShare)
{
if (user.ControllerInfo.IsLocallyHumanControlled())
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
return;
}
switch (actionEnum)
{
case UseActionEnum.OpenTerminal:
MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Block);
break;
case UseActionEnum.OpenInventory:
if (Block as IMyInventoryOwner != null)
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
}
break;
}
}
public override void UpdateAfterSimulation10()
{
base.UpdateAfterSimulation10();
if (!MyFakes.ENABLE_REMOTE_CONTROL)
{
return;
}
if (m_previousControlledEntity != null)
{
if (!RemoteIsInRangeAndPlayerHasAccess())
{
RequestRelease(false);
if (MyGuiScreenTerminal.IsOpen && MyGuiScreenTerminal.InteractedEntity == this)
{
MyGuiScreenTerminal.Hide();
}
}
var receiver = GetFirstRadioReceiver();
if (receiver != null)
{
receiver.UpdateHud(true);
}
}
}
void IMyUseObject.Use(UseActionEnum actionEnum, IMyEntity entity)
{
var user = entity as MyCharacter;
var relation = Block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);
if (!relation.IsFriendly())
{
if (user.ControllerInfo.IsLocallyHumanControlled())
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
return;
}
switch (actionEnum)
{
case UseActionEnum.OpenTerminal:
MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Block);
break;
case UseActionEnum.OpenInventory:
if (Block as IMyInventoryOwner != null)
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
}
break;
}
}
public void ShowTerminal(string blockId)
{
var block = m_lowLevelObserver.GetBlockById(blockId);
block.FatBlock.ThrowIfNull("Block has to be functional to show terminal");
MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, Character, block.FatBlock);
}
private void RequestControl()
{
if (!MyFakes.ENABLE_REMOTE_CONTROL)
{
return;
}
//Do not take control if you are already the controller
if (MySession.ControlledEntity == this)
{
return;
}
//Double check because it can be called from toolbar
if (!CanControl())
{
return;
}
if (MyGuiScreenTerminal.IsOpen)
{
MyGuiScreenTerminal.Hide();
}
//Temporary fix to prevent crashes on DS
//This happens when remote control is triggered by a sensor or a timer block
//We need to prevent this from happening at all
if (MySession.ControlledEntity != null)
{
SyncObject.RequestUse(UseActionEnum.Manipulate, MySession.ControlledEntity);
}
}
public override void ShowInventory()
{
if (m_enableShipControl)
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, m_pilot, this);
}
}
public override void Use(UseActionEnum actionEnum, IMyEntity entity)
{
var user = entity as MyCharacter;
var relation = Door.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);
if (!relation.IsFriendly())
{
if (user.ControllerInfo.IsLocallyHumanControlled())
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
return;
}
switch (actionEnum)
{
case UseActionEnum.Manipulate:
Door.SetOpenRequest(!Door.Open, user.ControllerInfo.ControllingIdentityId);
break;
case UseActionEnum.OpenTerminal:
MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Door);
break;
}
}
public void Use(UseActionEnum actionEnum, MyCharacter user)
{
var relation = GetUserRelationToOwner(user.ControllerInfo.Controller.Player.Identity.IdentityId);
if (!relation.IsFriendly())
{
if (user.ControllerInfo.Controller.Player == MySession.LocalHumanPlayer)
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
return;
}
if (actionEnum == UseActionEnum.OpenTerminal)
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, this);
}
else if (actionEnum == UseActionEnum.Manipulate)
{
if (m_user != null && m_user != user)
{
return;
}
SyncObject.RequestUse(actionEnum, user);
}
}
void IMyUseObject.Use(UseActionEnum actionEnum, IMyEntity entity)
{
var user = entity as MyCharacter;
var relation = Door.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);
if (relation != Common.MyRelationsBetweenPlayerAndBlock.Owner && relation != Common.MyRelationsBetweenPlayerAndBlock.FactionShare)
{
if (user.ControllerInfo.IsLocallyHumanControlled())
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
return;
}
switch (actionEnum)
{
case UseActionEnum.Manipulate:
Door.SetOpenRequest(!Door.Open, user.ControllerInfo.ControllingIdentityId);
break;
case UseActionEnum.OpenTerminal:
MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Door);
break;
}
}
public void Use(UseActionEnum actionEnum, MyCharacter user)
{
var relation = GetUserRelationToOwner(user.ControllerInfo.Controller.Player.Identity.IdentityId);
var player = MyPlayer.GetPlayerFromCharacter(user);
if (!(relation.IsFriendly() || (player != null && MySession.Static.IsUserSpaceMaster(player.Client.SteamUserId))))
{
if (user.ControllerInfo.Controller.Player == MySession.Static.LocalHumanPlayer)
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
return;
}
if (actionEnum == UseActionEnum.OpenTerminal)
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, this);
}
else if (actionEnum == UseActionEnum.Manipulate)
{
if (m_user != null && m_user != user)
{
return;
}
MyMultiplayer.RaiseEvent(this, x => x.RequestUse, actionEnum, user.EntityId);
}
}
void IMyUseObject.Use(UseActionEnum actionEnum, IMyEntity entity)
{
var user = entity as MyCharacter;
var relation = Block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);
if (relation != Sandbox.Common.MyRelationsBetweenPlayerAndBlock.Owner && relation != Sandbox.Common.MyRelationsBetweenPlayerAndBlock.FactionShare)
{
if (user.ControllerInfo.IsLocallyHumanControlled())
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
return;
}
switch (actionEnum)
{
case UseActionEnum.OpenInventory:
case UseActionEnum.OpenTerminal:
MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
break;
default:
//MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
break;
}
}
public override void Use(UseActionEnum actionEnum, IMyEntity entity)
{
var user = entity as MyCharacter;
var block = Entity as MyCubeBlock;
if (block != null)
{
var relation = block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);
if (!relation.IsFriendly())
{
if (user.ControllerInfo.IsLocallyHumanControlled())
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
return;
}
}
switch (actionEnum)
{
case UseActionEnum.OpenInventory:
case UseActionEnum.OpenTerminal:
MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Entity);
break;
default:
//MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
break;
}
}
public override void Use(UseActionEnum actionEnum, IMyEntity entity)
{
var user = entity as MyCharacter;
var relation = Block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);
if (!relation.IsFriendly() && !MySession.Static.AdminSettings.HasFlag(AdminSettingsEnum.UseTerminals))
{
if (user.ControllerInfo.IsLocallyHumanControlled())
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
return;
}
switch (actionEnum)
{
case UseActionEnum.OpenTerminal:
MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Block);
break;
case UseActionEnum.OpenInventory:
if (Block.GetInventory(0) as MyInventory != null)
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Block);
}
break;
}
}
static object GetItemInControlPanel()
{
if (MyGuiScreenTerminal.GetCurrentScreen() == MyTerminalPageEnum.ControlPanel)
{
return(MyGuiScreenTerminal.InteractedEntity);
}
return(null);
}
void Write(BitStream stream)
{
// TODO: Make sure sleeping, server controlled entities are not moving locally (or they can be but eventually their position should be corrected)
stream.WriteBool(MySession.ControlledEntity != null);
if (MySession.ControlledEntity == null)
{
Vector3D pos = MySpectatorCameraController.Static.Position;
stream.WriteDouble(pos.X);
stream.WriteDouble(pos.Y);
stream.WriteDouble(pos.Z);
}
else
{
var controlledEntity = MySession.ControlledEntity.Entity.GetTopMostParent();
// Send controlled entity every other frame to server
if (MyMultiplayer.Static.FrameCounter % 2 == 0)
{
// TODO: Write additional client data, context
if (controlledEntity != null && controlledEntity.SyncFlag && ((MySyncEntity)controlledEntity.SyncObject).ResponsibleForUpdate(Sync.Clients.LocalClient))
{
stream.WriteInt64(controlledEntity.EntityId);
switch (MyGuiScreenTerminal.GetCurrentScreen())
{
case MyTerminalPageEnum.Inventory:
stream.WriteInt32((int)MyContextKind.Inventory, 2);
break;
case MyTerminalPageEnum.ControlPanel:
stream.WriteInt32((int)MyContextKind.Terminal, 2);
break;
case MyTerminalPageEnum.Production:
stream.WriteInt32((int)MyContextKind.Production, 2);
break;
default:
stream.WriteInt32((int)MyContextKind.None, 2);
break;
}
if (MyGuiScreenTerminal.InteractedEntity != null)
{
stream.WriteInt64(MyGuiScreenTerminal.InteractedEntity.EntityId);
}
else
{
stream.WriteInt64(0);
}
((MySyncEntity)controlledEntity.SyncObject).SerializePhysics(stream, null);
}
}
}
}
private void OnOwnerUse(UseActionEnum actionEnum, MyCharacter user)
{
if (actionEnum == UseActionEnum.Manipulate)
{
OpenWindow(true, true, false);
}
else if (actionEnum == UseActionEnum.OpenTerminal)
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, this);
}
}
protected override void WriteInternal(BitStream stream, MyEntity controlledEntity)
{
MyContextKind context = GetContextByPage(MyGuiScreenTerminal.GetCurrentScreen());
stream.WriteInt32((int)context, 2);
if (context != MyContextKind.None)
{
var entityId = MyGuiScreenTerminal.InteractedEntity != null ? MyGuiScreenTerminal.InteractedEntity.EntityId : 0;
stream.WriteInt64(entityId);
}
}
protected override void WriteInternal(BitStream stream, MyEntity controlledEntity)
{
MyContextKind contextByPage = GetContextByPage(MyGuiScreenTerminal.GetCurrentScreen());
stream.WriteInt32((int)contextByPage, 2);
if (contextByPage != MyContextKind.None)
{
long value = (MyGuiScreenTerminal.InteractedEntity != null) ? MyGuiScreenTerminal.InteractedEntity.EntityId : 0L;
stream.WriteInt64(value, 64);
}
}
public override void ShowInventory()
{
base.ShowInventory();
if (m_enableShipControl)
{
var user = GetUser();
if (user != null)
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, this);
}
}
}
public void SelectBlueprint()
{
if (MyGuiScreenTerminal.IsOpen)
{
MyGuiScreenTerminal.Hide();
}
RemoveProjection(false);
var blueprintScreen = new MyGuiBlueprintScreen(m_clipboard);
blueprintScreen.Closed += OnBlueprintScreen_Closed;
MyGuiSandbox.AddScreen(blueprintScreen);
}
protected override void OnUpdate()
{
if (_available)
{
var screen = MyGuiScreenTerminal.GetCurrentScreen();
if (screen != _currentScreen)
{
_currentScreen = screen;
OnScreenChanged(screen);
}
}
base.OnUpdate();
}
public void RequestSetView()
{
if (IsWorking)
{
MyHud.Notifications.Remove(m_hudNotification);
MyHud.Notifications.Add(m_hudNotification);
CubeGrid.GridSystems.CameraSystem.SetAsCurrent(this);
SetView();
if (MyGuiScreenTerminal.IsOpen)
{
MyGuiScreenTerminal.Hide();
}
}
}
private void Grab()
{
if (MyAPIGateway.Session.ControlledObject != null && MyGuiScreenTerminal.GetCurrentScreen() == MyTerminalPageEnum.None && MyGuiScreenGamePlay.ActiveGameplayScreen == null)
{
if (grabber.TryGrabNew(5))
{
var packet = new List <byte>();
packet.AddRange(BitConverter.GetBytes(true));
packet.AddRange(BitConverter.GetBytes(MyAPIGateway.Session.Player.IdentityId));
MyAPIGateway.Multiplayer.SendMessageToOthers(HANDLER_ID, packet.ToArray());
grabbed = true;
}
}
}
private void OnFactionUse(UseActionEnum actionEnum, MyCharacter user)
{
bool isAccessible = IsAccessibleForFaction;
bool readOnlyNotification = false;
if (IsAccessibleForFaction)
{
if (actionEnum == UseActionEnum.Manipulate)
{
if (IsWritableForFaction)
{
OpenWindow(true, true, false);
}
else if (IsReadableForFaction)
{
OpenWindow(false, true, false);
}
else
{
Debug.Fail("Unknown state of text panel");
}
}
else if (actionEnum == UseActionEnum.OpenTerminal)
{
if (IsWritableForFaction)
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, this);
}
else
{
readOnlyNotification = true;
}
}
}
if (user.ControllerInfo.Controller.Player == MySession.LocalHumanPlayer)
{
if (!isAccessible)
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
else if (readOnlyNotification)
{
MyHud.Notifications.Add(MyNotificationSingletons.TextPanelReadOnly);
}
}
}
public override void Use(UseActionEnum actionEnum, IMyEntity entity)
{
var user = entity as MyCharacter;
var block = Entity as MyCubeBlock;
if (block != null)
{
var relation = block.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId);
if (!relation.IsFriendly())
{
if (user.ControllerInfo.IsLocallyHumanControlled())
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
return;
}
}
//by Gregory: on use action the button pressed should be checked because on use action we will always get only Inventory TODO: refactor somehow
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.TERMINAL))
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, Entity);
}
else
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Entity);
}
/*
* switch (actionEnum)
* {
* case UseActionEnum.OpenInventory:
* MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Entity);
* break;
* case UseActionEnum.OpenTerminal:
* MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Entity);
* break;
* default:
* //MyGuiScreenTerminal.Show(MyTerminalPageEnum.Inventory, user, Entity);
* break;
* }
*/
}
private bool OpenPropertiesByEntityId(long entityId)
{
MyEntity openTerminalEntity;
MyEntities.TryGetEntityById(entityId, out openTerminalEntity);
//rule: When you want to open character terminal you pass null as interactedEntity
if (openTerminalEntity is MyCharacter)
{
MyGuiScreenTerminal.ChangeInteractedEntity(null);
return(true);
}
//grid = null -> has been destroyed or something like that
if (openTerminalEntity != null && openTerminalEntity is MyCubeGrid)
{
var grid = openTerminalEntity as MyCubeGrid;
m_tempSendingToGrid.Clear();
m_tempReceivingFromGrid.Clear();
GridBroadcastersFromPlayer(grid, m_tempSendingToGrid);
PlayerBroadcastersFromGrid(grid, m_tempReceivingFromGrid);
if ((m_tempSendingToGrid.Count > 0 && m_tempReceivingFromGrid.Count > 0) || m_openInventoryInteractedEntityRepresentative == grid)
{
//This will only happen when you have a grid with no radio connection, in which case the entity itself is the only available option
if (m_tempReceivingFromGrid.Count <= 0)
{
MyGuiScreenTerminal.ChangeInteractedEntity(MyGuiScreenTerminal.InteractedEntity);
}
//pick the first antenna from cube grid to switch (could've been any one anyways)
else
{
MyGuiScreenTerminal.ChangeInteractedEntity(m_tempReceivingFromGrid.ElementAt(0).Entity as MyTerminalBlock);
}
return(true);
}
}
//Else throw an alert to the user saying "ship has been disconnected" or something?
return(false);
}
private static void ShowError(MyStringId errorText, IMyGuiControlsParent controlsParent)
{
foreach (var control in controlsParent.Controls)
{
control.Visible = false;
}
var label = (MyGuiControlLabel)controlsParent.Controls.GetControlByName("ErrorMessage");
if (label == null)
{
label = MyGuiScreenTerminal.CreateErrorLabel(errorText, "ErrorMessage");
}
label.TextEnum = errorText;
if (!controlsParent.Controls.Contains(label))
{
controlsParent.Controls.Add(label);
}
}
/// <summary>
/// Updates positions & orientations
/// </summary>
public void Update1()
{
if (!Enabled || !m_playerCanSee)
{
foreach (SeenHolo sh in m_holoEntities.Values)
{
if (sh.Holo.Render.Visible)
{
Log.DebugLog("hiding holo: " + sh.Seen.Entity.getBestName());
SetVisible(sh.Holo, false);
}
}
return;
}
if (MyGuiScreenTerminal.GetCurrentScreen() == MyTerminalPageEnum.None && MyAPIGateway.Session.ControlledObject.Entity is IMyCharacter && Static.MouseControls)
{
CheckInput();
}
PositionWorld projectionCentre = m_offset.ToWorld(m_block);
float distanceScale = m_radiusHolo / m_rangeDetection;
float sizeScale = distanceScale * m_sizeDistScale;
foreach (SeenHolo sh in m_holoEntities.Values)
{
MatrixD worldMatrix = sh.Seen.Entity.WorldMatrix;
worldMatrix.Translation = projectionCentre + (sh.Seen.Entity.GetPosition() - m_centreEntity.GetPosition()) * distanceScale + (sh.Seen.Entity.GetPosition() - sh.Seen.Entity.GetCentre()) * (sizeScale - distanceScale);
Log.DebugLog("entity: " + sh.Seen.Entity.getBestName() + "(" + sh.Seen.Entity.EntityId + "), centre: " + projectionCentre + ", offset: " + (worldMatrix.Translation - projectionCentre) + ", position: " + worldMatrix.Translation);
sh.Holo.PositionComp.SetWorldMatrix(worldMatrix);
sh.Holo.PositionComp.Scale = sizeScale;
}
if (ShowBoundary)
{
MatrixD sphereMatrix = m_block.WorldMatrix;
sphereMatrix.Translation = projectionCentre;
Color c = Color.Yellow;
MySimpleObjectDraw.DrawTransparentSphere(ref sphereMatrix, m_radiusHolo, ref c, MySimpleObjectRasterizer.Wireframe, 8);
}
}
public override void Use(UseActionEnum actionEnum, IMyEntity entity)
{
MyCharacter user = entity as MyCharacter;
if (!this.Door.GetUserRelationToOwner(user.ControllerInfo.ControllingIdentityId).IsFriendly() && !MySession.Static.AdminSettings.HasFlag(AdminSettingsEnum.UseTerminals))
{
if (user.ControllerInfo.IsLocallyHumanControlled())
{
MyHud.Notifications.Add(MyNotificationSingletons.AccessDenied);
}
}
else if (actionEnum == UseActionEnum.Manipulate)
{
this.Door.SetOpenRequest(!this.Door.Open, user.ControllerInfo.ControllingIdentityId);
}
else if (actionEnum == UseActionEnum.OpenTerminal)
{
MyGuiScreenTerminal.Show(MyTerminalPageEnum.ControlPanel, user, this.Door);
}
}
public void SetView()
{
if (!MyFakes.ENABLE_CAMERA_BLOCK)
{
return;
}
if (MySession.Static.CameraController is MyCameraBlock)
{
var oldCamera = MySession.Static.CameraController as MyCameraBlock;
oldCamera.IsActive = false;
}
MySession.SetCameraController(MyCameraControllerEnum.Entity, this);
if (MyGuiScreenTerminal.IsOpen)
{
MyGuiScreenTerminal.Hide();
}
SetFov(m_fov);
IsActive = true;
}
