ElegyOfDisaster-v2-kotlin/Effect.kt

import java.util.*

class WrongParameterException: Exception()

//This class take subjects[0] as the one to be damaged
class Damage(override vararg val subjects: Character,
             private val decreaseLife: Int) : Effect() {

    init {
        if (subjects.isEmpty() || decreaseLife <= 0) {
            throw WrongParameterException()
        }
    }

    private val subject = subjects[0]
    override val reverseEffect: Effect
        get() = Damage(subject.enemy, decreaseLife = decreaseLife)

    override val id = 1

    override fun apply() {
        subject.life -= decreaseLife
    }
}

//This class take subjects[0] as the one the be healed
class Heal(override vararg val subjects: Character, private val increaseLife: Int) : Effect() {

    init {
        if (subjects.isEmpty() || increaseLife <= 0) {
            throw WrongParameterException()
        }
    }

    private val subject = subjects[0]
    override val reverseEffect: Effect
        get() = Heal(subject.enemy, increaseLife = increaseLife)
    override val id = 2

    override fun apply() {
        subject.life += increaseLife
    }
}

//This class take subjects[0] as the one who draws from the deck
class DrawFromDeck(override vararg val subjects: Character,
                   private val numberOfCards: Int): Effect() {

    init {
        if (subjects.isEmpty() || numberOfCards <= 0) {
            throw WrongParameterException()
        }
    }

    private val subject = subjects[0]
    override val reverseEffect: Effect
        get() = DrawFromDeck(subject.enemy, numberOfCards = numberOfCards)
    override val id = 3

    override fun apply() {
        subject.drawFromDeck(numberOfCards)
    }
}

//This class take subjects[0] as the one who draws
//subjects[1] as the one whose cards is taken
class ChooseFromCharacterHand(override vararg val subjects: Character): Effect() {

    init {
        if (subjects.size < 2) {
            throw WrongParameterException()
        }
    }

    private val taker = subjects[0]
    private val giver = subjects[1]
    override val reverseEffect: Effect
        get() = ChooseFromCharacterHand(giver, taker)
    override val id = 4

    override fun apply() {
        taker.chooseFromCards(giver.hand)
    }
}

//This class take subjects[0] as the one who loses one card randomly
class LoseCard(override vararg val subjects: Character): Effect() {

    init {
        if (subjects.isEmpty()) {
            throw WrongParameterException()
        }
    }

    private val subject = subjects[0]
    override val reverseEffect: Effect
        get() = LoseCard(subject.enemy)
    override val id = 5

    override fun apply() {
        val cards = subject.hand
        val index = Random().nextInt(cards.size)
        cards.toMutableList().removeAt(index)
    }
}

//This class take subject[0] as the one who chooses the card
class ChooseFromDeck(override vararg val subjects: Character): Effect() {
    init {
        if (subjects.isEmpty()) {
            throw WrongParameterException()
        }
    }

    private val subject = subjects[0]
    override val reverseEffect: Effect
        get() = ChooseFromDeck(subject.enemy)
    override val id = 6

    override fun apply() {
        val random = Random()
        val first = random.nextInt(subject.deck.size)
        var second = random.nextInt(subject.deck.size)
        while(second == first) {
           second = random.nextInt(subject.deck.size)
        }
        var third = random.nextInt(subject.deck.size)
        while(third == first || third == second) {
            third = random.nextInt(subject.deck.size)
        }
        val cards = subject.deck.cards
        subject.chooseFromCards(mutableListOf(cards[first], cards[second], cards[third]))
    }
}

//This class take subject[0] as the one who was poisoned
class SolvePoison(override vararg val subjects: Character): Effect() {

    init {
        if (subjects.isEmpty()) {
            throw WrongParameterException()
        }
    }

    private val subject = subjects[0]
    override val reverseEffect: Effect
        get() = SolvePoison(subject.enemy)
    override val id = 7

    override fun apply() {
        subject.poisoned = false
    }
}

//The class take subject[0] as the one who's going to be poisoned
class Poison(override vararg val subjects: Character): Effect() {

    init {
        if (subjects.isEmpty()) {
            throw WrongParameterException()
        }
    }

    private val subject = subjects[0]
    override val reverseEffect: Effect
        get() = Poison(subject.enemy)
    override val id = 8

    override fun apply() {
        subject.poisoned = true
    }
}

//This class take subject[0] as the one who needs to defense attack
class Defense(override vararg val subjects: Character): Effect() {

    init {
        if (subjects.isEmpty()) {
            throw WrongParameterException()
        }
    }

    private val subject = subjects[0]
    override val reverseEffect: Effect
        get() = Defense(subject.enemy)
    override val id = 9

    override fun apply() {
        subject.effectBuffer = emptyArray()
        subject.attackingCard = null
    }
}

//This class take subject[0] as the one who wants to reflect the effect
class Reverse(override vararg val subjects: Character): Effect() {

    init {
        if (subjects.isEmpty()) {
            throw WrongParameterException()
        }
    }

    private val subject = subjects[0]
    override val reverseEffect: Effect
        get() = Reverse(subject.enemy)
    override val id = 10

    override fun apply() {
        subject.effectBuffer = subject.effectBuffer.map { it.reverseEffect }.toTypedArray()
        subject.effectBuffer.forEach { it.apply() }
    }
}