‘Strategy: The TeamStrategy class

‘This class provides an abstract interface 
‘to implement concrete strategy algorithms

Public MustInherit Class TeamStrategy

‘AlgorithmInterface : This is the interface provided
Public MustOverride Sub Play ()

End Class ‘ END CLASS DEFINITION TeamStrategy

‘ConcreteStrategy: The AttackStrategy class

‘This class is a concrete implementation of the
‘strategy class.

Public Class AttackStrategy
Inherits TeamStrategy

    ‘Overrides the Play function. 
    ‘Let us play some attacking game

    Public Overrides Sub Play()
        ‘Algorithm to attack
        System.Console.WriteLine(" Playing in attacking mode")
    End Sub

End Class ‘ END CLASS DEFINITION AttackStrategy

‘ConcreteStrategy: The DefendStrategy class

‘This class is a concrete implementation of the
‘strategy class.

Public Class DefendStrategy
Inherits TeamStrategy

    ‘Overrides the Play function. 
    ‘Let us go defensive
    Public Overrides Sub Play()
        ‘Algorithm to defend
        System.Console.WriteLine(" Playing in defensive mode")
    End Sub

End Class ‘ END CLASS DEFINITION DefendStrategy

‘Context: The Team class
‘This class encapsulates the algorithm

Public Class Team

    ‘Just a variable to keep the name of team
    Private teamName As String


    ‘A reference to the strategy algorithm to use
    Private strategy As TeamStrategy

    ‘ContextInterface to set the strategy
    Public Sub SetStrategy(ByVal s As TeamStrategy)
        ‘Set the strategy
        strategy = s
    End Sub

    ‘Function to play
    Public Sub PlayGame()
        ‘Print the team‘s name
        System.Console.WriteLine(teamName)
        ‘Play according to the strategy
        strategy.Play()
    End Sub

    ‘Constructor to create this class, by passing the team‘s name
    Public Sub New(ByVal teamName As String)
        ‘Set the team name to use later
        Me.teamName = teamName
    End Sub

End Class ‘ END CLASS DEFINITION Team

‘GameEngine class for demonstration
Public Class GameEngine

    Public Shared Sub Main()

        ‘Let us create a team and set its strategy,
        ‘and make the teams play the game

        ‘Create few strategies
        Dim attack As New AttackStrategy()
        Dim defend As New DefendStrategy()

        ‘Create our teams
        Dim france As New Team("France")
        Dim italy As New Team("Italy")

        System.Console.WriteLine("Setting the strategies..")

        ‘Now let us set the strategies
        france.SetStrategy(attack)
        italy.SetStrategy(defend)

        ‘Make the teams start the play
        france.PlayGame()
        italy.PlayGame()

        System.Console.WriteLine()
        System.Console.WriteLine("Changing the strategies..")

        ‘Let us change the strategies
        france.SetStrategy(defend)
        italy.SetStrategy(attack)

        ‘Make them play again
        france.PlayGame()
        italy.PlayGame()

        ‘Wait for a key press
        System.Console.Read()

    End Sub

End Class

‘ Component: The Player class

Public MustInherit Class Player

    ‘Just give a name for this player
    Private myName As String

    ‘The property to get/set the name
    Public Property Name() As String
        Get
            Return myName
        End Get
        Set(ByVal Value As String)
            myName = Value
        End Set
    End Property

    ‘This is the Operation in the component
    ‘and this will be overrided by concrete components
    Public MustOverride Sub PassBall()

End Class ‘ END CLASS DEFINITION Player

‘ ConcreteComponent : Field Player class

‘This is a concrete component. Later, we will add additional responsibilities
‘like Forward, Defender etc to a field player.

Public Class FieldPlayer
Inherits Player

    ‘Operation: Overrides PassBall operation
    Public Overrides Sub PassBall ()
        System.Console.WriteLine(_
          " Fieldplayer ({0}) - passed the ball", _
          MyBase.Name)
    End Sub

    ‘A constructor to accept the name of the player
    Public Sub New(ByVal playerName As String)
        MyBase.Name = playerName
    End Sub

End Class ‘ END CLASS DEFINITION FieldPlayer

‘ ConcreteComponent : GaolKeeper class

‘This is a concrete component.
‘Later, we can add additional responsibilities
‘to this class if required.

Public Class GoalKeeper
Inherits Player

    ‘Operation: Overriding the base class operation
    Public Overrides Sub PassBall ()
    System.Console.WriteLine(" GoalKeeper " & _ 
      "({0}) - passed the ball", MyBase.Name)
    End Sub

    ‘A constructor to accept the name of the player
    Public Sub New(ByVal playerName As String)
        MyBase.Name = playerName
    End Sub

End Class ‘ END CLASS DEFINITION GoalKeeper

‘Decorator: PlayerRole is the decorator

Public Class PlayerRole
Inherits player

    ‘The reference to the player
    Protected player As player

    ‘Call the base component‘s function
    Public Overrides Sub PassBall()
        player.PassBall()
    End Sub

    ‘This function is used to assign a player to this role
    Public Sub AssignPlayer(ByVal p As player)
        ‘Keep a reference to the player, to whom this
        ‘role is given
        player = p
    End Sub

End Class ‘ END CLASS DEFINITION PlayerRole

‘ConcreteDecorator: Forward class is a Concrete implementation
‘of the PlayerRole (Decorator) class

Public Class Forward
Inherits PlayerRole

    ‘Added Behavior: This is a responsibility exclusively for the Forward
    Public Sub ShootGoal()
        System.Console.WriteLine(" Forward ({0}) - " & _ 
          "Shooted the ball to goalpost", _
          MyBase.player.Name)
    End Sub

End Class ‘ END CLASS DEFINITION Forward

‘ConcreteDecorator: MidFielder class is a Concrete implementation
‘of the PlayerRole (Decorator) class

Public Class MidFielder
Inherits PlayerRole

    ‘AddedBehavior: This is a responsibility exclusively for the Midfielder
    ‘(Don‘t ask me whether only mid filders can dribble the ball - atleast
    ‘it is so in our engine)

    Public Sub Dribble()
        System.Console.WriteLine(_
          " Midfielder ({0}) - dribbled the ball", _
          MyBase.player.Name)
    End Sub

End Class ‘ END CLASS DEFINITION Midfielder

‘ConcreteDecorator: Defender class is a Concrete implementation
‘of the PlayerRole (Decorator) class

Public Class Defender
Inherits PlayerRole

    ‘Added Behavior: This is a responsibility exclusively for the Defender
    Public Sub Defend()
        System.Console.WriteLine(_
          " Defender ({0}) - defended the ball", _
          MyBase.player.Name)
    End Sub

End Class ‘ END CLASS DEFINITION Defender

‘Let us put it together
Public Class GameEngine

Public Shared Sub Main()

    ‘-- Step 1: 
    ‘Create few players (concrete components)

    ‘Create few field Players
    Dim owen As New FieldPlayer("Owen")
    Dim beck As New FieldPlayer("Beckham")

    ‘Create a goal keeper
    Dim khan As New GoalKeeper("Khan")

    ‘-- Step 2: 
    ‘Just make them pass the ball 
    ‘(during a warm up session ;))

    System.Console.WriteLine()
    System.Console.WriteLine(" > Warm up Session... ")

    owen.PassBall()
    beck.PassBall()
    khan.PassBall()

    ‘-- Step 3: Create and assign the responsibilities
    ‘(when the match starts)

    System.Console.WriteLine()
    System.Console.WriteLine(" > Match is starting.. ")

    ‘Set owen as our first forward
    Dim forward1 As New Forward()
    forward1.AssignPlayer(owen)

    ‘Set Beckham as our midfielder
    Dim midfielder1 As New MidFielder()
    midfielder1.AssignPlayer(beck)

    ‘Now, use these players to do actions
    ‘specific to their roles

    ‘Owen can pass the ball
    forward1.PassBall()
    ‘And owen can shoot as well
    forward1.ShootGoal()

    ‘Beckham can pass ball
    midfielder1.PassBall()
    ‘Beckham can dribble too
    midfielder1.Dribble()

    ‘ [ Arrange the above operations to some meaningfull sequence, like
    ‘ "Beckham dribbled and passed the ball to owen and owen shooted the
    ‘ goal ;) - just for some fun ]"

    ‘-- Step 4: Now, changing responsibilities
    ‘(during a substitution)

    ‘Assume that owen got injured, and we need a new player
    ‘to play as our forward1

    System.Console.WriteLine()
    System.Console.WriteLine(" > OOps, Owen " _ 
       "got injured. " & _
       "Jerrard replaced Owen.. ")

    ‘Create a new player
    Dim jerrard As New FieldPlayer("Jerrard")

    ‘Ask Jerrard to play in position of owen
    forward1.AssignPlayer(jerrard)
    forward1.ShootGoal()

    ‘-- Step 5: Adding multiple responsibilities
    ‘(When a player need to handle multiple roles)

    ‘We already have Beckham as our midfielder. 
    ‘Let us ask him to play as an additional forward

    Dim onemoreForward As New Forward()
    onemoreForward.AssignPlayer(beck)

    System.Console.WriteLine()
    System.Console.WriteLine(" > Beckham has " & _ 
           "multiple responsibilities.. ")

    ‘Now Beckham can shoot
    onemoreForward.ShootGoal()
    ‘And use his earlier responsibility to dribble too
    midfielder1.Dribble()

    ‘According to our design, you can attach the responsibility of
    ‘a forward to a goal keeper too, but when you actually 
    ‘play football, remember that it is dangerous ;)

    ‘Wait for key press
    System.Console.Read()

End Sub

End Class