//---------------------------------------------------------
CSG_Shape * CSG_PointCloud::Get_Shape(TSG_Point Point, double Epsilon)
{
CSG_Rect r(Point.x - Epsilon, Point.y - Epsilon, Point.x + Epsilon, Point.y + Epsilon);
if( r.Intersects(Get_Extent()) != INTERSECTION_None )
{
int iPoint = -1;
double iDistance = -1.0;
for(int iRecord=0; iRecord<Get_Count(); iRecord++)
{
Set_Cursor(iRecord);
if( r.Contains(Get_X(), Get_Y()) )
{
if( iPoint < 0 || iDistance > SG_Get_Distance(Point.x, Point.y, Get_X(), Get_Y()) )
{
iPoint = iRecord;
iDistance = SG_Get_Distance(Point.x, Point.y, Get_X(), Get_Y());
}
}
}
if( iPoint >= 0 )
{
return( CSG_Shapes::Get_Shape(iPoint) );
}
}
return( NULL );
}
// Cross product. Finds perpendicular direction to plane defined by 2. Also useful for lighting and angles
Direction Direction::Cross(const Direction& direction) const
{
return Direction::Coordinates(
Get_Y() * direction.Get_Z() - Get_Z() * direction.Get_Y(),
Get_Z() * direction.Get_X() - Get_X() * direction.Get_Z(),
Get_X() * direction.Get_Y() - Get_Y() * direction.Get_X());
}
//---------------------------------------------------------
const CSG_Rect & CSG_PointCloud::Get_Selection_Extent(void)
{
if( Get_Selection_Count() > 0 && Set_Cursor(Get_Selection_Index(0)) )
{
TSG_Rect r;
r.xMin = r.xMax = Get_X();
r.yMin = r.yMax = Get_Y();
for(size_t i=1; i<Get_Selection_Count(); i++)
{
if( Set_Cursor(Get_Selection_Index(i)) )
{
if( Get_X() < r.xMin ) r.xMin = Get_X();
else if( Get_X() > r.xMax ) r.xMax = Get_X();
if( Get_Y() < r.yMin ) r.yMin = Get_Y();
else if( Get_Y() > r.yMax ) r.yMax = Get_Y();
}
}
m_Extent_Selected.Assign(r);
}
else
{
m_Extent_Selected.Assign(0.0, 0.0, 0.0, 0.0);
}
return( m_Extent_Selected );
}
//---------------------------------------------------------
const CSG_Rect & CSG_PointCloud::Get_Selection_Extent(void)
{
if( m_nSelected > 0 && Set_Cursor(m_Selected[0]) )
{
TSG_Rect r;
r.xMin = r.xMax = Get_X();
r.yMin = r.yMax = Get_Y();
for(int i=1; i<m_nSelected; i++)
{
if( Set_Cursor(m_Selected[i]) )
{
if( Get_X() < r.xMin ) r.xMin = Get_X(); else if( Get_X() > r.xMax ) r.xMax = Get_X();
if( Get_Y() < r.yMin ) r.yMin = Get_Y(); else if( Get_Y() > r.yMax ) r.yMax = Get_Y();
}
}
m_Extent_Selected.Assign(r);
}
else
{
m_Extent_Selected.Assign(0.0, 0.0, 0.0, 0.0);
}
return( m_Extent_Selected );
}
void Monster::Rand_Move()
{
int idx[4] = { -1,0,1,0 };
int idy[4] = { 0,-1,0,1 };
int rand_dir = Singleton::getSingleton().Rand_Dir();
int temp = Singleton::getSingleton().Search(Get_X() + idx[rand_dir], Get_Y() + idy[rand_dir]);
if (temp == -1) Set_X(Get_X() + idx[rand_dir]), Set_Y(Get_Y() + idy[rand_dir]);
else if (Singleton::getSingleton().obj_list[temp]->Get_Type() == T_item)
{
Set_X(Get_X() + idx[rand_dir]), Set_Y(Get_Y() + idy[rand_dir]);
Singleton::getSingleton().Delete(temp);
Set_Have_Bomb(true);
}
else
{
bool Is_Move = false;
for (int i = 0; i < 4; i++)if (Singleton::getSingleton().Search(Get_X() + idx[i], Get_Y() + idy[i]) == -1)Is_Move = true;
if (Is_Move) Rand_Move();
}
}
//---------------------------------------------------------
bool CSG_PointCloud::Select(TSG_Rect Extent, bool bInvert)
{
if( !bInvert ) // clear selection
{
Select(-1, false);
}
if( Get_Extent().Intersects(Extent) != INTERSECTION_None )
{
for(int i=0; i<Get_Count(); i++)
{
Set_Cursor(i);
if( Extent.xMin <= Get_X() && Get_X() <= Extent.xMax
&& Extent.yMin <= Get_Y() && Get_Y() <= Extent.yMax )
{
Select(i, true);
}
}
}
return( Get_Selection_Count() > 0 );
}
void Monster::Attack()
{
int idx[4] = { 0,-1,0,1 };
int idy[4] = { -1,0,1,0 };
for (int i = 0; i < 4; i++)
{
int temp = Singleton::getSingleton().Search(Get_X() + idx[i], Get_Y() + idy[i]);
if (temp == -1) continue;
if (Singleton::getSingleton().obj_list[temp]->Get_Type() == T_player)
{
Singleton::getSingleton().Lose();
Singleton::getSingleton().End_Flag = true;
}
}
}
void Monster::Update()
{
Set_Frame_Cnt(Get_Frame_Cnt() + 1);
Get_Frame_Cnt() % 2 == 0 ? Set_Shape(MONSTER_EMPTY) : Set_Shape(MONSTER_FILL);
Rand_Move();
Attack();
if (Get_Frame_Cnt() % Bomb_Put_delay == 0 && Get_Have_Bomb())
{
int idx[4] = { -1,0,1,0 };
int idy[4] = { 0,-1,0,1 };
int rand_dir = Singleton::getSingleton().Rand_Dir();
int n_x = Get_X() + idx[rand_dir];
int n_y = Get_Y() + idy[rand_dir];
int temp = Singleton::getSingleton().Search(n_x, n_y);
if (temp == -1) Singleton::getSingleton().obj_list.push_back(new Bomb(n_x, n_y, T_monster));
else if (Singleton::getSingleton().obj_list[temp]->Get_Type() == T_item)
{
Singleton::getSingleton().Delete(temp);
Singleton::getSingleton().obj_list.push_back(new Bomb(n_x, n_y, T_monster));
}
}
}
void CrossHairClass::Update_Calibration(float tx,float ty,float area)
{
// two point calibration. We know that the area of the target when we are near the goal is 0.033
// The area of the target when we're far from the goal is 0.01
// We're going to maintain a line segment for the CrossHairY defined by two points:
// (0.033,m_CrossHairYNear) (0.01,m_CrossHairYFar)
// When we get a calibration request, we decide which point we are closer to and update that
// point, proportionally to the current area.
// if we are closer to 'AREA_NEAR' we update YNear, otherwise update YFar
if (area > AREA_MID)
{
//Updating YNear, assume YFar is fixed, compute YNear which would give us ty,area
// (YFar - YNear*) / (AREA_FAR - AREA_NEAR) == (YFar - ty) / (AREA_FAR - area)
float slope = (YFar - ty) / (AREA_FAR - area);
YNear = -slope * (AREA_FAR - AREA_NEAR) + YFar;
slope = (XFar - tx) / (AREA_FAR - area);
XNear = -slope * (AREA_FAR - AREA_NEAR) + XFar;
}
else
{
//Updating YFar. assume YNear is fixed, compute YFar which would give us ty,area
// (YFar* - YNear) / (AREA_FAR - AREA_NEAR) == (ty - YNear) / (area - AREA_NEAR)
float slope = (ty - YNear) / (area - AREA_NEAR);
YFar = slope * (AREA_FAR - AREA_NEAR) + YNear;
slope = (tx - XNear) / (area - AREA_NEAR);
XFar = slope * (AREA_FAR - AREA_NEAR) + XNear;
}
// double check
float xcheck = Get_X(area);
float ycheck = Get_Y(area);
printf("Calibrated! XIn: %f XCheck: %f YIn: %f YCheck: %f\r\n",tx,xcheck,ty,ycheck);
}
void C_Player1::Move()
{
//MOVE PLAYER/////////////////////
//LIMITS to keep things from getting stupid
if(Get_xSpeed() > m_xMaxSpeed)
Set_xSpeed(m_xMaxSpeed);
if(Get_xSpeed() < -m_xMaxSpeed)
Set_xSpeed(-m_xMaxSpeed);
if(Get_ySpeed() > m_yMaxSpeed)
Set_ySpeed(m_yMaxSpeed);
if(Get_ySpeed() < -m_yMaxSpeed)
Set_ySpeed(-m_yMaxSpeed);
//Update the position TODO: Make variable 'requested position' for future collision checking
Set_X(Get_X() + Get_xSpeed());
Set_Y(Get_Y() + Get_ySpeed());
//Window collision
if(Get_X() + Get_xSpeed() < 0)
Set_X(0);
if(Get_X() + Get_xSpeed() > LEVEL_WIDTH - PLAYER_WIDTH)//factor in player height/width TODO
m_X = (m_X - m_xSpeed);
if(Get_Y() + Get_ySpeed() < 0)
Set_Y(0);
if(Get_Y() + Get_ySpeed() > LEVEL_HEIGHT - PLAYER_HEIGHT)
m_Y = (m_Y - m_ySpeed);
//If there's a sword swing, move the shield
for(int i = 0; i < Weapons.size(); i++)
if(Weapons[i]->Get_weaponType() == SWORD)//if sword found
Controls.key_S = true;//simulate shield
//***************************************************ZONING STUFF /Scroll the screen and load in new zones when player hits an edge
// 16 X 8 sized map!!!!
if(m_Y < 10 && TileManager.Get_transitionDirection() == -1)//ZONE UP if not already zoning // THE -1 means no transition is happening
if(TileManager.Get_mapPosition().y != 1){//if not at the top
TileManager.MapTransition(UP);
SDL_Rect updateMapPosition = {TileManager.Get_mapPosition().x, TileManager.Get_mapPosition().y - 1};
TileManager.Set_mapPosition(updateMapPosition);
}
if(m_Y > 930 && TileManager.Get_transitionDirection() == -1)//ZONE DOWN if not already zoning
if(TileManager.Get_mapPosition().y != 4){//if not at the bottom (16 x 8 map)
TileManager.MapTransition(DOWN);
SDL_Rect updateMapPosition = {TileManager.Get_mapPosition().x, TileManager.Get_mapPosition().y + 1};
TileManager.Set_mapPosition(updateMapPosition);
}
if(m_X < 10 && TileManager.Get_transitionDirection() == -1)//zone LEFT if not already zoning
if(TileManager.Get_mapPosition().x != 1){//if not at far left
TileManager.MapTransition(LEFT);
SDL_Rect updateMapPosition = {TileManager.Get_mapPosition().x - 1, TileManager.Get_mapPosition().y};
TileManager.Set_mapPosition(updateMapPosition);
}
if(m_X > 1250 && TileManager.Get_transitionDirection() == -1)//zone RIGHT if not already zoning
if(TileManager.Get_mapPosition().x != 8){//if not at far right
TileManager.MapTransition(RIGHT);
SDL_Rect updateMapPosition = {TileManager.Get_mapPosition().x + 1, TileManager.Get_mapPosition().y};
TileManager.Set_mapPosition(updateMapPosition);
}
if(TileManager.Get_transitionDirection() == UP){
m_Y = TileManager.Get_offsetCounterY();
if(m_Y > SCREEN_HEIGHT - PLAYER_HEIGHT )//keep player from going into another transition
m_Y = LEVEL_HEIGHT - PLAYER_HEIGHT - 11;
}
if(TileManager.Get_transitionDirection() == DOWN){
m_Y = LEVEL_HEIGHT + TileManager.Get_offsetCounterY();
if(m_Y < LEVEL_HEIGHT - SCREEN_HEIGHT + PLAYER_HEIGHT/2)
m_Y = 11;
}
if(TileManager.Get_transitionDirection() == LEFT){
m_X = TileManager.Get_offsetCounterX();
if(m_X > SCREEN_WIDTH - PLAYER_WIDTH/2)
m_X = LEVEL_WIDTH - PLAYER_WIDTH -11;
}
if(TileManager.Get_transitionDirection() == RIGHT){
m_X = LEVEL_WIDTH + TileManager.Get_offsetCounterX();
if(m_X < LEVEL_WIDTH - SCREEN_WIDTH + PLAYER_WIDTH/3)
m_X = 11;
}
}
//---------------------------------------------------------
bool CSG_PRQuadTree_Node::Add_Point(double x, double y, double z)
{
if( Contains(x, y) )
{
if( has_Statistics() )
{
Get_X()->Add_Value(x);
Get_Y()->Add_Value(y);
Get_Z()->Add_Value(z);
}
int i = y < m_yCenter ? (x < m_xCenter ? 0 : 3) : (x < m_xCenter ? 1 : 2);
//-------------------------------------------------
if( m_pChildren[i] == NULL )
{
double Size = 0.5 * m_Size;
switch( i )
{
case 0: m_pChildren[i] = new CSG_PRQuadTree_Leaf(m_xCenter - Size, m_yCenter - Size, Size, x, y, z); break;
case 1: m_pChildren[i] = new CSG_PRQuadTree_Leaf(m_xCenter - Size, m_yCenter + Size, Size, x, y, z); break;
case 2: m_pChildren[i] = new CSG_PRQuadTree_Leaf(m_xCenter + Size, m_yCenter + Size, Size, x, y, z); break;
case 3: m_pChildren[i] = new CSG_PRQuadTree_Leaf(m_xCenter + Size, m_yCenter - Size, Size, x, y, z); break;
}
return( true );
}
//-----------------------------------------------------
if( m_pChildren[i]->is_Leaf() )
{
CSG_PRQuadTree_Leaf *pLeaf = m_pChildren[i]->asLeaf();
if( x != pLeaf->Get_X() || y != pLeaf->Get_Y() )
{
if( has_Statistics() )
{
m_pChildren[i] = new CSG_PRQuadTree_Node_Statistics (pLeaf);
}
else
{
m_pChildren[i] = new CSG_PRQuadTree_Node (pLeaf);
}
((CSG_PRQuadTree_Node *)m_pChildren[i])->Add_Point(x, y, z);
}
else
{
if( !pLeaf->has_Statistics() )
{
m_pChildren[i] = new CSG_PRQuadTree_Leaf_List(pLeaf->m_xCenter, pLeaf->m_yCenter, pLeaf->m_Size, x, y, pLeaf->Get_Z());
delete(pLeaf);
}
((CSG_PRQuadTree_Leaf_List *)m_pChildren[i])->Add_Value(z);
}
return( true );
}
//-------------------------------------------------
// if( m_pChildren[i]->is_Node() )
{
return( ((CSG_PRQuadTree_Node *)m_pChildren[i])->Add_Point(x, y, z) );
}
}
return( false );
}
void Direction::Set_Z(const float z)
{
Set_Coordinates(Get_X(), Get_Y(), z);
}
// Add values to the coordinates of the direction
void Direction::Add_Coordinates(const float x, const float y, const float z)
{
Set_Coordinates(Get_X() + x, Get_Y() + y, Get_Z() + z);
return;
}
//---------------------------------------------------------
CSG_Shape * CSG_PointCloud::_Set_Shape(int iPoint)
{
SG_UI_Progress_Lock(true);
CSG_Shape *pShape = m_Shapes.Get_Shape(0);
if( pShape->is_Modified() && m_Shapes_Index >= 0 && m_Shapes_Index < Get_Count() )
{
m_Cursor = m_Points[m_Shapes_Index];
for(int i=0; i<Get_Field_Count(); i++)
{
switch( Get_Field_Type(i) )
{
default:
Set_Value(i, pShape->asDouble(i));
break;
case SG_DATATYPE_Date:
case SG_DATATYPE_String:
Set_Value(i, pShape->asString(i));
break;
}
}
Set_Value(0, pShape->Get_Point(0).x);
Set_Value(1, pShape->Get_Point(0).y);
Set_Value(2, pShape->Get_Z (0) );
}
if( iPoint >= 0 && iPoint < Get_Count() )
{
if(1|| iPoint != m_Shapes_Index )
{
m_Cursor = m_Points[iPoint];
pShape->Set_Point(Get_X(), Get_Y(), 0, 0);
pShape->Set_Z (Get_Z() , 0, 0);
for(int i=0; i<Get_Field_Count(); i++)
{
switch( Get_Field_Type(i) )
{
default:
pShape->Set_Value(i, Get_Value(i));
break;
case SG_DATATYPE_Date:
case SG_DATATYPE_String:
{
CSG_String s;
Get_Value(i, s);
pShape->Set_Value(i, s);
}
break;
}
}
m_Shapes_Index = iPoint;
pShape->m_Index = iPoint;
pShape->Set_Selected(is_Selected(iPoint));
}
m_Shapes.Set_Modified(false);
SG_UI_Progress_Lock(false);
return( pShape );
}
m_Shapes_Index = -1;
SG_UI_Progress_Lock(false);
return( NULL );
}
void C_Player1::Render()
{
SDL_Rect offset = {Get_X() - Camera.Get_XYWH()->x, Get_Y() - Camera.Get_XYWH()->y, PLAYER_WIDTH, PLAYER_HEIGHT};
Uint32 color = SDL_MapRGB(screen->format, 255, 0, 0);
SDL_FillRect(screen, &offset, color);
}
void Direction::Set_Y(const float y)
{
Set_Coordinates(Get_X(), y, Get_Z());
}
// Find the distance between this direction and another
Direction Direction::Distance(const Direction& to) const
{
Direction copy = to;
copy.Add_Coordinates(-1 * Get_X(), -1 * Get_Y(), -1 * Get_Z());
return (copy);
}
// Dot product. Useful for lighting
float Direction::Dot(const Direction& direction) const
{
float answer = (Get_X() * direction.Get_X()) + (Get_Y() * direction.Get_Y()) + (Get_Z() * direction.Get_Z());
return (answer);
}
// Makes a vertex with the X, Y, and Z values
glm::vec3 Direction::To_Vertex(void) const
{
return (glm::vec3(Get_X(), Get_Y(), Get_Z()));
}