;Um einen Chat zu Bauen brauchst du einen Server und einen Clienten, hier beginnen wir mit dem Clienten
;Die Verbindung ist erstellt, d.h. jetzt können Daten empfangen werden und gesendet werden, bei UDP ist jedoch zu beachten, dass Daten \"blind\" gesendet werden, d.h. du sendest an eine Adresse, von der der Client nicht weiß, ob der Server auch online ist
;Ums einfach zu halten und zu garantieren, dass es funktioniert senden wir an die lokale Adresse 127.0.0.1 dafür brauchen wir auch keine Internetverbindung
;Um eine Nachricht zu senden, \"schreiben\" wir die Nachricht auf die Verbindung das geht so:
WriteString stream,\"Hallo ich bin eine Nachricht vom Clienten!\"
;Jetzt haben wir eine Zeichenkette auf den Stream mit dem Namen \"stream\" geschrieben, nun müssen wir sie auch noch absenden, das ist etwas schwerer:
;Zuerst brauchen wir die IP des Servers, an den wir die Nachricht senden wollen, die müssen wir natürlich wissen, da wir an uns selbst schicken lautet sie 127.0.0.1, damit kann der UDP-Befehl aber nichts anfangen, sonder nur der TCP-Befehl kann sie verarbeiten. Für UDP brauchen wir die Integer-Adresse des PCs die wir aus der \"normalen\" ableiten lassen können:
;Hierzu gibts eine Funktion, die ich selbst noch nicht hinterfragt habe, denn sie funktioniert und es ist nicht unbedingt wichtig wie sies tut *gg*:
Function verarb_ipwandeln(ip$)
	CountHostIPs(ip$) 
	Return HostIP(1) 
End Function
;Man ruft diese Funktion mit der IP \"127.0.0.1\" auf und bekommt die Integer-IP zurückgeliefert, das geht so:
server_ip=verarb_ipwandeln(\"127.0.0.1\")
;den Rückgabewert habe ich jetzt in der Variable \"server_ip\" gespeichert. Die Funktion und die Variable können natürlich nach Belieben umbenannt werden.
;Nun brauchen wir noch den Server-Port! Diesen brauch man nicht umzuwandeln, man muss ihn nur wissen, wir verwenden  einfach \"8080\" damit kriegen wir die geringsten Probleme
server_port=8080
;Jetzt haben wir, was wir brauchen und können die UDP-Nachricht absenden, das geht so:
SendUDPMsg stream,server_ip,server_port
;Ich schicke alles, was auf \"stream\" geschrieben wurde an den Server mit der IP \"server_ip\" an den Port \"server_port\"
;Natürlich kann man auch mehrere Sachen auf den stream schreiben, die dann vom Server nacheinander augelesen werden, dies ginge beispielsweise so:
WriteInt stream,1
WriteString stream,\"Hallo ich bin eine Nachricht\"
WriteString stream,\"Hallo ich bin auch eine Nachricht\"
SendUDPMsg stream,server_ip,server_port
;Da würde ich zerst einen Integer-Wert auf den stream schreiben, dann zwei Strings und dann alles zu sammen absenden
;Jetzt ist unser \"einfacher Client\" fertig, aber es reicht um das System zu verstehen. Damit ein Client auch Daten empfangen kann, muss er nachher mit Funktionen ausgestattet werden, wie wir sie jetzt im Server verwenden. Der Code für den Clienten hier noch mal zusammengefasst:

;Nun zum Server:
;Auch hier müssen wir erst einen Stream erstellen, wie bereits bekannt so:
stream=CreateUDPStream(8080)
;Dieses mal geben wir aber den Port an, weil der Client ja nur an den Port 8080 sendet
;Der Stream steht, also können nun Daten gesendet und empfangen werden. Weil der Server aber nicht weiß, wann Daten eintreffen, müssen wir in einer Schleife permanent abfragen, ob neue Daten eingetroffen sind. Das geht so:
Repeat
	client_ip=RecvUDPMsg(stream)
	If client_ip<>0 Then
	
	EndIf
Forever
;Das ist erst ein Fragment der Schleife: Der Befehl RecvUDPMsg(stream) fragt den Stream mit dem Namen \"stream\" ab, ob ein Client Daten gesendet hat, ist das der Fall, liefert er die Integer-IP des Clienten zurück, sind keine neuen Daten vorhanden, so liefert der Befehl 0 zurück
;Die If-Abfrage führt also den Code nur aus, wenn Daten von einem Clienten empfangen wurden, jetzt ergänzen wir die if-Anweisung
Repeat
	client_ip=RecvUDPMsg(stream)
	If client_ip<>0 Then
		nachricht$=ReadString$(stream)
		Notify \"Nachricht vom Client: \"+nachricht$
	EndIf
Forever
;Wenn also Daten auf \"stream\" ankommen, dann ließt der Befehl ReadString(stream) die Daten von \"stream\" und speichert sie in \"nachricht$\"
;Man sieht also, man sollte vorher wissen, welche Daten der Client sendet
;Hierfür lasse ich den Clienten immer zuerst einen Zahlenwert senden meinetwegen \"1\" für Anmeldung, dann weiß der Server, dass nun \"Benutzername, Passwort\" etc. als Daten eintreffen, denn man muss Integer über readInt(stream) String über readString(stream) usw. jeweils nach Datentyp einlesen
;Erwarte ich mehrere einkommende Daten, dann führe ich meinetwegen readString$(stream)/readInt(stream) so oft aus, wie Daten eintreffen, das kann dann so aussehen:
Repeat
	client_ip=RecvUDPMsg(stream)
	If client_ip<>0 Then
		nachrichtenart=ReadInt(stream) ;es wird der Typ der einkommenden Nachrichten ausgelesen, damit ich weiß, welche read-Befehle ich benutzen muss
		Select nachrichtenart
			Case 1:			;beispielsweise Anmeldung
				benutzername$=ReadString$(stream)			
				passwort$=ReadString$(stream)
			Case 2:			;beispielsweise Registrierung
				benutzername$=ReadString$(stream)			
				passwort$=ReadString$(stream)
				email$=ReadString$(stream)
				id=ReadInt(stream)			
		End Select
	EndIf
Forever
;Möchte ich nun eine Nachricht an den Clienten zurückschicken ist das nicht schwer: Die IP habe ich schon aus RecvUDPMsg(stream) unter \"client_ip\" gespeichert und den Port, an den ich senden muss bekomme ich durch UDPStreamPort(stream) zurückgeliefert, dann kann der Server ebenso über den stream Daten senden wie der Client, dafür muss aber kein neuer Stream erstellt werden, der alte kann immer wieder verwedet werden.
;Das wars, ich hoffe es war etwas hilfreich ^^\"
;Den Code für den Test-Server noch mal zusammengefasst: 

Graphics 640,480,24,2
SetBuffer BackBuffer()

;Variablen
	Global inp_stream
	Global out_stream
	;global out_stream = CreateUDPStream()
	;global server_ip = get_ip(\"127.0.0.1\")
	Global out_port = 8080
	Global inp_port = 8081
	Global name$
	Global nachricht$
	Global income$
	Global client_ip$
	Global msg_txt$ = \"_\"
	Global player_ip
;Username
	Global u_name$
	
	Type player
		Field net_id
		Field name$
	End Type
	
;Message
	Type message
		Field value$
	End Type
;Schriftarten laden
	Global font1 = LoadFont(\"Arial\",16)
	Global font2 = LoadFont(\"Arial\",16,1)
	SetFont font2

;<-------------Hauptmenü-------------->
Print \"Chat#1 © by KHORN\"
Print \"Special Thanks : Noa\"
Print \"\"
Print \"Was möchten Sie tun ?\"
Print \"[1]Server\"
Print \"[2]Client\"
Global wahl = Input(\"\")
If wahl = 1
	server_ip = get_ip(\"127.0.0.1\")
	Print server_ip
	out_port = 8080
  inp_port = 8081

EndIf
If wahl = 2
	ip$ = Input(\"IP : \")
	Print ip
	server_ip = get_ip(ip)
	Print server_ip
	
	out_port = 8081
  inp_port = 8080

	;writestring inp_stream, \"3 \"+u_name
	;SendUDPMsg inp_stream, server_ip, server_port	
EndIf

	out_stream = CreateUDPStream(out_port)
	inp_stream = CreateUDPStream(inp_port)
  Print inp_stream
	Print out_stream

	
u_name = Input(\"Name : \")
WriteString out_stream, \"2 \"+u_name+\" hat den Chat betreten.\"
SendUDPMsg out_stream, server_ip, out_port

WriteString out_stream, \"4 \"+u_name
SendUDPMsg out_stream, server_ip, out_port
;<------------------------------------>

Cls
SetFont font1

Repeat
Cls;####################################################################
;Nachrichtentypen--------------------------|
;1 = Normale Chatnachricht
;2 = Speziele Chatnachricht
;3 = Testen ob der Server aktiv ist.
;------------------------------------------|
	If KeyHit(28) And msg_txt <> \"\" And msg_txt <> \" \"
		msg_txt = Left(msg_txt,Len(msg_txt)-1)
		WriteString out_stream, \"1 \"+u_name+\"|\"+msg_txt$
		SendUDPMsg out_stream, server_ip, out_port
		msg_txt = \"_\"
	EndIf
	
	 ;funcs--------|
   write_msg()		
   show_msgs()
   show_users()
   ;-------------|

   Delay 20

   client_ip=RecvUDPMsg(inp_stream)

If client_ip<>0 Then

income$=ReadString$(inp_stream)
For i = 1 To Len(income$)	;Einkommende Nachricht zerlegen(Name,Nachricht).
If Mid(income, i, 1) = \"|\"
name$ = Mid(income, 3,i-3)
nachricht$ = Mid(income,i+1,-1)
EndIf
Next
		
msg_typ = Left(income,2);Typ der Nachricht.
add_msg(name+\" : \"+client_ip)
Select msg_typ
	Case 1  		
		add_msg(name+\" : \"+nachricht)
		For p.player = Each player ;Nachrichten an alle User weiterleiten.
			If p\net_id <> server_ip
			add_msg(\"<System> : Nachricht wird weitergeleitet an :\"+p\name)
			WriteString out_stream, income
			SendUDPMsg out_stream, server_ip, out_port
			EndIf
		Next

	Case 2
		nachricht = Mid(income,3,-1)
		If wahl = 1 And client_ip <> server_ip
		WriteString out_stream,income
		SendUDPMsg out_stream, client_ip, out_port
		EndIf
		add_msg(nachricht)

	Case 3
		ip = UDPMsgIP(inp_stream)
		ip = DottedIP(ip)
		Print ip

	Case 4 ;User in die Liste.
		nachricht = Mid(income,3,-1)
		create_player(nachricht,client_ip)
 		
End Select
	 		
EndIf

Flip;###################################################################
Until KeyHit(1)

;IP umwandeln in Int.IP des PC´s
Function get_ip(ip$)
   CountHostIPs(ip$)
   Return HostIP(1)
End Function
;Nachricht tippen.
Function write_msg()

	key = GetKey()
	
	If key >= 32 And key <= 127
		If Len(msg_txt) > 0 Then msg_txt = Left(msg_txt,Len(msg_txt)-1)
		msg_txt = msg_txt+Chr(key)
		msg_txt = msg_txt + \"_\"
	EndIf

	Text 0,0, msg_txt$

	If KeyDown(14) And Len(msg_txt) > 0
		msg_txt = Left(msg_txt,Len(msg_txt)-1)
	EndIf

End Function
;Nachricht hinzufgen.
Function add_msg(value$)

	msg.message = New message
	msg\value = value

End Function
;Nachrichten anzeigen
Function show_msgs()
	i = 1
	For msg.message = Each message
		Text 0,15*i, msg\value
		i = i + 1
		If i >= 30
			Delete First message
		EndIf
	Next
End Function
;Userliste
Function create_player(p_name$,p_id)

	p.player = New player
	p\net_id = p_id
	player_ip = p\net_id
	p\name = p_name
	
End Function
;Userliste anzeigen.
Function show_users()
	
	i = 1
	For p.player = Each player
		Text 450,15*i, i+\". \"+p\name+\"  || ID : \"+p\net_id
		i = i + 1
	Next

End Function