protected override bool Act(TimeSpan elapsed)
{
Vector3 vector3_1 = FezMath.RightVector(this.CameraManager.Viewpoint) * (float)FezMath.Sign(this.PlayerManager.LookingDirection);
float num = (float)(4.0 * (this.LevelManager.Descending ? -1.0 : 1.0)) / this.CameraManager.PixelsPerTrixel;
Vector3 vector3_2 = this.PlayerManager.HeldInstance.Center + (-vector3_1 + Vector3.UnitY * (float)Math.Sign(this.CollisionManager.GravityFactor)) * this.PlayerManager.HeldInstance.TransformedSize / 2f + this.gomezDelta + num * Vector3.UnitY;
if (!this.CameraManager.StickyCam && !this.CameraManager.Constrained)
{
this.CameraManager.Center = Vector3.Lerp(this.camOrigin, vector3_2, this.PlayerManager.Animation.Timing.NormalizedStep);
}
this.PlayerManager.SplitUpCubeCollectorOffset = this.gomezDelta * this.PlayerManager.Animation.Timing.NormalizedStep;
this.PlayerManager.Position = this.PlayerManager.HeldInstance.Center + (-vector3_1 + Vector3.UnitY * (float)Math.Sign(this.CollisionManager.GravityFactor)) * this.PlayerManager.HeldInstance.TransformedSize / 2f;
if (this.PlayerManager.Animation.Timing.Ended)
{
this.PlayerManager.Position += this.gomezDelta;
this.PlayerManager.HeldInstance = (TrileInstance)null;
this.PlayerManager.SplitUpCubeCollectorOffset = Vector3.Zero;
this.PhysicsManager.DetermineInBackground((IPhysicsEntity)this.PlayerManager, !this.PlayerManager.IsOnRotato, true, !this.PlayerManager.Climbing);
this.PlayerManager.Position += 0.5f * Vector3.UnitY * (float)Math.Sign(this.CollisionManager.GravityFactor);
IPlayerManager playerManager = this.PlayerManager;
Vector3 vector3_3 = playerManager.Velocity - Vector3.UnitY * (float)Math.Sign(this.CollisionManager.GravityFactor);
playerManager.Velocity = vector3_3;
this.PhysicsManager.Update((IComplexPhysicsEntity)this.PlayerManager);
this.PlayerManager.Action = ActionType.Idle;
}
return(true);
}
private void DoJump()
{
bool flag = ActionTypeExtensions.IsClimbingLadder(this.PlayerManager.LastAction) || ActionTypeExtensions.IsClimbingVine(this.PlayerManager.LastAction) || this.PlayerManager.HeldInstance != null;
if (flag)
{
IPlayerManager playerManager = this.PlayerManager;
Vector3 vector3 = playerManager.Velocity + FezMath.RightVector(this.CameraManager.Viewpoint) * this.InputManager.Movement.X * 0.25f;
playerManager.Velocity = vector3;
}
this.PlayerManager.HeldInstance = (TrileInstance)null;
if (this.scheduleJump || this.InputManager.Jump == FezButtonState.Pressed)
{
SoundEffectExtensions.EmitAt(this.jumpSound, this.PlayerManager.Position);
}
float gravityFactor = this.CollisionManager.GravityFactor;
float num = (float)((1.32500004768372 + (double)Math.Abs(gravityFactor) * 0.675000011920929) / 2.0) * (float)Math.Sign(gravityFactor);
IPlayerManager playerManager1 = this.PlayerManager;
Vector3 vector3_1 = playerManager1.Velocity * FezMath.XZMask;
playerManager1.Velocity = vector3_1;
Vector3 vector3_2 = (float)(0.150000005960464 * (double)num * 1.02499997615814 * (flag || this.PlayerManager.Swimming ? 0.774999976158142 : 1.0)) * Vector3.UnitY;
IPlayerManager playerManager2 = this.PlayerManager;
Vector3 vector3_3 = playerManager2.Velocity + vector3_2;
playerManager2.Velocity = vector3_3;
this.sinceJumped = TimeSpan.Zero;
this.GomezService.OnJump();
}
/// <summary>
/// Sets the audio signal to the most plausible player. This is the audio player, if present, else it is the
/// primary video player, if present.
/// </summary>
protected static void CheckAudio()
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
lock (playerManager.SyncObj)
{
if (playerManager.AudioSlotIndex != -1)
{
return;
}
IPlayer primaryPlayer = playerManager[PlayerManagerConsts.PRIMARY_SLOT];
IPlayer secondaryPlayer = playerManager[PlayerManagerConsts.SECONDARY_SLOT];
if (primaryPlayer is IAudioPlayer)
{
playerManager.AudioSlotIndex = PlayerManagerConsts.PRIMARY_SLOT;
}
else if (secondaryPlayer is IAudioPlayer)
{
playerManager.AudioSlotIndex = PlayerManagerConsts.SECONDARY_SLOT;
}
else if (primaryPlayer is IVideoPlayer)
{
playerManager.AudioSlotIndex = PlayerManagerConsts.PRIMARY_SLOT;
}
else if (secondaryPlayer is IVideoPlayer)
{
playerManager.AudioSlotIndex = PlayerManagerConsts.SECONDARY_SLOT;
}
else
{
playerManager.AudioSlotIndex = PlayerManagerConsts.PRIMARY_SLOT;
}
}
}
protected void CheckCurrentPlayerSlot()
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
IPlayerSlotController primaryPSC = playerManager.GetPlayerSlotController(PlayerManagerConsts.PRIMARY_SLOT);
IPlayerSlotController secondaryPSC = playerManager.GetPlayerSlotController(PlayerManagerConsts.SECONDARY_SLOT);
lock (playerManager.SyncObj)
{
bool primaryPlayerActive = primaryPSC.IsActive;
bool secondaryPlayerActive = secondaryPSC.IsActive;
int currentPlayerIndex = _currentPlayerIndex;
if (currentPlayerIndex == PlayerManagerConsts.PRIMARY_SLOT && !primaryPlayerActive)
{
currentPlayerIndex = -1;
}
else if (currentPlayerIndex == PlayerManagerConsts.SECONDARY_SLOT && !secondaryPlayerActive)
{
currentPlayerIndex = -1;
}
if (currentPlayerIndex == -1)
{
if (primaryPlayerActive)
{
currentPlayerIndex = PlayerManagerConsts.PRIMARY_SLOT;
}
}
CurrentPlayerIndex = currentPlayerIndex;
}
}
protected void HandlePlayerRolesChanged(int newCurrentPlayerIndex, int newAudioPlayerIndex)
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
CurrentPlayerIndex = newCurrentPlayerIndex;
playerManager.AudioSlotIndex = newAudioPlayerIndex;
}
private void Start()
{
gameManager = interfaceFactory.GameManager;
globeManager = interfaceFactory.GlobeManager;
errorHandler = interfaceFactory.ErrorHandler;
if (gameManager == null || globeManager == null || errorHandler == null)
{
gameObject.SetActive(false);
}
else
{
worldMapGlobe = globeManager.WorldMapGlobe;
if (worldMapGlobe == null)
{
errorHandler.ReportError("World Map Globe missing", ErrorState.restart_scene);
}
playerManager = gameManager.PlayerManager;
if (playerManager == null)
{
errorHandler.ReportError("Player Manager missing", ErrorState.restart_scene);
}
SetGlobeSettings();
started = true;
}
}
public override IPlayerSlotController PrepareVideoPlayerSlotController(IPlayerManager playerManager, PlayerContextManager playerContextManager,
PlayerContextConcurrencyMode concurrencyMode, out bool makePrimaryPlayer, out int audioPlayerSlotIndex, out int currentPlayerSlotIndex)
{
int numActive = playerContextManager.NumActivePlayerContexts;
switch (concurrencyMode)
{
case PlayerContextConcurrencyMode.ConcurrentVideo:
IList<IPlayerContext> playerContexts = playerContextManager.PlayerContexts;
if (numActive >= 1 && playerContexts[PlayerContextIndex.PRIMARY].AVType == AVType.Video)
{ // The primary slot is a video player slot
IPlayerSlotController result;
if (numActive == 1)
{
result = playerManager.OpenSlot();
makePrimaryPlayer = true;
}
else // numActive > 1
{
IPlayerContext pc = playerContexts[PlayerContextIndex.PRIMARY];
result = pc.Revoke(); // Necessary to revoke the player context to disable the auto close function (pc.CloseWhenFinished)
makePrimaryPlayer = true;
}
audioPlayerSlotIndex = PlayerContextIndex.PRIMARY;
currentPlayerSlotIndex = PlayerContextIndex.PRIMARY;
return result;
}
break;
}
// All other cases are handled the same as in the default player open strategy
return base.PrepareVideoPlayerSlotController(playerManager, playerContextManager, concurrencyMode, out makePrimaryPlayer,
out audioPlayerSlotIndex, out currentPlayerSlotIndex);
}
public virtual void PrepareAudioPlayer(IPlayerManager playerManager, IList <IPlayerContext> playerContexts, bool concurrentVideo, Guid mediaModuleId,
out IPlayerSlotController slotController, ref int audioSlotIndex, ref int currentPlayerIndex)
{
if (concurrentVideo)
{
int numActive = playerManager.NumActiveSlots;
// Solve conflicts - close conflicting slots
if (numActive > 1)
{
playerManager.CloseSlot(PlayerManagerConsts.SECONDARY_SLOT);
}
IPlayerContext pc;
if (numActive > 0 && (pc = playerContexts[PlayerManagerConsts.PRIMARY_SLOT]) != null && pc.AVType == AVType.Audio)
{
playerManager.CloseSlot(PlayerManagerConsts.PRIMARY_SLOT);
}
}
else // !concurrentVideo
// Don't enable concurrent controllers: Close all except the primary slot controller
{
playerManager.CloseAllSlots();
}
// Open new slot
int slotIndex;
playerManager.OpenSlot(out slotIndex, out slotController);
audioSlotIndex = slotController.SlotIndex;
currentPlayerIndex = slotIndex;
}
/// <inheritdoc />
public void Execute(ICommandContext context)
{
if (context.Parameters.Length == 0)
{
throw new CommandWrongUsageException();
}
IPlayerManager playerManager = context.Container.Resolve <IPlayerManager>("eco");
if (playerManager.TryGetOnlinePlayer(context.Parameters[0], out IPlayer player))
{
((EcoPlayer)player).User.SendMessage("You have been stripped of your administator permissions.");
}
else
{
player = playerManager.GetPlayer(context.Parameters[0]);
}
if (player is EcoPlayer ecoPlayer && ecoPlayer.UserIdType == UserIdType.Both)
{
UserManager.Config.Admins.Remove(ecoPlayer.InternalEcoUser.SteamId);
}
UserManager.Config.Admins.Remove(player.Id);
UserManager.Obj.SaveConfig();
context.User.SendMessage("The requested user has been removed as an administrator.");
}
public void Destroy()
{
Destroy(Object);
Destroy(gameObject);
Statistic = null;
Instance = null;
}
public override void PrepareVideoPlayer(IPlayerManager playerManager, IList<IPlayerContext> playerContexts, PlayerContextConcurrencyMode concurrencyMode, Guid mediaModuleId,
out IPlayerSlotController slotController, ref int audioSlotIndex, ref int currentPlayerIndex)
{
int numActive = playerContexts.Count;
switch (concurrencyMode)
{
case PlayerContextConcurrencyMode.ConcurrentVideo:
if (numActive >= 1 && playerContexts[0].AVType == AVType.Video)
{ // The primary slot is a video player slot
if (numActive == 1)
{
int slotIndex;
playerManager.OpenSlot(out slotIndex, out slotController);
playerManager.SwitchSlots();
}
else // numActive > 1
{
IPlayerContext pc = playerContexts[0];
pc.Reset(); // Necessary to reset the player context to disable the auto close function (pc.CloseWhenFinished)
playerManager.ResetSlot(PlayerManagerConsts.PRIMARY_SLOT, out slotController);
}
audioSlotIndex = PlayerManagerConsts.PRIMARY_SLOT;
currentPlayerIndex = PlayerManagerConsts.PRIMARY_SLOT;
return;
}
break;
}
// All other cases are the same as in the default player open strategy
base.PrepareVideoPlayer(playerManager, playerContexts, concurrencyMode, mediaModuleId, out slotController, ref audioSlotIndex, ref currentPlayerIndex);
}
protected override bool Act(TimeSpan elapsed)
{
this.sinceJumped += elapsed;
if (this.scheduleJump && this.sinceJumped.TotalMilliseconds >= 60.0)
{
this.DoJump();
this.scheduleJump = false;
}
if (this.PlayerManager.Grounded)
{
WalkRun.MovementHelper.Update((float)elapsed.TotalSeconds);
}
else if (this.InputManager.Jump == FezButtonState.Down)
{
float num1 = this.sinceJumped.TotalSeconds < 0.25 ? 0.6f : 0.0f;
float gravityFactor = this.CollisionManager.GravityFactor;
float num2 = (float)((1.20000004768372 + (double)Math.Abs(gravityFactor) * 0.800000011920929) / 2.0) * (float)Math.Sign(gravityFactor);
Vector3 vector3_1 = (float)(elapsed.TotalSeconds * (double)num1 * (double)num2 * 1.02499997615814 / 2.0) * Vector3.UnitY;
IPlayerManager playerManager = this.PlayerManager;
Vector3 vector3_2 = playerManager.Velocity + vector3_1;
playerManager.Velocity = vector3_2;
}
if (((double)this.CollisionManager.GravityFactor < 0.0 ? ((double)this.PlayerManager.Velocity.Y >= 0.0 ? 1 : 0) : ((double)this.PlayerManager.Velocity.Y <= 0.0 ? 1 : 0)) != 0 && !this.PlayerManager.Grounded && !this.scheduleJump)
{
this.PlayerManager.Action = ActionType.Falling;
}
return(true);
}
private void CorrectWallOverlap(bool overcompensate)
{
foreach (PointCollision pointCollision in this.PlayerManager.CornerCollision)
{
TrileInstance trileInstance = pointCollision.Instances.Deep;
if (trileInstance != null && trileInstance != this.PlayerManager.CarriedInstance && trileInstance.GetRotatedFace(this.CameraManager.VisibleOrientation) == CollisionType.AllSides)
{
Vector3 vector = (pointCollision.Point - trileInstance.Center + FezMath.Sign(this.PlayerManager.Position - pointCollision.Point) * trileInstance.TransformedSize / 2f) * FezMath.SideMask(this.CameraManager.Viewpoint);
this.PlayerManager.Position -= vector;
if (overcompensate)
{
this.PlayerManager.Position -= FezMath.Sign(vector) * (1.0 / 1000.0) * 2f;
}
if (!(FezMath.Sign(this.PlayerManager.Velocity) == FezMath.Sign(vector)))
{
break;
}
Vector3 vector3_1 = FezMath.Abs(FezMath.Sign(vector));
this.PlayerManager.Position -= this.PlayerManager.Velocity * vector3_1;
IPlayerManager playerManager = this.PlayerManager;
Vector3 vector3_2 = playerManager.Velocity * (Vector3.One - vector3_1);
playerManager.Velocity = vector3_2;
break;
}
}
}
public DebugParticlesCommand(ChatCommandManager chatCommandManager, Game game)
: base(chatCommandManager, game)
{
_logger = LoggerProvider.GetLogger();
_playerManager = game.PlayerManager;
_game = game;
}
public GMCorners(IRule r, IBoardManager b, IPlayerManager p)
{
rule = r;
playerManager = p;
boardManager = b;
Endgame = false;
}
//TODO: Think about a factory for this
public DebugCoordsPanel(IPlayerManager playerMan,
IEyeManager eyeMan,
IInputManager inputMan,
IStateManager stateMan,
IClyde displayMan,
IMapManager mapMan)
{
playerManager = playerMan;
eyeManager = eyeMan;
inputManager = inputMan;
stateManager = stateMan;
_displayManager = displayMan;
_mapManager = mapMan;
SizeFlagsHorizontal = SizeFlags.None;
contents = new Label
{
FontColorShadowOverride = Color.Black,
};
AddChild(contents);
PanelOverride = new StyleBoxFlat
{
BackgroundColor = new Color(67, 105, 255, 138),
ContentMarginLeftOverride = 5,
ContentMarginTopOverride = 5
};
MouseFilter = contents.MouseFilter = MouseFilterMode.Ignore;
}
public static bool LocalPlayerHasState(IPlayerManager pm, bool critical, bool dead, IEntityManager?entities = null)
{
if (pm.LocalPlayer?.ControlledEntity is not {
Valid : true
} player)
{
return(false);
}
IoCManager.Resolve(ref entities);
if (entities.TryGetComponent <MobStateComponent?>(player, out var mobState))
{
if (critical)
{
if (mobState.IsCritical())
{
return(true);
}
}
if (dead)
{
if (mobState.IsDead())
{
return(true);
}
}
}
return(false);
}
private void RotateViewRight()
{
bool flag = this.PlayerManager.Action == ActionType.GrabTombstone;
if (this.CameraManager.Viewpoint == Viewpoint.Perspective || this.GameState.InMap)
{
this.CameraManager.OriginalDirection = Vector3.Transform(this.CameraManager.OriginalDirection, Quaternion.CreateFromAxisAngle(Vector3.Up, 1.570796f));
if (!this.GameState.InMenuCube && !this.GameState.InMap)
{
this.EmitRight();
}
}
else if (this.CameraManager.ChangeViewpoint(FezMath.GetRotatedView(this.CameraManager.Viewpoint, 1), (flag ? 2f : 1f) * Math.Abs(1f / this.CollisionManager.GravityFactor)) && !flag)
{
this.EmitRight();
}
if (this.LevelManager.NodeType != LevelNodeType.Lesser || !(this.PlayerManager.AirTime != TimeSpan.Zero))
{
return;
}
IPlayerManager playerManager = this.PlayerManager;
Vector3 vector3 = playerManager.Velocity * FezMath.ScreenSpaceMask(this.CameraManager.Viewpoint);
playerManager.Velocity = vector3;
}
public SettlementTest()
{
playerManager = new PlayerManager();
drawManager = new DrawManager(playerManager);
drawDate = DateTime.Now;
drawManager.CreateDraw(drawDate);
}
public bool SetAudioStream(AudioStreamDescriptor stream)
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
IPlayerContext playerContext = stream.PlayerContext;
lock (playerManager.SyncObj)
{
if (!playerContext.IsActive)
{
return(false);
}
IPlayer player = playerContext.CurrentPlayer;
if (player == null || player.Name != stream.PlayerName)
{
return(false);
}
IVideoPlayer videoPlayer = player as IVideoPlayer;
if (videoPlayer != null)
{
videoPlayer.SetAudioStream(stream.AudioStreamName);
}
playerManager.AudioSlotController = playerContext.PlayerSlotController;
return(true);
}
}
public override IPlayerSlotController PrepareVideoPlayerSlotController(IPlayerManager playerManager, PlayerContextManager playerContextManager,
PlayerContextConcurrencyMode concurrencyMode, out bool makePrimaryPlayer, out int audioPlayerSlotIndex, out int currentPlayerSlotIndex)
{
int numActive = playerContextManager.NumActivePlayerContexts;
switch (concurrencyMode)
{
case PlayerContextConcurrencyMode.ConcurrentVideo:
IList <IPlayerContext> playerContexts = playerContextManager.PlayerContexts;
if (numActive >= 1 && playerContexts[PlayerContextIndex.PRIMARY].AVType == AVType.Video)
{ // The primary slot is a video player slot
IPlayerSlotController result;
if (numActive == 1)
{
result = playerManager.OpenSlot();
makePrimaryPlayer = true;
}
else // numActive > 1
{
IPlayerContext pc = playerContexts[PlayerContextIndex.PRIMARY];
result = pc.Revoke(); // Necessary to revoke the player context to disable the auto close function (pc.CloseWhenFinished)
makePrimaryPlayer = true;
}
audioPlayerSlotIndex = PlayerContextIndex.PRIMARY;
currentPlayerSlotIndex = PlayerContextIndex.PRIMARY;
return(result);
}
break;
}
// All other cases are handled the same as in the default player open strategy
return(base.PrepareVideoPlayerSlotController(playerManager, playerContextManager, concurrencyMode, out makePrimaryPlayer,
out audioPlayerSlotIndex, out currentPlayerSlotIndex));
}
protected void Update()
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
IsMuted = playerManager.Muted;
Volume = playerManager.Volume;
}
public static bool LocalPlayerHasState(IPlayerManager pm, bool critical, bool dead)
{
var playerEntity = pm.LocalPlayer?.ControlledEntity;
if (playerEntity == null)
{
return(false);
}
if (playerEntity.TryGetComponent <IMobStateComponent>(out var mobState))
{
if (critical)
{
if (mobState.IsCritical())
{
return(true);
}
}
if (dead)
{
if (mobState.IsDead())
{
return(true);
}
}
}
return(false);
}
protected override bool Act(TimeSpan elapsed)
{
Vector3 vector3_1 = this.PlayerManager.Size.Y / 2f * Vector3.UnitY * (float)Math.Sign(this.CollisionManager.GravityFactor);
if (this.PlayerManager.HeldInstance.PhysicsState != null)
{
this.PlayerManager.Position += this.PlayerManager.HeldInstance.PhysicsState.Velocity;
this.camOrigin += this.PlayerManager.HeldInstance.PhysicsState.Velocity;
}
if (!this.CameraManager.StickyCam && !this.CameraManager.Constrained)
{
this.CameraManager.Center = Vector3.Lerp(this.camOrigin, this.camOrigin + vector3_1, this.PlayerManager.Animation.Timing.NormalizedStep);
}
this.PlayerManager.SplitUpCubeCollectorOffset = vector3_1 * this.PlayerManager.Animation.Timing.NormalizedStep;
if (!this.PlayerManager.Animation.Timing.Ended)
{
return(true);
}
this.PlayerManager.Position += vector3_1;
this.PlayerManager.SplitUpCubeCollectorOffset = Vector3.Zero;
this.PlayerManager.Position += 0.5f * Vector3.UnitY * (float)Math.Sign(this.CollisionManager.GravityFactor);
IPlayerManager playerManager = this.PlayerManager;
Vector3 vector3_2 = playerManager.Velocity - Vector3.UnitY * (float)Math.Sign(this.CollisionManager.GravityFactor);
playerManager.Velocity = vector3_2;
this.PhysicsManager.Update((IComplexPhysicsEntity)this.PlayerManager);
this.PlayerManager.HeldInstance = (TrileInstance)null;
this.PlayerManager.Action = ActionType.Idle;
return(false);
}
protected void HandleUpdatePlayerRoles(PlayerContext newCurrentPlayerContext, PlayerContext newAudioPlayerContext)
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
CurrentPlayerContext = newCurrentPlayerContext;
playerManager.AudioSlotController = newAudioPlayerContext.PlayerSlotController;
}
public WCFHost(IPlayerManager playerManager, ISpectatorManager spectatorManager, IBanManager banManager, IFactory factory)
: base(playerManager, spectatorManager, banManager, factory)
{
_serviceHost = new WCFServiceHost(this);
_started = false;
}
public TargetingDummy(IPlayerManager playerManager, INetworkManager networkManager,
IResourceManager resourceManager)
{
_networkManager = networkManager;
_playerManager = playerManager;
_resourceManager = resourceManager;
var head = new TargetingDummyElement("dummy_head", BodyPart.Head, _resourceManager);
var torso = new TargetingDummyElement("dummy_torso", BodyPart.Torso, _resourceManager);
var groin = new TargetingDummyElement("dummy_groin", BodyPart.Groin, _resourceManager);
var armL = new TargetingDummyElement("dummy_arm_l", BodyPart.Left_Arm, _resourceManager);
var armR = new TargetingDummyElement("dummy_arm_r", BodyPart.Right_Arm, _resourceManager);
var legL = new TargetingDummyElement("dummy_leg_l", BodyPart.Left_Leg, _resourceManager);
var legR = new TargetingDummyElement("dummy_leg_r", BodyPart.Right_Leg, _resourceManager);
_elements.Add(head);
_elements.Add(torso);
_elements.Add(groin);
_elements.Add(armL);
_elements.Add(armR);
_elements.Add(legL);
_elements.Add(legR);
head.Clicked += Selected;
torso.Clicked += Selected;
groin.Clicked += Selected;
armL.Clicked += Selected;
armR.Clicked += Selected;
legL.Clicked += Selected;
legR.Clicked += Selected;
Update(0);
UpdateHealthIcon();
}
public virtual IPlayerSlotController PrepareAudioPlayerSlotController(IPlayerManager playerManager, PlayerContextManager playerContextManager,
bool concurrentVideo, out int currentPlayerSlotIndex)
{
int numActive;
if (concurrentVideo)
{
numActive = playerContextManager.NumActivePlayerContexts;
// Solve conflicts - close conflicting slots
IPlayerContext secondaryPC = playerContextManager.GetPlayerContext(PlayerContextIndex.SECONDARY);
if (secondaryPC != null)
{
secondaryPC.Close();
}
IPlayerContext pcPrimary;
if (numActive > 0 && (pcPrimary = playerContextManager.GetPlayerContext(PlayerContextIndex.PRIMARY)) != null && pcPrimary.AVType == AVType.Audio)
{
pcPrimary.Close();
}
}
else // !concurrentVideo
// Don't enable concurrent controllers: Close all except the primary slot controller
{
playerContextManager.CloseAllPlayerContexts();
}
numActive = playerContextManager.NumActivePlayerContexts;
currentPlayerSlotIndex = numActive;
return(playerManager.OpenSlot());
}
public PlayerController(IPlayerManager playerManager, ILocalizationService localizationService, ILogger <PlayerController> logger, IMapper mapper)
{
_playerManager = playerManager;
_localizationService = localizationService;
_logger = logger;
_mapper = mapper;
}
public Server(IPlayerManager playerManager, ISpectatorManager spectatorManager, IPieceProvider pieceProvider, IActionQueue gameActionQueue)
{
if (playerManager == null)
{
throw new ArgumentNullException(nameof(playerManager));
}
Options = new GameOptions();
Options.ResetToDefault();
_pieceProvider = pieceProvider;
_pieceProvider.Occurancies = () => Options.PieceOccurancies;
_playerManager = playerManager;
_spectatorManager = spectatorManager;
_gameActionQueue = gameActionQueue;
_hosts = new List <IHost>();
Assembly entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null)
{
Version version = entryAssembly.GetName().Version;
Version = new Versioning
{
Major = version.Major,
Minor = version.Minor,
};
}// else, we suppose SetVersion will be called later, before connecting
_gameStatistics = new Dictionary <string, GameStatisticsByPlayer>();
_winList = new List <WinEntry>();
State = ServerStates.WaitingStartServer;
}
public CacheSettingsPageViewModel(
INavigationService navigationService,
ISettingsService settingsService,
IPlayerManager playerManager,
IPageDialogService pageDialogService,
IStorageService storageService,
IEventAggregator eventAggregator,
IResourceService resourceService) : base(navigationService, settingsService, playerManager, resourceService)
{
_pageDialogService = pageDialogService;
_storageService = storageService;
_eventAggregator = eventAggregator;
_eventAggregator.GetEvent <CacheChangedEvent>().Subscribe((args) =>
{
LoadSettings();
});
_eventAggregator.GetEvent <AlbumInfoSelectionEvent>().ShowAlbum(async(uniqueTrack) =>
{
if (PageUtilities.IsCurrentPageTypeOf(typeof(CacheSettingsPage)))
{
var navigationParams = new NavigationParameters
{
{ "album", uniqueTrack.Album }
};
await NavigationService.NavigateAsync(nameof(AlbumDetailPage), navigationParams);
}
});
}
public override void ProcessPacket(FactoryLoadRequest packet, NebulaConnection conn)
{
if (IsClient)
{
return;
}
PlanetData planet = GameMain.galaxy.PlanetById(packet.PlanetID);
PlanetFactory factory = GameMain.data.GetOrCreateFactory(planet);
using (BinaryUtils.Writer writer = new BinaryUtils.Writer())
{
factory.Export(writer.BinaryWriter);
byte[] data = writer.CloseAndGetBytes();
Log.Info($"Sent {data.Length} bytes of data for PlanetFactory {planet.name} (ID: {planet.id})");
conn.SendPacket(new FactoryData(packet.PlanetID, data, planet.data.modData));
}
// Add requesting client to connected player, so he can receive following update
IPlayerManager playerManager = Multiplayer.Session.Network.PlayerManager;
INebulaPlayer player = playerManager.GetSyncingPlayer(conn);
if (player != null)
{
player.Data.LocalPlanetId = packet.PlanetID;
player.Data.LocalStarId = GameMain.galaxy.PlanetById(packet.PlanetID).star.id;
using (playerManager.GetConnectedPlayers(out System.Collections.Generic.Dictionary <INebulaConnection, INebulaPlayer> connectedPlayers))
{
connectedPlayers.Add(player.Connection, player);
}
}
}
public TargetingDummy(IPlayerManager playerManager, INetworkManager networkManager,
IResourceManager resourceManager)
{
_networkManager = networkManager;
_playerManager = playerManager;
_resourceManager = resourceManager;
var head = new TargetingDummyElement("dummy_head", BodyPart.Head, _resourceManager);
var torso = new TargetingDummyElement("dummy_torso", BodyPart.Torso, _resourceManager);
var groin = new TargetingDummyElement("dummy_groin", BodyPart.Groin, _resourceManager);
var armL = new TargetingDummyElement("dummy_arm_l", BodyPart.Left_Arm, _resourceManager);
var armR = new TargetingDummyElement("dummy_arm_r", BodyPart.Right_Arm, _resourceManager);
var legL = new TargetingDummyElement("dummy_leg_l", BodyPart.Left_Leg, _resourceManager);
var legR = new TargetingDummyElement("dummy_leg_r", BodyPart.Right_Leg, _resourceManager);
_elements.Add(head);
_elements.Add(torso);
_elements.Add(groin);
_elements.Add(armL);
_elements.Add(armR);
_elements.Add(legL);
_elements.Add(legR);
head.Clicked += Selected;
torso.Clicked += Selected;
groin.Clicked += Selected;
armL.Clicked += Selected;
armR.Clicked += Selected;
legL.Clicked += Selected;
legR.Clicked += Selected;
Update(0);
UpdateHealthIcon();
}
public HandleChatBoxMessage(Game game)
{
_game = game;
_chatCommandManager = game.ChatCommandManager;
_playerManager = game.PlayerManager;
_logger = LoggerProvider.GetLogger();
}
public ProfileApiController(
ApplicationUserManager userManager,
IPlayerManager playerManager,
IImageManager imageManager)
{
_userManager = userManager;
_playerManager = playerManager;
_imageManager = imageManager;
}
public SessionManager(IPlayerManager daoPlayer, IGamesManager daoGame)
{
this.daoPlayer = daoPlayer;
this.daoGame = daoGame;
cleanUpTimer = new Timer(numberOfMillisecondsBetweenCleanup);
cleanUpTimer.Elapsed += CleanUpTimer_Elapsed;
cleanUpTimer.AutoReset = true;
cleanUpTimer.Start();
}
public ValkyrieSceneProvider(GraphicsDevice graphicsdevice, SpriteBatch spritebatch, IFogRenderer fogrenderer)
{
this.device = graphicsdevice;
this.spritebatch = spritebatch;
players = new ValkyriePlayerManager<BaseCharacter>();
cameras = new ValkyrieCameraManager<BaseCamera>();
renderers = new ValkyrieRendererManager();
this.fogrenderer = fogrenderer;
}
public virtual void PrepareVideoPlayer(IPlayerManager playerManager, IList<IPlayerContext> playerContexts, PlayerContextConcurrencyMode concurrencyMode, Guid mediaModuleId,
out IPlayerSlotController slotController, ref int audioSlotIndex, ref int currentPlayerIndex)
{
int numActive = playerContexts.Count;
int slotIndex;
switch (concurrencyMode)
{
case PlayerContextConcurrencyMode.ConcurrentAudio:
if (numActive > 1 && playerContexts[1].AVType == AVType.Audio)
{ // The secondary slot is an audio player slot
slotIndex = PlayerManagerConsts.PRIMARY_SLOT;
IPlayerContext pc = playerContexts[0];
pc.Reset(); // Necessary to reset the player context to disable the auto close function (pc.CloseWhenFinished)
playerManager.ResetSlot(slotIndex, out slotController);
audioSlotIndex = PlayerManagerConsts.SECONDARY_SLOT;
}
else if (numActive == 1 && playerContexts[0].AVType == AVType.Audio)
{ // The primary slot is an audio player slot
playerManager.OpenSlot(out slotIndex, out slotController);
// Make new video slot the primary slot
playerManager.SwitchSlots();
audioSlotIndex = PlayerManagerConsts.SECONDARY_SLOT;
}
else
{ // No audio slot available
playerManager.CloseAllSlots();
playerManager.OpenSlot(out slotIndex, out slotController);
audioSlotIndex = PlayerManagerConsts.PRIMARY_SLOT;
}
break;
case PlayerContextConcurrencyMode.ConcurrentVideo:
if (numActive >= 1 && playerContexts[0].AVType == AVType.Video)
{ // The primary slot is a video player slot
if (numActive > 1)
playerManager.CloseSlot(PlayerManagerConsts.SECONDARY_SLOT);
playerManager.OpenSlot(out slotIndex, out slotController);
audioSlotIndex = PlayerManagerConsts.PRIMARY_SLOT;
}
else
{
playerManager.CloseAllSlots();
playerManager.OpenSlot(out slotIndex, out slotController);
audioSlotIndex = PlayerManagerConsts.PRIMARY_SLOT;
}
break;
default:
// Don't enable concurrent controllers: Close all except the primary slot controller
playerManager.CloseAllSlots();
playerManager.OpenSlot(out slotIndex, out slotController);
audioSlotIndex = PlayerManagerConsts.PRIMARY_SLOT;
break;
}
currentPlayerIndex = slotIndex;
}
protected State(IDictionary<Type, object> managers)
{
StateManager = (IStateManager) managers[typeof (IStateManager)];
NetworkManager = (INetworkManager) managers[typeof (INetworkManager)];
ResourceManager = (IResourceManager) managers[typeof (IResourceManager)];
UserInterfaceManager = (IUserInterfaceManager) managers[typeof (IUserInterfaceManager)];
MapManager = (IMapManager) managers[typeof (IMapManager)];
PlayerManager = (IPlayerManager) managers[typeof (IPlayerManager)];
ConfigurationManager = (IConfigurationManager) managers[typeof (IConfigurationManager)];
PlacementManager = (IPlacementManager) managers[typeof (IPlacementManager)];
KeyBindingManager = (IKeyBindingManager) managers[typeof (IKeyBindingManager)];
}
public static void Init(IntPtr smutilsptr, IntPtr sharesysptr, IntPtr myself, IntPtr playermanager,
IntPtr timersystem)
{
Console.WriteLine (Directory.GetCurrentDirectory());
HomePath = Path.Combine(Directory.GetCurrentDirectory(), "cstrike/addons/sharpsource");
ExtensionsPath = Path.Combine(HomePath, "extensions");
SourceMod = new ISourceMod(new CppInstancePtr(smutilsptr));
ShareSys = new IShareSys(new CppInstancePtr(sharesysptr));
Extension = new IExtension(new CppInstancePtr(myself));
PlayerManager = new IPlayerManager(new CppInstancePtr(playermanager));
TimerSystem = new ITimerSystem(new CppInstancePtr(timersystem));
Init();
}
public AuthController(
SignInManager<ApplicationUser> signInManager,
UserManager<ApplicationUser> userManager,
IPlayerManager playerManager,
IImageManager imageManager,
ILoggerFactory loggerFactory)
{
_playerManager = playerManager;
_imageManager = imageManager;
_signInManager = signInManager;
_userManager = userManager;
_logger = loggerFactory.CreateLogger(nameof(AuthController));
}
public MikmakController()
{
try
{
playerManager = new PlayerManager();
gameManager = GameManager.GetInstance();
if (sessionManager == null)
{
sessionManager = new SessionManager(playerManager, gameManager);
}
}
catch (Exception e)
{
throw e;
}
}
public StatusEffectBar(IResourceManager resourceManager, IPlayerManager playerManager)
{
_resourceManager = resourceManager;
_playerManager = playerManager;
if (playerManager.ControlledEntity != null &&
playerManager.ControlledEntity.HasComponent(ComponentFamily.StatusEffects))
{
assignedEnt = playerManager.ControlledEntity;
assigned = (StatusEffectComp) playerManager.ControlledEntity.GetComponent(ComponentFamily.StatusEffects);
assigned.Changed += assigned_Changed;
}
UpdateButtons();
Update(0);
//Pull info from compo and sub to event.
}
public PlacementManager(IResourceManager resourceManager, INetworkManager networkManager,
ICollisionManager collisionManager, IPlayerManager playerManager)
{
ResourceManager = resourceManager;
NetworkManager = networkManager;
CollisionManager = collisionManager;
PlayerManager = playerManager;
Type type = typeof (PlacementMode);
List<Assembly> assemblies = AppDomain.CurrentDomain.GetAssemblies().ToList();
List<Type> types = assemblies.SelectMany(t => t.GetTypes()).Where(p => type.IsAssignableFrom(p)).ToList();
_modeDictionary.Clear();
foreach (Type t in types)
_modeDictionary.Add(t.Name, t);
Clear();
}
public virtual void PrepareAudioPlayer(IPlayerManager playerManager, IList<IPlayerContext> playerContexts, bool concurrentVideo, Guid mediaModuleId,
out IPlayerSlotController slotController, ref int audioSlotIndex, ref int currentPlayerIndex)
{
if (concurrentVideo)
{
int numActive = playerManager.NumActiveSlots;
// Solve conflicts - close conflicting slots
if (numActive > 1)
playerManager.CloseSlot(PlayerManagerConsts.SECONDARY_SLOT);
IPlayerContext pc;
if (numActive > 0 && (pc = playerContexts[PlayerManagerConsts.PRIMARY_SLOT]) != null && pc.AVType == AVType.Audio)
playerManager.CloseSlot(PlayerManagerConsts.PRIMARY_SLOT);
}
else // !concurrentVideo
// Don't enable concurrent controllers: Close all except the primary slot controller
playerManager.CloseAllSlots();
// Open new slot
int slotIndex;
playerManager.OpenSlot(out slotIndex, out slotController);
audioSlotIndex = slotController.SlotIndex;
currentPlayerIndex = slotIndex;
}
public virtual IPlayerSlotController PrepareAudioPlayerSlotController(IPlayerManager playerManager, PlayerContextManager playerContextManager,
bool concurrentVideo, out int currentPlayerSlotIndex)
{
int numActive;
if (concurrentVideo)
{
numActive = playerContextManager.NumActivePlayerContexts;
// Solve conflicts - close conflicting slots
IPlayerContext secondaryPC = playerContextManager.GetPlayerContext(PlayerContextIndex.SECONDARY);
if (secondaryPC != null)
secondaryPC.Close();
IPlayerContext pcPrimary;
if (numActive > 0 && (pcPrimary = playerContextManager.GetPlayerContext(PlayerContextIndex.PRIMARY)) != null && pcPrimary.AVType == AVType.Audio)
pcPrimary.Close();
}
else // !concurrentVideo
// Don't enable concurrent controllers: Close all except the primary slot controller
playerContextManager.CloseAllPlayerContexts();
numActive = playerContextManager.NumActivePlayerContexts;
currentPlayerSlotIndex = numActive;
return playerManager.OpenSlot();
}
public EquipmentSlotUi(EquipmentSlot slot, IPlayerManager playerManager, IResourceManager resourceManager,
IUserInterfaceManager userInterfaceManager)
{
_playerManager = playerManager;
_resourceManager = resourceManager;
_userInterfaceManager = userInterfaceManager;
_color = Color.White;
AssignedSlot = slot;
_buttonSprite = _resourceManager.GetSprite("slot");
_textSprite = new TextSprite(slot + "UIElementSlot", slot.ToString(),
_resourceManager.GetFont("CALIBRI"))
{
ShadowColor = Color.Black,
ShadowOffset = new Vector2D(1, 1),
Shadowed = true,
Color = Color.White
};
Update(0);
}
public BalanceCheckFixture(IPlayerManager pm)
{
_playerManager = pm;
}
public DrawManager(IPlayerManager playerMgr)
{
this._playerManager = playerMgr;
}
public TicketPurchaseFixture(IPlayerManager pm, IDrawManager dm,
DateTime drawDate)
{
_drawManager = dm;
_playerManager = pm;
_drawDate = drawDate;
}
public CreatePlayerFixture(IPlayerManager pm)
{
_playerManager = pm;
}
/// <summary>
/// Initializes a new instance of the <see cref="NullServerManager" /> class.
/// </summary>
/// <param name="playerManager">The player manager.</param>
/// <exception cref="System.ArgumentNullException">playerManager</exception>
public NullServerManager(IPlayerManager playerManager)
{
if (playerManager == null) throw new ArgumentNullException("playerManager");
_playerManager = playerManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="PlayersController" /> class.
/// </summary>
/// <param name="playerManager">The player manager.</param>
/// <exception cref="System.ArgumentNullException">playerManager</exception>
public PlayersController(IPlayerManager playerManager)
{
if (playerManager == null) throw new ArgumentNullException("playerManager");
_playerManager = playerManager;
}
public HumanComboGui(IPlayerManager playerManager, INetworkManager networkManager,
IResourceManager resourceManager, IUserInterfaceManager userInterfaceManager)
{
_networkManager = networkManager;
_playerManager = playerManager;
_resourceManager = resourceManager;
_userInterfaceManager = userInterfaceManager;
ComponentClass = GuiComponentType.ComboGui;
#region Status UI
_ResBlunt = new ArmorInfoLabel(DamageType.Bludgeoning, resourceManager);
_ResBurn = new ArmorInfoLabel(DamageType.Burn, resourceManager);
_ResFreeze = new ArmorInfoLabel(DamageType.Freeze, resourceManager);
_ResPierce = new ArmorInfoLabel(DamageType.Piercing, resourceManager);
_ResShock = new ArmorInfoLabel(DamageType.Shock, resourceManager);
_ResSlash = new ArmorInfoLabel(DamageType.Slashing, resourceManager);
_ResTox = new ArmorInfoLabel(DamageType.Toxin, resourceManager);
#endregion
_equipBg = _resourceManager.GetSprite("outline");
_comboBg = _resourceManager.GetSprite("combo_bg");
_comboClose = new ImageButton
{
ImageNormal = "button_closecombo",
};
_tabEquip = new ImageButton
{
ImageNormal = "tab_equip",
};
_tabEquip.Clicked += TabClicked;
_tabHealth = new ImageButton
{
ImageNormal = "tab_health",
};
_tabHealth.Clicked += TabClicked;
_tabCraft = new ImageButton
{
ImageNormal = "tab_craft",
};
_tabCraft.Clicked += TabClicked;
_comboClose.Clicked += ComboCloseClicked;
//Left Side - head, eyes, outer, hands, feet
_slotHead = new EquipmentSlotUi(EquipmentSlot.Head, _playerManager, _resourceManager, _userInterfaceManager);
_slotHead.Dropped += SlotDropped;
_slotEyes = new EquipmentSlotUi(EquipmentSlot.Eyes, _playerManager, _resourceManager, _userInterfaceManager);
_slotEyes.Dropped += SlotDropped;
_slotOuter = new EquipmentSlotUi(EquipmentSlot.Outer, _playerManager, _resourceManager,
_userInterfaceManager);
_slotOuter.Dropped += SlotDropped;
_slotHands = new EquipmentSlotUi(EquipmentSlot.Hands, _playerManager, _resourceManager,
_userInterfaceManager);
_slotHands.Dropped += SlotDropped;
_slotFeet = new EquipmentSlotUi(EquipmentSlot.Feet, _playerManager, _resourceManager, _userInterfaceManager);
_slotFeet.Dropped += SlotDropped;
//Right Side - mask, ears, inner, belt, back
_slotMask = new EquipmentSlotUi(EquipmentSlot.Mask, _playerManager, _resourceManager, _userInterfaceManager);
_slotMask.Dropped += SlotDropped;
_slotEars = new EquipmentSlotUi(EquipmentSlot.Ears, _playerManager, _resourceManager, _userInterfaceManager);
_slotEars.Dropped += SlotDropped;
_slotInner = new EquipmentSlotUi(EquipmentSlot.Inner, _playerManager, _resourceManager,
_userInterfaceManager);
_slotInner.Dropped += SlotDropped;
_slotBelt = new EquipmentSlotUi(EquipmentSlot.Belt, _playerManager, _resourceManager, _userInterfaceManager);
_slotBelt.Dropped += SlotDropped;
_slotBack = new EquipmentSlotUi(EquipmentSlot.Back, _playerManager, _resourceManager, _userInterfaceManager);
_slotBack.Dropped += SlotDropped;
_txtDbg = new TextSprite("comboDlgDbg", "Combo Debug", _resourceManager.GetFont("CALIBRI"));
_craftSlot1 = new CraftSlotUi(_resourceManager, _userInterfaceManager);
_craftSlot2 = new CraftSlotUi(_resourceManager, _userInterfaceManager);
_craftButton = new ImageButton
{
ImageNormal = "wrenchbutt"
};
_craftButton.Clicked += CraftButtonClicked;
_craftStatus = new TextSprite("craftText", "Status", _resourceManager.GetFont("CALIBRI"))
{
ShadowColor = Color.DimGray,
ShadowOffset = new Vector2D(1, 1),
Shadowed = true
};
_blueprints = new ScrollableContainer("blueprintCont", new Size(210, 100), _resourceManager);
}
public CraftingManager(IPlayerManager PlayerManager, ISS14NetServer NetServer)
{
_netServer = NetServer;
_playerManager = PlayerManager;
}
public SetUpTestEnvironment()
{
playerManager = new PlayerManager();
}
public RandomPlayerViewModel()
{
m_playerManager = PlayerManager.Instance;
LoadData();
}
public PlayerApiController(
IPlayerManager playerManager)
{
_playerManager = playerManager;
}
public virtual IPlayerSlotController PrepareVideoPlayerSlotController(IPlayerManager playerManager, PlayerContextManager playerContextManager,
PlayerContextConcurrencyMode concurrencyMode, out bool makePrimaryPlayer, out int audioPlayerSlotIndex, out int currentPlayerSlotIndex)
{
IList<IPlayerContext> playerContexts = playerContextManager.PlayerContexts;
int numActive = playerContexts.Count;
IPlayerSlotController result;
switch (concurrencyMode)
{
case PlayerContextConcurrencyMode.ConcurrentAudio:
if (numActive > 1 && playerContexts[PlayerContextIndex.SECONDARY].AVType == AVType.Audio)
{ // The secondary slot is an audio player slot
IPlayerContext playerContext = playerContexts[PlayerContextIndex.PRIMARY];
result = playerContext.Revoke();
makePrimaryPlayer = true;
audioPlayerSlotIndex = PlayerContextIndex.SECONDARY;
}
else if (numActive == 1 && playerContexts[PlayerContextIndex.PRIMARY].AVType == AVType.Audio)
{ // The primary slot is an audio player slot
result = playerManager.OpenSlot();
makePrimaryPlayer = true;
audioPlayerSlotIndex = PlayerContextIndex.SECONDARY;
}
else
{ // No audio slot available
playerContextManager.CloseAllPlayerContexts();
result = playerManager.OpenSlot();
makePrimaryPlayer = true;
audioPlayerSlotIndex = PlayerContextIndex.PRIMARY;
}
break;
case PlayerContextConcurrencyMode.ConcurrentVideo:
if (numActive >= 1 && playerContexts[PlayerContextIndex.PRIMARY].AVType == AVType.Video)
{ // The primary slot is a video player slot
if (numActive > 1)
{
IPlayerContext pcSecondary = playerContextManager.GetPlayerContext(PlayerContextIndex.SECONDARY);
pcSecondary.Close();
}
result = playerManager.OpenSlot();
makePrimaryPlayer = false;
audioPlayerSlotIndex = PlayerContextIndex.PRIMARY;
}
else
{
playerContextManager.CloseAllPlayerContexts();
result = playerManager.OpenSlot();
makePrimaryPlayer = true;
audioPlayerSlotIndex = PlayerContextIndex.PRIMARY;
}
break;
default:
// Don't enable concurrent controllers: Close all except the primary slot controller
playerContextManager.CloseAllPlayerContexts();
result = playerManager.OpenSlot();
makePrimaryPlayer = true;
audioPlayerSlotIndex = PlayerContextIndex.PRIMARY;
break;
}
currentPlayerSlotIndex = makePrimaryPlayer ? PlayerContextIndex.PRIMARY : PlayerContextIndex.SECONDARY;
return result;
}
public SetUpTestEnvironment()
{
playerManager = new PlayerManager();
drawManager = new DrawManager(playerManager);
}
