请问MV有8方向走的插件吗？

Fan723

如题，超讨厌有直线距离不走非走个直角弯道，个人有点强迫症，网上找来找去总找不到。有的请帮忙，感谢！

世界第一中二

萌新要善用搜索&优先去本区图书馆里查查
下面是大佬的插件集合的链接https://rpg.blue/thread-384599-1-1.html

Fan723

世界第一中二 发表于 2017-11-3 17:10
萌新要善用搜索&优先去本区图书馆里查查
下面是大佬的插件集合的链接https://rpg.blue/thread-384599-1-1.h ...

这个试过了，鼠标点击还是绕弯路啊！有没有鼠标8方向寻路的？论坛有些隐藏的搜不到啊！

zdc223658

像素移动？！

梦想家大魔王

我把手头收集的几个同类插件挨个试了一遍，感觉这个用起来是最舒服的。
GALV_DiagonalMovement.7z (3.35 KB, 下载次数: 127)

2017-11-5 17:17 上传

点击文件名下载附件

[pre lang="javascript" line="1" file="GALV_DiagonalMovement.js"]//-----------------------------------------------------------------------------
//  Galv's Diagonal Movement
//-----------------------------------------------------------------------------
//  For: RPGMAKER MV
//  GALV_DiagonalMovement.js
//-----------------------------------------------------------------------------
//  2017-01-16 - Version 1.5 - added diagonal charset in the 'turn toward
//                           - character' move route command
//  2016-10-05 - Version 1.4 - modified how diag speed was coded for
//                             compatibility purposes
//  2016-08-26 - Version 1.3 - changed alias methods
//                           - fixed turn direction move route after diag move
//  2016-05-17 - Version 1.2 - diagonal block option added to prevent moving
//                           - diagonally past blocking tiles.
//                           - added ability to disable diagonal movement
//                           - during game
//  2016-02-04 - Version 1.1 - added option to slow diagonal move speed
//  2015-12-12 - Version 1.0 - release
//-----------------------------------------------------------------------------
//  Terms can be found at:
//  galvs-scripts.com
//-----------------------------------------------------------------------------

var Imported = Imported || {};
Imported.Galv_DiagonalMovement = true;

var Galv = Galv || {};
Galv.DM = Galv.DM || {};

//-----------------------------------------------------------------------------
/*:
* @plugindesc (v.1.5) Just a basic diagonal movement plugin. Written for compatibility with other Galv plugins.
*
* @author Galv - galvs-scripts.com
*
* @param Diagonal Mouse
* @desc true or false for diagonal pathfinding movement on mouse click. true may conflict with pathfinding plugins.
* @default false
*
* @param Diagonal Charset
* @desc true or false if you want to use diagonal charactersets (see help for more)
* @default true
*
* @param Diagonal Speed
* @desc % of move speed characters move while travelling diagonally
* @default 90
*
* @param Block Diagonal
* @desc true or false - if diagonal movement is blocked when moving past an impassable tile or not.
* @default false
*
* @help
*   Galv's Diagonal Movement
* ----------------------------------------------------------------------------
* Plug and play. If this doesn't play nice with other plugins, try putting it
* at the top of the plugin list. It overwrites the default diagonal function.
*
* If this conflicts with other pathfinding plugins you might have, change
* 'Diagonal Mouse' setting to false.
*
* When 'Diagonal Charsets' is true, the plugin will change the sprite if the
* character is on a diagonal. The new sprite used will be in the position
* directly below the selected character graphic. This means that only sprites
* on the top of a character sheet will be able to have diagonal graphics.
*
* Sprites on the bottom will not have diagonal graphics.
* ----------------------------------------------------------------------------
*   SCRIPT CALL
* ----------------------------------------------------------------------------
*
*   $gameSystem.disableVert = true;   // DISABLE diagonal movement
*
*   $gameSystem.disableVert = false;  // ENABLE diagonal movement
*
* ----------------------------------------------------------------------------
*/


//-----------------------------------------------------------------------------
//  CODE STUFFS
//-----------------------------------------------------------------------------



(function() {
Galv.DM.mouseMove = PluginManager.parameters('Galv_DiagonalMovement')["Diagonal Mouse"].toLowerCase() == 'true';
Galv.DM.diagGraphic = PluginManager.parameters('Galv_DiagonalMovement')["Diagonal Charset"].toLowerCase() == 'true';
Galv.DM.diagMod = Number(PluginManager.parameters('Galv_DiagonalMovement')["Diagonal Speed"]) * 0.01;       
Galv.DM.diagBlocked = PluginManager.parameters('Galv_DiagonalMovement')["Block Diagonal"].toLowerCase() == 'true';

Game_CharacterBase.prototype._cframes = 3;

Galv.DM.Game_CharacterBase_realMoveSpeed = Game_CharacterBase.prototype.realMoveSpeed;
Game_CharacterBase.prototype.realMoveSpeed = function() {
        var spd = Galv.DM.Game_CharacterBase_realMoveSpeed.call(this);
        return this._diagDir ? spd * Galv.DM.diagMod : spd;
};

// overwrite
Game_Follower.prototype.realMoveSpeed = function() {
        return $gamePlayer.realMoveSpeed();
};

Galv.DM.getHorzVertDirs = function(direction) {
        switch (direction) {
                case 1: return [4,2];
                case 3: return [6,2];
                case 7: return [4,8];
                case 9: return [6,8];
                default: return [0,0];
        };
};

Galv.DM.getDir = function(horz,vert) {
        if (horz == 4 && vert == 2) return 1;
        if (horz == 6 && vert == 2) return 3;
        if (horz == 4 && vert == 8) return 7;
        if (horz == 6 && vert == 8) return 9;
        return 0;
};

Galv.DM.diagRow = {
        3: 0,
        1: 1,
        9: 2,
        7: 3
};

Galv.DM.Game_CharacterBase_moveStraight = Game_CharacterBase.prototype.moveStraight;
Game_CharacterBase.prototype.moveStraight = function(d) {
        this._diagDir = false;
        Galv.DM.Game_CharacterBase_moveStraight.call(this,d);
};

Galv.DM.Game_CharacterBase_setDirection = Game_CharacterBase.prototype.setDirection;
Game_CharacterBase.prototype.setDirection = function(d) {
        if (this._diagStraigten) this._diagDir = false;
        Galv.DM.Game_CharacterBase_setDirection.call(this,d);
};

if (Galv.DM.diagBlocked) {
        Game_Player.prototype.canPassDiagonally = function(x, y, horz, vert) {
                var x2 = $gameMap.roundXWithDirection(x, horz);
                var y2 = $gameMap.roundYWithDirection(y, vert);
                if (this.canPass(x, y, vert) && this.canPass(x, y2, horz) && this.canPass(x, y, horz) && this.canPass(x2, y, vert)) {
                        return true;
                };
                return false;
        };
};

Galv.DM.Game_Player_canPassDiagonally = Game_Player.prototype.canPassDiagonally;
Game_Player.prototype.canPassDiagonally = function(x, y, horz, vert) {
        if ($gameSystem.disableVert) return false;
        return Galv.DM.Game_Player_canPassDiagonally.call(this,x,y,horz,vert);
};

// OVERWRITE
Game_CharacterBase.prototype.moveDiagonally = function(horz, vert) {
        var diag = this.canPassDiagonally(this._x, this._y, horz, vert);
    var norm = this.canPass(this._x, this._y, horz) || this.canPass(this._x, this._y, vert);
       
        if (diag) {
                this._diagDir = Galv.DM.getDir(horz,vert);
        this._x = $gameMap.roundXWithDirection(this._x, horz);
        this._y = $gameMap.roundYWithDirection(this._y, vert);
        this._realX = $gameMap.xWithDirection(this._x, this.reverseDir(horz));
        this._realY = $gameMap.yWithDirection(this._y, this.reverseDir(vert));
        this.increaseSteps();
        } else if (norm) {
                this._diagDir = false;
                this.moveStraight(this.getOtherdir(horz,vert));
    };
       
        this._diagStraigten = false;
    if (this._direction === this.reverseDir(horz)) this.setDirection(horz);
    if (this._direction === this.reverseDir(vert)) this.setDirection(vert);
        this._diagStraigten = true;
};

Game_CharacterBase.prototype.getOtherdir = function(horz, vert) {
    return this.canPass(this._x, this._y, horz) ? horz : vert;
};

// OVERWRITE
Game_Player.prototype.getInputDirection = function() {
    return Input.dir8;
};

Galv.DM.Game_Player_executeMove = Game_Player.prototype.executeMove;
Game_Player.prototype.executeMove = function(direction) {
        if (direction % 2 == 0) {
            Galv.DM.Game_Player_executeMove.call(this,direction);
        } else if (Math.abs(direction % 2) == 1) {
                var dirArray = Galv.DM.getHorzVertDirs(direction);
                this.moveDiagonally(dirArray[0],dirArray[1]);
        };
};



// If using Diaonal Charset
if (Galv.DM.diagGraphic) {
Galv.DM.Sprite_Character_characterPatternY = Sprite_Character.prototype.characterPatternY;
Sprite_Character.prototype.characterPatternY = function() {
        if (!this._isBigCharacter && this._character._diagDir && this._character.characterIndex() < 4) {
                return Galv.DM.diagRow[this._character._diagDir];
        } else {
            return Galv.DM.Sprite_Character_characterPatternY.call(this);
        };
};

Galv.DM.Sprite_Character_characterBlockX = Sprite_Character.prototype.characterBlockX;
Sprite_Character.prototype.characterBlockX = function() {
        if (!this._isBigCharacter && this._character._diagDir && this._character.characterIndex() < 4) {
                var index = this._character.characterIndex() + 4;
        return index % 4 * this._character._cframes;
        } else {       
            return Galv.DM.Sprite_Character_characterBlockX.call(this);
        };

};

Galv.DM.Sprite_Character_characterBlockY = Sprite_Character.prototype.characterBlockY;
Sprite_Character.prototype.characterBlockY = function() {
        if (!this._isBigCharacter && this._character._diagDir && this._character.characterIndex() < 4) {
                var index = this._character.characterIndex() + 4;
        return Math.floor(index / 4) * 4;
        } else {       
            return Galv.DM.Sprite_Character_characterBlockY.call(this);
        };

};
};
// end if using diagonal charset


// turn toward character on diagonal
// OVERWRITE
Game_Character.prototype.turnTowardCharacter = function(character) {
    var sx = this.deltaXFrom(character.x);
    var sy = this.deltaYFrom(character.y);
       
        var absSx = Math.abs(sx);
        var absSy = Math.abs(sy);

        if (absSx == absSy) {
                if (sx < 0) {
                        this._diagDir = sy > 0 ? 9 : 3;
                } else if (sx > 0) {
                        this._diagDir = sy > 0 ? 7 : 1;
                }
        } else {
                this._diagDir = 0;
        };
        if (absSx > absSy) {
               this.setDirection(sx > 0 ? 4 : 6);
    } else if (sy !== 0) {
        this.setDirection(sy > 0 ? 8 : 2);
    }
};






// If using diagonal mouse movement:

if (Galv.DM.mouseMove) {
Galv.DM.Game_Character_findDirectionTo = Game_Character.prototype.findDirectionTo;
// OVERWRITE
Game_Character.prototype.findDirectionTo = function(goalX, goalY) {
        if ($gameSystem.disableVert) {
                return Galv.DM.Game_Character_findDirectionTo.call(this,goalX,goalY);
        } else {
                var searchLimit = this.searchLimit();
                var mapWidth = $gameMap.width();
                var nodeList = [];
                var openList = [];
                var closedList = [];
                var start = {};
                var best = start;
       
                if (this.x === goalX && this.y === goalY) {
                        return 0;
                }
       
                start.parent = null;
                start.x = this.x;
                start.y = this.y;
                start.g = 0;
                start.f = $gameMap.distance(start.x, start.y, goalX, goalY);
                nodeList.push(start);
                openList.push(start.y * mapWidth + start.x);
       
                while (nodeList.length > 0) {
                        var bestIndex = 0;
                        for (var i = 0; i < nodeList.length; i++) {
                                if (nodeList.f < nodeList[bestIndex].f) {
                                        bestIndex = i;
                                }
                        }
       
                        var current = nodeList[bestIndex];
                        var x1 = current.x;
                        var y1 = current.y;
                        var pos1 = y1 * mapWidth + x1;
                        var g1 = current.g;
       
                        nodeList.splice(bestIndex, 1);
                        openList.splice(openList.indexOf(pos1), 1);
                        closedList.push(pos1);
       
                        if (current.x === goalX && current.y === goalY) {
                                best = current;
                                goaled = true;
                                break;
                        }
       
                        if (g1 >= searchLimit) {
                                continue;
                        }
       
       
                        for (var j = 0; j < 9; j++) {
                                var direction = 1 + j;
                               
                                if (direction === 5) continue;
                               
                                var diag = Math.abs(direction % 2) == 1;
                                var dirs = Galv.DM.getHorzVertDirs(direction);
                                var horz = dirs[0];
                                var vert = dirs[1];
                               
                                if (diag && this.canPassDiagonally(x1, y1, horz, vert) && (this.canPass(x1, y1, horz) || this.canPass(x1, y1, vert))) {
                                        // If can go diagonally and a horizontal dir isn't blocking
                                        var x2 = $gameMap.roundXWithDirection(x1, horz);
                                        var y2 = $gameMap.roundYWithDirection(y1, vert);
                                } else if (this.canPass(x1, y1, direction)) {
                                        var x2 = $gameMap.roundXWithDirection(x1, direction);
                                        var y2 = $gameMap.roundYWithDirection(y1, direction);
                                } else {
                                        continue;
                                };
       
                                var pos2 = y2 * mapWidth + x2;
       
                                if (closedList.contains(pos2)) {
                                        continue;
                                }
       
                                var g2 = g1 + 1;
                                var index2 = openList.indexOf(pos2);
       
                                if (index2 < 0 || g2 < nodeList[index2].g) {
                                        var neighbor;
                                        if (index2 >= 0) {
                                                neighbor = nodeList[index2];
                                        } else {
                                                neighbor = {};
                                                nodeList.push(neighbor);
                                                openList.push(pos2);
                                        }
                                        neighbor.parent = current;
                                        neighbor.x = x2;
                                        neighbor.y = y2;
                                        neighbor.g = g2;
                                        neighbor.f = g2 + $gameMap.distance(x2, y2, goalX, goalY);
                                        if (!best || neighbor.f - neighbor.g < best.f - best.g) {
                                                best = neighbor;
                                        }
                                }
                        }
                }
       
                var node = best;
                while (node.parent && node.parent !== start) {
                        node = node.parent;
                }
       
                var deltaX1 = $gameMap.deltaX(node.x, start.x);
                var deltaY1 = $gameMap.deltaY(node.y, start.y);
               
               
                if (deltaY1 > 0 && deltaX1 > 0) {
                        return 3;
                } else if (deltaY1 > 0 && deltaX1 < 0) {
                        return 1;
                } else if (deltaY1 < 0 && deltaX1 < 0) {
                        return 7;
                } else if (deltaY1 < 0 && deltaX1 > 0) {
                        return 9;
                };
               
               
                if (deltaY1 > 0) {
                        return 2;
                } else if (deltaX1 < 0) {
                        return 4;
                } else if (deltaX1 > 0) {
                        return 6;
                } else if (deltaY1 < 0) {
                        return 8;
                }
       
                var deltaX2 = this.deltaXFrom(goalX);
                var deltaY2 = this.deltaYFrom(goalY);
               
               
                if (Math.abs(deltaX2) > Math.abs(deltaY2)) {
                        return deltaX2 > 0 ? 4 : 6;
                } else if (deltaY2 !== 0) {
                        return deltaY2 > 0 ? 8 : 2;
                }
       
                return 0;
        };
};
};

})();[/pre]

Fan723

梦想家大魔王 发表于 2017-11-5 17:17
我把手头收集的几个同类插件挨个试了一遍，感觉这个用起来是最舒服的。

哎呀！插件好是好，但是跟Alpha ABS有冲突呀，求个兼容版。通通拜谢！

wabcmcc

最好用.有開關4方/8方通行插件.
Yami_8DirEx.js Yami_8DirEx.zip (2.72 KB, 下载次数: 157)

2017-11-20 15:59 上传

点击文件名下载附件

Fan723

wabcmcc 发表于 2017-11-20 16:03
最好用.有開關4方/8方通行插件.
Yami_8DirEx.js

谢谢！又一个作者，又多了冲突的可能，前面那个我已经解决兼容性问题了，这个留以后研究。