[CICLO 5] Storia 1

[Jocchan]

Storia 1: Storia di servizio, dedicata al perfezionamento della risposta agli input del giocatore. La risposta ai comandi deve essere istantanea e precisa, senza che alcun comando venga mai saltato, anche nelle situazioni più concitate. Nuovamente, occorrerà assicurarsi che la gemma non si sposti in maniera indesiderata dopo una pressione leggermente più lunga del solito, ed occorrerà correggere in maniera definitiva il bug di posizionamento della stessa alla pressione contemporanea dei tasti sx e dx.


Punti cardine da tenere a mente durante i lavori:

• Mai fare a gara a chi finisce il task per primo, meglio procedere con calma, altrimenti perderemo molto più tempo in seguito
• Evitiamo di complicarci la vita, esiste di certo una soluzione più semplice di quella che abbiamo pensato di implementare
• MAI aggiungere elementi non richiesti esplicitamente dai task: se mai serviranno, se ne parlerà nelle prossime storie
• Comunichiamo il più possibile, se qualcosa non è chiaro discutiamone tutti i dettagli fino ad eliminare ogni dubbio, anche il più insignificante

[VICIUS]

Task:
5.1.1: 71104
Implementare l'algoritmo di gestione degli Input di BlueDragon presente nel branch trunk/ (no copia/incolla. solo pair-programming)

ciao

[71104]

Originariamente inviato da VICIUS

Task:
5.1.1:
Implementare l'algoritmo di gestione degli Input di BlueDragon presente nel branch trunk/ (no copia/incolla. solo pair-programming)

ciao

embe'?? un solo task?
comunque vorrei prenotarmi anche per questo, ma non so se a voi va bene perché già ho fatto il pair programming dell'altra volta (forse volete cambiare un po'...)

[fek]

Originariamente inviato da 71104

embe'?? un solo task?
comunque vorrei prenotarmi anche per questo, ma non so se a voi va bene perché già ho fatto il pair programming dell'altra volta (forse volete cambiare un po'...)

E' la fine della storia che abbiamo iniziato al ciclo precedente, quindi un solo task

Vediamo se altri si prenotano, per te ci sono un po' di task nella Storia 2 freschi freschi e le cose cominciano a movimentarsi.

[Jocchan]

Chi si prenota insieme a 71104?
Venghino, siori, venghino, non fate i timidi

[71104]

nessuno si vuole prenotare con me perché faccio paura!!!

[71104]

ragazzi, qua non si prenota nessuno, siamo bloccati... Customer, dica una data: se entro la data nessuno si è ancora prenotato faccio o da solo o con fek
che ne pensa?

[VICIUS]

Bhe visto che l'idea l'ha avuta Blue Dragon sarebbe il caso che ci fosse anche lui nella coppia. Blue Dragon che fine hai fatto ?

ciao

[Jocchan]

Originariamente inviato da VICIUS

Bhe visto che l'idea l'ha avuta Blue Dragon sarebbe il caso che ci fosse anche lui nella coppia. Blue Dragon che fine hai fatto ?

ciao

BD l'ho contattato io ieri, e ora non ha molto tempo: dice che per il weekend (cioè da venerdì) sarà disponibile (e quindi direi che avremo un "volontario" per il task).
Quindi consiglierei a 71104 di fare prima il task della seconda storia, e poi nel weekend di svolgere questo (per fortuna sono dei task scollegati)

[VICIUS]

Ancora nessuno? Su forza che 71104 scalpita

ciao

[BlueDragon]

A quanto pare sono "volontario d'ufficio" per questo pair programming
Ho parlato con 71104 e questo weekend non abbiamo orari compatibili, proveremo nelle sere della prossima settimana.

Comunque ecco cosa bisogna fare:

1) Popolare la coda di Input tramite KeyboardImpl
E' una cosa "banale" se non fosse per un unico problema...KeyboardImpl conosce il numero intero corrispondente al tasto premuto, ma non conosce l'enum KeyCode da inserire nella coda. Ho guardato la documentazione dell'enum ma non ho trovato metodi per risalire dall'int al KeyCode in maniera semplice. Io nel mio spike avevo fatto una mappa inversa da int a KeyCode, ma non era una cosa carina a vedersi.
Ho parlato con 71104 su MSN ed abbiamo pensato di modificare la coda affinché i KeyEvent contengano gli int e non i KeyCode. La differenza rispetto al codice che c'è adesso sarà semplicemente che anziché scrivere nel codice KeyCode.vk_Left, useremo KeyCode.vk_Left.value() per riferirci al valore int.
Il vantaggio di questa soluzione è che così KeyboardImpl non ha bisogno di una mappa per capire i nostri enum, e noi umani che non ci ricordiamo tutti gli int della tastiera a memoria possiamo ancora appoggiarci ad i nomi dell'enum KeyCode.
Se avete in mente soluzioni migliori....ben vengano!!

2) Migliorare le reazioni agli Input:
Tramite l'utilizzo delle informazioni aggiuntive forniteci dalla coda, possiamo quindi passare a migliorare il comportamento del reactToInput affinché vengano superati i seguenti test:

  public void testKeyLeftLessThanDelay()
    {
        grid.insertGem(2, 5, gem); 
        grid.setGemUnderControl(gem); 
        input.generateKeyEvent(KeyCode.vk_Left, KeyState.Pressed); 
        grid.reactToInput(input, timer); 
        timer.setTime(timer.getTime() + grid.getInputDelay() - 1); 
        grid.reactToInput(input, timer); 
        assertTrue( "Gem has moved more than once with Left being pressed for less than Delay", 
        grid.isGemAt(2, 4)); 
    }


    public void testKeyLeftMoreThanDelay()
    {
        grid.insertGem(2, 5, gem);
        grid.setGemUnderControl(gem);

        input.generateKey(KeyCode.vk_Left);
        grid.reactToInput(input, timer);
        
        timer.setTime(timer.getTime() + grid.getInputDelay() + 1);
        
        grid.reactToInput(input, timer);
        
        assertTrue( "Gem isn't moving according to the correct delay with Left Key being pressed", 
                    grid.isGemAt(2, 3)); 
    }

    public void testKeyRightLessThanDelay()
    {
        grid.insertGem(2, 5, gem); 
        grid.setGemUnderControl(gem); 
        input.generateKeyEvent(KeyCode.vk_Right, KeyState.Pressed); 
        grid.reactToInput(input, timer); 
        timer.setTime(timer.getTime() + grid.getInputDelay() - 1); 
        grid.reactToInput(input, timer); 
        assertTrue( "Gem has moved more than once with Left being pressed for less than Delay", 
        grid.isGemAt(2, 6)); 
    }


    public void testKeyRightMoreThanDelay()
    {
        grid.insertGem(2, 5, gem);
        grid.setGemUnderControl(gem);

        input.generateKey(KeyCode.vk_Right);
        grid.reactToInput(input, timer);
        timer.setTime(timer.getTime() + grid.getInputDelay() + 1);
        grid.reactToInput(input, timer);

        assertTrue( "Gem isn't moving according to the correct delay with Right Key being pressed", 
            grid.isGemAt(2, 7)); 
    }

    public void testKeyLeftReleased()
    {
        grid.insertGem(2, 5, gem); 
        grid.setGemUnderControl(gem); 

        input.generateKeyEvent(KeyCode.vk_Left, KeyState.Pressed); 
        grid.reactToInput(input, timer); 
        input.generateKeyEvent(KeyCode.vk_Left, KeyState.Released); 
        timer.setTime(timer.getTime() + grid.getInputDelay()+1); 
        grid.reactToInput(input, timer); 
        
        assertTrue( "Gem didn't stop moving after Left Key being released", 
        grid.isGemAt(2, 4));     
    }
    
    public void testKeyRightReleased()
    {
        grid.insertGem(2, 5, gem); 
        grid.setGemUnderControl(gem); 

        input.generateKeyEvent(KeyCode.vk_Right, KeyState.Pressed); 
        grid.reactToInput(input, timer); 
        input.generateKeyEvent(KeyCode.vk_Right, KeyState.Released); 
        timer.setTime(timer.getTime() + grid.getInputDelay()+1); 
        grid.reactToInput(input, timer); 
        
        assertTrue( "Gem didn't stop moving after Right Key being released", 
        grid.isGemAt(2, 6));     
    }
    
    public void testMultipleLeftKeyPressed()
    {
        grid.insertGem(2, 5, gem); 
        grid.setGemUnderControl(gem); 
        input.generateKeyEvent(KeyCode.vk_Left, KeyState.Pressed); 
        input.generateKeyEvent(KeyCode.vk_Left, KeyState.Released); 
        input.generateKeyEvent(KeyCode.vk_Left, KeyState.Pressed); 
        input.generateKeyEvent(KeyCode.vk_Left, KeyState.Released); 
        grid.reactToInput(input, timer); 
        assertTrue( "Gem didn't move twice with Left Key pressed twice by user.", 
        grid.isGemAt(2, 3));    
    }

    public void testMultipleRightKeyPressed()
    {
        grid.insertGem(2, 5, gem); 
        grid.setGemUnderControl(gem); 
        input.generateKeyEvent(KeyCode.vk_Right, KeyState.Pressed); 
        input.generateKeyEvent(KeyCode.vk_Right, KeyState.Released); 
        input.generateKeyEvent(KeyCode.vk_Right, KeyState.Pressed); 
        input.generateKeyEvent(KeyCode.vk_Right, KeyState.Released); 
        grid.reactToInput(input, timer); 
        assertTrue( "Gem didn't move twice with Right Key pressed twice by user.", 
        grid.isGemAt(2, 7));    
    }
    
    public void testRapidSequence()
    {
        grid.insertGem(2, 5, gem); 
        grid.setGemUnderControl(gem); 
        input.generateKeyEvent(KeyCode.vk_Left, KeyState.Pressed); 
        input.generateKeyEvent(KeyCode.vk_Left, KeyState.Released); 
        input.generateKeyEvent(KeyCode.vk_Left, KeyState.Pressed); 
        input.generateKeyEvent(KeyCode.vk_Left, KeyState.Released); 
        input.generateKeyEvent(KeyCode.vk_Right, KeyState.Pressed); 
        input.generateKeyEvent(KeyCode.vk_Right, KeyState.Released); 
        grid.reactToInput(input, timer); 
        assertTrue( "Grid didn't react correctly to fast sequence.", 
        grid.isGemAt(2, 4)); 
    }

Di questi 9 test, 4 sostituiscono dei test già esistenti con lo stesso nome.

A parole ecco cosa testano:
testKeyLeftLessThanDelay()
Tenendo premuto il tasto, la gemma non si sposta una seconda volta prima che sia passato un certo delay.

testKeyLeftMoreThanDelay
Tenendo premuto il tasto, la gemma si sposta nuovamente una volta passato un certo delay.

testKeyLeftReleased
Rilasciando il tasto, la gemma smette di spostarsi.

testMultipleLeftKeyPressed
Se si preme diverse volte lo stesso tasto, la gemma si muove di un numero equivalente di celle senza che sia necessario attendere il delay.

testRapidSequence
La gemma è capace di reagire correttamente ad una catena di più eventi destra-sinistra in rapida successione senza attendere alcun delay.

[fek]

Originariamente inviato da BlueDragon

1) Popolare la coda di Input tramite KeyboardImpl
E' una cosa "banale" se non fosse per un unico problema...KeyboardImpl conosce il numero intero corrispondente al tasto premuto, ma non conosce l'enum KeyCode da inserire nella coda. Ho guardato la documentazione dell'enum ma non ho trovato metodi per risalire dall'int al KeyCode in maniera semplice. Io nel mio spike avevo fatto una mappa inversa da int a KeyCode, ma non era una cosa carina a vedersi.
Ho parlato con 71104 su MSN ed abbiamo pensato di modificare la coda affinché i KeyEvent contengano gli int e non i KeyCode. La differenza rispetto al codice che c'è adesso sarà semplicemente che anziché scrivere nel codice KeyCode.vk_Left, useremo KeyCode.vk_Left.value() per riferirci al valore int.
Il vantaggio di questa soluzione è che così KeyboardImpl non ha bisogno di una mappa per capire i nostri enum, e noi umani che non ci ricordiamo tutti gli int della tastiera a memoria possiamo ancora appoggiarci ad i nomi dell'enum KeyCode.
Se avete in mente soluzioni migliori....ben vengano!!

L'idea che il cliente della classe debba scrivere KeyCode.vk_Left.value() non mi piace affatto, preferisco una mappa inversa piuttosto.

Personalmente nasconderei anche il KeyCode dietro ad un metodo esplicito (left() magari), ma questo e' un discorso che si fara' piu' avanti.

[BlueDragon]

Beh, possiamo anche mettere la mappa inversa, però a quel punto mi sfugge una cosa...a che serve che il valore KeyCode.vk_Left sia pari a org.lwjgl.input.Keyboard.KEY_LEFT? Se tanto nessuno ne usa mai il value...
Potevamo a questo punto fare una enum associata a valori tipo "pippo","pluto","paperino"....
C'è qualcosa che mi sfugge nell'uso della enum...mi sa che andrò a fare un giro su java.sun.com....

Cmq il codice che avevo usato nello spike è questo:

Riempimento della coda in KeyBoardImpl:

    public void update(Input input)
    {
        Keyboard.poll();
        while(Keyboard.next())
        {
           Input.KeyCode key = (KeyCode)keyMap.get(Keyboard.getEventKey());
            if (key != null)
            {   
                boolean state = Keyboard.getEventKeyState();
                if (state) 
                {
                    input.generateKeyEvent(key , Input.KeyState.Pressed);
                } else 
                {
                    input.generateKeyEvent(key , Input.KeyState.Released);
                }
            }   
        }
    }

Supportato dalla creazione della mappa inversa nel costruttore di KeyboardImpl:

    private HashMap keyMap = new HashMap();

    public KeyboardImplementation()
    {
        try
        {
            Keyboard.create();
            keyMap.put(org.lwjgl.input.Keyboard.KEY_ESCAPE,KeyCode.vk_Escape);
            keyMap.put(org.lwjgl.input.Keyboard.KEY_UP,KeyCode.vk_Up);
            keyMap.put(org.lwjgl.input.Keyboard.KEY_DOWN,KeyCode.vk_Down);
            keyMap.put(org.lwjgl.input.Keyboard.KEY_LEFT,KeyCode.vk_Left);
            keyMap.put(org.lwjgl.input.Keyboard.KEY_RIGHT,KeyCode.vk_Right);
            
        }
        catch(Exception e)
        {
            throw new KeyboardException(
                "Something appened while i was initializing the input " + e);
        }
    }

[fek]

A che punto siamo con questa storia? Alla fine della giornata i task devono essere riassegnati, altrimenti rischiamo di non finirla.

Fatemi sapere qualcosa.

[VICIUS]

Originariamente inviato da fek

A che punto siamo con questa storia? Alla fine della giornata i task devono essere riassegnati, altrimenti rischiamo di non finirla.

Fatemi sapere qualcosa.

Merita un UP.

ciao

[fek]

Ok, il task e' libero. Prenotatevi pure.

[71104]

dovrei aver quasi finito... l'input sembra rispondere bene: quando si fanno pressioni consecutive molto rapide la gemma si sposta tante volte quante sono le pressioni (non tiene conto del delay), mentre quando il tasto rimane premuto a lungo viene tenuto conto del delay e la gemma si sposta a tratti.
i test passano tutti ma ancora non faccio il commit perché reactToInput è arrivato a complessità ciclomatica 14
lo dividerò in una ventina di funzioni e poi committo, ora però devo uscire, ci penserò domani.

ah, una cosa che ho notato è che c'è una notevole duplicazione tra la gestione del tasto left e il tasto right, è questo che provoca una complessità così elevata; bisognerà fare qualcosa, anche perché non si può ulteriormente replicare quel codice nel caso al gioco venga aggiunta la gestione di un altro tasto

inoltre c'è un bel po' di monnezza da buttare sia in Input che in Grid: il bitset ormai non si usa più...

[VICIUS]

Originariamente inviato da 71104

dovrei aver quasi finito... l'input sembra rispondere bene: quando si fanno pressioni consecutive molto rapide la gemma si sposta tante volte quante sono le pressioni (non tiene conto del delay), mentre quando il tasto rimane premuto a lungo viene tenuto conto del delay e la gemma si sposta a tratti. [...]

Ottimo lavoro. Procedi con il refactoring.

caio

[BlueDragon]

Originariamente inviato da 71104

inoltre c'è un bel po' di monnezza da buttare sia in Input che in Grid: il bitset ormai non si usa più...

Sono stato impegnato anche questa settimana ed alla fine è toccato tutto a te
Una curiosità, buttando via il bitset, come fai a sapere che un tasto è ancora premuto e la gemma va mossa ancora?
Io all'inizio avevo messo delle booleane in Grid che mi dicevano se era in corso un movimento a dx o sx (diventavano true quando c'era keypressed e false quando arrivava il keyreleased) poi però le avevo tolte ed avevo deciso di usare semplicemente input.isRightKeyPressed(), che interroga il bitset.

[71104]

ho fatto il commit, ma come ho scritto nel log c'è un bug da correggere (la gemma si comporta in modo strano se le frecce dx e sx vengono premute contemporaneamente) e poi c'è da fare un discorso più complesso per quanto riguarda la duplicazione di codice per la gestione dei due tasti freccia.
BD chiede giustamente come faccio a sapere se i tasti sono attualmente premuti se non uso il BitSet; in effetti ho fatto come ha detto lui, cioè ho usato dei flag, i quali devono essere distinti per ciascuno dei due tasti; tuttavia non è possibile (secondo me) sostituire l'uso dei due flag con l'uso del BitSet perché oltre ai flag bisogna associare ai due tasti anche l'informazione del timestamp dell'ultima pressione, da usare poi assieme al parametro di delay per verificare poi ad ogni iterazione se la gemma deve essere spostata in risposta ad una pressione prolungata del tasto.
di conseguenza dopo la correzione del bug secondo me andrebbe creata una nuova classe Grid.KeyData per mantenere queste due informazioni, e Grid la dovrebbe istanziare due volte (una per ogni freccia). la gestione del tasto freccia giù invece non necessita dell'uso di KeyData perché è molto più semplice: quando arriva un evento vk_Down Pressed la gravità viene aumentata, quando arriva vk_Down Released viene rimessa al valore normale; la gestione della freccia giù insomma non richiede l'uso di parametri di delay ecc.