player.cpp

含有uml的多个实例及实例的java源码。

// {{{RME classifier 'Logical View::Player'

#if defined( PRAGMA ) && ! defined( PRAGMA_IMPLEMENTED )
#pragma implementation "Player.h"
#endif

#include <RTSystem/CardGameComponent.h>
#include <Player.h>
#include <Hand.h>
#include <PokerHand.h>

// {{{RME tool 'OT::Cpp' property 'ImplementationPreface'
// {{{USR

// }}}USR
// }}}RME

static const RTRelayDescriptor rtg_relays[] =
{
	{
		"dealer_comm"
	  , &CommHeadsUp::Conjugate::rt_class
	  , 1 // cardinality
	}
};

static RTActor * new_Player_Actor( RTController * _rts, RTActorRef * _ref )
{
	return new Player_Actor( _rts, _ref );
}

const RTActorClass Player =
{
	(const RTActorClass *)0
  , "Player"
  , (RTVersionId)0
  , 1
  , rtg_relays
  , new_Player_Actor
};

static const char * const rtg_state_names[] =
{
	"TOP"
  , "WaitingToStart"
  , "GameResults"
  , "ReceivingCards"
  , "ReceiveAllCards"
  , "All_cards"
};

const RTTypeModifier rtg_tm_Player_Actor__hand =
{
	RTNumberConstant
  , 1
  , 1
};

#define SUPER RTActor

Player_Actor::Player_Actor( RTController * rtg_rts, RTActorRef * rtg_ref )
	: RTActor( rtg_rts, rtg_ref )
	, _bet( 5 )
	, _ncards( 0 )
	, _money( 150 )
	, _hand( (Hand *)0 )
{
}

Player_Actor::~Player_Actor( void )
{
}

int Player_Actor::_followInV( RTBindingEnd & rtg_end, int rtg_portId, int rtg_repIndex )
{
	switch( rtg_portId )
	{
	case 0:
		// dealer_comm
		if( rtg_repIndex < 1 )
		{
			rtg_end.port = &dealer_comm;
			rtg_end.index = rtg_repIndex;
			return 1;
		}
		break;
	default:
		break;
	}
	return RTActor::_followInV( rtg_end, rtg_portId, rtg_repIndex );
}

// {{{RME enter ':TOP:WaitingToStart'
INLINE_METHODS void Player_Actor::enter2_WaitingToStart( void )
{
	// {{{USR
	_ncards = 0;
	timer.informIn(RTTimespec(2, 0));
	// }}}USR
}
// }}}RME

void Player_Actor::enterStateV( void )
{
	switch( getCurrentState() )
	{
	case 2:
		enter2_WaitingToStart();
		break;
	default:
		RTActor::enterStateV();
		break;
	}
}

// {{{RME transition ':TOP:Initial:Initial'
INLINE_METHODS void Player_Actor::transition1_Initial( const void * rtdata, RTProtocol * rtport )
{
	// {{{USR
	_hand = new PokerHand;
	// }}}USR
}
// }}}RME

// {{{RME transition ':TOP:WaitingToStart:Junction2:Ante'
INLINE_METHODS void Player_Actor::transition2_Ante( const void * rtdata, Timing::Base * rtport )
{
	// {{{USR
	dealer_comm.Ante(_bet).send();
	// }}}USR
}
// }}}RME

// {{{RME transition ':TOP:GameResults:Junction1:Lose'
INLINE_METHODS void Player_Actor::transition3_Lose( const void * rtdata, CommHeadsUp::Conjugate * rtport )
{
	// {{{USR
	// update for loss
	_money -= _bet;
	// }}}USR
}
// }}}RME

// {{{RME transition ':TOP:WaitingToStart:Junction4:Win'
INLINE_METHODS void Player_Actor::transition4_Win( const int * rtdata, CommHeadsUp::Conjugate * rtport )
{
	// {{{USR
	// Update winnings from bet and win multiplier
	// sent from dealer.
	_money += _bet * (*rtdata);
	// }}}USR
}
// }}}RME

// {{{RME transition ':TOP:ReceivingCards:Got_all_cards:Got_all_cards'
INLINE_METHODS void Player_Actor::transition5_Got_all_cards( const Card * rtdata, CommHeadsUp::Conjugate * rtport )
{
	// {{{USR
	// Send the value of the hand to the Dealer
	dealer_comm.HandValue( _hand->value() ).send();
	// }}}USR
}
// }}}RME

// {{{RME transition ':TOP:ReceivingCards:ReceiveAllCards:Junction2:Received_card'
INLINE_METHODS void Player_Actor::transition8_Received_card( const Card * rtdata, CommHeadsUp::Conjugate * rtport )
{
	// {{{USR
	_hand->add(*rtdata, _ncards++);
	// }}}USR
}
// }}}RME

INLINE_CHAINS void Player_Actor::chain1_Initial( void )
{
	// transition ':TOP:Initial:Initial'
	rtgChainBegin( 1, "Initial" );
	rtgTransitionBegin();
	transition1_Initial( msg->data, msg->sap() );
	rtgTransitionEnd();
	enterState( 2 );
}

INLINE_CHAINS void Player_Actor::chain4_Win( void )
{
	// transition ':TOP:WaitingToStart:Junction4:Win'
	rtgChainBegin( 2, "Win" );
	exitState( rtg_parent_state );
	rtgTransitionBegin();
	transition4_Win( (const int *)msg->data, (CommHeadsUp::Conjugate *)msg->sap() );
	rtgTransitionEnd();
	enterState( 3 );
}

INLINE_CHAINS void Player_Actor::chain2_Ante( void )
{
	// transition ':TOP:WaitingToStart:Junction2:Ante'
	rtgChainBegin( 2, "Ante" );
	exitState( rtg_parent_state );
	rtgTransitionBegin();
	transition2_Ante( msg->data, (Timing::Base *)msg->sap() );
	rtgTransitionEnd();
	enterState( 4 );
	// transition ':TOP:ReceivingCards:Ante:Ante'
	rtgChainBegin( 4, "Ante" );
	rtgTransitionBegin();
	rtgTransitionEnd();
	enterState( 5 );
}

INLINE_CHAINS void Player_Actor::chain3_Lose( void )
{
	// transition ':TOP:GameResults:Junction1:Lose'
	rtgChainBegin( 3, "Lose" );
	exitState( rtg_parent_state );
	rtgTransitionBegin();
	transition3_Lose( msg->data, (CommHeadsUp::Conjugate *)msg->sap() );
	rtgTransitionEnd();
	enterState( 2 );
}

INLINE_CHAINS void Player_Actor::chain8_Received_card( void )
{
	// transition ':TOP:ReceivingCards:ReceiveAllCards:Junction2:Received_card'
	rtgChainBegin( 5, "Received_card" );
	exitState( rtg_parent_state );
	rtgTransitionBegin();
	transition8_Received_card( (const Card *)msg->data, (CommHeadsUp::Conjugate *)msg->sap() );
	rtgTransitionEnd();
	if( choicePoint1_All_cards( (const Card *)msg->data, (CommHeadsUp::Conjugate *)msg->sap() ) )
		chain9_Got_all_cards();
	else
		chain7_False();
}

// {{{RME choicePoint ':TOP:ReceivingCards:All_cards'
INLINE_METHODS int Player_Actor::choicePoint1_All_cards( const Card * rtdata, CommHeadsUp::Conjugate * rtport )
{
	// {{{USR
	return( _ncards >= _hand->size());
	// }}}USR
}
// }}}RME

INLINE_CHAINS void Player_Actor::chain9_Got_all_cards( void )
{
	// transition ':TOP:ReceivingCards:All_cards:Got_all_cards'
	rtgChainBegin( 6, "Got_all_cards" );
	rtgTransitionBegin();
	rtgTransitionEnd();
	// transition ':TOP:ReceivingCards:Got_all_cards:Got_all_cards'
	rtgChainBegin( 4, "Got_all_cards" );
	exitState( rtg_parent_state );
	rtgTransitionBegin();
	transition5_Got_all_cards( (const Card *)msg->data, (CommHeadsUp::Conjugate *)msg->sap() );
	rtgTransitionEnd();
	enterState( 3 );
}

INLINE_CHAINS void Player_Actor::chain7_False( void )
{
	// transition ':TOP:ReceivingCards:All_cards:False'
	rtgChainBegin( 6, "False" );
	rtgTransitionBegin();
	rtgTransitionEnd();
	enterState( 5 );
}

void Player_Actor::rtsBehavior( int signalIndex, int portIndex )
{
	for( int stateIndex = getCurrentState(); ; stateIndex = rtg_parent_state[ stateIndex - 1 ] )
		switch( stateIndex )
		{
		case 1:
			// {{{RME state ':TOP'
			switch( portIndex )
			{
			case 0:
				switch( signalIndex )
				{
				case 1:
					chain1_Initial();
					return;
				default:
					break;
				}
				break;
			default:
				break;
			}
			unexpectedMessage();
			return;
			// }}}RME
		case 2:
			// {{{RME state ':TOP:WaitingToStart'
			switch( portIndex )
			{
			case 0:
				switch( signalIndex )
				{
				case 1:
					return;
				default:
					break;
				}
				break;
			case 1:
				// {{{RME port 'dealer_comm'
				switch( signalIndex )
				{
				case CommHeadsUp::Conjugate::rti_Win:
					chain4_Win();
					return;
				default:
					break;
				}
				break;
				// }}}RME
			case 2:
				// {{{RME port 'timer'
				switch( signalIndex )
				{
				case Timing::Base::rti_timeout:
					chain2_Ante();
					return;
				default:
					break;
				}
				break;
				// }}}RME
			default:
				break;
			}
			break;
			// }}}RME
		case 3:
			// {{{RME state ':TOP:GameResults'
			switch( portIndex )
			{
			case 0:
				switch( signalIndex )
				{
				case 1:
					return;
				default:
					break;
				}
				break;
			case 1:
				// {{{RME port 'dealer_comm'
				switch( signalIndex )
				{
				case CommHeadsUp::Conjugate::rti_Lose:
					chain3_Lose();
					return;
				default:
					break;
				}
				break;
				// }}}RME
			default:
				break;
			}
			break;
			// }}}RME
		case 4:
			// {{{RME state ':TOP:ReceivingCards'
			switch( portIndex )
			{
			case 0:
				switch( signalIndex )
				{
				case 1:
					return;
				default:
					break;
				}
				break;
			default:
				break;
			}
			break;
			// }}}RME
		case 5:
			// {{{RME state ':TOP:ReceivingCards:ReceiveAllCards'
			switch( portIndex )
			{
			case 0:
				switch( signalIndex )
				{
				case 1:
					return;
				default:
					break;
				}
				break;
			case 1:
				// {{{RME port 'dealer_comm'
				switch( signalIndex )
				{
				case CommHeadsUp::Conjugate::rti_ACard:
					chain8_Received_card();
					return;
				default:
					break;
				}
				break;
				// }}}RME
			default:
				break;
			}
			break;
			// }}}RME
		default:
			unexpectedState();
			return;
		}
}

const RTActor_class * Player_Actor::getActorData( void ) const
{
	return &Player_Actor::rtg_class;
}

const RTActor_class Player_Actor::rtg_class =
{
	(const RTActor_class *)0
  , rtg_state_names
  , 5
  , Player_Actor::rtg_parent_state
  , &Player
  , 0
  , (const RTComponentDescriptor *)0
  , 2
  , Player_Actor::rtg_ports
  , 0
  , (const RTLocalBindingDescriptor *)0
  , 4
  , Player_Actor::rtg_Player_fields
};

const RTStateId Player_Actor::rtg_parent_state[] =
{
	0
  , 1
  , 1
  , 1
  , 4
};

const RTPortDescriptor Player_Actor::rtg_ports[] =
{
	{
		"dealer_comm"
	  , (const char *)0
	  , &CommHeadsUp::Conjugate::rt_class
	  , RTOffsetOf( Player_Actor, Player_Actor::dealer_comm )
	  , 1 // cardinality
	  , 1
	  , RTPortDescriptor::KindWired + RTPortDescriptor::NotificationDisabled + RTPortDescriptor::RegisterNotPermitted + RTPortDescriptor::VisibilityPublic
	}
  , {
		"timer"
	  , (const char *)0
	  , &Timing::Base::rt_class
	  , RTOffsetOf( Player_Actor, Player_Actor::timer )
	  , 1 // cardinality
	  , 2
	  , RTPortDescriptor::KindSpecial + RTPortDescriptor::NotificationDisabled + RTPortDescriptor::RegisterNotPermitted + RTPortDescriptor::VisibilityProtected
	}
};

const RTFieldDescriptor Player_Actor::rtg_Player_fields[] =
{
	// {{{RME classAttribute '_bet'
	{
		"_bet"
	  , RTOffsetOf( Player_Actor, _bet )
		// {{{RME tool 'OT::CppTargetRTS' property 'TypeDescriptor'
	  , &RTType_int
		// }}}RME
		// {{{RME tool 'OT::CppTargetRTS' property 'GenerateTypeModifier'
	  , (const RTTypeModifier *)0
		// }}}RME
	}
	// }}}RME
	// {{{RME classAttribute '_ncards'
  , {
		"_ncards"
	  , RTOffsetOf( Player_Actor, _ncards )
		// {{{RME tool 'OT::CppTargetRTS' property 'TypeDescriptor'
	  , &RTType_int
		// }}}RME
		// {{{RME tool 'OT::CppTargetRTS' property 'GenerateTypeModifier'
	  , (const RTTypeModifier *)0
		// }}}RME
	}
	// }}}RME
	// {{{RME classAttribute '_money'
  , {
		"_money"
	  , RTOffsetOf( Player_Actor, _money )
		// {{{RME tool 'OT::CppTargetRTS' property 'TypeDescriptor'
	  , &RTType_long
		// }}}RME
		// {{{RME tool 'OT::CppTargetRTS' property 'GenerateTypeModifier'
	  , (const RTTypeModifier *)0
		// }}}RME
	}
	// }}}RME
	// {{{RME classAttribute '_hand'
  , {
		"_hand"
	  , RTOffsetOf( Player_Actor, _hand )
		// {{{RME tool 'OT::CppTargetRTS' property 'TypeDescriptor'
	  , &RTType_Hand
		// }}}RME
		// {{{RME tool 'OT::CppTargetRTS' property 'GenerateTypeModifier'
	  , &rtg_tm_Player_Actor__hand
		// }}}RME
	}
	// }}}RME
};
#undef SUPER

// {{{RME tool 'OT::Cpp' property 'ImplementationEnding'
// {{{USR

// }}}USR
// }}}RME

// }}}RME