Sexscripts Memory game - wip

// Memory
// by MissEshock2002

// This script, from https://ss.deviatenow.com, is protected by this licence:
// CC0

boolean DEBUG = false

String SCRIPTNAME = "Memory"
String VERSION = "v0.4"

setInfos(9, SCRIPTNAME, "Memory game",
        "MissEshock2002",
        VERSION, 0x222222, "en", ["game", "memory", "estim", "electro", "formale", "forfemale"])


String SOUNDSDIR = "Memory/"
String EXT = ".wav"


List<String> arrowButtons = ["  ←  ", "  →  ", "  ↑  ", "  ↓  "]

// memory game vars:
int numberOfMatchingCards = 2 // number of cards to flip for match
int numberOfPairs = 6
List deck = []
boolean showCardImages = false
boolean showCardText = false
boolean playEstim = false

List<List> flipStack = [] // temp. save flipped cards
List rndCards = []
List cards = []
List flippedCards = []
int cols
int rows
int maxRow
int maxCol
int colPos = 0
int rowPos = 0

int score = 0
int failed = 0


int shockTime
List SHOCKTIMERANGE = [1, 10]
List shockTimeRange = SHOCKTIMERANGE
int shockTimePlus = 1

def clamp = { value, min, max -> return Math.max(min, Math.min(max, value)) }

// TODO sounds:
List sounds = []

// graphics:
int cardWidth = 160
int cardHeight = 220
int cardCornerSize = 12
int marginX = 10
int marginY = 10
java.awt.Color cardBGColor = java.awt.Color.DARK_GRAY
java.awt.Color cardBorderColor = java.awt.Color.LIGHT_GRAY
java.awt.Color cardFlippedBorderColor = java.awt.Color.WHITE
java.awt.Color bgColor = new java.awt.Color(24, 24, 24, 128)

String fontName = "Serif"
java.awt.Color fontColor = java.awt.Color.GRAY
java.awt.Color fontFlippedColor = java.awt.Color.WHITE

java.awt.BasicStroke stroke = new java.awt.BasicStroke(2)
java.awt.BasicStroke cursorStroke = new java.awt.BasicStroke(3)

String pathToCardDeck = "images/Bcards/StandardDeck2/"
def sampleImage = java.awt.Toolkit.getDefaultToolkit().getImage(pathToCardDeck + "0.png")
def cardBack = javax.imageio.ImageIO.read(new File(pathToCardDeck + "back.png"))

java.awt.geom.RoundRectangle2D cardRect
java.awt.geom.RoundRectangle2D cursorRect
String cardText = "?"
int imageWidth
int imageHeight
def frameBuffer
java.awt.Graphics graphics
java.awt.Font font


def initGraphics = {
    cardText = "?"

    if (showCardImages) {
        cardWidth = sampleImage.getWidth()
        cardHeight = sampleImage.getHeight()
    }

    cardRect = new java.awt.geom.RoundRectangle2D.Float(
            0, 0,
            cardWidth, cardHeight,
            cardCornerSize, cardCornerSize)

    cursorRect = new java.awt.geom.RoundRectangle2D.Float(
            0, 0,
            cardWidth, cardHeight,
            cardCornerSize, cardCornerSize)

    int fontSize = (int) (Math.min(cardWidth, cardHeight)) / 2
    font = new java.awt.Font(fontName, java.awt.Font.PLAIN, fontSize)

    imageWidth = (int) (cols * (cardWidth + marginX) + marginX)
    imageHeight = (int) (rows * (cardHeight + marginY) + marginY)
    frameBuffer = new java.awt.image.BufferedImage(imageWidth, imageHeight, java.awt.image.BufferedImage.TYPE_4BYTE_ABGR)
    graphics = frameBuffer.createGraphics()
    graphics.setRenderingHint(java.awt.RenderingHints.KEY_ANTIALIASING, java.awt.RenderingHints.VALUE_ANTIALIAS_ON)
}

def drawCards = {
    if (DEBUG) {
        show("DEBUG:\ncards:\n${cards.toString().replaceAll('],', "],\n")}" +
                "\n\nflipped cards:\n${flippedCards.toString().replaceAll('],', "],\n")}" +
                "\n\ncursor pos: col=${colPos}, row=${rowPos}" +
                "\ncard: ${cards[rowPos][colPos]}" +
                "\n\nflip stack: ${flipStack}" +
                "\n\nscore: ${score}" +
                "\n\nfailed: ${failed}" +
                "\n\nshockTime: ${shockTime}"
        )
    }

    // clear
    graphics.setBackground(bgColor)
    graphics.clearRect(0, 0, imageWidth, imageHeight)

    // draw cards
    (0..(rows - 1)).each { r ->
        (0..(cols - 1)).each { c ->
            if (cards[r][c] != null) {
                if (!showCardImages) {
                    cardRect.x = c * (cardWidth + marginX) + marginX
                    cardRect.y = r * (cardHeight + marginY) + marginY

                    // card BG
                    graphics.setColor(cardBGColor)
                    graphics.fill(cardRect)
                    graphics.draw(cardRect)

                    // card border
                    if (flippedCards[r][c]) {
                        graphics.setColor(cardFlippedBorderColor)
                    } else {
                        graphics.setColor(cardBorderColor)
                    }
                    graphics.setStroke(stroke)
                    graphics.draw(cardRect)
                }

                // card from deck of cards
                if (showCardImages) {
                    // card images
                    def cardImage = cardBack
                    if (flippedCards[r][c]) {
                        cardImage = javax.imageio.ImageIO.read(new File(pathToCardDeck + cards[r][c] + ".png"))
                    }
                    graphics.drawImage(cardImage,
                            c * (cardWidth + marginX) + marginX, r * (cardHeight + marginY) + marginY,
                            cardWidth, cardHeight, null)
                } else {
                    // card with text/numbers or none
                    if (flippedCards[r][c]) {
                        graphics.setColor(fontFlippedColor)
                        graphics.setFont(font)
                        java.awt.FontMetrics metrics = graphics.getFontMetrics(font)
                        if (showCardText) {
                            cardText = cards[r][c]
                        }
                        graphics.drawString(cardText,
                                (int) (cardRect.x + (cardRect.width - metrics.stringWidth(cardText)) / 2),
                                (int) (cardRect.y + ((cardRect.height - metrics.getHeight()) / 2) + metrics.getAscent()))
                    }
                }
            }
        }
    }

    // cursor
    graphics.setColor(java.awt.Color.GREEN)
    graphics.setStroke(cursorStroke)
    cursorRect.x = colPos * (cardWidth + marginX) + marginX
    cursorRect.y = rowPos * (cardHeight + marginY) + marginY
    graphics.draw(cursorRect)

    java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream()
    javax.imageio.ImageIO.write(frameBuffer, "png", baos)
    setImage(baos.toByteArray(), 0)
}


def getEstimFiles = {
    List<String> fileNames = []
    List<String> uniqueNames = []
    File dir = new File("sounds/" + SOUNDSDIR)
    dir.traverse(type: groovy.io.FileType.FILES, maxDepth: 0) { file ->
        if (file.name.endsWith(EXT)) fileNames.add(file.name)
    }
    if (fileNames.isEmpty()) {
        show("ERROR! Missing sound files?")
        showButton("Quit")
        exit()
    }
    return fileNames
}


List<String> estimFileNames = []

def initGame = {
    // reset
    score = 0
    failed = 0
    shockTime = shockTimeRange[0]
    deck = 0..51 // 52 cards

    // random cards
    List rndDeck = deck.collect()
    Collections.shuffle(rndDeck)
    (0..(numberOfPairs - 1)).each { n ->
        (0..(numberOfMatchingCards - 1)).each {
            rndCards.add(rndDeck[n])
        }
    }
    Collections.shuffle(rndCards)

    // fill cards with null
    cards.clear()
    (0..(rows - 1)).each { c ->
        List newRow = [null] * cols
        (0..(cols - 1)).each { r ->
            int pos = c * cols + r
            newRow[r] = rndCards[pos]
        }
        cards.add(newRow)
    }

    // fill flippedCards with false
    flippedCards.clear()
    cards.each { cardRow -> flippedCards.add([false] * cardRow.size()) }
    maxRow = cards[0].size() - 1
    maxCol = cards.size() - 1

    // list with sounds
    estimFileNames = getEstimFiles()
    Collections.shuffle(estimFileNames)
}

def playSoundNumber = { soundNumber ->
    if (!playEstim) return

    String sound = SOUNDSDIR + estimFileNames[soundNumber]
    int repetitions = (int) Math.ceil(shockTime / 10)
    playBackgroundSound(sound, repetitions)
    wait(shockTime)
    playBackgroundSound(null)
}

def showStats = {
    String statsText = "Shock Time = " + shockTime
    show(statsText)
}

def playMemory = {
    show(null)

    initGame()
    initGraphics()

    boolean gameOver = false
    while (!gameOver) {
        showStats()
        drawCards()
        int sel = getSelectedValue(null, (arrowButtons + "Flip"))
        if (sel == 0) colPos-- // left
        else if (sel == 1) colPos++ // right
        else if (sel == 2) rowPos-- // up
        else if (sel == 3) rowPos++ // down
        else { // flip
            List<Integer> currFlip = [rowPos, colPos]
            String flipedCard = cards[rowPos][colPos]
            if ((flippedCards[rowPos][colPos] == false) && cards[rowPos][colPos] != null) {
                flipStack.add(currFlip)
                flippedCards[rowPos][colPos] = true
                drawCards()
                playSoundNumber(cards[rowPos][colPos])

                if (flipStack.size() > 1) {
                    if (flipStack.any { pos -> cards[pos[0]][pos[1]] != cards[flipStack[0][0]][flipStack[0][1]] }) {
                        // TODO punishment
                        failed++
                        show("No match!")
                        wait(2)
                        flipStack.each { pos -> flippedCards[pos[0]][pos[1]] = false }
                        flipStack.clear()
                        shockTime += shockTimePlus
                        shockTime = Math.max(shockTime, shockTimeRange.min())
                        shockTime = Math.min(shockTime, shockTimeRange.max())
                    } else {
                        if (flipStack.size() == numberOfMatchingCards) {
                            // TODO reward
                            score++
                            show("Match!")
                            wait(2)
                            flipStack.each { pos -> cards[pos[0]][pos[1]] = null }
                            flipStack.clear()
                        }
                    }
                }
            }
        }
        colPos = clamp(colPos, 0, maxRow)
        rowPos = clamp(rowPos, 0, maxCol)

        gameOver = cards.every { cardRow -> cardRow.every { card -> card == null } }
    }

    show("Game Over")
    wait(2)
}


boolean endMain = false
while (!endMain) {
    show(null)
    setImage(null)

    while (true) {
        numberOfMatchingCards = getInteger("Number of cards to match? Pairs, triplets, ...? (2 - 4)", numberOfMatchingCards)
        if (numberOfMatchingCards >= 2 && numberOfMatchingCards <= 4) {
            break
        }
    }

    while (true) {
        numberOfPairs = getInteger("How many pairs, triplets, ...?", numberOfPairs)
        if (numberOfPairs >= 1 && numberOfPairs <= 52 / numberOfMatchingCards) {
            cols = (int) Math.ceil(Math.sqrt(numberOfPairs * numberOfMatchingCards))
            rows = (int) Math.ceil(numberOfPairs * numberOfMatchingCards / cols)
            break
        }
    }

    // play with cards, play with text/numbers or none
    int sel = getSelectedValue("Play with cards, play with numbers or blank cards", ["cards", "numbers", "blank"])
    if (sel == 0) {
        showCardImages = true
        showCardText = false
    } else if (sel == 1) {
        showCardImages = false
        showCardText = true
    } else {
        showCardImages = false
        showCardText = false
    }

    playEstim = getBoolean("Play eStim?")

    if (playEstim) {
        shockTimeRange[0] = getInteger("Min shock time?", shockTimeRange[0])
        shockTimeRange[1] = getInteger("Max shock time?", shockTimeRange[1])
        shockTimePlus = getInteger("Increase shock time per fail?", shockTimePlus)
    }

    playMemory()

    if (!getBoolean("Play again?")) endMain = true
}