James Weaver on Quantum Computing and Java

Special Effects in JavaFX: A book by Lucas Jordan

Georges Méliès (December 8, 1861 – January 21, 1938), full name Marie-Georges-Jean Méliès, was a French filmmaker famous for leading many technical and narrative developments in the earliest cinema. He was very innovative in the use of special effects. He accidentally discovered the stop trick, or substitution, in 1896, and was one of the first filmmakers to use multiple exposures, time-lapse photography, dissolves, and hand-painted color in his films. Because of his ability to seemingly manipulate and transform reality with the cinematography, Méliès is sometimes referred to as the "Cinemagician."

If you'd like to take a deep dive into the animation, effects, and gaming capabilities of JavaFX, you'll be interested to know that Lucas Jordan has written a book to help you do just that.  It's called JavaFX Special Effects: Taking Java™ RIA to the Extreme with Animation, Multimedia, and Game Elements, and is published by Apress.  I met Lucas at JavaOne 2009 where he and I participated in a JavaFX panel session, and I asked him today to give us a little back-story on the book.  Here's his response:

"I have always been interested in client side technologies and Java. So naturally I was interested AWT and Swing. But I was also interested in graphics beyond just buttons and text fields. Quite a few years ago I found a project from the University of Maryland, Human-Computer Interaction Lab (HCIL) called Piccolo and its predecessor Jazz. These where graphics toolkits that provided a way to describe a scene graph and render it with Java's Graphics 2D. I managed to find a few uses for Piccolo in my day job and was really pleased with the results.

When I heard about JavaFX my first thought was "Why bother, there is already a library for this". Of course this was before I really understood that JavaFX was also a new language and runtime, not just a Java graphics library. I managed to get put a project where I was creating a demo app for the JavaFX launch in the Fall of 2008. This was my first chance to really put in 8 hours a day on a JavaFX application and I quickly learned that JavaFX is an extremely productive language. You can get graphics on the screen wired up as components in no time, really amazing.

At the time I was working on my first JavaFX project, I was also finishing my first iPhone app. So by day I was working with JavaFX and then I would go home and work with cocoa and Objective-C. Let me tell you, Core Graphics feels like you're building a house without power tools compared to JavaFX. The same is true of Piccolo as well, both Java and Objective-C just require a lot more junk to express things that are very simple in JavaFX.

Come June of 2009 I was heading to JavaOne to present the nuts and bolts of the app I had built for the JavaFX launch. The app basically showed off a hand full of graphics effects, so I had a working knowledge of JavaFX and its classes by this point. It was here I met Jim Weaver, and he had just finished a book on JavaFX in time for JavaOne and was extolling the virtues of JavaFX. Jim kindly put me in contact with the people he worked with at Apress and they got in touch with me some time after JavaOne.

Apress basically came to me as said "what do you want to write about?" and I didn't really have an answer at first. It seemed like the core books where already written and JavaFX was only 50 some classes at that point. I knew I had done some interesting things with JavaFX in the last year, so we settled on writing a book explaining the cool stuff I got JavaFX to do. And that is basically what this book is, with each chapter taking a single concept or effect and showing how to implement it in JavaFX. We look at physics, particles, lighting effects and bunch of other stuff. The last few chapters take some of the ideas and combine them. I think my favorite chapter combines physics with particles to create some convincing fire balls. The very last chapter is a description of an entire game. This brings all the lessons together and talks about some of the real world issues of putting an app together.

Anyway, I hope people find it interesting. I think it is a pretty good collection of samples showing what JavaFX can do when you move past the point of drawing Rectangles and figuring out the new syntax." -Lucas Jordan

The picture above is a screen shot of the game to which Lucas referred, in which you shoot clowns out of a cannon into the vat of hydrochloric acid on the right side of the page.  It's really water, but just wanted to see if you're still reading this. ;-)  Tell you what, be the first commenter on this post, mentioning the acid thing, and I'll twist Mr. Jordan's arm to give you a free JavaFX Special Effects e-book.

Thanks and congratulations on your book, Lucas!

Jim Weaver

Win atom and bit-based Pro JavaFX books at Øredev 2009 RIA session Fri 3:35pm CET

Readers of this blog know that I like to hold contests to make things fun and encourage participation (e.g. see the 2000 USD JavaFXpert RIA Exemplar Challenge that ends 10 January, 2010).  In keeping with that sentiment, some JavaFX questions relevant to my presentation will be tweeted by @projavafxcourse to the twitterverse during the Øredev 2009 RIA Enterprise Application Developing with JavaFX session.

The seven people that earn the highest scores by tweeting fast, correct, answers to these questions will each win a copy of the Pro JavaFX book.  Six of these books will be composed of bits (e-books), and one will be composed of atoms.  The atom-based book is reserved for the person with the highest score of those present in the audience, but the e-books will be awarded (via an emailed Apress coupon) to the winners regardless on their location during the session.  This session starts on Friday,  November 6 at 3:35pm CET, lasting until 4:25pm, so please have your Twitter client ready.  When you tweet an answer, be sure to reply to the original tweet with your answer. 

On a technical note, all correct answers consist of one word or character, and the software that checks for a correct answer trims the spaces from the end of the reply and then uses the string found between the final space and the end of the reply.  So, if you want to put other words in your reply, presumably to give your followers a clue about what your terse message is, just make sure that your answer is at the end of your response.  For example, you might reply to the question:

The name of the layout class that arranges UI nodes horizontally is ____

with this message:

Answering a JavaFXpert presentation question with HBox

If you want to use an application that I'm developing for the purpose of responding to these questions, please make sure that you have a recent version (update 14 or later) of Java SE 6 and click the LearnFX icon over on the left. 

When the application starts up, the most recent question is displayed as shown in the screenshot below.  If the question is still active (i.e. the answer has not been revealed), then the text box will be enabled, allowing you to enter an answer and click the Send button or press the Enter key.  Responses that have been received appear as well, along with the the Twitter profile image, screen name, and indication of whether the question is correct (if the answer has been revealed -- if not, a question mark will be displayed).

  

The first time that you run the application, you'll need to click the configuration icon to open the configuration dialog shown below, in which you can enter your Twitter screen name and password, as well as some preferences.  This information is stored on your local machine, and automatically loaded on subsequent invocations of the application.

Until the contest begins, there is a sample question available if you wish to give this application a try before the real questions begin appearing.  By the way, when you use the LearnFX client, your tweet is a reply to the projavafxcourse user, and the message contains the following with the question ID, and answer that you supply, added to the end:

@projavafxcourse Answering JavaFXpert question http://bit.ly/2dn1kK

The bit.ly link in the message may be clicked by your followers to see what your strange tweet is about :-)

There is a WidgetFX version of this application in the works that I'll release and blog about in a subsequent post.  By the way, I'd like to publicly thank Steven Herod for the Twitter API this application uses, which he donated to the open source JFXtras project.

Regards, and good luck!  Please leave a comment if you have any questions,

Jim Weaver

I Wish... Henry Zhang would make a WidgetFX widget from his JavaFX Pac-Man game

Update 24 May, 2009: Stephen Chin raises the stakes with the following comment:

"That is a quite a challenge Jim laid on you, Henry. I will up the ante with a promise to display your widget on the big stage as part of the WidgetFX JavaOne presentation if you get it done in time.  There is a good tutorial on how to build widgets from my blog.

Update 25 May, 2009: Henry Zhang picks up the gauntlet with the following comment:

"I think it is a creative idea to put a game as a widget. I will take on the challenge and hopefully the widget can be demonstrated in JavaOne. Only a week or so to go. Will let you know the progress by blogging here:
http://www.javafxgame.com"

Update 26 May, 2009:

Henry finishes the Pac-Man widget.  Check it out at javafxgame.com.  Also, just a friendly reminder to reserve the JavaOne Pro JavaFX™ Platform: RIA Enterprise Application Development with JavaFX Technology session that Stephen Chin and I will be presenting.  As of May 29, 2009 there are only 96 seats available.

Dear Henry Zhang,

Please attend Stephen Chin and Josh Marinacci's Getting Started with WidgetFX session at JavaOne (or watch the video stream), and tweak your JavaFX Pac-Man game to run as a WidgetFX widget.  It would be cool to drag Pac-Man from the WidgetFX dock and devour dots for stress relief :-)

P.S. Congratulations on article #2 in your five part Pac-Man series being published on InsideRIA.  It was a pleasure to help (albeit in small ways) with that series.

Regards,
Jim Weaver

Answer: Blinky, Pinky, Inky and Clyde

The answer is: Blinky, Pinky, Inky and Clyde.  Please phrase your response in the form of a question.

If you said "What are the ghosts' nicknames in American Pac-Man", congratulations!  See the table below (from the Wikipedia Pac-Man article) for more stats on these ghosts:

Announcing Henry Zhang's five-part series on creating the Pac-Man game in JavaFX

For each of the next five weeks Henry Zhang will show you in great detail how he created a Pac-Man game in JavaFX.  He has written a series of articles for InsideRIA that build on each other, with each article having a JavaFX program that you can execute.  There are also Web Start links in the articles so that you can run the programs directly from the web page.  Here's an example screenshot from the first article:

Henry's articles are an excellent resource for increasing your JavaFX skills in the context of building a fun video game, so check them out!

Regards,

JIm Weaver

Creating a UFP (Ultimate Fighting Pigs) Game using JavaFX Production Suite :-)

At least it looks like a fighting game, with buttons labeled Kick and Punch.  Upon closer inspection, we find that it's a JavaFX version of the classic Pigs dice game, co-created by a JavaFX developer and a graphics designer.

Graphics designer Jonathan Wei used Adobe Illustrator to create the artwork.  The JavaFX Production Suite was employed to make it very easy for developer Jim Connell to use that artwork from JavaFX.  To help you learn this process, Jim has created an excellent tutorial that shows you how this game was created, walking through the [small amount of] JavaFX code contained in the program.

Regarding the Kick and Punch buttons:  They don't seem to be operable, and I suspect that they reflect the aforementioned guys' twisted sense of humor :-)

Thanks for this excellent resource, Jonathan and Jim!

Regards,

Jim Weaver
JavaFXpert.com (Learn JavaFX blog)

Table of Contents for the Pro JavaFX Platform early access eBook

Several people have asked for a table of contents for the Pro JavaFX Platform early access eBook (by Weaver, Gao, Chin, and Iverson) to give them a better idea of what's inside.  Because the table of contents isn't on the Apress site yet, I'm posting it here.  Apress and Amazon aren't likely to post the fully expanded table of contents anyway. 

I've sprinkled in a few screenshots to give you a flavor for some of the example programs:

CHAPTER 1: Getting a Jump Start in JavaFX

• JavaFX Can’t Bring Rich-Client Java Back by Itself
• A Brief History of JavaFX
• Going to the Source – Sun’s JavaFX Websites
  • Accessing the JavaFX SDK API and Language Documentation
  • Obtaining the JavaFX SDK
  • JavaFX Production Suite
  • Other Available Tools
• Developing Your First JavaFX Program: "Hello Earthrise"
  • Compiling and Running from the Command-Line
  • Understanding the Hello Earthrise Program
    • Comments
    • The package Declaration
    • import Statements
    • Declarative Code That Defines the User Interface
    • Using the Stage Class
    • Creating String Literals
    • Using the Scene Class
    • Displaying Images
    • Working with Graphical Nodes as a Group
    • Drawing Text
    • Clipping Graphical Areas
    • Animating the Text to Make it Scroll Up
  • Building and Running the Program with NetBeans
• Deploying JavaFX Applications
  • Deploying JavaFX Applications with Java Web Start
  • Deploying JavaFX Applets
• Developing Your Second JavaFX Program: "More Cowbell!"
  • Building and Running the Audio Configuration Program
  • The Behavior of the Audio Configuration Program
  • Understanding the Audio Configuration Program
    • Creating an Instance of the Model, and the Magic of Binding
    • Colors and Gradients
    • The Model Class for the Audio Configuration Example
    • Structure of a Minimal JavaFX class
    • Defining Triggers in the Model Class
• Surveying JavaFX Features
• Summary
• Resources

CHAPTER 2: Taking a Closer Look at the JavaFX Script Language

• An Overview of JavaFX Script
• Understanding Variables, Values, and Their Types
  • Understanding Variable Names
  • Understanding Variable Types
• Understanding the Primitive Types
  • Understanding the Boolean Type
    • Boolean Literals and Default Value
    • Boolean Operators
    • The Backing Class of Boolean Type
  • Understanding the Integer Type
    • Integer Literals and Default Value
    • Arithmetic Operators
    • The Backing Class of Integer Type
  • Understanding the Number Type
    • Number Literals and Default Value
    • Arithmetic Operations
    • The Backing Class of Number Type
  • Understanding the String Type
    • String Literals and Default Value
    • String Expressions
    • The Backing Class of String Type
  • Understanding the Duration Type
    • Duration Literals and Default Value
    • Arithmetic Operations Involving Durations
    • The Backing Class of Duration Type
• Working with Sequences
  • Understanding Sequence Types
  • Constructing Sequences Using Explicit Sequence Expressions
  • Constructing Numeric Sequences Using Range Expressions
  • Manipulating Sequences
    • Accessing the Size of a Sequence
    • Accessing an Element in a Sequence
    • Accessing a Slice of a Sequence
    • Accessing a Subset of a Sequence through a Predicate
    • Reversing a Sequence
    • Inserting an Element into a Sequence
    • Inserting another Sequence into a Sequence
    • Deleting Elements from a Sequence
    • A Sequence Manipulation Example
  • Understanding Sequence Comprehension
  • Using Utility Functions in javafx.util.Sequences
• JavaFX Script is an Expression Language
  • Understanding Expressions and their Types
  • Understanding the Block Expression
  • Understanding Precedence and Groupings
  • Understanding the Expression Separator
  • Understanding Variable and Constant Declarations
  • Understanding the Assignment Operator
  • Understanding the Compound Assignment Operators
  • Understanding the Relational Operators
  • Understanding the while Expression
  • Revisiting the for Expression
  • Understanding the if Expression
• Understanding Object Literals
  • Understanding Classes and Objects
  • The Object Literal Expression
    • Initializing Instance variables
    • Declaring Constants and Variables
    • Overriding Instance functions and Instance variables
  • Manipulating Objects
    • Manipulating Object States
    • Invoking Instance functions
  • Creating Java Objects with the new Operator
  • The Making of a Declarative Syntax
• Working With Data Bindings
  • Understanding the bind Expression
    • What Does the Data Binding Remember?
    • Binding to if Expressions
    • Binding to for Expressions
    • Binding to a Block
    • Binding to Function Invocation Expressions
    • Binding to Object Literal Expressions
  • Understanding Bidirectional Bindings
• Summary

CHAPTER 3: Creating a User Interface in JavaFX

• Introduction to Node-Centric UIs
• Setting the Stage
  • Understanding the Stage Class
    • Consulting the API Docs for the Stage Class
  • Using the Stage Class: The StageCoach Example
  • Understanding the StageCoach Program
    • Obtaining Program Arguments
    • Setting the Style of the Stage
    • Controlling Whether a Stage is Resizable
    • Making a Stage Full Screen
    • Working with the Bounds of the Stage
    • Drawing Rounded Rectangles
    • Dragging the Stage on the Desktop when a Title Bar isn’t Available
    • Using UI Layout Containers
    • Ascertaining Whether the Stage is in Focus
    • Controlling Z-Order of the Stage
    • Closing the Stage and Detecting when it is Closed
    • Exiting the application
• Making a Scene
  • Using the Scene Class: The OnTheScene Example
  • Understanding the OnTheScene Program
    • Setting the Cursor for the Scene
    • Painting the Scene's Background
    • Populating the Scene with Nodes
    • Finding a Scene Node by ID
    • Accessing the Stage from the Scene
    • Inserting a Node into the Scene's content Sequence
    • CSS Styling the Nodes in a Scene
    • Understanding the JavaFX Node Class Hierarchy
• Handling Input Events
  • Surveying Mouse and Keyboard Events and Handlers
    • Understanding the KeyEvent Class
    • Understanding the MouseEvent Class
  • Using Mouse and Key Events: The MobileEqualizer Example
  • Understanding the MobileEqualizer Program
    • Understanding the Model used in this Program
    • Using the onMousePressed Event Handler
    • Using the onMouseDragged Event Handler
    • Giving Keyboard Input Focus to a Node
    • Using the onKeyPressed Event Handler
• Animating Nodes in the Scene
  • Using a Timeline for Animation
    • The Metronome1 Example
    • Understanding the Metronome1 Program
      • Understanding the Timeline Class
      • Inserting Key-Frames into the Timeline
      • Controlling and Monitoring the Timeline
      • Shorthand Syntax for Key-Frames
  • Using the Transition Classes for Animation
    • The MetronomeTransition Example
    • The Behavior of the MetronomeTransition Program
    • Understanding the MetronomeTransition Program
      • Using the TranslateTransition Class
      • Controlling and Monitoring the Transition
      • The MetronomePathTransition Example
    • The Behavior of the MetronomePathTransition Program
    • Understanding the MetronomePathTransition Program
      • Using the PathTransition Class
      • Drawing an Ellipse
  • The Zen of Node Collision Detection
    • Understanding the ZenPong Program
      • Using the KeyFrame action Event Handler
      • Using the Node intersects() Function to Detect Collisions
      • Dragging a Node
  • Summary
  • Resources

CHAPTER 4: Using Functions, Classes and Other Advanced Features

• Working with Functions
  • Understanding Function Definitions
    • Understanding Return Types
    • Understanding Parameters and their Types
    • Understanding Function Bodies and the return Expression
    • What Can a Function Body See?
  • Understanding Overloaded Functions
    • Understanding Implicit Type Conversions
    • Rules for Overloaded Function Resolution
  • Understanding Function Types and Anonymous Functions
    • More Details on Function Type Specifiers
    • More Details on Anonymous Function Expressions
    • More Details on Closures
  • Understanding Bound Functions
  • Understanding Exceptions
    • Understanding the Call Stack
    • Throwing Exceptions
    • Handling Exceptions
• Working with Classes
  • Understanding Class Definitions
    • Understanding Instance Variables
    • Understanding Instance Functions
    • Understanding the this Expression
    • Understanding Initialization Blocks
  • Creating Class Hierarchies
    • Extending Classes
    • Overriding Instance Variables
    • Overriding Instance Functions
    • Understanding the super Keyword
    • Understanding Abstract Classes
    • Understanding Casting and the instanceof and as Operators
• Organizing JavaFX Script Code
  • What is a Script?
  • Understanding Modules
  • A Special Provision for Classes
  • Understanding Packages
  • Understanding Import Directives
  • Understanding Access Modifiers
    • Understanding the protected Modifier
    • Understanding the public-init and public-read Modifiers
• Understanding Triggers
  • Accessing the Old and New Values in Trigger Blocks
  • Accessing Sequence Modification Information in Trigger Blocks
  • Debugging With Triggers
• Understanding String Formatting and Internationalization
  • Using String Format Specifications
  • Internationalizing JavaFX Script Programs
• Leveraging Java from JavaFX Script
  • Instantiating Java Classes
  • Accessing Java Object Fields
  • Calling Java Methods
  • Accessing Static Fields and Methods
  • Quoting JavaFX Script Keywords
  • Accessing Nested Classes
  • Accessing Java Enums
  • Extending Java Classes and Interfaces
  • Iterating Through Java Collections
• Understanding JavaFX Script Reflection
  • Understanding Mirror-Based Reflection
  • Entering the Reflection World
  • Programming through Reflection
    • Creating a New Instance of a Class
    • Getting and Setting Values of Instance and Script variables
    • Invoking Instance and Script Functions
    • Other Reflection Capabilities
• Summary

 

CHAPTER 5: Creating Custom UI Components in JavaFX

• Creating Custom UI Components
  • Creating a Custom Node
    • The ColorPickerNode Example
    • Understanding the ColorPickerNode Custom Node
      • Overriding the CustomNode create() Function
      • Using the Node hover Variable
    • The ColorPickerSnowFlakeNode Example
    • Understanding ColorPickerSnowFlakeNode
      • Making a Node Act like a Dialog
      • Defining and Invoking an Event Handler
      • Overriding Instance Variables
      • The DropShadow Effect
      • Obtaining the width and height of a Node
      • Creating a Polygon Shape
      • Using the stroke and strokeWidth Variables
      • Using the transforms Variable to Transform Nodes
      • Blocking Mouse Events from Underlying Nodes
  • Creating Skinnable UI Controls
    • The StoplightSkinning Example
    • Understanding the StoplightSkinning Program
      • Creating the Control's Model
      • Using the hover, pressed, focused and Variables in the Model
      • Associating a Skin with the Model
      • Creating a Skin for the Control
      • Binding the Skin to the Model
      • Using the hover, pressed, focused and Variables in the Skin
      • The Code for the Horizontal Stoplight Skin
      • Associating a Skin with the Model using a Stylesheet
    • Deciding Between Creating a Custom Node and a UI Control
• Summary
• Exercise: Putting Chapters 1 – 5 Concepts in Practice
• Resources

CHAPTER 6: Using the Media Classes

• The Foundation
• Working With Media
• Playing Audio
  • Controlling Playback
  • Repetition
  • Volume and Balance
  • Streaming Media
• Playing Video
  • Controlling the Size of a MediaView
  • Transforming a MediaView
  • Compositing And Effects
  • One Player, Multiple Views
  • Playing Movies with SimpleMediaPlayer
• Summary

CHAPTER 7: Dynamically Laying Out Nodes in the User Interface

• Introducing JavaFX Reversi
  • Board Layout and Basic Rules
  • Building a JavaFX Model for Reversi
• Dynamic Layout Basics
  • Bind For Layouts
  • Centering Nodes and Text
  • Aligning to Edges
  • Aligning Nodes to Each Other
  • Using HBox and VBox
  • When to Use Bind Versus Boxes
• Creating Resizable Nodes
  • Building a Reversi Square
  • Building a Reversi Piece
• Creating a Grid Layout Container
  • Understanding the Geometry API
  • Extending the Container Class
  • The Grid Layout Algorithm
  • Binding the Layout to the Model
• A New Perspective on Reversi
  • The Perspective Layout Algorithm
  • Creating the Perspective Layout Class
  • Integrating the Perspective Layout
• Bringing Reversi to Life
  • Highlighting Legal Moves
  • Perspective Mouse Interaction
  • Highlighting the Active Cell
  • Taking Turns
  • Additional Game Enhancements
• Summary
• Resources

Chapter 8: Extending JavaFX with Third-Party Libraries

• Creating Desktop Widgets with WidgetFX
  • Creating a Movie Widget
  • Widget Configuration
  • Deploying Widgets to the Web
  • Third-Party Widgets
    • Disk Space Widget
    • World Clock Widget
    • World Smiley Widget
  • The Future of WidgetFX
• Building a Media Explorer with JFXtras
  • Laying out a Resizable Directory Navigator
  • Building a User Interface with Constraints
  • Displaying Media in a Dynamic Grid
  • Wrapping Media with Borders in a Deck
  • Creating an Asynchronous Search Form with MigLayout
    • Laying out the Search Form with MigLayout
    • Adding Asynchronous Search with the JFXWorker
    • Refining the Search With Filters
• The Rest of JFXtras
  • JFXtras Test
    • Nesting Test Cases
    • Fluent Expectations
    • Parameterized Testing
      • Using Assume to Calculator Output
    • Unit Testing the Media Search with Custom Expectations
  • Extended Shapes
  • The Future of JFXtras
• Other Libraries
  • Atomic Tile - 2D Tile-based Game Authoring
  • FXUtil - Inverse Kinetics Library
  • FEST-JavaFX - Automated UI Testing of JavaFX
• Predicting what will be in future versions of JavaFX
• Summary
• References

CHAPTER 9: Building a Professional JavaFX Application

• Writing RESTful Web Service Clients
  • Rise of the RESTful Web
  • Using The HttpRequest Class
  • Writing JSON Clients
    • Parsing JSON in JavaFX
    • Who is My Representative?
  • Writing XML Clients
    • Parsing XML in JavaFX
    • Who is My Representative in XML
• Developing a Rich Internet Application
  • Making Use of Assets with the Production Suite
  • Using the Amazon Web Service API
  • User Interface Considerations
    • Inside the NodeFactory
  • The Home Page
    • A Java-Based Image Cache
    • Getting the Top Sellers from Amazon
  • The Search Page
    • Adding Item Search to the Application Model
  • The Cart Page
• Summary
• Resources

 Chapter 10: Developing JavaFX Mobile Applications

• The Vision of JavaFX Mobile
• Mobile Hello Earthrise
  • Running in the Mobile Emulator
  • Fitting Applications on the Mobile Screen
• Developing for the Common Profile
• Mobile DrawJFX
  • Creating a Mobile Color Picker
  • Refactoring DrawJavaFX for Mobile Devices
• Advanced Mobile Features
  • Performance Tuning JavaFX Mobile Applications
• Summary
• References

We end where we began, with the Hello Earthrise program, this time running in JavaFX Mobile.

Regards,
Jim Weaver

Facebook User? Check out the JavaFX Picture Puzzle

A JavaFX "Picture Puzzle" app that is integrated with Facebook is featured In a blog post by Sharon Zakhour.  Not only is it graphically pleasing and smooth operating (wasn't that a song performed by Sade?), but it "lives" in Facebook, and makes jigsaw puzzles out of your Facebook friends' profile pictures.  It uses the Facebook API, and it was developed by Sun.

 

By the way, if anyone knows whether the source code is available, please post a comment, as it would be a great learning example.

Check this JavaFX Facebook app out and puzzle all of your friends! :-)  That was lame, but it's Friday.

Regards,
Jim Weaver
JavaFXpert.com

Henry Zhang Just Raised the Bar for JavaFX Games

While checking my email today (jim.weaver [at] javafxpert.com), I received a request for feedback from Henry Zhang on a game that he had written in JavaFX.  My feedback, Henry, is that your Pac-Man game ROCKS!

According to Henry's blog post where you can play the game, this Pac-Man game is developed with JavaFX SDK 1.0, and demonstrates the following features:

• Binding
• Animations
• Effects
• Transforms
• Multiple inheritance
• Java classes integration
• Declarative statements
• Sequences, how to map 2D arrays into a 1D Sequence
• Handling keyboard events

Check it out, and please give Henry some feedback!

Regards,
Jim Weaver
JavaFXpert.com

JavaFX Whack-a-Janssen Game for Devoxx :-)

This year I had to miss Devoxx 2008, but really wanted to go. Not only is it a great conference, but this year it is the first major conference since the JavaFX SDK 1.0 was released, so there are some great JavaFX sessions and speakers on the agenda.

 

So, in honor of the Devoxx conference and the excellent leadership that Stephan Janssen provides to it, I've created a game in JavaFX.  I'm not a game programmer nor am I a graphic designer, and I didn't enlist the help of either for this quick effort.  With those disclaimers, and the hope that Stephan Janssen will take this in good-natured fun, I give you: "Whack-A-Janssen", styled loosely after the old "Whac-a-Mole" game.

Click on the Launch icon to run it as a Java Web Start application.  To play the game, simply click the Start Game button and then click on Stephan's faces when they pop up.  While the game is in progress the Start Game button changes to Stop Game.  If all three faces appear, the game is over and the Start Game button reappears.

The Code Behind the Game

This game makes use of the transition convenience classes in the javafx.animation.transition package to achieve animated movement, scaling and fading.  It also uses the Timeline and KeyFrame classes in the javafx.animation package to popup the many faces of Stephen:

/*
 * WhackAJanssen.fx
 *
 * Developed 2008 by James L. Weaver (jim.weaver at javafxpert.com)
 * to demonstrate creating applications using JavaFX SDK 1.0, and for
 * having some good-natured fun with Stephan Janssen of Devoxx.
 */

package javafxpert;

import javafx.animation.*;
import javafx.animation.transition.*;
import javafx.ext.swing.*;
import javafx.scene.*;
import javafx.scene.effect.*;
import javafx.scene.image.*;
import javafx.scene.input.*;
import javafx.scene.paint.*;
import javafx.scene.shape.*;
import javafx.scene.text.*;
import javafx.scene.transform.*;
import javafx.stage.Stage;
import java.lang.Math;

Stage {
  // Transitions for popups
  var popupRefs:Transition[] = [
    ScaleTransition {
      node: bind stephen1Ref
      duration: 1s
      fromX: 0.1
      fromY: 0.1
      toX: 1.0
      toY: 1.0
    },
    TranslateTransition {
      node: bind stephen2Ref
      duration: 1s
      fromY: 0
      byY: -70
      //autoReverse: true
    },
    FadeTransition {
      node: bind stephen3Ref
      duration: 1s
      fromValue: 0.0
      toValue: 1.0
      //autoReverse: true
   }
  ];
  // Transitions for knock-downs
  var knockdownRefs:Transition[] = [
    ScaleTransition {
      node: bind stephen1Ref
      duration: 500ms
      fromX: 1.0
      fromY: 1.0
      toX: 0.1
      toY: 0.1
    },
    TranslateTransition {
      node: bind stephen2Ref
      duration: 500ms
      fromY: -70
      byY: 70
      //autoReverse: true
    },
    FadeTransition {
      node: bind stephen3Ref
      duration: 500ms
      fromValue: 1.0
      toValue: 0.0
      //autoReverse: true
   }
  ];
  var stephen1Ref:ImageView;
  var stephen2Ref:ImageView;
  var stephen3Ref:ImageView;
  // Timeline that causes random Stephens to popup
  var gameTimeline = Timeline {
    keyFrames: [
      KeyFrame {
        time: 2s
        action: function():Void {
          var stephenNum:Integer =
            (Math.random() * sizeof stephensDown) as Integer;
          if (stephensDown[stephenNum]) {
            stephensDown[stephenNum] = false;
            popupRefs[stephenNum].playFromStart();
          }
        }
      }
    ]
    repeatCount: Timeline.INDEFINITE
  }
  // Position that the stephens are in. The trigger evaluates whether
  // the game is over and stops the game Timeline
  var stephensDown:Boolean[] = [true, true, true] on replace {
    var downs = for (stephen in stephensDown where stephen == true) stephen;
    if (sizeof downs == 0) {
      gameTimeline.stop();
    }
  };
  title: "Whack-A-Janssen"
  scene: Scene {
    var btn:SwingButton;
    width: 300
    height: 350
    fill: Color.#010101
    content: [
      ImageView {
        transforms: Translate.translate(24, 56)
        image: Image {
          url: "{__DIR__}images/devoxx250.jpg"
        }
      },
      // Left-most face
      stephen1Ref = ImageView {
        transforms: [
          Translate.translate(63, 99),
        ]
        opacity: 1.0
        image: Image {
          url: "{__DIR__}images/sj_face_small.gif"
        }
        cursor: Cursor.HAND
        onMouseClicked: function(me:MouseEvent):Void {
          stephensDown[0] = true;
          knockdownRefs[0].playFromStart();
        }
      },
      // Middle face
      Group {
        transforms: Translate.translate(120, 20)
        content: [
          Group {
            content: [
              stephen2Ref = ImageView {
                transforms: Translate.translate(0, 90)
                image: Image {
                  url: "{__DIR__}images/sj_head_small.gif"
                }
              },
            ]
            clip: Group {
              content: [
                Polygon {
                  points: [
                   0, 0,
                   0, 46
                   15, 80
                   51, 80,
                   66, 46,
                   66, 0
                  ]
                },
                Arc {
                  centerX: 33
                  centerY: 80
                  startAngle: 180
                  length: 180
                  radiusX: 18
                  radiusY: 10
                }
              ]
            }
          },
          Rectangle {
            width: 66
            height: 98
            fill: Color.TRANSPARENT
            cursor: Cursor.HAND
            onMouseClicked: function(me:MouseEvent):Void {
              stephensDown[1] = true;
              knockdownRefs[1].playFromStart();
            }
          }
        ]
      },
      // Right-most face
      stephen3Ref = ImageView {
        transforms: Translate.translate(190, 95)
        image: Image {
          url: "{__DIR__}images/sj_left_facing.gif"
        }
        opacity: 0.0
        effect: Glow {}
        cursor: Cursor.HAND
        onMouseClicked: function(me:MouseEvent):Void {
          stephensDown[2] = true;
          knockdownRefs[2].playFromStart();
        }
      },
      // Start Game button
      btn = SwingButton {
        transforms: [
          Translate.translate(200, 207),
          Scale.scale(0.7, 0.7),
          Rotate { angle: -4}
        ]
        text: bind if (gameTimeline.running) "Stop Game" else "Start Game"
        foreground: bind if (gameTimeline.running) Color.BLACK else Color.RED
        font: Font {
          name: "Arial Bold"
        }
        action: function():Void {
          if (not gameTimeline.running) {
            stephensDown[0] = true;
            stephensDown[1] = true;
            stephensDown[2] = true;
            knockdownRefs[0].playFromStart();
            knockdownRefs[1].playFromStart();
            knockdownRefs[2].playFromStart();
            gameTimeline.playFromStart();
          }
          else {
            gameTimeline.stop();
          }
        }
      }
    ]
  }
}

Enjoy the conference if you're attending, and this very simple and lame Whack-A-Janssen game!

Regards,

Jim Weaver
JavaFXpert.com

Creating Games with JavaFX: Silveira is Having Too Much Fun :-)

I've featured Silveira Neto's JavaFX work (play?) in a couple of recent posts, and it appears that he's had gaming on his mind lately.  Silveira is a CS student, CEJUG member and Sun Campus Ambassador at Federal University of Ceará.

His latest creation, shown above, is a game in which the player tries to vacuum up the dirty clouds with a sphere-shaped cleaner.  It demonstrates several techniques in JavaFX, such as creating a side-scrolling game, capturing keyboard input, and ascertaining when a graphical object intersects with a pixel in another graphical object.  You can see more information, including the source code and a YouTube video of the game being played, from Silveira's blog post.

In a prior post, Silveira discusses how to create a side-scrolling game in JavaFX, showing the classes that he's building to support it.

Have fun!

Jim Weaver
JavaFXpert.com blog