castleinfinity.java

good project for programmer,,

    //make the polygons
    int outRadius = 60;
    int inRadius = 40;
    Polygon[] parts = new Polygon[4];
    double angle = 0;
    for(int index = 0; index < 4; index += 1) {
      int[] xpoints = new int[6];
      int[] ypoints = new int[6];
      for(int i = 0; i < 6; i += 1) {
        xpoints[i] = (int)(c.x + castleRadii[i]*Math.cos(angle + castleAngles[i]));
        ypoints[i] = (int)(c.y + castleRadii[i]*Math.sin(angle + castleAngles[i]));
      }
      parts[index] = new Polygon(xpoints, ypoints, 6);
      angle += Math.PI/2;
    }

    castles[castleIndex] = parts;

    removeHexagon(p);

    //find the hexagons the castle now borders
    Polygon[] surroundingHexagons = new Polygon[6];
    for(int i = 0; i < 6; i += 1) {
      Polygon nearest = null;
      Point guessedCenter = new Point((int)(c.x + hexRad*Math.sqrt(3)*Math.cos(i*Math.PI/3)),
                                      (int)(c.y + hexRad*Math.sqrt(3)*Math.sin(i*Math.PI/3)));
      double shortestGap = 10000;
      Integer index = null;
      for(int j = 0; j < countryPolygons.size(); j += 1) {
        Polygon thePolygon = (Polygon)countryPolygons.get(j);
        Point center = polygonCenter(thePolygon);
        double gap = dist(guessedCenter, center);
        if(gap < shortestGap) {
          shortestGap = gap;
          nearest = thePolygon;
        }
      }
      surroundingHexagons[i] = nearest;

    }

    //adjust the shapes of the hexagons the castle intrudes onto
    Rectangle castleBounds = new Rectangle(c.x - cOR, c.y - cOR, cOR*2, cOR*2);
    Polygon hex;
    hex = surroundingHexagons[0];
    for(int i = 0; i < hex.npoints; i += 1) {
      if(castleBounds.contains(hex.xpoints[i], hex.ypoints[i]) && hex.ypoints[i] > c.y) {
        hex.xpoints[i] = c.x + cOR;
        hex.ypoints[i] = (int)(c.y + cOR*Math.tan(Math.PI/6));
      } else if(castleBounds.contains(hex.xpoints[i], hex.ypoints[i]) && hex.ypoints[i] < c.y) {
        hex.xpoints[i] = c.x + cOR;
        hex.ypoints[i] = (int)(c.y - cOR*Math.tan(Math.PI/6));
      }
    }

    hex = surroundingHexagons[3];
    for(int i = 0; i < hex.npoints; i += 1) {
      if(castleBounds.contains(hex.xpoints[i], hex.ypoints[i]) && hex.ypoints[i] > c.y) {
        hex.xpoints[i] = c.x - cOR;
        hex.ypoints[i] = (int)(c.y + cOR*Math.tan(Math.PI/6));
      } else if(castleBounds.contains(hex.xpoints[i], hex.ypoints[i]) && hex.ypoints[i] < c.y) {
        hex.xpoints[i] = c.x - cOR;
        hex.ypoints[i] = (int)(c.y - cOR*Math.tan(Math.PI/6));
      }
    }

    Point c1 = polygonCenter(surroundingHexagons[1]);
    surroundingHexagons[1].xpoints = new int[7];
    surroundingHexagons[1].ypoints = new int[7];
    surroundingHexagons[1].xpoints[0] = c.x + cOR;
    surroundingHexagons[1].ypoints[0] = (int)(c.y + cOR*Math.tan(Math.PI/6));
    surroundingHexagons[1].xpoints[1] = c.x + cOR;
    surroundingHexagons[1].ypoints[1] = c.y + cOR;
    surroundingHexagons[1].xpoints[2] = c.x;
    surroundingHexagons[1].ypoints[2] = c.y + cOR;
    surroundingHexagons[1].xpoints[3] = c.x;
    surroundingHexagons[1].ypoints[3] = (int)(c1.y + hexRad/2);
    surroundingHexagons[1].xpoints[4] = c1.x;
    surroundingHexagons[1].ypoints[4] = (int)(c1.y + hexRad);
    surroundingHexagons[1].xpoints[5] = (int)(c1.x + Math.sqrt(3)/2*hexRad);
    surroundingHexagons[1].ypoints[5] = (int)(c1.y + hexRad/2);
    surroundingHexagons[1].xpoints[6] = (int)(c1.x + Math.sqrt(3)/2*hexRad);
    surroundingHexagons[1].ypoints[6] = (int)(c1.y - hexRad/2);
    surroundingHexagons[1].npoints = 7;

    surroundingHexagons[2].xpoints = new int[7];
    surroundingHexagons[2].ypoints = new int[7];
    surroundingHexagons[4].xpoints = new int[7];
    surroundingHexagons[4].ypoints = new int[7];
    surroundingHexagons[5].xpoints = new int[7];
    surroundingHexagons[5].ypoints = new int[7];
    surroundingHexagons[2].npoints = 7;
    surroundingHexagons[4].npoints = 7;
    surroundingHexagons[5].npoints = 7;
    for(int i = 0; i < 7; i += 1) {
      surroundingHexagons[2].xpoints[i] = c.x + -(surroundingHexagons[1].xpoints[i]-c.x);
      surroundingHexagons[2].ypoints[i] = surroundingHexagons[1].ypoints[i];
      surroundingHexagons[4].xpoints[i] = surroundingHexagons[2].xpoints[i];
      surroundingHexagons[4].ypoints[i] = c.y + -(surroundingHexagons[1].ypoints[i]-c.y);
      surroundingHexagons[5].xpoints[i] = surroundingHexagons[1].xpoints[i];
      surroundingHexagons[5].ypoints[i] = surroundingHexagons[4].ypoints[i];
    }

    //create the conections from castle to hexagons
    castleConnections[castleIndex][0] = new Vector();
    castleConnections[castleIndex][0].add(castles[castleIndex][1]);
    castleConnections[castleIndex][0].add(castles[castleIndex][3]);
    castleConnections[castleIndex][0].add(surroundingHexagons[0]);
    castleConnections[castleIndex][0].add(surroundingHexagons[1]);
    castleConnections[castleIndex][1] = new Vector();
    castleConnections[castleIndex][1].add(castles[castleIndex][0]);
    castleConnections[castleIndex][1].add(castles[castleIndex][2]);
    castleConnections[castleIndex][1].add(surroundingHexagons[2]);
    castleConnections[castleIndex][1].add(surroundingHexagons[3]);
    castleConnections[castleIndex][2] = new Vector();
    castleConnections[castleIndex][2].add(castles[castleIndex][1]);
    castleConnections[castleIndex][2].add(castles[castleIndex][3]);
    castleConnections[castleIndex][2].add(surroundingHexagons[3]);
    castleConnections[castleIndex][2].add(surroundingHexagons[4]);
    castleConnections[castleIndex][3] = new Vector();
    castleConnections[castleIndex][3].add(castles[castleIndex][2]);
    castleConnections[castleIndex][3].add(castles[castleIndex][0]);
    castleConnections[castleIndex][3].add(surroundingHexagons[5]);
    castleConnections[castleIndex][3].add(surroundingHexagons[0]);
    //create the connections from hexagons to castle
    for(int i = 0; i < 4; i += 1) {
      for(int j = 0; j < castleConnections[castleIndex][i].size(); j += 1) {
        int hexIndex = countryPolygons.indexOf(castleConnections[castleIndex][i].get(j));
        if(hexIndex != -1) ((Vector)connections.get(hexIndex)).add(castles[castleIndex][i]);
      }
    }
  }




  //create borders between the countryside continents. each countryside continent
  //consists of all hexagons closer to a given castle than any other. borders between
  //continents should consist of choke points in the forms of penalty bridges or land
  //bridges
  private void makeCountrysideBorders() {
    //countrySideConnectionType[i][j] = 
    //   0 - castles i and j are not connected
    //   1 - castles i and j are connected by a land bridge
    //   2 - castles i and j are connected by a penalty bridge
    int[][] countrysideConnectionType = new int[numCastles][numCastles];

    //borders[i][j] consists of the countries on the border between i and j
    Vector[][] borders = new Vector[numCastles][numCastles];
    for(int i = 0; i < numCastles; i += 1) {
      for(int j = 0; j < numCastles; j += 1) {
        countrysideConnectionType[i][j] = 0; //no connections
        borders[i][j] = new Vector();
      }
    }

    //the points at the center of each castle
    Point[] castlePoints = new Point[numCastles];
    for(int i = 0; i < numCastles; i += 1) {
      castlePoints[i] = polygonCenter(castleCenters[i]);
    }

    //now, for each country, determine if it is on the border between its two
    //closest castles. pick connection types for continents that border each other
    loop:
    for(int i = 0; i < countryPolygons.size(); i += 1) {
      Point closestCastle = null;
      Point secondClosest = null;
      int closestIndex = -1;
      int secondClosestIndex = -1;
      double closestDist = 10000;
      double secondClosestDist = 10000;
      for(int j = 0; j < numCastles; j += 1) {
        double dist = dist(castlePoints[j], polygonCenter((Polygon)countryPolygons.get(i)));
        if(dist < secondClosestDist) {
          if(dist < closestDist) {
            secondClosest = closestCastle;
            secondClosestDist = closestDist;
            secondClosestIndex = closestIndex;
            closestCastle = castlePoints[j];
            closestDist = dist;
            closestIndex = j;
          } else {
            secondClosest = castlePoints[j];
            secondClosestDist = dist;
            secondClosestIndex = j;
          }
        }
      }

      if(secondClosest == null) continue loop;

      Point midpoint = midpoint(closestCastle, secondClosest);
      double lineAngle = (Math.atan2(closestCastle.y - secondClosest.y ,
                            closestCastle.x - secondClosest.x) + Math.PI/2+6*Math.PI)%(2*Math.PI);
      Point endpoint1 = new Point((int)(midpoint.x + -1000*Math.cos(lineAngle)),
                                  (int)(midpoint.y + -1000*Math.sin(lineAngle)));
      Point endpoint2 = new Point((int)(midpoint.x +  1000*Math.cos(lineAngle)),
                                  (int)(midpoint.y +  1000*Math.sin(lineAngle)));
      Line2D.Double perpBisector = new Line2D.Double(endpoint1, endpoint2);

      Rectangle r = dilatePolygon((Polygon)countryPolygons.get(i), 33.0/31).getBounds();
      if(!perpBisector.intersects(r)) {
        continue loop; //not part of a border
      }

      int connType = countrysideConnectionType[closestIndex][secondClosestIndex];
      if(connType == 0) {
        connType = 1+rand.nextInt(2);
        countrysideConnectionType[secondClosestIndex][closestIndex] = connType;
        countrysideConnectionType[closestIndex][secondClosestIndex] = connType;
      }
      borders[closestIndex][secondClosestIndex].add((Polygon)countryPolygons.get(i));
      borders[secondClosestIndex][closestIndex].add((Polygon)countryPolygons.get(i));
    }

    //now, for land bridge connections remove all countries on the border except an isthmus
    //remove all border countries for penalty bridge connections
    for(int i = 0; i < numCastles; i += 1) {
      for(int j = i+1; j < numCastles; j += 1) {
        if(countrysideConnectionType[i][j] == 1) { //land bridge
          //keep is whether we keep or remove a given hexagon:
          boolean[] keep = new boolean[borders[i][j].size()];
          for(int k = 0; k < keep.length; k += 1) {
            keep[k] = false;
          }
          loop:
          for(int k = 0; k < 1; k += 1) {
            int bridgeSeed = rand.nextInt(borders[i][j].size());
            keep[bridgeSeed] = true;
            //don't retain a polygon already removed by another connection:
            if(!countryPolygons.contains(borders[i][j].get(bridgeSeed))) {
              k -= 1;
              continue loop;
            }

            //keep a hexagon and all those that touch it
            Vector conns = (Vector)connections.get(countryPolygons.indexOf(borders[i][j].get(bridgeSeed)));
            for(int l = 0; l < conns.size(); l += 1) {
              int index =  borders[i][j].indexOf((Polygon)conns.get(l));
              if(index != -1) keep[index] = true;
            }
          }

          for(int k = 0; k < borders[i][j].size(); k += 1) {
            if(!keep[k]) removeHexagon((Polygon)borders[i][j].get(k));
          }
        } else if(countrysideConnectionType[i][j] == 2) { //penalty bridge, remove everything
          for(int k = 0; k < borders[i][j].size(); k += 1) {
            removeHexagon((Polygon)borders[i][j].get(k));
          }
        }
      }

    }

    //make bridges. the bridge's location is initial the midpoint of the castles it connects
    //then we choose the two hexagons a bridge at that point would connect to, and move the 
    //bridge center to their midpoint. repeat to get a well-placed bridge. then make it
    for(int i = 0; i < numCastles; i += 1) {
      for(int j = i + 1; j < numCastles; j += 1) {
        if(countrysideConnectionType[i][j] == 2) {

          Point bridgeCenter = midpoint(castlePoints[i], castlePoints[j]);

          int closestToI = -1, closestToJ = -1;
          int iDist = 10000;
          int jDist = 10000;
          for(int iter = 0; iter < 5; iter += 1) {

            for(int k = 0; k < countryPolygons.size(); k += 1) {
              int closestCastle = closestCastle((Polygon)countryPolygons.get(k));

              int bDist = (int)dist(bridgeCenter, polygonCenter((Polygon)countryPolygons.get(k)));
              if(closestCastle == i && bDist < iDist) {
                iDist = bDist;
                closestToI = k;
              }
              if(closestCastle == j && bDist < jDist) {
                jDist = bDist;
               closestToJ = k;
              }
            }
            bridgeCenter = midpoint(polygonCenter((Polygon)countryPolygons.get(closestToI)),
                                    polygonCenter((Polygon)countryPolygons.get(closestToJ)));
          }
          makeBridgeBetween((Polygon)countryPolygons.get(closestToI),
                            (Polygon)countryPolygons.get(closestToJ));
        }
      }
    }

    //remove any isolated hexagons or hexagons in the wrong continent
    for(int i = 0; i < countryPolygons.size(); i += 1) {
      Vector conns = (Vector)connections.get(i);
      boolean hasNeighborInContinent = false;
      int iClosestCastle = closestCastle((Polygon)countryPolygons.get(i));
      for(int j = 0; j < conns.size(); j += 1) {
        if(countryPolygons.contains(conns.get(j)) &&
           iClosestCastle == closestCastle((Polygon)conns.get(j))) {
          hasNeighborInContinent = true;
        }
      }