view_area.h

Go to the documentation of this file.

// -*-c++-*-
 
/*
 *Copyright:
 
 Copyright (C) Hidehisa AKIYAMA
 
 This code is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 *EndCopyright:
 */
 
 
#ifndef RCSC_PLAYER_VIEW_AREA_H
#define RCSC_PLAYER_VIEW_AREA_H
 
#include <rcsc/geom/vector_2d.h>
#include <rcsc/geom/angle_deg.h>
#include <rcsc/game_time.h>
 
#include <deque>
#include <cmath>
 
namespace rcsc {
 
class ViewArea {
private:
    double M_view_width; 
    Vector2D M_origin; 
    AngleDeg M_angle; 
    GameTime M_time; 
 
public:
 
    ViewArea()
        : M_view_width( -1.0 )
        , M_origin( Vector2D::INVALIDATED )
        , M_angle()
        , M_time( -1, 0 )
      { }
 
    explicit
    ViewArea( const GameTime & t )
        : M_view_width( -1.0 )
        , M_origin( Vector2D::INVALIDATED )
        , M_angle()
        , M_time( t )
      { }
 
 
    ViewArea( const double & view_width,
              const Vector2D & origin,
              const AngleDeg & angle,
              const GameTime & t )
        : M_view_width( view_width )
        , M_origin( origin )
        , M_angle( angle )
        , M_time( t )
      { }
 
    const
    double & viewWidth() const
      {
          return M_view_width;
      }
 
    const
    Vector2D & origin() const
      {
          return M_origin;
      }
 
    const
    AngleDeg & angle() const
      {
          return M_angle;
      }
 
    const
    GameTime & time() const
      {
          return M_time;
      }
 
    bool isValid() const
      {
          return M_view_width > 0.0;
      }
 
    bool contains( const Vector2D & point,
                   const double & dir_thr,
                   const double & visible_dist2 ) const
      {
          if ( ! isValid() )
          {
              return false;
          }
 
          Vector2D rpos( point - origin() );
          if ( rpos.r2() < visible_dist2 )
          {
              return true;
          }
 
          return ( rpos.th() - M_angle ).abs() < M_view_width*0.5 - dir_thr;
      }
};
 
typedef std::deque< ViewArea > ViewAreaCont;
 
}
 
#endif