# Exemple

Script complet et fonctionnel, récolte Orchidée Freyesque avec utilisation du Havre-Sac et retour en banque entre 85 et 90%.

```csharp
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Retn.Game;
using Retn.Game.Pathing;
using Retn.Game.Script;
using Retn.Protocol.Game.Enums;

namespace Retn.Script;

public class Freyesque(IScript script)
{
    private IScriptMap Map => script.Map;
    private IScriptNpc Npc => script.Npc;
    private IScriptBank Bank => script.Bank;
    private IScriptFight Fight => script.Fight;
    private IScriptInventory Inventory => script.Inventory;
    private IScriptCharacter Character => script.Character;

    [Handler]
    public Task OnLoadedAsync()
    {
        Bank.SetWeightLimit(85, 90);

        return Task.CompletedTask;
    }

    [Handler]
    public async Task OnMoveAsync(int count)
    {
        var items = Inventory.GetItems([7968]);

        foreach (var item in items)
        {
            await Inventory.UseAsync(item, item.Quantity);
        }
        
        var move = new Dictionary<(short, short), List<Func<Task>>>
        {
            [(0, 0)] =
            [
                async () => { await Map.UseZaapAsync(73400320); }
            ],
            [(-16, 1)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Right);
                }
            ],
            [(-15, 1)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Down);
                }
            ],
            [(-15, 2)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Left);
                }
            ],
            [(-16, 2)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Left);
                }
            ],
            [(-17, 2)] =
            [
                async () => { await Map.ChangeToAsync(ChangeMapSide.Up); }
            ],
            [(-17, 1)] =
            [
                async () => { await Map.ChangeToAsync(ChangeMapSide.Up); }
            ],
            [(-17, 0)] =
            [
                async () => { await Map.ChangeToAsync(ChangeMapSide.Left); }
            ],
            [(-18, 0)] =
            [
                async () => { await Map.ChangeToAsync(ChangeMapSide.Left); }
            ],
            [(-19, 0)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Up);
                }
            ],
            [(-19, -1)] =
            [
                async () => { await Map.ChangeToAsync(ChangeMapSide.Left); }
            ],
            [(-20, -1)] =
            [
                async () => { await Map.ChangeToAsync(ChangeMapSide.Down); }
            ],
            [(-20, 0)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Left);
                }
            ],
            [(-21, 0)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Left);
                }
            ],
            [(-22, 0)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Down);
                }
            ],
            [(-22, 1)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Left);
                },
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Down);
                }
            ],
            [(-23, 1)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Right);
                }
            ],
            [(-22, 2)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Left);
                },
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Down);
                }
            ],
            [(-23, 2)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Right);
                }
            ],
            [(-22, 3)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Left);
                },
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Down);
                }
            ],
            [(-23, 3)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Right);
                }
            ],
            [(-22, 4)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Right);
                }
            ],
            [(-21, 4)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Up);
                }
            ],
            [(-21, 3)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Up);
                }
            ],
            [(-21, 2)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Up);
                }
            ],
            [(-21, 1)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Right);
                }
            ],
            [(-20, 1)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Down);
                }
            ],
            [(-20, 2)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Down);
                }
            ],
            [(-20, 3)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Down);
                }
            ],
            [(-20, 4)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Right);
                }
            ],
            [(-19, 4)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Right);
                },
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Up);
                }
            ],
            [(-18, 4)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Left);
                }
            ],
            [(-19, 3)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Up);
                }
            ],
            [(-19, 2)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Up);
                }
            ],
            [(-19, 1)] =
            [
                async () =>
                {
                    await Map.GatherAsync([68]);
                    await Map.ChangeToAsync(ChangeMapSide.Up);
                }
            ],
        };

        if (move.TryGetValue(Map.Coords, out var actions))
        {
            await actions[(count - 1) % actions.Count]();
            return;
        }

        await Map.GoToHavenBagAsync();
    }

    [Handler]
    public async Task OnMoveBankAsync()
    {
        if (Map.Id == 84935175)
        {
            await Npc.SpeakToAsync(100);
            return;
        }

        await Map.AutoTripAsync(84935175);
    }

    [Handler]
    public async Task OnNpcDialogOpenedAsync(NpcQuestion question)
    {
        if (question.MessageId == 48375)
        {
            await Npc.AnswerAsync(question.Replies[0]);
        }
    }

    [Handler]
    public async Task OnBankOpenedAsync()
    {
        await Bank.DepositAsync(DepositType.Everything);

        await Bank.TakeKamasAsync(Bank.Kamas);

        await Bank.LeaveAsync();
    }

    [Handler]
    public async Task OnFightPosAsync()
    {
        await Fight.SetBonusAsync(ChallengeBonusEnum.ChallengeDropBonus);

        await Fight.SetPositionAsync(FightPosition.Furthest);
    }

    [Handler]
    public async Task OnFightTurnAsync()
    {
        switch (Character.Breed)
        {
            case PlayableBreedEnum.Cra:

                await Fight.ExecuteAsync(
                [
                    new FightActionMove(FightMove.Nearest),
                    new FightActionCast(13058, CastTarget.Me),
                    new FightActionCast(13055, CastTarget.Enemy),
                    new FightActionCast(13047, CastTarget.Enemy),
                    new FightActionCast(13047, CastTarget.Enemy),
                    new FightActionFinishTurn()
                ]);

                break;

            case PlayableBreedEnum.Sacrieur:

                await Fight.ExecuteAsync(
                [
                    new FightActionMove(FightMove.Nearest),
                    new FightActionCast(12744, CastTarget.Invoke), // Épée Vorace
                    new FightActionCast(12746, CastTarget.Enemy), // Ravage
                    new FightActionCast(12725, CastTarget.Enemy), // Supplice
                    new FightActionCast(12725, CastTarget.Enemy), // Supplice
                    new FightActionFinishTurn()
                ]);

                break;
        }
    }

    [Handler]
    public async Task OnFightEndedAsync()
    {
        switch (Character.Breed)
        {
            case PlayableBreedEnum.Cra:
                await Character.UpgradeStatAsync(Characteristic.Agility);
                break;
            case PlayableBreedEnum.Sacrieur:
                await Character.UpgradeStatAsync(Characteristic.Strength);
                break;
        }
    }

    [Handler]
    public Task OnInventoryWeightChangedAsync()
    {
        if (Character.IsInBank)
        {
            Bank.SetWeightLimit(85, 90);
        }

        return Task.CompletedTask;
    }
}
```