A pointer is a variable literally pointing to an address (any address) in memory.

for instance:

int nVar = 12; //This is a regular variable!
int * pVar = 0; //This is a pointer variable!

the variable nVar contains a the number 12. This is located somewhere in the heap. It doesn’t matter where. We don’t really care. nVar is an integer an can only take things that are 4 bytes on size.

the variable pVar is a pointer. This is a variable that takes an address, any address! However, it expects that the address will point to an integer (that bit is important). Right now, it’s just a zero, meaning that it’s not pointing to anything at all. It’s empty, and sad…

we know pVar is a pointer, and takes an address. So we can give it an address:

pVar = &nVar; //now pVar is pointing to nVar.

If you remember & gets the address of a variable. So we’re giving pVar, the addresss to nVar. This is important… We’re not giving pVar the number 12. We’re just telling pVar where 12 is located. In other words, if you tried to do a cout on pVar, you would not get 12. Instead, you’ll see something like: 0x0025fe. If you went inside your computer, and went to this place in memory, you’d see 12 there.

This presents a problem. You know where something is, but sometimes you point to something and want to know the value! Knowing where 12 is, is pretty useful, but what if you wanted to know what nVar minus 5 is and you only had the address.

That’s when dereferencing comes into play. Dereferencing is a way to tell the pointer to give you the value of the address it has. In other words, It’s asking google, who lives at 4275 Solar Circle? This is accomplished by putting a star right before the variable.

int newVar = 0; //Lets create a new variable
newVar = *pVar; //newVar is now 12!

There is something even more interesting than this… How about if i have the address to nVar, and want to change the value of nVar?

cout << “The value is: ” << nVar << endl; //”The value is: 12″
*pVar += 5;
cout << “The new value is: ” << nVar << endl; //”The new value is: 17″

Why? Well, I went into the address for nVar, and changed the value. nVar is still pointing to the same location. That never changed. But now I changed the value of that specific box.

Enter Arrays:

Arrays, as we talked, are just addresses to a location. So what makes them different from pointers?

int arrayVar[4]; //arrayVar is an address to a place that can contain 4 integers.
int *pVar; //pVar is an address to a location.

The difference is very succinct. The different lies in that an array is pointing to a location which has a specific number of slots allocated, while a pointer is pointing to any location. It doesn’t care about size either, which is what makes them great when you’re allocating memory dynamically! No longer are you held back by that ugly 4… If you need more space, just ask for it!

int *pVar = new int[whatever]; //and by whatever, i mean 3000 if i want!

This is called, dynamic memory allocation. That “new” keyword means: “give me a brand new location where i can store this many items”. It’s then allocated for you on the fly and will stay in memory for as long as you tell it to. However, the rules for arrays still apply. After all, arrays are just pointers. So pointers are also just arrays. What if i need index 4?

pVar[4] = 15; //Lets put a 15 in the 4th space!
cout << “Index 4: ” << pVar[4] << endl; //Show me what’s in index 4 -> “Index 4: 15″

So why i didn’t dereference it here? Well, the answer is fairly simple. Remember how a pointer is just an address that expects something the size of the data type? the brackets [] are actually a function in a sense. They say quite literally “move this many positions”. But how does it know how far to move… after all, what if I have a array of very large objects! 4 bytes wouldn’t be enough. how far each step is, is defined by the data type (int in this case).

Now when you see arrayVar[0], you get the first element because you never moved from the first location! You moved zero steps. Equally with the pointer. pVar[4] is asking the pointer to tell you what’s contained 4 steps ahead. Each step the size of the data type (int in this case). Now, I lied, it doesn’t move in reality. Notice that i said “to tell you what’s contained 4 steps ahead”. That’s because the pointer is still pointing at the beginning of the array. It’s just “pretending” to move, so it can tell you what’s in the location you asked.

So, what if you moved ahead for reals?

pVar += 4; //oh no… What’s going to happen?

First, notice that I didn’t dereference the point. This time, i’m actually moving the address. This is a little deceptive. I’m not moving the address 4 locations. It’s not going from 0×000001 to 0×00004. The answer is above. When i move, the pointer moves each step the distance of the data type. In this case, the data type is int which is 4 bytes. So the address goes from 0×000001 to 0×000017 (4 steps by 4 bytes). You can go ahead and check it out if you feel ever so skeptical.

Even more interesting is this… I moved 4 steps, so where exactly am I?

cout << “My value is: ” << pVar[0] << end; //”My value is: 15″

What?! Well, think about it. pVar[4] value is 15. So instead of peaking using brackets [], I actually moved to the location and got the first index.

Now, the fancy math is very dangerous, so DO NOT use it, unless you know what you’re doing. Otherwise, kaboom goes the system! Stick with the brackets. After all, you just want to know what’s ahead. You don’t need to change the location.

Finally and before the grand finale, it brings us to dereferencing a pointer or an array. The answer by now should be fairly obvious. You don’t need to dereference a pointer when you’re using it as an array. After all, arrays are just pointers, and pointers can be arrays.

Lastly, and perhaps more important than any other thing: Uncle Ben once told me while driving to the library: “With great power comes great responsibility”. He got killed by a robber shortly after… This lesson cannot be any truer with pointers. Pointers are addresses to locations. So when you allocate memory dynamically (using the “new” keyword), it’s then allocated for you on the fly and will stay in memory for as long as you tell it to.

pVar = new int[3000]; //I created a new array for 3000 elements.
pVar = new int[2]; //I create another array of 2 elements.

This is bad! Why? Because you first allocated a big array, and then a small one. But what’s the big deal? you might think. Well, that big array is still in memory. Some where. Just waiting to be used, discarded, or something. Anything! It won’t disappear until you told it to. Even worse… You just lost the address to it because you allocated a new one! You don’t even know where this huge “memory leak” is at. Congratulations, you have ruined your computer forever… Or until you turn it off since the stack memory is wiped out.

But the lesson to be learned is important. Doing this is bad. You need to be responsible with memory. It’s not free, it’s not safe, and needs to be managed carefully.

pVar = new int[3000]; //I created a new array for 3000 elements.
delete [] pVar; //and thus, i release thee from my memory.
pVar = 0; // and this for good measure to indicate it’s empty. Do it! don’t be lazy!
pVar = new int[2]; //and new life is reborn.
.
.
.
delete [] pVar; //Ashes to ashes, and so on.
pVar = 0; //you’re ready to rise again… like a phoenix!

May the force, be with you…

I shall soon, when I get my ruby project going!

The idea of the addon is simple; Now that I’m leveling a brand new druid along with my friends, I wanted a simple way to track my progress on each session. We all love playing but we have very limited time. Our biggest time constrain at the moment is my wife, who comes home from work at 9pm and after eating it barely leaves us with 2 hours (till midnight) to play. Two hours a night might seem like a good amount of time for most people, but anyone that knows MMOs and how RPGs generally work, knows that 2 hours is such a small window that progress needs to be made efficiently.

Because of this, I wanted to track where we were getting most of our XP from. Sometimes it’s easier to complete small quests, and some times you get far more XP by grinding. It really depends on the Zone, the quest and the mobs that you’re fighting. In our case, and with a party of 4, things die very quickly, but getting drops takes very long. Sometimes a single “drop” quest takes about 30 minutes. That works very much against us as we could be completing other chains that require just killing in far less time.

Anyway.. I digress. This is what the addon does:

* Track XP by Level
* Track XP by session
* Track XP by LifeTime

With in each of this categories you can track:

* Number of Kills
* XP gained from kills
* Number of Quests completed
* XP gained from quests.

Additionally because of the data already available, you can make a fair assumption on how many quests or kills are needed to level. The only issue with this is that I make this assumption on a per level basis, so once you level up, you’re going to need to either kill a mob or complete a quest to get the next forecast. This is to avoid old data from affecting the new set of stats for the level.

Over all, I think it was a fun project that I’m hoping to keep working on and maybe grow some. I got some ideas that I’d like to introduce as well as improve the over all architecture of the addon. A lot of work can be done and it has a lot of potential!

That is it for today! Have fun and good bye.

http://www.tentonhammer.com/node/26419

I’ve been trying to solve an issue with saving variables between sessions, and after much looking, I came across this particular tutorial. It is very outdated, but the information on it is still very valid. If not accurate, it is still a good reference guide for my first addon.

I will post pics when it’s in a more fitting working condition.

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Graphics;

static public class InputHandler
{

}

Notice the libraries that are included. Only the ones that are strictly necessary. The reason it’s static and public, it’s to allow all other parts of the program access to it. This is handy because it will allow us to control menu selections, and gameplay at the same time without having to initialize the class everywhere. This are the initial members of the class:

static public class InputHandler
{
//Texture
static Texture2D nullTex;
static int spacing = 7;

//GetMouse
static Vector2 mouseRecOrigin = Vector2.Zero;

static MouseState prevMouseState = Mouse.GetState();
static public MouseState MouseState
{ get { return prevMouseState; } }

static Rectangle mouseRec = Rectangle.Empty;
static public Rectangle MouseRec
{ get { return mouseRec; } }

static bool isLeftClick = false;
static public bool LeftClick
{ get { return isLeftClick; } }

static bool isRightClick = false;
static public bool RightClick
{ get { return isRightClick; } }

}

Tons of variables here, but as we can see, these are all private, and only a few have accessor functions. That’s because we don’t want any other class to change the information that it’s being passed around. The other reason is because we’re going to use some private variables to track information that will become useful a bit later. I have also included a texture here. This is because we want to be able to draw a rectangle if the left button is pressed and dragged. The texture is a 1×1 transparent png. The first function is not a constructor. There is no need because we want to get the mouse information as soon as we start the program. For this reason, we initialize the state of the mouse as soon as it launches. That defeats the whole purpose of having a constructor in this case. All other information will be processed as it is received. The first function is Update() function:

static public void Update()
{
MouseHandler();
}

Tada! Yes.. tis’ that bad. The problem here is that our class is a general input handling class. That means that we don’t want to limit ourselves to just mouse input (even though it is what we’re doing initially). Now for the real MouseHandler(). This is a rather large function. So I will break it down into little pieces: The initialization:

static private void MouseHandler()
{
  MouseState mouseState = Mouse.GetState();
  isLeftClick = false;
  isRightClick = false;

Get the current state of the mouse is pretty obvious. The little less obvious is isLeftClick and isRightClick. We want to make this two false as soon as we enter the function. We’re only going to turn them on if there is an action in progress. If there is no action, they will drop all the way down as false. This are the single right and left click variables. That’s important to know.

  //the left button has been pressed.
  //Create the rectangle
  if (prevMouseState.LeftButton == ButtonState.Released && mouseState.LeftButton == ButtonState.Pressed)
  {
    mouseRec = new Rectangle((int)mouseState.X, (int)mouseState.Y, 0, 0);
    mouseRecOrigin = new Vector2(mouseState.X, mouseState.Y);
  }

the first thing we do is compare the previous value to the new value. If it was not pressed before, and it’s pressed now, we create a rectangle. The X, Y coordinates are set to the position of the mouse. We also set the MouseRecOrigin values to X, Y. This is a private variable which is used to keep track of where the rectangle was started. This will allow us to draw rectangles in every directions.

  //the left button is on hold.
  //Update rec with appropiate dimensions
  if (prevMouseState.LeftButton == ButtonState.Pressed && mouseState.LeftButton == ButtonState.Pressed)
  {
    //Capture the origin and width
    if (mouseState.X > mouseRecOrigin.X)
      mouseRec.Width = mouseState.X - mouseRec.X;
    else
    {
      mouseRec.Width = (int)mouseRecOrigin.X - mouseState.X;
      mouseRec.X = mouseState.X;
    }

    //capture the origin and height
    if (mouseState.Y > mouseRecOrigin.Y)
      mouseRec.Height = mouseState.Y - mouseRec.Y;
    else
    {
      mouseRec.Height = (int)mouseRecOrigin.Y - mouseState.Y;
      mouseRec.Y = mouseState.Y;
    }
  }

This chunk is the one that we’ll probably care the most. I had seen a tutorial here which is a great resource. The problem I found with their way of doing things, is that it didn’t allow for the mouse to be dragged in a top-right diagonal. So this was my solution to their issue. Not the most elegant, but it certainly gets the job done.

First we make sure that the mouse was previously pressed and it continues being pressed. This is the only time that we want to draw/create a rectangle. Now, if the current position X of the mouse is greater than the origin X, then that means we’re dragging the mouse to the right. In this case, the rectangle’s origin should be X. In this case we only care about the width of the rectangle which we calculate by subtracting the current position from the old position.

However, if the current position X is less than the origin X, then we’re dragging the mouse to the left. Because of this, we need to not only find the new width of the rectangle, but also find the new origin. We find a new origin because we want to keep the rectangle straight with non-negative width. In this case, we subtract the position X of the mouse from the origin to calculate the width.

Additionally, we store the current location of the mouse to the origin of the rectangle. The update done for Y is identical, except for the change in the variable name from X to Y. The only things left to do are capture the single clicks.

  //the left button has been released
  if (mouseState.LeftButton == ButtonState.Released &&
      prevMouseState.LeftButton == ButtonState.Pressed &&
      mouseRec.Width == 0 && mouseRec.Height == 0)
  {
    isLeftClick = true;
  }

  //Check for right mouse click (No drag allowed)
  if (mouseState.RightButton == ButtonState.Released && prevMouseState.RightButton == ButtonState.Pressed)
    isRightClick = true;

very simple code here. In the case of the left click we want to check the previous status of pressed to the new status of released. That means it’s been let go. However because we do care about the drag characteristics of the left click, we do one more check against if the rectangle has a width or height. This will ensure that it’s a single click or a drag. For the right click, we’re just going to check the status. Finally the clean up code:

  //Clear the rectangle
  if (mouseRec != Rectangle.Empty &&
      mouseState.LeftButton == ButtonState.Released &&
      prevMouseState.LeftButton == ButtonState.Released)
    mouseRec = Rectangle.Empty;

  //update the mouse state
  prevMouseState = mouseState;
}//End input handler

We have three checks here. First we check if the rectangle is empty. If it’s empty, we just keep going. No need to set it again. If there is a rectangle, then we check if the current status of the mouse is pressed. If it’s not, it’s because the user might have just released. If that is the case, we want to leave the rectangle alone, so whatever is next in line can use the rectangle as needed.

If the previous state was released, then it means that it’s been released for two frames: Clear the rectangle. Finally we just update the previous mouse state. Now, for the drawing! First things first: Load the texture:

static public void Load(ContentManager theContentManager)
{
  if (nullTex == null)
    nullTex = theContentManager.Load(@"gfx/1x1");
}

Simple enough. I do the null check in case some other part of the program is also trying to load it. In that case we don’t wanna cause errors so we just return. Now, for the actual drawing:

static public void Draw(SpriteBatch spriteBatch)
{

  spriteBatch.Begin(SpriteBlendMode.AlphaBlend);

  //Set up the rectangle.
  Rectangle dstRec = new Rectangle(mouseRec.X, (int)mouseRec.Y, 1, 1);
  Color color = Color.WhiteSmoke;

Again, tons of code, so we break it down. First initalize the variables. Pass spriteBatch as an argument, and begin! Now we set up a temporary rectangle. The origin is going to be the origin of the mouseRec. However, the width and height are only 1 because that’s the size of the border we want for the dragged rectangle. We also set a color because we’re going to use it in the draw function. So better to not hardcode something 4 times.

  if (mouseRec.Width > 0)
  {
    int x = mouseRec.Width / spacing;
    for (int i = 0; i <= x; i++)
    {
      //draw horizontal top
      spriteBatch.Draw(nullTex, dstRec, new Rectangle(0, 0, nullTex.Width, nullTex.Height), color);

      if (mouseRec.height > 0)
      {
        //draw horizontal bottom
        dstRec.Y += mouseRec.Height;
        spriteBatch.Draw(nullTex, dstRec, new Rectangle(0, 0, nullTex.Width, nullTex.Height), color);
        dstRec.Y -= mouseRec.Height;
      }

      //advance
      dstRec.X += spacing;
    }
  }

We’re going to have to do two independent checks. One for width and one for height. We could potentially do it in one, but it’s just messy if we do. So much better to have two separate statements. First things first, we set up a sentinel value. This value is the width of the rectangle. The result is the space between each graphical assets to be drawn as a border. I like 7 because it gives you this ton of space between dots. Makes it oddly cool. Now we loop through the entire width.

Notice that the condition is not less than but also equal to. This is because if you don’t draw one more, you’re going to have a odd gap on the bottom right corner. This way the extra space is filled by a extra iteration. Now, I draw the bottom horizontal line. For this we first check if the height is greater than zero. If it is not greater than zero, then we don’t even worry about drawing it. This will certainly save cycles. If the height is greater, then we will move the Y position of our temp rectangle to the bottom of the rectangle. and we draw one more sprite there.

Next we reset it back at the top for good measure. The tutorial I linked above has this whole thing outsourced to a function which is called 2 times. I rather do it in the same loop. it’s one less jump and we have all the information at hand. The verticals are identical to the horizontals. The only difference is that we’re moving to the right column if the width is greater than zero:

if (mouseRec.Height > 0)
{
  dstRec.X = mouseRec.X;
  int Y = mouseRec.Height / spacing;
  for (int i = 0; i <= Y; i++)
  {
  //draw vertical right
  spriteBatch.Draw(nullTex, dstRec, new Rectangle(0, 0, nullTex.Width, nullTex.Height), color);

    if(mouseRec.Width > 0)
    {
      //draw vertical left
      dstRec.X += mouseRec.Width;
      spriteBatch.Draw(nullTex, dstRec, new Rectangle(0, 0, nullTex.Width, nullTex.Height), color);
      dstRec.X -= mouseRec.Width;
    }

    dstRec.Y += spacing;
  }
}

  spriteBatch.End();
}

Finally we close the spriteBatch! PHEWW… that was long. But I think at the end, it makes for a nice effect and certainly adds a ton of functionality! The final result?

* Initial Screen
* Options
* Pause
* others

This was done thanks to one of the resources in the XNA (again using code from resources… shame on me). The complexity of it is a bit above my knowledge, so it was a direct copy/paste and I just did some mark up to get it to work with my own code.

I did this because of several reasons. First of all, I really got to clean up the code and outsource everything out of the main class and into a World class. World class controls everything in the game board through function calls on update for each element. The only logic here is on the AI behavior changes (when enemies shoot or dive).

The second reason is because it let me use a Options screen that lets me load and reaload things without having to quit the game. This was when the big eureka moment hit me. After having traced how each screen worked, i noticed that it didnt’ have a way to pass game options from point to point. In other words, any options that I added to the options screen was lost the moment I left the screen.

This posed a problem to my idea of having options for adding enemies and other elements. Of course, this is the whole purpose of the options screen! The solution was rather inspired by my previous work with the Sound class. So I created a public static GameSettings class. Why static? well, the answer is rather simple, it offers me the option to control them and access them from anywhere. When the options are updated in the options screen, they’re read by the World class in the GamplayScreen and taken into account when the game loads.

I like this solutions a lot. I think it’s both elegant and functional. It also led me to create a Level class which can store level options. I can create a array of levels, and then access each level as the game progresses.

I am currently working on a HUD. I just got started on it, so there is no much functionality to it yet. So far I am only drawing a radar and a small marker for where the hero is. I still need to decide how to work the radar in the game. I have 2 options, to display a radius of where things are, or display everything in the playing field. They both have pros and cons. I haven’t decided because I’m still strugling with now I want to make the game work. This is a bad thing at this stage… I really should know where I’m going, but I have become increasingly worried about what it takes to make any type of RTS work (even on the simplest level). I love the idea of the RTS, but it takes more than one person, and I have been doing this all by myself, which makes it extremely difficult.

I think I will be working on a single controlled ship taking a number of enemies very much Galaga style though the AI will be free roaming.

More to work on =)

That was the case of this latest step in the process. Sound was something that I was not entirely sure how to bring into the world. I knew the basics such as initializing the engine, the soundbank and the wav. I had some trouble getting the Cues to play, but that had to do with not knowing much about XACT (the sound rendering engine in the XNA). FYI, if anyone ever has trouble getting their cues to play, just make sure you actually added the cue from the soundbank to the cue list at the bottom. One of the issues with sound (and this is an issue with a number of things when making games), is that a lot of elements in the game need access to the sound engine and sound cues. There are several way to solve this issue; for instance, you can inialize the engine in the “world” class, and pass a reference to every sub class. This is not very portable, and certainly makes for a mess of very ugly code. Another option is to allocate a sound engine and intialize it in every sub class. This is portable… but holy cow would it be expensive and unnecessary use of resources. It also makes for ugly code.

Then I found the Marble Game way. It’s one of those moments when you find out that the simplest answer is the correct and takes you some time to realize that you have been doing it all wrong. The easiest and most effective way to do this is to create a static class and initialize it in the “world”. The great advantage of this is that it makes it portable, accessible, economic, and very elegant code. The static class can be called from any other sub class and the initialization can take place with a single call. It was brilliant. The execution on the example of the Marblet Game was also very elegant. When things meet all this needs, it would be silly to attempt and create my own, so I learned what to do next time, and moved on!

The next step will be setting a player based AI with mouse selection and way points. Looks like a very hard task but it should be fun.

I also need to implement a HUD. I honestly think this should be one of the last things to even think about. Having said that, I also believe that it’s one of the things that can really bring a game to life.

No screenie today. Source code might be up later this week, after I clean up and make it pretty.

In the process of learning all this stuff, I have found a new love for AI. The complexities of it and the subtle things that make it great even on the most simple games. The book I’m reading is http://ai4g.com/. It’s is certainly a great book though I wish the pseudo code was a bit better as far as what each function needs to pass and return. I guess their idea is to make it as open as possible, the downside is that if you’re learning, you’re left wondering.

So I currently have the following behaviors:

Seek: It moves the object to a target at a set speed. Object rotates to face the target and then moves forward.
Flee: It moves the object away from a target at a set speed. Object rotates to face away from the target and then forward
Wander: It moves the object around. First forward and then with a chance of modifying the orientation left or right.
Homebound: This one I kind of invented just to experiment. Homebound moves the object to the defined starting point. It uses the Seek steering and the only real difference is that once it reaches the target, it will return to facing the last stored orientation. This can be useful for “patrolling” behaviors.
Static: Does nothing. This is an actual needed behavior. Even if there is no movement involved, having the ability to control what a object does when it’s not moving, makes it very useful.

Finally, here is the screenshot of the program. The red rectangle is the bounding box of the object. This is basically the rectangle that determines where an object is being hit or the size of the object when rotated. There are just too many reasons to have this. Obviously, it’s just debug information to have it colored and drawn. In an actual game, this would certainly be invisible to the user.

I have also added some text on the left side. The Cylon raider are numbered 0-9 (a 10 size array) with the information on rotation and position on the screen. This was very useful when trying to find out if the objects where behaving correctly at the early stages of making the AI. Now, this is a bit redundant. However, having information displayed like that has become essential to me. Learning on my own, I used to struggle a lot trying to trace where things where going or what they were doing. I have since then learned that you can learn a lot by just letting the program run and display as much information as possible about what’s going on.

The next step will be to add the collision back into the game. I already have working collision behavior for bullets from a previous version. I just need to find a better way to manage all the interaction between the assets to minimize the number of cycles while maximizing the information output.

I actually found working with the XNA very comfortable and fun. C# is very easy to pick up if you already know Java and C++. I’ve been working in my own project, and helping others with little things here and there. I created this little splash screen in just 30 mins.

Just a logo with a clock like animation. I’ll put more details on my actual project later on!

Thus will it come to pass. A dying leader will know the truth of the Opera House. The missing Three will give you the Five who come from the home of the Thirteenth. You are the harbinger of death, Kara Thrace. You will lead them all to their end. End of Line

Spoiler Alert: Episode – Sometimes a Great Notion. January 16th, 2006

This is the last line that the Hybrid gives to Starbuck before being unplugged during the Season 4 (1st half) Episode – Faith. Why is it so significant? Well, for the second part of season 4 this will be the line to unravel the story (or so my theory goes).

Danielle has an interesting theory actually. She believes that Starbuck is actually a 13th cylon or cylon related “creature”. The theory is actually pretty good if you tie it to this specific line. This is go it goes.

The facts:

There were twelve colonies. One for each sign on the zodiac.
There was a thirteen colony in a planet called Earth. This is also related to a thirteen zodiac sign.
There are twelve cylons.
The remains found in Earth are not human remains but cylon remains.

The speculation:

Danielle’s theory is actually pretty simple. There are only 12 known cylons. However, just like the 13th, colony, there might be a 13th cylon that is not known to the others. This new cylon is Starbuck. So far, one part of the line given by the Hybrid has come true. The missing three did give the 4 (5 if you count this episode).

There are the following parts to unfold:

A dying leader will know the truth of the Opera House.
You are the harbinger of death, Kara Thrace. You will lead them all to their end.

However, the most interesting line is this:

…the Five who come from the home of the Thirteenth.

There is one interesting issue here. This line does not say anything about the 13th being the colony or a cyclon. The wording is so vague that it’s entirely plausible that the line is talking about a 13th cylon who is the maker and could potentially be the “God” of the cylon religion. It would also explain why “God” didn’t want the other 7 to know about the five since they were created on earth and had reach a human-like society which the other 7 were craving for. I don’t think Starbuck is the god of the cylons, but I do think she is related to the maker. Maybe a clone of which would tie it to the Caprica series. Making her the original Cylon. This would also explain how she returned from the dead, and why she has the bigger destiny to acomplish.

I don’t think there is a solid theory out there as to why Starbuck is the “Harbinger of Death”. But I think this covers pretty much everything else.