[CICLO 6/bis] Xmas Carol Story 2

[Jocchan]

Visto che siete insaziabili, e avete già prenotato tutti i task disponibili, allora possiamo permetterci di introdurre anche una nuova storia, che ci porterà ancora più vicini ad una versione effettivamente giocabile. Questa storia è indipendente dalla precedente, quindi potrete prenotarvi per i task fin da subito.

Storia 2: Le gemme devono scendere a coppie di due, sebbene la loro caduta sia scollegata. Quella inizialmente in basso è la gemma primaria della coppia, quella inizialmente in alto è la secondaria. Premendo il tasto Z, la secondaria deve cambiare posizione ruotando (ma non su sè stessa, le png devono avere lo stesso aspetto) in senso antiorario intorno alla primaria. Premendo il tasto X, invece, la secondaria deve ruotare in senso orario. Se la casella di destinazione della gemma secondaria è già occupata, e la rotazione è impossibile, la gemma verrà automaticamente fatta ruotare ulteriormente nello stesso senso di rotazione, fino a trovare una casella libera in cui posizionarla. Gli effetti delle rotazioni sono descritti nello schema:

- secondaria sopra la primaria -> la secondaria andrà rispettivamente a sinistra o a destra della primaria
- secondaria a sx della primaria -> andrà rispettivamente sotto o sopra
- secondaria sotto la primaria -> andrà rispettivamente a destra o a sinistra
- secondaria a dx della primaria -> andrà rispettivamente sopra o sotto

Mediante il tasto C, la gemma secondaria dovrà ruotare di due posizioni.
Quando ognuna delle due gemme collide con qualche oggetto sottostante, l'altra - se non troverà nulla al di sotto - proseguirà indipendentemente la propria caduta. Il box Next continuerà a mostrare, senza incertezze, la coppia di gemme immediatamente successiva a quella attualmente in caduta (la nuova primaria in basso, la nuova secondaria in alto).


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
• Postare sempre la test list PRIMA di mettere mano al codice

[Jocchan]

Piccolo schema riassuntivo per le rotazioni:

[VICIUS]

Ecco i task per questa nuova storia.

Task
Xmas.2.1: thebol + Ufo13: completato
GridControl deve ora creare due gemme. La prima si chiamera pivot e sara quella sotto controllo tramite input. La secondaria deve seguire i movimenti della prima.
Xmas.2.2: DanieleC88: completato
Intercettare la pressione del tasto Z e ruotare la gemma secondaria di 90° in senso orario attorno al pivot
Xmas.2.3: VICIUS: completato
Intercettare la pressione del tasto X e ruotare la gemma secondaria di 90° in senso anti-orario attorno al pivot
Xmas.2.4: VICIUS: completato
Intercettare la pressione del tasto C e ruotare la gemma secondaria di 180°.
Xmas.2.5: 71104: completato
Quando una delle due gemme collide entrambe perdono il controllo e quella ancora libera precipita verso la prima cella libera.

ciao

[Ufo13]

prendo Xmas.2.4, 2 giorni dopo la fine del task 1

[DanieleC88]

Il Xmas.2.2 è mio.
1 giorno, direi.

[thebol]

Prendo l'Xmas 2.1
tempo 2 giorni

[71104]

vorrei il 5°, 2 giorni a partire da quando finisco il task del game over ^^'
(provo a finirlo adesso)

[fek]

Ho fatto un corposo refactoring di GridController e InputReactor (cionci, e' quello di cui abbiamo parlato). Fate un bell'update prima di iniziare i vostri task.

Mi raccomando la test list.

[thebol]

testlist provvisoria:

test inserire 2 gemme in grid e posizione
test che la prima gemma inserita sia quella sottocontrollo(pivot) e nella posizione
1,4
test che la seconda gemma sia in 0,4

test che a un movimento della prima gemma, corrisponda un movimento analogo della seconda



naturalmente, varie ed eventuali

[thebol]

Lo scopo del task è generare 2 gemme e metterle sotto il controllo di grid.

Per fare questo, voglio pero aggiungere un test, per controllare che la queue dopo essere stata creata sia full

    public void testFullAfterNew()
    {
        assertTrue("queue must be full",new GemQueue(Config.createForTesting()).isFull());   
       
    }

poi inserisco il test

    public void testInsertTwoNewGem()
    {
        int oldNumberOfGems = grid.getNumberOfGems();
        grid.insertTwoNewGem();
        assertTrue("two gem are added", grid.getNumberOfGems() - 2 == oldNumberOfGems);
    }
    
    public void testPositionOfInsertTwoNewGem()
    {
        grid.insertTwoNewGem();
        assertTrue("one jem at 0,4", grid.isGemAt(0, 4));
        assertTrue("one jem at 1,4", grid.isGemAt(1, 4));
    }

implemento:

    public void insertTwoNewGem()
    {
        insertGem(1,4, gemGenerator.extract());
        insertGem(0,4, gemGenerator.extract());
    }

ora devo settare la prima come master, e la seconda come slave

devo introdurre un nuovo metodo che inserisca la gemma come slave(ho aggiunto la variabile gemSlave).

ma ancor prima devo creare e testare che la setGemSlave e getSlave

    public void testGetGemSlave()
    {
        
        grid.setGemSlave(gem1);

        assertSame("Wrong gem under control", gem1, grid.getGemSlave());
    }
    
    public void testGetgemSlaveIsNotInTheGrid()
    {
        try
        {
            grid.insertGem(0, 0, gem1);
            grid.setGemSlave(Gem.createForTesting());
        }
        catch(IllegalArgumentException e2)
        {
            return;
        }

        fail("must throw if gem is not in the grid");
    }

e

    public Gem getGemSlave()
    {
        return gemSlave;
    }


    public void setGemSlave(Gem gem)
    {
        if(!gem.isAttachedToGrid())
        {
            throw new IllegalArgumentException();
        }

        gemSlave= gem;
        
    }

introduco poi il metodo insertGemAsSlave(...)

[VICIUS]

Originariamente inviato da thebol

poi inserisco il test

    public void testInsertTwoNewGem()
    {
        int oldNumberOfGems = grid.getNumberOfGems();
        grid.insertTwoNewGem();
        assertTrue("two gem are added", grid.getNumberOfGems() - 2 == oldNumberOfGems);
    }

Qui secondo me convine usare: assetEquals("...", oldNumberOfGems + 2, grid.getNumberOfGems())
in questo modo è molto piu chiaro quello che vuoi testare.

ciao

[thebol]

A questo punto per la insertGemAsSlave devo testare:
che inserisca la gemma in grid, che dove la inserisca non ci siano altre gemme, etc



Pero primi mi rendo conto che insertGemAsSlave fa praticamente tutto il lavoro di insertGem, ma invece di chiamare alla fine setGemUnderControl(gem);
chiamerà setGemSlave(gem);

per questo, prima di implementare insertGemSlave, faccio un po di refactoring.

tolgo la setGemUnderCOntrol(gem) da insertGem (rendendola piu generica) e la sposto nella
insertNewGem che diventa

    public void insertNewGem()
    {
        Gem gem1 = gemGenerator.extract();
        insertGemIntoColumn(4, gem1);
        setGemUnderControl(gem1);
    }

si sarebbe potuto creare un metodo insertGemUnderControl, ma per adesso penso vada bene cosi.

la insertNewGem() diventa percio

        Gem gem1 = gemGenerator.extract();
        insertGemIntoColumn(4, gem1);
        setGemUnderControl(gem1);

la build cosi è molto rotta, perche in molti test(nel codice forse no, il gioco sembra andare bene) la insertGem e stata usata presupponendo che mettesse anche la gemma sotto controllo.

percui, rifaccio lo stesso refactoring ma in un altra maniera
prima rinomino insertGem in insertGemUnderControl, e poi ci estraggo tutto il codice tranne l'ultim riga e rinomino il metodo insertGem.

Alla fine la insertGemUnderControl è venuta fuori =D. Si potrebbe fare un po di refactoring sui test per vedere dove andrebbe usate insertGem invece che insertGemUnderControl(la ex insertGem), ma si puo fare in futuro.

[la nuova funzione insertGem e testata implicitamente da tutti i test che testano insertGemUnderControl, percui escluso il discorso di prima, non cè bisogno di toccare i test]

a questo punto posso aggiungere

    public void testInsertGemAsSlave(){
        grid.insertGemAsSlave(0, 0, gem1);
        assertSame("Wrong gem slave", gem1, grid.getGemSlave());
    }

con relativa implementazione

    public void insertGemAsSlave(int row, int column, Gem gem)
    {
        insertGem(row, column, gem);
        setGemSlave(gem);
    }

[thebol]

Originariamente inviato da VICIUS

Qui secondo me convine usare: assetEquals("...", oldNumberOfGems + 2, grid.getNumberOfGems())
in questo modo è molto piu chiaro quello che vuoi testare.

ciao

fatto

[thebol]

dopo questa modifica insertTwoNewGem() diventa

   public void insertTwoNewGem()
    {
        insertGemUnderControl(1,4, gemGenerator.extract());
        insertGemAsSlave(0,4, gemGenerator.extract());
    }

e posso testare il fatto che

    public void testInsertTwoNewGem()
    {
        int oldNumberOfGems = grid.getNumberOfGems();
        grid.insertTwoNewGem();
        assertEquals("two gem are added", oldNumberOfGems +2, grid.getNumberOfGems());
        assertNotNull("Gem under control is null", grid.getGemUnderControl());
        assertNotNull("Gem slave is null", grid.getGemSlave());
    }

(Avrei dovuto fare il contrario, sorry :\ )


ora manca il test per il movimento simultaneo della gemmaPivot e per la slave

mi verrebbe da testare che a ogni movimento le posizioni relative rimangano costanti, ma se a qualcuno viene un idea migliore, forse e meglio

[thebol]

inizio testando che la seconda gemma cada per la gravita

    public void testTwoGemIsMovingWhenLowerCellIsEmpty()
    {
        grid.insertGemUnderControl(1, 4, gem1);
        grid.insertGemAsSlave(0,4,gem2);
        //grid.setGemUnderControl(gem1);
        grid.setGravity(1.0f);
        
        float oldPositionPivot = gem1.getY();
        float oldPositionSlave = gem2.getY();
        
        grid.update(new MockTimer());
        
        assertEquals("Gem Pivot is not moving when cell under current position is empty", 
            oldPositionPivot + 1.0f, gem1.getY(), 0.0001f);
        
        assertEquals("Gem Slave is not moving when cell under current position is empty", 
            oldPositionSlave + 1.0f, gem2.getY(), 0.0001f);
    }

modificando il metodo update di grid

    public void update(AbstractTimer timer)
    {
        updateGemAnimations(timer);
        
        if(getGemUnderControl() == null)
        {
            return;
        }

        if(gemCantMoveDown(getGemUnderControl()))
        {
            alignGemToCellUpperBound(getGemUnderControl());
            getGemUnderControl().dropGem();

            if(gemIsSurroundedBySameType(getGemUnderControl()))
            {
                getGemUnderControl().useBrighterImage();
            }
        }
        else
        {
            moveGem(getGemUnderControl());
            if (getGemSlave() == null){
                return;
            }
            moveGem(getGemSlave());
        }
    }

Cosi facendo, tutti i test passano e posso andare avanti.
[NB, con questa implementazione ci puo essere un bug se girando le gemme, quella piu in basso risulta la slave. Ma mi sembra che questa cosa vada risolta col 4 task, percui se non ricevo altre informazioni, questo caso non sarà coperto in questo task]

questo test compre anche il caso della pressione del tasto down, che presuppone un aumento
del fattore gravity



Ora ce da testare che se spingo lefkey, entrambe le gemme si spostino(andra poi fatto uguale per rightkey)

   public void testTwoGemMoveLeft()
    {
        
        grid.insertGemUnderControl(1, 4, gem1);
        grid.insertGemAsSlave(0, 4, gem2);

        input.generateKey(KeyCode.vk_Left, timer.getTime());
        inputReactor.reactToInput();

        assertEquals("Gem pivot didnt move to the left", grid.getGemAt(1, 3), gem1);
        assertEquals("Gem slave didnt move to the left", grid.getGemAt(0, 3), gem2);
    }

per farlo passare, basta andare nella classe LeftKeyHandler e modificare executeWhenPressed

    public void executeWhenPressed(InputReactor inputReactor)
    {
        KeyEventHandler rightHandler = inputReactor.getKeyHandler(KeyCode.vk_Right);
        
        if(!rightHandler.wasRepeated() 
            && !rightHandler.hasBeenRepeated(
                    inputReactor.getLastInputTimeStamp()))
        {
            if(this.grid.getGemUnderControl() != null)
            {
                this.grid.moveGemLeft(this.grid.getGemUnderControl());                
            }
            if(this.grid.getGemSlave() != null)
            {
                this.grid.moveGemLeft(this.grid.getGemSlave());                
            }
        }
    }

analogo per il moveRight

[^TiGeRShArK^]

non ci posso credereeee!!!
mi avete lasciato il 2.3!!!
sono commosso!!!
non ci speravo proprio che dei lupi famelici come voi mi lasciassero qualcosa....
VICIUUUUSSSS:..
prenotami prima che se lo mangi qualcunoooo!!!!!!

tempo stimato ....... se il pc a torino non si è autodistrutto direi 2 giorni....

[thebol]

ho una domanda da fare.
i test per il movimento, non è propriamente corretto, nel senso che se le 2 gemme sono messe in orizzontale (2,1)(2,0) puo non funzionare.

Questa e pero una casistica compresa nel mio task?

in teoria no, visto che non è ancora possibile farle girare...

percui introddurre questo test e andare fuori task o no?

[Jocchan]

Originariamente inviato da thebol

ho una domanda da fare.
i test per il movimento, non è propriamente corretto, nel senso che se le 2 gemme sono messe in orizzontale (2,1)(2,0) puo non funzionare.

Questa e pero una casistica compresa nel mio task?

in teoria no, visto che non è ancora possibile farle girare...

percui introddurre questo test e andare fuori task o no?

Non hai tutti i torti, in effetti ci starebbe bene un sesto task, per definire il comportamento anche nei casi di posizionamenti relativi differenti.
Quando vedo Vicius su MSN vedremo di elaborarlo e di postarlo. Poi, se nessuno si prenota, allora sarà tuo di diritto

[cionci]

Sinceramente io avrei visto benissimo una classe GemsPair derivata da Gem con una istanza della gemma slave all'interno...
Continuando così si rende Grid troppo complicato...magari avrebbe dovuto essere il task Xmas.2.0...

[Ufo13]

Originariamente inviato da cionci

Sinceramente io avrei visto benissimo una classe GemsPair derivata da Gem con una istanza della gemma slave all'interno...
Continuando così si rende Grid troppo complicato...magari avrebbe dovuto essere il task Xmas.2.0...

Sono d'accordissimo sul GemsPair che renderebbe il tutto mooolto più facile da gestire, però non capisco perchè deve derivare da Gem...