class Hand
{
  float m_X;
  float m_Y;
    
  float m_HandWidth;
  float m_HandHeight;
  
  float m_MovementAreaX;
  float m_MovementAreaY;
  float m_MovementAreaXExt;
  float m_MovementAreaYExt;
  float m_MovementPullbackDist;
    
  float m_BallOffsetX;
  float m_BallOffsetY;
  
  int m_HandState;    //0 - holding ball
                      //1 - throwing ball
                      //2 - released ball
  float m_ThrowPower;
                      
  void Initialize()
  {
    m_HandWidth = IMAGE_POOL.m_Images[2].width;
    m_HandHeight = IMAGE_POOL.m_Images[2].height;
    
    m_BallOffsetX = 3.0;
    m_BallOffsetY = 2.0;
    
    m_MovementPullbackDist = 30.0;
    m_MovementAreaX = 0.0;
    m_MovementAreaY = ScreenHeight - m_HandHeight;    
    m_MovementAreaXExt = ScreenWidth - m_HandWidth;
    m_MovementAreaYExt = ScreenHeight - m_HandHeight + m_MovementPullbackDist;
      
    Reset();
  }
  
  void Reset()
  {         
    m_HandState = 0;
    m_ThrowPower = 0.0;
    m_X = (ScreenWidth / 2.0) - (m_HandWidth / 2.0);
    m_Y = m_MovementAreaY;
  }
    
  void Draw( float offsetX, float offsetY )
  {
    image( IMAGE_POOL.m_Images[2], m_X + offsetX, m_Y + offsetY );
  }
  
  void Update()
  {
    if( m_HandState == 1 )
    {
      m_Y -= 7.5;
      if( m_Y < m_MovementAreaY )
      {
        m_Y = m_MovementAreaY;
        BALL.ReleaseBall( m_ThrowPower );
        m_HandState = 2;
      }
    }
  }
  
  void ThrowBall()
  {
    if( m_Y == m_MovementAreaY )
    {
      return;
    }
    
    m_HandState = 1;
    m_ThrowPower = (m_Y - m_MovementAreaY) / m_MovementPullbackDist;
  }
  
  void UpdatePositionWithMouse()
  {
    m_X = mouseX - INPUT.dragOffsetX;
    m_Y = mouseY - INPUT.dragOffsetY;
  
    //keep within bounding box
    if( m_X < m_MovementAreaX )
    {
      m_X = m_MovementAreaX;
    }
    if( m_X > m_MovementAreaXExt )
    {
      m_X = m_MovementAreaXExt;
    }
    if( m_Y < m_MovementAreaY )
    {
      m_Y = m_MovementAreaY;
    }
    if( m_Y > m_MovementAreaYExt )
    {
      m_Y = m_MovementAreaYExt;
    }            
  }  
}

class Player
{
  Hand m_Hand;
  
  int m_Difficulty;
  
  float m_DrunkLevel;
  float m_DrunkOffsetX1;
  float m_DrunkOffsetY1;
  float m_DrunkOffsetX2;
  float m_DrunkOffsetY2; 
  float m_DrunkOpacity;
  float m_DrunkTimerMax;
  float m_DrunkTimerHalf;  
  float m_DrunkTimer;
  float m_DrunkTimerIncrease;
  Vector2D m_DrunkMovementVector1;
  Vector2D m_DrunkMovementVector2;
      
  void Initialize()
  {
    m_Hand = new Hand();
    m_Hand.Initialize();
    m_Difficulty = 0;
    m_DrunkMovementVector1 = new Vector2D();
    m_DrunkMovementVector2 = new Vector2D();
        
    m_DrunkTimerIncrease = 0.2;
    
    Reset();
  }
  
  void Reset()
  {
    m_DrunkLevel = 0.0;
    m_DrunkOffsetX1 = 0.0;
    m_DrunkOffsetY1 = 0.0;
    m_DrunkOffsetX2 = 0.0;
    m_DrunkOffsetY2 = 0.0;    
    m_DrunkOpacity = 255.0;
    m_DrunkTimerMax = 0.0;
    m_DrunkTimerHalf = 0.0;
    m_DrunkTimer = 0.0;
    m_DrunkMovementVector1.x = 0.0;
    m_DrunkMovementVector1.y = 0.0;
    m_DrunkMovementVector2.x = 0.0;
    m_DrunkMovementVector2.y = 0.0;
    m_Hand.Reset();        
  }
  
  void Draw( float opacity, float offsetX, float offsetY )
  {
    float redPercent = (m_Hand.m_Y - m_Hand.m_MovementAreaY) / m_Hand.m_MovementPullbackDist;
    redPercent *= 255.0;
    redPercent = 255.0 - redPercent;
    int redInt = (int)redPercent;
    
    tint( 255, redInt, redInt, (int)opacity );    
    m_Hand.Draw( offsetX, offsetY );
  }
  
  void Update()
  {
    m_Hand.Update();
    
    if( m_DrunkLevel > 0.0 )
    {
      m_DrunkTimer += m_DrunkTimerIncrease;
      if( m_DrunkTimer > m_DrunkTimerMax )
      {
        m_DrunkTimer = 0.0;
        m_DrunkMovementVector1.x = random(2.0);
        m_DrunkMovementVector1.x -= 1.0;
        m_DrunkMovementVector1.y = random(2.0);
        m_DrunkMovementVector1.y -= 1.0;
        m_DrunkMovementVector1.Normalize();
        m_DrunkMovementVector2.x = -m_DrunkMovementVector1.x;
        m_DrunkMovementVector2.y = -m_DrunkMovementVector1.y;
        m_DrunkMovementVector2.x += (random(0.6) - 0.3);
        m_DrunkMovementVector2.y += (random(0.6) - 0.3);
        m_DrunkOffsetX1 = 0.0;
        m_DrunkOffsetY1 = 0.0;
        m_DrunkOffsetX2 = 0.0;
        m_DrunkOffsetY2 = 0.0;        
      }
      else
      {
        if( m_DrunkTimer < m_DrunkTimerHalf )
        {
          m_DrunkOffsetX1 += m_DrunkMovementVector1.x;
          m_DrunkOffsetY1 += m_DrunkMovementVector1.y;
          m_DrunkOffsetX2 += m_DrunkMovementVector2.x;
          m_DrunkOffsetY2 += m_DrunkMovementVector2.y;          
        }
        else
        {
          m_DrunkOffsetX1 -= m_DrunkMovementVector1.x;
          m_DrunkOffsetY1 -= m_DrunkMovementVector1.y;          
          m_DrunkOffsetX2 -= m_DrunkMovementVector2.x;
          m_DrunkOffsetY2 -= m_DrunkMovementVector2.y;          
        }
      }
    }
  }
  
  void IncreaseDrunkLevel()
  {
    if( m_DrunkLevel < 0.01 )
    {
      m_DrunkLevel += 0.05;
    }
    
    switch( m_Difficulty )
    {
      case 0:
      m_DrunkLevel += 0.05;
      break;
      case 1:
      m_DrunkLevel += 0.06;      
      break;
      case 2:
      m_DrunkLevel += 0.07;      
      break;
    }
    
    UpdateDrunkValues();
  }
  
  void IncreaseDrunkLevel( float increase )
  {
    m_DrunkLevel += increase;
    if( m_DrunkLevel > 0.6 )
    {
      m_DrunkLevel = 0.6;
    }
    
    print( "Increased.  Level: " + m_DrunkLevel + '\n' );
    
    UpdateDrunkValues();
  }
  
  void DecreaseDrunkLevel( float decrease )
  {
    m_DrunkLevel -= decrease;
    if( m_DrunkLevel < 0.0 )
    {
      m_DrunkLevel = 0.0;
    }

    print( "Decreased.  Level: " + m_DrunkLevel + '\n' );
            
    UpdateDrunkValues();
  }
  
  void UpdateDrunkValues()
  {
    m_DrunkTimerMax = 5.0;//2.0 / m_DrunkLevel;
    m_DrunkTimerHalf = m_DrunkTimerMax / 2.0;
    m_DrunkTimer = 0.0;
    m_DrunkOffsetX1 = 0.0;
    m_DrunkOffsetY1 = 0.0;
    m_DrunkOffsetX2 = 0.0;
    m_DrunkOffsetY2 = 0.0;    
    m_DrunkOpacity = (1.0 - m_DrunkLevel) * 255.0;
  }  
}