SHARE
TWEET

Untitled

a guest Apr 16th, 2019 38 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. Galv.DM.Game_CharacterBase_realMoveSpeed = Game_CharacterBase.prototype.realMoveSpeed;
  2. Game_CharacterBase.prototype.realMoveSpeed = function() {
  3.     var spd = Galv.DM.Game_CharacterBase_realMoveSpeed.call(this);
  4.     return this._diagDir ? spd * Galv.DM.diagMod : spd;
  5. };
  6.  
  7. // overwrite
  8. Game_Follower.prototype.realMoveSpeed = function() {
  9.     return $gamePlayer.realMoveSpeed();
  10. };
  11.  
  12. Galv.DM.getHorzVertDirs = function(direction) {
  13.     switch (direction) {
  14.         case 1: return [4,2];
  15.         case 3: return [6,2];
  16.         case 7: return [4,8];
  17.         case 9: return [6,8];
  18.         default: return [0,0];
  19.     };
  20. };
  21.  
  22. Galv.DM.getDir = function(horz,vert) {
  23.     if (horz == 4 && vert == 2) return 1;
  24.     if (horz == 6 && vert == 2) return 3;
  25.     if (horz == 4 && vert == 8) return 7;
  26.     if (horz == 6 && vert == 8) return 9;
  27.     return 0;
  28. };
  29.  
  30. Galv.DM.diagRow = {
  31.     3: 0,
  32.     1: 1,
  33.     9: 2,
  34.     7: 3
  35. };
  36.  
  37. Galv.DM.Game_CharacterBase_moveStraight = Game_CharacterBase.prototype.moveStraight;
  38. Game_CharacterBase.prototype.moveStraight = function(d) {
  39.     this._diagDir = false;
  40.     Galv.DM.Game_CharacterBase_moveStraight.call(this,d);
  41. };
  42.  
  43. Galv.DM.Game_CharacterBase_setDirection = Game_CharacterBase.prototype.setDirection;
  44. Game_CharacterBase.prototype.setDirection = function(d) {
  45.     if (this._diagStraigten) this._diagDir = false;
  46.     Galv.DM.Game_CharacterBase_setDirection.call(this,d);
  47. };
  48.  
  49. if (Galv.DM.diagBlocked) {
  50.     Game_Player.prototype.canPassDiagonally = function(x, y, horz, vert) {
  51.         var x2 = $gameMap.roundXWithDirection(x, horz);
  52.         var y2 = $gameMap.roundYWithDirection(y, vert);
  53.         if (this.canPass(x, y, vert) && this.canPass(x, y2, horz) && this.canPass(x, y, horz) && this.canPass(x2, y, vert)) {
  54.             return true;
  55.         };
  56.         return false;
  57.     };
  58. };
  59.  
  60. Galv.DM.Game_Player_canPassDiagonally = Game_Player.prototype.canPassDiagonally;
  61. Game_Player.prototype.canPassDiagonally = function(x, y, horz, vert) {
  62.     if ($gameSystem.disableVert) return false;
  63.     return Galv.DM.Game_Player_canPassDiagonally.call(this,x,y,horz,vert);
  64. };
  65.  
  66. // OVERWRITE
  67. Game_CharacterBase.prototype.moveDiagonally = function(horz, vert) {
  68.     var diag = this.canPassDiagonally(this._x, this._y, horz, vert);
  69.     var norm = this.canPass(this._x, this._y, horz) || this.canPass(this._x, this._y, vert);
  70.    
  71.     if (diag) {
  72.         this._diagDir = Galv.DM.getDir(horz,vert);
  73.         this._x = $gameMap.roundXWithDirection(this._x, horz);
  74.         this._y = $gameMap.roundYWithDirection(this._y, vert);
  75.         this._realX = $gameMap.xWithDirection(this._x, this.reverseDir(horz));
  76.         this._realY = $gameMap.yWithDirection(this._y, this.reverseDir(vert));
  77.         this.increaseSteps();
  78.     } else if (norm) {
  79.         this._diagDir = false;
  80.         this.moveStraight(this.getOtherdir(horz,vert));
  81.     };
  82.    
  83.     this._diagStraigten = false;
  84.     if (this._direction === this.reverseDir(horz)) this.setDirection(horz);
  85.     if (this._direction === this.reverseDir(vert)) this.setDirection(vert);
  86.     this._diagStraigten = true;
  87. };
  88.  
  89. Game_CharacterBase.prototype.getOtherdir = function(horz, vert) {
  90.     return this.canPass(this._x, this._y, horz) ? horz : vert;
  91. };
  92.  
  93. // OVERWRITE
  94. Game_Player.prototype.getInputDirection = function() {
  95.     return Input.dir8;
  96. };
  97.  
  98. Galv.DM.Game_Player_executeMove = Game_Player.prototype.executeMove;
  99. Game_Player.prototype.executeMove = function(direction) {
  100.     if (direction % 2 == 0) {
  101.         Galv.DM.Game_Player_executeMove.call(this,direction);
  102.     } else if (Math.abs(direction % 2) == 1) {
  103.         var dirArray = Galv.DM.getHorzVertDirs(direction);
  104.         this.moveDiagonally(dirArray[0],dirArray[1]);
  105.     };
  106. };
  107.  
  108.  
  109.  
  110. // If using Diaonal Charset
  111. if (Galv.DM.diagGraphic) {
  112. Galv.DM.Sprite_Character_characterPatternY = Sprite_Character.prototype.characterPatternY;
  113. Sprite_Character.prototype.characterPatternY = function() {
  114.     if (!this._isBigCharacter && this._character._diagDir && this._character.characterIndex() < 4) {
  115.         return Galv.DM.diagRow[this._character._diagDir];
  116.     } else {
  117.         return Galv.DM.Sprite_Character_characterPatternY.call(this);
  118.     };
  119. };
  120.  
  121. Galv.DM.Sprite_Character_characterBlockX = Sprite_Character.prototype.characterBlockX;
  122. Sprite_Character.prototype.characterBlockX = function() {
  123.     if (!this._isBigCharacter && this._character._diagDir && this._character.characterIndex() < 4) {
  124.         var index = this._character.characterIndex() + 4;
  125.         return index % 4 * this._character._cframes;
  126.     } else {   
  127.         return Galv.DM.Sprite_Character_characterBlockX.call(this);
  128.     };
  129.  
  130. };
  131.  
  132. Galv.DM.Sprite_Character_characterBlockY = Sprite_Character.prototype.characterBlockY;
  133. Sprite_Character.prototype.characterBlockY = function() {
  134.     if (!this._isBigCharacter && this._character._diagDir && this._character.characterIndex() < 4) {
  135.         var index = this._character.characterIndex() + 4;
  136.         return Math.floor(index / 4) * 4;
  137.     } else {   
  138.         return Galv.DM.Sprite_Character_characterBlockY.call(this);
  139.     };
  140.  
  141. };
  142. };
  143. // end if using diagonal charset
  144.  
  145.  
  146. // turn toward character on diagonal
  147. // OVERWRITE
  148. Game_Character.prototype.turnTowardCharacter = function(character) {
  149.     var sx = this.deltaXFrom(character.x);
  150.     var sy = this.deltaYFrom(character.y);
  151.    
  152.     var absSx = Math.abs(sx);
  153.     var absSy = Math.abs(sy);
  154.  
  155.     if (absSx == absSy) {
  156.         if (sx < 0) {
  157.             this._diagDir = sy > 0 ? 9 : 3;
  158.         } else if (sx > 0) {
  159.             this._diagDir = sy > 0 ? 7 : 1;
  160.         }
  161.     } else {
  162.         this._diagDir = 0;
  163.     };
  164.     if (absSx > absSy) {
  165.         this.setDirection(sx > 0 ? 4 : 6);
  166.     } else if (sy !== 0) {
  167.         this.setDirection(sy > 0 ? 8 : 2);
  168.     }
  169. };
  170.  
  171.  
  172.  
  173.  
  174.  
  175.  
  176. // If using diagonal mouse movement:
  177.  
  178. if (Galv.DM.mouseMove) {
  179. Galv.DM.Game_Character_findDirectionTo = Game_Character.prototype.findDirectionTo;
  180. // OVERWRITE
  181. Game_Character.prototype.findDirectionTo = function(goalX, goalY) {
  182.     if ($gameSystem.disableVert) {
  183.         return Galv.DM.Game_Character_findDirectionTo.call(this,goalX,goalY);
  184.     } else {
  185.         var searchLimit = this.searchLimit();
  186.         var mapWidth = $gameMap.width();
  187.         var nodeList = [];
  188.         var openList = [];
  189.         var closedList = [];
  190.         var start = {};
  191.         var best = start;
  192.    
  193.         if (this.x === goalX && this.y === goalY) {
  194.             return 0;
  195.         }
  196.    
  197.         start.parent = null;
  198.         start.x = this.x;
  199.         start.y = this.y;
  200.         start.g = 0;
  201.         start.f = $gameMap.distance(start.x, start.y, goalX, goalY);
  202.         nodeList.push(start);
  203.         openList.push(start.y * mapWidth + start.x);
  204.    
  205.         while (nodeList.length > 0) {
  206.             var bestIndex = 0;
  207.             for (var i = 0; i < nodeList.length; i++) {
  208.                 if (nodeList[i].f < nodeList[bestIndex].f) {
  209.                     bestIndex = i;
  210.                 }
  211.             }
  212.    
  213.             var current = nodeList[bestIndex];
  214.             var x1 = current.x;
  215.             var y1 = current.y;
  216.             var pos1 = y1 * mapWidth + x1;
  217.             var g1 = current.g;
  218.    
  219.             nodeList.splice(bestIndex, 1);
  220.             openList.splice(openList.indexOf(pos1), 1);
  221.             closedList.push(pos1);
  222.    
  223.             if (current.x === goalX && current.y === goalY) {
  224.                 best = current;
  225.                 goaled = true;
  226.                 break;
  227.             }
  228.    
  229.             if (g1 >= searchLimit) {
  230.                 continue;
  231.             }
  232.    
  233.    
  234.             for (var j = 0; j < 9; j++) {
  235.                 var direction = 1 + j;
  236.                
  237.                 if (direction === 5) continue;
  238.                
  239.                 var diag = Math.abs(direction % 2) == 1;
  240.                 var dirs = Galv.DM.getHorzVertDirs(direction);
  241.                 var horz = dirs[0];
  242.                 var vert = dirs[1];
  243.                
  244.                 if (diag && this.canPassDiagonally(x1, y1, horz, vert) && (this.canPass(x1, y1, horz) || this.canPass(x1, y1, vert))) {
  245.                     // If can go diagonally and a horizontal dir isn't blocking
  246.                     var x2 = $gameMap.roundXWithDirection(x1, horz);
  247.                     var y2 = $gameMap.roundYWithDirection(y1, vert);
  248.                 } else if (this.canPass(x1, y1, direction)) {
  249.                     var x2 = $gameMap.roundXWithDirection(x1, direction);
  250.                     var y2 = $gameMap.roundYWithDirection(y1, direction);
  251.                 } else {
  252.                     continue;
  253.                 };
  254.    
  255.                 var pos2 = y2 * mapWidth + x2;
  256.    
  257.                 if (closedList.contains(pos2)) {
  258.                     continue;
  259.                 }
  260.    
  261.                 var g2 = g1 + 1;
  262.                 var index2 = openList.indexOf(pos2);
  263.    
  264.                 if (index2 < 0 || g2 < nodeList[index2].g) {
  265.                     var neighbor;
  266.                     if (index2 >= 0) {
  267.                         neighbor = nodeList[index2];
  268.                     } else {
  269.                         neighbor = {};
  270.                         nodeList.push(neighbor);
  271.                         openList.push(pos2);
  272.                     }
  273.                     neighbor.parent = current;
  274.                     neighbor.x = x2;
  275.                     neighbor.y = y2;
  276.                     neighbor.g = g2;
  277.                     neighbor.f = g2 + $gameMap.distance(x2, y2, goalX, goalY);
  278.                     if (!best || neighbor.f - neighbor.g < best.f - best.g) {
  279.                         best = neighbor;
  280.                     }
  281.                 }
  282.             }
  283.         }
  284.    
  285.         var node = best;
  286.         while (node.parent && node.parent !== start) {
  287.             node = node.parent;
  288.         }
  289.    
  290.         var deltaX1 = $gameMap.deltaX(node.x, start.x);
  291.         var deltaY1 = $gameMap.deltaY(node.y, start.y);
  292.        
  293.        
  294.         if (deltaY1 > 0 && deltaX1 > 0) {
  295.             return 3;
  296.         } else if (deltaY1 > 0 && deltaX1 < 0) {
  297.             return 1;
  298.         } else if (deltaY1 < 0 && deltaX1 < 0) {
  299.             return 7;
  300.         } else if (deltaY1 < 0 && deltaX1 > 0) {
  301.             return 9;
  302.         };
  303.        
  304.        
  305.         if (deltaY1 > 0) {
  306.             return 2;
  307.         } else if (deltaX1 < 0) {
  308.             return 4;
  309.         } else if (deltaX1 > 0) {
  310.             return 6;
  311.         } else if (deltaY1 < 0) {
  312.             return 8;
  313.         }
  314.    
  315.         var deltaX2 = this.deltaXFrom(goalX);
  316.         var deltaY2 = this.deltaYFrom(goalY);
  317.        
  318.        
  319.         if (Math.abs(deltaX2) > Math.abs(deltaY2)) {
  320.             return deltaX2 > 0 ? 4 : 6;
  321.         } else if (deltaY2 !== 0) {
  322.             return deltaY2 > 0 ? 8 : 2;
  323.         }
  324.    
  325.         return 0;
  326.     };
  327. };
  328. };
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top