public void Shout(ShoutPacket shoutPacket)
{
var sayPacket = new SayPacket
{
VisualType = VisualType.Player,
VisualId = 0,
Type = SayColorType.Yellow,
Message =
$"({Language.Instance.GetMessageFromKey(LanguageKey.ADMINISTRATOR, Session.Account.Language)}){shoutPacket.Message}"
};
var msgPacket = new MsgPacket
{
Type = MessageType.Shout,
Message = shoutPacket.Message
};
var sayPostedPacket = new PostedPacket
{
Packet = PacketFactory.Serialize(sayPacket),
SenderCharacter = new Data.WebApi.Character()
{
Name = Session.Character.Name,
Id = Session.Character.CharacterId
}
};
var msgPostedPacket = new PostedPacket
{
Packet = PacketFactory.Serialize(msgPacket)
};
ServerManager.Instance.BroadcastPackets(new List <PostedPacket>(new[] { sayPostedPacket, msgPostedPacket }));
}
public IActionResult PostPacket([FromBody] PostedPacket postedPacket)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var message = PacketFactory.Deserialize(postedPacket.Packet);
switch (postedPacket.ReceiverType)
{
case ReceiverType.All:
ServerManager.Instance.Broadcast(message);
break;
case ReceiverType.OnlySomeone:
var receiverSession = ServerManager.Instance.Sessions.FirstOrDefault(s =>
s.Character.Name == postedPacket.ReceiverCharacterData.CharacterName);
if (receiverSession == null)
{
return(Ok());
}
receiverSession.SendPacket(message);
break;
}
return(Ok());
}
public void BroadcastPacket(PostedPacket postedPacket)
{
foreach (var channel in Instance.Get <List <WorldServerInfo> >("api/channels"))
{
Instance.Post <PostedPacket>("api/packet", postedPacket, channel.WebApi);
}
}
public void BroadcastPacket(PostedPacket packet)
{
foreach (var channel in Instance.Get <List <ChannelInfo> >(WebApiRoute.Channel)?.Where(c => c.Type == ServerType.WorldServer) ?? new List <ChannelInfo>())
{
Instance.Post <PostedPacket>(WebApiRoute.Packet, packet, channel.WebApi);
}
}
public async Task BroadcastPacketAsync(PostedPacket packet)
{
foreach (var channel in (await _channelHttpClient.GetChannelsAsync().ConfigureAwait(false))
?.Where(c => c.Type == ServerType.WorldServer) ?? new List <ChannelInfo>())
{
SendPacketToChannel(packet, channel.WebApi !.ToString());
}
}
public void BroadcastPacket(PostedPacket packet)
{
foreach (var channel in _channelHttpClient.GetChannels()
?.Where(c => c.Type == ServerType.WorldServer) ?? new List <ChannelInfo>())
{
SendPacketToChannel(packet, channel.WebApi.ToString());
}
}
public void BroadcastPacket(PostedPacket postedPacket, int channelId)
{
var channel = Instance.Get <List <WorldServerInfo> >("api/channels", channelId).FirstOrDefault();
if (channel != null)
{
Instance.Post <PostedPacket>("api/packet", postedPacket, channel.WebApi);
}
}
public async Task BroadcastPacketAsync(PostedPacket packet, int channelId)
{
var channel = await _channelHttpClient.GetChannelAsync(channelId).ConfigureAwait(false);
if (channel != null)
{
await SendPacketToChannelAsync(packet, channel.WebApi !.ToString()).ConfigureAwait(false);
}
}
public void BroadcastPacket(PostedPacket packet, int channelId)
{
var channel = Instance.Get <List <ChannelInfo> >(WebApiRoute.Channel, channelId).FirstOrDefault();
if (channel != null)
{
Instance.Post <PostedPacket>(WebApiRoute.Packet, packet, channel.WebApi);
}
}
public void BroadcastPacket(PostedPacket packet, int channelId)
{
var channel = _channelHttpClient.GetChannel(channelId);
if (channel != null)
{
SendPacketToChannel(packet, channel.WebApi.ToString());
}
}
private async Task SendPacketToChannelAsync(PostedPacket postedPacket, string channel)
{
var client = _httpClientFactory.CreateClient();
client.BaseAddress = new Uri(channel);
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", await _channelHttpClient.GetOrRefreshTokenAsync().ConfigureAwait(false));
var content = new StringContent(JsonSerializer.Serialize(postedPacket),
Encoding.Default, "application/json");
await client.PostAsync("api/packet", content).ConfigureAwait(false);
}
private void SendPacketToChannel(PostedPacket postedPacket, string channel)
{
var client = _httpClientFactory.CreateClient();
client.BaseAddress = new Uri(channel);
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", _channelHttpClient.GetOrRefreshToken());
var content = new StringContent(JsonConvert.SerializeObject(postedPacket),
Encoding.Default, "application/json");
client.PostAsync("api/packet", content);
}
public void BroadcastPacket(PostedPacket postedPacket, int?channelId = null)
{
if (channelId == null)
{
foreach (var channel in WebApiAccess.Instance.Get <List <WorldServerInfo> >("api/channels"))
{
WebApiAccess.Instance.Post <PostedPacket>("api/packet", postedPacket, channel.WebApi);
}
}
else
{
var channel = WebApiAccess.Instance.Get <List <WorldServerInfo> >("api/channels", id: channelId.Value).FirstOrDefault();
if (channel != null)
{
WebApiAccess.Instance.Post <PostedPacket>("api/packet", postedPacket, channel.WebApi);
}
}
}
public IActionResult PostPacket([FromBody] PostedPacket postedPacket)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var message = _deserializer.Deserialize(postedPacket.Packet);
switch (postedPacket.ReceiverType)
{
case ReceiverType.All:
Broadcaster.Instance.SendPacket(message);
break;
case ReceiverType.OnlySomeone:
ICharacterEntity receiverSession;
if (postedPacket.ReceiverCharacter.Name != null)
{
receiverSession = Broadcaster.Instance.GetCharacter(s =>
s.Name == postedPacket.ReceiverCharacter.Name);
}
else
{
receiverSession = Broadcaster.Instance.GetCharacter(s =>
s.VisualId == postedPacket.ReceiverCharacter.Id);
}
if (receiverSession == null)
{
return(Ok()); //TODO: not found
}
receiverSession.SendPacket(message);
break;
default:
_logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.UNKWNOWN_RECEIVERTYPE));
break;
}
return(Ok());
}
public async Task <IActionResult> PostPacket([FromBody] PostedPacket postedPacket)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var message = _deserializer.Deserialize(postedPacket.Packet !);
switch (postedPacket.ReceiverType)
{
case ReceiverType.All:
await Broadcaster.Instance.SendPacketAsync(message).ConfigureAwait(false);
break;
case ReceiverType.OnlySomeone:
ICharacterEntity?receiverSession;
if (postedPacket.ReceiverCharacter !.Name != null)
{
receiverSession = Broadcaster.Instance.GetCharacter(s =>
s.Name == postedPacket.ReceiverCharacter.Name);
}
else
{
receiverSession = Broadcaster.Instance.GetCharacter(s =>
s.VisualId == postedPacket.ReceiverCharacter.Id);
}
if (receiverSession == null)
{
return(Ok()); //TODO: not found
}
await receiverSession.SendPacketAsync(message).ConfigureAwait(false);
break;
public override Task ExecuteAsync(ShoutPacket shoutPacket, ClientSession session)
{
var message =
$"({GameLanguage.Instance.GetMessageFromKey(LanguageKey.ADMINISTRATOR, session.Account.Language)}) {shoutPacket.Message}";
var sayPacket = new SayPacket
{
VisualType = VisualType.Player,
VisualId = 0,
Type = SayColorType.Yellow,
Message = message
};
var msgPacket = new MsgPacket
{
Type = MessageType.Shout,
Message = message
};
var sayPostedPacket = new PostedPacket
{
Packet = _packetSerializer.Serialize(new[] { sayPacket }),
SenderCharacter = new Character
{
Name = session.Character.Name,
Id = session.Character.CharacterId
},
ReceiverType = ReceiverType.All
};
var msgPostedPacket = new PostedPacket
{
Packet = _packetSerializer.Serialize(new[] { msgPacket }),
ReceiverType = ReceiverType.All
};
_packetHttpClient.BroadcastPacketsAsync(new List <PostedPacket>(new[] { sayPostedPacket, msgPostedPacket }));
return(Task.CompletedTask);
}
public async Task BroadcastPacketAsync(PostedPacket packet)
{
var list = (await _channelHttpClient.GetChannelsAsync().ConfigureAwait(false))
?.Where(c => c.Type == ServerType.WorldServer) ?? new List <ChannelInfo>();
await Task.WhenAll(list.Select(channel => SendPacketToChannelAsync(packet, channel.WebApi !.ToString()))).ConfigureAwait(false);
}
