dev.to staff

Posted on Jan 24, 2020

Daily Challenge #170 - Pokemon Damage Calculator

#challenge

Setup

For this challenge, you'll be thrown into a Pokemon battle! Calculate the damage that a particular move would do using the following formula:

total damage = base damage * (attack / defense) * effectiveness

base damage = the original power of the attack
attack = your attack stat
defense = the opponent's defense stat
effectiveness = the effectiveness of the attack based on the type matchup

Attacks can be super effective, neutral, or not very effective depending on the matchup.

super effective : 2x damage
neutral: 1x damage
not very effective: 0.5x damage

To prevent the challenge from being too tedious, you'll only deal with four types: fire, water, grass, and electric. Here are the matchups:

fire > grass
fire < water
fire = electric
water < grass
water < electric
grass = electric
**Any type against itself is not very effective

Overall, the function you implement must take in:

your type
the opponent's type
attack power
the opponent's defense

... and must output the total damage of the attack.

Tests

What are the total damage outputs of these attacks?

"grass", "electric", 57, 19
"grass", "water", 40, 40
"grass", "fire", 35, 5
"fire", "electric", 10, 2

Good luck!

This challenge comes from yaphi1 on CodeWars. Thank you to CodeWars, who has licensed redistribution of this challenge under the 2-Clause BSD License!

Want to propose a challenge idea for a future post? Email yo+challenge@dev.to with your suggestions!

Top comments (5)

Kyle Jones • Jan 24 '20 • Edited

As there's no mention of the value, I set the base damage to 50 in each scenario.

Code

def compare_attack_types(first_type, second_type):
    if first_type == "fire":
        if second_type == "grass":
            return 2
        if second_type == "water":
            return 0.5
    if first_type == "grass":
        if second_type == "fire":
            return 0.5
        if second_type == "water":
            return 2
    if first_type == "electric":
        if second_type == "water":
            return 2
    if first_type == "water":
        if second_type == "fire":
            return 2
        if second_type == "grass":
            return 0.5
    return 1

def calculate_damage(base_damage, own_type, opponent_type, attack, defense):
    return base_damage * (attack / defense) * compare_attack_types(own_type, opponent_type)

print(calculate_damage(50, "grass", "electric", 57, 19))
print(calculate_damage(50, "grass", "water", 40, 40))
print(calculate_damage(50, "grass", "fire", 35, 5))
print(calculate_damage(50, "fire", "electric", 10, 2))

Results

150
100
175
250

lusen / they / them 🏳️‍🌈🥑 • Jan 24 '20

Ok cool. I'll use 50, too.

Here'a another Python implementation:

SUPER_EFFECTIVE = 'super_effective'
NEUTRAL = 'neutral'
NOT_VERY_EFFECTIVE = 'not_very_effective'

EFFECTIVENESS_MULTIPLIER = {
  SUPER_EFFECTIVE: 2,
  NEUTRAL: 1,
  NOT_VERY_EFFECTIVE: .5}

FIRE = 'fire'
GRASS = 'grass'
WATER = 'water'
ELECTRIC = 'electric'

ATTACK_ON_DEFENSE_EFFECTIVENESS = {
  FIRE: {
    FIRE: NOT_VERY_EFFECTIVE,
    GRASS: SUPER_EFFECTIVE,
    WATER: NOT_VERY_EFFECTIVE,
    ELECTRIC: NEUTRAL,
  },
  GRASS: {
    GRASS: NOT_VERY_EFFECTIVE,
    WATER: SUPER_EFFECTIVE,
    ELECTRIC: NEUTRAL,
    FIRE: NOT_VERY_EFFECTIVE
  },
  WATER: {
    WATER: NOT_VERY_EFFECTIVE,
    GRASS: NOT_VERY_EFFECTIVE,
    ELECTRIC: NOT_VERY_EFFECTIVE,
    FIRE: SUPER_EFFECTIVE
  },
  ELECTRIC: {
    ELECTRIC: NOT_VERY_EFFECTIVE,
    GRASS: NEUTRAL,
    WATER: SUPER_EFFECTIVE,
    FIRE: SUPER_EFFECTIVE
  }
}

def _calculate_effectiveness(attack_type, defense_type):
  effectiveness_name = ATTACK_ON_DEFENSE_EFFECTIVENESS[attack_type][defense_type]
  return EFFECTIVENESS_MULTIPLIER[effectiveness_name]

def _total_damage(base_damage, attack, defense, effectiveness):
  return base_damage * (attack / defense) * effectiveness

def calculate_damage(base_damage, attack_type, defense_type, attack_power, defense_power):
  return _total_damage(
    base_damage,
    attack_power,
    defense_power,
    _calculate_effectiveness(attack_type, defense_type)
  )

print(calculate_damage(50, "grass", "electric", 57, 19))
print(calculate_damage(50, "grass", "water", 40, 40))
print(calculate_damage(50, "grass", "fire", 35, 5))
print(calculate_damage(50, "fire", "electric", 10, 2))

Ilyes Chouia • Jan 31 '20 • Edited

PHP ::)

class Pokemon {

    public $baseDamage;
    public $own;
    public $opponent;
    public $attack;
    public $defense;

    public function __construct ($baseDamage, $own, $opponent, $attack, $defense)
    {
        $this->baseDamage = $baseDamage;
        $this->attack = $attack;
        $this->defense = $defense;
        $this->own = $own;
        $this->opponent = $opponent;
    }

    public function compareAttackTypes ()
    {
        switch($this->own){
            case "fire":
                if($this->opponent == "grass"){ return 2; }
                if($this->opponent == "water"){ return 0.5; }
            case "grass":
                if($this->opponent == "fire"){ return 0.5; }
                if($this->opponent == "water"){ return 2; }
            case "electric":
                if($this->opponent == "water"){ return 2; }
            case "water":
                if($this->opponent == "fire"){ return 2; }
                if($this->opponent == "grass"){ return 0.5; }
            default:
                return 1;
        }
    }

    public function calculateDamage ()
    {
        return $this->baseDamage * ($this->attack / $this->defense) * $this->compareAttackTypes();
    }
}

$pk = new Pokemon(50, "grass", "water", 40, 40); // result : 100
echo $pk->calculateDamage();

Craig McIlwrath • Jan 24 '20

Haskell solution. The last argument of the function is the base damage. I'm also changing the function to accept an ADT Type type instead of strings for the Pokémon type.

data Type = Grass | Fire | Water | Electric deriving (Eq)

effect :: Type -> Type -> Double
effect Fire Grass = 2
effect Water Fire = 2
effect Fire Electric = 1
effect Grass Water = 2
effect Electric Water = 2
effect Grass Electric = 1
effect a b
  | a == b    = 1
  | otherwise = recip $ effect b a

totalDamage :: Type -> Type -> Double -> Double -> Double -> Double
totalDamage t1 t2 att def = (*) $ att / def * effect t1 t2

SavagePixie • Jan 25 '20 • Edited

Pattern matching for the win!

I didn't know what to do with the base_power thing, so I left it as one.

Elixir

defmodule Pokemon do
  def calculate(effectiveness, attack, defence) do
    1 * (attack / defence) * effectiveness
  end

  def total_damage(a, a, att, def), do: calculate(0.5, att, def)
  def total_damage("electric", "water", att, def), do: calculate(2, att, def)
  def total_damage("fire", "grass", att, def), do: calculate(2, att, def)
  def total_damage("fire", "water", att, def), do: calculate(0.5, att, def)
  def total_damage("grass", "fire", att, def), do: calculate(0.5, att, def)
  def total_damage("grass", "water", att, def), do: calculate(2, att, def)
  def total_damage("water", "electric", att, def), do: calculate(0.5, att, def)
  def total_damage("water", "fire", att, def), do: calculate(2, att, def)
  def total_damage("water", "grass", att, def), do: calculate(0.5, att, def)
  def total_damage(_, _, att, def), do: calculate(1, att, def)
end

DEV Community

Daily Challenge #170 - Pokemon Damage Calculator

Setup

Tests

Top comments (5)

Code

Results

Read next

A Beginners Guide to Serverless API Gateway Authentication with Lambda Authorizer

Github Copilot is Now Free: Here's How to Set It Up

My 30-Day Kubernetes Learning Plan

5 Open-Source AI Tools You’ve Probably Missed.