C# Game Server vanaf Sketch

[slabbetje]

Beste helpers,

Ik ben bezig met het leren van C# doormiddel van het bouwen van een Game Server / Private server. Nu ben ik inmiddels aangekomen bij een Tcp connectie om meerdere spelers binnen een server te laten alleen snap ik hier niet echt de werking van.

Hoe kan ik dus de connectie leggen met de Client en de Server?
Want ik neem aan dat je een Sender en Responder moet schrijven maar is dit voor elke client het zelfde of zit hier een verschil in per game/client?

Als iemand mij dit kan beantwoorden zou ik dit fijn vinden, Tutorials zijn ook welkom als dit te moeilijk is...

Mvg,

Michael

 

[edmoor]

Ik kan je er niet mee helpen maar bedoel je niet 'scratch' in plaats van 'sketch'.

 

[slabbetje]

Ja i know ik zag het wat te laat en kan het niet meer aanpassen

Edit: De connectie word nu succesvol gemaakt ik heb alleen nog het antwoord nodig hoe dat zit met die game clients...

 

[jimowns]

Voor een private server te maken moet je gebruik maken van packets.

Wat zijn packets ?
laten we als voorbeeld het spel WoW nemen.

Een packet is een serie van bytes(normaal in hexdecimale getallen) wat de server en computer naar elkaar versturen.
Het is hetzelfde als 2 mensen tegen elkaar zitten te praten, ze wisselen informatie.
Bij computers versturen ze de packets naar elkaar en vragen ze voor informatie te krijgen.
In WoW zijn de packets gedecodeerd, dus ze kunnen geen willkeurige packet in ontvangst nemen.
De Client decodeerd de packet en stuurt de antwoorden die zijn gedecodeerd.
De Server laat alleen de Client de packetten versturen.


Hoe kan je zo'n packet krijgen?
Je download een packet sniffer of een packet analyser.


Elk spel heeft zen eigen packets dus daar gaat de server al zeggen van: Ik ken dit packet niet dus geen verbinding maken
maar ook elk spel connecteerd op een bepaalde poort
voor ROSE liggen deze op 29000/29100/29200
maar een ander spel bijv WoW liggen deze poorten op 8700/8701


Ik heb zelf ook een private server aan het maken.
Maar ben er voor de moment even mee gestopt.


Hier is mijn packet in C# , Maar deze is nog niet af

    public class Packet
    {
        // Fields
        public ushort Size;
        public ushort Command;
        public ushort UnUsed;
        public byte[] BYTE = new byte[4096]; 

        //default constructor
        public Packet()
        {
            Size = 8;
            Command = 0;
            UnUsed = 0;
        }
        // Constructor
        public Packet(ushort Hex, ushort size, ushort unused)
        {
            Hex = Command;
            size = Size;
            unused = UnUsed;
        }
        // Constructor. 
        public Packet(ushort HexGetal)
        {
            Size = 8;      
            UnUsed = 0;
            Command = HexGetal;
        }
        // Methode 
        public void AddByte(byte Value) 
        {
            BYTE[Size] = Value;  
            Size += 1; 
        }
        // methode
        public void AddString(string Value)
        {
            byte[] CharValue = System.Text.Encoding.Default.GetBytes(Value);   
            for (int i = 0; i < CharValue.Length; i++)     
                AddByte(CharValue[i]); 
        }
        public void EndPack()
        {
            /* Maak hier een einde packet*/ 
        }

        public void Decryption()
        {
            /*
             * maak hier uw decrypt             */
        }
        public void Encryption()
        {
            /*
             * maak hier uw Encryption 
             */
        }

Voor connectie te leggen naar de client to op een IP: 127.0.0.1 of uw eigen IP, is het voor elk spel anders.
Bij het eene spell moet je de connectie leggen met een executable file met daarachter een IP, voorbeeld: Text.exe 127.0.0.1
En bij een ander spel is dat gewoon een bestandje openen in textblok en IP verranderen.
Het is dus voor elk spel verschillend.

Maar over welk spel gaat het ? als ik vragen mag


PS:: Een private server maken is legaal alleen als het voor eigen gebruik is.
Als je uw server publiek wil stellen, bestaat de kans dat je boetes kan krijgen, Maar normaal waarschuwen ze u eerst.
Je mag het publiek stellen, onder bepaalde voorwaardes, dat is bij sommige van die spelletjes het geval.




Met vriendelijke groetjes Jim.

 

[slabbetje]

De server gaat wel publiek worden zonder commercieel doel...
Misschien wel in de vorm van donatie om een snellere/betere server af te huren.
Ook zal ik goed vermelden dat dit niet de offici�le site is alvorens je de site op kan.
Want het is niet eens mijn doel om mensen te hacken of iets maar wil dit juist voorkomen.

P.s. Ik ben er inmiddels uit hoe dit werkt en ook dat de packets base64 gecodeerd zijn, niet zo moeilijk dus.

Edit: Ik heb inmiddels mijn Stream reader af nu alleen nog de responder en de manager natuurlijk.

[CPP] /// <summary>
/// This is the stream reader
/// </summary>
public class Stream
{
#region Fields
/// <summary>
/// The id of the sended packet
/// </summary>
private uint PacketId;

/// <summary>
/// The body of the sended packet
/// </summary>
private List<byte> Body;
#endregion Fields

#region Properties
/// <summary>
/// Gets the id of the sended packet
/// </summary>
public uint Id { get { return PacketId; } }

/// <summary>
/// Gets the header of the sended Message
/// </summary>
public string Header { get { return GameServer.DefaultEncoding.GetString(Base64Encoding.Encodeuint(PacketId, 2)); } }

/// <summary>
/// Gets the length of the packet
/// </summary>
public int Length { get { return Body.Count; } }
#endregion Properties

#region Constructors
public Stream(uint _PacketId)
{
Init(_PacketId);
}
#endregion Constructors

#region Methods
/// <summary>
/// Overwrite the ToString function from C# by a new one
/// </summary>
/// <returns></returns>
public override string ToString()
{
return Header + Encoding.Default.GetString(Body.ToArray());
}

/// <summary>
/// Gets the Body in a string
/// </summary>
/// <returns></returns>
public string ToBodyString()
{
return Encoding.Default.GetString(Body.ToArray());
}

/// <summary>
/// Clear the Body
/// </summary>
public void Clear()
{
Body.Clear();
}

/// <summary>
/// Initialize function for the Packet sender
/// </summary>
/// <param name="_PacketId">Id of the Packet</param>
public void Init(uint _PacketId)
{
PacketId = _PacketId;
Body = new List<byte>();
}

/// <summary>
/// Add a single byte
/// </summary>
/// <param name="b">Byte</param>
public void AppendByte(byte b)
{
Body.Add(b);
}

/// <summary>
/// Adding multiple bytes
/// </summary>
/// <param name="Data"></param>
public void AppendBytes(byte[] Data)
{
if (Data == null || Data.Length == 0)
{
return;
}

Body.AddRange(Data);
}

/// <summary>
/// Transform a string to bytes using a custom encoder
/// </summary>
/// <param name="s">String</param>
/// <param name="Encoding">Encoding class</param>
public void AppendString(string s, Encoding Encoding)
{
if (s == null || s.Length == 0)
{
return;
}

AppendBytes(Encoding.GetBytes(s));
}

/// <summary>
/// Transform a string to bytes using the default encoder
/// </summary>
/// <param name="s"></param>
public void AppendString(string s)
{
AppendString(s, Encoding.Default);
}

/// <summary>
/// Add a break to the body
/// </summary>
public void AppendBreak()
{
AppendStringWithBreak("");
}

/// <summary>
/// Add a break to the body
/// </summary>
/// <param name="s">String</param>
public void AppendStringWithBreak(string s)
{
AppendStringWithBreak(s, 2);
}

/// <summary>
/// Adds a String with a break character
/// </summary>
/// <param name="s">String</param>
/// <param name="BreakChar">Breakcharacter</param>
public void AppendStringWithBreak(string s, byte BreakChar)
{
AppendString(s);
AppendByte(BreakChar);
}

/// <summary>
/// Adds a int32 to the Bytes
/// </summary>
/// <param name="i">Int32</param>
public void AppendInt32(Int32 i)
{
AppendBytes(WireEncoding.EncodeInt32(i));
}

/// <summary>
/// Adds a raw int32 to the Bytes
/// </summary>
/// <param name="i">Int32</param>
public void AppendRawInt32(Int32 i)
{
AppendString(i.ToString(), Encoding.ASCII);
}

/// <summary>
/// Adds a uint
/// </summary>
/// <param name="i">Uint</param>
public void AppendUInt(uint i)
{
Int32 _i = (Int32)i;
AppendInt32(_i);
}

/// <summary>
/// Adds a raw uint
/// </summary>
/// <param name="i">Uint</param>
public void AppendRawUInt(uint i)
{
Int32 _i = (Int32)i;
AppendRawInt32(_i);
}

/// <summary>
/// Adds a Boolean to the bytestring
/// </summary>
/// <param name="Bool"></param>
public void AppendBoolean(Boolean Bool)
{
if (Bool)
{
Body.Add(WireEncoding.POSITIVE);
}
else if (!Bool)
{
Body.Add(WireEncoding.NEGATIVE);
}
}

/// <summary>
/// Get all the bytes
/// </summary>
/// <returns>Base 64 encoded byte</returns>
public byte[] GetBytes()
{
byte[] Data = new byte[Length + 3];
byte[] Header = Base64Encoding.Encodeuint(PacketId, 2);

Data[0] = Header[0];
Data[1] = Header[1];

for (int i = 0; i < Length; i++)
{
Data[i + 2] = Body;
}

Data[Data.Length - 1] = 1;

return Data;
}
#endregion Methods

}[/CPP]