SnipeRifle Class Reference

#include <snipe_rifle.h>

Inheritance diagram for SnipeRifle:

[legend]Collaboration diagram for SnipeRifle:

[legend]List of all members.

Public Member Functions
	SnipeRifle ()
void	SignalProjectileGhostState ()
void	DrawBeam ()
void	Draw ()
Protected Member Functions
bool	p_Shoot ()
void	p_Deselect ()
WeaponProjectile *	GetProjectileInstance ()
Private Member Functions
bool	ComputeCrossPoint (bool force)
Private Attributes
double	last_angle
Point2i	last_rifle_pos
Point2i	laser_beam_start
Point2i	targeted_point
bool	targeting_something
Sprite *	m_laser_image
Color	laser_beam_color

---

Detailed Description

Definition at line 38 of file snipe_rifle.h.

---

Constructor & Destructor Documentation

SnipeRifle::SnipeRifle

(

)

Definition at line 53 of file snipe_rifle.cpp.

                       : WeaponLauncher(WEAPON_SNIPE_RIFLE,"snipe_rifle", new ExplosiveWeaponConfig())
{
  m_name = _("Sniper Rifle");

  last_angle = 0.0;
  targeting_something = false;
  m_laser_image = new Sprite(resource_manager.LoadImage(weapons_res_profile,m_id+"_laser"));
  m_weapon_fire = new Sprite(resource_manager.LoadImage(weapons_res_profile,m_id+"_fire"));
  m_weapon_fire->EnableRotationCache(32);
  laser_beam_color = resource_manager.LoadColor(weapons_res_profile,m_id+"_laser_color");

  ReloadLauncher();
}

Here is the call graph for this function:

---

Member Function Documentation

bool SnipeRifle::ComputeCrossPoint

(

bool

force

)

[private]

Definition at line 93 of file snipe_rifle.cpp.

{
  // Did the current character is moving ?
  Point2i pos = GetGunHolePosition();
  double angle = ActiveCharacter().GetFiringAngle();
  if ( !force && last_rifle_pos == pos && last_angle == angle ) return targeting_something;
  else {
    last_rifle_pos=pos;
    last_angle=angle;
  }

  // Equation of movement : y = ax + b
  double a, b;
  a = sin(angle) / cos(angle);
  b = pos.y - ( a * pos.x );
  Point2i delta_pos, size, start_point;
  start_point = pos;
  uint distance = 0;
  targeting_something = false;
  // While test is not finished
  while( distance < SNIPE_RIFLE_MAX_BEAM_SIZE ){
    // going upwards ( -3pi/4 < angle <-pi/4 )
    if (angle < -0.78 && angle > -2.36){
      pos.x = (int)((pos.y-b)/a);       //Calculate x
      delta_pos.y = -1;                   //Increment y
    // going downwards ( 3pi/4 > angle > pi/4 )
    } else if (angle > 0.78 && angle < 2.36){
      pos.x = (int)((pos.y-b)/a);       //Calculate x
      delta_pos.y = 1;                    //Increment y
    // else going at right or left
    } else {
      pos.y = (int)((a*pos.x) + b);   //Calculate y
      delta_pos.x = ActiveCharacter().GetDirection();   //Increment x
    }
    // start point of the laser beam
    if ( distance < SNIPE_RIFLE_BEAM_START ) laser_beam_start = pos;

    // the point is outside the map
    if ( world.EstHorsMondeX(pos.x) || world.EstHorsMondeY(pos.y) ) break;

    // is there a collision ??
    if ( distance > 30 && !projectile->IsInVacuumXY( pos )){
      targeting_something = true;
      break;
    }
    pos += delta_pos;
    distance = (int) start_point.Distance(pos);
  }
  targeted_point=pos;
  return targeting_something;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SnipeRifle::Draw

(

)

[virtual]

Reimplemented from WeaponLauncher.

Definition at line 197 of file snipe_rifle.cpp.

{
  WeaponLauncher::Draw();
  if( GameLoop::GetInstance()->ReadState() != GameLoop::PLAYING || IsActive() ) return;
  ComputeCrossPoint();
  DrawBeam();
  // Draw the laser impact
  if( targeting_something ) m_laser_image->Draw(targeted_point - (m_laser_image->GetSize()/2));
}

Here is the call graph for this function:

void SnipeRifle::DrawBeam

(

)

Definition at line 151 of file snipe_rifle.cpp.

{
  Point2i pos1 = laser_beam_start - camera.GetPosition();
  Point2i pos2 = targeted_point - camera.GetPosition();
  AppWormux::GetInstance()->video.window.AALineColor(pos1.x, pos2.x, pos1.y, pos2.y, laser_beam_color);

  // Set area of the screen to be redrawn:
  // Splited into little rectangles to avoid too large area of redraw
  float redraw_size = 20.0;
  float dst = laser_beam_start.Distance(targeted_point);
  Point2f pos = Point2f((float)laser_beam_start.x, (float)laser_beam_start.y);
  Point2f delta = ( Point2f((float)targeted_point.x, (float)targeted_point.y) - pos ) * redraw_size / dst;
  Point2i delta_i((int)delta.x, (int)delta.y);

  if(delta_i.x < 0) delta_i.x = - delta_i.x; // the Map::ToRedraw method doesn't support negative rectangles
  if(delta_i.y < 0) delta_i.y = - delta_i.y;
  delta_i.x += 6; // We have to increase the size of the rectangle so the corner of the rectangles overlaps
  delta_i.y += 6;

  int i = 0;
  while( (float)i * redraw_size < dst )
  {
    // float to int conversion...
    Point2i pos_i((int)pos.x, (int)pos.y);
    if(delta.x < 0.0)
    {
      pos_i.x -= delta_i.x;
      pos_i.x += 3;
    }
    else
      pos_i.x -= 3;

    if(delta.y < 0.0)
    {
      pos_i.y -= delta_i.y;
      pos_i.y += 3;
    }
    else
      pos_i.y -= 3;

    world.ToRedrawOnMap(Rectanglei( pos_i, delta_i ));
    pos += delta;
    i++;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

WeaponProjectile * SnipeRifle::GetProjectileInstance

(

)

[protected, virtual]

Implements WeaponLauncher.

Definition at line 67 of file snipe_rifle.cpp.

{
  return dynamic_cast<WeaponProjectile *>
      (new SnipeBullet(cfg(),dynamic_cast<WeaponLauncher *>(this)));
}

Here is the call graph for this function:

void SnipeRifle::p_Deselect

(

)

[protected, virtual]

Reimplemented from WeaponLauncher.

Definition at line 146 of file snipe_rifle.cpp.

{
  ActiveCharacter().SetFiringAngle(0.);
}

Here is the call graph for this function:

bool SnipeRifle::p_Shoot

(

)

[protected, virtual]

Reimplemented from WeaponLauncher.

Definition at line 73 of file snipe_rifle.cpp.

{
  if(m_is_active)
    return false;

  m_is_active = true;
  projectile->Shoot (SNIPE_RIFLE_BULLET_SPEED);
  projectile = NULL;
  ReloadLauncher();
  return true;
}

Here is the call graph for this function:

void SnipeRifle::SignalProjectileGhostState

(

)

[virtual]

Reimplemented from WeaponLauncher.

Definition at line 86 of file snipe_rifle.cpp.

{
  m_is_active = false;
  ReloadLauncher();
  ComputeCrossPoint(true);
}

Here is the call graph for this function:

---

Member Data Documentation

Color SnipeRifle::laser_beam_color [private]

Definition at line 47 of file snipe_rifle.h.

Point2i SnipeRifle::laser_beam_start [private]

Definition at line 43 of file snipe_rifle.h.

double SnipeRifle::last_angle [private]

Definition at line 41 of file snipe_rifle.h.

Point2i SnipeRifle::last_rifle_pos [private]

Definition at line 42 of file snipe_rifle.h.

Sprite* SnipeRifle::m_laser_image [private]

Definition at line 46 of file snipe_rifle.h.

Point2i SnipeRifle::targeted_point [private]

Definition at line 44 of file snipe_rifle.h.

bool SnipeRifle::targeting_something [private]

Definition at line 45 of file snipe_rifle.h.

---

The documentation for this class was generated from the following files:

• src/weapon/snipe_rifle.h
• src/weapon/snipe_rifle.cpp

---