javauis/lcdui_qt/tsrc/src/com/nokia/openlcdui/mt/game/CollisionDetectionTest.java
/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
package com.nokia.openlcdui.mt.game;
import junit.framework.*;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.Sprite;
import javax.microedition.lcdui.game.TiledLayer;
import com.nokia.openlcdui.mt.SWTTestCase;
/**
* Unit tests for LCDUI Sprite collision detection.
*/
public class CollisionDetectionTest extends SWTTestCase
{
/**
* Constructor.
*/
public CollisionDetectionTest()
{
}
/**
* Constructor.
*
* @param sTestName Test name.
* @param rTestMethod Test method.
*/
public CollisionDetectionTest(String sTestName)
{
super(sTestName);
}
/**
* To create the test suite. You need to add a new aSuite.addTest entry for
* any new test methods.
*
* @return new testsuite.
*/
public static Test suite()
{
TestSuite suite = new TestSuite();
java.util.Vector methodNames;
java.util.Enumeration e;
// Add widget tests
methodNames = CollisionDetectionTest.methodNames();
e = methodNames.elements();
while(e.hasMoreElements())
{
suite.addTest(new CollisionDetectionTest((String)e.nextElement()));
}
return suite;
}
public static java.util.Vector methodNames()
{
java.util.Vector methodNames = new java.util.Vector();
methodNames.addElement("testSpriteImageCollision");
methodNames.addElement("testSpriteSpriteCollision");
methodNames.addElement("testSpriteTiledLayerCollision");
methodNames.addElement("testCollisionTransform");
return methodNames;
}
protected void runTest() throws Throwable
{
if(getName().equals("testSpriteImageCollision")) testSpriteImageCollision();
else if(getName().equals("testSpriteSpriteCollision")) testSpriteSpriteCollision();
else if(getName().equals("testSpriteTiledLayerCollision")) testSpriteTiledLayerCollision();
else if(getName().equals("testCollisionTransform")) testCollisionTransform();
else super.runTest();
}
/** Tests collision between sprite and image.
*/
public void testSpriteImageCollision()
{
Image image1 = null;
Image image2 = null;
try
{
//100x100, 0,0, -> 50,50 full opaque, 0,50 -> 50,70 partially
//transparent, other area full transparent.
image1 = Image.createImage("opaqueTest.png");
image2 = Image.createImage("opaqueTest.png");
}
catch(java.io.IOException e)
{
System.out.println(e);
fail("" + e);
}
Sprite sprite1 = new Sprite(image1);
// Test non-overlapping sprite and image:
sprite1.setPosition(100, 100);
assertTrue("sprite-image fail 1.", !sprite1.collidesWith(image2, 100, 0, false));
assertTrue("sprite-image fail 2.", !sprite1.collidesWith(image2, 100, 0, true));
assertTrue("sprite-image fail 3.", !sprite1.collidesWith(image2, 100, 200, false));
assertTrue("sprite-image fail 4.", !sprite1.collidesWith(image2, 100, 200, true));
assertTrue("sprite-image fail 5.", !sprite1.collidesWith(image2, 0, 100, false));
assertTrue("sprite-image fail 6.", !sprite1.collidesWith(image2, 0, 100, true));
assertTrue("sprite-image fail 7.", !sprite1.collidesWith(image2, 200, 100, false));
assertTrue("sprite-image fail 8.", !sprite1.collidesWith(image2, 200, 100, true));
// Test overlapping sprite and image:
sprite1.setPosition(0, 0);
assertTrue("sprite-image fail 9.", sprite1.collidesWith(image2, 0, 0, false));
assertTrue("sprite-image fail 10.", sprite1.collidesWith(image2, 0, 0, true));
// Test overlapping transparent sprite and image:
assertTrue("sprite-image fail 11.", sprite1.collidesWith(image2, 50, 0, false));
assertTrue("sprite-image fail 12.", !sprite1.collidesWith(image2, 50, 0, true));
// Test collisionarea-settings:
sprite1.defineCollisionRectangle(0, 0, 50, 100);
assertTrue("sprite-image fail 13.", sprite1.collidesWith(image2, 0, 0, false));
assertTrue("sprite-image fail 14.", sprite1.collidesWith(image2, 0, 0, true));
sprite1.defineCollisionRectangle(50, 0, 50, 100);
assertTrue("sprite-image fail 15.", sprite1.collidesWith(image2, 0, 0, false));
assertTrue("sprite-image fail 16.", !sprite1.collidesWith(image2, 0, 0, true));
sprite1.defineCollisionRectangle(0, 0, 50, 100);
assertTrue("sprite-image fail 17.", !sprite1.collidesWith(image2, 50, 0, false));
assertTrue("sprite-image fail 18.", !sprite1.collidesWith(image2, 50, 0, true));
sprite1.defineCollisionRectangle(0, 0, 100, 100);
// Test invisible sprite:
sprite1.setVisible(false);
assertTrue("sprite-image fail 19.", !sprite1.collidesWith(image2, 0, 0, false));
sprite1.setVisible(true);
// Test framed sprites:
// 2x2 = 4 frames.
Sprite sprite3 = new Sprite(image1, 50, 50);
sprite3.setPosition(0, 0);
assertTrue("sprite-image fail 20.", sprite3.collidesWith(image2, 0, 0, false));
assertTrue("sprite-image fail 21.", sprite3.collidesWith(image2, 0, 0, true));
sprite3.nextFrame();
assertTrue("sprite-image fail 22.", sprite3.collidesWith(image2, 0, 0, false));
assertTrue("sprite-image fail 23.", !sprite3.collidesWith(image2, 0, 0, true));
// Test rotated sprite:
sprite1.setTransform(Sprite.TRANS_ROT90);
sprite1.setPosition(0, 0);
assertTrue("sprite-image fail 24.", sprite1.collidesWith(image2, 0, 0, false));
assertTrue("sprite-image fail 25.", sprite1.collidesWith(image2, 0, 0, true));
sprite1.setTransform(Sprite.TRANS_ROT180);
sprite1.setPosition(0, 0);
assertTrue("sprite-image fail 26.", sprite1.collidesWith(image2, 0, 0, false));
assertTrue("sprite-image fail 27.", !sprite1.collidesWith(image2, 0, 0, true));
// Test collision rectangle in transformed sprite:
sprite1.setTransform(Sprite.TRANS_NONE);
sprite1.defineCollisionRectangle(0, 0, 50, 50);
sprite1.setTransform(Sprite.TRANS_ROT90);
sprite1.setPosition(0, 0);
assertTrue("sprite-image fail 28.", sprite1.collidesWith(image2, 0, 0, false));
assertTrue("sprite-image fail 29.", !sprite1.collidesWith(image2, 0, 0, true));
}
/** Tests collision between two sprites.
*/
public void testSpriteSpriteCollision()
{
Image image1 = null;
Image image2 = null;
try
{
//100x100, 0,0, -> 50,50 full opaque, 0,50 -> 50,70 partially
//transparent, other area full transparent.
image1 = Image.createImage("opaqueTest.png");
image2 = Image.createImage("opaqueTest.png");
}
catch(java.io.IOException e)
{
System.out.println(e);
fail("" + e);
}
Sprite sprite1 = new Sprite(image1);
Sprite sprite2 = new Sprite(image2);
// Test non-overlapping sprites:
sprite1.setPosition(100, 100);
sprite2.setPosition(100, 0);
assertTrue("sprite-sprite fail 1.", !sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 2.", !sprite1.collidesWith(sprite2, true));
sprite2.setPosition(100, 200);
assertTrue("sprite-sprite fail 3.", !sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 4.", !sprite1.collidesWith(sprite2, true));
sprite2.setPosition(0, 100);
assertTrue("sprite-sprite fail 5.", !sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 6.", !sprite1.collidesWith(sprite2, true));
sprite2.setPosition(200, 100);
assertTrue("sprite-sprite fail 7.", !sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 8.", !sprite1.collidesWith(sprite2, true));
// Test overlapping sprites:
sprite1.setPosition(0, 0);
sprite2.setPosition(0, 0);
assertTrue("sprite-sprite fail 9.", sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 10.", sprite1.collidesWith(sprite2, true));
// Test overlapping transparent sprites:
sprite2.setPosition(50, 0);
assertTrue("sprite-sprite fail 11.", sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 12.", !sprite1.collidesWith(sprite2, true));
// Test collisionarea-settings:
sprite2.setPosition(0, 0);
sprite1.defineCollisionRectangle(0, 0, 50, 100);
assertTrue("sprite-sprite fail 13.", sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 14.", sprite1.collidesWith(sprite2, true));
sprite1.defineCollisionRectangle(50, 0, 50, 100);
assertTrue("sprite-sprite fail 15.", sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 16.", !sprite1.collidesWith(sprite2, true));
sprite1.defineCollisionRectangle(0, 0, 50, 100);
sprite2.setPosition(50, 0);
assertTrue("sprite-sprite fail 17.", !sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 18.", !sprite1.collidesWith(sprite2, true));
sprite1.defineCollisionRectangle(0, 0, 100, 100);
// Test invisible sprite:
sprite1.setPosition(0, 0);
sprite2.setPosition(0, 0);
sprite1.setVisible(false);
assertTrue("sprite-sprite fail 19.", !sprite1.collidesWith(sprite2, false));
sprite1.setVisible(true);
// Test framed sprites:
// 2x2 = 4 frames.
Sprite sprite3 = new Sprite(image1, 50, 50);
sprite3.setPosition(0, 0);
assertTrue("sprite-sprite fail 20.", sprite3.collidesWith(sprite1, false));
assertTrue("sprite-sprite fail 21.", sprite3.collidesWith(sprite1, true));
sprite3.nextFrame();
assertTrue("sprite-sprite fail 22.", sprite3.collidesWith(sprite1, false));
sprite3.setPosition(10, 20);
sprite1.setPosition(10, 20);
assertTrue("sprite-sprite fail 23.", !sprite3.collidesWith(sprite1, true));
// Test rotated sprite:
sprite1.setTransform(Sprite.TRANS_ROT90);
sprite1.setPosition(0, 0);
assertTrue("sprite-sprite fail 24.", sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 25.", sprite1.collidesWith(sprite2, true));
sprite1.setTransform(Sprite.TRANS_ROT180);
sprite1.setPosition(0, 0);
assertTrue("sprite-sprite fail 26.", sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 27.", !sprite1.collidesWith(sprite2, true));
// Test collision rectangle in transformed sprite:
sprite1.setTransform(Sprite.TRANS_NONE);
sprite1.defineCollisionRectangle(0, 0, 50, 50);
sprite1.setTransform(Sprite.TRANS_ROT90);
sprite1.setPosition(0, 0);
assertTrue("sprite-sprite fail 28.", sprite1.collidesWith(sprite2, false));
assertTrue("sprite-sprite fail 29.", !sprite1.collidesWith(sprite2, true));
}
/** Tests collision between sprite and TiledLayer.
*/
public void testSpriteTiledLayerCollision()
{
Image image1 = null;
Image image2 = null;
TiledLayer tiledLayer = null;
try
{
//100x100, 0,0, -> 50,50 full opaque, 0,50 -> 50,70 partially
//transparent, other area full transparent.
image1 = Image.createImage("opaqueTest.png");
image2 = Image.createImage("opaqueTest.png");
}
catch(java.io.IOException e)
{
fail(e.toString());
}
Sprite sprite1 = new Sprite(image1);
tiledLayer = new TiledLayer(2, 2, image2, 50, 50);
tiledLayer.setCell(0, 0, 1);
tiledLayer.setCell(0, 1, 1);
tiledLayer.setCell(1, 0, 0);
tiledLayer.setCell(1, 1, 0);
// Test non-overlapping sprite:
sprite1.setPosition(100, 100);
tiledLayer.setPosition(100, 0);
assertTrue("sprite-tiledlayer fail 1.", !sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 2.", !sprite1.collidesWith(tiledLayer, true));
tiledLayer.setPosition(100, 200);
assertTrue("sprite-tiledlayer fail 3.", !sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 4.", !sprite1.collidesWith(tiledLayer, true));
tiledLayer.setPosition(0, 100);
assertTrue("sprite-tiledlayer fail 5.", !sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 6.", !sprite1.collidesWith(tiledLayer, true));
tiledLayer.setPosition(200, 100);
assertTrue("sprite-tiledlayer fail 7.", !sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 8.", !sprite1.collidesWith(tiledLayer, true));
// Test overlapping sprite:
sprite1.setPosition(0, 0);
tiledLayer.setPosition(0, 0);
assertTrue("sprite-tiledlayer fail 9.", sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 10.", sprite1.collidesWith(tiledLayer, true));
// Test overlapping transparent sprite:
tiledLayer.setPosition(50, 0);
assertTrue("sprite-tiledlayer fail 11.", sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 12.", !sprite1.collidesWith(tiledLayer, true));
// Test collisionarea-settings:
tiledLayer.setPosition(0, 0);
sprite1.defineCollisionRectangle(0, 0, 50, 100);
assertTrue("sprite-tiledlayer fail 13.", sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 14.", sprite1.collidesWith(tiledLayer, true));
sprite1.defineCollisionRectangle(50, 0, 50, 100);
assertTrue("sprite-tiledlayer fail 15.", !sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 16.", !sprite1.collidesWith(tiledLayer, true));
sprite1.defineCollisionRectangle(0, 0, 50, 100);
tiledLayer.setPosition(50, 0);
assertTrue("sprite-tiledlayer fail 17.", !sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 18.", !sprite1.collidesWith(tiledLayer, true));
sprite1.defineCollisionRectangle(0, 0, 100, 100);
// Test invisible sprite:
sprite1.setPosition(0, 0);
tiledLayer.setPosition(0, 0);
sprite1.setVisible(false);
assertTrue("sprite-tiledlayer fail 19.", !sprite1.collidesWith(tiledLayer, false));
sprite1.setVisible(true);
// Test rotated sprite:
sprite1.setTransform(Sprite.TRANS_ROT90);
sprite1.setPosition(0, 0);
assertTrue("sprite-tiledlayer fail 24.", sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 25.", sprite1.collidesWith(tiledLayer, true));
sprite1.setTransform(Sprite.TRANS_ROT180);
sprite1.setPosition(0, 0);
assertTrue("sprite-tiledlayer fail 26.", sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 27.", sprite1.collidesWith(tiledLayer, true));
// Test collision rectangle in transformed sprite:
sprite1.setTransform(Sprite.TRANS_NONE);
sprite1.defineCollisionRectangle(0, 0, 50, 50);
sprite1.setTransform(Sprite.TRANS_ROT90);
sprite1.setPosition(0, 0);
assertTrue("sprite-tiledlayer fail 28.", !sprite1.collidesWith(tiledLayer, false));
assertTrue("sprite-tiledlayer fail 29.", !sprite1.collidesWith(tiledLayer, true));
}
public void testCollisionTransform()
{
int[] rgb1 = { 0xFF00FF00, 0xFF00FF00, 0x0000FF00,
0x0000FF00, 0x0000FF00, 0xFF00FF00
};
// O O T
// T T O
Image spriteImage1 = Image.createRGBImage(rgb1, 3, 2, true);
Sprite sprite1 = new Sprite(spriteImage1, 1, 2);
sprite1.defineCollisionRectangle(0, 0, 1, 1);
int[] rgb2 = { 0xFF0000FF, 0x000000FF,
0x000000FF, 0xFF0000FF,
0xFF0000FF, 0x000000FF,
};
// O T
// T O
// O T
Image spriteImage2 = Image.createRGBImage(rgb2, 2, 3, true);
Sprite sprite2 = new Sprite(spriteImage2, 2, 1);
sprite2.defineReferencePixel(1, 0);
sprite2.defineCollisionRectangle(1, 0, 1, 1);
// should not get collision - one transparent, one opaque
for(int transform1 = 0; transform1 < 8; transform1++)
{
sprite1.setTransform(transform1);
for(int transform2 = 0; transform2 < 8; transform2++)
{
sprite2.setTransform(transform2);
sprite2.setRefPixelPosition(0, 0);
boolean result = !sprite1.collidesWith(sprite2, true);
if(!result)
{
print("1. Sprite should't collide with Sprite - frame 1");
fail("transform1=" + transform1 + " transform2=" + transform2);
}
}
}
sprite1.nextFrame(); // frame 2
sprite2.nextFrame(); // frame 2
// should always get collision - both opaque
for(int transform1 = 0; transform1 < 8; transform1++)
{
sprite1.setTransform(transform1);
for(int transform2 = 0; transform2 < 8; transform2++)
{
sprite2.setTransform(transform2);
boolean result = sprite1.collidesWith(sprite2, true);
if(!result)
{
print("2. Sprite should collide with Sprite - frame 2");
fail("transform1=" + transform1 + " transform2=" + transform2);
}
}
}
sprite1.nextFrame(); // frame 3
sprite2.nextFrame(); // frame 3
// should not get collision - both transparent
for(int transform1 = 0; transform1 < 8; transform1++)
{
sprite1.setTransform(transform1);
for(int transform2 = 0; transform2 < 8; transform2++)
{
sprite2.setTransform(transform2);
boolean result = !sprite1.collidesWith(sprite2, true);
if(!result)
{
print("3. Sprite should't collide with Sprite - frame 3");
fail("transform1=" + transform1 + " transform2=" + transform2);
}
}
}
// same test but with image
Image image = Image.createRGBImage(rgb1, 1, 2, true);
sprite2.setFrame(0);
// should not get collision - sprite transparent
for(int transform = 0; transform < 8; transform++)
{
sprite2.setTransform(transform);
sprite2.setRefPixelPosition(0, 0);
boolean result = !sprite2.collidesWith(image, 0, 0, true);
if(!result)
{
print("4. Sprite should't collide with Image - frame 1");
fail("transform=" + transform);
}
}
sprite2.setFrame(1);
// should get collision - sprite opaque
for(int transform = 0; transform < 8; transform++)
{
sprite2.setTransform(transform);
sprite2.setRefPixelPosition(0, 0);
boolean result = sprite2.collidesWith(image, 0, 0, true);
if(!result)
{
print("5. Sprite should collide with Image - frame 2");
fail("transform=" + transform);
}
}
// same test but with tiledlayer
int[] rgb4 = { 0xFF00FF00 };
// O
Image tiledLayerImage = Image.createRGBImage(rgb4, 1, 1, true);
TiledLayer tiledLayer = new TiledLayer(1, 2, tiledLayerImage, 1, 1);
tiledLayer.setCell(0, 0, 1); // opaque
sprite2.setFrame(0);
// should not get collision - sprite transparent
for(int transform = 0; transform < 8; transform++)
{
sprite2.setTransform(transform);
sprite2.setRefPixelPosition(0, 0);
boolean result = !sprite2.collidesWith(tiledLayer, true);
if(!result)
{
print("6. Sprite should't collide with TiledLayer - frame 1");
fail("transform=" + transform);
}
}
sprite2.setFrame(1);
// should get collision - sprite opaque
for(int transform = 0; transform < 8; transform++)
{
sprite2.setTransform(transform);
sprite2.setRefPixelPosition(0, 0);
boolean result = sprite2.collidesWith(tiledLayer, true);
if(!result)
{
print("7. Sprite should collide with TiledLayer - frame 2");
fail("transform=" + transform);
}
}
}
}