public PlayerRepairSystemEvent(IGame game, IClientPlayer clientPlayer, IInnerPlayerControl playerControl, SystemTypes systemType, byte amount)
{
Game = game;
ClientPlayer = clientPlayer;
PlayerControl = playerControl;
SystemType = systemType;
Amount = amount;
}
private void Event_PlayerJoin(IClientPlayer byPlayer)
{
if (!didSelect && byPlayer.PlayerUID == capi.World.Player.PlayerUID)
{
createCharDlg = new GuiDialogCreateCharacter(capi, this);
createCharDlg.PrepAndOpen();
}
}
public Boolean matchPlayer(IClientPlayer match)
{
if (match.Equals(_controller))
{
return(true);
}
return(false);
}
private void Event_PlayerSpawn(IClientPlayer byPlayer)
{
if (mapSink.IsOpened && !MapComps.ContainsKey(byPlayer))
{
EntityMapComponent cmp = new EntityMapComponent(capi, otherTexture, byPlayer.Entity);
MapComps[byPlayer] = cmp;
mapSink.AddMapData(cmp);
}
}
private void WriteJoinedGameMessage(IMessageWriter message, bool clear, IClientPlayer player)
{
var playerIds = _players
.Where(x => x.Value != player)
.Select(x => x.Key)
.ToArray();
Message07JoinedGameS2C.Serialize(message, clear, Code, player.Client.Id, HostId, playerIds);
}
protected async ValueTask <bool> UnregisteredCall(CheatContext context, IClientPlayer sender)
{
if (await sender.Client.ReportCheatAsync(context, "Client sent unregistered call"))
{
return(false);
}
return(true);
}
private async Task AssignJester(List <IClientPlayer> gameplayers)
{
int r = rnd.Next(gameplayers.Count);
Jester = gameplayers[r];
Jestername = gameplayers[r].Character.PlayerInfo.PlayerName;
await ServerSendChatToPlayerAsync($"You're the JESTER! (unless you'll be an imposter)", gameplayers[r].Character).ConfigureAwait(false);
_logger.LogInformation($"- {gameplayers[r].Character.PlayerInfo.PlayerName} is probably the jester.");
}
public void RemoveDeadPlayer(IClientPlayer player)
{
lock (Players)
{
if (player != null && Players.Contains(player))
{
Players.Remove(player);
}
}
}
public override SkillItem[] GetToolModes(ItemSlot slot, IClientPlayer forPlayer, BlockSelection blockSel)
{
if (blockSel == null)
{
return(null);
}
Block block = forPlayer.Entity.World.BlockAccessor.GetBlock(blockSel.Position);
return(block is BlockAnvil ? toolModes : null);
}
internal void RemoveGamePlayer(IClientPlayer player)
{
if (_controllers.TryGetValue(player.Game.Code.Code, out var muteController))
{
muteController.LeaveFromGame(player);
return;
}
_logger.LogError($"There is no mute controller to pair with game `{player.Game.Code.Code}`.");
return;
}
private void Event_PlayerDespawn(IClientPlayer byPlayer)
{
EntityMapComponent mp;
if (MapComps.TryGetValue(byPlayer, out mp))
{
mp.Dispose();
MapComps.Remove(byPlayer);
}
}
internal void OnPlayerSpawned(IClientPlayer player)
{
if (_controllers.TryGetValue(player.Game.Code.Code, out var muteController))
{
// muteController.SyncDeadStatus(); // After the game is over, "player.Character" will be null, so it is not called here.
muteController.PlayerSpawned();
return;
}
return;
}
public async ValueTask HandleAlterGame(IMessageReader message, IClientPlayer sender, bool isPublic)
{
IsPublic = isPublic;
using var packet = MessageWriter.Get(MessageType.Reliable);
message.CopyTo(packet);
await SendToAllExceptAsync(packet, sender.Client.Id);
await _eventManager.CallAsync(new GameAlterEvent(this, isPublic));
}
public Player(IClientPlayer player, Game game)
{
this.ClientPlayer = player;
this.Game = game;
if (Game.BotConnected)
{
TryWatchMe();
}
}
private async Task MakePlayerLookAtChat(IClientPlayer player)
{
await Task.Delay(TimeSpan.FromSeconds(0.5)).ConfigureAwait(false);
string playername = player.Character.PlayerInfo.PlayerName;
await player.Character.SetNameAsync($"OPEN CHAT").ConfigureAwait(false);
await Task.Delay(TimeSpan.FromSeconds(3)).ConfigureAwait(false);
await player.Character.SetNameAsync(playername).ConfigureAwait(false);
}
public void MarkWPForSelection(IClientPlayer player)
{
if (player.CurrentBlockSelection != null)
{
MarkWPForBlockSel(player.CurrentBlockSelection);
}
else if (player.CurrentEntitySelection != null)
{
MarkWPForEntitySel(player.CurrentEntitySelection);
}
}
internal async ValueTask SetPositionAsync(IClientPlayer sender, Vector2 position)
{
_targetSyncPosition = position;
var playerMovementEvent = _pool.Get();
playerMovementEvent.Reset(_game, sender, _playerControl);
await _eventManager.CallAsync(playerMovementEvent);
_pool.Return(playerMovementEvent);
}
public static void SendMessage(this IClientPlayer player, string msg, int chatGroup = -1)
{
if (chatGroup == -1)
{
chatGroup = GlobalConstants.CurrentChatGroup;
}
ICoreAPI api = player.Entity.Api;
(api as ICoreClientAPI).SendChatMessage(msg, chatGroup);
api.World.Logger.Chat(msg);
}
internal async ValueTask SetPositionAsync(IClientPlayer sender, Vector2 position, Vector2 velocity)
{
Position = position;
Velocity = velocity;
var playerMovementEvent = _pool.Get();
playerMovementEvent.Reset(Game, sender, _playerControl);
await _eventManager.CallAsync(playerMovementEvent);
_pool.Return(playerMovementEvent);
}
protected async ValueTask <bool> ValidateOwnership(CheatContext context, IClientPlayer sender)
{
if (!sender.IsOwner(this))
{
if (await sender.Client.ReportCheatAsync(context, $"Failed ownership check on {GetType().Name}"))
{
return(false);
}
}
return(true);
}
private bool CheckIfColliding(IClientPlayer player1, IClientPlayer player2)
{
Vector2 crewmatePos = player1.Character.NetworkTransform.Position;
Vector2 impostorPos = player2.Character.NetworkTransform.Position;
float crewmateX = (float)Math.Round(crewmatePos.X, 1);
float crewmateY = (float)Math.Round(crewmatePos.Y, 1);
float impostorX = (float)Math.Round(impostorPos.X, 1);
float impostorY = (float)Math.Round(impostorPos.Y, 1);
return(crewmateX <= impostorX + freezeRange && crewmateX >= impostorX - freezeRange &&
crewmateY <= impostorY + freezeRange && crewmateY >= impostorY - freezeRange);
}
protected async ValueTask <bool> ValidateImpostor(CheatContext context, IClientPlayer sender, InnerPlayerInfo playerInfo, bool value = true)
{
if (playerInfo.IsImpostor != value)
{
if (await sender.Client.ReportCheatAsync(context, "Failed impostor check"))
{
return(false);
}
}
return(true);
}
protected async ValueTask <bool> ValidateCmd(CheatContext context, IClientPlayer sender, IClientPlayer?target)
{
if (target == null || !target.IsHost)
{
if (await sender.Client.ReportCheatAsync(context, "Failed cmd check"))
{
return(false);
}
}
return(true);
}
protected async ValueTask <bool> ValidateBroadcast(CheatContext context, IClientPlayer sender, IClientPlayer?target)
{
if (target != null)
{
if (await sender.Client.ReportCheatAsync(context, "Failed broadcast check"))
{
return(false);
}
}
return(true);
}
protected async ValueTask <bool> ValidateHost(CheatContext context, IClientPlayer sender)
{
if (!sender.IsHost)
{
if (await sender.Client.ReportCheatAsync(context, "Failed host check"))
{
return(false);
}
}
return(true);
}
private void Event_PlayerSpawn(IClientPlayer byPlayer)
{
if (capi.World.Config.GetBool("mapHideOtherPlayers", false) && byPlayer.PlayerUID != capi.World.Player.PlayerUID)
{
return;
}
if (mapSink.IsOpened && !MapComps.ContainsKey(byPlayer))
{
EntityMapComponent cmp = new EntityMapComponent(capi, otherTexture, byPlayer.Entity);
MapComps[byPlayer] = cmp;
}
}
/// <summary>
/// Sends a private message to a player with in-game chat
/// </summary>
/// <param name="toPlayer">The Player to receive the message</param>
/// <param name="messages">The message to send</param>
/// <returns></returns>
public async Task SendPrivateMessageAsync(IClientPlayer toPlayer, params string[] messages)
{
if (toPlayer.Character != null)
{
var name = toPlayer.Character.PlayerInfo.PlayerName;
var message = string.Join("\n\n", messages);
await toPlayer.Character.SetNameAsync(_susSuitePlugin.FormattedPluginName);
await toPlayer.Character.SendChatToPlayerAsync(message);
await toPlayer.Character.SetNameAsync(name);
}
}
public override async ValueTask DeserializeAsync(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!await ValidateHost(CheatContext.Deserialize, sender))
{
return;
}
if (initialState)
{
IsNew = reader.ReadBoolean();
}
PlayerId = reader.ReadByte();
}
public override void Deserialize(IClientPlayer sender, IClientPlayer?target, IMessageReader reader, bool initialState)
{
if (!sender.IsHost)
{
// throw new ImpostorCheatException($"Client attempted to send data for {nameof(InnerPlayerControl)} as non-host");
}
if (initialState)
{
IsNew = reader.ReadBoolean();
}
PlayerId = reader.ReadByte();
}
public override void BeforeRender(float dt)
{
if (meshRefOpaque == null && meshRefOit == null)
{
return;
}
if (gearInv == null && eagent?.GearInventory != null)
{
registerSlotModified();
}
if (capi.IsGamePaused)
{
return;
}
if (player == null && entity is EntityPlayer)
{
player = capi.World.PlayerByUid((entity as EntityPlayer).PlayerUID) as IClientPlayer;
nameTagRenderHandler = capi.ModLoader.GetModSystem <EntityNameTagRendererRegistry>().GetNameTagRenderer(entity);
OnNameChanged();
}
isSpectator = player != null && player.WorldData.CurrentGameMode == EnumGameMode.Spectator;
if (isSpectator)
{
return;
}
if (DisplayChatMessages && messageTextures.Count > 0)
{
MessageTexture tex = messageTextures.Last();
if (capi.World.ElapsedMilliseconds > tex.receivedTime + 3500 + 100 * (tex.message.Length - 10))
{
messageTextures.RemoveAt(messageTextures.Count - 1);
tex.tex.Dispose();
/*if (messageTextures.Count > 0)
* {
* tex = messageTextures[messageTextures.Count - 1];
* long msvisible = tex.receivedTime + 3500 + 100 * (tex.message.Length - 10) - capi.World.ElapsedMilliseconds;
* tex.receivedTime += Math.Max(0, 1000 - msvisible);
* }*/
}
}
}
