Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- BLACKJACK_MAX_BET=1000
- BLACKJACK_MIN_BET=100
- BLACKJACK_DEALER_AI=1
- BLACKJACK_DEALER_RISK=20
- BLACKJACK_DEALER_HIT=16
- class Game_Deck
- #--------------------------------------------------------------------------
- # * Constants
- #--------------------------------------------------------------------------
- SUITS=["spades", "hearts", "diamonds", "clubs"]
- VALUES=['A','2','3','4','5','6','7','8','9','10','J','Q','K']
- #--------------------------------------------------------------------------
- # * Object Initialization
- #--------------------------------------------------------------------------
- def initialize(num_decks = 1)
- # Setup Cards
- @cards = []
- # Setup Deck
- @deck = []
- # Setup Discarded
- @discard = []
- # Setup In Play
- @in_play = []
- # Setup Number of Decks
- @num_decks = num_decks
- # Setup Cards
- setup_cards
- # Shuffle
- shuffle
- end
- #--------------------------------------------------------------------------
- # * Setup Cards
- #--------------------------------------------------------------------------
- def setup_cards
- # Run Through number of decks times
- @num_decks.times do
- # Run Through Each Suit
- SUITS.each do |suit|
- # Run Through each value
- VALUES.each do |number|
- # Setup Card
- card = Game_Card.new(suit, number)
- # Push into cards array
- @deck.push(card)
- end
- end
- end
- end
- #--------------------------------------------------------------------------
- # * Shuffle
- #--------------------------------------------------------------------------
- def shuffle
- # Setup local variable cards
- cards = []
- # Clear Discarded
- @discard.clear
- # Setup Cards to Deck
- @cards = [@deck].flatten!
- # Delete Cards already out
- delete_in_use_cards
- # Run through until cards are empty
- until @cards.empty?
- # Push a Random Card and Delete
- cards.push(@cards.delete_at(rand(@cards.size)))
- end
- # Set Cards to Cards
- @cards = cards
- end
- #--------------------------------------------------------------------------
- # * Draw
- #--------------------------------------------------------------------------
- def draw(number = 1)
- # Return if number is 1
- if number == 1
- # Shuffle if empty?
- shuffle if @cards.empty?
- # Get Card
- card = @cards.shift
- # Add Card to in play
- @in_play.push(card)
- # Return card
- return card
- end
- # Setup Array
- drawn = []
- # Run Through number of times
- number.times do
- # Shuffle if empty?
- shuffle if @cards.empty?
- # Break if cards are still empty (all in play)
- break if @cards.empty?
- # Get Card
- card = @cards.shift
- # Add Card to in play
- @in_play.push(card)
- # Add to Drawn
- drawn.push(card)
- end
- # Return Drawn Cards
- return drawn
- end
- #--------------------------------------------------------------------------
- # * Discard In Play
- #--------------------------------------------------------------------------
- def discard
- # Add all in play cards to discard
- @discard += @in_play
- # Clear in play
- @in_play.clear
- end
- #--------------------------------------------------------------------------
- # * Number
- #--------------------------------------------------------------------------
- def number(*strings)
- # Setup Local Variable
- number = 0
- # Run Through each card
- @cards.each do |card|
- # Run Through Each String Sent to this method
- strings.each do |string|
- # If A Suit
- if SUITS.include?(string)
- # Increase By 1 if suits are equal
- number += 1 if card.suit == string
- # If A Value
- elsif VALUES.include?(string)
- # Increase By 1 if values are equal
- number += 1 if card.value == string
- end
- end
- end
- return number
- end
- #--------------------------------------------------------------------------
- # * Size
- #--------------------------------------------------------------------------
- def size
- return @cards.size
- end
- #--------------------------------------------------------------------------
- # * Delete Cards In Use
- #--------------------------------------------------------------------------
- def delete_in_use_cards
- # Return if empty cards
- return if @in_play.empty?
- # Run Through each in play card and Delete Card from list
- @in_play.each {|card| @cards.delete(card)}
- # Clear In Play
- @in_play.clear
- end
- end
- class Game_Card
- #--------------------------------------------------------------------------
- # * Public Instance Variables
- #--------------------------------------------------------------------------
- attr_reader :number
- attr_reader :suit
- attr_reader :value
- #--------------------------------------------------------------------------
- # * Object Initialization
- #--------------------------------------------------------------------------
- def initialize(suit, value, face10 = false, ace11 = false)
- @suit = suit
- @value = value
- @face10 = face10
- @ace11 = ace11
- @flipped = true
- setup_number
- end
- #--------------------------------------------------------------------------
- # * Ace?
- #--------------------------------------------------------------------------
- def ace?
- return @value == 'A'
- end
- #--------------------------------------------------------------------------
- # * King?
- #--------------------------------------------------------------------------
- def king?
- return @value == 'K'
- end
- #--------------------------------------------------------------------------
- # * Queen?
- #--------------------------------------------------------------------------
- def queen?
- return @value == 'Q'
- end
- #--------------------------------------------------------------------------
- # * Jack?
- #--------------------------------------------------------------------------
- def jack?
- return @value == 'J'
- end
- #--------------------------------------------------------------------------
- # * Face?
- #--------------------------------------------------------------------------
- def face?
- return ['J','Q','K'].include?(@value)
- end
- #--------------------------------------------------------------------------
- # * Ten?
- #--------------------------------------------------------------------------
- def ten?
- return @value == '10' || (self.face? and @face10)
- end
- def flipped
- return @flipped
- end
- def flipped=(value)
- @flipped=value
- end
- #--------------------------------------------------------------------------
- # * To String (Returns card's value)
- #--------------------------------------------------------------------------
- def to_s
- return self.value
- end
- #--------------------------------------------------------------------------
- # * Setup Number (Private)
- #--------------------------------------------------------------------------
- def setup_number
- case @value
- when 'A'
- @number = @ace11 ? 11 : 1
- when 'J'
- @number = @face10 ? 10 : 11
- when 'Q'
- @number = @face10 ? 10 : 12
- when 'K'
- @number = @face10 ? 10 : 13
- else
- @number = @value.to_i
- end
- end
- def self.createBack
- return _INTL("Graphics/Pictures/Cards/Backs/Pokemon")
- end
- def createBitmap
- if !@flipped
- return Game_Card.createBack
- end
- return sprintf("Graphics/Pictures/Cards/Normal/%s_%s",@suit,@value)
- end
- end
- class Game_CardHand
- #--------------------------------------------------------------------------
- # * Object Initialization
- #--------------------------------------------------------------------------
- def initialize
- # Setup Cards
- @cards = []
- end
- #--------------------------------------------------------------------------
- # * Each (Runs Through Each Card in Hand)
- #--------------------------------------------------------------------------
- def each
- @cards.each {|card| yield(card)}
- end
- #--------------------------------------------------------------------------
- # * Cards
- #--------------------------------------------------------------------------
- def cards
- return @cards.size
- end
- #--------------------------------------------------------------------------
- # * Draw
- #--------------------------------------------------------------------------
- def draw(*args)
- args.flatten!
- @cards.push(*args)
- @cards.each_with_index do |card, index|
- # Set Flipped Flag
- card.flipped = index != 0
- end
- end
- #--------------------------------------------------------------------------
- # * Discard
- #--------------------------------------------------------------------------
- def discard
- @cards.clear
- end
- #--------------------------------------------------------------------------
- # * To String (ex. A234K)
- #--------------------------------------------------------------------------
- def to_s
- string = ''
- @cards.each {|card| string += card.to_s}
- return string
- end
- end
- class Game_BlackJackHand < Game_CardHand
- #--------------------------------------------------------------------------
- # * Bust?
- #--------------------------------------------------------------------------
- def bust?
- return self.total > 21
- end
- #--------------------------------------------------------------------------
- # * Black Jack
- #--------------------------------------------------------------------------
- def blackjack?
- return ((@cards[0].ace? && @cards[1].ten?) || (@cards[1].ace? &&
- @cards[0].ten?)) && @cards.size == 2
- end
- #--------------------------------------------------------------------------
- # * Double?
- #--------------------------------------------------------------------------
- def double?
- return @cards.size == 2
- end
- #--------------------------------------------------------------------------
- # * Split
- #--------------------------------------------------------------------------
- def split?
- return @cards[0].value == @cards[1].value && @cards.size == 2
- end
- #--------------------------------------------------------------------------
- # * Aces
- #--------------------------------------------------------------------------
- def aces
- num = 0
- @cards.each {|card| num += 1 if card.ace?}
- return num
- end
- #--------------------------------------------------------------------------
- # * Total
- #--------------------------------------------------------------------------
- def total(ace1 = false, countflipped=false)
- # Setup Number
- num = 0
- # Add Up
- each {|card| num += card.number if card.flipped or countflipped}
- # Decrease ace value to 1 if over 21
- self.aces.times { num -= 10 if num > 21 || ace1 }
- # Return total
- return num
- end
- #--------------------------------------------------------------------------
- # * Value
- #--------------------------------------------------------------------------
- def value
- return blackjack? ? 'BJ' : bust? ? 'Bust' : total.to_s
- end
- end
- class Blackjack_Scene
- def update
- pbUpdateSpriteHash(@sprites)
- pbDrawTable
- end
- def pbStart
- # Create sprite hash
- @sprites={}
- @deck=Game_Deck.new
- @playerhand=Game_BlackJackHand.new
- @dealerhand=Game_BlackJackHand.new
- @bet=0
- @phase=0 # 0 = Bet, 1 = Game, 2 = End
- @viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
- @viewport.z=99999
- addBackgroundPlane(@sprites,"bg","Cards/background",@viewport)
- @sprites["overlay"]=BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
- pbSetSystemFont(@sprites["overlay"].bitmap)
- pbDrawTable
- pbFadeInAndShow(@sprites) { update }
- end
- def pbReset
- if Kernel.pbConfirmMessage(_INTL("Would you like to play again?"))
- @deck=Game_Deck.new
- @playerhand=Game_BlackJackHand.new
- @dealerhand=Game_BlackJackHand.new
- @bet=0
- @phase=0 # 0 = Bet, 1 = Game
- else
- @phase=2
- end
- end
- def pbDrawTable
- overlay=@sprites["overlay"].bitmap
- overlay.clear
- baseColor=Color.new(248,248,248)
- shadowColor=Color.new(104,104,104)
- textPositions=[
- [_INTL("Dealer's Hand"),38,58,0,baseColor,shadowColor],
- [_INTL("{1}",(@dealerhand.value rescue "N/A")),72,88,1,baseColor,shadowColor],
- [_INTL("{1}'s Hand",$Trainer.name),38,174,0,baseColor,shadowColor],
- [_INTL("{1}",(@playerhand.value rescue "N/A")),72,204,1,baseColor,shadowColor],
- [_INTL("BET: {1}",@bet),342,58,0,baseColor,shadowColor],
- [_INTL("COINS: {1}",$PokemonGlobal.coins),324,88,0,baseColor,shadowColor]
- ]
- pbDrawTextPositions(overlay,textPositions)
- imagePositions=[]
- x=170
- for card in @playerhand
- imagePositions.push([card.createBitmap,x,174,0,0,-1,-1])
- if @playerhand.cards<=3
- x+=82
- elsif @playerhand.cards<=7
- x+=36
- else
- x+=12
- end
- end
- x=170
- for card in @dealerhand
- imagePositions.push([card.createBitmap,x,80,0,0,-1,-1])
- if @dealerhand.cards<=3
- x+=82
- elsif @dealerhand.cards<=7
- x+=36
- else
- x+=12
- end
- end
- pbDrawImagePositions(overlay,imagePositions)
- end
- def pbMain
- loop do
- Graphics.update
- Input.update
- self.update
- case @phase
- when 0
- params=ChooseNumberParams.new
- params.setRange(BLACKJACK_MIN_BET,BLACKJACK_MAX_BET)
- params.setInitialValue(BLACKJACK_MIN_BET)
- params.setCancelValue(0)
- qty=Kernel.pbMessageChooseNumber(
- _INTL("How much are you betting?"),params
- )
- if qty>0
- if $PokemonGlobal.coins>qty
- @phase=1
- @bet=qty
- $PokemonGlobal.coins-=@bet
- @playerhand.draw(@deck.draw(2))
- @playerhand.each{|card| card.flipped=true}
- @dealerhand.draw(@deck.draw(2))
- else
- Kernel.pbMessage(_INTL("You don't have enough to bet that."))
- end
- else
- Kernel.pbMessage(_INTL("Have a good day."))
- break
- end
- when 1
- commands=[_INTL("Hit"),_INTL("Stay")]
- commands.push(_INTL("Double")) if @playerhand.double? && !($PokemonGlobal.coins < @bet)
- action=Kernel.pbShowCommands(nil,commands)
- case action
- when 0
- action_hit
- when 1
- action_stay
- when 2
- action_double
- end
- when 2
- break
- end
- end
- end
- def action_hit
- player_draw
- if @playerhand.bust?
- start_cpu
- return
- end
- end
- def action_stay
- start_cpu
- end
- def action_double
- if $PokemonGlobal.coins < @bet
- return
- end
- $PokemonGlobal.coins-=@bet
- @bet*=2
- player_draw
- start_cpu
- end
- def start_cpu
- if (@dealerhand.total(false,true) == 21 or @dealerhand.total(false,true) > @playerhand.total or
- @playerhand.blackjack? or @playerhand.bust?)
- # Start Checking Phase (Dealer Stands)
- start_check
- # Return
- return
- end
- case BLACKJACK_DEALER_AI
- when 0 # Hit 16 Stand 17
- # If Less than or equal to 16 Draw Card Else Stand
- @dealerhand.total(false,false) <= 16 ? @dealerhand.draw(@deck.draw) : start_check
- when 1 # Hit When Advantageous
- # Get Total (All Aces are 1)
- amount = 21 - @dealerhand.total(true,true)
- # If Amount greater than or equal to 10
- if amount >= 10
- # Always Hit
- @dealerhand.draw(@deck.draw)
- # Return
- return
- end
- # Create Values
- values = ('2'..amount.to_s).to_a << 'A'
- # Get Number of Cards then won't make the dealer bust
- number = @deck.number(*values)
- # Get Size of Deck
- size = @deck.size
- # Get Chance of Not Busting
- if size != 0
- chance = number * 100 / size
- else
- chance = 0
- end
- # If chance is less than the riskiness or If value is less than minimum
- if (100 - chance <= BLACKJACK_DEALER_RISK ||
- @dealerhand.total <= BLACKJACK_DEALER_HIT)
- # Hit Again
- @dealerhand.draw(@deck.draw)
- # Return
- return
- end
- # Else Dealer Stands
- start_check
- end
- end
- def player_draw
- @playerhand.draw(@deck.draw)
- @playerhand.each{|card| card.flipped=true}
- end
- def start_check
- self.update
- player, dealer = @playerhand.value, @dealerhand.value
- if @playerhand.bust?
- # Lose
- check_lose
- pbReset
- return
- end
- if @dealerhand.blackjack? and not @playerhand.blackjack?
- # Lose
- check_lose
- # Return
- pbReset
- return
- elsif @playerhand.blackjack? and not @dealerhand.blackjack?
- # Win
- check_win
- # Return
- pbReset
- return
- end
- if @playerhand.total > @dealerhand.total || @dealerhand.bust?
- # Win
- check_win
- # Return
- pbReset
- return
- # Push
- elsif @playerhand.total == @dealerhand.total
- # Push
- check_push
- # Return
- pbReset
- return
- # Lose
- else
- # Lose
- check_lose
- # Return
- pbReset
- return
- end
- end
- def check_lose
- Kernel.pbMessage(_INTL("\\me[Voltorb Flip Game Over]Oh no! You lost {1} Coins!\\wtnp[50]",@amount))
- end
- def check_win
- winnings = (@bet * (@playerhand.blackjack? ? 2.5 : 2)).to_i
- Kernel.pbMessage(_INTL("\\me[Voltorb Flip Win]Congratulations! You won {1} Coins!\\wtnp[40]",winnings))
- $PokemonGlobal.coins+=winnings
- end
- def check_push
- Kernel.pbMessage(_INTL("\\me[013-Gag02]It's a draw. You got a refund!\\wtnp[50]"))
- end
- def pbEnd
- pbFadeOutAndHide(@sprites) { update }
- pbDisposeSpriteHash(@sprites)
- @viewport.dispose
- end
- end
- class Blackjack_Screen
- def initialize(scene)
- @scene=scene
- end
- def pbStartScreen
- @scene.pbStart
- @scene.pbMain
- @scene.pbEnd
- end
- end
- def pbBlackJack
- if hasConst?(PBItems,:COINCASE) && $PokemonBag.pbQuantity(:COINCASE)<=0
- Kernel.pbMessage(_INTL("You can't play unless you have a Coin Case."))
- elsif $PokemonGlobal.coins==MAXCOINS
- Kernel.pbMessage(_INTL("Your Coin Case is full!"))
- else
- scene=Blackjack_Scene.new
- screen=Blackjack_Screen.new(scene)
- screen.pbStartScreen
- end
- end
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement