Il condizionale non si innesca quando viene dato un 75: android

Question

Ok, quindi questa è probabilmente una domanda stupida da parte di un programmatore dilettante che cerca di sperimentare l'uso di base della grafica Android, ma eccola qui.

Per familiarizzare con la grafica 2D in 2D per aiutare un mio amico che vuole che usi la sua idea per il suo gioco, ho deciso di provare e creare una versione semplice di pong. (Significato semplice non ho nemmeno fatto entrambe le pale si muovono ancora)

Andando fuori del Android API guides, ho costruito l'applicazione sperimentale intorno a un oggetto personalizzato View (PongView), che ha 3 ShapeDrawable oggetti (rectangles). I due paddle (li ho chiamati bastoni) e la palla. Ho implementato un MotionEventListener nella vista e fatto muovere la levetta sinistra con esso (yay ho capito qualcosa :).

Successivamente, ho spostato la sfera utilizzando un ritardo Runnable creato nell'attività principale che chiama un metodo di aggiornamento all'interno della visualizzazione personalizzata. Nel metodo di aggiornamento, ho creato un gestore di collisioni che inverte il vettore della palla (su un asse specifico) quando colpisce i lati dello schermo o qualsiasi lato dei paddle.

Ma dopo aver giocato con esso, ho visto che una delle mie condizioni di collisione non sparava. La palla passerebbe attraverso il fondo e il lato destro del bastone, rimbalzando quando colpisce il lato sinistro o superiore.

Ecco le condizioni di collisione:

//collisions 
    if ((bx + bside == getMeasuredWidth() || bx == 0) || //hit right or left of screen 
      ((bx + bside == lx || bx == lx + width) && (by < ly + height && by > ly)) || //hit left stick 
      ((bx + bside == rx || rx + width == bx) && (by < ry + height && by > ry))) { //hit right stick 
     bVectorX = -bVectorX; 
     System.out.println("bounce x"); 
    } 
    if ((by + bside == getMeasuredHeight() || by == 0) || 
      ((by + bside == ly || by == ly + height) && (bx < lx + width && bx > lx)) || 
      ((by + bside == ry || by == ry + height) && (bx < rx + width && bx > rx))) { 
     bVectorY = -bVectorY; 
     System.out.println("bounce y"); 
    } 

• bside: lunghezza laterale (pixel) del quadrato palla
• larghezza: larghezza di pale
• altezza: altezza di pale
• bVectorX : modifica delle coordinate (pixel) per aggiornamento sull'asse x
• bx: coordinata x della palla
• da: coordinata y della palla
• lx: coordinata x della sinistra-paddle

Cercando di circoscrivere l'area del problema, ho commentato fuori tutti tranne questa affermazione come questa dichiarazione mi stava dando il problema (almeno sul asse x):

bx == lx + width 

mi resi conto che, poiché lx mai cambiato durante l'esecuzione, ho potuto collegare il valore grezzo (75) per il test e vedere se che ha causato la condizione di innesco . Non è stato così. Così ho deciso di provare 76 invece, e indovina un po ', ha funzionato! Non ho idea del perché, ma ha funzionato. la palla è rimbalzata su quella linea di pixel. Così ho provato a rimettere le variabili, provando:

bx == lx + width + 1 
    bx == lx + width - 1 

ed entrambi hanno funzionato! Quando ho tolto il primo + 1, tuttavia, sarebbe andato dritto attraverso la pagaia e rimbalzando dal colpire l'altro lato. (dato che tutto ciò che faccio è invertire il vettore). Quello che voglio che faccia è colpire il lato destro della paletta e invertire il vettore.

ho idea perché questo sta accadendo, grazie in anticipo per il vostro aiuto :)

EDIT: Così ho provato il condizionale e ha scoperto che questi due pezzi di ritorno codice vero.

if (75 == 75) { 

    int i = 75; 
    if (i == 75) { 

Ma questo non torna mai vero.

if (bx == 75) { 

Grazie ancora per il supporto. :)

Answer 1

Non si dovrebbe essere il controllo per l'uguaglianza esatto cioè if (bx == 75) {} come questa condizione per rilevare una collisione sarebbe incontrato solo se il bVectorX avuto serie molto limitata di valori (cioè solo numeri interi che hanno aggiunto o sottratto da/per bx farebbe sempre in modo di valutare 75).

Basta usare <= e >= e si dovrebbe andare bene.

Lo stesso vale per il rilevamento di collisioni con i bordi dello schermo.