The Big Programming Thread - Page 404

#ifndef CStateMachine_H
#define CStateMachine_H

/**
* Class CStateMachine
*Description: Manages the game states.
**/

#include "CState.h"

//namespace tpe {

	class CStateMachine{

	public:
		// == Constructors
								CStateMachine();
								~CStateMachine();

		// == Methods

		void					OnLoop(CGame* _game);

		void					OnDraw(CGame* _game);

		void					OnEvent(CGame* _game);

		/**
		 * Set a new state, removes the old one to make space for the new one.
		 *
		 * \param _state The new state to make active.
		 * \param _game The game class.
		 * \param _id The state ID.
		 * \return Returns true if the state was set.
		**/
		bool					SetState(CState* _state, CGame* const _game, unsigned int _id);
		/**
		 * Destroys the current state.
		 *
		 * \param _game The game object to pass to the states before destroying them.
		 * \return Returns true. ATM
		**/
		bool					RemoveCurSet(CGame* _game);

		// == Members
		CState*					m_currentState;
	
	};

//}

#endif

#include "CStateMachine.h"

//namespace tpe{

	CStateMachine::CStateMachine()
	{
		m_currentState = NULL;
	}

	CStateMachine::~CStateMachine()
	{
		m_currentState = NULL;
	}

	void CStateMachine::OnLoop(CGame* _game)
	{
	
	}

	void CStateMachine::OnDraw(CGame* _game)
	{

		m_currentState->OnDraw(_game);
	
	}

	bool CStateMachine::SetState(CState* _state, CGame* const _game, unsigned int _id)
	{
	
		if(!RemoveCurSet(_game)) { return false; }
		m_currentState = _state;
		if(!_state) { return true; }
		m_currentState->m_stateId = _id;
		m_currentState->OnInit(_game);

		return true;

	}

	bool CStateMachine::RemoveCurSet(CGame* _game)
	{
	
		if(!m_currentState) { return true;}
		m_currentState->OnDestroy(_game);
		delete m_currentState;
		m_currentState = NULL;
		return true;
	
	}

	void CStateMachine::OnEvent(CGame* _game)
	{
		m_currentState->OnEvent(_game);
	}

//}

class User
  include Mongoid::Document
  attr_accessor :password, :password_confirmation

  field :name,             :type => String
  field :email,            :type => String
  field :crypted_password, :type => String
  
  validates_presence_of     (etc...)
  validates_confirmation_of :password,                   :if => :password_required
  validates_length_of       :password, :within => 3..40, :if => :password_required
  validates (etc...)

  before_save :encrypt_password, :if => :password_required

  def self.authenticate(email, password)
    account = first(:conditions => { :email => /^#{email}$/i }) if email.present?
    account && account.has_password?(password) ? account : nil
  end

  def has_password?(password)
    ::BCrypt::Password.new(crypted_password) == password
  end

private
  def encrypt_password
    self.crypted_password = ::BCrypt::Password.create(self.password)
  end

  def password_required
    crypted_password.blank? || self.password.present?
  end
end