(gameSurface.getWidth() - (circle.getRadius() * 2))) {
121 | newX = gameSurface.getWidth() - (circle.getRadius() * 2);
122 | }
123 |
124 | // check for the bottom of screen the height newY is greater than height
125 | // minus radius times 2(height of sprite)
126 | double newY = rnd.nextInt((int) gameSurface.getHeight());
127 | if (newY > (gameSurface.getHeight() - (circle.getRadius() * 2))) {
128 | newY = gameSurface.getHeight() - (circle.getRadius() * 2);
129 | }
130 |
131 | circle.setTranslateX(newX);
132 | circle.setTranslateY(newY);
133 | circle.setVisible(true);
134 | circle.setId(b.toString());
135 |
136 | // add to actors in play (sprite objects)
137 | getSpriteManager().addSprites(b);
138 |
139 | // add sprite's
140 | getSceneNodes().getChildren().add(0, b.node);
141 |
142 | }
143 | }
144 |
145 | /**
146 | * Each sprite will update it's velocity and bounce off wall borders.
147 | * @param sprite - An atomic particle (a sphere).
148 | */
149 | @Override
150 | protected void handleUpdate(Sprite sprite) {
151 | if (sprite instanceof Atom) {
152 | Atom sphere = (Atom) sprite;
153 |
154 | // advance the spheres velocity
155 | sphere.update();
156 |
157 | // bounce off the walls when outside of boundaries
158 | if (sphere.node.getTranslateX() > (getGameSurface().getWidth() -
159 | sphere.node.getBoundsInParent().getWidth()) ||
160 | sphere.node.getTranslateX() < 0 ) { sphere.vX = sphere.vX * -1; } if (sphere.node.getTranslateY() > getGameSurface().getHeight()-
161 | sphere.node.getBoundsInParent().getHeight() ||
162 | sphere.node.getTranslateY() < 0) {
163 | sphere.vY = sphere.vY * -1;
164 | }
165 | }
166 | }
167 |
168 | /**
169 | * How to handle the collision of two sprite objects. Stops the particle
170 | * by zeroing out the velocity if a collision occurred.
171 | * @param spriteA
172 | * @param spriteB
173 | * @return
174 | */
175 | @Override
176 | protected boolean handleCollision(Sprite spriteA, Sprite spriteB) {
177 | if (spriteA.collide(spriteB)) {
178 | ((Atom)spriteA).implode(this);
179 | ((Atom)spriteB).implode(this);
180 | getSpriteManager().addSpritesToBeRemoved(spriteA, spriteB);
181 | return true;
182 | }
183 | return false;
184 | }
185 |
186 | /**
187 | * Remove dead things.
188 | */
189 | @Override
190 | protected void cleanupSprites() {
191 | // removes from the scene and backend store
192 | super.cleanupSprites();
193 |
194 | // let user know how many sprites are showing.
195 | NUM_SPRITES_FIELD.setText(String.valueOf(getSpriteManager().getAllSprites().size()));
196 |
197 | }
198 | }
199 |
--------------------------------------------------------------------------------
/jfxgenproj/src/main/java/carlfx/gameengine/GameWorld.java:
--------------------------------------------------------------------------------
1 | package carlfx.gameengine;
2 |
3 | import javafx.animation.Animation;
4 | import javafx.animation.KeyFrame;
5 | import javafx.animation.Timeline;
6 | import javafx.animation.TimelineBuilder;
7 | import javafx.event.ActionEvent;
8 | import javafx.event.EventHandler;
9 | import javafx.scene.Group;
10 | import javafx.scene.Scene;
11 | import javafx.stage.Stage;
12 | import javafx.util.Duration;
13 |
14 | /**
15 | * This application demonstrates a JavaFX 2.x Game Loop.
16 | * Shown below are the methods which comprise of the fundamentals to a
17 | * simple game loop in JavaFX:
18 | *
19 | * initialize() - Initialize the game world.
20 | * beginGameLoop() - Creates a JavaFX Timeline object containing the game life cycle.
21 | * updateSprites() - Updates the sprite objects each period (per frame)
22 | * checkCollisions() - Method will determine objects that collide with each other.
23 | * cleanupSprites() - Any sprite objects needing to be removed from play.
24 | *
25 | *
26 | * @author cdea
27 | */
28 | public abstract class GameWorld {
29 |
30 | /**
31 | * The JavaFX Scene as the game surface
32 | */
33 | private Scene gameSurface;
34 | /**
35 | * All nodes to be displayed in the game window.
36 | */
37 | private Group sceneNodes;
38 | /**
39 | * The game loop using JavaFX's Timeline API.
40 | */
41 | private static Timeline gameLoop;
42 |
43 | /**
44 | * Number of frames per second.
45 | */
46 | private final int framesPerSecond;
47 |
48 | /**
49 | * Title in the application window.
50 | */
51 | private final String windowTitle;
52 |
53 | /**
54 | * The sprite manager.
55 | */
56 | private final SpriteManager spriteManager = new SpriteManager();
57 |
58 | private final SoundManager soundManager = new SoundManager(3);
59 |
60 | /**
61 | * Constructor that is called by the derived class. This will
62 | * set the frames per second, title, and setup the game loop.
63 | *
64 | * @param fps - Frames per second.
65 | * @param title - Title of the application window.
66 | */
67 | public GameWorld(final int fps, final String title) {
68 | framesPerSecond = fps;
69 | windowTitle = title;
70 | // create and set timeline for the game loop
71 | buildAndSetGameLoop();
72 | }
73 |
74 | /**
75 | * Builds and sets the game loop ready to be started.
76 | */
77 | protected final void buildAndSetGameLoop() {
78 |
79 | final Duration oneFrameAmt = Duration.millis(1000 / (float) getFramesPerSecond());
80 | final KeyFrame oneFrame = new KeyFrame(oneFrameAmt,
81 | new EventHandler() {
82 |
83 | @Override
84 | public void handle(javafx.event.ActionEvent event) {
85 |
86 | // update actors
87 | updateSprites();
88 |
89 | // check for collision
90 | checkCollisions();
91 |
92 | // removed dead things
93 | cleanupSprites();
94 |
95 | }
96 | }); // oneFrame
97 |
98 | // sets the game world's game loop (Timeline)
99 | setGameLoop(TimelineBuilder.create()
100 | .cycleCount(Animation.INDEFINITE)
101 | .keyFrames(oneFrame)
102 | .build());
103 | }
104 |
105 | /**
106 | * Initialize the game world by update the JavaFX Stage.
107 | *
108 | * @param primaryStage The main window containing the JavaFX Scene.
109 | */
110 | public abstract void initialize(final Stage primaryStage);
111 |
112 | /**
113 | * Kicks off (plays) the Timeline objects containing one key frame
114 | * that simply runs indefinitely with each frame invoking a method
115 | * to update sprite objects, check for collisions, and cleanup sprite
116 | * objects.
117 | */
118 | public void beginGameLoop() {
119 | getGameLoop().play();
120 | }
121 |
122 | /**
123 | * Updates each game sprite in the game world. This method will
124 | * loop through each sprite and passing it to the handleUpdate()
125 | * method. The derived class should override handleUpdate() method.
126 | */
127 | protected void updateSprites() {
128 | for (Sprite sprite : spriteManager.getAllSprites()) {
129 | handleUpdate(sprite);
130 | }
131 | }
132 |
133 | /**
134 | * Updates the sprite object's information to position on the game surface.
135 | *
136 | * @param sprite - The sprite to update.
137 | */
138 | protected void handleUpdate(Sprite sprite) {
139 | }
140 |
141 | /**
142 | * Checks each game sprite in the game world to determine a collision
143 | * occurred. The method will loop through each sprite and
144 | * passing it to the handleCollision()
145 | * method. The derived class should override handleCollision() method.
146 | */
147 | protected void checkCollisions() {
148 | // check other sprite's collisions
149 | spriteManager.resetCollisionsToCheck();
150 | // check each sprite against other sprite objects.
151 | for (Sprite spriteA : spriteManager.getCollisionsToCheck()) {
152 | for (Sprite spriteB : spriteManager.getAllSprites()) {
153 | if (handleCollision(spriteA, spriteB)) {
154 | // The break helps optimize the collisions
155 | // The break statement means one object only hits another
156 | // object as opposed to one hitting many objects.
157 | // To be more accurate comment out the break statement.
158 | break;
159 | }
160 | }
161 | }
162 | }
163 |
164 | /**
165 | * When two objects collide this method can handle the passed in sprite
166 | * objects. By default it returns false, meaning the objects do not
167 | * collide.
168 | *
169 | * @param spriteA - called from checkCollision() method to be compared.
170 | * @param spriteB - called from checkCollision() method to be compared.
171 | * @return boolean True if the objects collided, otherwise false.
172 | */
173 | protected boolean handleCollision(Sprite spriteA, Sprite spriteB) {
174 | return false;
175 | }
176 |
177 | /**
178 | * Sprites to be cleaned up.
179 | */
180 | protected void cleanupSprites() {
181 | spriteManager.cleanupSprites();
182 | }
183 |
184 | /**
185 | * Returns the frames per second.
186 | *
187 | * @return int The frames per second.
188 | */
189 | protected int getFramesPerSecond() {
190 | return framesPerSecond;
191 | }
192 |
193 | /**
194 | * Returns the game's window title.
195 | *
196 | * @return String The game's window title.
197 | */
198 | public String getWindowTitle() {
199 | return windowTitle;
200 | }
201 |
202 | /**
203 | * The game loop (Timeline) which is used to update, check collisions, and
204 | * cleanup sprite objects at every interval (fps).
205 | *
206 | * @return Timeline An animation running indefinitely representing the game
207 | * loop.
208 | */
209 | protected static Timeline getGameLoop() {
210 | return gameLoop;
211 | }
212 |
213 | /**
214 | * The sets the current game loop for this game world.
215 | *
216 | * @param gameLoop Timeline object of an animation running indefinitely
217 | * representing the game loop.
218 | */
219 | protected static void setGameLoop(Timeline gameLoop) {
220 | GameWorld.gameLoop = gameLoop;
221 | }
222 |
223 | /**
224 | * Returns the sprite manager containing the sprite objects to
225 | * manipulate in the game.
226 | *
227 | * @return SpriteManager The sprite manager.
228 | */
229 | public SpriteManager getSpriteManager() {
230 | return spriteManager;
231 | }
232 |
233 | /**
234 | * Returns the JavaFX Scene. This is called the game surface to
235 | * allow the developer to add JavaFX Node objects onto the Scene.
236 | *
237 | * @return Scene The JavaFX scene graph.
238 | */
239 | public Scene getGameSurface() {
240 | return gameSurface;
241 | }
242 |
243 | /**
244 | * Sets the JavaFX Scene. This is called the game surface to
245 | * allow the developer to add JavaFX Node objects onto the Scene.
246 | *
247 | * @param gameSurface The main game surface (JavaFX Scene).
248 | */
249 | protected void setGameSurface(Scene gameSurface) {
250 | this.gameSurface = gameSurface;
251 | }
252 |
253 | /**
254 | * All JavaFX nodes which are rendered onto the game surface(Scene) is
255 | * a JavaFX Group object.
256 | *
257 | * @return Group The root containing many child nodes to be displayed into
258 | * the Scene area.
259 | */
260 | public Group getSceneNodes() {
261 | return sceneNodes;
262 | }
263 |
264 | /**
265 | * Sets the JavaFX Group that will hold all JavaFX nodes which are rendered
266 | * onto the game surface(Scene) is a JavaFX Group object.
267 | *
268 | * @param sceneNodes The root container having many children nodes
269 | * to be displayed into the Scene area.
270 | */
271 | protected void setSceneNodes(Group sceneNodes) {
272 | this.sceneNodes = sceneNodes;
273 | }
274 |
275 | protected SoundManager getSoundManager() {
276 | return soundManager;
277 | }
278 |
279 | /**
280 | * Stop threads and stop media from playing.
281 | */
282 | public void shutdown() {
283 | getGameLoop().stop();
284 | getSoundManager().shutdown();
285 | }
286 | }
287 |
--------------------------------------------------------------------------------
/demos/navigateship/src/main/java/carlfx/demos/navigateship/TheExpanse.java:
--------------------------------------------------------------------------------
1 | package carlfx.demos.navigateship;
2 |
3 | import carlfx.gameengine.GameWorld;
4 | import carlfx.gameengine.Sprite;
5 | import javafx.event.ActionEvent;
6 | import javafx.event.EventHandler;
7 | import javafx.scene.CacheHint;
8 | import javafx.scene.Group;
9 | import javafx.scene.Node;
10 | import javafx.scene.Scene;
11 | import javafx.scene.control.Button;
12 | import javafx.scene.control.Label;
13 | import javafx.scene.control.TextField;
14 | import javafx.scene.input.KeyCode;
15 | import javafx.scene.input.KeyEvent;
16 | import javafx.scene.input.MouseButton;
17 | import javafx.scene.input.MouseEvent;
18 | import javafx.scene.layout.HBox;
19 | import javafx.scene.layout.VBox;
20 | import javafx.scene.paint.Color;
21 | import javafx.scene.shape.Circle;
22 | import javafx.stage.Stage;
23 |
24 | import java.util.Random;
25 |
26 | /**
27 | * This is a simple game world simulating a bunch of spheres looking
28 | * like atomic particles colliding with each other. When the game loop begins
29 | * the user will notice random spheres (atomic particles) floating and
30 | * colliding. The user will navigate his/her ship by right clicking the mouse to
31 | * trust forward and left click to fire weapon to atoms.
32 | *
33 | * @author cdea
34 | */
35 | public class TheExpanse extends GameWorld {
36 |
37 | // mouse pt label
38 | Label mousePtLabel = new Label();
39 |
40 | // mouse press pt label
41 | Label mousePressPtLabel = new Label();
42 |
43 | TextField xCoordinate = new TextField("234");
44 | TextField yCoordinate = new TextField("200");
45 | Button moveShipButton = new Button("Rotate ship");
46 |
47 | Ship myShip = new Ship();
48 |
49 | public TheExpanse(int fps, String title) {
50 | super(fps, title);
51 | }
52 |
53 | /**
54 | * Initialize the game world by adding sprite objects.
55 | *
56 | * @param primaryStage The game window or primary stage.
57 | */
58 | @Override
59 | public void initialize(final Stage primaryStage) {
60 | // Sets the window title
61 | primaryStage.setTitle(getWindowTitle());
62 | //primaryStage.setFullScreen(true);
63 |
64 | // Create the scene
65 | setSceneNodes(new Group());
66 | setGameSurface(new Scene(getSceneNodes(), 800, 600));
67 | getGameSurface().setFill(Color.BLACK);
68 | primaryStage.setScene(getGameSurface());
69 | // Setup Game input
70 | setupInput(primaryStage);
71 |
72 |
73 | // Create many spheres
74 | generateManySpheres(2);
75 |
76 | // Display the number of spheres visible.
77 | // Create a button to add more spheres.
78 | // Create a button to freeze the game loop.
79 | //final Timeline gameLoop = getGameLoop();
80 | getSpriteManager().addSprites(myShip);
81 | getSceneNodes().getChildren().add(0, myShip.node);
82 |
83 | // mouse point
84 | VBox stats = new VBox();
85 |
86 | HBox row1 = new HBox();
87 | mousePtLabel.setTextFill(Color.WHITE);
88 | row1.getChildren().add(mousePtLabel);
89 | HBox row2 = new HBox();
90 | mousePressPtLabel.setTextFill(Color.WHITE);
91 | row2.getChildren().add(mousePressPtLabel);
92 |
93 | stats.getChildren().add(row1);
94 | stats.getChildren().add(row2);
95 |
96 | // mouse point
97 | HBox enterCoord1 = new HBox();
98 | enterCoord1.getChildren().add(xCoordinate);
99 | enterCoord1.getChildren().add(yCoordinate);
100 | enterCoord1.getChildren().add(moveShipButton);
101 | stats.getChildren().add(enterCoord1);
102 | moveShipButton.setOnAction(new EventHandler() {
103 | @Override
104 | public void handle(ActionEvent actionEvent) {
105 | double x = Double.parseDouble(xCoordinate.getText());
106 | double y = Double.parseDouble(yCoordinate.getText());
107 | myShip.plotCourse(x, y, false);
108 | }
109 | });
110 |
111 | // load sound file
112 | getSoundManager().loadSoundEffects("laser", getClass().getClassLoader().getResource("laser_2.mp3"));
113 |
114 | // ===================================================
115 | // Debugging purposes
116 | // uncomment to test mouse press and rotation angles.
117 | //getSceneNodes().getChildren().add(stats);
118 | }
119 |
120 | /**
121 | * Sets up the mouse input.
122 | *
123 | * @param primaryStage The primary stage (app window).
124 | */
125 | private void setupInput(Stage primaryStage) {
126 | System.out.println("Ship's center is (" + myShip.getCenterX() + ", " + myShip.getCenterY() + ")");
127 |
128 | EventHandler fireOrMove = new EventHandler() {
129 | @Override
130 | public void handle(MouseEvent event) {
131 | mousePressPtLabel.setText("Mouse Press PT = (" + event.getX() + ", " + event.getY() + ")");
132 | if (event.getButton() == MouseButton.PRIMARY) {
133 | // Aim
134 | myShip.plotCourse(event.getX(), event.getY(), false);
135 | // fire
136 | Missile m1 = myShip.fire();
137 | getSpriteManager().addSprites(m1);
138 |
139 | // play sound
140 | getSoundManager().playSound("laser");
141 |
142 | getSceneNodes().getChildren().add(0, m1.node);
143 |
144 |
145 | } else if (event.getButton() == MouseButton.SECONDARY) {
146 | // determine when all atoms are not on the game surface. Ship should be one sprite left.
147 | if (getSpriteManager().getAllSprites().size() <= 1) {
148 | generateManySpheres(30);
149 | }
150 |
151 | // stop ship from moving forward
152 | myShip.applyTheBrakes(event.getX(), event.getY());
153 | // move forward and rotate ship
154 | myShip.plotCourse(event.getX(), event.getY(), true);
155 | }
156 |
157 | }
158 | };
159 |
160 |
161 | // Initialize input
162 | primaryStage.getScene().setOnMousePressed(fireOrMove);
163 | //addEventHandler(MouseEvent.MOUSE_PRESSED, me);
164 |
165 | // set up stats
166 | EventHandler changeWeapons = new EventHandler() {
167 | @Override
168 | public void handle(KeyEvent event) {
169 | if (KeyCode.SPACE == event.getCode()) {
170 | myShip.shieldToggle();
171 | return;
172 | }
173 | myShip.changeWeapon(event.getCode());
174 |
175 | }
176 | };
177 | primaryStage.getScene().setOnKeyPressed(changeWeapons);
178 |
179 |
180 | // set up stats
181 | EventHandler showMouseMove = new EventHandler() {
182 | @Override
183 | public void handle(MouseEvent event) {
184 | mousePtLabel.setText("Mouse PT = (" + event.getX() + ", " + event.getY() + ")");
185 | }
186 | };
187 |
188 | primaryStage.getScene().setOnMouseMoved(showMouseMove);
189 | }
190 |
191 | /**
192 | * Make some more space spheres (Atomic particles)
193 | *
194 | * @param numSpheres The number of random sized, color, and velocity atoms to generate.
195 | */
196 | private void generateManySpheres(int numSpheres) {
197 | Random rnd = new Random();
198 | Scene gameSurface = getGameSurface();
199 | for (int i = 0; i < numSpheres; i++) {
200 | Color c = Color.rgb(rnd.nextInt(255), rnd.nextInt(255), rnd.nextInt(255));
201 | Atom b = new Atom(rnd.nextInt(15) + 5, c, true);
202 | Circle circle = b.getAsCircle();
203 | // random 0 to 2 + (.0 to 1) * random (1 or -1)
204 | b.vX = (rnd.nextInt(2) + rnd.nextDouble()) * (rnd.nextBoolean() ? 1 : -1);
205 | b.vY = (rnd.nextInt(2) + rnd.nextDouble()) * (rnd.nextBoolean() ? 1 : -1);
206 |
207 | // random x between 0 to width of scene
208 | double newX = rnd.nextInt((int) gameSurface.getWidth());
209 |
210 | // check for the right of the width newX is greater than width
211 | // minus radius times 2(width of sprite)
212 | if (newX > (gameSurface.getWidth() - (circle.getRadius() * 2))) {
213 | newX = gameSurface.getWidth() - (circle.getRadius() * 2);
214 | }
215 |
216 | // check for the bottom of screen the height newY is greater than height
217 | // minus radius times 2(height of sprite)
218 | double newY = rnd.nextInt((int) gameSurface.getHeight());
219 | if (newY > (gameSurface.getHeight() - (circle.getRadius() * 2))) {
220 | newY = gameSurface.getHeight() - (circle.getRadius() * 2);
221 | }
222 |
223 | circle.setTranslateX(newX);
224 | circle.setTranslateY(newY);
225 | circle.setVisible(true);
226 | circle.setId(b.toString());
227 | circle.setCache(true);
228 | circle.setCacheHint(CacheHint.SPEED);
229 | circle.setManaged(false);
230 | // add to actors in play (sprite objects)
231 | getSpriteManager().addSprites(b);
232 |
233 | // add sprite's
234 | getSceneNodes().getChildren().add(b.node);
235 |
236 | }
237 | }
238 |
239 | /**
240 | * Each sprite will update it's velocity and bounce off wall borders.
241 | *
242 | * @param sprite - An atomic particle (a sphere).
243 | */
244 | @Override
245 | protected void handleUpdate(Sprite sprite) {
246 | // advance object
247 | sprite.update();
248 | if (sprite instanceof Missile) {
249 | removeMissiles((Missile) sprite);
250 | } else {
251 | bounceOffWalls(sprite);
252 | }
253 | }
254 |
255 | /**
256 | * Change the direction of the moving object when it encounters the walls.
257 | *
258 | * @param sprite The sprite to update based on the wall boundaries.
259 | * TODO The ship has got issues.
260 | */
261 | private void bounceOffWalls(Sprite sprite) {
262 | // bounce off the walls when outside of boundaries
263 |
264 | Node displayNode;
265 | if (sprite instanceof Ship) {
266 | displayNode = sprite.node;//((Ship)sprite).getCurrentShipImage();
267 | } else {
268 | displayNode = sprite.node;
269 | }
270 | // Get the group node's X and Y but use the ImageView to obtain the width.
271 | if (sprite.node.getTranslateX() > (getGameSurface().getWidth() - displayNode.getBoundsInParent().getWidth()) ||
272 | displayNode.getTranslateX() < 0) {
273 |
274 | // bounce the opposite direction
275 | sprite.vX = sprite.vX * -1;
276 |
277 | }
278 | // Get the group node's X and Y but use the ImageView to obtain the height.
279 | if (sprite.node.getTranslateY() > getGameSurface().getHeight() - displayNode.getBoundsInParent().getHeight() ||
280 | sprite.node.getTranslateY() < 0) {
281 | sprite.vY = sprite.vY * -1;
282 | }
283 | }
284 |
285 | /**
286 | * Remove missiles when they reach the wall boundaries.
287 | *
288 | * @param missile The missile to remove based on the wall boundaries.
289 | */
290 | private void removeMissiles(Missile missile) {
291 | // bounce off the walls when outside of boundaries
292 | if (missile.node.getTranslateX() > (getGameSurface().getWidth() -
293 | missile.node.getBoundsInParent().getWidth()) ||
294 | missile.node.getTranslateX() < 0) {
295 |
296 | getSpriteManager().addSpritesToBeRemoved(missile);
297 | getSceneNodes().getChildren().remove(missile.node);
298 |
299 | }
300 | if (missile.node.getTranslateY() > getGameSurface().getHeight() -
301 | missile.node.getBoundsInParent().getHeight() ||
302 | missile.node.getTranslateY() < 0) {
303 |
304 | getSpriteManager().addSpritesToBeRemoved(missile);
305 | getSceneNodes().getChildren().remove(missile.node);
306 | }
307 | }
308 |
309 | /**
310 | * How to handle the collision of two sprite objects. Stops the particle
311 | * by zeroing out the velocity if a collision occurred.
312 | *
313 | * @param spriteA Sprite from the first list.
314 | * @param spriteB Sprite from the second list.
315 | * @return boolean returns a true if the two sprites have collided otherwise false.
316 | */
317 | @Override
318 | protected boolean handleCollision(Sprite spriteA, Sprite spriteB) {
319 | if (spriteA != spriteB) {
320 | if (spriteA.collide(spriteB)) {
321 |
322 | if (spriteA != myShip) {
323 | spriteA.handleDeath(this);
324 | }
325 | if (spriteB != myShip) {
326 | spriteB.handleDeath(this);
327 | }
328 | }
329 | }
330 |
331 | return false;
332 | }
333 |
334 | }
335 |
--------------------------------------------------------------------------------
/demos/navigateship/src/main/java/carlfx/demos/navigateship/Ship.java:
--------------------------------------------------------------------------------
1 | package carlfx.demos.navigateship;
2 |
3 | import carlfx.gameengine.Sprite;
4 | import javafx.animation.*;
5 | import javafx.event.ActionEvent;
6 | import javafx.event.EventHandler;
7 | import javafx.scene.CacheHint;
8 | import javafx.scene.Group;
9 | import javafx.scene.Node;
10 | import javafx.scene.image.Image;
11 | import javafx.scene.input.KeyCode;
12 | import javafx.scene.paint.Color;
13 | import javafx.scene.shape.Circle;
14 | import javafx.scene.shape.CircleBuilder;
15 | import javafx.util.Duration;
16 |
17 | import java.util.ArrayList;
18 | import java.util.List;
19 |
20 | /**
21 | * A space ship with 32 directions
22 | * When two atoms collide each will fade and become removed from the scene. The
23 | * method called implode() implements a fade transition effect.
24 | *
25 | * @author cdea
26 | */
27 | public class Ship extends Sprite {
28 |
29 | /**
30 | * 360 degree turn
31 | */
32 | private final static int TWO_PI_DEGREES = 360;
33 |
34 | /**
35 | * Number of ship frames and directions the ship is pointing nose
36 | */
37 | private final static int NUM_DIRECTIONS = 32;
38 |
39 | /**
40 | * The angle of one direction (adjacent directions) (11.25 degrees)
41 | */
42 | private final static float UNIT_ANGLE_PER_FRAME = ((float) TWO_PI_DEGREES / NUM_DIRECTIONS);
43 |
44 | /**
45 | * Amount of time it takes the ship to move 180 degrees in milliseconds.
46 | */
47 | private final static int MILLIS_TURN_SHIP_180_DEGREES = 300;
48 |
49 | /**
50 | * When the ship turns on each direction one amount of time for one frame or turn of the ship. (18.75 milliseconds)
51 | */
52 | private final static float MILLIS_PER_FRAME = (float) MILLIS_TURN_SHIP_180_DEGREES / (NUM_DIRECTIONS / 2);
53 |
54 | /**
55 | * All possible turn directions Clockwise, Counter Clockwise, or Neither when the user clicks mouse around ship
56 | */
57 | private enum DIRECTION {
58 | CLOCKWISE, COUNTER_CLOCKWISE, NEITHER
59 | }
60 |
61 | /**
62 | * Velocity amount used vector when ship moves forward. scale vector of ship. See flipBook translateX and Y.
63 | */
64 | private final static float THRUST_AMOUNT = 4.3f;
65 |
66 | /***/
67 | private final static float MISSILE_THRUST_AMOUNT = 6.3F;
68 |
69 | /**
70 | * Angle in degrees to rotate ship.
71 | */
72 |
73 |
74 | /**
75 | * Current turning direction. default is NEITHER. Clockwise and Counter Clockwise.
76 | */
77 | private DIRECTION turnDirection = DIRECTION.NEITHER;
78 |
79 | /**
80 | * The current starting position of the vector or coordinate where the nose of the ship is pointing towards.
81 | */
82 | private Vec u; // current or start vector
83 |
84 | /**
85 | * All ImageViews of all the possible image frames for each direction the ship is pointing. ie: 32 directions.
86 | */
87 | private final List directionalShips = new ArrayList<>();
88 |
89 | /**
90 | * The Timeline instance to animate the ship rotating using images. This is an optical illusion similar to page
91 | * flipping as each frame is displayed the previous visible attribute is set to false. No rotation is happening.
92 | */
93 | private Timeline rotateShipTimeline;
94 |
95 | /**
96 | * The current index into the list of ImageViews representing each direction of the ship. Zero is the ship
97 | * pointing to the right or zero degrees.
98 | */
99 | private int uIndex = 0;
100 |
101 | /**
102 | * The end index into the list of ImageViews representing each direction of the ship. Zero is the ship
103 | * pointing to the right or zero degrees.
104 | */
105 | private int vIndex = 0;
106 |
107 | /**
108 | * The spot where the user has right clicked letting the engine check the ship's center is in this area.
109 | */
110 | private final Circle stopArea = new Circle();
111 |
112 | /**
113 | * A group contain all of the ship image view nodes.
114 | */
115 | private final Group flipBook = new Group();
116 |
117 | /**
118 | * A key code will be used for weapon selection.
119 | */
120 | private KeyCode keyCode;
121 |
122 | /**
123 | * Turn shields on
124 | */
125 | private boolean shieldOn;
126 |
127 | /**
128 | * Green shield to be used as collision bounds.
129 | */
130 | private Circle shield;
131 |
132 | /**
133 | * A fade effect while the shields are up momentarily
134 | */
135 | FadeTransition shieldFade;
136 |
137 | /**
138 | * The collision bounding region for the ship
139 | */
140 | private Circle hitBounds;
141 |
142 | public Ship() {
143 |
144 | // Load one image.
145 | Image shipImage;
146 | shipImage = new Image(getClass().getClassLoader().getResource("ship.png").toExternalForm(), true);
147 | stopArea.setRadius(40);
148 | stopArea.setStroke(Color.ORANGE);
149 | RotatedShipImage prev = null;
150 | // create all the number of directions based on a unit angle. 360 divided by NUM_DIRECTIONS
151 | for (int i = 0; i < NUM_DIRECTIONS; i++) {
152 | RotatedShipImage imageView = new RotatedShipImage();
153 | imageView.setImage(shipImage);
154 | imageView.setRotate(-1 * i * UNIT_ANGLE_PER_FRAME);
155 | imageView.setCache(true);
156 | imageView.setCacheHint(CacheHint.SPEED);
157 | imageView.setManaged(false);
158 |
159 | imageView.prev = prev;
160 | imageView.setVisible(false);
161 | directionalShips.add(imageView);
162 | if (prev != null) {
163 | prev.next = imageView;
164 | }
165 | prev = imageView;
166 | flipBook.getChildren().add(imageView);
167 | }
168 |
169 | RotatedShipImage firstShip = directionalShips.get(0);
170 | firstShip.prev = prev;
171 | prev.next = firstShip;
172 | // set javafx node to an image
173 | firstShip.setVisible(true);
174 | node = flipBook;
175 | flipBook.setTranslateX(200);
176 | flipBook.setTranslateY(300);
177 | flipBook.setCache(true);
178 | flipBook.setCacheHint(CacheHint.SPEED);
179 | flipBook.setManaged(false);
180 | flipBook.setAutoSizeChildren(false);
181 | initHitZone();
182 |
183 | }
184 |
185 | /**
186 | * Initialize the collision region for the space ship.
187 | * It's just a inscribed circle.
188 | */
189 | public void initHitZone() {
190 | // build hit zone
191 | if (hitBounds == null) {
192 | //RotatedShipImage firstShip = directionalShips.get(0);
193 | double hZoneCenterX = 55;
194 | double hZoneCenterY = 34;
195 | hitBounds = CircleBuilder.create()
196 | .centerX(hZoneCenterX)
197 | .centerY(hZoneCenterY)
198 | .stroke(Color.PINK)
199 | .fill(Color.RED)
200 | .radius(15)
201 | .opacity(0)
202 | .build();
203 | flipBook.getChildren().add(hitBounds);
204 | collisionBounds = hitBounds;
205 | }
206 |
207 | }
208 |
209 | /**
210 | * Change the velocity of the atom particle.
211 | */
212 | @Override
213 | public void update() {
214 | flipBook.setTranslateX(flipBook.getTranslateX() + vX);
215 | flipBook.setTranslateY(flipBook.getTranslateY() + vY);
216 |
217 | if (stopArea.contains(getCenterX(), getCenterY())) {
218 | vX = 0;
219 | vY = 0;
220 | }
221 |
222 | }
223 |
224 |
225 | private RotatedShipImage getCurrentShipImage() {
226 | return directionalShips.get(uIndex);
227 | }
228 |
229 | /**
230 | * The center X coordinate of the current visible image. See getCurrentShipImage() method.
231 | *
232 | * @return The scene or screen X coordinate.
233 | */
234 | public double getCenterX() {
235 | RotatedShipImage shipImage = getCurrentShipImage();
236 | return node.getTranslateX() + (shipImage.getBoundsInLocal().getWidth() / 2);
237 | }
238 |
239 | /**
240 | * The center Y coordinate of the current visible image. See getCurrentShipImage() method.
241 | *
242 | * @return The scene or screen Y coordinate.
243 | */
244 | public double getCenterY() {
245 | RotatedShipImage shipImage = getCurrentShipImage();
246 | return node.getTranslateY() + (shipImage.getBoundsInLocal().getHeight() / 2);
247 | }
248 |
249 | /**
250 | * Determines the angle between it's starting position and ending position (Similar to a clock's second hand).
251 | * When the user is shooting the ship nose will point in the direction of the mouse press using the primary button.
252 | * When the user is thrusting to a location on the screen the right click mouse will pass true to the thrust
253 | * parameter.
254 | *
255 | * @param screenX The mouse press' screen x coordinate.
256 | * @param screenY The mouse press' screen ycoordinate.
257 | * @param thrust Thrust ship forward or not. True move forward otherwise false.
258 | */
259 | public void plotCourse(double screenX, double screenY, boolean thrust) {
260 | // get center of ship
261 | double sx = getCenterX();
262 | double sy = getCenterY();
263 |
264 | // get user's new turn position based on mouse click
265 | Vec v = new Vec(screenX, screenY, sx, sy);
266 | if (u == null) {
267 | u = new Vec(1, 0);
268 | }
269 |
270 |
271 | double atan2RadiansU = Math.atan2(u.y, u.x);
272 | double atan2DegreesU = Math.toDegrees(atan2RadiansU);
273 |
274 | double atan2RadiansV = Math.atan2(v.y, v.x);
275 | double atan2DegreesV = Math.toDegrees(atan2RadiansV);
276 |
277 | double angleBetweenUAndV = atan2DegreesV - atan2DegreesU;
278 |
279 |
280 | // if abs value is greater than 180 move counter clockwise
281 | //(or opposite of what is determined)
282 | double absAngleBetweenUAndV = Math.abs(angleBetweenUAndV);
283 | boolean goOtherWay = false;
284 | if (absAngleBetweenUAndV > 180) {
285 | if (angleBetweenUAndV < 0) {
286 | turnDirection = DIRECTION.COUNTER_CLOCKWISE;
287 | goOtherWay = true;
288 | } else if (angleBetweenUAndV > 0) {
289 | turnDirection = DIRECTION.CLOCKWISE;
290 | goOtherWay = true;
291 | } else {
292 | turnDirection = Ship.DIRECTION.NEITHER;
293 | }
294 | } else {
295 | if (angleBetweenUAndV < 0) {
296 | turnDirection = Ship.DIRECTION.CLOCKWISE;
297 | } else if (angleBetweenUAndV > 0) {
298 | turnDirection = Ship.DIRECTION.COUNTER_CLOCKWISE;
299 | } else {
300 | turnDirection = Ship.DIRECTION.NEITHER;
301 | }
302 | }
303 |
304 | double degreesToMove = absAngleBetweenUAndV;
305 | if (goOtherWay) {
306 | degreesToMove = TWO_PI_DEGREES - absAngleBetweenUAndV;
307 | }
308 |
309 | //int q = v.quadrant();
310 |
311 | uIndex = Math.round((float) (atan2DegreesU / UNIT_ANGLE_PER_FRAME));
312 | if (uIndex < 0) {
313 | uIndex = NUM_DIRECTIONS + uIndex;
314 | }
315 | vIndex = Math.round((float) (atan2DegreesV / UNIT_ANGLE_PER_FRAME));
316 | if (vIndex < 0) {
317 | vIndex = NUM_DIRECTIONS + vIndex;
318 | }
319 | String debugMsg = turnDirection +
320 | " U [m(" + u.mx + ", " + u.my + ") => c(" + u.x + ", " + u.y + ")] " +
321 | " V [m(" + v.mx + ", " + v.my + ") => c(" + v.x + ", " + v.y + ")] " +
322 | " start angle: " + atan2DegreesU +
323 | " end angle:" + atan2DegreesV +
324 | " Angle between: " + degreesToMove +
325 | " Start index: " + uIndex +
326 | " End index: " + vIndex;
327 |
328 | System.out.println(debugMsg);
329 |
330 | if (thrust) {
331 | vX = Math.cos(atan2RadiansV) * THRUST_AMOUNT;
332 | vY = -Math.sin(atan2RadiansV) * THRUST_AMOUNT;
333 | }
334 | turnShip();
335 |
336 | u = v;
337 | }
338 |
339 | private void turnShip() {
340 |
341 | final Duration oneFrameAmt = Duration.millis(MILLIS_PER_FRAME);
342 | RotatedShipImage startImage = directionalShips.get(uIndex);
343 | RotatedShipImage endImage = directionalShips.get(vIndex);
344 | List frames = new ArrayList<>();
345 |
346 | RotatedShipImage currImage = startImage;
347 |
348 | int i = 1;
349 | while (true) {
350 |
351 | final Node displayNode = currImage;
352 |
353 | KeyFrame oneFrame = new KeyFrame(oneFrameAmt.multiply(i),
354 | new EventHandler() {
355 |
356 | @Override
357 | public void handle(javafx.event.ActionEvent event) {
358 | // make all ship images invisible
359 | for (RotatedShipImage shipImg : directionalShips) {
360 | shipImg.setVisible(false);
361 | }
362 | // make current ship image visible
363 | displayNode.setVisible(true);
364 |
365 | // update the current index
366 | //uIndex = directionalShips.indexOf(displayNode);
367 | }
368 | }); // oneFrame
369 |
370 | frames.add(oneFrame);
371 |
372 | if (currImage == endImage) {
373 | break;
374 | }
375 | if (turnDirection == DIRECTION.CLOCKWISE) {
376 | currImage = currImage.prev;
377 | }
378 | if (turnDirection == DIRECTION.COUNTER_CLOCKWISE) {
379 | currImage = currImage.next;
380 | }
381 | i++;
382 | }
383 |
384 |
385 | if (rotateShipTimeline != null) {
386 | rotateShipTimeline.stop();
387 | rotateShipTimeline.getKeyFrames().clear();
388 | rotateShipTimeline.getKeyFrames().addAll(frames);
389 | } else {
390 | // sets the game world's game loop (Timeline)
391 | rotateShipTimeline = TimelineBuilder.create()
392 | .keyFrames(frames)
393 | .build();
394 |
395 | }
396 |
397 | rotateShipTimeline.playFromStart();
398 |
399 |
400 | }
401 |
402 | /**
403 | * Stops the ship from thrusting forward.
404 | *
405 | * @param screenX the screen's X coordinate to stop the ship.
406 | * @param screenY the screen's Y coordinate to stop the ship.
407 | */
408 | public void applyTheBrakes(double screenX, double screenY) {
409 | stopArea.setCenterX(screenX);
410 | stopArea.setCenterY(screenY);
411 | }
412 |
413 | public Missile fire() {
414 | Missile m1;
415 |
416 | float slowDownAmt = 0;
417 | int scaleBeginningMissle;
418 | if (KeyCode.DIGIT2 == keyCode) {
419 | m1 = new Missile(9, Color.BLUE);
420 | slowDownAmt = 1.3f;
421 | scaleBeginningMissle = 11;
422 | } else {
423 | m1 = new Missile(Color.RED);
424 | scaleBeginningMissle = 8;
425 | }
426 | // velocity vector of the missile
427 | m1.vX = Math.cos(Math.toRadians(uIndex * UNIT_ANGLE_PER_FRAME)) * (MISSILE_THRUST_AMOUNT - slowDownAmt);
428 | m1.vY = -Math.sin(Math.toRadians(uIndex * UNIT_ANGLE_PER_FRAME)) * (MISSILE_THRUST_AMOUNT - slowDownAmt);
429 |
430 | // make the missile launch in the direction of the current direction of the ship nose. based on the
431 | // current frame (uIndex) into the list of image view nodes.
432 | RotatedShipImage shipImage = directionalShips.get(uIndex);
433 |
434 | // start to appear in the center of the ship to come out the direction of the nose of the ship.
435 | double offsetX = (shipImage.getBoundsInLocal().getWidth() - m1.node.getBoundsInLocal().getWidth()) / 2;
436 | double offsetY = (shipImage.getBoundsInLocal().getHeight() - m1.node.getBoundsInLocal().getHeight()) / 2;
437 |
438 | // initial launch of the missile (multiply vector by 4 makes it appear at the nose of the ship)
439 | m1.node.setTranslateX(node.getTranslateX() + (offsetX + (m1.vX * scaleBeginningMissle)));
440 | m1.node.setTranslateY(node.getTranslateY() + (offsetY + (m1.vY * scaleBeginningMissle)));
441 | return m1;
442 | }
443 |
444 | public void changeWeapon(KeyCode keyCode) {
445 | this.keyCode = keyCode;
446 | }
447 |
448 | public void shieldToggle() {
449 |
450 |
451 | if (shield == null) {
452 | RotatedShipImage shipImage = getCurrentShipImage();
453 | double x = shipImage.getBoundsInLocal().getWidth() / 2;
454 | double y = shipImage.getBoundsInLocal().getHeight() / 2;
455 |
456 | // add shield
457 | shield = CircleBuilder.create()
458 | .radius(60)
459 | .strokeWidth(5)
460 | .stroke(Color.LIMEGREEN)
461 | .centerX(x)
462 | .centerY(y)
463 | .opacity(.70)
464 | .build();
465 | collisionBounds = shield;
466 | shieldFade = FadeTransitionBuilder.create()
467 | .fromValue(1)
468 | .toValue(.40)
469 | .duration(Duration.millis(1000))
470 | .cycleCount(12)
471 | .autoReverse(true)
472 | .node(shield)
473 | .onFinished(new EventHandler() {
474 | @Override
475 | public void handle(ActionEvent actionEvent) {
476 | shieldOn = false;
477 | flipBook.getChildren().remove(shield);
478 | shieldFade.stop();
479 | collisionBounds = hitBounds;
480 | }
481 | })
482 | .build();
483 | shieldFade.playFromStart();
484 |
485 | }
486 | shieldOn = !shieldOn;
487 | if (shieldOn) {
488 | collisionBounds = shield;
489 | flipBook.getChildren().add(0, shield);
490 | shieldFade.playFromStart();
491 | } else {
492 | flipBook.getChildren().remove(shield);
493 | shieldFade.stop();
494 | collisionBounds = hitBounds;
495 |
496 | }
497 |
498 |
499 | }
500 |
501 | }
502 |
--------------------------------------------------------------------------------