Pagina 3 di 4 primaprima 1 2 3 4 ultimoultimo
Visualizzazione dei risultati da 21 a 30 su 31
  1. #21
    classe Giocatore
    codice:
    import java.util.*;
    
    public class Giocatore implements Comparable{
    	
    	public String nome;
    	public int id;
    	Contatore partiteGiocate;	
    	List<Giocatore> compagniList;	//	lista dei compagni con i quali deve giocare
    	
    	public Giocatore()
    	{
    		this(0);
    	}
    	public Giocatore(int identificativo)
    	{
    		this.nome="Sconosciuto";
    		this.id=identificativo;
    		this.partiteGiocate = new Contatore();
    		this.compagniList = new ArrayList<Giocatore>();
    	}
    	
    	public void nuovaListaCompagni(Giocatore [] g)
    	{
    		for(Giocatore a: g)
    			{
    			if(a.id!=this.id)	//	se il giocatore non è se stesso lo si aggiunge ai compagni
    				compagniList.add(a);	
    			}
    	}
    	
    	public void stampaGiocatore()
    	{
    		System.out.printf("%-8s %-10s ID: %2d nP: %2d","Nome:", this.nome, this.id, this.partiteGiocate.getValore());
    	}
    	
    	@Override
    	public int compareTo(Object o) {
    		//	per comparare Giocatore con l'oggetto bisogna fare un cast dell'oggetto
    		
    		if(this.partiteGiocate.cmpContatore(((Giocatore)o).partiteGiocate.getValore()))
    		return 0;	// ritorna 0 se sono uguali
    		
    		else if(this.partiteGiocate.isLessNumber(((Giocatore)o).partiteGiocate.getValore()))
    			return -1;	//	-1 se l'oggetto corrente è minore
    		
    		else
    		return 1;	//	altrimenti è maggiore e ritorna 1
    	}
    	
    	public boolean scegliCompagno(List<Giocatore> compagniScelti)
    	{
    		Giocatore temp = new Giocatore();
    		boolean esisteGiocatore=false;
    		if(!compagniList.isEmpty())	//	se la lista dei compagni da scegliere non è vuota
    		{
    			Collections.sort(compagniList);		//	ordina la lista dei compagni per numero di partite giocate
    		for(Giocatore i: compagniList)
    			{
    				
    				if(!compagniScelti.contains(i))	//	se il giocatore non è già stato scelto in giornata lo aggiunge ed esce dal ciclo
    				{
    					temp=i;
    					compagniScelti.add(this);
    					compagniScelti.add(i);
    					this.partiteGiocate.incContatore();
    					esisteGiocatore=true;
    					break;
    					
    				}
    			}
    		if(esisteGiocatore)	//	se ha trovato un giocatore da aggiungere
    			{
    			temp.partiteGiocate.incContatore();
    			compagniList.remove(temp);
    			return true;	//	 ritorna vero se ha aggiuto un giocatore
    			}
    		}		
    		return false;	//	ritorna false se non esistono giocatori nella lista compagni che ancora non hanno giocato in giornata
    	}
    	public boolean CompagnoGiaGiocato(List<Giocatore> compagniScelti) {
    		
    		Giocatore temp = new Giocatore();
    		if(!compagniList.isEmpty())	//	se non e' vuota
    		{
    			Collections.sort(compagniList);	// la riordina
    			temp=compagniList.get(0);		//	copia in temp il primo elemento della lista che sarà quello con meno partite
    			compagniScelti.add(this);
    			compagniScelti.add(temp);
    			this.partiteGiocate.incContatore();
    			temp.partiteGiocate.incContatore();
    			compagniList.remove(temp);
    			
    			System.out.printf("In questa giornata |%-10s ID: %2d| giocherà 2 volte\n", temp.nome, temp.id);
    			return true;
    		}
    		return false;
    	}
    }
    classe Torneo
    codice:
    import java.util.*;
    
    public class Torneo {
    
    	int partecipanti;	
    	public Giocatore [] vetGiocatori;
    	
    	public Torneo(int n)
    	{
    		partecipanti=n;
    		vetGiocatori = new Giocatore[partecipanti];
    		resetGiocatori();
    	}
    
    	public void resetGiocatori() 
    	{
    		for(int i=0;	i<vetGiocatori.length;	i++)
    			vetGiocatori[i] = new Giocatore(i+1);
    	}
    
    	public void accoppiamenti()
    	{
    			for(Giocatore a: vetGiocatori)
    				a.nuovaListaCompagni(vetGiocatori);	
    	}
    
    	private void stampaListaGiornata(List<Giocatore> compagniScelti) {
    		
    		int i=1;
    		for(Giocatore n: compagniScelti)
    		{
    			n.stampaGiocatore();
    			if(i%2==0)
    				System.out.println();
    			else
    				System.out.printf("\te\t");
    			i++;
    		}
    		
    	}
    
    	public void calcoloGiornata()
    	{
    		List<Giocatore> compagniScelti = new ArrayList<Giocatore>();
    		Giocatore temp = new Giocatore();
    		while(compagniScelti.size()<16 && !tutteListeVuote())
    		{
    			Arrays.sort(vetGiocatori);
    			if(tuttiUguali())	//	se tutti i giocatori hanno le stesse partite fa una scelta random
    				vetGiocatori[sceltaRandom()].scegliCompagno(compagniScelti);
    			else
    			{
    			for(Giocatore a: vetGiocatori)
    			{
    				if(!compagniScelti.contains(a))
    				{
    					temp=a;
    					if(temp.compagniList.isEmpty())	//	se il giocatore scelto ha finito i compagni passa al prossimo
    						continue;
    					else
    					break;
    				}
    			}	//	fine for
    				if(!temp.scegliCompagno(compagniScelti))	//	se tutti i compagni di temp hanno già giocato in giornata
    					{
    					if(!temp.CompagnoGiaGiocato( compagniScelti))				//	sceglie un compagno che ha già giocato in giornata
    					{	// se si entra in questo if il giocatore ha finito i compagni	(NON DOVREBBE MAI SUCCEDERE)
    						temp.stampaGiocatore();
    						System.out.printf("\nHa finito i compagni\n");
    						stampaLista(temp.compagniList);
    					System.out.println();
    					stampaLista(compagniScelti);
    					System.exit(-1);
    						}
    					}
    			}	//	fine else
    		}	//	fine while
    		System.out.println();
    		stampaListaGiornata(compagniScelti);
    	}
    
    	private boolean tutteListeVuote() {		//	ritorna vero se tutte le liste dei giocatori sono vuote
    		for(Giocatore g: vetGiocatori)
    		{
    			if(!g.compagniList.isEmpty())	//	se una lista non e' vuota ritorna falso
    				return false;
    		}
    		return true;
    	}
    
    	private int sceltaRandom() {
    		return (int)Math.floor(Math.random()*vetGiocatori.length);	//	sceglie un giocatore random tra tutti i partecipanti
    	}
    
    	private boolean tuttiUguali() {	//	ritorna true se tutti i partecipanti hanno lo stesso numero di partite
    		
    		for(int i=0;	i<vetGiocatori.length-1;	i++)
    		{
    			if(!vetGiocatori[i].partiteGiocate.cmpContatore(vetGiocatori[i+1].partiteGiocate.getValore()))	//	se qualche giocatore e' diverso pone uguali false 
    				return false;
    		}
    		return true;
    	}
    	public void stampaLista(List<Giocatore> lista)
    	{
    		for(Giocatore a: lista)
    		{
    			a.stampaGiocatore();
    			System.out.println();
    		}
    	}
    
    }
    classe Main
    codice:
    public class Main {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		
    		 String [] nomi = {"Buffon","Grosso","Cannavaro","Materazzi","Zambrotta","Gattuso","Pirlo","De Rossi",
    				"Totti","Camoranesi","Perrotta","Del Piero","Toni","Gilardino","Inzaghi","Iaquinta","Peruzzi","Amelia"};
    		
    		Torneo t = new Torneo(18);		//	crea un nuovo torneo
    		
    		for(int i=0; i<t.vetGiocatori.length	; i++)
    		{
    			t.vetGiocatori[i].nome=nomi[i];
    		}
    		
    		t.accoppiamenti();	//	crea le liste per tutti i giocatori
    		
    		for(int i=0;	i<39;	i++)	//	in 39 giornate tutte le liste compagni finiscono
    		{
    		System.out.printf("Giornata %2d\n", i+1);
    		t.calcoloGiornata();
    		
    		}
    		
    	}
    }
    La classe contatore è la stessa che ho postato prima quindi non la copio...
    In questa versione tutti giocano tutte le partite mantenendo una gestione delle attese quasi perfetta. Il problema ora è che un giocatore eventualmente può dover giocare più di una volta a giornata...
    proverò a sistemare l'inghippo ricalcolando l'intera giornata se qualcuno è costretto a giocare 2 partite...
    fammi sapere se hai altre idee

  2. #22
    Utente di HTML.it
    Registrato dal
    Apr 2011
    Messaggi
    15
    il problema è quindi lo stesso.. per riempire l'ultima giornata che non riesce a calcolare dovrebbe far giocare due volte lo stesso giocatore!!
    nel mio codice siccome ho messo diciamo il "divieto" di questo mi si blocca all'ultima giornata nel migliori dei casi..
    altre idee non ne ho!!
    secondo me dobbiamo iniziare a tener conto della possibilità che 17 giornate piene con tutti i giocatori che hanno giocato con tutti gli altri 17 almeno una volta non è possibile!!
    mi farebbe piacere che mi smentissi

  3. #23
    purtroppo nel mio codice il problema non è dell'ultima giornata, perchè potrebbe accadere anche a metà torneo, anche se è più facile che si verifichi verso la fine del torneo visto che la lista dei compagni diminuisce mentre la lista dei compagni per ogni giornata è sempre di 16! comunque dipende da cosa intendi, di sicuro è impossibile creare n giornate di modo che ogni giocatore abbia giocato con gli altri 17 per 2 volte, questo semplicemente perchè la divisione partite/giornate da resto... quindi si otterrebbe un' ultima giornata con 2 partite invece che 8... che fine si fa fare a quelle 2 partite?

    EDIT: ho letto che parli di 17 giornate, a me ne escono 38 più l'ultima da 2 partite...
    infatti 17*18*2=612
    mentre 16*38=608
    608+4(2 partite=4 compagni)=612...
    che macelloooo

  4. #24
    ho risistemato il codice ed ora senza ripetizioni crea tutto il girone di andata, calcolando che il girone di ritorno è lo stesso a posizioni invertite dovrebbe essere idoneo per quel che cerchi
    se invece vuoi un girone di ritorno diverso da quello di andata allora è un'altra storia,
    naturalmente l'ultima giornata del girone di andata contiene solo 2 compagni, ma questo non è risolvibile perchè come ho già detto la divisione numero Giocatori/ numero Giocatori per Giornata da resto.
    La soluzione non è la più efficente del mondo, fa un casino di cicli... il minimo numero di cicli che mi è capitato è stato 30 il massimo 3800!!
    comunque l'efficenza non mi sembra così importante in questo caso, basta che dopo qualche secondo dia la soluzione .
    Ti posto il codice senza la classe Contatore e fammi sapere tu se hai altre idee.

    classe Giocatore
    codice:
    import java.util.*;
    
    public class Giocatore implements Comparable<Object>{
    	
    	public String nome;
    	public int id;
    	Contatore partiteGiocate;	
    	List<Giocatore> compagniList;	//	lista dei compagni con i quali deve giocare
    	
    	public Giocatore()
    	{
    		this(0);
    	}
    	public Giocatore(int identificativo)
    	{
    		this.nome="Sconosciuto";
    		this.id=identificativo;
    		this.partiteGiocate = new Contatore();
    		this.compagniList = new ArrayList<Giocatore>();
    	}
    	
    	public void nuovaListaCompagni(Giocatore [] g)
    	{
    		for(Giocatore a: g)
    			{
    			if(a.id!=this.id)	//	se il giocatore non è se stesso lo si aggiunge ai compagni
    				compagniList.add(a);	
    			}
    	}
    	
    	public void stampaGiocatore()
    	{
    		System.out.printf("%-8s %-10s ID: %2d nP: %2d","Nome:", this.nome, this.id, this.partiteGiocate.getValore());
    	}
    	
    	@Override
    	public int compareTo(Object o) {
    		//	per comparare Giocatore con l'oggetto bisogna fare un cast dell'oggetto
    		
    		if(this.partiteGiocate.cmpContatore(((Giocatore)o).partiteGiocate.getValore()))
    		return 0;	// ritorna 0 se sono uguali
    		
    		else if(this.partiteGiocate.isLessNumber(((Giocatore)o).partiteGiocate.getValore()))
    			return -1;	//	-1 se l'oggetto corrente è minore
    		
    		else
    		return 1;	//	altrimenti è maggiore e ritorna 1
    	}
    	
    	public boolean scegliCompagno(List<Giocatore> compagniScelti)
    	{
    		Giocatore temp = new Giocatore();
    		boolean esisteGiocatore=false;
    		if(!compagniList.isEmpty())	//	se la lista dei compagni da scegliere non è vuota
    		{
    			Collections.sort(compagniList);		//	ordina la lista dei compagni per numero di partite giocate
    		for(Giocatore i: compagniList)
    			{
    				
    				if(!compagniScelti.contains(i))	//	se il giocatore non è già stato scelto in giornata lo aggiunge ed esce dal ciclo
    				{
    					temp=i;
    					compagniScelti.add(this);
    					compagniScelti.add(i);
    					this.partiteGiocate.incContatore();
    					esisteGiocatore=true;
    					break;
    					
    				}
    			}
    		if(esisteGiocatore)	//	se ha trovato un giocatore da aggiungere
    			{
    			temp.partiteGiocate.incContatore();
    			compagniList.remove(temp);
    			temp.compagniList.remove(this);		//	rimuove il giocatore corrente dalla lista del compagno
    			return true;	//	 ritorna vero se ha aggiuto un giocatore
    			}
    		}		
    		return false;	//	ritorna false se non esistono giocatori nella lista compagni che ancora non hanno giocato in giornata
    	}
    	
    }
    classe Torneo
    codice:
    import java.util.*;
    
    public class Torneo {
    
    	int partecipanti;	
    	public Giocatore [] vetGiocatori;
    	public List<Giocatore> torneo;
    	public Torneo(int n)
    	{
    		partecipanti=n;
    		vetGiocatori = new Giocatore[partecipanti];
    		torneo= new ArrayList<Giocatore>();
    		resetGiocatori();
    	}
    
    	public void resetGiocatori() 
    	{
    		for(int i=0;	i<vetGiocatori.length;	i++)
    			vetGiocatori[i] = new Giocatore(i+1);
    	}
    
    	public void accoppiamenti()
    	{
    			for(Giocatore a: vetGiocatori)
    				a.nuovaListaCompagni(vetGiocatori);	
    	}
    
    	public boolean calcoloGiornata()
    	{
    		List<Giocatore> compagniScelti = new ArrayList<Giocatore>();
    		Giocatore temp = new Giocatore();
    		while(compagniScelti.size()<16 && !tutteListeVuote())
    		{
    			Arrays.sort(vetGiocatori);
    			if(tuttiUguali())	//	se tutti i giocatori hanno le stesse partite fa una scelta random
    				vetGiocatori[sceltaRandom()].scegliCompagno(compagniScelti);
    			else
    			{
    			for(Giocatore a: vetGiocatori)
    			{
    				if(!compagniScelti.contains(a))
    				{
    					temp=a;
    					if(temp.compagniList.isEmpty())	//	se il giocatore scelto ha finito i compagni passa al prossimo
    						continue;
    					else
    					break;
    				}
    			}	//	fine for
    				if(!temp.scegliCompagno(compagniScelti))	//	se tutti i compagni di temp hanno già giocato in giornata
    					{
    					return false;
    			
    					}
    			}	//	fine else
    		}	//	fine while
    		
    		aggiungiTorneo(compagniScelti);
    		return true;		//	ritorna vero quando ha creato tutte le giornate senza copie
    	}
    
    	private void aggiungiTorneo(List<Giocatore> compagniScelti) {
    		while(!compagniScelti.isEmpty())
    		{
    			torneo.add(compagniScelti.get(0));
    			compagniScelti.remove(0);
    		}
    		
    	}
    
    	private boolean tutteListeVuote() {		//	ritorna vero se tutte le liste dei giocatori sono vuote
    		for(Giocatore g: vetGiocatori)
    		{
    			if(!g.compagniList.isEmpty())	//	se una lista non e' vuota ritorna falso
    				return false;
    		}
    		return true;
    	}
    
    	private int sceltaRandom() {
    		return (int)Math.floor(Math.random()*vetGiocatori.length);	//	sceglie un giocatore random tra tutti i partecipanti
    	}
    
    	private boolean tuttiUguali() {	//	ritorna true se tutti i partecipanti hanno lo stesso numero di partite
    		
    		for(int i=0;	i<vetGiocatori.length-1;	i++)
    		{
    			if(!vetGiocatori[i].partiteGiocate.cmpContatore(vetGiocatori[i+1].partiteGiocate.getValore()))	//	se qualche giocatore e' diverso pone uguali false 
    				return false;
    		}
    		return true;
    	}
    
    }
    classe Main
    codice:
    public class Main {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		
    		 String [] nomi = {"Buffon","Grosso","Cannavaro","Materazzi","Zambrotta","Gattuso","Pirlo","De Rossi",
    				"Totti","Camoranesi","Perrotta","Del Piero","Toni","Gilardino","Inzaghi","Iaquinta","Peruzzi","Amelia"};
    		 Torneo t;
    		 boolean completo=false;
    		int nCicli=0;
    		while(!completo)	
    		{
    			nCicli++;	//	conterà il numero di tornei creati per trovare quello giusto!
    		t = new Torneo(18);		//	crea un nuovo torneo
    		
    		for(int i=0; i<t.vetGiocatori.length	; i++)		//	inserisce nomi giocatori
    		{
    			t.vetGiocatori[i].nome=nomi[i];
    		}
    		
    		t.accoppiamenti();	//	crea le liste per tutti i giocatori
    		
    			for(int i=0;	i<20;	i++)	
    			{
    				if(!t.calcoloGiornata())			//	se calcolo giornata è falso esce dal ciclo e crea un nuovo torneo
    					break;
    				if(i==19)							//	quando i==19 sarà finito il girone di andata
    				{completo=true;
    				stampaTorneo(t);
    				}
    				}	//	for
    			
    		}// while
    		System.out.printf("%d tornei creati per trovare la soluzione :-)\n", nCicli);
    	}
    
    	private static void stampaTorneo(Torneo t)
    	{
    		
    		int i=0;	//	utilizzata per scorrere la lista dei giocatori
    		int j=1;	//	utilizzata per scorrere le giornate
    		boolean giornata=false;	//	quando vera stampa la giornata
    		
    		System.out.printf("Giornata %2d\n", j);
    		j++;
    		for(int a=0;	a<t.torneo.size();	a++)	//	azzera tutti i contatori dei giocatori e li riconterà nel ciclo di stampa
    			((Giocatore)(t.torneo.get(a))).partiteGiocate.resetContatore();
    		while(i<t.torneo.size())
    		{
    			if(giornata)	//	se vera stampa la giornata
    			{System.out.printf("Giornata %2d\n", j);
    			j++;
    			giornata=false;
    			}
    			((Giocatore)(t.torneo.get(i))).partiteGiocate.incContatore();	//	effettua un cast a Giocatore e ne incrementa il contatore
    			((Giocatore)(t.torneo.get(i))).stampaGiocatore();				//	stampa il giocatore
    			i++;															//	passa al giocatore successivo della lista
    			
    			if(i%2==0)														//	se da resto 0 va a capo
    				{System.out.println();
    				if(i%16==0 && i!=0)											//	se giocatore i /16 da resto 0 pone giornata = a true
    					giornata=true;
    				}
    			else
    				System.out.printf("\te\t");
    			
    		}
    	}
    }

  5. #25
    Utente di HTML.it
    Registrato dal
    Apr 2011
    Messaggi
    15
    Ti stimo fratello!!!
    Quindi hai trovato la soluzione..
    Hai ragione per fare tutti 17 partite e due attese, ho bisogno di 19 giornate!!
    I due della 20esima giornata li lascio da parte... non è un problema!!
    E per fare il girone di ritorno diverso da quello di andata faccio girare due volte il codice!!!
    Sei stato davvero grande!!
    BRAVO!!

  6. #26
    effettivamente a far girare due volte il codice per creare il girone di ritorno diverso non ci avevo pensato ...
    allora possiamo dire di essere arrivati ad una soluzione accettabile!
    Ci stavo perdendo le speranze
    buon torneo!

  7. #27
    Utente di HTML.it
    Registrato dal
    Apr 2011
    Messaggi
    15
    ciao...
    devo darti delle brutte notizie!!
    stavo per iniziare il torneo e controllandomi un po' le giornate scopro che in alcune giornate un giocatore gioca in due squadre diverse!!
    Peccato.. l'algoritmo sembrava funzionare al meglio...
    Invece nulla!! Ora sono punto e a capo... e dovrò rinviarlo ancora peccato!!

    controlla anche tu... io me ne sono accorto quando dovevo scrivermi le attese.. allora mi so fatto un algoritmo che me le scriveva in automatico.. e non riuscivo a capire perchè in alcune giornate erano 3 i giocatori che attendevano... e guardo bene e due giocatori con id uguale giocano due volte...
    evidentemente non hai messo un controllo che se un giocatore è gia presente nella giornata che stai creando non deve più metterlo ...

  8. #28
    scusa, ma ne sei certo? perchè ho controllato e a me va perfettamente, in più ho ricontrollato il codice e c'è il controllo sulla ripetizione... qui c' è un esempio dell'output:
    codice:
    http://www.mediafire.com/?e0yr33m15ax6qzl

  9. #29
    Utente di HTML.it
    Registrato dal
    Apr 2011
    Messaggi
    15
    sisi purtroppo ne sono sicurissimo!!
    nel tuo file txt non si capisce molto..
    Comunque ho provato più di una volta e il risultato è sempre lo stesso entro le prime 10 giornate almeno in una c'è un giocatore che gioca due volte..
    prova a stamparti ad ogni giornata i giocatori che non giocano, cioè quelli che fanno il turno di attesa, nel codice che hai postato, in almeno due giornate ci sono tre giocatori che attendono e questo significa che c'è un player che viene stampato due volte..
    Il numero delle partite viene conteggiato cmq.. in effetti il giocatore diciamo falsato che gioca due volte in una giornata alla prima apparizione ad esempio ha nP: 7 e alla seconda apparizione NELLA STESSA GIORNATA ha nP: 8 ...
    purtroppo c'è ancora qualcosa che non va..
    al primo colpo d'occhio sembra tutto ok!!
    ma osservando per bene tutte le giornate esce questo bug..
    Se riesci a risolvere fammi sapere.. io non voglio mettere mani nel tuo codice, sto cercando di farne uno da capo.. ho solo provato a mettere un ArrayList per stamparmi le attese e proprio per questo me ne sono accorto..

    EDIT: comunque per essere più chiaro, e per dimostrarti che evidentemente il controllo sul numero di volte che un giocatore gioca in una giornata non funziona bene, mi sono messo a controllare per bene il tuo output..
    Alla giornata 7 succede quello di cui ti parlavo.. Il giocatore con ID: 6 che tu hai chiamato Gattuso, gioca due volte in due squadre diverse.. e nella stessa giornata il suo contatore del numero delle partite viene incrementato due volte..
    Ecco ti incollo la giornata numero 7 del tuo output con una formattazione più diretta!

    Giornata 7
    Nome: Amelia ID: 18 nP: 6 e Nome: De Rossi ID: 8 nP: 6
    Nome: Totti ID: 9 nP: 6 e Nome: Toni ID: 13 nP: 6
    Nome: Iaquinta ID: 16 nP: 6 e Nome: Camoranesi ID: 10 nP: 6
    Nome: Gilardino ID: 14 nP: 6 e Nome: Inzaghi ID: 15 nP: 6
    Nome: Grosso ID: 2 nP: 6 e Nome: Buffon ID: 1 nP: 6
    Nome: Materazzi ID: 4 nP: 6 e Nome: Gattuso ID: 6 nP: 6
    Nome: Gattuso ID: 6 nP: 7 e Nome: Pirlo ID: 7 nP: 7

    Nome: Perrotta ID: 11 nP: 7 e Nome: Cannavaro ID: 3 nP: 7

  10. #30
    cavolo se hai ragione! ricontrollo e ti faccio sapere perchè un controllo già esiste

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2026 vBulletin Solutions, Inc. All rights reserved.