[TASK 8.2.2] Pair Programming: Ufo13 + thebol

[Ufo13]

Benissimo partiamo subito! :)

[fek]

Prima la test list :)

[Ufo13]

Test List:

- Le Gem appartenenti ad un GemGroup non vengono disegnate.

- Dato un GemGroup testiamo che la texture caricata per disegnare il GemGroup sia la texture corretta.

- Dato un GemGroup testiamo che vengano rilevate le tile di tipo "angolo_alto_sx, angolo_alto_dx etc...", i bordi (alto, sx, dx, basso) e i riempimenti. Il tutto nelle corrette posizioni.

- Dato un gruppo 3x3 testiamo che ai corrispondenti angoli, bordi e riempimenti vengano disegnate le "tile" corrette.

[Ufo13]

Prima la test list :)

dammi il tempo :p

[Ufo13]

ecco il primo test :)

public class TestGemGroupsDrawing extends TestCase
{
private Grid grid;

private MockTimer timer;

public void setUp()
{
grid = Grid.createForTesting();

timer = new MockTimer();
}

public void testGroupedGemIsNotDrawn()
{
MockEngine engine = new MockEngine();

Gem gem1 = Gem.diamond(3500);
Gem gem2 = Gem.diamond(3500);
Gem gem3 = Gem.diamond(3500);
Gem gem4 = Gem.diamond(3500);

insertAndUpdate(gem1, 13, 3);
insertAndUpdate(gem2, 13, 4);
insertAndUpdate(gem3, 12, 3);
insertAndUpdate(gem4, 12, 4);

gem1.draw(engine);
gem2.draw(engine);
gem3.draw(engine);
gem4.draw(engine);

assertEquals("grouped Gems must be not drawn", 0, engine.getNumberOfQuadsDrawn());
}

private void insertAndUpdate(Gem gem, int x, int y)
{
grid.insertGem(x, y, gem);
grid.update(timer, gem);
}
}

[thebol]

public void draw(EngineInterface engine)
{
if (!isInAGroup())
{
sprite.draw(engine);
}

}
è la draw di gem

ps.si sarebbe potuto inserire il controllo in grid.draw(), anziche in gem.draw(); dove è piu sensato metterlo?(per passare questo test è pero obbligatorio metterlo in gem)

[fek]

Test List:

- Le Gem appartenenti ad un GemGroup non vengono disegnate.

- Dato un GemGroup testiamo che la texture caricata per disegnare il GemGroup sia la texture corretta.

- Dato un GemGroup testiamo che vengano rilevate le tile di tipo "angolo_alto_sx, angolo_alto_dx etc...", i bordi (alto, sx, dx, basso) e i riempimenti. Il tutto nelle corrette posizioni.

- Dato un gruppo 3x3 testiamo che ai corrispondenti angoli, bordi e riempimenti vengano disegnate le "tile" corrette.

Ottimo. Aggiungete i test man mano che ne vengono fuori altri.

[fek]

public void draw(EngineInterface engine)
{
if (!isInAGroup())
{
sprite.draw(engine);
}

}
è la draw di gem

ps.si sarebbe potuto inserire il controllo in grid.draw(), anziche in gem.draw(); dove è piu sensato metterlo?(per passare questo test è pero obbligatorio metterlo in gem)

E' piu' sensato metterlo dove fa passare tutti i test, quindi dove l'hai messo tu :)

[Bonfo]

Che bello...ho la ppossibilità di guardarmi un task in pair in diretta!!! :asd:
Meglio di SKY...mi prendo 2 pop-corn e me lo godo tutto !!! :rotfl: :rotfl: :rotfl:

[Ufo13]

E' piu' sensato metterlo dove fa passare tutti i test, quindi dove l'hai messo tu :)

ashg

[thebol]

public void testGetTexture(){
Config config = Config.createForTesting();
GemGroups gemGroups = new GemGroups(config.getInteger("rows"), config.getInteger("columns"));
gemGroups.addGem(gem1);
assertNotNull("Not texture loaded in gemGroups",gemGroups.getTexture());

}

[Ufo13]

Hmmm il test da NullPointerException...

La Gem va prima inserita nella griglia :)

Il test cambia così:


public void testGetTexture()
{
Config config = Config.createForTesting();
GemGroups gemGroups = new GemGroups(config.getInteger("rows"), config.getInteger("columns"));
insertAndUpdate(gem1, 11, 4);
gemGroups.addGem(gem1);
assertNotNull("No texture loaded in gemGroups", gemGroups.getTexture());
}



Questo è il codice (Quick Fix) che fa passare il test :)


public Texture getTexture()
{
return new Texture("diamond");
}

[Ufo13]

preparo il nuovo test....

Devo testare che il GemGroup restituisca la Texture giusta in base al "GemType del gruppo"... Il GemType del GemGroup non è definito... Tralasciamo questo test un secondo :)

Propongo questo test

public void testGemType()
{
insertAndUpdate(gem3, 13, 3);
insertAndUpdate(gem4, 13, 4);
insertAndUpdate(gem5, 12, 3);
insertAndUpdate(gem6, 12, 4);

assertEquals("Wrong GemType of this GemGroup", GemType.EMERALD, gem3.getGroup().getType());
}


Corretto il test... 12 invece di 14 :D

[Ufo13]

Non capisco perchè da build rotta sulla build machine... I test sono in ignore!

[thebol]

public GemType getType()
{
return gemType;
}
il type viene definito nel costruttore

public GemGroups(int rows, int columns, GemType gemType)
{
defaultRows = rows;
defaultColumns = columns;
this.gemType = gemType;
}

questo per evitare che un gruppo non abbia gemType.

[Ufo13]

thebol ha committato un nuovo test ma è dovuto scappare così non ha potuto postare


public void testDifferenteTextureLoaded(){
insertAndUpdate(gem3, 13, 1);
insertAndUpdate(gem4, 13, 2);
insertAndUpdate(gem5, 12, 1);
insertAndUpdate(gem6, 12, 2);

insertAndUpdate(gem9, 13, 3);
insertAndUpdate(gem10, 13, 4);
insertAndUpdate(gem11, 12, 3);
insertAndUpdate(gem12, 12, 4);

assertEquals("gemGroup Texture is not correct", "gfx/gems/tiles/emerald", gem3.getGroup().getTexture().getName());
assertEquals("gemGroup Texture is not correct", "gfx/gems/tiles/diamond", gem9.getGroup().getTexture().getName());
}


L'ho modificato un pelo per testare che la texture sia proprio del tipo corretto :)

[Ufo13]

Aggiunti i seguenti field in GemGroup (ho pure cambiato il nome da GemGroups a GemGroup per coerenza con Gem)


private static final String GEMGROUP_PATH = "gfx/gems/tiles/";

private Texture texture;




Nel costruttore viene inizializzato l'oggetto Texture


this.texture = new Texture(GEMGROUP_PATH.concat(gemType.name()));




Di conseguenza


public Texture getTexture()
{
return texture;
}


Build verde :)

Preparo il nuovo test

[Ufo13]

Il nuovo test è:


public void testCorrectGemsPositions()
{
Gem gem9 = Gem.create(gem3.getType(), 3500);
Gem gem10 = Gem.create(gem3.getType(), 3500);
Gem gem11 = Gem.create(gem3.getType(), 3500);

insertAndUpdate(gem3, 13, 1);
insertAndUpdate(gem4, 13, 2);
insertAndUpdate(gem5, 13, 3);
insertAndUpdate(gem6, 12, 1);
insertAndUpdate(gem7, 12, 2);
insertAndUpdate(gem8, 12, 3);
insertAndUpdate(gem9, 11, 1);
insertAndUpdate(gem10, 11, 2);
insertAndUpdate(gem11, 11, 3);

GemGroup gemGroup = gem3.getGroup();

assertEquals("gem3's groupPosition is not correct", GemGroup.PositionType.BottomLeftCorner, gemGroup.getPositionType(gem3));
assertEquals("gem4's groupPosition is not correct", GemGroup.PositionType.BottomEdge, gemGroup.getPositionType(gem4));
assertEquals("gem5's groupPosition is not correct", GemGroup.PositionType.BottomRightCorner, gemGroup.getPositionType(gem5));
assertEquals("gem6's groupPosition is not correct", GemGroup.PositionType.LeftEdge, gemGroup.getPositionType(gem6));
assertEquals("gem7's groupPosition is not correct", GemGroup.PositionType.Inner, gemGroup.getPositionType(gem7));
assertEquals("gem8's groupPosition is not correct", GemGroup.PositionType.RightEdge, gemGroup.getPositionType(gem8));
assertEquals("gem9's groupPosition is not correct", GemGroup.PositionType.TopLeftCorner, gemGroup.getPositionType(gem9));
assertEquals("gem10's groupPosition is not correct", GemGroup.PositionType.TopEdge, gemGroup.getPositionType(gem10));
assertEquals("gem11's groupPosition is not correct", GemGroup.PositionType.TopRightCorner, gemGroup.getPositionType(gem11));
}


A te thebol :)

[thebol]

private void updateGroup()
{

if (checkRectFullOfGems())
{
setGemPositionType();
lightUpGems();
}
}

private void setGemPositionType()
{
candidateGems.put(lefTopCorner, PositionType.TopLeftCorner);
candidateGems.put(leftBottomCorner, PositionType.BottomLeftCorner);
candidateGems.put(rightTopCorner, PositionType.TopRightCorner);
candidateGems.put(rightBottomcorner, PositionType.BottomRightCorner);

for(Gem currentGem : candidateGems.keySet())
{
if (isSettablePositionType(currentGem))
{
if (isInnerGem(currentGem))
{
candidateGems.put(currentGem, PositionType.Inner);

}
else if (currentGem.getCellRow() == topRow)
{
candidateGems.put(currentGem, PositionType.TopEdge);
}
else if (currentGem.getCellRow() == bottomRow)
{
candidateGems.put(currentGem, PositionType.BottomEdge);
}
else if (currentGem.getCellColumn() == leftColumn)
{
candidateGems.put(currentGem, PositionType.LeftEdge);
}
else if (currentGem.getCellColumn() == rightColumn)
{
candidateGems.put(currentGem, PositionType.RightEdge);
}

}
}

}

4 posizione le ho gratis.
poi per le restanti settabili guardo che spigoli sono.

qua gli altri metodi che facevano arrivare la complessita a 12 :asd:

private boolean isSettablePositionType(Gem currentGem)
{
return gemIsInRect(currentGem) && !gemIsACorner(currentGem);
}

private boolean isInnerGem(Gem currentGem)
{
return currentGem.getCellRow() > topRow
&& currentGem.getCellColumn() > leftColumn
&& currentGem.getCellRow() < bottomRow
&& currentGem.getCellColumn() < rightColumn;
}

currentGem è diventata una hashMap<Gem. typePosition>, ho modificato un paio di metodi che ciclavano sull'arrayList.

[Ufo13]

Posto io il test che ha fatto thebol :)

L'ho completato ed ora è così


public void testCorrectTileDraw()
{
MockEngine engine = MockEngine.createForTesting(800, 600);

Gem gem9 = Gem.create(gem3.getType(), 3500);
Gem gem10 = Gem.create(gem3.getType(), 3500);
Gem gem11 = Gem.create(gem3.getType(), 3500);

insertAndUpdate(gem3, 13, 1);
insertAndUpdate(gem4, 13, 2);
insertAndUpdate(gem5, 13, 3);
insertAndUpdate(gem6, 12, 1);
insertAndUpdate(gem7, 12, 2);
insertAndUpdate(gem8, 12, 3);
insertAndUpdate(gem9, 11, 1);
insertAndUpdate(gem10, 11, 2);
insertAndUpdate(gem11, 11, 3);

GemGroup gemGroup = gem3.getGroup();

gemGroup.draw(PositionType.BottomLeftCorner, engine);
assertEquals("bad texture drawn", 0, engine.getTextureRect().left());
assertEquals("bad texture drawn", Gem.GEM_SIZE * 2, engine.getTextureRect().top());

gemGroup.draw(PositionType.BottomEdge, engine);
assertEquals("bad texture drawn", Gem.GEM_SIZE, engine.getTextureRect().left());
assertEquals("bad texture drawn", Gem.GEM_SIZE * 2, engine.getTextureRect().top());

gemGroup.draw(PositionType.BottomRightCorner, engine);
assertEquals("bad texture drawn", Gem.GEM_SIZE * 2, engine.getTextureRect().left());
assertEquals("bad texture drawn", Gem.GEM_SIZE * 2, engine.getTextureRect().top());

gemGroup.draw(PositionType.LeftEdge, engine);
assertEquals("bad texture drawn", 0, engine.getTextureRect().left());
assertEquals("bad texture drawn", Gem.GEM_SIZE, engine.getTextureRect().top());

gemGroup.draw(PositionType.Inner, engine);
assertEquals("bad texture drawn", Gem.GEM_SIZE, engine.getTextureRect().left());
assertEquals("bad texture drawn", Gem.GEM_SIZE, engine.getTextureRect().top());

gemGroup.draw(PositionType.RightEdge, engine);
assertEquals("bad texture drawn", Gem.GEM_SIZE * 2, engine.getTextureRect().left());
assertEquals("bad texture drawn", Gem.GEM_SIZE, engine.getTextureRect().top());

gemGroup.draw(PositionType.TopLeftCorner, engine);
assertEquals("bad texture drawn", 0, engine.getTextureRect().left());
assertEquals("bad texture drawn", 0, engine.getTextureRect().top());

gemGroup.draw(PositionType.TopEdge, engine);
assertEquals("bad texture drawn", Gem.GEM_SIZE, engine.getTextureRect().left());
assertEquals("bad texture drawn", 0, engine.getTextureRect().top());

gemGroup.draw(PositionType.TopRightCorner, engine);
assertEquals("bad texture drawn", Gem.GEM_SIZE * 2, engine.getTextureRect().left());
assertEquals("bad texture drawn", 0, engine.getTextureRect().top());
}

[Ufo13]

Inizio con QuickFix sul draw di GemGroup per far compilare il tutto...

Build rossa... NullPointerException... Implemento il draw :)


public void draw(PositionType position, EngineInterface engine)
{
Point origin = POSITIONTOPOINT.get(position);

sprite.setOrigin((int)origin.getX(), (int)origin.getY());

sprite.draw(engine);
}


Ho aggiunto una HashMap per tenere le posizioni di ogni tile all'interno della Texture.

Build verde :)

[Ufo13]

Bene preparo il prossimo test


public void testDrawInCorrectPositions()
{
MockEngine engine = MockEngine.createForTesting(800, 600);

Gem gem9 = Gem.create(gem3.getType(), 3500);
Gem gem10 = Gem.create(gem3.getType(), 3500);
Gem gem11 = Gem.create(gem3.getType(), 3500);

insertAndUpdate(gem3, 13, 1);
insertAndUpdate(gem4, 13, 2);
insertAndUpdate(gem5, 13, 3);
insertAndUpdate(gem6, 12, 1);
insertAndUpdate(gem7, 12, 2);
insertAndUpdate(gem8, 12, 3);
insertAndUpdate(gem9, 11, 1);
insertAndUpdate(gem10, 11, 2);
insertAndUpdate(gem11, 11, 3);

grid.draw(engine);

assertEquals("GemGroup wasn't drawn correctly", 10, engine.getNumberOfQuadsDrawn());
}


I quad sono 10 perchè c'è anche il Background :)

Build rossa...

[Ufo13]

thebol è uscito e Fek ha chiesto di finire il task stasera... Finisco io...

cambio il draw in Grid


public void draw(EngineInterface engine)
{
background.draw(engine);

for(int y = grid.length - 1; y >= 0; y--)
{
for(int x = 0; x < grid[y].length; x++)
{
Gem gem = getGemAt(y, x);
if(gem != null)
{
gem.draw(engine);

if(gem.getGroup() != null)
{
gem.getGroup().draw(gem.getGroup().getPositionType(gem), engine);
}
}
}
}
}


Build Verde :)

[Ufo13]

Mi manca ancora un test... la draw di un tile deve venire fatta alle coordinate della gemma corrispondente nel gemgroup.

Hmmm pensandoci bene preferisco spezzarlo in due test... Prima controllo che la draw venga fatta in una certa posizione.


public void testGridDrawsTilesInRightPositions()
{
MockEngine engine = MockEngine.createForTesting(800, 600);

insertAndUpdate(gem3, 13, 1);
insertAndUpdate(gem4, 13, 2);
insertAndUpdate(gem5, 12, 1);
insertAndUpdate(gem6, 12, 2);

gem3.getGroup().draw(PositionType.BottomLeftCorner, engine, new Point(10, 20));

assertEquals("Tile wasn't drawn in correct position (X)", 10, (int)engine.getQuadPosition().getX());
assertEquals("Tile wasn't drawn in correct position (Y)", 20, (int)engine.getQuadPosition().getY());

gem3.getGroup().draw(PositionType.BottomLeftCorner, engine, new Point(30, 40));

assertEquals("Tile wasn't drawn in correct position (X)", 30, (int)engine.getQuadPosition().getX());
assertEquals("Tile wasn't drawn in correct position (Y)", 40, (int)engine.getQuadPosition().getY());
}


Il codice che fa passare il test è questo:

public void draw(PositionType positionType, EngineInterface engine, Point position)
{
Point origin = POSITIONTOPOINT.get(positionType);

sprite.setOrigin((int)origin.getX(), (int)origin.getY());

sprite.moveTo(position.getX(), position.getY());

sprite.draw(engine);
}

[Ufo13]

Mi serve un test che dimostri la correttezza della posizione della draw...

Non sono riuscito a trovare modo migliore per fare questo test :)


public void testGridDrawsEveryTileInCorrespondingGemPosition()
{
MockEngine engine = MockEngine.createForTesting(800, 600);

insertAndUpdate(gem3, 13, 1);
insertAndUpdate(gem4, 13, 2);
insertAndUpdate(gem5, 12, 1);
insertAndUpdate(gem6, 12, 2);

grid.draw(engine);

assertEquals("TopRight tile wasn't drawn correctly (X)", gem6.getX(), engine.getQuadPosition().getX());
assertEquals("TopRight tile wasn't drawn correctly (Y)", gem6.getY(), engine.getQuadPosition().getY());

gem6.moveTo(60, 50);

grid.draw(engine);

assertEquals("TopRight tile wasn't drawn correctly (X)", gem6.getX(), engine.getQuadPosition().getX());
assertEquals("TopRight tile wasn't drawn correctly (Y)", gem6.getY(), engine.getQuadPosition().getY());
}


Il codice che fa passare il test è semplicissimo:


public void draw(EngineInterface engine)
{
background.draw(engine);

for(int y = grid.length - 1; y >= 0; y--)
{
for(int x = 0; x < grid[y].length; x++)
{
Gem gem = getGemAt(y, x);
if(gem != null)
{
gem.draw(engine);

if(gem.getGroup() != null)
{
Point position = new Point(gem.getX(), gem.getY());

GemGroup gemGroup = gem.getGroup();

gemGroup.draw(gemGroup.getPositionType(gem), engine, position);
}
}
}
}
}


E finalmente gli agglomerati si vedono in gioco :)

[fek]

Appena provata la build. Che belli i gemmoni! :D