path: root/osframework/source/demos/Demo2/Board.cpp

#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"

// Why are we including ImageFont.h and not Font.h? Font.h is just a generic
// base class. ImageFont creates fonts from an image that contains all the
// text characters as well as a text file that indicates character widths
// and kerning information, as well as some more advanced features not used
// in this tutorial such as font layers, etc.
#include "SexyAppFramework/ImageFont.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"

// 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 by fully glowing and making the pulse decrease
	mPulseAmt = 255;
	mIncPulse = false;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
Board::~Board()
{
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
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();

	// Every frame (100 times per second) let's change the pulse amount by
	// 1. When we reach either 0 or 255 (the lower/upper bounds of
	// a color value) we'll reverse the pulsing direction. See the Draw()
	// method for its usage: we're going to draw an image with varying intenstiy
	// over time.
	if (mIncPulse)
	{
		if (++mPulseAmt >= 255)
		{
			mIncPulse = false;
			mPulseAmt = 255;
		}
	}
	else
	{
		if (--mPulseAmt <= 0)
		{
			mIncPulse = true;
			mPulseAmt = 0;
		}
	}

	// Let's play the timer sound effect once every 2 second.
	// Since this method is called 100 times per second, just mod
	// mUpdateCnt by 200. We do that by calling GameApp's PlaySample()
	// method and specifying the integral ID of the sound to play. This
	// ID is the same as we used when loading the sound in GameApp::LoadingThreadProc()
	if (mUpdateCnt % 200 == 0)
		mApp->PlaySample(1);

	// What about playing a sound but making it play on either the left or
	// right speaker? And what about pitch shifting? These are all possible,
	// but we won't learn about them until a later demo.



	// 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)
{
	// And now for the good stuff! 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 print some text. In order to do so, we need to instruct the
	// graphics object as to which font we want to use. We do that with
	// the SetFont method. Then we call the DrawString method and pass in
	// a normal string and give it an X, Y to draw at. But wait! If we just
	// draw a string right now, we won't see it. Can you guess why?
	// The graphics object is still using the color, white, which we
	// set a few lines above. Thus, when it goes to draw the string,
	// it will draw it in white. How do you change the text color?
	// Easy: it's just like you learned for drawing those primitives:
	// just use SetColor and you're done! It doesn't matter whether you
	// set the color before or after you set the font, fyi.
	g->SetColor(Color(255, 0, 0));
	g->SetFont(mApp->mTextFont);
	g->DrawString(_S("Woo! Text! Ya!"), 10, 10);

	// Wait a minute, didn't we say to draw at a Y value of 10? Then why does it 
	// appear to be drawing at about 0? That's because the text is offset
	// by the ascent of the font. A discussion of font terms is beyond the
	// scope of this demo, but basically just remember that if you want to
	// display the text at the exact Y coordinate, that you should add
	// the value of the font's ascent. You can get the ascent by calling
	// GetAscent() on the font in question. I'm going to use the same
	// Y value of 10 just to show you the slight difference using GetAscent makes.
	g->SetColor(Color(55, 90, 255));
	// We already set the font, no need to set it again unless we want a new one
	g->DrawString(_S("I like Techno and Drum n' Bass"), 170, 10 + mApp->mTextFont->GetAscent());

	// And to help you out visually, let's draw a line at Y coordinate 10:
	g->SetColor(Color(255, 255, 255));
	g->DrawLine(0, 10, mWidth, 10);

	// Just for fun, let's change the font. This font, as you can see from its image, 
	// only contains digits and a few symbols. As an example, I will draw a string
	// containing only those characters as well as a string containing characters that
	// the font can't represent to show you what would happen.
	g->SetFont(mApp->mNumberFont);
	g->SetColor(Color(255, 255, 0));
	g->DrawString(_S("+200"), 10, 40);
	g->DrawString(_S("+200 pts"), 10, 60);

	// You can also get the width of a string in pixels for any given font. In addition, you
	// can use a printf style function, StrFormat, which is defined in Common.h, to 
	// format strings. You might want to look at Common.h for some...common...and handy functions.
	g->SetColor(Color(0, 255, 255));
	SexyString myString = StrFormat(_S("You got %d points!"), 147);
	g->SetFont(mApp->mTextFont);
	g->DrawString(myString, 10, 80);
	g->SetColor(Color(0, 255, 0));
	g->DrawString(_S(" I am to the right of that previous string."), 10 + mApp->mTextFont->StringWidth(myString), 80);
	

	// What about some other common text functions, like justifying and word wrapping? 
	// Not a problem. The Widget class contains some useful features.
	// For justification, the easiest is to use the WriteString method. 
	// The valid justification values are:
	//	-1: Left justified (same as DrawString)
	//	0: Centered
	//	1: Right justified
	//	
	//	For centered/right justified, you can also specify a width indicating the size of the region you
	//	are printing in. The sole purpose of that is to control the centering/right aligning. 
	g->SetColor(Color(255, 255, 255));
	WriteString(g, _S("Left justified at X of 200"), 200, 95, -1, -1);
	WriteString(g, _S("Centered using app width"), 0, 110, mWidth, 0);
	WriteString(g, _S("Centered using width of 200, X of 200"), 200, 125, 200, 0);

	// And now for a word wrapping example. With this function, you specify a rectangular region
	// that represents the "box" in which you want the text to be displayed. You can also
	// set the line spacing, or use -1 for the default font height, and you can also set
	// the justification using the same values as for WriteString. We'll also draw the "box" using
	// the DrawRect function, for illustrative purposes. You may notice that I didn't offset the
	// Y coordinate of the text by the font's ascent: that's because WriteWordWrapped automatically
	// does that for you.
	g->SetColor(Color(255, 255, 255));
	g->DrawRect(30, 140, 200, 400);
	g->SetColor(Color(0, 255, 0));
	WriteWordWrapped(g, Rect(30, 140, 200, 400), _S("This is some text that is wrapped inside of the rectangle \
												at X of 30, Y of 140, width of 200, height of 400. It has \
												been wrapped using the default left justification and the \
												default line spacing."), -1, -1);

	////////////////////////////////////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// Enough talk, let's draw images!
	// The simplest way to draw an image is with, coincidentally, the DrawImage method.
	// Just specify the image and the X, Y to draw at and boom! It's done.
	g->DrawImage(mApp->mTurbotImg, 230, 140);

	// What about changing the color of an image? This is called colorization, and it works just like
	// all the previous examples: You call SetColor with the color you want. But wait! There's 
	// an extra step: Because colorizing an image on the fly is slower than normal drawing, you have
	// to explicity tell the graphics object that you want to enable it. This is done by calling the
	// SetColorizeImages method of the Graphics class with a parameter value of "true".
	// IMPORTANT: You should call SetColorizeImages again but with a parameter of "false" when you
	// are done drawing your colorized image! Otherwise all subsequent image drawing calls will
	// be colorized using the most recent value from SetColor. You may call SetColor either before
	// or after SetColorizeImages, it doesn't matter. For this example, we'll draw an image normally
	// and then colorized. We'll also use the GetHeight() method to draw this image just below the
	// previous one.
	g->DrawImage(mApp->mOpaqueBeamImg, 230, 140 + mApp->mTurbotImg->GetHeight());

	g->SetColor(Color(255, 0, 0));
	g->SetColorizeImages(true);
	g->DrawImage(mApp->mOpaqueBeamImg, 230 + mApp->mOpaqueBeamImg->GetWidth(), 140 + mApp->mTurbotImg->GetHeight());
	g->SetColorizeImages(false);

	// You may have noticed that part of the previous two images was drawn offscreen. The graphics object by
	// default sets a clipping region to the size of the widget, and anything drawn outside of it
	// is clipped, or not drawn. You'll see some more advanced uses of clipping and widgets in a later demo.

	// There's another cool effect you can do to images: Drawing additively instead of normally.
	// Additive drawing is just what the name implies: when you draw the image, instead of
	// drawing using the exact RGBA values of the image, it actually combines them with whatever
	// pixel values there are in the location in which it is placed. One common use of this is
	// to draw the same image, but brighter: To do so, you'd just draw the image normally first,
	// then draw the same image on top of it but additively. Let's try an example and draw
	// our first image, mApp->mTurbotImg, additively to get a bright effect. 
	g->DrawImage(mApp->mTurbotImg, 230 + mApp->mTurbotImg->GetWidth(), 140);

	// Enable additive drawing with the call below. IMPORTANT: You should set the
	// drawmode back to Graphics::DRAWMODE_NORMAL when done, so that other images
	// don't get drawn additively. Additive drawing is slower than colorization,
	// so keep that in mind if you are concerned about your game's performance.
	g->SetDrawMode(Graphics::DRAWMODE_ADDITIVE);	
	g->DrawImage(mApp->mTurbotImg, 230 + mApp->mTurbotImg->GetWidth(), 140);
	g->SetDrawMode(Graphics::DRAWMODE_NORMAL);

	// You can even draw an image colorized and additively. This is comonly used to
	// implement a pulsing sort of effect. Let's do just that: the variable,
	// mPulseAmt, is updated in our Update method and controls the RGB value
	// that we'll use to make our image pulse. Again, be sure to set things back
	// to normal when you are done. Also, it matters not in which order the
	// SetDrawMode, SetColor, and SetColorizeImages calls are made.
	g->DrawImage(mApp->mTurbotImg, 230 + mApp->mTurbotImg->GetWidth() * 2, 140);

	g->SetDrawMode(Graphics::DRAWMODE_ADDITIVE);	
	g->SetColor(Color(mPulseAmt, mPulseAmt, mPulseAmt));
	g->SetColorizeImages(true);
	g->DrawImage(mApp->mTurbotImg, 230 + mApp->mTurbotImg->GetWidth() * 2, 140);
	g->SetDrawMode(Graphics::DRAWMODE_NORMAL);
	g->SetColorizeImages(false);

	// And finally, let's just have a simple example of alpha blending. We'll
	// Draw our first image, a picture of a moon, normally, and draw
	// our friend Turbot at reduced opacity on top of it. The result is you can
	// see through turbot to the moon below. Notice that we set the color
	// for turbot to r=255, g=255, b=255, alpha=128: This results in the
	// RGB values not being changed, only the alpha. Using a value of 255 for
	// a colorization amount basically means that the color component will not
	// be altered.
	g->DrawImage(mApp->mMoonImg, 400, 300);
	g->SetColor(Color(255, 255, 255, 60));
	g->SetColorizeImages(true);
	g->DrawImage(mApp->mTurbotImg, 400, 300);
	g->SetColorizeImages(false);

}