dealer.cpp

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

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

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

#include <RTSystem/CardGameComponent.h>
#include <Dealer.h>
#include <Card.h>
#include <Hand.h>
#include <PokerHand.h>

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

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

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

static RTActor * new_Dealer_Actor( RTController * _rts, RTActorRef * _ref )
{
	return new Dealer_Actor( _rts, _ref );
}

const RTActorClass Dealer =
{
	(const RTActorClass *)0
  , "Dealer"
  , (RTVersionId)0
  , 1
  , rtg_relays
  , new_Dealer_Actor
};

static const char * const rtg_state_names[] =
{
	"TOP"
  , "WaitingToStart"
  , "Playing"
};

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

#define SUPER RTActor

Dealer_Actor::Dealer_Actor( RTController * rtg_rts, RTActorRef * rtg_ref )
	: RTActor( rtg_rts, rtg_ref )
	, _hand( (Hand *)0 )
	, _deck( 52 )
{
}

// {{{RME operation '~Dealer()'
Dealer_Actor::~Dealer_Actor( void )
{
	// {{{USR
	delete _hand;
	// }}}USR
}
// }}}RME

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

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

// {{{RME transition ':TOP:WaitingToStart:Junction2:Deal_cards'
INLINE_METHODS void Dealer_Actor::transition2_Deal_cards( const int * rtdata, CommHeadsUp::Base * rtport )
{
	// {{{USR
	// distribute hands to player and take one for myself
	Card card;
	for( int i = 0; i < _hand->size(); i++ )
	{
		_deck.get( card );
	  	player_comm.ACard( card ).send();
		_deck.get( card );
	  	_hand->add( card, i );
	}
	// }}}USR
}
// }}}RME

// {{{RME transition ':TOP:Playing:Junction2:Calc_hands'
INLINE_METHODS void Dealer_Actor::transition3_Calc_hands( const int * rtdata, CommHeadsUp::Base * rtport )
{
	// {{{USR
	// compare the players hand to ours. If the Player has a better 
	// hand then the Player wins; otherwise, the Dealer wins.
	if( *rtdata > _hand->value() )
		player_comm.Win(2).send();
	else
		player_comm.Lose().send();

	// shuffle deck for next game
	_deck.shuffle();
	// }}}USR
}
// }}}RME

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

INLINE_CHAINS void Dealer_Actor::chain2_Deal_cards( void )
{
	// transition ':TOP:WaitingToStart:Junction2:Deal_cards'
	rtgChainBegin( 2, "Deal_cards" );
	exitState( rtg_parent_state );
	rtgTransitionBegin();
	transition2_Deal_cards( (const int *)msg->data, (CommHeadsUp::Base *)msg->sap() );
	rtgTransitionEnd();
	enterState( 3 );
}

INLINE_CHAINS void Dealer_Actor::chain3_Calc_hands( void )
{
	// transition ':TOP:Playing:Junction2:Calc_hands'
	rtgChainBegin( 3, "Calc_hands" );
	exitState( rtg_parent_state );
	rtgTransitionBegin();
	transition3_Calc_hands( (const int *)msg->data, (CommHeadsUp::Base *)msg->sap() );
	rtgTransitionEnd();
	enterState( 2 );
}

void Dealer_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 'player_comm'
				switch( signalIndex )
				{
				case CommHeadsUp::Base::rti_Ante:
					chain2_Deal_cards();
					return;
				default:
					break;
				}
				break;
				// }}}RME
			default:
				break;
			}
			break;
			// }}}RME
		case 3:
			// {{{RME state ':TOP:Playing'
			switch( portIndex )
			{
			case 0:
				switch( signalIndex )
				{
				case 1:
					return;
				default:
					break;
				}
				break;
			case 1:
				// {{{RME port 'player_comm'
				switch( signalIndex )
				{
				case CommHeadsUp::Base::rti_HandValue:
					chain3_Calc_hands();
					return;
				default:
					break;
				}
				break;
				// }}}RME
			default:
				break;
			}
			break;
			// }}}RME
		default:
			unexpectedState();
			return;
		}
}

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

const RTActor_class Dealer_Actor::rtg_class =
{
	(const RTActor_class *)0
  , rtg_state_names
  , 3
  , Dealer_Actor::rtg_parent_state
  , &Dealer
  , 0
  , (const RTComponentDescriptor *)0
  , 1
  , Dealer_Actor::rtg_ports
  , 0
  , (const RTLocalBindingDescriptor *)0
  , 2
  , Dealer_Actor::rtg_Dealer_fields
};

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

const RTPortDescriptor Dealer_Actor::rtg_ports[] =
{
	{
		"player_comm"
	  , (const char *)0
	  , &CommHeadsUp::Base::rt_class
	  , RTOffsetOf( Dealer_Actor, Dealer_Actor::player_comm )
	  , 1 // cardinality
	  , 1
	  , RTPortDescriptor::KindWired + RTPortDescriptor::NotificationDisabled + RTPortDescriptor::RegisterNotPermitted + RTPortDescriptor::VisibilityPublic
	}
};

const RTFieldDescriptor Dealer_Actor::rtg_Dealer_fields[] =
{
	// {{{RME classAttribute '_hand'
	{
		"_hand"
	  , RTOffsetOf( Dealer_Actor, _hand )
		// {{{RME tool 'OT::CppTargetRTS' property 'TypeDescriptor'
	  , &RTType_Hand
		// }}}RME
		// {{{RME tool 'OT::CppTargetRTS' property 'GenerateTypeModifier'
	  , &rtg_tm_Dealer_Actor__hand
		// }}}RME
	}
	// }}}RME
	// {{{RME classAttribute '_deck'
  , {
		"_deck"
	  , RTOffsetOf( Dealer_Actor, _deck )
		// {{{RME tool 'OT::CppTargetRTS' property 'TypeDescriptor'
	  , &RTType_Deck
		// }}}RME
		// {{{RME tool 'OT::CppTargetRTS' property 'GenerateTypeModifier'
	  , (const RTTypeModifier *)0
		// }}}RME
	}
	// }}}RME
};
#undef SUPER

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

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

// }}}RME