Added UROKO design function(size adjustment).

diff --git a/engine/kage.js b/engine/kage.js
index b2d9710..0d3f933 100755 (executable)
--- a/engine/kage.js
+++ b/engine/kage.js
@@ -1,314 +1,222 @@
-function Kage(){
-  // method
-  function makeGlyph(polygons, buhin){ // void
-    var glyphData = this.kBuhin.search(buhin);
-    if(glyphData != ""){
-      this.drawStrokesArray(polygons, this.adjustKakato(this.getEachStrokes(glyphData)));
-    }
-  }
-  Kage.prototype.makeGlyph = makeGlyph;
-  
-  function getEachStrokes(glyphData){ // strokes array
-    var strokesArray = new Array();
-    var strokes = glyphData.split("$");
-    for(var i = 0; i < strokes.length; i++){
-      var columns = strokes[i].split(":");
-      if(Math.floor(columns[0]) != 99){
-        strokesArray.push([
-          Math.floor(columns[0]),
-          Math.floor(columns[1]),
-          Math.floor(columns[2]),
-          Math.floor(columns[3]),
-          Math.floor(columns[4]),
-          Math.floor(columns[5]),
-          Math.floor(columns[6]),
-          Math.floor(columns[7]),
-          Math.floor(columns[8]),
-          Math.floor(columns[9]),
-          Math.floor(columns[10])
-          ]);
-      } else {
-        var buhin = this.kBuhin.search(columns[7]);
-        if(buhin != ""){
-          strokesArray = strokesArray.concat(this.getEachStrokesOfBuhin(buhin,
-                                                  Math.floor(columns[3]),
-                                                  Math.floor(columns[4]),
-                                                  Math.floor(columns[5]),
-                                                  Math.floor(columns[6]))
-                            );
-        }
-      }
-    }
-    return strokesArray;
-  }
-  Kage.prototype.getEachStrokes = getEachStrokes;
-  
-  function getEachStrokesOfBuhin(buhin, x1, y1, x2, y2){
-    var temp = this.getEachStrokes(buhin);
-    var result = new Array();
-    for(var i = 0; i < temp.length; i++){
-      result.push([temp[i][0],
-                   temp[i][1],
-                   temp[i][2],
-                   x1 + temp[i][3] * (x2 - x1) / 200,
-                   y1 + temp[i][4] * (y2 - y1) / 200,
-                   x1 + temp[i][5] * (x2 - x1) / 200,
-                   y1 + temp[i][6] * (y2 - y1) / 200,
-                   x1 + temp[i][7] * (x2 - x1) / 200,
-                   y1 + temp[i][8] * (y2 - y1) / 200,
-                   x1 + temp[i][9] * (x2 - x1) / 200,
-                   y1 + temp[i][10] * (y2 - y1) / 200]);
-    }
-    return result;
-  }
-  Kage.prototype.getEachStrokesOfBuhin = getEachStrokesOfBuhin;
-  
-  function adjustKakato(strokesArray){ // strokesArray
-    for(var i = 0; i < strokesArray.length; i++){
-      if(strokesArray[i][0] == 1 &&
-         (strokesArray[i][2] == 13 || strokesArray[i][2] == 23)){
-        for(var k = 0; k < this.kAdjustKakatoStep; k++){
-          var crossing = 0;
-          for(var j = 0; j < strokesArray.length && !crossing; j++){
-            if(i == j){ continue; }
-            switch(strokesArray[j][0]){
-            case 0:
-            case 8:
-            case 9:
-              break;
-            case 6:
-            case 7:
-              if(!crossing && isCross(strokesArray[j][7],
-                         strokesArray[j][8],
-                         strokesArray[j][9],
-                         strokesArray[j][10],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k])){
-                crossing++;
-              }
-              if(!crossing && isCross(strokesArray[j][7],
-                         strokesArray[j][8],
-                         strokesArray[j][9],
-                         strokesArray[j][10],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1])){
-                crossing++;
-              }
-              if(!crossing && isCross(strokesArray[j][7],
-                         strokesArray[j][8],
-                         strokesArray[j][9],
-                         strokesArray[j][10],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1])){
-                crossing++;
-              }
-              if(!crossing && isCross(strokesArray[j][7],
-                         strokesArray[j][8],
-                         strokesArray[j][9],
-                         strokesArray[j][10],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1])){
-                crossing++;
-              }
-            case 2:
-            case 12:
-            case 3:
-              if(!crossing && isCross(strokesArray[j][5],
-                         strokesArray[j][6],
-                         strokesArray[j][7],
-                         strokesArray[j][8],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k])){
-                crossing++;
-              }
-              if(!crossing && isCross(strokesArray[j][5],
-                         strokesArray[j][6],
-                         strokesArray[j][7],
-                         strokesArray[j][8],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1])){
-                crossing++;
-              }
-              if(!crossing && isCross(strokesArray[j][5],
-                         strokesArray[j][6],
-                         strokesArray[j][7],
-                         strokesArray[j][8],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1])){
-                crossing++;
-              }
-              if(!crossing && isCross(strokesArray[j][5],
-                         strokesArray[j][6],
-                         strokesArray[j][7],
-                         strokesArray[j][8],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1])){
-                crossing++;
-              }
-            default:
-              if(!crossing && isCross(strokesArray[j][3],
-                         strokesArray[j][4],
-                         strokesArray[j][5],
-                         strokesArray[j][6],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k])){
-                crossing++;
-              }
-              if(!crossing && isCross(strokesArray[j][3],
-                         strokesArray[j][4],
-                         strokesArray[j][5],
-                         strokesArray[j][6],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1])){
-                crossing++;
-              }
-              if(!crossing && isCross(strokesArray[j][3],
-                         strokesArray[j][4],
-                         strokesArray[j][5],
-                         strokesArray[j][6],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1])){
-                crossing++;
-              }
-              if(!crossing && isCross(strokesArray[j][3],
-                         strokesArray[j][4],
-                         strokesArray[j][5],
-                         strokesArray[j][6],
-                         strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1],
-                         strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,
-                         strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1])){
-                crossing++;
-              }
-            }
-          }
-          if(crossing){
-            strokesArray[i][2] += (3 - k) * 100;
-            k = Infinity;
-          }
-        }
-      }
-    }
-    return strokesArray;
-  }
-  Kage.prototype.adjustKakato = adjustKakato;
-  
-  function drawStrokesArray(polygons, strokesArray){
-    for(var i = 0; i < strokesArray.length; i++){
-      dfDrawFont(this, polygons,
-                 strokesArray[i][0],
-                 strokesArray[i][1],
-                 strokesArray[i][2],
-                 strokesArray[i][3],
-                 strokesArray[i][4],
-                 strokesArray[i][5],
-                 strokesArray[i][6],
-                 strokesArray[i][7],
-                 strokesArray[i][8],
-                 strokesArray[i][9],
-                 strokesArray[i][10]);
-    }
-  }
-  Kage.prototype.drawStrokesArray = drawStrokesArray;
-  
-  function drawGlyph(polygons, glyph){ // void
-    // [glyph] : [stroke]$[stroke]$.....
-    // [stroke] : [column]:[column]:.....
-    var strokes = glyph.split("$");
-    for(var i = 0; i < strokes.length; i++){
-      var columns = strokes[i].split(":");
-      if(Math.floor(columns[0]) != 99){
-        dfDrawFont(this, polygons,
-                   Math.floor(columns[0]),
-                   Math.floor(columns[1]), Math.floor(columns[2]),
-                   Math.floor(columns[3]), Math.floor(columns[4]),
-                   Math.floor(columns[5]), Math.floor(columns[6]),
-                   Math.floor(columns[7]), Math.floor(columns[8]),
-                   Math.floor(columns[9]), Math.floor(columns[10]));
-      } else {
-        var buhin = this.kBuhin.search(columns[7]);
-        if(buhin != ""){
-          this.drawBuhin(polygons, buhin,
-                         Math.floor(columns[3]),
-                         Math.floor(columns[4]),
-                         Math.floor(columns[5]),
-                         Math.floor(columns[6]));
-        }
-      }
-    }
-  }
-  Kage.prototype.drawGlyph = drawGlyph;
-  
-  function drawBuhin(polygons, glyph, x1, y1, x2, y2){ // void
-    var strokes = glyph.split("$");
-    for(var i = 0; i < strokes.length; i++){
-      var columns = strokes[i].split(":");
-      if(Math.floor(columns[0]) != 99){
-        dfDrawFont(this, polygons,
-                   Math.floor(columns[0]),
-                   Math.floor(columns[1]),
-                   Math.floor(columns[2]),
-                   x1 + Math.floor(columns[3]) * (x2 - x1) / 200,
-                   y1 + Math.floor(columns[4]) * (y2 - y1) / 200,
-                   x1 + Math.floor(columns[5]) * (x2 - x1) / 200,
-                   y1 + Math.floor(columns[6]) * (y2 - y1) / 200,
-                   x1 + Math.floor(columns[7]) * (x2 - x1) / 200,
-                   y1 + Math.floor(columns[8]) * (y2 - y1) / 200,
-                   x1 + Math.floor(columns[9]) * (x2 - x1) / 200,
-                   y1 + Math.floor(columns[10]) * (y2 - y1) / 200);
-      } else {
-        var buhin = this.kBuhin.search(columns[7]);
-        if(buhin != ""){
-          this.drawBuhin(polygons, buhin,
-                         x1 + Math.floor(columns[3]) * (x2 - x1) / 200,
-                         y1 + Math.floor(columns[4]) * (y2 - y1) / 200,
-                         x1 + Math.floor(columns[5]) * (x2 - x1) / 200,
-                         y1 + Math.floor(columns[6]) * (y2 - y1) / 200);
-        }
-      }
-    }
-  }
-  Kage.prototype.drawBuhin = drawBuhin;
-  
-  //properties
-  Kage.prototype.kMincho = 0;
-  Kage.prototype.kGothic = 1;
-  this.kShotai = this.kMincho;
-  this.kMage = 10;
-  this.kRate = 100;
-  this.kMinWidthY = 2;
-  this.kMinWidthT = 6;
-  this.kWidth = 5;
-  this.kAdjustKakatoL = ([14, 9, 5, 2]); // 調整済みカカト用
-  this.kAdjustKakatoR = ([8, 6, 4, 2]); // 調整済みカカト用
-  this.kAdjustKakatoRangeX = 20; // 影響判定矩形の大きさ
-  this.kAdjustKakatoRangeY = ([1, 19, 24, 30]); // 影響判定矩形の大きさ
-  this.kAdjustKakatoStep = 3; // 影響判定矩形の段階
-  this.kKakato = 3;
-  this.kL2RDfatten = 1.1;
-  this.kBuhin = new Buhin();
-  
-  return this;
-}
+function Kage(){\r
+  // method\r
+  function makeGlyph(polygons, buhin){ // void\r
+    var glyphData = this.kBuhin.search(buhin);\r
+    if(glyphData != ""){\r
+      this.drawStrokesArray(polygons, this.adjustUroko(this.adjustKakato(this.getEachStrokes(glyphData))));\r
+    }\r
+  }\r
+  Kage.prototype.makeGlyph = makeGlyph;\r
+  \r
+  function getEachStrokes(glyphData){ // strokes array\r
+    var strokesArray = new Array();\r
+    var strokes = glyphData.split("$");\r
+    for(var i = 0; i < strokes.length; i++){\r
+      var columns = strokes[i].split(":");\r
+      if(Math.floor(columns[0]) != 99){\r
+        strokesArray.push([\r
+          Math.floor(columns[0]),\r
+          Math.floor(columns[1]),\r
+          Math.floor(columns[2]),\r
+          Math.floor(columns[3]),\r
+          Math.floor(columns[4]),\r
+          Math.floor(columns[5]),\r
+          Math.floor(columns[6]),\r
+          Math.floor(columns[7]),\r
+          Math.floor(columns[8]),\r
+          Math.floor(columns[9]),\r
+          Math.floor(columns[10])\r
+          ]);\r
+      } else {\r
+        var buhin = this.kBuhin.search(columns[7]);\r
+        if(buhin != ""){\r
+          strokesArray = strokesArray.concat(this.getEachStrokesOfBuhin(buhin,\r
+                                                  Math.floor(columns[3]),\r
+                                                  Math.floor(columns[4]),\r
+                                                  Math.floor(columns[5]),\r
+                                                  Math.floor(columns[6]))\r
+                            );\r
+        }\r
+      }\r
+    }\r
+    return strokesArray;\r
+  }\r
+  Kage.prototype.getEachStrokes = getEachStrokes;\r
+  \r
+  function getEachStrokesOfBuhin(buhin, x1, y1, x2, y2){\r
+    var temp = this.getEachStrokes(buhin);\r
+    var result = new Array();\r
+    for(var i = 0; i < temp.length; i++){\r
+      result.push([temp[i][0],\r
+                   temp[i][1],\r
+                   temp[i][2],\r
+                   x1 + temp[i][3] * (x2 - x1) / 200,\r
+                   y1 + temp[i][4] * (y2 - y1) / 200,\r
+                   x1 + temp[i][5] * (x2 - x1) / 200,\r
+                   y1 + temp[i][6] * (y2 - y1) / 200,\r
+                   x1 + temp[i][7] * (x2 - x1) / 200,\r
+                   y1 + temp[i][8] * (y2 - y1) / 200,\r
+                   x1 + temp[i][9] * (x2 - x1) / 200,\r
+                   y1 + temp[i][10] * (y2 - y1) / 200]);\r
+    }\r
+    return result;\r
+  }\r
+  Kage.prototype.getEachStrokesOfBuhin = getEachStrokesOfBuhin;\r
+  \r
+       function adjustUroko(strokesArray){ // strokesArray\r
+    for(var i = 0; i < strokesArray.length; i++){\r
+      if(strokesArray[i][0] == 1 && strokesArray[i][2] == 0){ // \8fc\82Í\83E\83\8d\83R\82È\82¢\82Ì\82Å\96³\8e\8b\81B\82Å\82à\8cv\8eZ\97Ê\82ª\96³\91Ê\r
+        for(var k = 0; k < this.kAdjustUrokoLengthStep; k++){\r
+          var tx, ty, tlen;\r
+          if(strokesArray[i][4] == strokesArray[i][6]){ // \89¡\r
+            tx = strokesArray[i][5] - this.kAdjustUrokoLine[k];\r
+            ty = strokesArray[i][6] - 0.5;\r
+            tlen = strokesArray[i][5] - strokesArray[i][3];\r
+          } else {\r
+            var rad = Math.atan((strokesArray[i][6] - strokesArray[i][4]) / (strokesArray[i][5] - strokesArray[i][3]));\r
+            tx = strokesArray[i][5] - this.kAdjustUrokoLine[k] * Math.cos(rad) - 0.5 * Math.sin(rad);\r
+            ty = strokesArray[i][6] - this.kAdjustUrokoLine[k] * Math.sin(rad) - 0.5 * Math.cos(rad);\r
+            tlen = Math.sqrt((strokesArray[i][6] - strokesArray[i][4]) * (strokesArray[i][6] - strokesArray[i][4]) +\r
+                             (strokesArray[i][5] - strokesArray[i][3]) * (strokesArray[i][5] - strokesArray[i][3]));\r
+          }\r
+          if(tlen < this.kAdjustUrokoLength[k] ||\r
+             isCrossWithOthers(strokesArray, i, tx, ty, strokesArray[i][5], strokesArray[i][6])\r
+             ){\r
+            strokesArray[i][2] += (this.kAdjustUrokoLengthStep - k) * 100;\r
+            k = Infinity;\r
+          }\r
+        }\r
+      }\r
+    }\r
+    return strokesArray;\r
+  }\r
+  Kage.prototype.adjustUroko = adjustUroko;\r
+       \r
+  function adjustKakato(strokesArray){ // strokesArray\r
+    for(var i = 0; i < strokesArray.length; i++){\r
+      if(strokesArray[i][0] == 1 &&\r
+         (strokesArray[i][2] == 13 || strokesArray[i][2] == 23)){\r
+        for(var k = 0; k < this.kAdjustKakatoStep; k++){\r
+          if(isCrossBoxWithOthers(strokesArray, i,\r
+                               strokesArray[i][5] - this.kAdjustKakatoRangeX / 2,\r
+                               strokesArray[i][6] + this.kAdjustKakatoRangeY[k],\r
+                               strokesArray[i][5] + this.kAdjustKakatoRangeX / 2,\r
+                               strokesArray[i][6] + this.kAdjustKakatoRangeY[k + 1])\r
+             ){\r
+            strokesArray[i][2] += (3 - k) * 100;\r
+            k = Infinity;\r
+          }\r
+        }\r
+      }\r
+    }\r
+    return strokesArray;\r
+  }\r
+  Kage.prototype.adjustKakato = adjustKakato;\r
+  \r
+  function drawStrokesArray(polygons, strokesArray){\r
+    for(var i = 0; i < strokesArray.length; i++){\r
+      dfDrawFont(this, polygons,\r
+                 strokesArray[i][0],\r
+                 strokesArray[i][1],\r
+                 strokesArray[i][2],\r
+                 strokesArray[i][3],\r
+                 strokesArray[i][4],\r
+                 strokesArray[i][5],\r
+                 strokesArray[i][6],\r
+                 strokesArray[i][7],\r
+                 strokesArray[i][8],\r
+                 strokesArray[i][9],\r
+                 strokesArray[i][10]);\r
+    }\r
+  }\r
+  Kage.prototype.drawStrokesArray = drawStrokesArray;\r
+  \r
+  function drawGlyph(polygons, glyph){ // void\r
+    // [glyph] : [stroke]$[stroke]$.....\r
+    // [stroke] : [column]:[column]:.....\r
+    var strokes = glyph.split("$");\r
+    for(var i = 0; i < strokes.length; i++){\r
+      var columns = strokes[i].split(":");\r
+      if(Math.floor(columns[0]) != 99){\r
+        dfDrawFont(this, polygons,\r
+                   Math.floor(columns[0]),\r
+                   Math.floor(columns[1]), Math.floor(columns[2]),\r
+                   Math.floor(columns[3]), Math.floor(columns[4]),\r
+                   Math.floor(columns[5]), Math.floor(columns[6]),\r
+                   Math.floor(columns[7]), Math.floor(columns[8]),\r
+                   Math.floor(columns[9]), Math.floor(columns[10]));\r
+      } else {\r
+        var buhin = this.kBuhin.search(columns[7]);\r
+        if(buhin != ""){\r
+          this.drawBuhin(polygons, buhin,\r
+                         Math.floor(columns[3]),\r
+                         Math.floor(columns[4]),\r
+                         Math.floor(columns[5]),\r
+                         Math.floor(columns[6]));\r
+        }\r
+      }\r
+    }\r
+  }\r
+  Kage.prototype.drawGlyph = drawGlyph;\r
+  \r
+  function drawBuhin(polygons, glyph, x1, y1, x2, y2){ // void\r
+    var strokes = glyph.split("$");\r
+    for(var i = 0; i < strokes.length; i++){\r
+      var columns = strokes[i].split(":");\r
+      if(Math.floor(columns[0]) != 99){\r
+        dfDrawFont(this, polygons,\r
+                   Math.floor(columns[0]),\r
+                   Math.floor(columns[1]),\r
+                   Math.floor(columns[2]),\r
+                   x1 + Math.floor(columns[3]) * (x2 - x1) / 200,\r
+                   y1 + Math.floor(columns[4]) * (y2 - y1) / 200,\r
+                   x1 + Math.floor(columns[5]) * (x2 - x1) / 200,\r
+                   y1 + Math.floor(columns[6]) * (y2 - y1) / 200,\r
+                   x1 + Math.floor(columns[7]) * (x2 - x1) / 200,\r
+                   y1 + Math.floor(columns[8]) * (y2 - y1) / 200,\r
+                   x1 + Math.floor(columns[9]) * (x2 - x1) / 200,\r
+                   y1 + Math.floor(columns[10]) * (y2 - y1) / 200);\r
+      } else {\r
+        var buhin = this.kBuhin.search(columns[7]);\r
+        if(buhin != ""){\r
+          this.drawBuhin(polygons, buhin,\r
+                         x1 + Math.floor(columns[3]) * (x2 - x1) / 200,\r
+                         y1 + Math.floor(columns[4]) * (y2 - y1) / 200,\r
+                         x1 + Math.floor(columns[5]) * (x2 - x1) / 200,\r
+                         y1 + Math.floor(columns[6]) * (y2 - y1) / 200);\r
+        }\r
+      }\r
+    }\r
+  }\r
+  Kage.prototype.drawBuhin = drawBuhin;\r
+  \r
+  //properties\r
+  Kage.prototype.kMincho = 0;\r
+  Kage.prototype.kGothic = 1;\r
+  this.kShotai = this.kMincho;\r
+       \r
+  this.kRate = 100;\r
+       \r
+  this.kMinWidthY = 2;\r
+  this.kMinWidthT = 6;\r
+  this.kWidth = 5;\r
+  this.kKakato = 3;\r
+  this.kL2RDfatten = 1.1;\r
+  this.kMage = 10;\r
+       \r
+  this.kAdjustKakatoL = ([14, 9, 5, 2]); // \92²\90®\8dÏ\82Ý\83J\83J\83g\97p 000,100,200,300\r
+  this.kAdjustKakatoR = ([8, 6, 4, 2]); // \92²\90®\8dÏ\82Ý\83J\83J\83g\97p 000,100,200,300\r
+  this.kAdjustKakatoRangeX = 20; // \89e\8b¿\94»\92è\8bé\8c`\82Ì\91å\82«\82³\r
+  this.kAdjustKakatoRangeY = ([1, 19, 24, 30]); // \89e\8b¿\94»\92è\8bé\8c`\82Ì\91å\82«\82³\8b«\8aE\81i3\97Ì\88æ\81j\r
+  this.kAdjustKakatoStep = 3; // \89e\8b¿\94»\92è\8bé\8c`\82Ì\92i\8aK\r
+       \r
+  this.kAdjustUrokoX = ([24, 20, 16, 12]); // \92²\90®\8dÏ\82Ý\83T\83C\83Y 000,100,200,300\r
+  this.kAdjustUrokoY = ([12, 11, 9, 8]); // \92²\90®\8dÏ\82Ý\83T\83C\83Y 000,100,200,300\r
+  this.kAdjustUrokoLength = ([22, 36, 50]); // \89e\8b¿\94»\92è\92·\82³\82Ì\92i\8aK\r
+  this.kAdjustUrokoLengthStep = 3; // \89e\8b¿\94»\92è\92·\82³\82Ì\92i\8aK\r
+  this.kAdjustUrokoLine = ([22, 26, 30]); // \8cð\8d·\82Ì\89e\8b¿\94»\92è\81BLength\82Æ\91Î\89\9e\r
+       \r
+  this.kBuhin = new Buhin();\r
+  \r
+  return this;\r
+}\r

diff --git a/engine/kagecd.js b/engine/kagecd.js
index aec3dca..a28be90 100755 (executable)
--- a/engine/kagecd.js
+++ b/engine/kagecd.js
@@ -603,7 +603,7 @@ function cdDrawCurve(kage, polygons, x1, y1, x2, y2, x3, y3, a1, a2){
                                deltad = Math.pow(1.0 - t, hosomi);\r
                        }\r
       else{ deltad = 1; }\r
-\r
+      \r
                        if(deltad < 0.15){\r
                                deltad = 0.15;\r
                        }\r
@@ -1099,36 +1099,20 @@ function cdDrawLine(kage, polygons, tx1, ty1, tx2, ty2, ta1, ta2){
         }\r
       }\r
       else{\r
+        //always same\r
         poly = new Polygon(4);\r
-        switch(a1){\r
-        case 0:\r
-          poly.set(0, x1, y1 - kage.kMinWidthY);\r
-          poly.set(3, x1, y1 + kage.kMinWidthY);\r
-          break;\r
-        case 2:\r
-          poly.set(0, x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
-          poly.set(3, x1 - kage.kMinWidthT, y1 + kage.kMinWidthY);\r
-          break;\r
-        }\r
-        \r
-        switch(a2){\r
-        case 0:\r
-          poly.set(1, x2, y2 - kage.kMinWidthY);\r
-          poly.set(2, x2, y2 + kage.kMinWidthY);\r
-          break;\r
-        case 2:\r
-          poly.set(1, x2 + kage.kMinWidthT, y2 - kage.kMinWidthY);\r
-          poly.set(2, x2 + kage.kMinWidthT, y2 + kage.kMinWidthY);\r
-        }\r
-        \r
+        poly.set(0, x1, y1 - kage.kMinWidthY);\r
+        poly.set(1, x2, y2 - kage.kMinWidthY);\r
+        poly.set(2, x2, y2 + kage.kMinWidthY);\r
+        poly.set(3, x1, y1 + kage.kMinWidthY);\r
         polygons.push(poly);\r
         \r
         //UROKO\r
         if(a2 == 0){\r
           poly = new Polygon();\r
           poly.push(x2, y2 - kage.kMinWidthY);\r
-          poly.push(x2 - 24, y2);\r
-          poly.push(x2 - 12, y2 - 12);\r
+          poly.push(x2 - kage.kAdjustUrokoX[opt2], y2);\r
+          poly.push(x2 - kage.kAdjustUrokoX[opt2] / 2, y2 - kage.kAdjustUrokoY[opt2]);\r
           polygons.push(poly);\r
         }\r
       }\r
@@ -1136,40 +1120,20 @@ function cdDrawLine(kage, polygons, tx1, ty1, tx2, ty2, ta1, ta2){
     else{ //for others, use x-axis\r
       rad = Math.atan((y2 - y1) / (x2 - x1));\r
       if((Math.abs(y2 - y1) < Math.abs(x2 - x1)) && (a1 != 6) && (a2 != 6) && !(x1 > x2)){ //ASAI KAUDO\r
+        //always same\r
         poly = new Polygon(4);\r
-        switch(a1){ //must be 0 or 2\r
-        case 0:\r
-          poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthY, y1 - Math.cos(rad) * kage.kMinWidthY);\r
-          poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthY, y1 + Math.cos(rad) * kage.kMinWidthY);\r
-          break;\r
-        case 2:\r
-          poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthY - kage.kMinWidthT * Math.cos(rad),\r
-                   y1 - Math.cos(rad) * kage.kMinWidthY - kage.kMinWidthT * Math.sin(rad));\r
-          poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthY - kage.kMinWidthT * Math.cos(rad),\r
-                   y1 + Math.cos(rad) * kage.kMinWidthY - kage.kMinWidthT * Math.sin(rad));\r
-          break;\r
-        }\r
-        \r
-        switch(a2){ //must be 0 or 2\r
-        case 0:\r
-          poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthY, y2 - Math.cos(rad) * kage.kMinWidthY);\r
-          poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthY, y2 + Math.cos(rad) * kage.kMinWidthY);\r
-          break;\r
-        case 2:\r
-          poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthY + kage.kMinWidthT * Math.cos(rad),\r
-                   y2 - Math.cos(rad) * kage.kMinWidthY + kage.kMinWidthT * Math.sin(rad));\r
-          poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthY + kage.kMinWidthT * Math.cos(rad),\r
-                   y2 + Math.cos(rad) * kage.kMinWidthY + kage.kMinWidthT * Math.sin(rad));\r
-        }\r
-        \r
+        poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthY, y1 - Math.cos(rad) * kage.kMinWidthY);\r
+        poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthY, y2 - Math.cos(rad) * kage.kMinWidthY);\r
+        poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthY, y2 + Math.cos(rad) * kage.kMinWidthY);\r
+        poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthY, y1 + Math.cos(rad) * kage.kMinWidthY);\r
         polygons.push(poly);\r
         \r
         //UROKO\r
         if(a2 == 0){\r
           poly = new Polygon();\r
           poly.push(x2 + Math.sin(rad) * kage.kMinWidthY, y2 - Math.cos(rad) * kage.kMinWidthY);\r
-          poly.push(x2 - Math.cos(rad) * 24, y2 - Math.sin(rad) * 24);\r
-          poly.push(x2 - Math.cos(rad) * 12 + Math.sin(rad) * 12, y2 - Math.sin(rad) * 12 - Math.cos(rad) * 12);\r
+          poly.push(x2 - Math.cos(rad) * kage.kAdjustUrokoX[opt2], y2 - Math.sin(rad) * kage.kAdjustUrokoX[opt2]);\r
+          poly.push(x2 - Math.cos(rad) * kage.kAdjustUrokoX[opt2] / 2 + Math.sin(rad) * kage.kAdjustUrokoX[opt2] / 2, y2 - Math.sin(rad) * kage.kAdjustUrokoY[opt2] - Math.cos(rad) * kage.kAdjustUrokoY[opt2]);\r
           polygons.push(poly);\r
         }\r
       }\r