Пример #1
0
void MapBackground::RenderElement(CIwUIGraphics& parentGraphics)
{
	// Render tiles for the background
	std::list<MapTile*>::iterator iter = gVectorImageUrls.begin();

	int i = 0;
	while (iter != gVectorImageUrls.end())
	{
		MapTile* pTile = *iter;

		if (pTile->pTexture)
		{
			//Calculate the top left of the map image
			CIwSVec2 topLeft, bottomRight;
			topLeft.x = pTile->location.x;
			topLeft.y = pTile->location.y;
			CIwUIRect rect(CIwVec2(topLeft.x, topLeft.y), CIwVec2(pTile->pTexture->GetWidth(), pTile->pTexture->GetHeight()));

			CIwUIColour c(0xff,0xff,0xff,0xff);
			CIwColour* wtf = IW_GX_ALLOC(CIwColour, 4);

			CIwMaterial* pMat = IW_GX_ALLOC_MATERIAL();
			pMat->SetModulateMode(CIwMaterial::MODULATE_NONE);
			pMat->SetTexture(pTile->pTexture);

			parentGraphics.DrawImage(pTile->pTexture, pMat, rect, CIwSVec2(0,0), CIwSVec2(4096, 4096), c, false);
		}
		iter++;
	}
}
Пример #2
0
TextSprite::TextSprite(GameManager *gameManager, const char *_text) : Sprite(gameManager)
{

    text = _text;
    textFont = null;
    horizontalAlignment = IW_2D_FONT_ALIGN_LEFT;

    textColorSource = null;
    backgroundColorSource = null;
    borderColorSource = null;
    borderXSource = null;
    borderYSource = null;
    marginXSource = null;
    marginYSource = null;
    paddingXSource = null;
    paddingYSource = null;

    margin = CIwVec2(0, 0);
    padding = CIwVec2(0, 0);
    borderThickness = CIwVec2(0, 0);

    textColor.Set(0, 0, 0);
    borderColor.Set(0, 0, 0, 0);
    backgroundColor.Set(0, 0, 0, 0);
    
    RecalculateTextData();
}
Пример #3
0
void TextSprite::RenderImage(uint32 gameTime)
{
    if(textColorSource != null) textColor = textColorSource->GetColor(gameTime);
    if(borderColorSource != null) borderColor = borderColorSource->GetColor(gameTime);
    if(backgroundColorSource != null) backgroundColor = backgroundColorSource->GetColor(gameTime);
    if(marginXSource != null) margin = SCREEN_TO_SUBPIXEL(CIwVec2(marginXSource->GetInt(gameTime), marginYSource->GetInt(gameTime)));
    if(paddingXSource != null) padding = SCREEN_TO_SUBPIXEL(CIwVec2(paddingXSource->GetInt(gameTime), paddingYSource->GetInt(gameTime)));
    if(borderXSource != null) borderThickness = SCREEN_TO_SUBPIXEL(CIwVec2(borderXSource->GetInt(gameTime), borderYSource->GetInt(gameTime)));

    if(marginXSource != null || paddingXSource != null || borderXSource != null)
    {
        UpdatePositionData();
    }

    CIw2DFont *prevFont = null;
    CIwColour prevColor = Iw2DGetColour();

    if(textFont != null)
    {
        prevFont = Iw2DGetFont();
        Iw2DSetFont(textFont);
    }

    if(backgroundColor.a > 0)
    {
        Iw2DSetColour(backgroundColor);
        Iw2DFillRect(CIwSVec2(backgroundPosition), CIwSVec2(backgroundSize));
    }

    if(borderColor.a > 0)
    {
        Iw2DSetColour(borderColor);
        Iw2DFillRect(CIwSVec2(borderPosition), CIwSVec2(borderSize));

        Iw2DSetColour(backgroundColor);
        Iw2DFillRect(CIwSVec2(innerBorderPosition), CIwSVec2(innerBorderSize));
    }

    Iw2DSetColour(textColor);
    
    const char *textPtr = text.c_str();

    Iw2DDrawString(textPtr, CIwSVec2(textPosition), CIwSVec2(textSize), horizontalAlignment, IW_2D_FONT_ALIGN_TOP);

    Iw2DSetColour(prevColor);

    if(prevFont != null)
    {
        Iw2DSetFont(prevFont);
    }
}
Пример #4
0
void WallLevel::EnterWallLevel(EventCallback *eventData)
{
    mgr->RemoveAllGameObjects();

    selectedBrick = null;
    selectedTarget = null;

    StateVariable zeroVar;
    zeroVar.intValue = 0;
    mgr->GetStateManager()->SetVar(VAR_POINTS, zeroVar);
    mgr->GetStateManager()->SetVar(VAR_CURRENT_THINGY_COUNT, zeroVar);
    mgr->GetStateManager()->SetVar(VAR_CURRENT_CORRECT_THINGY_COUNT, zeroVar);

    Sprite *sprite = new Sprite(mgr);
    sprite->SetImage(mgr->GetResourceManager()->GetImage(IMAGE_WALL_BACKGROUND));
    sprite->SetBaseLocation(CIwVec2(0, 0));
    sprite->SetZIndex(-999);
    mgr->RegisterGameObject(sprite);
    strcpy(sprite->debugId, "WallLevelBackground");

    PointsManager *pointsManager = new PointsManager(mgr, STATE_WALL_SUMMARY);

    pointsManager->ClearTransformations();
    pointsManager->AddTransformation(new AnchorTransformation(AnchorPosTopLeft));
    pointsManager->SetBaseLocation(CIwVec2(20, 20));

    for(int y = 0; y < NUM_COURSES; y++)
    {
        new Brick(mgr, this, -1, y);
        new Brick(mgr, this, NUM_POSITIONS, y);
    }

    //    for(int y=0; y < NUM_COURSES; y++)
    //    {
    //    for(int x = 0; x < NUM_POSITIONS; x++)
    //    {
    //        brickTargets[x] = new BrickTarget(mgr, this, x, y);
    //    }
    //    }
    //return;

    for(int x = 0; x < NUM_POSITIONS; x++)
    {
        brickCourses[x] = -1;
        brickTargets[x] = new BrickTarget(mgr, this, x, 0);
        bricks[x] = new Brick(mgr, this, x);
    }

}
Пример #5
0
void MakeBezierSprite(GameManager *mgr, uint32 marker_handle, int x, int y, int dx, int dy, float scale)
{
    PathFollowingSprite *path = new PathFollowingSprite(mgr);
    path->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    path->SetBaseLocation(CIwVec2(x, y));
    path->AddTransformation(new AnchorTransformation());
    path->AddTransformation(new ScaleTransformation(scale));
    mgr->RegisterGameObject(path);

    path->SetTotalPathTimeMillis(10000);
    path->AddSegment(new PathSegmentBezier(CIwVec2(x, y), CIwVec2(x, y + dy), CIwVec2(x + dx, y + dy), CIwVec2(x + dx, y)));
    path->AddSegment(new PathSegmentLine(CIwVec2(x + dx, y), CIwVec2(x + dx, y + dy)));
    path->AddSegment(new PathSegmentBezier(CIwVec2(x + dx, y + dy), CIwVec2(x - dx, y), CIwVec2(x + dx * 2, y), CIwVec2(x, y + dy)));
    path->AddSegment(new PathSegmentLine(CIwVec2(x, y + dy), CIwVec2(x, y)));
}
Пример #6
0
void MakeSquareSprite(GameManager *mgr, uint32 marker_handle, int x, int y, int dx, int dy)
{
    PathFollowingSprite *path = new PathFollowingSprite(mgr);
    path->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    path->SetBaseLocation(CIwVec2(x, y));
    path->AddTransformation(new AnchorTransformation());
    path->AddTransformation(new ScaleTransformation(0.25));
    mgr->RegisterGameObject(path);

    path->SetPathSpeedPixelsPerSecond(500);
    path->AddSegment(new PathSegmentLine(CIwVec2(dx, 0)));
    path->AddSegment(new PathSegmentLine(CIwVec2(0, dy)));
    path->AddSegment(new PathSegmentLine(CIwVec2(-dx, 0)));
    path->AddSegment(new PathSegmentLine(CIwVec2(0, -dy)));
}
Пример #7
0
int32 ResetSprite(void *systemData, void *userData)
{
    GameManager *mgr;

    if(systemData != NULL)
    {
        Sprite *spritePtr = (Sprite *)systemData;

        mgr = spritePtr->GetManager();
        mgr->RemoveGameObject(spritePtr);
        delete spritePtr;
    }
    else
    {
        mgr = (GameManager*)userData;
    }

    Sprite *tmp = new Sprite(mgr);
    tmp->SetImage(mgr->GetResourceManager()->GetImage(ARROW_HANDLE));
    tmp->SetBaseLocation(CIwVec2(mgr->GetSurfaceWidth() / 2, mgr->GetSurfaceHeight() / 2));
    tmp->AddTransformation(new AnchorTransformation());
    OrbitTransformation *orbiter = new OrbitTransformation(150, 5000, 0, Clockwise);
    tmp->AddTransformation(orbiter);
    mgr->RegisterGameObject(tmp);

    tmp->SetLifespan(++resetCount * 500);
    tmp->SetCompletionCallback(ResetSprite, NULL);

    return 0;
}
Пример #8
0
void Iw2DSprite::Render(CIwSVec2 pPosition)
{
	if(m_Angle > 0 || m_Angle < 0)
	{
		CIwMat2D RotationMatrix;
		RotationMatrix.SetRot(m_Angle, CIwVec2(pPosition.x + m_Center.x , pPosition.y + m_Center.y) );
		Iw2DSetTransformMatrix(RotationMatrix);
	}

	if( m_Flip.x > 0 && m_Flip.y > 0)
		Iw2DSetImageTransform(IW_2D_IMAGE_TRANSFORM_ROT180);
	else if( m_Flip.x > 0 && m_Flip.y <= 0)
		Iw2DSetImageTransform(IW_2D_IMAGE_TRANSFORM_FLIP_X);	
	else if( m_Flip.y > 0 && m_Flip.x <= 0)
		Iw2DSetImageTransform(IW_2D_IMAGE_TRANSFORM_FLIP_Y);

	Iw2DDrawImageRegion(m_SpriteSheet,
						pPosition,
						m_FrameSize,
						m_DrawRect,
						m_FrameSize);

	if(m_Angle > 0 || m_Angle < 0)
		Iw2DSetTransformMatrix(CIwMat2D::g_Identity);
	if( m_Flip.x > 0 || m_Flip.y > 0)
		Iw2DSetImageTransform(IW_2D_IMAGE_TRANSFORM_NONE);
}
Пример #9
0
BrickTarget::BrickTarget(GameManager *mgr, WallLevel *_parent, int _xPos, int _yPos) : Sprite(mgr)
{
    DEBUG_TRACER(BrickTarget::BrickTarget);

    prefix = wordBuilder->GetNextPrefix();
    isSelected = false;
    parent = _parent;
    staticTarget = false;

    sprintf(debugId, "BrTg - %d(%s) [%d, %d]", brickTargetCount, prefix.c_str(), _xPos, _yPos);

    SetImage(mgr->GetResourceManager()->GetImage(IMAGE_BRICK_TARGET));

    xPos = _xPos;
    yPos = _yPos;

    int brickLocX = 85 + (yPos % 2) * 70 + xPos * 140;
    int brickLocY =  330 - 73 * yPos;

    SetBaseLocation(CIwVec2(brickLocX, brickLocY));

    AddTransformation(new AnchorTransformation());

    mgr->RegisterGameObject(this);

    //char buffer[50];
    //sprintf(buffer, "%d, %d", xPos, yPos);
    //prefixSprite = new TextSprite(mgr, buffer);

    prefixSprite = new TextSprite(mgr, prefix.c_str());
    prefixSprite->SetParent(this);
    prefixSprite->AddTransformation(new AnchorTransformation());
    prefixSprite->AddTransformation(new RotationTransformation(0, Clockwise));
    prefixSprite->SetFont(mgr->GetResourceManager()->GetFont(FONT_COOPER_18));
    prefixSprite->SetBackgroundColor(g_IwGxColours[IW_GX_COLOUR_WHITE]);
    prefixSprite->SetBorderColor(g_IwGxColours[IW_GX_COLOUR_BLACK]);
    prefixSprite->SetBorderThickness(CIwVec2(2, 2));
    prefixSprite->SetPadding(CIwVec2(3, 3));
    prefixSprite->SetZIndex(10);
    mgr->RegisterGameObject(prefixSprite);

    sprintf(prefixSprite->debugId, "Brick Target Prefix - %d(%s)", brickTargetCount, prefix.c_str());

    brickTargetCount++;
}
Пример #10
0
void AnimationTest(GameManager *mgr, uint32 marker_handle, uint32 width, uint32 height)
{
    FlipbookSprite *tmp = new FlipbookSprite(mgr);
    tmp->SetAnimationParams(mgr->GetResourceManager()->GetImage(FIRE_HANDLE), 64, 48, 20, 20);
    tmp->SetBaseLocation(CIwVec2(mgr->GetSurfaceWidth() / 2, mgr->GetSurfaceHeight() / 2));
    tmp->AddTransformation(new AnchorTransformation());
    OrbitTransformation *orbiter = new OrbitTransformation(150, 5000, 0, Clockwise);
    tmp->AddTransformation(orbiter);
    mgr->RegisterGameObject(tmp);
}
Пример #11
0
    CIwVec2 GetLocation(uint32 gameTime)
    {
        if(gameTime > nextChangeTime)
        {
            nextChangeTime = gameTime + SHAKER_FRAME_TIME_MILLIS;
            deltaX = rand() % 11 - 5;
            deltaY = rand() % 11 - 5;
        }

        return CIwVec2(deltaX, deltaY);
    }
Пример #12
0
void TextSprite::UpdatePositionData()
{
    textPosition = margin + borderThickness + padding;

    innerBorderPosition = margin + borderThickness;
    innerBorderSize = textSize + padding + padding;

    borderPosition = margin;
    borderSize = textSize + padding + padding + borderThickness + borderThickness;

    backgroundPosition = CIwVec2(0, 0);
    backgroundSize = textSize + padding + padding + margin + margin + borderThickness + borderThickness;
}
Пример #13
0
void WallLevel::SummarizeWallLevel(EventCallback *eventData)
{
    StateVariable finalPoints = mgr->GetStateManager()->GetVar(VAR_POINTS);

    char stateSummary[1024];

    sprintf(stateSummary, "You got %d points.\nHave some stars!\nTouch to continue.", finalPoints.intValue);

    mgr->RemoveAllGameObjects();

    Sprite *sprite = new Sprite(mgr);
    sprite->SetImage(mgr->GetResourceManager()->GetImage(IMAGE_WALL_BACKGROUND));
    sprite->SetBaseLocation(CIwVec2(0, 0));
    sprite->SetZIndex(-999);
    mgr->RegisterGameObject(sprite);
    strcpy(sprite->debugId, "WallLevelBackground");
    sprite->SetTouchEndCallback(this, (EventCallbackPtr)&WallLevel::GoToLevelSelect, (void*)(mgr->GetCurrentClockTime() + 2000));

    for(int y = 0; y < NUM_COURSES; y++)
    {
        for(int x = -1; x<= NUM_POSITIONS; x++)
        {
            new Brick(mgr, this, x, y);
        }
    }

    TextSprite *summary = new TextSprite(mgr, stateSummary);
    summary->SetAlign(IW_2D_FONT_ALIGN_CENTRE);
    summary->SetBackgroundColor(g_IwGxColours[IW_GX_COLOUR_WHITE]);
    summary->SetFont(mgr->GetResourceManager()->GetFont(FONT_COOPER_24));
    summary->SetBorderColor(g_IwGxColours[IW_GX_COLOUR_BLACK]);
    summary->SetBorderThickness(CIwVec2(4, 4));
    summary->SetPadding(CIwVec2(7, 7));
    summary->AddTransformation(new AnchorTransformation());
    summary->SetBaseLocation(CIwVec2(mgr->GetSurfaceWidth() / 2, mgr->GetSurfaceHeight() / 2));
    summary->SetZIndex(999);
    mgr->RegisterGameObject(summary);
}
Пример #14
0
void LabeledSprite(GameManager *mgr, uint32 marker_handle, uint32 width, uint32 height)
{
    Sprite *image = new Sprite(mgr);
    image->SetImage(mgr->GetResourceManager()->GetImage(ARROW_HANDLE));
    image->AddTransformation(new AnchorTransformation());
    image->SetBaseLocation(CIwVec2(mgr->GetSurfaceWidth() / 2, mgr->GetSurfaceHeight() / 2));
    OrbitTransformation *orbiter = new OrbitTransformation(150, 5000, 0, CounterClockwise);
    image->AddTransformation(orbiter);
    mgr->RegisterGameObject(image);

    TextSprite *text = new TextSprite(mgr, (char *)"Normal");
    text->AddTransformation(new AnchorTransformation());
    text->AddTransformation(new AnchorToTransformation(image, image, (float)(text->GetHeight() / 2 + image->GetHeight() / 2 + 10), 0, RelativeToNormal));
    text->AddTransformation(new OrientToTransformation((IDirectional*)image, OrientAlongOrientation));
    mgr->RegisterGameObject(text);
}
Пример #15
0
void myIwGxDrawStar(int x, int y, CIwSVec2 texpos, int iscale, iwangle rotval, int alphaf)
{
    CIwMat2D transformMatrix;
    int i;
    //
    if (ssend_vertices + 4 > (MX_VERTICES))
    {
        myIwGxDoneBonus();
        ssend_vertices = 0;
    }
    transformMatrix = CIwMat2D::g_Identity;
    transformMatrix.SetRot(rotval, CIwVec2(x, y));
    //
    // 0 = top-left
    // 1 = bottom-left
    // 2 = bottom-right
    // 3 = top-right
    //
    svertices[ssend_vertices + 0].x = x - iscale;
    svertices[ssend_vertices + 0].y = y - iscale;
    svertices[ssend_vertices + 1].x = x - iscale;
    svertices[ssend_vertices + 1].y = y + iscale;
    svertices[ssend_vertices + 2].x = x + iscale;
    svertices[ssend_vertices + 2].y = y + iscale;
    svertices[ssend_vertices + 3].x = x + iscale;
    svertices[ssend_vertices + 3].y = y - iscale;
    //
    suvdata[ssend_vertices + 0].x = (texpos.x) << 3;
    suvdata[ssend_vertices + 0].y = (texpos.y) << 3;
    suvdata[ssend_vertices + 1].x = (texpos.x) << 3;
    suvdata[ssend_vertices + 1].y = (texpos.y + 32) << 3;
    suvdata[ssend_vertices + 2].x = (texpos.x + 32) << 3;
    suvdata[ssend_vertices + 2].y = (texpos.y + 32) << 3;
    suvdata[ssend_vertices + 3].x = (texpos.x + 32) << 3;
    suvdata[ssend_vertices + 3].y = (texpos.y) << 3;
    //
    scolors[ssend_vertices + 0].Set(0xFF, 0xFF, 0xFF, (uint8)(alphaf));
    scolors[ssend_vertices + 1].Set(0xFF, 0xFF, 0xFF, (uint8)(alphaf));
    scolors[ssend_vertices + 2].Set(0xFF, 0xFF, 0xFF, (uint8)(alphaf));
    scolors[ssend_vertices + 3].Set(0xFF, 0xFF, 0xFF, (uint8)(alphaf));
    //
    for (i = 0; i < 4; i++)
        svertices[ssend_vertices + i] = transformMatrix.TransformVec(svertices[ssend_vertices + i]);
    ssend_vertices += 4;
    //
}
Пример #16
0
//-----------------------------------------------------------------------------
void ExampleRender()
{
	static const CIwSVec2 imageSize(g_Image->GetWidth() >> 3, g_Image->GetHeight() >> 3);
	static const CIwSVec2 halfImageSize = imageSize >> 1;

	const CIwSVec2 screenCentre = CIwSVec2((int16)Iw2DGetSurfaceWidth() >> 1, (int16)Iw2DGetSurfaceHeight() >> 1);

	const b2Transform t = g_body->GetTransform();
	const CIwSVec2 pos = screenCentre + (CIwSVec2(int16(t.p.x*8), -int16(t.p.y*8)));
	const float angle = -t.q.GetAngle() * (180.0f/3.14159f);	// reverse angle as our screen-Y coord is reversed

	CIwMat2D rot;
	rot.SetRot(iwangle(angle * 1024 / 90), CIwVec2(pos) << 3);
	Iw2DSetTransformMatrixSubPixel(rot);

	Iw2DDrawImage(g_Image, pos - halfImageSize, imageSize);

    //
    Iw2DSetTransformMatrix(CIwMat2D::g_Identity);
    Iw2DSurfaceShow();
}
Пример #17
0
void TileSet::Render(int index,CIwSVec2 topLeft,int rotation)
{
	int ind=index-m_firstGid;
	if(ind<0)
		return;
	int index_X=ind%_tilesPerRow;
	int index_Y=ind/_tilesPerRow;
	CIwSVec2 pos = CIwSVec2(index_X * _tilewidth,index_Y * _tileheight);
	if(rotation!=0)
	{
		iwangle  angle =90*rotation;//90 degrees
		CIwSVec2 centre=CIwSVec2(iwsfixed(topLeft.x+(float)_tilewidth/2.0f),iwsfixed(topLeft.y+(float)_tileheight/2.0f));
		CIwMat2D rot;
    
		rot.SetRot(IW_ANGLE_FROM_DEGREES(angle), CIwVec2(centre));

		Iw2DSetTransformMatrix(rot);
	}
	Iw2DDrawImageRegion(_image, topLeft, pos, _tileSize);
	Iw2DSetTransformMatrix(CIwMat2D::g_Identity);
}
Пример #18
0
void MakeOrbiters(GameManager *mgr, int x, int y, uint32 marker_handle)
{
        Sprite *bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->SetBaseLocation(CIwVec2(x, y));
    bug1->AddTransformation(new AnchorTransformation());
    OrbitTransformation *orbiter = new OrbitTransformation(200, 15000);
    bug1->AddTransformation(orbiter);
    orbiter = new OrbitTransformation(70, 7000);
    bug1->AddTransformation(orbiter);
    mgr->RegisterGameObject(bug1);
    Sprite *anchorBug = bug1;
    ILocationSource *locBug = bug1;

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new AnchorToTransformation(anchorBug, CIwVec2(-56, 56)));
    bug1->AddTransformation(new ScaleTransformation(0.3f));
    orbiter = new OrbitTransformation(40, 2000);
    bug1->AddTransformation(orbiter);
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new AnchorToTransformation(anchorBug, CIwVec2(-56, -56)));
    bug1->AddTransformation(new ScaleTransformation(0.3f));
    orbiter = new OrbitTransformation(40, 2000);
    bug1->AddTransformation(orbiter);
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new AnchorToTransformation(anchorBug, CIwVec2(80, 0)));
    bug1->AddTransformation(new ScaleTransformation(0.3f));
    orbiter = new OrbitTransformation(40, 2000, 180);
    bug1->AddTransformation(orbiter);
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->SetBaseLocation(CIwVec2(x, y));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new OrientToTransformation(locBug, OrientToward));
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->SetBaseLocation(CIwVec2(x / 2, y));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new OrientToTransformation(locBug, OrientToward));
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->SetBaseLocation(CIwVec2(x, y/2));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new OrientToTransformation(locBug, OrientToward));
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->SetBaseLocation(CIwVec2(x, y * 3 / 2));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new OrientToTransformation(locBug, OrientToward));
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->SetBaseLocation(CIwVec2(x * 3 / 2, y));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new OrientToTransformation(locBug, OrientToward));
    mgr->RegisterGameObject(bug1);
}
Пример #19
0
void MakeNormalShip(GameManager *mgr, int marker_handle, int x, int y)
{
    Sprite *bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->SetBaseLocation(CIwVec2(x, y));
    bug1->AddTransformation(new AnchorTransformation());
    OrbitTransformation *orbiter = new OrbitTransformation(0, 5000, 0, Clockwise);
    bug1->AddTransformation(orbiter);
    mgr->RegisterGameObject(bug1);
    Sprite *anchorBug = bug1;

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new AnchorToTransformation(anchorBug, anchorBug, 70, 60));
    bug1->AddTransformation(new ScaleTransformation(0.3f));
    orbiter = new OrbitTransformation(20, 2000, 0);
    bug1->AddTransformation(orbiter);
    bug1->AddTransformation(new OrientToTransformation(orbiter, OrientAlongNormal));
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new AnchorToTransformation(anchorBug, anchorBug, 70, 60));
    bug1->AddTransformation(new ScaleTransformation(0.3f));
    orbiter = new OrbitTransformation(20, 2000, 120);
    bug1->AddTransformation(orbiter);
    bug1->AddTransformation(new OrientToTransformation(orbiter, OrientAlongNormal));
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new AnchorToTransformation(anchorBug, anchorBug, 70, 60));
    bug1->AddTransformation(new ScaleTransformation(0.3f));
    orbiter = new OrbitTransformation(20, 2000, -120);
    bug1->AddTransformation(orbiter);
    bug1->AddTransformation(new OrientToTransformation(orbiter, OrientAlongNormal));
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new AnchorToTransformation(anchorBug, anchorBug, 70, -60));
    bug1->AddTransformation(new ScaleTransformation(0.3f));
    orbiter = new OrbitTransformation(20, 2000, 0);
    bug1->AddTransformation(orbiter);
    bug1->AddTransformation(new OrientToTransformation(orbiter, OrientAlongNormal));
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new AnchorToTransformation(anchorBug, anchorBug, 70, -60));
    bug1->AddTransformation(new ScaleTransformation(0.3f));
    orbiter = new OrbitTransformation(20, 2000, 120);
    bug1->AddTransformation(orbiter);
    bug1->AddTransformation(new OrientToTransformation(orbiter, OrientAlongNormal));
    mgr->RegisterGameObject(bug1);

    bug1 = new Sprite(mgr);
    bug1->SetImage(mgr->GetResourceManager()->GetImage(marker_handle));
    bug1->AddTransformation(new AnchorTransformation());
    bug1->AddTransformation(new AnchorToTransformation(anchorBug, anchorBug, 70, -60));
    bug1->AddTransformation(new ScaleTransformation(0.3f));
    orbiter = new OrbitTransformation(20, 2000, -120);
    bug1->AddTransformation(orbiter);
    bug1->AddTransformation(new OrientToTransformation(orbiter, OrientAlongNormal));
    mgr->RegisterGameObject(bug1);
}
Пример #20
0
S3E_MAIN_DECL void IwMain()
{
    srand(time(NULL));

    GameManager *mgr;
    mgr = new GameManager();

    mgr->SetRequestedFPS(100);

    mgr->GetResourceManager()->RegisterResourceGroup("images.group");

    BUG_HANDLE = mgr->GetResourceManager()->RegisterImage("bug");
    SPLAT_HANDLE = mgr->GetResourceManager()->RegisterImage("splat");
    LEAVES_HANDLE = mgr->GetResourceManager()->RegisterImage("leaves");
    ARROW_HANDLE = mgr->GetResourceManager()->RegisterImage("right_arrow");
    FIRE_HANDLE = mgr->GetResourceManager()->RegisterImage("FireBlast");

    TREB_FONT_HANDLE = mgr->GetResourceManager()->RegisterFont("trebuchet16pt");
    COOPER_FONT_HANDLE = mgr->GetResourceManager()->RegisterFont("cooper_24pt");

    GameManager::SetDebugFont(mgr->GetResourceManager()->GetFont(TREB_FONT_HANDLE));

    Iw2DSetFont(mgr->GetResourceManager()->GetFont(TREB_FONT_HANDLE));

    Sprite *background = new Sprite(mgr);
    background->SetImage(mgr->GetResourceManager()->GetImage(LEAVES_HANDLE));
    background->SetBaseLocation(CIwVec2(0, 0));
    background->SetZIndex(-999);
    mgr->RegisterGameObject(background);

    int width = mgr->GetSurfaceWidth();
    int height = mgr->GetSurfaceHeight();

#define SIMPLE_TEST 0
#define MANY_SHIP_TEST 1
#define ORBITER_TEST 2
#define ANIMATION_TEST 3
#define LABELED_SPRITE 4
#define PATH_TEST 5

    int test_selection = SIMPLE_TEST;

    switch(test_selection)
    {
    case SIMPLE_TEST:
        DoSimpleTest(mgr, ARROW_HANDLE, width, height);
        break;

    case MANY_SHIP_TEST:
        DoManyShipTest(mgr, 10, 10, width, height, ARROW_HANDLE);
        break;

    case ORBITER_TEST:
        MakeOrbiters(mgr, width / 2, height / 2, ARROW_HANDLE);
        break;

    case ANIMATION_TEST:
        AnimationTest(mgr, 0, width, height);
        break;

    case LABELED_SPRITE:
        LabeledSprite(mgr, 0, width, height);
        break;

    case PATH_TEST:
        PathTest(mgr, ARROW_HANDLE, width, height);
        break;
    }

    mgr->MainLoop();

    delete mgr;
}
Пример #21
0
CIwVec2 MapBackground::MeasureElement(const CIwVec2& availableSize) const
{
	return CIwVec2(availableSize.x, availableSize.y);
}
Пример #22
0
void DoSimpleTest(GameManager *mgr, uint32 marker_handle, uint32 width, uint32 height)
{
    StateManager *state = mgr->GetStateManager();

    StateVariable tmpVar;

    tmpVar.intValue = 21;
    INT_VAR_HANDLE = state->RegisterStateVariable("IntVar", tmpVar);

    tmpVar.floatValue = 3.1415f;
    FLOAT_VAR_HANDLE = state->RegisterStateVariable("FloatVar", tmpVar);

    tmpVar.stringValue = "Hello World!";
    STRING_VAR_HANDLE = state->RegisterStateVariable("StringVar", tmpVar);

    PathFollowingSprite *intPath = new PathFollowingSprite(mgr);
    intPath->AddSegment(new PathSegmentBezier(CIwVec2(100,100), CIwVec2(200, 900), CIwVec2(700, -50), CIwVec2(800,600)));
    intPath->SetTotalPathTimeMillis(5000);
    mgr->RegisterGameObject(intPath);

    CIwColour transparent;

    transparent.Set(0, 0, 0, 0);

    char buffer[1024];
    sprintf(buffer, "Int: %d", state->GetStateVar(INT_VAR_HANDLE).intValue);
    intSprite = new TextSprite(mgr, buffer);
    intSprite->SetBackgroundColor(g_IwGxColours[IW_GX_COLOUR_WHITE]);
    intSprite->SetBorderColor(g_IwGxColours[IW_GX_COLOUR_BLUE]);
    intSprite->SetBorderThickness(CIwVec2(3, 3));
    intSprite->SetPadding(CIwVec2(3, 3));
    intSprite->SetBaseLocation(CIwVec2(300, 100));
    //intSprite->AddTransformation(new AnchorToTransformation(intPath, CIwVec2(0,0)));
    //intSprite->AddTransformation(new OrbitTransformation(0, 5000));
    mgr->RegisterGameObject(intSprite);

    sprintf(buffer, "Float: %f", state->GetStateVar(FLOAT_VAR_HANDLE).floatValue);
    floatSprite = new TextSprite(mgr, buffer);
    floatSprite->SetBackgroundColor(g_IwGxColours[IW_GX_COLOUR_WHITE]);
    floatSprite->SetBorderColor(g_IwGxColours[IW_GX_COLOUR_GREEN]);
    floatSprite->SetBorderThickness(CIwVec2(3, 3));
    floatSprite->SetPadding(CIwVec2(3, 3));
    floatSprite->SetBaseLocation(CIwVec2(300, 200));
    mgr->RegisterGameObject(floatSprite);

    sprintf(buffer, "String: %s", state->GetStateVar(STRING_VAR_HANDLE).stringValue);
    stringSprite = new TextSprite(mgr, buffer);
    stringSprite->SetBackgroundColor(g_IwGxColours[IW_GX_COLOUR_WHITE]);
    stringSprite->SetBorderColor(g_IwGxColours[IW_GX_COLOUR_CYAN]);
    stringSprite->SetBorderThickness(CIwVec2(5, 5));
    stringSprite->SetPadding(CIwVec2(2, 2));
    stringSprite->SetBaseLocation(CIwVec2(300, 300));
    mgr->RegisterGameObject(stringSprite);

    sprintf(buffer, "Next string");
    stringSprite = new TextSprite(mgr, buffer);
    stringSprite->SetBackgroundColor(g_IwGxColours[IW_GX_COLOUR_WHITE]);
    stringSprite->SetBorderColor(g_IwGxColours[IW_GX_COLOUR_BLACK]);
    stringSprite->SetMargin(CIwVec2(4, 4));
    stringSprite->SetBorderThickness(CIwVec2(4, 4));
    stringSprite->SetPadding(CIwVec2(4, 4));
    stringSprite->SetBaseLocation(CIwVec2(400, 400));
    mgr->RegisterGameObject(stringSprite);

    state->SubscribeStateVarChange(INT_VAR_HANDLE, stateVarChanged, intSprite);
    state->SubscribeStateVarChange(FLOAT_VAR_HANDLE, stateVarChanged, floatSprite);

    state->SubscribeEvent("FloatChange", changeVarValue, NULL);

    state->PostFutureEvent("FloatChange", NULL, mgr->GetCurrentClockTime() + 3000);
}