public GameResultResponse GetBetResult(BaccaratBet bet)
{
int money = 0;
if (result == BaccaratResultType.Banker)
{
money = bet.BankerBet * 95 / 100 - bet.PlayerBet
- bet.TieBet;
}
else if (result == BaccaratResultType.Player)
{
money = bet.PlayerBet - bet.BankerBet - bet.TieBet;
}
else
{
money = bet.TieBet * 8;
}
int betMoney = bet.BankerBet + bet.PlayerBet + bet.TieBet;
BaccaratResult betResult = new BaccaratResult(result, money, betMoney);
GameResultResponse response = new GameResultResponse();
response.BankerCards = PacketHelper.Serialize(bankerCards);
response.PlayerCards = PacketHelper.Serialize(playerCards);
response.GameResult = (byte)betResult.Type;
response.BetMoney = betResult.BetMoney;
response.MoneyDelta = betResult.Money;
return(response);
}
public void SendAllRoomStatus(GamePeer peer, SendParameters sendParameters)
{
GetRoomsResponse response = new GetRoomsResponse();
response.RoomProperties = PacketHelper.Serialize <RoomPropertyList>(GetRoomProperties());
peer.SendOperationResponse(new OperationResponse(CommonOperationCode.GetRooms, response), sendParameters);
}
private void HandleAcceptedConnection()
{
SendPacket(WorldOpcodes.SMSG_AUTH_CHALLENGE, PacketHelper.Build(new SMSG_AUTH_CHALLENGE
{
Seed = Seed
}));
}
public void Poll()
{
if (c2s.Count <= 0)
{
return;
}
// コマンド処理時、リストに新たなデータを追加される可能性があるため
// 配列に変換して処理します
var list = c2s.ToArray();
c2s.Clear();
foreach (var data in list)
{
using (var ms = new MemoryStream(data))
{
var packet = new PacketHelper(ms);
while (ms.Position < ms.Length)
{
byte[] bytes;
if (packet.Receive(out bytes))
{
if (commandExec != null)
{
commandExec(this, bytes);
}
}
}
}
}
}
private void Server_UserJoinRoom(ClientPackets.JoinRoomPacket packet, Socket socket)
{
User user = GetUser(socket);
Room room = GetRoom(packet.Guid);
// The user's already in this room, so return.
if (room.Users.Contains(user))
{
return;
}
// Otherwise go ahead and proceed.
room.Users.Add(user);
user.Room = room;
// Send a packet to the user either allowing or disallowing joining the room.
SendPacket(socket, PacketHelper.Serialize(new Data.Packets.Server.JoinRoomPacket(true, room)));
// Send refresh and notification packets to all the users in the room.
foreach (var userItem in user.Room.Users)
{
SendPacket(userItem.Socket, PacketHelper.Serialize(new RefreshUsersPacket(room.Users)));
SendPacket(userItem.Socket, PacketHelper.Serialize(new UserJoinedRoomPacket(string.Format("<<< {0} has joined {1} >>>", user.Username, room.Name), user, room)));
}
// Finally, send an update packet to reflect the new user count.
SendPacket(socket, PacketHelper.Serialize(new UpdateRoomsPacket(rooms)));
}
private void Server_PacketReceived(StateObject state)
{
Packet packet = PacketHelper.Deserialize(state.Buffer);
if (packet is LoginPacket)
{
if (UserLogin != null)
{
UserLogin(packet as LoginPacket, state.WorkSocket);
}
}
else if (packet is CreateRoomPacket)
{
if (CreateRoom != null)
{
CreateRoom(packet as CreateRoomPacket, state.WorkSocket);
}
}
else if (packet is ClientPackets.JoinRoomPacket)
{
if (UserJoinRoom != null)
{
UserJoinRoom(packet as ClientPackets.JoinRoomPacket, state.WorkSocket);
}
}
else if (packet is MessagePacket)
{
if (UserMessage != null)
{
UserMessage(packet as MessagePacket, state.WorkSocket);
}
}
}
void conversationService_OnCreateThread(Thread thread, NetworkStream stream)
{
var data = PacketHelper.GetPacketServerAskClientIsOnline();
stream.Write(data, 0, data.Length);
//AppendList(clientid);
}
private void ForestInfo(Session session, Packet packet)
{
var reply = new Packet(packet);
uint forestId;
try
{
forestId = packet.GetUInt32();
}
catch (Exception)
{
ReplyError(session, packet, Error.Unexpected);
return;
}
IForest forest;
if (!forestManager.TryGetValue(forestId, out forest))
{
ReplyError(session, packet, Error.ObjectNotFound);
return;
}
locker.Lock(forest).Do(() =>
{
reply.AddUInt32(UnixDateTime.DateTimeToUnix(forest.DepleteTime.ToUniversalTime()));
PacketHelper.AddToPacket(forest.Wood, reply);
});
session.Write(reply);
}
private void SendResultToPlayers()
{
playerManager.ForEach((player) =>
{
BlackjackPlayer bPlayer = player as BlackjackPlayer;
if (bPlayer.status == PlayerStatus.Playing)
{
BlackjackDeckResults deckResults = new BlackjackDeckResults();
deckResults.deckResults = new List <BlackjackResult>();
int moneyDelta = 0;
for (int i = 0; i < playerCards[bPlayer].Count; i++)
{
BlackjackResult result = GetGameResult(bPlayer, i, playerBetsDic[player].initialBet);
deckResults.deckResults.Add(result);
moneyDelta += result.Money;
}
GameResultResponse response = new GameResultResponse();
response.deckResults = PacketHelper.Serialize <BlackjackDeckResults>(deckResults);
response.BetMoney = playerBetsDic[player].initialBet;
response.DealerCards = PacketHelper.Serialize <CardSet>(dealerCards);
bPlayer.peer.SendOperationResponse(new OperationResponse(CommonOperationCode.BaccaratGameResult, response), new SendParameters());
bPlayer.money += moneyDelta;
//WebHelper.UpdatePlayerMoney(player.name, moneyDelta);
}
else
{
GameResultResponse response = new GameResultResponse();
response.BetMoney = 0;
response.DealerCards = PacketHelper.Serialize <CardSet>(dealerCards);
bPlayer.peer.SendOperationResponse(new OperationResponse(CommonOperationCode.BaccaratGameResult, response), new SendParameters());
}
});
}
private void Awake()
{
packetHelper = new PacketHelper();
networkHelper = GetComponent <NetworkHelper>();
_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
}
// When server receives data open the appropriate method and then resend the packet to all existing clients.
protected virtual void OnDataReceived(NetIncomingMessage msg)
{
string packet_name = msg.ReadString();
string packet_identifier = msg.ReadString();
NetOutgoingMessage outMsg = server.CreateMessage();
Console.WriteLine("Message Received In Server: " + packet_name + " packet");
if (Packet_Register.Instance.packetTypes.ContainsKey(packet_name))
{
Object instance = Activator.CreateInstance(Packet_Register.Instance.packetTypes[packet_name], packet_identifier);
MethodInfo openMethod = Packet_Register.Instance.packetTypes[packet_name].GetMethod("OpenPacketFromMessage");
object packet = openMethod.Invoke(instance, new object[] { msg });
bool shouldResend = false;
//If it needs to be adjusted then adjust the packet
if (Packet_Register.Instance.serverPacketReceivedRegister.ContainsKey(packet_identifier))
{
shouldResend = Packet_Register.Instance.serverPacketReceivedRegister[packet_identifier].Invoke(new object[] { packet, msg.SenderConnection });
}
MethodInfo packMethod = Packet_Register.Instance.packetTypes[packet_name].GetMethod("PackPacketIntoMessage");
outMsg = PacketHelper.AddDefaultInformationToPacket(outMsg, packet_name, packet_identifier);
outMsg = packMethod.Invoke(instance, new object[] { outMsg, packet }) as NetOutgoingMessage;
if (shouldResend)
{
server.SendToAll(outMsg, NetDeliveryMethod.ReliableOrdered);
}
}
}
public byte[] GetObjectBytes()
{
while (isDirty)
{
// Players must always be locked first
primaryLock.EnterReadLock();
var playersInRegion = primaryObjects.ToArray <ILockable>();
var currentLastUpdated = regionLastUpdated;
primaryLock.ExitReadLock();
var isDone = lockerFactory().Lock(playersInRegion).Do(() =>
{
// Enter write lock but give up all locks if we cant in 1 second just to be safe
if (!primaryLock.TryEnterWriteLock(1000))
{
return(false);
}
// ReSharper disable ConditionIsAlwaysTrueOrFalse
// ReSharper disable HeuristicUnreachableCode
if (!isDirty)
{
primaryLock.ExitWriteLock();
return(true);
}
// ReSharper restore HeuristicUnreachableCode
// ReSharper restore ConditionIsAlwaysTrueOrFalse
if (currentLastUpdated != regionLastUpdated)
{
primaryLock.ExitWriteLock();
return(false);
}
var dummyPacket = new Packet();
// Write tiles
dummyPacket.AddBytes(map);
// Write objects
dummyPacket.AddUInt16(primaryObjects.Count);
foreach (ISimpleGameObject obj in primaryObjects)
{
PacketHelper.AddToPacket(obj, dummyPacket, true);
}
objects = dummyPacket.GetPayload();
isDirty = false;
primaryLock.ExitWriteLock();
return(true);
});
if (isDone)
{
break;
}
}
return(objects);
}
private void Awake()
{
networkManager = GetComponent <NetworkManager>();
uiManager = GetComponent <UIManager>();
packetHelper = new PacketHelper();
gameManager = GetComponent <GameManager>();
}
public void Poll()
{
if (!Connected())
{
return;
}
session.EachReceive(receive =>
{
using (var ms = new MemoryStream(receive))
{
var packet = new PacketHelper(ms);
while (ms.Position < ms.Length)
{
byte[] bytes;
if (packet.Receive(out bytes))
{
if (ReceviedEvent != null)
{
ReceviedEvent(bytes);
}
}
}
}
});
}
private void BattleReinforceAttacker(IBattleManager battle, ICombatGroup combatGroup)
{
var packet = CreatePacket(battle, Command.BattleReinforceAttacker);
PacketHelper.AddToPacket(combatGroup, packet);
channel.Post(channelName, packet);
}
/// <summary>
/// Sends a text message to the server's specified chat room.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="room">The room to send the message to.</param>
public void SendMessage(string message, Room room)
{
if (room != null)
{
SendPacket(PacketHelper.Serialize(new MessagePacket(message, room)));
}
}
public void SendAvatarInfo(Character toCharacter)
{
var packet = new Packet(ServerMessages.TOURNAMENT_AVATAR_INFO);
for (var i = 0; i < SLOTS; i++)
{
var id = Match[i, 0]; // Initial player list
var player = GetPlayer(id);
if (player == null)
{
packet.WriteBool(false);
}
else
{
packet.WriteBool(true);
PacketHelper.AddAvatar(packet, player);
packet.WriteString(player.Name);
}
}
if (toCharacter != null)
{
toCharacter.SendPacket(packet);
}
else
{
SendPacket(packet);
}
}
private void GetInfo(Session session, Packet packet)
{
var reply = new Packet(packet);
uint id;
try
{
id = packet.GetUInt32();
}
catch (Exception)
{
ReplyError(session, packet, Error.Unexpected);
return;
}
ITribe tribe;
locker.Lock(id, out tribe).Do(() =>
{
if (tribe == null)
{
ReplyError(session, packet, Error.TribeNotFound);
return;
}
PacketHelper.AddTribeInfo(strongholdManager, tribeManager, session, tribe, reply);
session.Write(reply);
});
}
public ConnectionPolicy(QQClient client, string id, ProtocolFamily supportedFamily, ProtocolFamily relocateFamily)
{
this.ID = id;
this.client = client;
this.SupportedFamily = supportedFamily;
this.RelocateFamily = relocateFamily;
helper = new PacketHelper();
}
// Adds the default information to a packet and sends it to a specific client.
public void SendPacketToExistingConnection <T>(T packet, NetConnection conn) where T : Packet <T>
{
NetOutgoingMessage msg = server.CreateMessage();
msg = PacketHelper.AddDefaultInformationToPacket(msg, typeof(T).Name, packet.Get_PacketIdentifier());
msg = packet.PackPacketIntoMessage(msg, packet);
server.SendMessage(msg, conn, NetDeliveryMethod.ReliableOrdered);
}
public static void Text(GameClient Client, string Text)
{
NpcDialog *Packet = PacketHelper.NpcPacket(Text);
Packet->OptionType = NpcOptionType.Dialogue;
Client.Send(Packet, Packet->Size);
Memory.Free(Packet);
}
public Session(TcpClient client, Action <Session, byte[]> commandExec)
{
this.client = client;
this.stream = client.GetStream();
this.packet = new PacketHelper(this.stream);
this.userInfo = new UserInfo();
this.commandExec = commandExec;
}
public static void Finish(GameClient Client)
{
NpcDialog *Packet = PacketHelper.NpcPacket();
Packet->OptionType = NpcOptionType.Finish;
Client.Send(Packet, Packet->Size);
Memory.Free(Packet);
}
private void chatTextBox_KeyDown(object sender, KeyEventArgs e)
{
if (_client != null && _client.IsConnected && e.KeyCode == Keys.Enter && !string.IsNullOrWhiteSpace(currentChatText))
{
_client.SendPacketToServer(PacketHelper.CreateUserToServerChatMessage(currentChatText));
chatTextBox.Text = string.Empty;
}
}
// Adds the default information to a packet and sends it to the server.
public virtual void SendPacketToServer <T>(T packet) where T : Packet <T>
{
NetOutgoingMessage msg = client.CreateMessage();
msg = PacketHelper.AddDefaultInformationToPacket(msg, typeof(T).Name, packet.Get_PacketIdentifier());
msg = packet.PackPacketIntoMessage(msg, packet);
client.SendMessage(msg, NetDeliveryMethod.ReliableOrdered);
}
private void TribeOnRanksUpdated(object sender, TribeEventArgs e)
{
Packet packet = new Packet(Command.TribeChannelRanksUpdate);
PacketHelper.AddTribeRanksToPacket(e.Tribe, packet);
Global.Current.Channel.Post("/TRIBE/" + e.Tribe.Id, packet);
}
public override void SendPacketToServer <T>(T packet)
{
NetOutgoingMessage msg = client.CreateMessage();
msg = PacketHelper.AddDefaultInformationToPacketWithId(msg, typeof(T).Name, packet.Get_PacketIdentifier(), player_id);
msg = packet.PackPacketIntoMessage(msg, packet);
client.SendMessage(msg, NetDeliveryMethod.ReliableOrdered);
}
private void ProfileByType(Session session, Packet packet)
{
var reply = new Packet(packet);
string type;
uint id;
try
{
type = packet.GetString().ToLowerInvariant();
id = packet.GetUInt32();
}
catch (Exception)
{
ReplyError(session, packet, Error.Unexpected);
return;
}
if (type == "city")
{
ICity city;
locker.Lock(id, out city).Do(() =>
{
if (city == null)
{
ReplyError(session, reply, Error.PlayerNotFound);
return;
}
PacketHelper.AddPlayerProfileToPacket(city.Owner, reply);
session.Write(reply);
});
return;
}
if (type == "stronghold")
{
IStronghold stronghold;
locker.Lock(id, out stronghold).Do(() =>
{
if (stronghold == null || stronghold.StrongholdState == StrongholdState.Inactive)
{
ReplyError(session, reply, Error.ObjectNotFound);
return;
}
PacketHelper.AddStrongholdProfileToPacket(session, stronghold, reply);
session.Write(reply);
});
return;
}
ReplyError(session, packet, Error.Unexpected);
}
private void AttackCity(Session session, Packet packet)
{
uint cityId;
uint targetCityId;
Position target;
ISimpleStub simpleStub;
AttackMode mode;
try
{
mode = (AttackMode)packet.GetByte();
cityId = packet.GetUInt32();
targetCityId = packet.GetUInt32();
target = new Position(packet.GetUInt32(), packet.GetUInt32());
simpleStub = PacketHelper.ReadStub(packet, FormationType.Attack);
}
catch (Exception)
{
ReplyError(session, packet, Error.Unexpected);
return;
}
var cityNotFound = locker.Lock(session.Player).Do(() => session.Player.GetCity(cityId) == null);
if (cityNotFound)
{
ReplyError(session, packet, Error.Unexpected);
return;
}
Dictionary <uint, ICity> cities;
locker.Lock(out cities, cityId, targetCityId).Do(() =>
{
if (cities == null)
{
ReplyError(session, packet, Error.Unexpected);
return;
}
ICity city = cities[cityId];
var troopInitializer = troopObjectInitializerFactory.CreateCityTroopObjectInitializer(cityId,
simpleStub,
TroopBattleGroup.Attack,
mode);
var attackAction = actionFactory.CreateCityAttackChainAction(cityId,
troopInitializer,
targetCityId,
target);
var result = city.Worker.DoPassive(city, attackAction, true);
ReplyWithResult(session, packet, result);
});
}
public static void Option(GameClient Client, byte OptionID, string Text)
{
NpcDialog *Packet = PacketHelper.NpcPacket(Text);
Packet->OptionType = NpcOptionType.Option;
Packet->OptionID = OptionID;
Client.Send(Packet, Packet->Size);
Memory.Free(Packet);
}
