pseudocode.txt

CLASS Deck:
    SET availableCards TO []
    SET cutCards TO []
    SET spentCards TO []
    SET players TO 5

    METHOD createDeck(decks)
        SET decks TO decks * 4
        FOR iter1 FROM 0 TO decks DO
            FOR iter2 FROM 0 TO 14 DO
				IF i = 11 
				ELSE
                	APPEND [iter1, iter2] TO availableCards
				END IF
            END FOR
        END FOR
    END METHOD

    METHOD shuffle()
        SET length TO length(availableCards)
		SET temp TO undefined
		SET selectedCard TO undefined
        
        WHILE length > 0 DO
            SET length TO length - 1
            SET selectedCard TO RoundDown(RandomInt * length)

            SET temp TO availableCards[length]
            SET availableCards[length] TO availableCards[selectedCard]
            SET availableCards[selectedCard] TO temp
        END WHILE
    END METHOD

    METHOD cut()
        FOR iterA FROM 0 TO 62 DO
            APPEND availableCards[iterA] TO cutCards
            REMOVE availableCards[iterA]
        END FOR
    END METHOD

    METHOD deal()
        FOR EACH iterB FROM Players DO
            APPEND availableCards[2 LAST] TO Players[iterB]
        END FOR
    END METHOD
    
    METHOD hit() 
        RETURN LAST availableCards INDEX
    END METHOD
    
    METHOD returnCards(cards) 
        PUSH cards TO spentCards
    END METHOD
    
    METHOD combineDecks()
        FOR i FROM Length(cutCards) TO 0 INCREMENT -2
			SET tempArray to []
			APPEND cutCards.End TO tempArray
			APPEND cutCards.End TO tempArray
            APPEND tempArray TO availableCards
        END FOR
        FOR j FROM Length(spentCards) TO 0 INCREMENT -2
			SET tempArray to []
			APPEND spentCards.End TO tempArray
			APPEND spentCards.End TO tempArray
            APPEND tempArray TO availableCards
        END FOR
    END METHOD
    
    METHOD store()
        WRITE {
            availableCards, availableCards
            cutCards, cutCards
            spentCards, spentCards
			players, players
			playing, PLAYING
        }  TO FILE
    END METHOD
END CLASS
    
CLASS Dealer:
    SET cards TO []
    SET turn TO False
    SET cardBalance TO 17
    
    METHOD display()
        FOR EACH card FROM cards
            SWITCH cards[1]:
                0: SET suit TO 'A'
                1: SET suit TO 'B'
                2: SET suit TO 'C'
                3: SET suit TO 'D'
            END SWITCH
			SWITCH colour
				'0': 'black',
				'1': 'red',
				'2': 'red',
				'3': 'black'
            END SWITCH
			
			SET value TO card[0] MOD 4 TO STRING
			SET suit TO suits[value]
            SET cardVal TO cards[1] + 1 TO HEXADECIMAL
            SET temp TO "0x0001F0" & suit & cardVal
            RETURN [temp TO UNICODE, colour[value]]
        END FOR    
    END METHOD
    
    METHOD evaluate()
        SET value TO 0
		SET flag TO False
		
        FOR iterC FROM 0 TO Length(cards)
            IF cards[iterC][1] = 0 OR flag IS False
				SET value TO value += 11
				SET flag TO True
			ELSE IF cards[iterC][1] < 10
				SET value TO cards[iterC][1] + 1
			ELSE
				SET value TO value + 10
			END IF
        END FOR
		
		IF flag AND value > 21
			SET value TO value - 10
        	RETURN value
		ELSE
        	RETURN value
		END IF
    END METHOD  
    
    METHOD natural()
        IF cards[0][1] IS ZERO AND cards[1][1] > 9 
            RETURN True
        IF cards[0][1] > 9 AND cards[1][1] IS 0
            RETURN True
        ELSE
            RETURN False
        END IF    
    END METHOD    
            
    METHOD stand()
        SET turn TO False 
    END METHOD
    
    METHOD hit()
        APPEND deck.hit() TO cards
    END METHOD
    
    METHOD returnCards()
		FOR i FROM Length(cards) TO 0 DO
			SET temp TO LAST INDEX cards
			REMOVE LAST INDEX cards
			deck.returnCards(temp)
		END FOR
    END METHOD
    
    METHOD store()
        WRITE {
            i & cards, cards
            i & players, players
        }  TO FILE
    END METHOD
END CLASS
    
CLASS AIhand INHERITS Dealer:
    SET bank TO 5000
    SET wager TO 50
    SET wagerBalance TO 0
    
    METHOD wagerBalanceCalc()
        SET wagerBalance TO RoundFloor(Math.random() * 3)
        SWITCH wagerBalance DO
            CASE 0:
                SET wager TO 10
                BREAK
            CASE 1:
                SET wager TO 50
                BREAK
            CASE 2:
                SET wager TO 100
                BREAK
            END SWITCH
    END METHOD

    METHOD cardBalance()
        SET max TO 9
        SET min TO 7
        SET x TO Math.floor(Math.random() * (max - min + 1) + min)
        SET y TO Math.floor(Math.random() * (max - min + 1) + min)
        SET cardBalance TO x + y
    END
    
    METHOD store(i)
        WRITE {
            i & cards, cards
			i & turn, turn
			i & cardBalance, cardbalance
			i & wagerBalance, wagerBalance
            i & bank, bank
            i & wager, wager
        }  TO FILE
    END METHOD
END CLASS

CLASS playerHand INHERITS Dealer:
    SET bank TO 5000
    SET wager TO 50
    SET splitCards TO []
    SET handle TO ""
    SET rounds TO 0

	METHOD stand
		settlement(True, True)
    END METHOD

	METHOD returnCards() {
		FOR i FROM Length(cards) TO 0 DO
			SET temp TO LAST INDEX cards
			REMOVE LAST INDEX cards
		END FOR
		
		FOR i FROM Length(cards) TO 0 DO
			SET temp TO LAST INDEX splitCards
			REMOVE LAST INDEX splitCards
		END FOR
    END METHOD

	METHOD splitCardsCheck() {
		IF cards[0][1] IS cards[1][1]
			RETURN True
		ELSE IF cards[0][1] > 8 AND cards[1][1] > 8) {
			RETURN True
		ELSE
			RETURN False
		END IF
    END METHOD

	METHOD splitTheCards() {
		APPEND cards[last] TO splitCards
		hit()
		hit()
		APPEND cards[last] TO splitCards
    END METHOD
    
    METHOD store(i)
        WRITE {
            i & cards, cards
            i & bank, bank
            i & wager, wager
            i & cardBalance, cardBalance
            i & handle, handle
            i & splitCards, splitCards
            i & turn, turn
			i & rounds, rounds
        }  TO FILE
    END METHOD
END CLASS

                # MAIN PROGRAM  #
SET deck TO NEW deck
SET Players TO UNDEFINED
SET PLAYING TO False

FUNCTION getID(x) 
	RETURN GET ELEMENT x FROM DOCUMENT
END FUNCTION

FUNCTION parse2D(object, item) 
    SET string TO READ FILE item
    SET data TO SPLIT string ON ,
	FOR k FROM 0 TO Length(data) INCREMENT 2 DO
		SET tempArray TO []
		APPEND data[k] TO tempArray
		APPEND data[k + 1] TO tempArray
	APPEND tempArray TO object
	END FOR
END FUNCTION
		
WHEN ARRAY.End RETURN ARRAY[ARRAY.length-1]
		
FUNCTION toggleWagers(bool) 
	SET x TO ALL ELEMENTS WHERE CLASS wager

	IF bool IS True
		FOR i FROM 0 TO Length(x) DO
			SET x[i].className TO mgame wager
		END FOR
	ELSE
		FOR i FROM 0 TO Length(x) DO
			< style x[i] to locked >
		END FOR
	END IF
END FUNCTION

FUNCTION round(Tournament):    
	HIDE deal, selectWager, nextRound, won, loss, tied, loseTournament, winTournament
	
	< unlock action buttons >
	
	toggleWagers(false)

    SET playerLength TO Length(Players)
	SET PLAYING TO True
	
	IF Length(deck.availableCards) < playerLength * 5 DO
		deck.combineDecks()
		deck.shuffle()
		deck.cut()
	END IF
	
	IF Length(Players[0].cards) > 0 
		FOR iterX FROM 0 TO playerLength DO 
			Players[iterX].returnCards()
		END FOR
	END IF
	
	FOR iterY FROM 1 TO playerLength-1 DO 
		Players[iterY].wagerBalanceCalc()
		Players[iterY].cardBalanceCalc()
	END FOR
		
	IF Players.End.rounds > 10
		tournament(Players.End.bank, Players.End.handle)
		RETURN
	END IF
		
    deck.deal()
    
    FOR EACH iterG FROM Players DO
        Players[iterG].store(iterG)
    END FOR
    
    deck.store()
    
    SET natural TO False
    FOR iter5 FROM 1 TO playerLength
        IF Players[iter5].natural() IS True
            SET natural TO True
        END IF
    END FOR
    
    IF natural IS False
		SET display TO ROUND DOWN (playersLength-1 / 2) + 1
		FOR iterE FROM 1 TO display DO
			SET Players[iterD].turn TO True
			WHILE Players[iterD].turn IS True Then
                IF Players[iterD].evaluate() > Players[iterD].balance THEN
                    Players[iterD].hit()
                ELSE
                    Players[iterD].stand()
                END IF
            END WHILE
        END FOR
	ELSE
		settlement(False, True)
    END IF
    
    IF Tournament IS True
		Players.End.rounds += 1
	END IF
END FUNCTION

FUNCTION newGame(players):
	play();
	
	SHOW deal, select wager
	HIDE nextRound, double, loseTournament, winTournament
	
	SET PLAYING TO False
	
	SET Players TO []
	SET deck TO new Deck()
	SET deck.players TO players
	
	PUSH NEW Dealer() TO Players

	GLOBALLY SET deck TO NEW Deck()

	FOR i FROM 1 TO players DO
		PUSH NEW VirtualHand() TO Players
	END FOR

	PUSH NEW playerHand() TO Players

    SET wager TO Players.End.wager
	< select wager >
	
    deck.createDeck(6)
    deck.shuffle()
    deck.cut()
END FUNCTION

FUNCTION settlement(noNatural, noDouble):
	SET PLAYING TO False

	< hide elements >
	< unlock action buttons >
	toggleWagers(true);

	SET wager TO Players.End.wager
	SET wager.className TO 'mgame wager selected'

	IF noNatural IS True DO
        FOR iter FROM 0 TO playerLength -1 DO 
			SET Players[l].turn TO True
			WHILE Players[l].turn IS True DO
				IF Players[l].evaluate() < Players[l].cardBalance DO
					Players[l].hit()
				ELSE
					Players[l].stand()
				END IF
			END WHILE
		END FOR
	END IF

	IF noNatural IS False DO
		IF Players.End.natural() DO
			Players.End.wager TO Players.End.wager * 1.5
		END IF
	END IF

	IF noDouble IS False {
		Players.End.wager += Players.End.wager
	END IF
	
	SET winnings TO Players.End.wager
	SET losings TO Players.End.wager

    FOR iterI FROM 1 TO Length(Players) DO
		IF noNatural IS False DO        
			IF Players[i].natural() DO            
				IF i IS Length(Players) - 1 DO
					SET Players[i].bank += Players[i].wager
					< display won >
				END IF
				SET Players[i].bank += Players[i].wager * 1.5
			END IF
            
		ELSE IF Players[0].evaluate() > 21 AND Players[i].evaluate() < 22 DO
			SET Players[i].bank += Players[i].wager

			IF i IS Length(Players) - 1
				< display won >
			END IF

		ELSE IF Players[i].evaluate() > 21 OR Players[i].evaluate() < Players[0].evaluate() DO
			SET Players[i].bank -= Players[i].wager

			IF i IS Length(Players) - 1 DO
				< display lost >
			END IF

		ELSE IF Players[i].evaluate() > Players[0].evaluate() DO
			SET Players[i].bank += Players[i].wager

			IF i IS Length(Players) - 1 DO
				< display won >
			END IF
            
		ELSE
			IF i IS Length(Players) - 1 DO
				< display tied >
			END IF
		END IF
	END FOR

	IF noNatural IS False DO
		IF Players.End.natural() DO
			SET Players.End.wager TO Players.End.wager / 1.5
		END IF
	END IF

	IF noDouble IS False DO
		SET Players.End.wager TO Players.End.wager / 2
	END FOR

	FOR iterI FROM 1 TO Length(Players)
		Players[i].store(i)
	END FOR

	deck.store()
END FUNCTION

FUNCTION tournament(bank, handle):
	SET table TO getID('leaderboardTable')
	SET lastRow TO table.rows[5]
	SET lastCellValue TO lastRow.cells[2].content
	SET value TO parseInt(lastCellValue.substr(1))
	
	SET PLAYING TO False
	< lock stand and hit >
	toggleWagers(false)
	
	IF value < bank DO
		SET tempArr TO []
		PUSH bank TO tempArr
        FOR iter FROM 1 TO 6 DO
			SET rowVal TO table.rows[i].cells[2].content
			SET Val TO parseInt(rowVal.substr(1))
			PUSH Val TO tempArr
		END FOR

		SET index TO UNDEFINED
		SET flag TO True
        
		FOR iter FROM 1 TO 6
			IF tempArr[i] < tempArr[i + 1] DO
				SET tempVal TO tempArr[i]
				tempArr[i] TO tempArr[i + 1]
				tempArr[i + 1] TO tempVal
				index TO i + 2
				SET flag TO False
			END IF
		END FOR
		
		IF flag IS True 
			SET index TO 1
		END IF
		
		SWITCH suffix
			'1': 'st',
			'2': 'nd',
			'3': 'rd',
			'4': 'th',
			'5': 'th'
		END SWITCH
		
		SHOW winTournamentText
		SET place TO index & suffix[index]
		
		FROM table DELETE ROW 5

		SET newRow TO table.insertRow(index)

		SET col1 TO document.createTextNode(index)
		SET col2 TO document.createTextNode(handle)
		SET col3 TO document.createTextNode('£' + bank)
		APPEND col1 TO newRow.insertCell(0)
		APPEND col2 TO newRow.insertCell(1)
		APPEND col3 TO newRow.insertCell(2)

		FOR iter FROM index + 1 TO 6 DO
            < reindex rows below the inserted row with the iterator >
			SET table.rows[i].cells[0].content TO i
		END FOR
	ELSE
		< show feedback for not placing on leaderboard >
	END IF
END FUNCTION

FUNCTION splitCards()
	HIDE split button
	< style player node >
END FUNCTION

FUNCTION loadGame() {
	play()

	< set dealer margins >

	toggleWagers(True)
	
	SWITCH bool
		'True' = True,
		'False' = False
	END SWITCH
	
	SET boolean TO bool[READ FILE playing]
	SET PLAYING TO boolean
	toggleWagers( NOT boolean )

	GLOBALLY SET Players TO []
	
	PUSH NEW Dealer() TO Players

	GLOBALLY SET deck TO NEW Deck()
	
    SET deck.availableCards TO READ FILE availableCards
    SET deck.cutCards TO READ FILE cutCards
    SET deck.spentCards TO READ FILE spentCards
    SET deck.players TO READ FILE Int(players)

	FOR i FROM 1 TO deck.players DO
		PUSH NEW VirtualHand() TO Players
	END FOR

	PUSH NEW playerHand() TO Players

    SET Players[0].cards TO READ FILE cards
    SET Players[0].turn TO READ FILE turn
    SET Players[0].cardBalance TO READ FILE cardBalance

	FOR j FROM 1 TO deck.players + 1 DO
		SET Players[j].cards TO READ FILE j & cards
		SET Players[j].bank TO READ FILE j & bank
		SET Players[j].wager TO READ FILE j & wager
		SET Players[j].turn TO READ FILE j & turn
		SET Players[j].cardBalance TO READ FILE j & cardBalance

		IF j IS deck.players DO
			SET Players[j].splitCards TO READ FILE j & splitCards
			SET Players[j].handle TO READ FILE j & handle
		} ELSE {
			SET Players[j].wagerBalance TO READ FILE j & wagerBalance
		END IF
	END FOR
	
	SET wager TO Players.End.wager
	< style wager >
	
	IF Players.End.Rounds > 0
		SHOW roundText
	ELSE 
		HIDE roundText
	END IF
END

FUNCTION clearNode(node) {
	WHILE node.firstChild
		REMOVE firstChild FROM node
	END WHILE
END FUNCTION

FUNCTION displayNode(node, object, cards, i) {
	FOR i FROM 0 TO Length(object.cards)
		SET card TO object.cards[Cd]
		SET unicard TO object.display(card)[0]
		SET content TO CREATE TEXT NODE unicard
		SET span TO CREATE ELEMENT SPAN
		SET span.className TO "card"
		APPEND content TO span
		SET span.style.color TO object.display(card)[1]
		APPEND span TO node
	END FOR
END FUNCTION

FUNCTION display() {
	SET total TO Players.End.bank
	
	SET dealerNode TO getID("dealer")
	SET dealer TO Players[0]
	
	clearNode(dealerNode)

	IF Length(dealer.cards) IS 0 OR PLAYING IS True) {
		SET card TO [0, -1]
		SET content TO document.createTextNode(dealer.display(card)[0])
		SET span TO document.createElement("span")
		span.className TO "card"
		APPEND content TO span
		IF PLAYING IS True
			SET span.style.color TO dealer.display(dealer.cards[0])[1]
		END IF
		APPEND span TO dealerNode
	END IF

	IF PLAYING IS True 
		SET Cd TO 1
	ELSE 
		SET Cd To 0
	END IF
	
	displayNode(dealerNode, dealer, Cd)

	FOR x FROM 1 TO 5 DO
		clearNode(getID("ai" + x))
	END FOR

	IF Length(Players) > 2	
		FOR PL FROM 1 TO deck.players DO
			SET aiNode TO getID("ai" + (Pl))			
			displayNode(aiNode, Players[Pl], 0)
		END FOR
	END IF

	SET playerNode TO getID('player')
	SET player TO Players.End
	
	clearNode(playerNode)

	displayNode(playerNode, player, 'cards', 0)

	SET splitNode TO getID('splitCards')

	clearNode(splitNode)

	IF Length(player.splitCards) > 0 DO
		FOR Cd FROM 0 TO LENGTH(Players.End.splitCards) DO
			SET card TO Players.End.splitCards[Cd]
			SET content TO document.createTextNode(Players.End.display(card)[0])
			SET span TO document.createElement("span")
			SET span.className TO "card"
			APPEND content TO span
			SET span.style.color TO Players.End.display(card)[1]
			APPEND span TO splitCards
		END FOR
	END IF
END FUNCTION

ON CLICK ID game DO makeClicker("gameScreen")
ON CLICK ID rules DO makeClicker("rulesScreen")
ON CLICK ID leaderboard DO makeClicker("leaderboardScreen")
ON CLICK ID exit DO makeClicker("exit")
ON CLICK ID create DO makeClicker("gameScreen2")
ON CLICK ID 10 DO makeWager("10")
ON CLICK ID 50 DO makeWager("50")
ON CLICK ID 100 DO makeWager("100")
SET main TO makeClicker("mainScreen")
SET play TO makeClicker("mainGame")

FUNCTION makeClicker(Button) {
	< assigns the onclick method to the below function >
	RETURN FUNCTION () {
		SET x TO ALL ELEMENTS WHERE CLASS IS screen
		FOR i FROM 0 TO Length(x) DO
			HIDE x[i]
		END FOR
		DISPLAY Button
	}
END FUNCTION

FUNCTION makeWager(Button) {
	< assigns the onclick method to the below function >
	RETURN FUNCTION () {
		IF PLAYING IS False
			SET Players.last().wager TO Integer(Button)

			toggleWagers(true)

			DISPLAY Button
		END IF
	}
END FUNCTION

SET y TO ALL ELEMENTS WHERE CLASS IS return
FOR k FROM 0 TO LENGTH(y) DO
	ON CLICK y[k] TO main
END FOR

ON CLICK ID decPlayers DO
	IF deck.players > 1
        SET deck.player -= 1
    END IF
END ON CLICK

ON CLICK ID incPlayers DO
	IF deck.players < 5
        SET deck.player += 1        
    END IF
END ON CLICK

ON CLICK ID play DO
	HIDE roundText

	< space dealer without tournament text >

	SWITCH deck.players
	CASE 1:
		< set margin to space the player accordingly >
		BREAK
	CASE 2:
		< set margin to space the player accordingly >
		BREAK
	CASE 3:
	CASE 4:
	CASE 5:
		< set margin to space the player accordingly >
		BREAK
	END SWITCH

	newGame(deck.players)
END ON CLICK

ON CLICK ID previous DO
	loadGame()
END ON CLICK

ON CLICK ID tournament DO
	SHOW roundText

	< space dealer without tournament text >
	< set margin to space the player accordingly >

	newGame(1)

	SET Players.End.rounds TO 1
	SET Players.End.handle TO GET KEYBOARD INPUT 'Handle: '
END ON CLICK

ON CLICK ID hit DO
	IF PLAYING IS True
		Players.End.hit()
	END IF
END ON CLICK

ON CLICK ID stand DO
	IF PLAYING IS True
		Players.End.stand()
	END IF
END ON CLICK

ON CLICK ID double DO
	Players.End.hit()
	settlement(True, False)
END ON CLICK

ON CLICK ID split DO
	Players.End.splitTheCards()
	< hide split button >
END ON CLICK

ON CLICK ID deal DO
    round(Players.End.rounds)
END ON CLICK

ON CLICK ID nextRound DO
    round(Players.End.rounds)
END ON CLICK

< call below every 0.1 seconds, and redraw screen >
	SET HTML players TO deck.players
	display()

	IF PLAYING IS True
		SET user TO Players.End

		IF user.evaluate() > 21  	
			settlement(True, True)
		END IF
		
		IF Length(user.cards) = 2
			IF user.evaluate() > 8 AND user.evaluate() < 12
				< show double button >
			ELSE
				< hide double button >
			END IF

			IF user.splitCardsCheck() 
				< show split button >
			ELSE
				< hide split button >
			END IF
		ELSE
			< hide double and split button >
		END IF
	END IF

	IF Players.End.rounds > 0 
		< show round 1 of 10 >
	END IF
< end call >