[Abandonné]Open Space : Idée d'un metaverse 100% Pure Basic

[flaith]

Date : 28/10/2013 08:35:47
Lieu : Hanoi - Vietnam
Fournisseur d'accès : Autre - vnn
Navigateur : Mozilla Firefox
Débit descendant : 1,4 Mbit/s
Débit montant : 1,1 Mbit/s
Latence : 183 ms
Gigue : 2 ms
Ping : 357 ms

[Backup]

je remet l'adresse du lien vers le Client a Tester

http://s242132022.onlinehome.fr/Downloa ... e%203D.zip

Fournisseur d'accès : France Telecom S.A.
Navigateur : Mozilla Firefox
Adresse IP : ***********
Débit descendant : 7,8 Mbit/s
Débit montant : 0,8 Mbit/s
Latence : 27 ms
Gigue : 1 ms
Ping : 0 ms

[G-Rom]

Ca rame à mort ici. Je ne sais pas ce que tu utilises comme type d'architecture réseau ( Serveur <-> clients ? , p2p ? )
En tout cas , y a quelque chose qui ne va pas.
Pour avoir fait un peu de réseau, je dirais que tu bases tes mouvements sur les positions qu'envois le serveur, en fonction des touches du client, je me trompe ?
Sinon , très bonne idée ( le projet ).

Bug : Limité la taille du pseudo, car là, des pseudos qui font 10km, la carte graphique ne va pas apprécier longtemps

edit:

Je viens de profilé l'application, elle ne rame pas, elle ne bouffe pas de bande passante non plus malgrès la musique.
Le problème viens donc du code serveur<->client

[Backup]

t'a un Pc en carton ?
ou une connexion qui passe par Jupiter ...

moi ça ne rame pas du tout !

hier nous etions 3 a parler .. pas de Rames ...
tu occupais ton PC a calculer une Image ou bien ?

[G-Rom]

un i7 à 8 coeurs... Je fait tourné bf4 au taquet. donc c'est un problème de code, la partie réseau ne doit pas être correctement codé.
ma connexion internet est pourrie ( ~1/2 méga ), mais je peu jouer à 64 à bf3 ou 4.
Les jeux en réseau n'attendent pas pour afficher la position du joueur "local".
Le serveur envois des "images" du jeu au temps <T> , les clients interpole les positions entre les temps T pour "lisser" les mouvements.
le joueur local affiche sa propre position en temps réel, le serveur lui envois au temp T des corrections , le joueur local interpole sa propre position avec la position reçue du serveur.

quelques article pour les non anglophobe :

http://www.racer.nl/tech/multiplayer.html
https://developer.valvesoftware.com/wik ... Networking

un de mes codes pour interpolé 2 vecteurs selon un temps entre 0 & 1 ( exemple a la fin ) :

Code : Tout sélectionner

Procedure.f min(a.f,b.f)
   If a<b
      ProcedureReturn a
   EndIf
   ProcedureReturn b
EndProcedure

Procedure.f max(a.f,b.f)
   If a>b
      ProcedureReturn a
   EndIf
   ProcedureReturn b
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
Structure sVector2f
  x.f
  y.f
EndStructure
;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.i createVector2f(x.f, y.f)
  *v.sVector2f = AllocateMemory(SizeOf(sVector2f))
  If *v
    *v\x  = x
    *v\y  = y
    ProcedureReturn *v
  EndIf 
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL deleteVector2f(*v.sVector2f)
  If *v
    *v\x = #Null
    *v\y = #Null
    FreeMemory(*v)
  EndIf 
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL addVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f)
  *result\x = *a\x + *b\x
  *result\y = *a\y + *b\y
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL subVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f)
  *result\x = *a\x - *b\x
  *result\y = *a\y - *b\y
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL mulVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f)
  *result\x = *a\x * *b\x
  *result\y = *a\y * *b\y
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL divVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f)
  If *b\x <> 0
   *result\x = *a\x / *b\x
  EndIf 
  
  If *b\y <> 0
   *result\y = *a\y / *b\y
  EndIf 
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL scaleVector2f(*a.sVector2f, value.f)
  *a\x * value
  *a\y * value
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.f squareLengthVector2f(*v.sVector2f)
  ProcedureReturn (*v\x * *v\x) + (*v\y * *v\y)
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.f lengthVector2f(*v.sVector2f)
  ProcedureReturn Sqr((*v\x * *v\x) + (*v\y * *v\y))
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.f dotProductVector2f(*a.sVector2f, *b.sVector2f)
  ProcedureReturn (*a\x * *b\x) + (*a\y * *b\y)
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL normalizeVector2f(*v.sVector2f)
  l.f = Sqr((*v\x * *v\x) + (*v\y * *v\y))
  If l > 0
    *v\x / l
    *v\y / l
  EndIf 
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL middlePointVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f)
  *result\x = (*a\x + *b\x) * 0.5
  *result\y = (*a\y + *b\y) * 0.5
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL lerpVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f, val.f)
  *result\x = *a\x + (*b\x - *a\x) * val
  *result\y = *a\y + (*b\y - *a\y) * val
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.f crossProductVector2f(*a.sVector2f, *b.sVector2f)
  ProcedureReturn *a\x * *b\y - *a\y * *b\x
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL randomDeviantVector2f(*v.sVector2f, angle.f)
  angle = angle * Random(angle) * (#PI*2)
  cosa.f = Cos(angle)
  sina.f = Cos(angle)
  *v\x = cosa * *v\x - sina - *v\y
  *v\y = sina * *v\x + cosa * *v\y
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL perpendicularVector2f(*v.sVector2f)
  Protected x.f = *v\x
  Protected y.f = *v\y
  *v\x = -y
  *v\y = x
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL reflectVector2f(*v.sVector2f, *normal.sVector2f)
  Protected dot.f = (*v\x * *normal\x) + (*v\y * *normal\y)
  *v\x = *v\x - ( 2 * dot * *normal\x )
  *v\y = *v\y - ( 2 * dot * *normal\y )
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.i intersectVector2f(*p1.sVector2f,*p2.sVector2f,*p3.sVector2f,*p4.sVector2f)
  
Protected.f x1 = *p1\x, x2 = *p2\x, x3 = *p3\x, x4 = *p4\x;
Protected.f y1 = *p1\y, y2 = *p2\y, y3 = *p3\y, y4 = *p4\y;

Protected.d d = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)

If d = 0
  ProcedureReturn #Null
EndIf 

Protected.f pre = (x1*y2 - y1*x2), post = (x3*y4 - y3*x4)
Protected.f x   = ( pre * (x3 - x4) - (x1 - x2) * post ) / d
Protected.f y   = ( pre * (y3 - y4) - (y1 - y2) * post ) / d

If ( x < min(x1, x2) Or x > max(x1, x2) Or x < min(x3, x4) Or x > max(x3, x4) ) 
  ProcedureReturn #Null 
EndIf 

If ( y < min(y1, y2) Or y > max(y1, y2) Or y < min(y3, y4) Or y > max(y3, y4) ) 
  ProcedureReturn #Null
EndIf 

ProcedureReturn createVector2f(x,y)
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////



*PositionA.sVector2f      = createVector2f(100,100)
*PositionB.sVector2f      = createVector2f(200,200)
*Interpolation.sVector2f  = createVector2f(0,0)


For TIME = 1 To 1000
  normalizedTime.f = (1/1000)*TIME ; 0.0 -> 1.0
  lerpVector2f(*Interpolation, *PositionA, *PositionB, normalizedTime) ; 0.0 -> 1.0
  Debug StrF(*Interpolation\x) + " : " + StrF(*Interpolation\y) 
Next 

[falsam]

Je viens de profilé l'application, elle ne rame pas, elle ne bouffe pas de bande passante non plus malgrès la musique.
Le problème viens donc du code serveur<->client

Merci G-Rom pour ton retour d'expérience.

Comme tu viens de le dire l'application ne rame pas du tout et je continue à l'optimiser avant de passer à la suite.

Pour être sur que ça ne vient pas de mon code j'ai testé mon application sur un serveur local (Apache et Mysql)
Aucun souci de fluidité.

Cotés client je pense qu'il n'y a pas grand chose à dire concernant la mise à jour de la position des avatars.

Cotes serveur. C'est un serveur virtuel hébergé actuellement chez 1and1 sous linux. La base de données est gérée sous mysql.

Je pense qu'avec un serveur dédié, ce souci de lag serait réglé.

[G-Rom]

C'est plus facile de te parlé ici.
Il faut revoir ta com entre les clients, stocké la position dans une bdd puis l'envoyer tout les 100ms n'est pas une bonne solution.
comme je te l'ai dit , ca te fait pour un jeu à 60fps, seulement environ une image sur 10 qui est envoyé , les 9 autres "sont droppé".
donc Dobro au du forcé sur la bouteille en disant que c'est fluide, ou alors il cligne des yeux très vite et ne se rend plus compte de la réalité autour de lui
Si tu veut , je peu te filé un coup de paluche pour l'utilisation du code que je t'ai donner par mail, tu pourras avoir un serveur dédié , et ton serveur 1and1 stockera la liste de tout les serveurs disponible.

[falsam]

donc Dobro au du forcé sur la bouteille en disant que c'est fluide, ou alors il cligne des yeux très vite et ne se rend plus compte de la réalité autour de lui

Ce que voulait dire Dobro c'est que le cube qui le représente ne ramait pas. Par contre les cubes représentant les autres joueurs sur son écran devaient saccader un peu. Ce qui est normal vu l'appel à la procédure de mise à jour fixé à 100 ms.

un i7 à 8 coeurs... Je fait tourné bf4 au taquet. donc c'est un problème de code, la partie réseau ne doit pas être correctement codé.

Je n'ai qu'un pc à base de Core duo qui date de 6 ans et je ne rame absolument pas. Bon par contre j'ai une connexion qui tourne plutôt pas mal. Pas une connexion en carton hein ?

[falsam]

Si tu veut , je peu te filé un coup de paluche pour l'utilisation du code que je t'ai donner par mail, tu pourras avoir un serveur dédié , et ton serveur 1and1 stockera la liste de tout les serveurs disponible.

Premiere fois qu'un mail ne me parvient pas et il faut que ça tombe sur toi

Le message "Tornado" que jerome xxxxx (xxxxx@gmail.com) vous a envoyé contenait un virus. Si vous souhaitez écrire à jerome, il vous suffit de cliquer sur Répondre et d'envoyer un message à jerome. Merci, L'équipe Gmail

ha ha ha

Ceci dit j'étais pas parti pour une solution P2P et je ne vois pas ce que ça changerait pour les accès base de données.

[G-Rom]

mon propre cube rame aussi alors que le cpu à une charge de 5% max.
Pour le mail , ton truc déconnes , j'ai pas de virus sur mon pc...
c'est un simple zip avec du code pb dedans

[falsam]

J'ajouterais le ping sur l'écran de connexion. Je vais tenter de faire une mesure correcte des temps de réponse des 4 différentes requetes du code. Merci pour cette astuce G-Rom

[G-Rom]

j'ai vérifier comment procède gmail, il fait lui même une analyse en ligne lors de l'envois du fichier
y avait un build , une dll donc dedans, ceci explique surement le faux positif.
je te renvois l'archive sans dll

[falsam]

j'ai vérifier comment procède gmail, il fait lui même une analyse en ligne lors de l'envois du fichier
y avait un build , une dll donc dedans, ceci explique surement le faux positif.
je te renvois l'archive sans dll

Merci

Pour en revenir au mouvement saccadé, je te confirme que je ne fais pas d'interpolation entres deux déplacements. Le déplacement est absolu.

Je pourrais faire un timeout plus court mais ça engendre une augmentation des requêtes sql aussi. Il faut que je trouve le juste milieu.

Actuellement le joueur qui a une bonne connexion ne saccade pas car son déplacement est géré par son ordinateur. Il met a jour sa position SQL pour les autres joueur tout les centième de seconde. Ce qui explique que lui même voit les autres joueurs saccadés.

[G-Rom]

oui, mais imagine le cas de figure ou tu as 10 personnes par exemple.
est ce que 1&1 va t'autorisé à avoir 100 requête toute les secondes ? dans le cadre d'un envois tout les 100ms
si tu passe à 25ms cela fera 400 requête par seconde !

[falsam]

L'interpolation linéaires entres deux point de coordonnées x,y,z est effectivement pas mal et permet de réduite considerablement le nombres de requêtes sql sur le serveur.

Le tout est de trouver la bonne formule pour faire un déplacement relatif entres deux points.