Array Per Sendbuf über ServerSocket senden.

[Schaedel]

Hallo und guten Morgen,

ich sitz hier in der Schule und bin an einem 4 Spieler ping pong am programmieren.
Ich habe ein kleines Problem mit dem Senden des Arrays an die anderen Clienten.

Wir nutzen hier Delphi 6 Personal.

hier der Code zum Versenden und Empfangen

Delphi-Quellcode:

type
  Spieler = record
    ID : integer;
    x1 : integer;
    y1 : integer;
  end;
var
Serverarray : Array of Spieler;
Spielerarray : Array of Spieler;

Senden

Delphi-Quellcode:

procedure TForm3.ServerSocket1ClientRead(Sender: TObject;  Socket: TCustomWinSocket);
var
  i : integer;
begin
  Socket.ReceiveBuf(Buffer,sizeof(Buffer));
  Serverarray[buffer.ID-1].ID := Buffer.ID;
  Serverarray[buffer.ID-1].x1 := Buffer.x1;
  Serverarray[Buffer.ID-1].y1 := Buffer.y1;
  for i := 0 to connections-1 do begin
    ServerSocket1.Socket.Connections[i].SendBuf(Serverarray,sizeof(Serverarray));
  end;

 // edit2.Text := Socket.ReceiveText;
  //ServerSocket1.Socket.Connections[0].SendText(Edit1.text);
end;

Empfangen

Delphi-Quellcode:

procedure TForm3.ClientSocket1Read(Sender: TObject;  Socket: TCustomWinSocket);
begin
if not(Connected) then begin
  socket.receivebuf(Spielerarray[0],sizeof(spielerarray[0]));
  Connected := true;
end else begin
  clientsocket1.socket.ReceiveBuf(Spielerarray,sizeof(Spielerarray));
//  for i := 0 to 0 do begin
   // TShape(FindComponent('Shape'+inttostr(i))).left := Spielerarray[i-1].x1;
   // TShape(FindComponent('Shape'+inttostr(i))).top  := Spielerarray[i-1].y1;
   memo1.lines.add('id: '+inttostr(Spielerarray[0].id)+ 'x1: '+inttostr(Spielerarray[0].x1)+'y1: '+ inttostr(Spielerarray[0].y1));
//  end;
end;

Das Array kommt nicht an.
Es ist immer leer nach dem einlesen.
Wenn wir nur einen Record Datensatz schicken dann kommt dieser an.

Jemand ne Idee wie man ein Array versenden kann?


Dank im Vorraus!

So Far

Schaedel

[Muetze1]

ServerArray ist ein Zeiger und daher überträgt er die Adresse des Array und nicht dessen Inhalt. Abhilfe: schicke als erstes die Anzahl der Einträge und danach die Einträge des Array einzelnd nacheinander. Beim Auslesen als erstes die Anzahl der folgenden Einträge und dann die Einträge auslesen.

[himitsu]

Na ja, einzeln brauch er die nicht unbedingt zu senden, da die eh schon nett hintereinander aufgereit sind. (solange keine weiteren Pointerbasierenden Typen in den einzelnen ArrayFeldern virhanden sind, wie z.B. Strings, dynamische Arrays...)

Erstmal sicherstellen, daß überall und immer die Typen gleich groß sind, denn durch Speicherausrichtung lönnen sich da leicht schon mal ein paar Bytes einschleichen und dann stehen, bei unterschiedlicher Ausrichtung, die Werte bei den beiden Programmen an 'ner anderen Position (im Array).

Code:

type
  TSpieler = [b]packed[/b] record
    ID : integer;
    x1 : integer;
    y1 : integer;
  end;
var
Serverarray : [b]packed[/b] Array of TSpieler;
Spielerarray : [b]packed[/b] Array of TSpieler;

siehe OH PACKED

Also ginge es auch in etwa so ... alle Felder Length(TArray) mit einer Feldgröße von SizeOf(Spieler), also zusammem Length(TArray)*SizeOf(Spieler) werden von der Speichposition des ersten Feldes TArray[0] zusammen gelesen/gesendet und empfangen/geschrieben.

Delphi-Quellcode:

ServerSocket1.Socket.Connections[i].SendBuf(Length(Serverarray), SizeOf(Integer)); 
ServerSocket1.Socket.Connections[i].SendBuf(Serverarray[0], Length(Serverarray) * SizeOf(Spieler));

ClientSocket1.Socket.ReceiveBuf(i, SizeOf(Integer));
SetLength(Spielerarray, i);
ClientSocket1.Socket.ReceiveBuf(Serverarray[0], Length(Serverarray) * SizeOf(Spieler));

PS: wenn du dir mal die Größe der gesendeten/empfangen Daten angesehn hättest, dann hätte dir auch auffallen konnen, daß SizeOf(Spielerarray) immer 4 ist, was rein zufällig 4 Byte sind, also SizeOf(Pointer) entspricht ^^