AndroidTutorial_FeedYourWorms/WormController.pde at master · TeslyukTaras/AndroidTutorial_FeedYourWorms · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
float VELOCITY = 140;
int CORNER_CHECK_COEF = 2;
int WALL_CHECK_COEF = 1;

class WormController {
  int worldSizeX = 0;
  int worldSizeY = 0;

  void setWorldSize(int x, int y) {
    this.worldSizeX = x;
    this.worldSizeY = y;
  }

  void moveWorms(Worm[] worms, float millis) {
    for (int i = 0; i < worms.length; i++) {
      dragWorm(worms[i], millis);
    }
  }

  void calculateIntersections(Worm[] worms, ArrayList<Food> foods) {
    for (int i = 0; i < worms.length; i++) {
      Worm worm = worms[i];

      for (int j = 0; j < foods.size(); j++) {
        Food food = foods.get(j);
        float distance = sqrt((worm.sx[0] - food.x) * (worm.sx[0] - food.x) +
          (worm.sy[0] - food.y) * (worm.sy[0] - food.y));
        if (distance < food.radius) {
          println("Consume food!");
          food.consume();
          worm.addSegment();
        }
      }
    }
  }

  private void dragWorm(Worm worm, float millis) {
    float timeFrame = millis / 1000;
    float angle = getRightAngle(worm) + getAngleShift(worm, timeFrame);

    float distance = timeFrame * VELOCITY;
    float nextX = worm.sx[0] + cos(angle) * distance;
    float nextY = worm.sy[0] + sin(angle) * distance;
    worm.drag(nextX, nextY);
  }

  float getAngleShift(Worm worm, float timeFrame) {
     float angleShift = PI * sin(worm.initialPeriod +
      ( (float) millis() / worm.wavePeriod)) * timeFrame;
      return angleShift;
  }

  float getRightAngle(Worm worm) {
    float dx = worm.sx[0] - worm.sx[1];
    float dy = worm.sy[0] - worm.sy[1];

    if (isInCorner(worm)) {
      if (worm.preferedCornerRotation == CORNER_ROTATION_UNDEFINED) {
        boolean isDxBigger = abs(dx) > abs(dy);
        if (isDxBigger) {
          worm.preferedCornerRotation = CORNER_ROTATION_OY;
        } else {
          worm.preferedCornerRotation = CORNER_ROTATION_OX;
        }
      }
      if (worm.preferedCornerRotation == CORNER_ROTATION_OY) {
        dx = 0.01;//move OY
        if (isTopWall(worm, CORNER_CHECK_COEF)) {
          dy = 1; //DOWN
        } else {
          dy = -1; //UP
        }
      } else {
        dy = 0.01;//move OX
        if (isLeftWall(worm, CORNER_CHECK_COEF)) {
          dx = 1; //RIGHT
        } else {
          dx = -1;//LEFT
        }
      }
    } else {
      worm.preferedCornerRotation = CORNER_ROTATION_UNDEFINED;
      if (isLeftWall(worm, WALL_CHECK_COEF)) {
        dx = 0.01;//move OY
      } else if (isRightWall(worm, WALL_CHECK_COEF)) {
        dx = -0.01; //move OY
      }
      if (isTopWall(worm, WALL_CHECK_COEF)) {
        dy = 0.01; //move OX
      } else if (isBottomWall(worm, WALL_CHECK_COEF)) {
        dy = -0.01; //move OX
      }
    }

    return atan2(dy, dx);
  }

  private boolean isInCorner(Worm worm) {
    int closeWalls = 0;

    if (isLeftWall(worm, CORNER_CHECK_COEF)) {
      closeWalls++;
    } else if (isRightWall(worm, CORNER_CHECK_COEF)) {
      closeWalls++;
    }
    if (isTopWall(worm, CORNER_CHECK_COEF)) {
      closeWalls++;
    } else if (isBottomWall(worm, CORNER_CHECK_COEF)) {
      closeWalls++;
    }

    return closeWalls == 2;
  }

  private boolean isLeftWall(Worm worm, int coef) {
    return worm.sx[0] < coef* STROKE_WIDTH;
  }

  private boolean isRightWall(Worm worm, int coef) {
    return worm.sx[0] > worldSizeX - coef * STROKE_WIDTH;
  }

  private boolean isTopWall(Worm worm, int coef) {
    return worm.sy[0] < coef*STROKE_WIDTH;
  }

  private boolean isBottomWall(Worm worm, int coef) {
    return worm.sy[0] > worldSizeY - coef*STROKE_WIDTH;
  }
}