Monthly Archives: February 2011

I can select you!


yeah this red triangle means – I am selected.. I will be working on sprites manager over the weekend..
At least.. I have managed to select sprites inside of box described by start point and end point – both defined by mouse click and release.

Class probably will be improved in the future but now.. welcome to AddToSelected method

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
void PlayerManager::addEntityToSelected(POINT mouseBoxStart, POINT mouseBoxEnd){

std::map::iterator iter = playersEntities.begin();
for(; iter != playersEntities.end(); ++iter)
{
if(mouseBoxStart.x> mouseBoxEnd.x)
{
mouseBoxStart.x +=mouseBoxEnd.x;
mouseBoxEnd.x = mouseBoxStart.x - mouseBoxEnd.x;
mouseBoxStart.x -= mouseBoxEnd.x;
}

if(mouseBoxStart.y> mouseBoxEnd.y)
{
mouseBoxStart.y +=mouseBoxEnd.y;
mouseBoxEnd.y = mouseBoxStart.y - mouseBoxEnd.y;
mouseBoxStart.y -= mouseBoxEnd.y;
}

bool collisionResult = false;

if(mouseBoxStart.x < = iter->second->getPosition().x && iter->second->getPosition().x < = mouseBoxEnd.x)
{
if(mouseBoxStart.y <= iter->second->getPosition().y && iter->second->getPosition().y < = mouseBoxEnd.y)
{
collisionResult = true;
}
}

//if point is inside square then add to selected

if(collisionResult == true)
{
playersSelectedEntities[iter->second->getID()] = iter->second;
}

}

}

idea of this method is to search player entities list.
let me explain

when program is adding new objects to the scene it is adding new entities. Entities can have tag/name simple if check at this stage can save a bit of CPU later on, when instead of searching through all entities on the map we are searching only list of players entities that are pointing to exact entity.

1
2
3
4
5
6
7
8
9
void PlayerManager::markSelected(ID3DXSprite* sprite){
std::map::iterator iter = playersSelectedEntities.begin();
for(; iter != playersSelectedEntities.end(); ++iter)
{
D3DXVECTOR3 deltaPosition = iter->second->getPosition() - LevelManager::getOffset();
sprite->Draw(texture, 0, 0, &deltaPosition, D3DCOLOR_XRGB(255,255,255));

}
}

markSelected method is the one that needs little bit more brain storming on. At the moment I am keeping it in PlayerManager class.. which in my opinion is little bit weird.. but in my defense.. we want to mark “Players” selected entities.. don’t we?

Zombeesh back in 2D

After lately chat with my tutor I have to move back to 2D based game. – time pressure and general overloading forced me to make this decision.
GDD must be finished by tomorrow – but shall not fear! I have some resources. I will borrow units tile set from star craft – come on zombies looks almost like infected marine

as well as terrain tiles – provided by Maniak – thanks man!

I am improving level manager so I will be able to deal with offsets and a stuff.. as far as now I have prototype and hopefully it will be ready in next couple hours.

LevelManager.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#pragma once

#ifndef LEVELMANAGER_H
#define LEVELMANAGER_H

#include <map>
#include <d3dx9 .h>
#include "Level.h"

class LevelManager
{
private:
   //list of maps
   static std::map<int , Level*> levels;
   static int currentLevelId;
   
public:
   
   static LevelManager* instance;
   static void init();
   static void loadLevel(Level* level); // load level
   static void unloadLevel(Level* level);
   static void registerLevel(Level* level); //add level to levels pool
   static Level* getLevel(int id) ;
   static D3DXVECTOR3 getOffset(); //gets offset off current map;

   LevelManager();
   ~LevelManager();
};

#endif

LevelManager.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include "LevelManager.h"

int LevelManager::currentLevelId=-1; //no level
LevelManager* LevelManager::instance =0;
std::map</int><int , Level*> LevelManager::levels = std::map</int><int , Level*>();

LevelManager::LevelManager()
{
}

void LevelManager::init()
{
   LevelManager::instance = new LevelManager();
}


LevelManager::~LevelManager()
{
   if(!levels.empty())
   {
      std::map</int><int ,Level*>::iterator iter = levels.begin();
      for(; iter != levels.end(); ++iter)
      {
         delete iter->second;
         iter->second = 0;
      }
      levels.clear();
   }
}

void LevelManager::loadLevel(Level* level)
{
   registerLevel(level);
   LevelManager::currentLevelId = levels.size();
}

void LevelManager::unloadLevel(Level* level)
{
   std::map</int><int , Level*>::iterator iter = levels.find(level->getId());
   if(iter != levels.end())
      levels.erase(iter);
}


void LevelManager::registerLevel(Level* level)
{
   //get size of current levels list and increment by one
   int size = levels.size() + 1;
   levels[size]= level;
   level->setId(size);
}

//ok do I need to register all entitys into level? - I guess I do. need to double check that with Kevin
Level* LevelManager::getLevel(int id)
{
   std::map</int><int , Level*>::iterator iter = levels.find(id);
   if(iter != levels.end())
   {
      return iter->second;
   }
   return 0;
}
D3DXVECTOR3 LevelManager::getOffset(){

   std::map</int><int , Level*>::iterator iter = levels.find(currentLevelId);
   if(iter != levels.end())
      return iter->second->getOffset();
   return D3DXVECTOR3(0,0,0);

}

xBox is evil!

arrives at 8:30 that’s bed omen for starters!
then it says – if your hdmi monitor doesn’t have speakers you cannot do much about that.
then it steal whole day from your life!

I have started playing assassin’s creed – about 9 am and at some point my love told me to do something and that was 10 PM! 13 straight hours lost!
but I have to say it is worth it! game is amazing. and xbox 360 elite is well designed.

big plus for microsoft for device but huge minus for fees that allows you to play over the net with friends.. come on ms it is greedy!

and yeah I have 3pads!

I see meshes everywhere!

Huzza!! I did it!

I have learned how to create a mesh from .x file format! – now I only need to apply picking and I am good to go!

Mesh.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#pragma once
#ifndef MESH_H
#define MESH_H

#include <d3dx9 .h>
#include <vector>

class Mesh
{
   friend class MeshInstance;
public:
   Mesh();
   ~Mesh();
   Mesh(LPCSTR fName, IDirect3DDevice9* dev);
   HRESULT Load(LPCSTR fName, IDirect3DDevice9* Dev);
   void Render();
   void Release();

private:
   IDirect3DDevice9* m_pDevice;
   ID3DXMesh* m_pMesh;
   std::vector<idirect3dtexture9 *> m_textures;
   std::vector<d3dmaterial9> m_materials;
   D3DMATERIAL9 m_white;


};

class MeshInstance{
public:
   MeshInstance();
   MeshInstance(Mesh* meshPtr);
   void Render();

   void SetMesh(Mesh* m) { m_pMesh = m;}
   void SetPosition(D3DXVECTOR3 p) { m_pos = p; }
   void SetRotation(D3DXVECTOR3 r) { m_rot = r; }
   void SetScale(D3DXVECTOR3 s) { m_sca = s; }

private:
   Mesh* m_pMesh;
   D3DXVECTOR3 m_pos, m_rot, m_sca;

};

#endif

Mesh.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#include "Mesh.h"


Mesh::Mesh()
{
   m_pDevice = NULL;
   m_pMesh = NULL;
}

Mesh::Mesh(LPCSTR fName, IDirect3DDevice9* dev)
{
   m_pDevice = dev;
   m_pMesh = NULL;
   Load(fName, m_pDevice);
}

Mesh::~Mesh()
{
   Release();
}

HRESULT Mesh::Load(LPCSTR fName, IDirect3DDevice9* dev)
{
   m_pDevice = dev;

   //Set m_white material
   m_white.Ambient = m_white.Specular = m_white.Diffuse  = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
   m_white.Emissive = D3DXCOLOR(0.0f, 0.0f, 0.0f, 1.0f);
   m_white.Power = 1.0f;

   Release();

   //Load new m_pMesh
   ID3DXBuffer * adjacencyBfr = NULL;
   ID3DXBuffer * materialBfr = NULL;
   DWORD noMaterials = NULL;

   if(FAILED(D3DXLoadMeshFromX(fName, D3DXMESH_MANAGED, m_pDevice,   
                        &adjacencyBfr, &materialBfr, NULL,
                        &noMaterials, &m_pMesh)))
      return E_FAIL;

   D3DXMATERIAL *mtrls = (D3DXMATERIAL*)materialBfr->GetBufferPointer();

   for(int i=0;i< (int)noMaterials;i++)
   {
      //mtrls[i].MatD3D.Ambient = mt[i].MatD3D.Diffuse;
      m_materials.push_back(mtrls[i].MatD3D);

      if(mtrls[i].pTextureFilename != NULL)
      {
         char textureFileName[90];
         strcpy(textureFileName, "meshes/");
         strcat(textureFileName, mtrls[i].pTextureFilename);
         IDirect3DTexture9 * newTexture = NULL;
         D3DXCreateTextureFromFile(m_pDevice, textureFileName, &newTexture);       
         m_textures.push_back(newTexture);
      }
      else m_textures.push_back(NULL);
   }

   m_pMesh->OptimizeInplace(D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_COMPACT | D3DXMESHOPT_VERTEXCACHE,
                     (DWORD*)adjacencyBfr->GetBufferPointer(), NULL, NULL, NULL);

   adjacencyBfr->Release();
   materialBfr->Release();

   return S_OK;
}


void Mesh::Render()
{
   for(int i=0;i< (int)m_materials.size();i++)
   { 
      if(m_textures[i] != NULL)m_pDevice->SetMaterial(&m_white);
      else m_pDevice->SetMaterial(&m_materials[i]);
      m_pDevice->SetTexture(0,m_textures[i]);
      m_pMesh->DrawSubset(i);
   } 
}

void Mesh::Release()
{
   //Clear old mesh...
   if(m_pMesh != NULL)
   {
      m_pMesh->Release();
      m_pMesh = NULL;
   }

   //Clear textures and materials
   for(int i=0;i< (int)m_textures.size();i++)
      if(m_textures[i] != NULL)
         m_textures[i]->Release();

   m_textures.clear();
}

MeshInstance::MeshInstance()
{
m_pMesh = NULL;
   m_pos = m_rot = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
   m_sca = D3DXVECTOR3(1.0f, 1.0f, 1.0f);
}

MeshInstance::MeshInstance(Mesh* meshPtr)
{
   m_pMesh = meshPtr;
   m_pos = m_rot = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
   m_sca = D3DXVECTOR3(1.0f, 1.0f, 1.0f);
}

void MeshInstance::Render()
{
if(m_pMesh != NULL)
   {
      D3DXMATRIX p, r, s;
      D3DXMatrixTranslation(&p, m_pos.x, m_pos.y, m_pos.z);
      D3DXMatrixRotationYawPitchRoll(&r, m_rot.y, m_rot.x, m_rot.z);
      D3DXMatrixScaling(&s, m_sca.x, m_sca.y, m_sca.z);
     
      D3DXMATRIX world = s * r * p;
      m_pMesh->m_pDevice->SetTransform(D3DTS_WORLD, &world);

      m_pMesh->Render();
   }
}

ObjectClass.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#ifndef OBJECTCLASS_H
#define OBJECTCLASS_H

#include <vector>
#include "debug.h"
#include "mesh.h"

HRESULT LoadObjectResources(IDirect3DDevice9* Device);
void UnloadObjectResources();

#define OBJ_TREE 0
#define OBJ_STONE 1

class ObjectClass{
   public:
      ObjectClass();
      ObjectClass(int t, D3DXVECTOR3 pos, D3DXVECTOR3 rot, D3DXVECTOR3 sca);
      void Render();

   private:
      MeshInstance m_meshInstance;
      int m_type;
};


#endif

ObjectClass.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include "ObjectClass.h"

std::vector<mesh *> objectMeshes;

HRESULT LoadObjectResources(IDirect3DDevice9* device)
{
   Mesh* one = new Mesh("meshes/one.x", device);
   objectMeshes.push_back(one);

   Mesh* two= new Mesh("meshes/two.x", device);
   objectMeshes.push_back(two);

   return S_OK;
}

void UnloadObjectResources()
{
   for(int i=0; i< (int)objectMeshes.size(); i++)
      objectMeshes[i]->Release();

   objectMeshes.clear();
}

ObjectClass::ObjectClass()
{
   m_type =0;
}

ObjectClass::ObjectClass(int t, D3DXVECTOR3 pos, D3DXVECTOR3 rot, D3DXVECTOR3 sca)
{
   m_type = t;
   m_meshInstance.SetPosition(pos);
   m_meshInstance.SetRotation(rot);
   m_meshInstance.SetScale(sca);
   m_meshInstance.SetMesh(objectMeshes[m_type]);
}

void ObjectClass::Render()
{
   m_meshInstance.Render();
}

usage is really simple:

in our main program class game/application/app you name it.

we need to add include

1
#include "ObjectClass.h"

then in Init method for your program place

1
   LoadObjectResources(m_pDevice);

it is loading resources do our device.

to add object call

1
2
3
   AddObject(0, INTPOINT(x, y)); //objec one
            else if(m_pHeightMap->GetHeight(x, y) >= 1.0f && hm3.GetHeight(x, y) > 0.9f && rand()%20 == 0)
   AddObject(1, INTPOINT(x, y)); //object two

I am calling it in terrain class.

at the moment placed randomly

1
2
3
4
5
6
7
8
9
10
11
void Terrain::AddObject(int type, INTPOINT mappos)
{
   D3DXVECTOR3 pos = D3DXVECTOR3((float)mappos.x, m_pHeightMap->GetHeight(mappos), (float)-mappos.y);
   D3DXVECTOR3 rot = D3DXVECTOR3((rand()%1000 / 1000.0f) * 0.13f, (rand()%1000 / 1000.0f) * 3.0f, (rand()%1000 / 1000.0f) * 0.13f);

   float sca_xz = (rand()%1000 / 1000.0f) * 0.5f + 0.5f;
   float sca_y = (rand()%1000 / 1000.0f) * 1.0f + 0.5f;
   D3DXVECTOR3 sca = D3DXVECTOR3(sca_xz, sca_y, sca_xz);

   m_objects.push_back(ObjectClass(type, pos, rot, sca));
}

Tomorrows plans.. picking!!
and come on! 374 FPS ain’t bad!

Frame Animation manager – 2D

This week at university we have covered 2D frame animation – simple idea every frame is separate image.

what we need are two classes:

  • Animation
  • AnimationManager

Animation.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#pragma once
#ifndef ANIMATION_H
#define ANIMATION_H

#include <d3d9 .h>

class Animation
{
private:
   IDirect3DTexture9* texture;
   int frameWidth;
   int frameHeight;
   int startFrame;
   int endFrame;
   int frameCount;
   float frameTime;
   bool isLooping;

public:
   Animation(IDirect3DTexture9* texture);
   Animation(IDirect3DTexture9* texture, float frameTime, bool isLooping);
   Animation(IDirect3DTexture9* texture, float frameTime, bool isLooping, int startFrame, int endFrame,int frameWidth, int frameHeight);
   ~Animation();

   void setTexture(IDirect3DTexture9* newTexture){ texture = newTexture; }
   IDirect3DTexture9* getTexture(){ return texture;}

   void setFrameTime(float newFrameTime){ frameTime = newFrameTime;};
   float getFrameTime(){return frameTime;}

   void setIsLooping(bool newIsLooping){ isLooping = newIsLooping; }
   bool getIsLooping() { return isLooping; }

   void setStartFrame(int newStartFrame) { startFrame = newStartFrame;}
   int getStartFrame() { return startFrame;}

   void setEndFrame(int newEndFrame) { endFrame = newEndFrame; }
   int getEndFrame() { return endFrame; }

   void setFrameCount(int newFrameCount) { frameCount = newFrameCount; }
   int getFrameCount() { return frameCount;}

   void setFrameWidth(int newFrameWidht) { frameWidth = newFrameWidht; }
   int getFrameWidth() { return frameWidth; }

   void setFrameHeight(int newFrameHeight) { frameHeight = newFrameHeight; }
   int getFrameHeight() { return frameHeight; }

};
#endif

as we can see just bunch of attributes and geters/seters
Animation.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include "Animation.h"

Animation::Animation(IDirect3DTexture9* texture): texture(texture)
{
   frameTime = 1.0f/ 30.0f;
   isLooping = true;
   D3DSURFACE_DESC desc;
   texture->GetLevelDesc(0, &desc);
   startFrame = 0;
   endFrame = desc.Width / desc.Height;
   frameCount = endFrame - startFrame;
   frameWidth = desc.Height;
   frameHeight = desc.Height;
}

Animation::Animation(IDirect3DTexture9* texture, float frameTime, bool isLooping)
: texture(texture), frameTime(frameTime),isLooping(isLooping)
{
   D3DSURFACE_DESC desc;
   texture->GetLevelDesc(0, &desc);
   startFrame = 0;
   endFrame = desc.Width / desc.Height;
   frameCount = endFrame - startFrame;
   frameWidth = desc.Height;
   frameHeight = desc.Height;
}
Animation::Animation(IDirect3DTexture9* texture, float frameTime, bool isLooping, int startFrame, int endFrame,int frameWidth, int frameHeight)
: texture(texture),
frameTime(frameTime),
isLooping(isLooping),
startFrame(startFrame),
endFrame(endFrame),
frameWidth(frameWidth),
frameHeight(frameHeight)
{
   frameCount = endFrame - startFrame;
}



Animation::~Animation()
{
}

AnimationManager.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#pragma once
#ifndef ANIMATIONPLAYER_H
#define ANIMATIONPLAYER_H

#include "Animation.h"
#include </d3d9><d3d9 .h>
#include <d3dx9 .h>
#include <string>
#include <map>

class AnimationPlayer
{
private:
   Animation* currentAnimation;
   std::string playing;
   std::map<std::string , Animation*> animations;
   int frameIndex;
   float time;
public:
   AnimationPlayer();
   void playAnimation(std::string name);
   void addAnimation(std::string name, Animation* anim);
   void update(float frameTime);
   void draw(ID3DXSprite* spriteBatch, D3DXVECTOR3 position, D3DXMATRIX transform);

   ~AnimationPlayer();

   Animation* getCurrentAnimation(){return currentAnimation;}

   std::string getPlaying(){ return playing; }
   int getFrameIndes() { return frameIndex;}
};

#endif

Animation manager keeps all animations in map, pointer to current animation, playing are easy to guess.

same with methods: playAnimation, addAnimation, draw and getCurrentAnimation but why there is an update method?
well code should make that clear.

AnimationManager.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#include "AnimationPlayer.h"

AnimationPlayer::AnimationPlayer()
{
}

AnimationPlayer::~AnimationPlayer()
{
   std::map</std::string><std::string , Animation*>::iterator iter = animations.begin();
   for(; iter != animations.end(); ++iter)
   {
      delete iter->second;
   }
   animations.clear();
}

void AnimationPlayer::playAnimation(std::string name)
{
   Animation* anim = animations[name];
   if(anim == currentAnimation)
      return;

   currentAnimation = anim;
   playing = name;
   frameIndex = 0;
   time = 0.0f;
}

void AnimationPlayer::update(float frameTime)
{
   if(currentAnimation == 0)
      return;

   time += frameTime;

   while(time > currentAnimation->getFrameTime())
   {
      time -=currentAnimation->getFrameTime();
      if(currentAnimation->getIsLooping())
         frameIndex = (++frameIndex) % currentAnimation->getFrameCount();
      else
         frameIndex = min(++frameIndex, currentAnimation->getFrameCount() - 1);
   }

}

void AnimationPlayer::draw(ID3DXSprite* sprite, D3DXVECTOR3 position, D3DXMATRIX transform)
{
   if(currentAnimation == 0)
      return;
   D3DXMATRIX currentTransform;
   sprite->GetTransform(&currentTransform);
   sprite->SetTransform(&transform);

   int frameX = (frameIndex + currentAnimation->getStartFrame());
   frameX *= currentAnimation->getFrameWidth();

   int frameY = (frameIndex + currentAnimation->getStartFrame());
   frameY *= currentAnimation->getFrameWidth();
   frameY %= currentAnimation->getFrameWidth();

   RECT rect;
   rect.left = frameX;
   rect.right = frameX + currentAnimation->getFrameWidth();
   rect.top = frameY;
   rect.bottom = frameY + currentAnimation->getFrameHeight();

// sprite->Draw(currentAnimation->getTexture(), &rect, 0, &position - Level::getOffset(), D3DCOLOR_XRGB(255,255,255));
   sprite->Draw(currentAnimation->getTexture(), &rect, 0, &position, D3DCOLOR_XRGB(255,255,255));
   sprite->SetTransform(&currentTransform);

}

I am bit worried because all stuff we do leads us – students to develop 2D based platformer game.. next week we are going to do simple 2d physics and particles.. which is not really necessary in my game.

but good news is.. I have managed to get back on track with my 3D Zombeesh.. some tech demo should be ready by end of the week!! can’t wait!

PlayerManager – prototype class

Just a quick note. I have managed to write Player Manager class which is kind a prototype.. the two issues that I am having are how to get an offset of a map.. if I am trying to set up offset to static DXDVECTOR3 variable inside Level class linker is complaining, passing as attribute well it is a option but then I need to modify other classes.

Second problem is click in a frame. actually I have just figured this out :).. wow sometimes one sec break and step back can do the trick.

Anyway deep beta presents PlayerManager prototype class – probably it will be totally modified but as far as now I have something like that:

PlayerManager.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#pragma once
#ifndef PLAYERMANAGER_H
#define PLAYERMANAGER_H

#include "Entity.h"
#include <map>
#include "Level.h"
#include <d3dx9 .h>


class PlayerManager
{

private:
   //players entities
   static std::map<int , Entity*> playersEntities;
   static std::map</int><int , Entity*> playersSelectedEntities;
   
public:
   static PlayerManager* instance;
   static void init();
   static void registerPlayersEntity(Entity* playersEntity); // called in players unity type constructor
   static void removePlayersEntity(Entity* playersEntity);
   static Entity* getPlayersEntity(int id);
   static void clearSelected();
   static void addEntityToSelected(POINT mousePosition);


   PlayerManager();
   ~PlayerManager();
};

#endif

PlayerManager.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#include "PlayerManager.h"
#include "Collision.h"


PlayerManager* PlayerManager::instance =0;
std::map</int><int , Entity*> PlayerManager::playersEntities = std::map</int><int , Entity*>();
std::map</int><int , Entity*> PlayerManager::playersSelectedEntities = std::map</int><int , Entity*>();

PlayerManager::PlayerManager()
{
}

void PlayerManager::init()
{
   PlayerManager::instance = new PlayerManager();
}

PlayerManager::~PlayerManager()
{
   {
      //clear selected units list
      std::map</int><int ,Entity*>::iterator iter = playersSelectedEntities.begin();
      for(; iter != playersSelectedEntities.end(); ++iter)
      {
         delete iter->second;
         iter->second = 0;
      }
      playersSelectedEntities.clear();
   }
   {
      playersEntities.clear();
   }
}


//register entity in players list
void PlayerManager::registerPlayersEntity(Entity* entity)
{
   //register entity called only once and after registration in entity manager
   // we have entity ID and I am pretty sure it will not dublicate.
   playersEntities[entity->getID()] = entity;
}


void PlayerManager::removePlayersEntity(Entity* entity)
{
   //removes selecred entity from players entities lise
   std::map</int><int , Entity*>::iterator iter = playersEntities.find(entity->getID());
   if(iter != playersEntities.end())
      playersEntities.erase(iter);
}



Entity* PlayerManager::getPlayersEntity(int id)
{
   //returns pointer to entity defined by id
   std::map</int><int , Entity*>::iterator iter = playersEntities.find(id);
   if(iter != playersEntities.end())
      return iter->second;
   return 0;
}

void PlayerManager::addEntityToSelected(POINT mousePosition){
   
   D3DXVECTOR3 position(0.0f,0.0f,0.0f);
   float radius = 1.0f;

   D3DXVECTOR3 mPosition(mousePosition.x, mousePosition.y, 0.0f);

   Circle mouseCircle = {mPosition, radius };
   Circle unitCircle = {position, radius };
   //CollisionResults collisionResult;

   mouseCircle.position.x = mousePosition.x; // need to figure out how to apply offset
   mouseCircle.position.y = mousePosition.y;
   mouseCircle.position.z = 0.0f;
   mouseCircle.radius = 2.0f;
   
   std::map</int><int , Entity*>::iterator iter = playersEntities.begin();
   for(; iter != playersEntities.end(); ++iter)
   {
      unitCircle.position = iter->second->getPosition();
      unitCircle.radius = 20.0f; // need to set this global instead of calculated based on number images etc like TILEBASEWIDTH or something
      CollisionResults collisionResult = TestCollisionCircle(mouseCircle, unitCircle);
      //iter->second->update(frameTime);
      if(collisionResult == OVERLAPPING)
      {
         std::cout < < "AWESOME";
      }else {
         PlayerManager::clearSelected();
         std::cout << "NOT";
      }
   }

}

void PlayerManager::clearSelected()
{
   std::map<int, Entity*>::iterator iter = playersSelectedEntities.begin();
   for(; iter != playersSelectedEntities.end(); ++iter)
   {
      if(iter->second)
      {
         delete iter->second;
         iter->second = 0;
      }
   }
   playersSelectedEntities.clear();
   
}