path: root/Add-Hail-as-a-new-weather-condition.md

This tutorial is for how to add Hail as a new weather condition. Though it focuses on a specific weather condition, this can be used as a guideline to add any other crazy and wacky weather you wish.
Since Hail has a lot of similarities to Sandstorm, we can use it as a template in which we base our modifications on.


## Contents

1. [Define some new weather constants](#1-define-some-new-weather-constants)
2. [Add new text related to the weather condition](#2-add-new-text-related-to-the-weather-condition)
3. [Add damage-inflicting effect](#3-add-damage-inflicting-effect)
4. [Add Blizzard accuracy bypass effect](#4-add-blizzard-accuracy-bypass-effect)
5. [Halve Solar Beam's power during Hail](#5-halve-solar-beams-power-during-hail)
6. [Add move that triggers the weather condition](#6-add-move-that-triggers-the-weather-condition)
7. [Teach the AI how to use this weather effectively](#7-teach-the-ai-how-to-use-this-weather-effectively)
8. [Make it look flashy!](#8-make-it-look-flashy)


## 1. Define some new weather constants

Edit [constants/battle_constants.asm](../blob/master/constants/battle_constants.asm):

```diff
; values in wBattleWeather
	const_def
	const WEATHER_NONE
	const WEATHER_RAIN
	const WEATHER_SUN
	const WEATHER_SANDSTORM
+	const WEATHER_HAIL
	const WEATHER_RAIN_END
	const WEATHER_SUN_END
	const WEATHER_SANDSTORM_END
+	const WEATHER_HAIL_END
```


## 2. Add new text related to the weather condition

We need to create some new battle text to go along with the most relevant effects that our weather condition shall have (such as when it is started/ended, etc).

Edit [data/text/battle.asm](../blob/master/data/text/battle.asm):

```diff
 BattleText_TheSandstormRages:
	text "The sandstorm"
	line "rages."
	prompt
 
+BattleText_HailContinuesToFall:
+	text "Hail continues to"
+	line "fall."
+	prompt
+
 BattleText_TheRainStopped:
	text "The rain stopped."
	prompt

	...

 BattleText_TheSandstormSubsided:
	text "The sandstorm"
	line "subsided."
	prompt
 
+BattleText_TheHailStopped:
+	text "The hail stopped."
+	prompt
+
 BattleText_EnemyMonFainted:
	text "Enemy @"
	text_ram wEnemyMonNick

	...

 BattleText_NoTimeLeftToday: ; unreferenced
	text "There is no time"
	line "left today!"
	done

+ItStartedToHailText:
+	text "It started"
+	line "to hail!"
+	prompt
+
+PeltedByHailText:
+	text "<USER>"
+	line "is pelted by HAIL!"
+	prompt
+
```

## 3. Add damage-inflicting effect

Using Sandstorm as a guideline, we can create the actual effects of this new weather condition. This means inflicting some damage to all Pokémon, possibly excluding Ice-types. For Sandstorm, this is done core.asm.

Edit `HandleWeather` in [engine/battle/core.asm](../blob/master/engine/battle/core.asm):

```diff
 HandleWeather:
	...
	ld hl, wWeatherCount
	dec [hl]
-	jr z, .ended
+	jr nz, .continues

+; ended
+	ld hl, .WeatherEndedMessages
+	call .PrintWeatherMessage
+	xor a
+	ld [wBattleWeather], a
+	ret
+
+.continues
	ld hl, .WeatherMessages
	call .PrintWeatherMessage

	ld a, [wBattleWeather]
	cp WEATHER_SANDSTORM
-	ret nz
+	jr nz, .check_hail
 
	ldh a, [hSerialConnectionStatus]
	cp USING_EXTERNAL_CLOCK
	jr z, .enemy_first

	...

	ld hl, SandstormHitsText
	jp StdBattleTextbox

-.ended
-	ld hl, .WeatherEndedMessages
-	call .PrintWeatherMessage
-	xor a
-	ld [wBattleWeather], a
-	ret
+.check_hail
+	ld a, [wBattleWeather]
+	cp WEATHER_HAIL
+	ret nz
+
+	ldh a, [hSerialConnectionStatus]
+	cp USING_EXTERNAL_CLOCK
+	jr z, .enemy_first_hail
+
+; player first
+	call SetPlayerTurn
+	call .HailDamage
+	call SetEnemyTurn
+	jr .HailDamage
+
+.enemy_first_hail
+	call SetEnemyTurn
+	call .HailDamage
+	call SetPlayerTurn
+
+.HailDamage:
+	ld a, BATTLE_VARS_SUBSTATUS3
+	call GetBattleVar
+	bit SUBSTATUS_UNDERGROUND, a
+	ret nz
+
+	ld hl, wBattleMonType1
+	ldh a, [hBattleTurn]
+	and a
+	jr z, .ok1
+	ld hl, wEnemyMonType1
+.ok1
+	ld a, [hli]
+	cp ICE
+	ret z
+
+	ld a, [hl]
+	cp ICE
+	ret z
+
+	call GetSixteenthMaxHP
+	call SubtractHPFromUser
+
+	ld hl, PeltedByHailText
+	jp StdBattleTextbox

 .PrintWeatherMessage:
	ld a, [wBattleWeather]

	...

 .WeatherMessages:
 ; entries correspond to WEATHER_* constants
	dw BattleText_RainContinuesToFall
	dw BattleText_TheSunlightIsStrong
	dw BattleText_TheSandstormRages
+	dw BattleText_HailContinuesToFall

 .WeatherEndedMessages:
 ; entries correspond to WEATHER_* constants
	dw BattleText_TheRainStopped
	dw BattleText_TheSunlightFaded
	dw BattleText_TheSandstormSubsided
+	dw BattleText_TheHailStopped
 ...
```

Some things to note. The `.ended` branch was moved up so as to avoid an unnecessary `jp` instruction after adding the Hail handling, and moves it closer to where the actual weather count check is made. If the weather effect is otherwise still continuing, then the code jumps to the `.continues` branch to execute the right weather effect.

Most of the code for Hail is copied from the Sandstorm handling, with exception of the text to print and the types that are unaffected. Additionally, the animation is removed because we have yet to add any fancy visuals to the new effects (this will optionally be added later). Lastly, the actual battle text data we added in the previous step are referenced for use here.


## 4. Add Blizzard accuracy bypass effect

Another effect of Hail is making it so that Blizzard does not miss when it is active. We can handle this the same way that the game handles Thunder accuracy under the effects of rain.

First we should associate Blizzard with a new specific move effect, which will be subject to the Hail accuracy handling we will implement. (More detail on this process in [this tutorial](https://github.com/pret/pokecrystal/wiki/Add-a-new-move-effect)).

Edit [constants/move_effect_constants.asm](../blob/master/constants/move_effect_constants.asm):

```diff
 ; MoveEffectsPointers indexes (see data/moves/effects_pointers.asm)
	const_def
	...
	const EFFECT_BEAT_UP
	const EFFECT_FLY
	const EFFECT_DEFENSE_CURL
+	const EFFECT_BLIZZARD
 NUM_MOVE_EFECTS EQU const_value
```

Edit [data/moves/moves.asm](../blob/master/data/moves/moves.asm):

```diff
 Moves:
 ; entries correspond to constants/move_constants.asm
	...
	move ICE_BEAM,     EFFECT_FREEZE_HIT,         95, ICE,          100, 10,  10
-	move BLIZZARD,     EFFECT_FREEZE_HIT,        120, ICE,           70,  5,  10
+	move BLIZZARD,     EFFECT_BLIZZARD,          120, ICE,           70,  5,  10
	move PSYBEAM,      EFFECT_CONFUSE_HIT,        65, PSYCHIC_TYPE, 100, 20,  10
```

For the effect pointer, we will reuse FreezeHit, since for the purposes of what commands the move will call, it is functionally identical to that effect. We don't need to copy it for a new redundant effect.

Edit [data/moves/effects_pointers.asm](../blob/master/data/moves/effects_pointers.asm):

```diff
 MoveEffectsPointers:
 ; entries correspond to EFFECT_* constants
	...
	dw BeatUp
	dw Fly
	dw DefenseCurl
+	dw FreezeHit ; for Blizzard, purposefully with different EFFECT_* constant
	assert_table_length NUM_MOVE_EFECTS
```

Now we can check for this move effect when performing the accuracy checks, similar to how Thunder works in rain.

Edit `BattleCommand_CheckHit` in [engine/battle/effect_commands.asm](../blob/master/engine/battle/effect_commands.asm):

```diff
 BattleCommand_CheckHit:
	...
	call .ThunderRain
	ret z
 
+	call .BlizzardHail
+	ret z
+
	call .XAccuracy
	ret nz
 
	...

	cp WEATHER_RAIN
	ret
 
+.BlizzardHail:
+; Return z if the current move always hits in hail, and it is hailing.
+	ld a, BATTLE_VARS_MOVE_EFFECT
+	call GetBattleVar
+	cp EFFECT_BLIZZARD
+	ret nz
+
+	ld a, [wBattleWeather]
+	cp WEATHER_HAIL
+	ret
+
 .XAccuracy:
	ld a, BATTLE_VARS_SUBSTATUS4
	call GetBattleVar
	...
```

`BattleCommand_CheckHit` is the routine which checks/decides whether any move (with some exceptions) will connect or not. There are special cases, such as Thunder in rain or having the "Locked-On" substatus. Here we add a subroutine which checks whether it's Blizzard (or more specifically, a move that has the effect EFFECT_BLIZZARD) and it's hailing, in which case it completely bypasses the accuracy check.

## 5. Halve Solar Beam's power during Hail

During hail, Solar Beam's power is reduced by 50%, so we need to implement this. Go to [data/battle/weather_modifiers.asm](../blob/master/data/battle/weather_modifiers.asm):

```diff
 WeatherTypeModifiers:
	db WEATHER_RAIN, WATER, MORE_EFFECTIVE
	db WEATHER_RAIN, FIRE,  NOT_VERY_EFFECTIVE
	db WEATHER_SUN,  FIRE,  MORE_EFFECTIVE
	db WEATHER_SUN,  WATER, NOT_VERY_EFFECTIVE
	db -1 ; end

 WeatherMoveModifiers:
	db WEATHER_RAIN, EFFECT_SOLARBEAM, NOT_VERY_EFFECTIVE
+	db WEATHER_HAIL, EFFECT_SOLARBEAM, NOT_VERY_EFFECTIVE
	db -1 ; end
```

## 6. Add move that triggers the weather condition

We have successfully added a weather condition that we can never trigger. Let's fix that by introducing a new move, Hail. You can follow [this tutorial](https://github.com/pret/pokecrystal/wiki/Add-a-new-move) to learn how to add a new move, with the caveat that it should have a new move effect which we will implement, EFFECT_HAIL. Its battle properties are `HAIL, EFFECT_HAIL, 0, ICE, 100, 10, 0`. Let's define what this effect does.

Modify [constants/move_effect_constants.asm](../blob/master/constants/move_effect_constants.asm) again:

```diff
 ; MoveEffectsPointers indexes (see data/moves/effects_pointers.asm)
	const_def
	...
	const EFFECT_BEAT_UP
	const EFFECT_FLY
	const EFFECT_DEFENSE_CURL
	const EFFECT_BLIZZARD
+	const EFFECT_HAIL
 NUM_MOVE_EFECTS EQU const_value
```

Edit [data/moves/effects_pointers.asm](../blob/master/data/moves/effects_pointers.asm) again:

```diff
MoveEffectsPointers:
; entries correspond to EFFECT_* constants
	...
	dw BeatUp
	dw Fly
	dw DefenseCurl
	dw FreezeHit ; for Blizzard, purposefully with different EFFECT_* constant
+	dw Hail
	assert_table_length NUM_MOVE_EFECTS
```

Edit [data/moves/effects.asm](../blob/master/data/moves/effects.asm):

```diff
 MoveEffects: ; used only for BANK(MoveEffects)

 ...

 DefenseCurl:
	checkobedience
	usedmovetext
	doturn
	defenseup
	curl
	lowersub
	statupanim
	raisesub
	statupmessage
	statupfailtext
	endmove

+Hail:
+	checkobedience
+	usedmovetext
+	doturn
+	starthail
+	endmove
+
```

Edit [macros/scripts/battle_commands.asm](../blob/master/macros/scripts/battle_commands.asm):

```diff
 ; BattleCommandPointers indexes (see data/battle/effect_command_pointers.asm)
	...
 	command supereffectivelooptext  ; ad
 	command startloop               ; ae
 	command curl                    ; af
+	command starthail               ; b0
NUM_EFFECT_COMMANDS EQU const_value - 1

	const_def -1, -1
	command endmove                 ; ff
	command endturn                 ; fe
```

Edit [data/battle/effect_command_pointers.asm](../blob/master/data/battle/effect_command_pointers.asm):

```diff
 BattleCommandPointers:
 ; entries correspond to macros/scripts/battle_commands.asm
	...
	dw BattleCommand_SuperEffectiveLoopText
	dw BattleCommand_StartLoop
	dw BattleCommand_Curl
+	dw BattleCommand_StartHail
	assert_table_length NUM_EFFECT_COMMANDS
```

Here we introduced a new effect for starting the hail weather condition, and associated it to a battle command routine which will be called when the move is used successfully. Again we can draw inspiration from the Sandstorm related routine, `BattleCommand_StartSandstorm`.

Create [engine/battle/move_effects/hail.asm](../blob/master/engine/battle/move_effects/hail.asm):

```diff
+BattleCommand_StartHail:
+; starthail
+
+	ld a, [wBattleWeather]
+	cp WEATHER_HAIL
+	jr z, .failed
+
+	ld a, WEATHER_HAIL
+	ld [wBattleWeather], a
+	ld a, 5
+	ld [wWeatherCount], a
+	ld hl, ItStartedToHailText
+	jp StdBattleTextbox
+
+.failed
+	call AnimateFailedMove
+	jp PrintButItFailed
+
```

Edit [engine/battle/effect_commands.asm](../blob/master/engine/battle/effect_commands.asm) again:

```diff
 INCLUDE "engine/battle/move_effects/future_sight.asm"

 INCLUDE "engine/battle/move_effects/thunder.asm"

+INCLUDE "engine/battle/move_effects/hail.asm"

 CheckHiddenOpponent:
	...
```

This routine simply loads the weather with the hail constant we defined, and sets its remaining turns to 5; in case hail is already set up, it'll fail. The function also prints text depending on what happens. For all practical purposes, our new weather is now implemented.
If you run this at this stage, the new move is functional and the effects work as intended, but we can still do some extra steps in order to polish it. The rest of the sections should be considered optional.


## 7. Teach the AI how to use this weather effectively

There is already some rudimentary logic on how the AI uses the other weather effects. Let's implement some basic checking to have the AI also use Hail in a (minimally) effective manner.

Modify [engine/battle/ai/redundant.asm](../blob/master/engine/battle/ai/redundant.asm):

```diff
 .Moves:	
	...
	dbw EFFECT_MOONLIGHT,    .Moonlight
	dbw EFFECT_SWAGGER,      .Swagger
	dbw EFFECT_FUTURE_SIGHT, .FutureSight
+	dbw EFFECT_HAIL,         .Hail
	db -1

	...
 
+.Hail:
+	ld a, [wBattleWeather]
+	cp WEATHER_HAIL
+	jr z, .Redundant
+	jr .NotRedundant
+
 .Heal:
 .MorningSun:
 .Synthesis:
 .Moonlight:
	...
```

This file lists some moves that the AI can quickly check for redundancy. Hail has a quick redundancy check in which, if it's hailing, then the move should be dismissed.

Edit [engine/battle/ai/scoring.asm](../blob/master/engine/battle/ai/scoring.asm):

```diff
 AI_Smart_EffectHandlers:
	...
	dbw EFFECT_SOLARBEAM,        AI_Smart_Solarbeam
	dbw EFFECT_THUNDER,          AI_Smart_Thunder
	dbw EFFECT_FLY,              AI_Smart_Fly
+	dbw EFFECT_HAIL,             AI_Smart_Hail
	db -1 ; end

	...
 
 .SandstormImmuneTypes:
	db ROCK
	db GROUND
	db STEEL
	db -1 ; end

+AI_Smart_Hail:
+; Greatly discourage this move if the player is immune to Hail damage.
+	ld a, [wBattleMonType1]
+	cp ICE
+	jr z, .greatly_discourage
+
+	ld a, [wBattleMonType2]
+	cp ICE
+	jr z, .greatly_discourage
+
+; Discourage this move if player's HP is below 50%.
+	call AICheckPlayerHalfHP
+	jr nc, .discourage
+
+; Encourage move if AI has good Hail moves
+	push hl
+	ld hl, .GoodHailMoves
+	call AIHasMoveInArray
+	pop hl
+	jr c, .encourage
+
+; 50% chance to encourage this move otherwise.
+	call AI_50_50
+	ret c
+
+.encourage
+	dec [hl]
+	ret
+
+.greatly_discourage
+	inc [hl]
+.discourage
+	inc [hl]
+	ret
+
+.GoodHailMoves
+	db BLIZZARD
+	db -1 ; end
+
 AI_Smart_Endure:
	ld a, [wEnemyProtectCount]
	and a
```

We base this behavior on the Sunny Day/Rain Dance and Sandstorm AI-related routines. The AI will avoid using the move if the player is immune to Hail or has low HP, and will encourage the move if it has any "Good Hail moves", which right now is only composed of the move Blizzard. This list is fully extensible with other moves.


## 8. Make it look flashy!

The move and weather have no special animations. It's completely possible to reuse some other move animation (such as Powder Snow), but we can quickly whip something up with the resources we already have at our disposal. The Sandstorm animation already works well as a "weather hazard," and there are some sprites representing ice, so let's make use of them.

Edit [constants/battle_anim_constants.asm](../blob/master/constants/battle_anim_constants.asm):

```diff
 ; BattleAnimObjects indexes (see data/battle_anims/objects.asm)
	const_def
	...
	const ANIM_OBJ_PLAYERHEAD_1ROW
	const ANIM_OBJ_ENEMYFEET_2ROW
	const ANIM_OBJ_PLAYERHEAD_2ROW
+	const ANIM_OBJ_HAIL
 NUM_ANIM_OBJS EQU const_value
 
 ; BattleAnimFrameData indexes (see data/battle_anims/framesets.asm)
	const_def
	...
	const BATTLEANIMFRAMESET_B6
	const BATTLEANIMFRAMESET_B7
	const BATTLEANIMFRAMESET_B8
+	const BATTLEANIMFRAMESET_HAIL
 NUM_BATTLEANIMFRAMESETS EQU const_value
 
 ; BattleAnimOAMData indexes (see data/battle_anims/oam.asm)
	const_def
	...
	const BATTLEANIMOAMSET_D5
	const BATTLEANIMOAMSET_D6
	const BATTLEANIMOAMSET_D7
+	const BATTLEANIMOAMSET_HAIL
 NUM_BATTLEANIMOAMSETS EQU const_value
```

Edit [data/battle_anims/framesets.asm](../blob/master/data/battle_anims/framesets.asm):

```diff
 BattleAnimFrameData:
 ; entries correspond to BATTLEANIMFRAMESET_* constants
	...
	dw .Frameset_b6 ; BATTLEANIMFRAMESET_B6
	dw .Frameset_b7 ; BATTLEANIMFRAMESET_B7
	dw .Frameset_b8 ; BATTLEANIMFRAMESET_B8
+	dw .Frameset_Hail ; BATTLEANIMFRAMESET_HAIL
	assert_table_length NUM_BATTLEANIMFRAMESETS
 
	...

.Frameset_b8:
	frame BATTLEANIMOAMSET_D7,  8
	endanim
+
+.Frameset_Hail:
+	frame BATTLEANIMOAMSET_HAIL, 32
+	endanim
```

Edit [data/battle_anims/oam.asm](../blob/master/data/battle_anims/oam.asm):

```diff
 BattleAnimOAMData:
 ; entries correspond to BATTLEANIMOAMSET_* constants
	...
	battleanimoam $00,  6, .OAMData_d5 ; BATTLEANIMOAMSET_D5
	battleanimoam $00, 14, .OAMData_d6 ; BATTLEANIMOAMSET_D6
	battleanimoam $00, 12, .OAMData_d7 ; BATTLEANIMOAMSET_D7
+	battleanimoam $00, 13, .OAMData_Hail ; BATTLEANIMOAMSET_HAIL
	assert_table_length NUM_BATTLEANIMOAMSETS
 
	...

	dbsprite   6,  -2, 4, 0, $00, $0
	dbsprite   8,  -4, 4, 0, $00, $0
	dbsprite  10,  -2, 4, 0, $00, $0

+.OAMData_Hail:
+	dbsprite -13,  -2, 4, 0, $04, $0
+	dbsprite -11,  -4, 4, 0, $04, $0
+	dbsprite  -9,  -1, 4, 0, $04, $0
+	dbsprite  -7,  -5, 4, 0, $04, $0
+	dbsprite  -5,  -3, 4, 0, $04, $0
+	dbsprite  -3,  -5, 4, 0, $04, $0
+	dbsprite  -1,  -3, 4, 0, $04, $0
+	dbsprite   0,  -3, 4, 0, $04, $0
+	dbsprite   2,  -5, 4, 0, $04, $0
+	dbsprite   4,   0, 4, 0, $04, $0
+	dbsprite   6,  -2, 4, 0, $04, $0
+	dbsprite   8,  -4, 4, 0, $04, $0
+	dbsprite  10,  -2, 4, 0, $04, $0
+
```

These are simply some frame and OAM data that we'll use to get the proper tile from the tileset we'll load along with the new animation. The structure of the OAMData_Hail in particular is the same as Sandstorm's, but with a different tile stored in VRAM. Now we should create an object that will take the form of this little "hail crystal".

Modify [data/battle_anims/objects.asm](../blob/master/data/battle_anims/objects.asm):

```diff
 ; ANIM_OBJ_ENEMYFEET_2ROW
	battleanimobj ABSOLUTE_X, $00, BATTLEANIMFRAMESET_B7, BATTLEANIMFUNC_NULL, PAL_BATTLE_OB_ENEMY, ANIM_GFX_PLAYERHEAD
 ; ANIM_OBJ_PLAYERHEAD_2ROW
	battleanimobj ABSOLUTE_X, $00, BATTLEANIMFRAMESET_B8, BATTLEANIMFUNC_NULL, PAL_BATTLE_OB_PLAYER, ANIM_GFX_ENEMYFEET
+; ANIM_OBJ_HAIL
+	battleanimobj RELATIVE_X | X_FLIP, $00, BATTLEANIMFRAMESET_HAIL, BATTLEANIMFUNC_RAIN_SANDSTORM, PAL_BATTLE_OB_BLUE, ANIM_GFX_ICE
	assert_table_length NUM_ANIM_OBJS
```

Objects are the data structures that serve as the "particles" in the game's animation engine. So having the object created, we need to use them in some form of animation sequence. We're going to create two different animations, which will use the same sequence. Since the animation constant for a move corresponds to it the move's constant already, we only need to define one extra animation constant for the situation where the hail should play between turns (such as the case with Sandstorm).

Edit [constants/move_constants.asm](../blob/master/constants/move_constants.asm):

```diff
 ; battle anims
	...
	const ANIM_WOBBLE            ; 113
	const ANIM_SHAKE             ; 114
	const ANIM_HIT_CONFUSION     ; 115
+	const ANIM_IN_HAIL           ; 116
 NUM_BATTLE_ANIMS EQU const_value - 1
```

Modify [data/moves/animations.asm](../blob/master/data/moves/animations.asm):

```diff
	dw BattleAnim_Whirlpool
	dw BattleAnim_BeatUp
+	dw BattleAnim_Hail
	assert_table_length NUM_ATTACKS + 1
-	dw BattleAnim_252
	dw BattleAnim_253
	dw BattleAnim_254
	dw BattleAnim_SweetScent2

	...

	dw BattleAnim_Wobble
	dw BattleAnim_Shake
	dw BattleAnim_HitConfusion
+	dw BattleAnim_InHail
	assert_table_length NUM_BATTLE_ANIMS + 1

 BattleAnim_0:
-BattleAnim_252:
 BattleAnim_253:
 BattleAnim_254:
 BattleAnim_MirrorMove:
	anim_ret

	...

	anim_obj ANIM_OBJ_HIT_BIG_YFIX, 136, 48, $0
	anim_wait 8
	anim_call BattleAnim_ShowMon_0
	anim_ret

+BattleAnim_Hail:
+BattleAnim_InHail:
+	anim_1gfx ANIM_GFX_ICE
+	anim_bgeffect ANIM_BG_WHITE_HUES, $0, $8, $0
+	anim_obj ANIM_OBJ_HAIL, 88, 0, $0
+	anim_wait 8
+	anim_obj ANIM_OBJ_HAIL, 72, 0, $1
+	anim_wait 8
+	anim_obj ANIM_OBJ_HAIL, 56, 0, $2
+.loop
+	anim_sound 0, 1, SFX_SHINE
+	anim_wait 8
+	anim_loop 8, .loop
+	anim_wait 8
+	anim_ret
+

 BattleAnimSub_Drain:
	anim_obj ANIM_OBJ_DRAIN, 132, 44, $0
	anim_obj ANIM_OBJ_DRAIN, 132, 44, $8
	anim_obj ANIM_OBJ_DRAIN, 132, 44, $10
...
```

The animation is now complete, so now we can call it whenever we need to show some hailing in the battle screen.

Edit `HandleWeather.HailDamage` in [engine/battle/core.asm](../blob/master/engine/battle/core.asm):

```diff
 .HailDamage:
	...

	ld a, [hl]
	cp ICE
	ret z

+	call SwitchTurnCore
+	xor a
+	ld [wNumHits], a
+	ld de, ANIM_IN_HAIL
+	call Call_PlayBattleAnim
+	call SwitchTurnCore
+
	call GetSixteenthMaxHP
	call SubtractHPFromUser

	ld hl, PeltedByHailText
	jp StdBattleTextbox
```

Modify the earlier file we created, `BattleCommand_StartHail` in [engine/battle/move_effects/hail.asm](../blob/master/engine/battle/move_effects/hail.asm):

```diff
 BattleCommand_StartHail:
 ; starthail
	...
	ld a, WEATHER_HAIL
	ld [wBattleWeather], a
	ld a, 5
	ld [wWeatherCount], a
+	call AnimateCurrentMove
	ld hl, ItStartedToHailText
	jp StdBattleTextbox
	...
```

And with that, everything is in place, and now we have a brand new weather type to use in the game! The main point of this tutorial was to show how one can simply use the resources already available to create something new. In a lot of cases, it helps to check similar systems already implemented in the codebase.

![Screenshot](https://i.imgur.com/WIqgj2c.gif)