Subversion Repositories AndroidProjects

#include "Board.h"
#include "GameApp.h"
#include "SexyAppFramework/Graphics.h"

// See the Draw method for more information on using the Color class.
#include "SexyAppFramework/Color.h"

// The Image.h file just declares basic functions. All images are either of
// the DDImage or MemoryImage type. For this demo, we will use DDImage
// types, as they are the type returned by the image loading code.
// A DDImage is actually derived from MemoryImage, so where an Image or
// MemoryImage is required, a DDImage will suffice as well. A DDImage
// contains optimized code for use with DirectX 7+.
#include "SexyAppFramework/DDImage.h"

// The Rectangle template, used to specify X, Y, Width, Height
#include "SexyAppFramework/Rect.h"

// We're going to be making a button in this demo so we need to
// include this file.
#include "SexyAppFramework/ButtonWidget.h"

// We're going to add our own button widget, which requires knowing about the
// WidgetManager.
#include "SexyAppFramework/WidgetManager.h"

#include "SexyAppFramework/ImageFont.h"

// The SexyAppFramework resides in the "Sexy" namespace. As a convenience,
// you'll see in all the .cpp files "using namespace Sexy" to avoid
// having to prefix everything with Sexy::
using namespace Sexy;

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
Board::Board(GameApp* theApp)
{
        mApp = theApp;

        // Start off drawing the first frame of mLightningImg
        mAnimFrame = 0;

        mButton = NULL;
       
        mMouseX = mMouseY = 0;
        mLeftDown = mRightDown = mMiddleDown = false;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
Board::~Board()
{
        delete mButton;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void Board::Update()
{
        // Let the parent class update as well. This will increment
        // the variable mUpdateCnt which is an integer that indicates
        // how many times the Update() method has been called. Since our
        // Board class is updated 100 times per second, this variable will
        // increment 100 times per second. As you will see in later demos,
        // we will use this variable for animation since its value represents
        // hundredths of a second, which is for almost all games a good
        // enough timer value and doesn't rely on the system clock function
        // call.
        Widget::Update();

        // Let's update our animation frame every 5 update ticks. This
        // is equivalent to 20 times per second.
        if (mUpdateCnt % 5 == 0)
        {
                // In GameApp we specified how many rows and columns this image
                // had. Thus, if our current frame of animation exceeds the number
                // of frames that we have, we should reset the animation frame back
                // to 0.
                if (++mAnimFrame >= mApp->mLightningImg->mNumRows)
                        mAnimFrame = 0;
        }


       
        // For this and most of the other demos, you will see the function
        // below called every Update() call. MarkDirty() tells the widget
        // manager that something has changed graphically in the widget and
        // that it needs to be repainted. All widgets follow this convention.
        //              In general, if you don't need
        // to update your drawing every time you call the Update method
        // (the most common case is when the game is paused) you should
        // NOT mark dirty. Why? If you aren't marking dirty every frame,
        // then you aren't drawing every frame and thus you use less CPU
        // time. Because people like to multitask, or they may be on a laptop
        // with limited battery life, using less CPU time lets people do
        // other things besides play your game. Of course, everyone
        // will want to play your game at all times, but it's good to be
        // nice to those rare people that might want to read email or
        // do other things at the same time.
        //              In this particular demo, we
        // won't be nice, as the purpose is to bring you up to speed as
        // quickly as possible, and so we'll dispense with optimizations
        // for now, so you can concentrate on other core issues first.
        //              In general, this is the last method called in the Update
        // function, but that is not necessary. In fact, the MarkDirty
        // function can be called anywhere, in any method (although
        // calling it in the Draw method doesn't make sense since it is
        // already drawing) and even multiple times. Calling it multiple
        // times does not do anything: only the first call makes a difference.
        MarkDirty();
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void Board::Draw(Graphics* g)
{
        // The Graphics object, "g", is
        // automatically created and passed to this method by the
        // WidgetManager and can be thought of as the main screen
        // bitmap/canvas upon which all drawing will be done. This object
        // is double buffered automatically so you don't need to worry
        // about those details. All you need to do is instruct the object
        // that you would like to draw something to it, and when the
        // WidgetManager gets done letting all widgets draw to the
        // Graphics object, it will then blit everything to the screen
        // at once.

        // First, let's start by clearing the screen to black.
        // As you'll recall from Demo1, we set the color with SetColor
        // and pass in a Color object that contains either 3 or 4 parameters,
        // that represent the r,g,b,a values (alpha is 255 if only 3 specified).
        g->SetColor(Color(0, 0, 0));
        g->FillRect(0, 0, mWidth, mHeight);

        // Now let's try drawing a stretched image. We'll draw the original image
        // stretched to twice its size. Drawing a stretched image is exactly like
        // drawing a normal image, except that you have two extra parameters:
        // the stretched width and height. You can use this to draw a shrunk version
        // of the image as well (which we'll do second)
        g->DrawImage(mApp->mTurbotImg, 0, 0, mApp->mTurbotImg->GetWidth() * 2, mApp->mTurbotImg->GetHeight() * 2);
        g->DrawImage(mApp->mTurbotImg, 0, 275, mApp->mTurbotImg->GetWidth() / 2, mApp->mTurbotImg->GetHeight() / 2);

        // The default stretching algorithm (the one used in the two examples above) uses
        // the slow stretching method. The slow stretching method anti-aliases the resulting
        // image to give a smoother, less pixelated look. While this tends to look a lot
        // nicer, it also requires more processing power. Thus, if you either don't need
        // or don't care about the anti-aliasing, you can instruct the graphics object
        // to use fast stretching. Just remember: unless you turn fast stretching off when
        // done, it will remain on. Let's give it a try by drawing the same image
        // stretched twice as large using fast stretching.
        g->SetFastStretch(true);
        g->DrawImage(mApp->mTurbotImg, 275, 0, mApp->mTurbotImg->GetWidth() * 2, mApp->mTurbotImg->GetHeight() * 2);
        g->SetFastStretch(false);

        // A good use of fast/non fast stretching is to enable the slower stretching method
        // for users with a supported 3D card and to disable it for users that have
        // to run in software mode. You'll learn more about determining if a user is in
        // 3D mode or not in a later demo, but keep this simple optimization in mind
        // when creating drawing code for your games.

        // Another cool thing we can do is to draw an image mirrored. This is exactly
        // like using the DrawImage command except that you use DrawImageMirror
        // instead. The optional fourth argument is just a convenience switch: if it's false,
        // it will draw the image normally. In 3D mode, this is just as fast as a normal draw.
        g->DrawImageMirror(mApp->mTurbotImg, 75, 275);

        // But what if you want to draw the image mirrored AND stretched? It's a little different,
        // but still easy. The first parameter, like usual, is the image you want to draw.
        // The second parameter is a Rect which indicates the destination region you want to draw
        // the image to: The XY of the Rect is just what you think it is, it's the pixel coordinate
        // the image should be drawn at. The Width, Height of the Rect however is how you accomplish
        // the stretching/shrinking. Specify a different width/height from the original image size
        // and you've just accomplished resizing the original image! Note that we have a third
        // parameter, also a Rect. This is the source rectangle, and indicates the region of
        // image you wish to draw. As you'll see in our animation example, you don't have to
        // always draw the entire image. You can specify a rectangular region of the source image
        // that you wish to draw, which is useful for large strips of animation (more below).
        // For our current case, however, we want to draw the entire image. So we specify that
        // we should draw from the top left (0,0) coordinate of the source image and we should
        // use it's full width/height. Again, just like with DrawImage, you can use the
        // SetFastStretch call to set whether you want the nice, slow, smooth scaling, or the quick
        // and efficient exact scaling. In 3D mode, this is just as fast as a normal stretched draw.
        g->DrawImageMirror(mApp->mTurbotImg,
                                                Rect(200, 275, mApp->mTurbotImg->GetWidth() * 2, mApp->mTurbotImg->GetHeight() * 2),
                                                Rect(0, 0, mApp->mTurbotImg->GetWidth(), mApp->mTurbotImg->GetHeight()));
                                               

        // Remember that black and white image we made in GameApp::LoadingThreadCompleted?
        // How about we draw it now so you can see what the result looks like:
        g->DrawImage(mApp->mAlteredImg, 500, 0);

        // And now for the exciting part: animation! As you can see in ::Update, we
        // increment the animation frame every 5 update ticks. We don't want to use
        // DrawImage because that will render the entire image. Instead, we only
        // want to draw a particular cel. We do that with the DrawImageCel function,
        // specifying the row or column to draw like so:
        g->DrawImageCel(mApp->mLightningImg, 0, 540, mAnimFrame);

        // If your animation strips contain both multiple rows AND columns,
        // you will need to use one of the alternate forms of DrawImageCel.
        // DrawImageCel is really just a convenience wrapper around DrawImage.
        // As you may have seen, you can tell DrawImage to draw just a particular
        // rectangular region of the image. Here is the equivalent function
        // call that we could have used in place of DrawImageCel above:
        //g->DrawImage(mApp->mLightningImg,
        //Rect(0, 540, mApp->mLightningImg->GetWidth(), mApp->mLightningImg->GetCelHeight()),
        //Rect(0, mApp->mLightningImg->GetCelHeight() * mAnimFrame, mApp->mLightningImg->GetWidth(), mApp->mLightningImg->GetCelHeight()));
        //
        // As you can see, DrawImageCel is a lot quicker to type.

        // Let's also display the current mouse XY and which button(s) are held down.
        // You should recall how to set fonts and change their colors from Demo2.
        // You will notice that the X, Y is not updated when the cursor moves over
        // the button that we added. This can be explained by reading the comments
        // for the MouseMove/MouseDrag/MouseDown/MouseUp methods.
        g->SetFont(mApp->mFont);
        g->SetColor(Color(255, 255, 255));
        g->DrawString(StrFormat(_S("X, Y is %d, %d"), mMouseX, mMouseY), 630, 20);
       
        SexyString buttonStr;
        if (mLeftDown)
                buttonStr += _S("Left button is down. ");
        if (mRightDown)
                buttonStr += _S("Right button is down. ");
        if (mMiddleDown)
                buttonStr += _S("Middle button is down. ");

        WriteWordWrapped(g, Rect(630, 40, mWidth - 630, 300), buttonStr, -1, -1);

}


//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void Board::AddedToManager(WidgetManager* theWidgetManager)
{
        // At this point, the Board class has already been added to the
        // widget manager. We should call our parent class' method
        // so that it can be sure to perform any needed tasks, first.
        Widget::AddedToManager(theWidgetManager);

        // Now let's create our first widget: a button. We do that by
        // telling the button what integer ID it should be identified with,
        // and by passing it a pointer to a button listener. Widgets have
        // "listeners" which respond to their particular events. Any class
        // can be a listener. For this particular demo, it is convenient for the
        // Board class to be the listener, but it is also common to use GameApp
        // as the main listener for all application buttons. The choice is up
        // to you and your needs.
        mButton = new ButtonWidget(1, this);

        // Remember how we had to position and size the Board class when we first
        // created it? A button is no different, it too is a widget. Let's
        // place this button on screen and set it's size now:
        mButton->Resize(675, 500, 100, 50);

        // Because a button can have a label on it, we should set the font to use:
        mButton->SetFont(mApp->mFont);

        // And just what should that label be? How about the word "Off".
        // We'll make it so that when it's clicked, it changes to "On" and
        // back to "Off" again.
        mButton->mLabel = _S("Off");

        // We can also change some colors, like the label color and the color
        // the label gets when moused over using the constants below:
        mButton->SetColor(ButtonWidget::COLOR_LABEL, Color(0, 0, 0));
        mButton->SetColor(ButtonWidget::COLOR_LABEL_HILITE, Color(0, 255, 0));

        // And finally, just like with the Board class, we have to add it
        // if we want to do anything with it.
        theWidgetManager->AddWidget(mButton);

        // If you want, you can also control the placement of the button.
        // You can put it in front of another widget, behind another widget,
        // at the top of the drawing order, or at the bottom of the
        // drawing order. You accomplish that with the WidgetManager's
        // PutInFront, PutBehind, BringToFront, BringToBack methods, respectively.

        // But wait, what does this button look like? If you don't specify an
        // image to use, the default Windows widget look will be used. We'll cover
        // images and widgets in a later demo.
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void Board::RemovedFromManager(WidgetManager* theWidgetManager)
{
        // This is called after we've been removed from the widget manager.
        // Again, we should let our base class do anything it needs to, first.
        Widget::RemovedFromManager(theWidgetManager);

        // We should now also remove any widgets we are responsible for. In
        // our current case, we made a button in AddedToManager. Let's remove
        // it now:
        theWidgetManager->RemoveWidget(mButton);

        // We'll delete it in our destructor.
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void Board::ButtonDepress(int theId)
{
        // Because we told our button that we, the Board class, are
        // going to listen for its particular events, this method will
        // thus be called when our button has any events it wants us
        // to know about. In our current case, we only want to know when
        // the button is clicked, but you could also respond to a few others.
        // Let's change the label on our button whenever it is clicked, from
        // "Off" to "On" and back again.
        if (theId == 1)
        {
                // We assigned ID of 1 to our button. You'd ideally want to use
                // a constant, but since this is a demo and there's only 1 button,
                // we're going to just use a literal instead. When a button
                // causes an action, it calls the appropriate listener function and
                // let's the listener know who it is via the ID parameter.
                if (mButton->mLabel == _S("Off"))
                        mButton->mLabel = _S("On");
                else
                        mButton->mLabel = _S("Off");
        }
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void Board::MouseMove(int x, int y)
{
        // This is called because the mouse cursor changed position and
        // the Board class was the widget closest to the cursor.
        // We're going to keep track of the XY coordinate whenever we
        // get this message for the sake of this demo.
        mMouseX = x;
        mMouseY = y;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void Board::MouseDrag(int x, int y)
{
        // This is called because the mouse cursor changed position  while
        // a button was down (a drag) and
        // the Board class was the widget closest to the cursor.
        // We're going to keep track of the XY coordinate whenever we
        // get this message for the sake of this demo.
        // Note that MouseDrag is called instead of MouseMove under
        // this condition.
        mMouseX = x;
        mMouseY = y;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void Board::MouseDown(int x, int y, int theClickCount)
{
        // Let the parent class know about this and perform any actions
        // it needs to.
        Widget::MouseDown(x, y, theClickCount);

        // Let's just keep track of which button is currently held down.
        if (theClickCount == 3)
                mMiddleDown = true;
        else if (theClickCount > 0)
                mLeftDown = true;
        else if (theClickCount < 0)
                mRightDown = true;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
void Board::MouseUp(int x, int y, int theClickCount)
{
        // Let the parent class know about this and perform any actions
        // it needs to.
        Widget::MouseUp(x, y, theClickCount);

        //You can actually tell if the left, right,
        // or middle buttons are currently held down by calling one of these
        // WidgetManager methods: IsLeftButtonDown, IsRightButtonDown,
        // IsMiddleButtonDown. However, we're going to keep track of this
        // manually just to illustrate a point.
        if (theClickCount == 3)
                mMiddleDown = false;
        else if (theClickCount > 0)
                mLeftDown = false;
        else if (theClickCount < 0)
                mRightDown = false;
}