Head

GCC Code Coverage Report

Directory:	src/		Exec	Total	Coverage
File:	src/being/crazymoves.cpp	Lines:	1	358	0.3 %
Date:	2021-03-17	Branches:	0	254	0.0 %


/*
 *  The ManaPlus Client
 *  Copyright (C) 2011-2019  The ManaPlus Developers
 *  Copyright (C) 2019-2021  Andrei Karas
 *
 *  This file is part of The ManaPlus Client.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "being/crazymoves.h"

#include "configuration.h"
#include "settings.h"

#include "being/localplayer.h"

#include "enums/being/beingdirection.h"

#include "gui/shortcut/dropshortcut.h"

#include "gui/windows/outfitwindow.h"

#include "net/packetlimiter.h"
#include "net/pethandler.h"
#include "net/playerhandler.h"

#include "resources/db/emotedb.h"

#include "resources/map/map.h"

#include "utils/timer.h"

#include "debug.h"

CrazyMoves *crazyMoves = nullptr;

CrazyMoves::CrazyMoves() :
    mMoveProgram(),
    mDisableCrazyMove(false)
{
}

void CrazyMoves::crazyMove()
{
    const bool oldDisableCrazyMove = mDisableCrazyMove;
    mDisableCrazyMove = true;
    switch (settings.crazyMoveType)
    {
        case 1:
            crazyMove1();
            break;
        case 2:
            crazyMove2();
            break;
        case 3:
            crazyMove3();
            break;
        case 4:
            crazyMove4();
            break;
        case 5:
            crazyMove5();
            break;
        case 6:
            crazyMove6();
            break;
        case 7:
            crazyMove7();
            break;
        case 8:
            crazyMove8();
            break;
        case 9:
            crazyMove9();
            break;
        case 10:
            crazyMoveA();
            break;
        default:
            break;
    }
    mDisableCrazyMove = oldDisableCrazyMove;
}

void CrazyMoves::crazyMove1()
{
    if ((localPlayer == nullptr) ||
        (playerHandler == nullptr) ||
        localPlayer->getCurrentAction() == BeingAction::MOVE)
    {
        return;
    }

//    if (!PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
//        return;

    switch (localPlayer->getDirection())
    {
        case BeingDirection::UP:
            localPlayer->setWalkingDir(BeingDirection::UP);
            localPlayer->setDirection(BeingDirection::LEFT);
            playerHandler->setDirection(BeingDirection::LEFT);
            break;
        case BeingDirection::LEFT:
            localPlayer->setWalkingDir(BeingDirection::LEFT);
            localPlayer->setDirection(BeingDirection::DOWN);
            playerHandler->setDirection(BeingDirection::DOWN);
            break;
        case BeingDirection::DOWN:
            localPlayer->setWalkingDir(BeingDirection::DOWN);
            localPlayer->setDirection(BeingDirection::RIGHT);
            playerHandler->setDirection(BeingDirection::RIGHT);
            break;
        case BeingDirection::RIGHT:
            localPlayer->setWalkingDir(BeingDirection::RIGHT);
            localPlayer->setDirection(BeingDirection::UP);
            playerHandler->setDirection(BeingDirection::UP);
            break;
        default:
            break;
    }
}

void CrazyMoves::crazyMove2()
{
    if ((localPlayer == nullptr) ||
        (playerHandler == nullptr) ||
        localPlayer->getCurrentAction() == BeingAction::MOVE)
    {
        return;
    }

//    if (!PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
//        return;

    switch (localPlayer->getDirection())
    {
        case BeingDirection::UP:
            localPlayer->setWalkingDir(BeingDirection::UP |
                BeingDirection::LEFT);
            localPlayer->setDirection(BeingDirection::RIGHT);
            playerHandler->setDirection(
                BeingDirection::DOWN | BeingDirection::RIGHT);
            break;

        case BeingDirection::RIGHT:
            localPlayer->setWalkingDir(BeingDirection::UP |
                BeingDirection::RIGHT);
            localPlayer->setDirection(BeingDirection::DOWN);
            playerHandler->setDirection(
                BeingDirection::DOWN | BeingDirection::LEFT);
            break;

        case BeingDirection::DOWN:
            localPlayer->setWalkingDir(BeingDirection::DOWN |
                BeingDirection::RIGHT);
            localPlayer->setDirection(BeingDirection::LEFT);
            playerHandler->setDirection(
                BeingDirection::UP | BeingDirection::LEFT);
            break;

        case BeingDirection::LEFT:
            localPlayer->setWalkingDir(BeingDirection::DOWN |
                BeingDirection::LEFT);
            localPlayer->setDirection(BeingDirection::UP);
            playerHandler->setDirection(
                BeingDirection::UP | BeingDirection::RIGHT);
            break;

        default:
            break;
    }
}

void CrazyMoves::crazyMove3()
{
    if ((localPlayer == nullptr) ||
        (playerHandler == nullptr) ||
        localPlayer->getCurrentAction() == BeingAction::MOVE)
    {
        return;
    }

    switch (settings.crazyMoveState)
    {
        case 0:
            localPlayer->move(1, 1);
            settings.crazyMoveState = 1;
            break;
        case 1:
            localPlayer->move(1, -1);
            settings.crazyMoveState = 2;
            break;
        case 2:
            localPlayer->move(-1, -1);
            settings.crazyMoveState = 3;
            break;
        case 3:
            localPlayer->move(-1, 1);
            settings.crazyMoveState = 0;
            break;
        default:
            break;
    }

//    if (!PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
//        return;

    localPlayer->setDirection(BeingDirection::DOWN);
    playerHandler->setDirection(BeingDirection::DOWN);
}

void CrazyMoves::crazyMove4()
{
    if ((localPlayer == nullptr) ||
        localPlayer->getCurrentAction() == BeingAction::MOVE)
    {
        return;
    }

    switch (settings.crazyMoveState)
    {
        case 0:
            localPlayer->move(7, 0);
            settings.crazyMoveState = 1;
        break;
        case 1:
            localPlayer->move(-7, 0);
            settings.crazyMoveState = 0;
        break;
        default:
        break;
    }
}

void CrazyMoves::crazyMove5()
{
    if ((localPlayer == nullptr) ||
        localPlayer->getCurrentAction() == BeingAction::MOVE)
    {
        return;
    }

    switch (settings.crazyMoveState)
    {
        case 0:
            localPlayer->move(0, 7);
            settings.crazyMoveState = 1;
            break;
        case 1:
            localPlayer->move(0, -7);
            settings.crazyMoveState = 0;
            break;
        default:
            break;
    }
}

void CrazyMoves::crazyMove6()
{
    if ((localPlayer == nullptr) ||
        localPlayer->getCurrentAction() == BeingAction::MOVE)
    {
        return;
    }

    switch (settings.crazyMoveState)
    {
        case 0:
            localPlayer->move(3, 0);
            settings.crazyMoveState = 1;
            break;
        case 1:
            localPlayer->move(2, -2);
            settings.crazyMoveState = 2;
            break;
        case 2:
            localPlayer->move(0, -3);
            settings.crazyMoveState = 3;
            break;
        case 3:
            localPlayer->move(-2, -2);
            settings.crazyMoveState = 4;
            break;
        case 4:
            localPlayer->move(-3, 0);
            settings.crazyMoveState = 5;
            break;
        case 5:
            localPlayer->move(-2, 2);
            settings.crazyMoveState = 6;
            break;
        case 6:
            localPlayer->move(0, 3);
            settings.crazyMoveState = 7;
            break;
        case 7:
            localPlayer->move(2, 2);
            settings.crazyMoveState = 0;
            break;
        default:
            break;
    }
}

void CrazyMoves::crazyMove7()
{
    if ((localPlayer == nullptr) ||
        localPlayer->getCurrentAction() == BeingAction::MOVE)
    {
        return;
    }

    switch (settings.crazyMoveState)
    {
        case 0:
            localPlayer->move(1, 1);
            settings.crazyMoveState = 1;
            break;
        case 1:
            localPlayer->move(-1, 1);
            settings.crazyMoveState = 2;
            break;
        case 2:
            localPlayer->move(-1, -1);
            settings.crazyMoveState = 3;
            break;
        case 3:
            localPlayer->move(1, -1);
            settings.crazyMoveState = 0;
            break;
        default:
            break;
    }
}

void CrazyMoves::crazyMove8()
{
    if (localPlayer == nullptr ||
        localPlayer->getCurrentAction() == BeingAction::MOVE)
    {
        return;
    }
    const Map *const map = localPlayer->getMap();
    if (map == nullptr)
        return;
    const int x = localPlayer->getTileX();
    const int y = localPlayer->getTileY();
    int idx = 0;
    const int dist = 1;

// look
//      up, ri,do,le
    static const int movesX[][4] =
    {
        {-1,  0,  1,  0},   // move left
        { 0,  1,  0, -1},   // move up
        { 1,  0, -1,  0},   // move right
        { 0, -1,  0,  1}    // move down
    };

// look
//      up, ri,do,le
    static const int movesY[][4] =
    {
        { 0, -1,  0,  1},   // move left
        {-1,  0,  1,  0},   // move up
        { 0,  1,  0, -1},   // move right
        { 1,  0, -1,  0}    // move down
    };

    switch (localPlayer->getDirection())
    {
        case BeingDirection::UP:
            idx = 0;
            break;

        case BeingDirection::RIGHT:
            idx = 1;
            break;

        case BeingDirection::DOWN:
            idx = 2;
            break;

        case BeingDirection::LEFT:
            idx = 3;
            break;

        default:
            break;
    }

    int mult = 1;
    const unsigned char blockWalkMask = localPlayer->getBlockWalkMask();
    if (map->getWalk(x + movesX[idx][0],
        y + movesY[idx][0], blockWalkMask))
    {
        while (map->getWalk(x + movesX[idx][0] * mult,
               y + movesY[idx][0] * mult,
               blockWalkMask) && mult <= dist)
        {
            mult ++;
        }
        localPlayer->move(movesX[idx][0] * (mult - 1),
            movesY[idx][0] * (mult - 1));
    }
    else if (map->getWalk(x + movesX[idx][1],
             y + movesY[idx][1], blockWalkMask))
    {
        while (map->getWalk(x + movesX[idx][1] * mult,
               y + movesY[idx][1] * mult,
               blockWalkMask) && mult <= dist)
        {
            mult ++;
        }
        localPlayer->move(movesX[idx][1] * (mult - 1),
            movesY[idx][1] * (mult - 1));
    }
    else if (map->getWalk(x + movesX[idx][2],
             y + movesY[idx][2], blockWalkMask))
    {
        while (map->getWalk(x + movesX[idx][2] * mult,
               y + movesY[idx][2] * mult,
               blockWalkMask) && mult <= dist)
        {
            mult ++;
        }
        localPlayer->move(movesX[idx][2] * (mult - 1),
            movesY[idx][2] * (mult - 1));
    }
    else if (map->getWalk(x + movesX[idx][3],
             y + movesY[idx][3], blockWalkMask))
    {
        while (map->getWalk(x + movesX[idx][3] * mult,
               y + movesY[idx][3] * mult,
               blockWalkMask) && mult <= dist)
        {
            mult ++;
        }
        localPlayer->move(movesX[idx][3] * (mult - 1),
            movesY[idx][3] * (mult - 1));
    }
}

void CrazyMoves::crazyMove9()
{
    int dx = 0;
    int dy = 0;

    if (localPlayer == nullptr ||
        localPlayer->getCurrentAction() == BeingAction::MOVE)
    {
        return;
    }

    switch (settings.crazyMoveState)
    {
        case 0:
            switch (localPlayer->getDirection())
            {
                case BeingDirection::UP   : dy = -1; break;
                case BeingDirection::DOWN : dy = 1; break;
                case BeingDirection::LEFT : dx = -1; break;
                case BeingDirection::RIGHT: dx = 1; break;
                default: break;
            }
            localPlayer->move(dx, dy);
            settings.crazyMoveState = 1;
            break;
        case 1:
            settings.crazyMoveState = 2;
            if (!localPlayer->allowAction())
                return;
            if (playerHandler != nullptr)
                playerHandler->changeAction(BeingAction::SIT);
            break;
        case 2:
            settings.crazyMoveState = 3;
            break;
        case 3:
            settings.crazyMoveState = 0;
            break;
        default:
            break;
    }
}

void CrazyMoves::crazyMoveAm() const
{
    if (localPlayer == nullptr)
        return;

    settings.crazyMoveState ++;
    if (settings.crazyMoveState < mMoveProgram.length())
    {
        int dx = 0;
        int dy = 0;

        signed char param = mMoveProgram[settings.crazyMoveState++];
        if (param == '?')
        {
            const char cmd[] = {'l', 'r', 'u', 'd', 'L', 'R', 'U', 'D'};
            srand(tick_time);
            param = cmd[rand() % 8];
        }
        switch (param)
        {
            case 'd':
                localPlayer->move(0, 1);
                break;
            case 'u':
                localPlayer->move(0, -1);
                break;
            case 'l':
                localPlayer->move(-1, 0);
                break;
            case 'r':
                localPlayer->move(1, 0);
                break;
            case 'D':
                localPlayer->move(1, 1);
                break;
            case 'U':
                localPlayer->move(-1, -1);
                break;
            case 'L':
                localPlayer->move(-1, 1);
                break;
            case 'R':
                localPlayer->move(1, -1);
                break;
            case 'f':
            {
                const uint8_t dir = localPlayer->getDirection();
                if ((dir & BeingDirection::UP) != 0)
                    dy = -1;
                else if ((dir & BeingDirection::DOWN) != 0)
                    dy = 1;
                if ((dir & BeingDirection::LEFT) != 0)
                    dx = -1;
                else if ((dir & BeingDirection::RIGHT) != 0)
                    dx = 1;
                localPlayer->move(dx, dy);
                break;
            }
            case 'b':
            {
                const uint8_t dir = localPlayer->getDirection();
                if ((dir & BeingDirection::UP) != 0)
                    dy = 1;
                else if ((dir & BeingDirection::DOWN) != 0)
                    dy = -1;
                if ((dir & BeingDirection::LEFT) != 0)
                    dx = 1;
                else if ((dir & BeingDirection::RIGHT) != 0)
                    dx = -1;
                localPlayer->move(dx, dy);
                break;
            }
            default:
                break;
        }
    }
}

void CrazyMoves::crazyMoveAd() const
{
    settings.crazyMoveState ++;

    if (settings.crazyMoveState < mMoveProgram.length())
    {
        signed char param = mMoveProgram[settings.crazyMoveState++];
        if (param == '?')
        {
            const char cmd[] = {'l', 'r', 'u', 'd'};
            srand(tick_time);
            param = cmd[rand() % 4];
        }
        switch (param)
        {
            case 'd':
//               if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
                {
                    localPlayer->setDirection(BeingDirection::DOWN);
                    playerHandler->setDirection(
                        BeingDirection::DOWN);
                }
                break;
            case 'u':
//               if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
                {
                    localPlayer->setDirection(BeingDirection::UP);
                    playerHandler->setDirection(
                        BeingDirection::UP);
                }
                break;
            case 'l':
//               if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
                {
                    localPlayer->setDirection(BeingDirection::LEFT);
                    playerHandler->setDirection(
                        BeingDirection::LEFT);
                }
                break;
            case 'r':
//               if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
                {
                    localPlayer->setDirection(BeingDirection::RIGHT);
                    playerHandler->setDirection(
                        BeingDirection::RIGHT);
                }
                break;
            case 'L':
//               if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
                {
                    uint8_t dir = 0;
                    switch (localPlayer->getDirection())
                    {
                        case BeingDirection::UP:
                            dir = BeingDirection::LEFT;
                            break;
                        case BeingDirection::DOWN:
                            dir = BeingDirection::RIGHT;
                            break;
                        case BeingDirection::LEFT:
                            dir = BeingDirection::DOWN;
                            break;
                        case BeingDirection::RIGHT:
                            dir = BeingDirection::UP;
                            break;
                        default:
                            break;
                    }
                    localPlayer->setDirection(dir);
                    playerHandler->setDirection(dir);
                }
                break;
            case 'R':
//               if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
                {
                    uint8_t dir = 0;
                    switch (localPlayer->getDirection())
                    {
                        case BeingDirection::UP:
                            dir = BeingDirection::RIGHT;
                            break;
                        case BeingDirection::DOWN:
                            dir = BeingDirection::LEFT;
                            break;
                        case BeingDirection::LEFT:
                            dir = BeingDirection::UP;
                            break;
                        case BeingDirection::RIGHT:
                            dir = BeingDirection::DOWN;
                            break;
                        default:
                            break;
                    }
                    localPlayer->setDirection(dir);
                    playerHandler->setDirection(dir);
                }
                break;
            case 'b':
//               if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
                {
                    uint8_t dir = 0;
                    switch (localPlayer->getDirection())
                    {
                        case BeingDirection::UP:
                            dir = BeingDirection::DOWN;
                            break;
                        case BeingDirection::DOWN:
                            dir = BeingDirection::UP;
                            break;
                        case BeingDirection::LEFT:
                            dir = BeingDirection::RIGHT;
                            break;
                        case BeingDirection::RIGHT:
                            dir = BeingDirection::LEFT;
                            break;
                        default:
                            break;
                    }
                    localPlayer->setDirection(dir);
                    playerHandler->setDirection(dir);
                }
                break;
            case '0':
                dropShortcut->dropFirst();
                break;
            case 'a':
                dropShortcut->dropItems(1);
                break;
            default:
                break;
        }
    }
}

void CrazyMoves::crazyMoveAs()
{
    settings.crazyMoveState ++;
    if (localPlayer->toggleSit())
        settings.crazyMoveState ++;
}

void CrazyMoves::crazyMoveAo() const
{
    settings.crazyMoveState ++;
    if (settings.crazyMoveState < mMoveProgram.length())
    {
        // wear next outfit
        if (mMoveProgram[settings.crazyMoveState] == 'n')
        {
            settings.crazyMoveState ++;
            outfitWindow->wearNextOutfit(false);
        }
        // wear previous outfit
        else if (mMoveProgram[settings.crazyMoveState] == 'p')
        {
            settings.crazyMoveState ++;
            outfitWindow->wearPreviousOutfit(false);
        }
    }
}

void CrazyMoves::crazyMoveAe() const
{
    settings.crazyMoveState ++;
    const signed char emo = mMoveProgram[settings.crazyMoveState];
    unsigned char emoteId = 0;
    if (emo == '?')
    {
        srand(tick_time);
        emoteId = CAST_U8(
            1 + (rand() % EmoteDB::size()));
    }
    else
    {
        if (emo >= '0' && emo <= '9')
            emoteId = CAST_U8(emo - '0' + 1);
        else if (emo >= 'a' && emo <= 'z')
            emoteId = CAST_U8(emo - 'a' + 11);
        else if (emo >= 'A' && emo <= 'Z')
            emoteId = CAST_U8(emo - 'A' + 37);
    }
    if (mMoveProgram[settings.crazyMoveState - 1] == 'e')
        LocalPlayer::emote(emoteId);
    else if (PacketLimiter::limitPackets(PacketType::PACKET_CHAT))
        petHandler->emote(emoteId);

    settings.crazyMoveState ++;
}

void CrazyMoves::crazyMoveA()
{
    mMoveProgram = config.getStringValue("crazyMoveProgram");

    if (localPlayer->getCurrentAction() == BeingAction::MOVE)
        return;

    if (mMoveProgram.empty())
        return;

    if (settings.crazyMoveState >= mMoveProgram.length())
        settings.crazyMoveState = 0;

    // move command
    if (mMoveProgram[settings.crazyMoveState] == 'm')
    {
        crazyMoveAm();
    }
    // direction command
    else if (mMoveProgram[settings.crazyMoveState] == 'd')
    {
        crazyMoveAd();
    }
    // sit command
    else if (mMoveProgram[settings.crazyMoveState] == 's')
    {
        crazyMoveAs();
    }
    // wear outfits
    else if (mMoveProgram[settings.crazyMoveState] == 'o')
    {
        crazyMoveAo();
    }
    // pause
    else if (mMoveProgram[settings.crazyMoveState] == 'w')
    {
        settings.crazyMoveState ++;
    }
    // pick up
    else if (mMoveProgram[settings.crazyMoveState] == 'p')
    {
        settings.crazyMoveState ++;
        localPlayer->pickUpItems(0);
    }
    // emote
    else if (mMoveProgram[settings.crazyMoveState] == 'e'
             || mMoveProgram[settings.crazyMoveState] == 'E')
    {
        crazyMoveAe();
    }
    else
    {
        settings.crazyMoveState ++;
    }

    if (settings.crazyMoveState >= mMoveProgram.length())
        settings.crazyMoveState = 0;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/*
2			* The ManaPlus Client
3			* Copyright (C) 2011-2019 The ManaPlus Developers
4			* Copyright (C) 2019-2021 Andrei Karas
5			*
6			* This file is part of The ManaPlus Client.
7			*
8			* This program is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation; either version 2 of the License, or
11			* any later version.
12			*
13			* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program. If not, see <http://www.gnu.org/licenses/>.
20			*/
21
22			#include "being/crazymoves.h"
23
24			#include "configuration.h"
25			#include "settings.h"
26
27			#include "being/localplayer.h"
28
29			#include "enums/being/beingdirection.h"
30
31			#include "gui/shortcut/dropshortcut.h"
32
33			#include "gui/windows/outfitwindow.h"
34
35			#include "net/packetlimiter.h"
36			#include "net/pethandler.h"
37			#include "net/playerhandler.h"
38
39			#include "resources/db/emotedb.h"
40
41			#include "resources/map/map.h"
42
43			#include "utils/timer.h"
44
45			#include "debug.h"
46
47			CrazyMoves *crazyMoves = nullptr;
48
49			CrazyMoves::CrazyMoves() :
50			mMoveProgram(),
51			mDisableCrazyMove(false)
52			{
53			}
54
55			void CrazyMoves::crazyMove()
56			{
57			const bool oldDisableCrazyMove = mDisableCrazyMove;
58			mDisableCrazyMove = true;
59			switch (settings.crazyMoveType)
60			{
61			case 1:
62			crazyMove1();
63			break;
64			case 2:
65			crazyMove2();
66			break;
67			case 3:
68			crazyMove3();
69			break;
70			case 4:
71			crazyMove4();
72			break;
73			case 5:
74			crazyMove5();
75			break;
76			case 6:
77			crazyMove6();
78			break;
79			case 7:
80			crazyMove7();
81			break;
82			case 8:
83			crazyMove8();
84			break;
85			case 9:
86			crazyMove9();
87			break;
88			case 10:
89			crazyMoveA();
90			break;
91			default:
92			break;
93			}
94			mDisableCrazyMove = oldDisableCrazyMove;
95			}
96
97			void CrazyMoves::crazyMove1()
98			{
99			if ((localPlayer == nullptr) \|\|
100			(playerHandler == nullptr) \|\|
101			localPlayer->getCurrentAction() == BeingAction::MOVE)
102			{
103			return;
104			}
105
106			// if (!PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
107			// return;
108
109			switch (localPlayer->getDirection())
110			{
111			case BeingDirection::UP:
112			localPlayer->setWalkingDir(BeingDirection::UP);
113			localPlayer->setDirection(BeingDirection::LEFT);
114			playerHandler->setDirection(BeingDirection::LEFT);
115			break;
116			case BeingDirection::LEFT:
117			localPlayer->setWalkingDir(BeingDirection::LEFT);
118			localPlayer->setDirection(BeingDirection::DOWN);
119			playerHandler->setDirection(BeingDirection::DOWN);
120			break;
121			case BeingDirection::DOWN:
122			localPlayer->setWalkingDir(BeingDirection::DOWN);
123			localPlayer->setDirection(BeingDirection::RIGHT);
124			playerHandler->setDirection(BeingDirection::RIGHT);
125			break;
126			case BeingDirection::RIGHT:
127			localPlayer->setWalkingDir(BeingDirection::RIGHT);
128			localPlayer->setDirection(BeingDirection::UP);
129			playerHandler->setDirection(BeingDirection::UP);
130			break;
131			default:
132			break;
133			}
134			}
135
136			void CrazyMoves::crazyMove2()
137			{
138			if ((localPlayer == nullptr) \|\|
139			(playerHandler == nullptr) \|\|
140			localPlayer->getCurrentAction() == BeingAction::MOVE)
141			{
142			return;
143			}
144
145			// if (!PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
146			// return;
147
148			switch (localPlayer->getDirection())
149			{
150			case BeingDirection::UP:
151			localPlayer->setWalkingDir(BeingDirection::UP \|
152			BeingDirection::LEFT);
153			localPlayer->setDirection(BeingDirection::RIGHT);
154			playerHandler->setDirection(
155			BeingDirection::DOWN \| BeingDirection::RIGHT);
156			break;
157
158			case BeingDirection::RIGHT:
159			localPlayer->setWalkingDir(BeingDirection::UP \|
160			BeingDirection::RIGHT);
161			localPlayer->setDirection(BeingDirection::DOWN);
162			playerHandler->setDirection(
163			BeingDirection::DOWN \| BeingDirection::LEFT);
164			break;
165
166			case BeingDirection::DOWN:
167			localPlayer->setWalkingDir(BeingDirection::DOWN \|
168			BeingDirection::RIGHT);
169			localPlayer->setDirection(BeingDirection::LEFT);
170			playerHandler->setDirection(
171			BeingDirection::UP \| BeingDirection::LEFT);
172			break;
173
174			case BeingDirection::LEFT:
175			localPlayer->setWalkingDir(BeingDirection::DOWN \|
176			BeingDirection::LEFT);
177			localPlayer->setDirection(BeingDirection::UP);
178			playerHandler->setDirection(
179			BeingDirection::UP \| BeingDirection::RIGHT);
180			break;
181
182			default:
183			break;
184			}
185			}
186
187			void CrazyMoves::crazyMove3()
188			{
189			if ((localPlayer == nullptr) \|\|
190			(playerHandler == nullptr) \|\|
191			localPlayer->getCurrentAction() == BeingAction::MOVE)
192			{
193			return;
194			}
195
196			switch (settings.crazyMoveState)
197			{
198			case 0:
199			localPlayer->move(1, 1);
200			settings.crazyMoveState = 1;
201			break;
202			case 1:
203			localPlayer->move(1, -1);
204			settings.crazyMoveState = 2;
205			break;
206			case 2:
207			localPlayer->move(-1, -1);
208			settings.crazyMoveState = 3;
209			break;
210			case 3:
211			localPlayer->move(-1, 1);
212			settings.crazyMoveState = 0;
213			break;
214			default:
215			break;
216			}
217
218			// if (!PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
219			// return;
220
221			localPlayer->setDirection(BeingDirection::DOWN);
222			playerHandler->setDirection(BeingDirection::DOWN);
223			}
224
225			void CrazyMoves::crazyMove4()
226			{
227			if ((localPlayer == nullptr) \|\|
228			localPlayer->getCurrentAction() == BeingAction::MOVE)
229			{
230			return;
231			}
232
233			switch (settings.crazyMoveState)
234			{
235			case 0:
236			localPlayer->move(7, 0);
237			settings.crazyMoveState = 1;
238			break;
239			case 1:
240			localPlayer->move(-7, 0);
241			settings.crazyMoveState = 0;
242			break;
243			default:
244			break;
245			}
246			}
247
248			void CrazyMoves::crazyMove5()
249			{
250			if ((localPlayer == nullptr) \|\|
251			localPlayer->getCurrentAction() == BeingAction::MOVE)
252			{
253			return;
254			}
255
256			switch (settings.crazyMoveState)
257			{
258			case 0:
259			localPlayer->move(0, 7);
260			settings.crazyMoveState = 1;
261			break;
262			case 1:
263			localPlayer->move(0, -7);
264			settings.crazyMoveState = 0;
265			break;
266			default:
267			break;
268			}
269			}
270
271			void CrazyMoves::crazyMove6()
272			{
273			if ((localPlayer == nullptr) \|\|
274			localPlayer->getCurrentAction() == BeingAction::MOVE)
275			{
276			return;
277			}
278
279			switch (settings.crazyMoveState)
280			{
281			case 0:
282			localPlayer->move(3, 0);
283			settings.crazyMoveState = 1;
284			break;
285			case 1:
286			localPlayer->move(2, -2);
287			settings.crazyMoveState = 2;
288			break;
289			case 2:
290			localPlayer->move(0, -3);
291			settings.crazyMoveState = 3;
292			break;
293			case 3:
294			localPlayer->move(-2, -2);
295			settings.crazyMoveState = 4;
296			break;
297			case 4:
298			localPlayer->move(-3, 0);
299			settings.crazyMoveState = 5;
300			break;
301			case 5:
302			localPlayer->move(-2, 2);
303			settings.crazyMoveState = 6;
304			break;
305			case 6:
306			localPlayer->move(0, 3);
307			settings.crazyMoveState = 7;
308			break;
309			case 7:
310			localPlayer->move(2, 2);
311			settings.crazyMoveState = 0;
312			break;
313			default:
314			break;
315			}
316			}
317
318			void CrazyMoves::crazyMove7()
319			{
320			if ((localPlayer == nullptr) \|\|
321			localPlayer->getCurrentAction() == BeingAction::MOVE)
322			{
323			return;
324			}
325
326			switch (settings.crazyMoveState)
327			{
328			case 0:
329			localPlayer->move(1, 1);
330			settings.crazyMoveState = 1;
331			break;
332			case 1:
333			localPlayer->move(-1, 1);
334			settings.crazyMoveState = 2;
335			break;
336			case 2:
337			localPlayer->move(-1, -1);
338			settings.crazyMoveState = 3;
339			break;
340			case 3:
341			localPlayer->move(1, -1);
342			settings.crazyMoveState = 0;
343			break;
344			default:
345			break;
346			}
347			}
348
349			void CrazyMoves::crazyMove8()
350			{
351			if (localPlayer == nullptr \|\|
352			localPlayer->getCurrentAction() == BeingAction::MOVE)
353			{
354			return;
355			}
356			const Map *const map = localPlayer->getMap();
357			if (map == nullptr)
358			return;
359			const int x = localPlayer->getTileX();
360			const int y = localPlayer->getTileY();
361			int idx = 0;
362			const int dist = 1;
363
364			// look
365			// up, ri,do,le
366			static const int movesX[][4] =
367			{
368			{-1, 0, 1, 0}, // move left
369			{ 0, 1, 0, -1}, // move up
370			{ 1, 0, -1, 0}, // move right
371			{ 0, -1, 0, 1} // move down
372			};
373
374			// look
375			// up, ri,do,le
376			static const int movesY[][4] =
377			{
378			{ 0, -1, 0, 1}, // move left
379			{-1, 0, 1, 0}, // move up
380			{ 0, 1, 0, -1}, // move right
381			{ 1, 0, -1, 0} // move down
382			};
383
384			switch (localPlayer->getDirection())
385			{
386			case BeingDirection::UP:
387			idx = 0;
388			break;
389
390			case BeingDirection::RIGHT:
391			idx = 1;
392			break;
393
394			case BeingDirection::DOWN:
395			idx = 2;
396			break;
397
398			case BeingDirection::LEFT:
399			idx = 3;
400			break;
401
402			default:
403			break;
404			}
405
406			int mult = 1;
407			const unsigned char blockWalkMask = localPlayer->getBlockWalkMask();
408			if (map->getWalk(x + movesX[idx][0],
409			y + movesY[idx][0], blockWalkMask))
410			{
411			while (map->getWalk(x + movesX[idx][0] * mult,
412			y + movesY[idx][0] * mult,
413			blockWalkMask) && mult <= dist)
414			{
415			mult ++;
416			}
417			localPlayer->move(movesX[idx][0] * (mult - 1),
418			movesY[idx][0] * (mult - 1));
419			}
420			else if (map->getWalk(x + movesX[idx][1],
421			y + movesY[idx][1], blockWalkMask))
422			{
423			while (map->getWalk(x + movesX[idx][1] * mult,
424			y + movesY[idx][1] * mult,
425			blockWalkMask) && mult <= dist)
426			{
427			mult ++;
428			}
429			localPlayer->move(movesX[idx][1] * (mult - 1),
430			movesY[idx][1] * (mult - 1));
431			}
432			else if (map->getWalk(x + movesX[idx][2],
433			y + movesY[idx][2], blockWalkMask))
434			{
435			while (map->getWalk(x + movesX[idx][2] * mult,
436			y + movesY[idx][2] * mult,
437			blockWalkMask) && mult <= dist)
438			{
439			mult ++;
440			}
441			localPlayer->move(movesX[idx][2] * (mult - 1),
442			movesY[idx][2] * (mult - 1));
443			}
444			else if (map->getWalk(x + movesX[idx][3],
445			y + movesY[idx][3], blockWalkMask))
446			{
447			while (map->getWalk(x + movesX[idx][3] * mult,
448			y + movesY[idx][3] * mult,
449			blockWalkMask) && mult <= dist)
450			{
451			mult ++;
452			}
453			localPlayer->move(movesX[idx][3] * (mult - 1),
454			movesY[idx][3] * (mult - 1));
455			}
456			}
457
458			void CrazyMoves::crazyMove9()
459			{
460			int dx = 0;
461			int dy = 0;
462
463			if (localPlayer == nullptr \|\|
464			localPlayer->getCurrentAction() == BeingAction::MOVE)
465			{
466			return;
467			}
468
469			switch (settings.crazyMoveState)
470			{
471			case 0:
472			switch (localPlayer->getDirection())
473			{
474			case BeingDirection::UP : dy = -1; break;
475			case BeingDirection::DOWN : dy = 1; break;
476			case BeingDirection::LEFT : dx = -1; break;
477			case BeingDirection::RIGHT: dx = 1; break;
478			default: break;
479			}
480			localPlayer->move(dx, dy);
481			settings.crazyMoveState = 1;
482			break;
483			case 1:
484			settings.crazyMoveState = 2;
485			if (!localPlayer->allowAction())
486			return;
487			if (playerHandler != nullptr)
488			playerHandler->changeAction(BeingAction::SIT);
489			break;
490			case 2:
491			settings.crazyMoveState = 3;
492			break;
493			case 3:
494			settings.crazyMoveState = 0;
495			break;
496			default:
497			break;
498			}
499			}
500
501			void CrazyMoves::crazyMoveAm() const
502			{
503			if (localPlayer == nullptr)
504			return;
505
506			settings.crazyMoveState ++;
507			if (settings.crazyMoveState < mMoveProgram.length())
508			{
509			int dx = 0;
510			int dy = 0;
511
512			signed char param = mMoveProgram[settings.crazyMoveState++];
513			if (param == '?')
514			{
515			const char cmd[] = {'l', 'r', 'u', 'd', 'L', 'R', 'U', 'D'};
516			srand(tick_time);
517			param = cmd[rand() % 8];
518			}
519			switch (param)
520			{
521			case 'd':
522			localPlayer->move(0, 1);
523			break;
524			case 'u':
525			localPlayer->move(0, -1);
526			break;
527			case 'l':
528			localPlayer->move(-1, 0);
529			break;
530			case 'r':
531			localPlayer->move(1, 0);
532			break;
533			case 'D':
534			localPlayer->move(1, 1);
535			break;
536			case 'U':
537			localPlayer->move(-1, -1);
538			break;
539			case 'L':
540			localPlayer->move(-1, 1);
541			break;
542			case 'R':
543			localPlayer->move(1, -1);
544			break;
545			case 'f':
546			{
547			const uint8_t dir = localPlayer->getDirection();
548			if ((dir & BeingDirection::UP) != 0)
549			dy = -1;
550			else if ((dir & BeingDirection::DOWN) != 0)
551			dy = 1;
552			if ((dir & BeingDirection::LEFT) != 0)
553			dx = -1;
554			else if ((dir & BeingDirection::RIGHT) != 0)
555			dx = 1;
556			localPlayer->move(dx, dy);
557			break;
558			}
559			case 'b':
560			{
561			const uint8_t dir = localPlayer->getDirection();
562			if ((dir & BeingDirection::UP) != 0)
563			dy = 1;
564			else if ((dir & BeingDirection::DOWN) != 0)
565			dy = -1;
566			if ((dir & BeingDirection::LEFT) != 0)
567			dx = 1;
568			else if ((dir & BeingDirection::RIGHT) != 0)
569			dx = -1;
570			localPlayer->move(dx, dy);
571			break;
572			}
573			default:
574			break;
575			}
576			}
577			}
578
579			void CrazyMoves::crazyMoveAd() const
580			{
581			settings.crazyMoveState ++;
582
583			if (settings.crazyMoveState < mMoveProgram.length())
584			{
585			signed char param = mMoveProgram[settings.crazyMoveState++];
586			if (param == '?')
587			{
588			const char cmd[] = {'l', 'r', 'u', 'd'};
589			srand(tick_time);
590			param = cmd[rand() % 4];
591			}
592			switch (param)
593			{
594			case 'd':
595			// if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
596			{
597			localPlayer->setDirection(BeingDirection::DOWN);
598			playerHandler->setDirection(
599			BeingDirection::DOWN);
600			}
601			break;
602			case 'u':
603			// if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
604			{
605			localPlayer->setDirection(BeingDirection::UP);
606			playerHandler->setDirection(
607			BeingDirection::UP);
608			}
609			break;
610			case 'l':
611			// if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
612			{
613			localPlayer->setDirection(BeingDirection::LEFT);
614			playerHandler->setDirection(
615			BeingDirection::LEFT);
616			}
617			break;
618			case 'r':
619			// if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
620			{
621			localPlayer->setDirection(BeingDirection::RIGHT);
622			playerHandler->setDirection(
623			BeingDirection::RIGHT);
624			}
625			break;
626			case 'L':
627			// if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
628			{
629			uint8_t dir = 0;
630			switch (localPlayer->getDirection())
631			{
632			case BeingDirection::UP:
633			dir = BeingDirection::LEFT;
634			break;
635			case BeingDirection::DOWN:
636			dir = BeingDirection::RIGHT;
637			break;
638			case BeingDirection::LEFT:
639			dir = BeingDirection::DOWN;
640			break;
641			case BeingDirection::RIGHT:
642			dir = BeingDirection::UP;
643			break;
644			default:
645			break;
646			}
647			localPlayer->setDirection(dir);
648			playerHandler->setDirection(dir);
649			}
650			break;
651			case 'R':
652			// if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
653			{
654			uint8_t dir = 0;
655			switch (localPlayer->getDirection())
656			{
657			case BeingDirection::UP:
658			dir = BeingDirection::RIGHT;
659			break;
660			case BeingDirection::DOWN:
661			dir = BeingDirection::LEFT;
662			break;
663			case BeingDirection::LEFT:
664			dir = BeingDirection::UP;
665			break;
666			case BeingDirection::RIGHT:
667			dir = BeingDirection::DOWN;
668			break;
669			default:
670			break;
671			}
672			localPlayer->setDirection(dir);
673			playerHandler->setDirection(dir);
674			}
675			break;
676			case 'b':
677			// if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
678			{
679			uint8_t dir = 0;
680			switch (localPlayer->getDirection())
681			{
682			case BeingDirection::UP:
683			dir = BeingDirection::DOWN;
684			break;
685			case BeingDirection::DOWN:
686			dir = BeingDirection::UP;
687			break;
688			case BeingDirection::LEFT:
689			dir = BeingDirection::RIGHT;
690			break;
691			case BeingDirection::RIGHT:
692			dir = BeingDirection::LEFT;
693			break;
694			default:
695			break;
696			}
697			localPlayer->setDirection(dir);
698			playerHandler->setDirection(dir);
699			}
700			break;
701			case '0':
702			dropShortcut->dropFirst();
703			break;
704			case 'a':
705			dropShortcut->dropItems(1);
706			break;
707			default:
708			break;
709			}
710			}
711			}
712
713			void CrazyMoves::crazyMoveAs()
714			{
715			settings.crazyMoveState ++;
716			if (localPlayer->toggleSit())
717			settings.crazyMoveState ++;
718			}
719
720			void CrazyMoves::crazyMoveAo() const
721			{
722			settings.crazyMoveState ++;
723			if (settings.crazyMoveState < mMoveProgram.length())
724			{
725			// wear next outfit
726			if (mMoveProgram[settings.crazyMoveState] == 'n')
727			{
728			settings.crazyMoveState ++;
729			outfitWindow->wearNextOutfit(false);
730			}
731			// wear previous outfit
732			else if (mMoveProgram[settings.crazyMoveState] == 'p')
733			{
734			settings.crazyMoveState ++;
735			outfitWindow->wearPreviousOutfit(false);
736			}
737			}
738			}
739
740			void CrazyMoves::crazyMoveAe() const
741			{
742			settings.crazyMoveState ++;
743			const signed char emo = mMoveProgram[settings.crazyMoveState];
744			unsigned char emoteId = 0;
745			if (emo == '?')
746			{
747			srand(tick_time);
748			emoteId = CAST_U8(
749			1 + (rand() % EmoteDB::size()));
750			}
751			else
752			{
753			if (emo >= '0' && emo <= '9')
754			emoteId = CAST_U8(emo - '0' + 1);
755			else if (emo >= 'a' && emo <= 'z')
756			emoteId = CAST_U8(emo - 'a' + 11);
757			else if (emo >= 'A' && emo <= 'Z')
758			emoteId = CAST_U8(emo - 'A' + 37);
759			}
760			if (mMoveProgram[settings.crazyMoveState - 1] == 'e')
761			LocalPlayer::emote(emoteId);
762			else if (PacketLimiter::limitPackets(PacketType::PACKET_CHAT))
763			petHandler->emote(emoteId);
764
765			settings.crazyMoveState ++;
766			}
767
768			void CrazyMoves::crazyMoveA()
769			{
770			mMoveProgram = config.getStringValue("crazyMoveProgram");
771
772			if (localPlayer->getCurrentAction() == BeingAction::MOVE)
773			return;
774
775			if (mMoveProgram.empty())
776			return;
777
778			if (settings.crazyMoveState >= mMoveProgram.length())
779			settings.crazyMoveState = 0;
780
781			// move command
782			if (mMoveProgram[settings.crazyMoveState] == 'm')
783			{
784			crazyMoveAm();
785			}
786			// direction command
787			else if (mMoveProgram[settings.crazyMoveState] == 'd')
788			{
789			crazyMoveAd();
790			}
791			// sit command
792			else if (mMoveProgram[settings.crazyMoveState] == 's')
793			{
794			crazyMoveAs();
795			}
796			// wear outfits
797			else if (mMoveProgram[settings.crazyMoveState] == 'o')
798			{
799			crazyMoveAo();
800			}
801			// pause
802			else if (mMoveProgram[settings.crazyMoveState] == 'w')
803			{
804			settings.crazyMoveState ++;
805			}
806			// pick up
807			else if (mMoveProgram[settings.crazyMoveState] == 'p')
808			{
809			settings.crazyMoveState ++;
810			localPlayer->pickUpItems(0);
811			}
812			// emote
813			else if (mMoveProgram[settings.crazyMoveState] == 'e'
814			\|\| mMoveProgram[settings.crazyMoveState] == 'E')
815			{
816			crazyMoveAe();
817			}
818			else
819			{
820			settings.crazyMoveState ++;
821			}
822
823			if (settings.crazyMoveState >= mMoveProgram.length())
824			settings.crazyMoveState = 0;
825		2	}