async void OnSave(object sender, System.EventArgs e)
{
var player = BindingContext as Player;
if (String.IsNullOrWhiteSpace(player.PlayerName))
{
await DisplayAlert("Hey!", "Please enter a name", "Okay");
return;
}
if (String.IsNullOrWhiteSpace(player.PlayerNumber))
{
await DisplayAlert("Hey!", "Please enter the player's number", "Okay");
return;
}
if (player.ID == 0)
{
await _connection.InsertAsync(player);
PlayerAdded?.Invoke(this, player);
}
else
{
await _connection.UpdateAsync(player);
PlayerUpdated?.Invoke(this, player);
}
await Navigation.PopAsync();
}
void InvokePlayerUpdated()
{
if (IsActive && Config.IsLocal)
{
PlayerUpdated?.Invoke(PlayerID, config);
}
}
public static void HandleData(GetDataEventArgs args, MemoryStream data, PvPPlayer player)
{
switch (args.MsgID)
{
case PacketTypes.PlayerHurtV2:
PlayerHurt?.Invoke(typeof(DataHandler), new PlayerHurtArgs(args, data, player));
return;
case PacketTypes.TogglePvp:
PvPToggled?.Invoke(typeof(DataHandler), new TogglePvPArgs(player));
return;
case PacketTypes.PlayerSlot:
PlayerSlotUpdated?.Invoke(typeof(DataHandler), new PlayerSlotArgs(data, player));
return;
case PacketTypes.PlayerDeathV2:
PlayerDied?.Invoke(typeof(DataHandler), new PlayerDeathArgs(player));
return;
case PacketTypes.ProjectileNew:
ProjectileNew?.Invoke(typeof(DataHandler), new ProjectileNewArgs(args, data, player));
return;
case PacketTypes.ProjectileDestroy:
ProjectileDestroyed?.Invoke(typeof(DataHandler), new ProjectileDestroyArgs(data));
return;
case PacketTypes.PlayerUpdate:
PlayerUpdated?.Invoke(typeof(DataHandler), new PlayerUpdateArgs(data, player));
return;
}
}
protected void Start()
{
_smallIndex = this.Players.IndexOf(this.Players.FirstOrDefault(it => it.Role == GameRole.Small));
_currentIndex = _smallIndex;
this.Players[_currentIndex].IsActive = true;
PlayerUpdated?.Invoke(this.Players[_currentIndex]);
}
public void Consume(PlayerUpdated @event)
{
var player = _repository.Players.Single(x => x.Id == @event.Id);
player.VipLevelId = @event.VipLevelId;
_repository.SaveChanges();
}
public void UpdatePlayer(Vector2 position, float rotation, bool isS, int h)
{
Position = position;
Rotation = rotation;
isShooting = isS;
currentHp = h;
if (PlayerUpdated != null)
{
PlayerUpdated.Invoke();
}
}
public void Consume(PlayerUpdated message)
{
var player = _repository.Players.Single(x => x.Id == message.Id);
player.Email = message.Email;
player.PhoneNumber = message.PhoneNumber;
player.VipLevelId = message.VipLevelId;
player.AccountAlertEmail = message.AccountAlertEmail;
player.AccountAlertSms = message.AccountAlertSms;
_repository.SaveChanges();
}
void OnClientReady(NetworkDataMessage dataMsg)
{
NetworkClientPlayer client;
if (!clients.TryGetValue(dataMsg.Connection.Id, out client))
{
return;
}
var message = dataMsg.ReadAs <PeerReadyMessage>();
client.IsReady = message.IsReady;
PlayerUpdated?.Invoke(client);
}
void OnClientConfigUpdated(NetworkDataMessage dataMsg)
{
NetworkClientPlayer client;
if (!clients.TryGetValue(dataMsg.Connection.Id, out client))
{
return;
}
var message = dataMsg.ReadAs <ClientUpdateConfigMessage>();
client.Config = message.PlayerConfig;
client.Config.PlayerID = client.PlayerID;
PlayerUpdated?.Invoke(client);
}
/// <summary>
/// 移动到下个玩家
/// </summary>
public void MoveToNext()
{
_currentIndex++;
_currentIndex = _currentIndex % Players.Count();
if (this.Players[_currentIndex].Status == GamePlayerStatus.Fold || this.Players[_currentIndex].IsAllIn)
{
MoveToNext();
}
else
{
this.Players[_currentIndex].IsActive = true;
PlayerUpdated?.Invoke(this.Players[_currentIndex]);
}
}
public void Consume(PlayerUpdated @event)
{
var paymentRepository = _container.Resolve <IPaymentRepository>();
var playerPaymentLevel =
paymentRepository.PlayerPaymentLevels.FirstOrDefault(p => p.PlayerId == @event.Id);
if (playerPaymentLevel != null)
{
var paymentLevel = paymentRepository.PaymentLevels.Single(p => p.Id == @event.PaymentLevelId);
playerPaymentLevel.PaymentLevel = paymentLevel;
paymentRepository.SaveChanges();
}
}
public void CycleColor(bool backward)
{
if (CharacterSelectMenu == null)
{
return;
}
var newSelection = CharacterSelectMenu.NextPallete(Config.Selection, PlayerID, backward);
bool changed = !Config.Selection.Equals(newSelection);
config.Selection = newSelection;
if (changed)
{
PlayerUpdated?.Invoke(PlayerID, config);
}
UpdatePlayerInfo();
}
public void Handle(PlayerUpdated @event)
{
var playerId = @event.Id;
AddPlayerLog(playerId);
var playerQueries = Container.Resolve <PlayerQueries>();
var lastPlayerInfoRecords = playerQueries.GetPlayerInfoLog(playerId).Take(2).ToArray();
var newValues = lastPlayerInfoRecords[0];
var oldValues = lastPlayerInfoRecords[1];
var changes = GetPlayerFieldChanges(oldValues, newValues).ToList();
AddActivityLog(string.Join(", ", changes.Select(c => c.Field)), @event, @event.Id,
changes.ToDictionary(c => c.Field, c => (object)(c.OldValue + " -> " + c.NewValue)));
}
public void CycleCharacter(bool backward)
{
if (CharacterSelectMenu == null)
{
return;
}
var newId = CharacterSelectMenu.NextCharacterID(Config.Selection.CharacterID, backward);
bool changed = Config.Selection.CharacterID != newId;
config.Selection.CharacterID = newId;
if (changed)
{
PlayerUpdated?.Invoke(PlayerID, config);
}
UpdatePlayerInfo();
}
private void ButtonReward_Click(object sender, EventArgs e)
{
int index = IndexOfChosenPlayer;
Player player = _players[index];
RewardMenu rewards = new RewardMenu(player.Stats.Gold);
var result = rewards.ShowDialog();
if (result == DialogResult.OK)
{
player.Stats.Intellect += rewards.Intellect;
player.Stats.Spirit += rewards.Spirit;
player.Stats.MaxHealthPoints += rewards.MaxHealth;
player.Stats.MaxMana += rewards.MaxMana;
player.Stats.Gold = rewards.Gold;
//RefreshPlayer(index);
PlayerUpdated?.Invoke(this, new PlayerEventArgs(player, index));
}
}
public async Task UpdatePlayerOptions(Guid userId, PlayerOptionsData options)
{
EnsureUserIsOnline(userId);
EnsureGameIsNotStarted();
if (!_playerListEditor.Contains(userId))
{
return;
}
var updated = _playerListEditor.Update(userId, options);
if (!updated)
{
return;
}
var playerUpdated = new PlayerUpdated(_state.RoomId, _playerListEditor[userId]);
await _hub.NotifyEverybody(playerUpdated);
}
public bool UpdatePlayer(Guid playerId, Player player)
{
bool flag = connectedPlayers.ContainsKey(playerId);
if (flag)
{
connectedPlayers[playerId] = player;
}
Console.WriteLine($"Player updated: {playerId}");
PlayerDataUpdatedPacket playerDataUpdatedPacket = new PlayerDataUpdatedPacket(playerId, player);
server.SendPacketToAll(playerDataUpdatedPacket);
PlayerEventArgs playerEventArgs = new PlayerEventArgs(playerId);
PlayerUpdated?.Invoke(this, playerEventArgs);
return(flag);
}
public void Handle(PlayerUpdated updatedEvent)
{
var repository = _container.Resolve <IReportRepository>();
var record = repository.PlayerRecords.SingleOrDefault(r => r.PlayerId == updatedEvent.Id);
if (record == null)
{
throw new RegoException(string.Format(PlayerRecordWasNotFoundMessage, updatedEvent.Id));
}
record.PlayerName = updatedEvent.DisplayName;
record.Birthday = updatedEvent.DateOfBirth.Date;
record.Title = updatedEvent.Title;
record.Gender = updatedEvent.Gender;
record.Email = updatedEvent.Email;
record.Mobile = updatedEvent.PhoneNumber;
record.Country = updatedEvent.CountryName;
record.StreetAddress = string.Join("\n", updatedEvent.AddressLines).Trim('\n');
record.PostCode = updatedEvent.ZipCode;
record.VipLevel = updatedEvent.VipLevel;
record.Updated = updatedEvent.EventCreated;
record.UpdatedBy = updatedEvent.EventCreatedBy;
repository.SaveChanges();
}
// Player Record Edit category
public void Consume(PlayerUpdated message)
{
_playerRecordEditHandlers.Handle(message);
}
public static void InvokePlayerUpdated(Player player)
{
PlayerUpdated?.Invoke(player);
}
public void Consume(PlayerUpdated message)
{
//todo: talk to BA about updating.
}
public virtual void OnPlayerUpdate()
{
PlayerUpdated?.Invoke(this, EventArgs.Empty);
}
protected virtual void OnPlayerUpdated(Player player)
{
PlayerUpdated?.Invoke(this, player);
}
internal void OnPlayerUpdated(Player?stored, Player fetched)
{
Task.Run(() => PlayerUpdated?.Invoke(this, new PlayerUpdatedEventArgs(stored, fetched)));
}
public void Consume(PlayerUpdated message)
{
_eventHandlers.Handle(message);
}
public void Handle(PlayerUpdated @event)
{
AddActivityLog(AdminActivityLogCategory.Player, @event);
}
private void HandlePlayerUpdated(User user, User oldUser, string externalUserId)
{
var e = new PlayerUpdated(user.Id, user.Email);
_eventBuilder.Build(e, externalUserId, oldUser, user);
_logger.InformationDefault(e);
}
internal void InvokePlayerUpdated(NetworkClientPlayer client)
{
PlayerUpdated?.Invoke(client);
}