diff --git a/TennisGame/fonts/TitilliumWeb-Regular.ttf b/TennisGame/fonts/TitilliumWeb-Regular.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..6da821935dc29725c445ee8b469a2242c508c481
Binary files /dev/null and b/TennisGame/fonts/TitilliumWeb-Regular.ttf differ
diff --git a/TennisGame/game.uia b/TennisGame/game.uia
new file mode 100644
index 0000000000000000000000000000000000000000..01d364a5cb18aab0085e92a0c0befe03e240aab4
--- /dev/null
+++ b/TennisGame/game.uia
@@ -0,0 +1,16 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/TennisGame/game.uip b/TennisGame/game.uip
new file mode 100644
index 0000000000000000000000000000000000000000..ae8c4c628eca9a9d6994b736e5c0ff2dabcd7986
--- /dev/null
+++ b/TennisGame/game.uip
@@ -0,0 +1,129 @@
+
+
+
+
+ #ffffff #ffffff #ffffff #ffffff #ffffff #ffffff #ffffff #ffffff #ffffff #ffffff #ffffff #ffffff #ffffff #ffffff #ffffff #ffffff
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/TennisGame/maps/Cork1.png b/TennisGame/maps/Cork1.png
new file mode 100644
index 0000000000000000000000000000000000000000..b27b27d40ce9fe5146d8e49da42a68c9b5ec6384
Binary files /dev/null and b/TennisGame/maps/Cork1.png differ
diff --git a/TennisGame/maps/Wood7.png b/TennisGame/maps/Wood7.png
new file mode 100644
index 0000000000000000000000000000000000000000..9d9a219a459b4176ba1a95d8897f6788c9604527
Binary files /dev/null and b/TennisGame/maps/Wood7.png differ
diff --git a/TennisGame/readme.md b/TennisGame/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..ff073e6a18950cff43582c0e9caf7b498d058ee7
--- /dev/null
+++ b/TennisGame/readme.md
@@ -0,0 +1,29 @@
+# Qt 3D Studio Tennis Game Demo
+
+This demo application is created with Qt 3D Studio.
+Behaviors and actions are used to implement a tennis game. The player is pitted against a computer opponent
+with a mission of getting the ball behind the opponent to score. Whoever gets 3 points first wins.
+The paddle of the player is controlled with a mouse by clicking on the screen and moving around.
+
+Two custom behaviors are used: Movement.qml and Score.qml.
+Movement.qml is the most complex script used. It handles the movement of the player, AI and the ball.
+It includes collision detection and handles score detection and ball serving also.
+
+Properties that can be set from the studio for Movement.qml are:
+- Obstacle 1: Object that can be collided with
+- Obstacle 2: Another object that can be collided with
+- Has Physics: Determines if the object is handled as a ball
+- Has AI: Determines if the object is handled as the AI paddle
+
+The important handlers for Movement.qml are "onMouseDown" and "onMouseUp".
+The Scene object in the presentation includes actions that listen for mouse input to the screen.
+If such events occur the functions "onMouseDown" and "onMouseUp" from Movement.qml are called.
+The script can then use the inputs to move the player around.
+
+Movement.qml can also output two events: "onPlayerScore" and "onComputerScore".
+The Movement script for the ball includes two actions in the studio that listen for these events.
+When one side scores the functions that increment scores in the Score script, owned by the score text object, are called.
+
+Score.qml itself also outputs two events: "onPlayerWins" and "onComputerWins".
+The Score scripts increments the scores and, if one score is equal to 3, fires the win event for the owner of that score.
+The actions that listen for the win events then tell the Scene object to jump to a victory or a defeat slide.
\ No newline at end of file
diff --git a/TennisGame/scripts/Movement.qml b/TennisGame/scripts/Movement.qml
new file mode 100644
index 0000000000000000000000000000000000000000..562658eb957ae73bc5e2f6abf79088e4bb641165
--- /dev/null
+++ b/TennisGame/scripts/Movement.qml
@@ -0,0 +1,221 @@
+/*[[
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+]]*/
+
+import QtStudio3D.Behavior 1.0
+
+Behavior {
+ //Properties exposed to the studio
+ property var obstacle1
+ property var obstacle2
+ property var hasPhysics
+ property var hasAI
+ property var speed
+
+ //Properties used as global variables
+ property var mouseDown: false
+ property var input: Qt.vector3d(0, 0, 0);
+ property var direction: Qt.vector3d(-1, Math.random() * 2 - 1, 0);
+ property var physicsSpeed
+ property var serveTimer: 1
+
+ onInitialize: {
+ //Only the ball speed has to be reset during initalization
+ //since the ball movement speeds up during gameplay
+ physicsSpeed = speed;
+ }
+
+ onUpdate: {
+ //Pause the ball movement before the serve
+ if (hasPhysics && serveTimer > 0) {
+ serveTimer -= getDeltaTime();
+ return;
+ }
+
+ //Get the position of the script owner
+ var transform = calculateGlobalTransform();
+ var position = transform.row(3).toVector3d();
+
+ //Check if ball is out of bounds
+ var levelWidth = 600;
+ if (position.x > levelWidth)
+ fireEvent("onPlayerScore");
+ else if (position.x < -levelWidth)
+ fireEvent("onComputerScore");
+
+ if (position.x < -levelWidth || position.x > levelWidth) {
+ //Reset properties if out of bounds
+ setAttribute("position.x", 0);
+ setAttribute("position.y", 0);
+ transform = calculateGlobalTransform();
+ position = transform.row(3).toVector3d();
+ direction.y = Math.random() * 2 - 1;
+ physicsSpeed = speed;
+ serveTimer = 1;
+ return;
+ }
+
+ if (mouseDown) {
+ //Handle movement with mouse input
+ var perspectiveFactor = 1.4;
+ var halfScreenHeight = 240;
+ var target = (halfScreenHeight - getMousePosition().y) * perspectiveFactor;
+ if (Math.abs(position.y - target) > 6) {
+ if (position.y > target)
+ moveDown();
+ else
+ moveUp();
+ } else {
+ stopVertical();
+ }
+ } else {
+ stopVertical();
+ }
+
+ var next = Qt.vector3d(position.x, position.y, position.z);
+
+ direction = direction.normalized();
+
+ if (hasAI) {
+ //Handle AI movement input
+ var obstacleTransform = calculateGlobalTransform(obstacle1);
+ var obstaclePosition = obstacleTransform.row(3).toVector3d();
+ if (Math.abs(obstaclePosition.y - position.y) > 25)
+ input.y = Math.sign(obstaclePosition.y - position.y);
+ else
+ input.y = 0;
+ }
+
+ //Separate collision solving to X and Y axis
+ //Even if a collision happens on the X axis one can move along the Y axis and vice versa
+ var canMoveX = true;
+ var canMoveY = true;
+
+ if (hasPhysics) {
+ //Handle ball movement
+ next.x += direction.x * physicsSpeed * getDeltaTime();
+ next.y += direction.y * physicsSpeed * getDeltaTime();
+ if (next.y > 300 || next.y < -300)
+ canMoveY = false;
+ } else {
+ //Handle paddle movement
+ next.y += input.y * speed * getDeltaTime();
+ }
+
+ //Check collisions against two objects
+ var collisions = [collidesWith(obstacle1, position, next),
+ collidesWith(obstacle2, position, next)];
+
+ var collisionPosition;
+ for (var i = 0; i < collisions.length; ++i) {
+ if (collisions[i].x || collisions[i].y)
+ collisionPosition = collisions[i].position;
+ if (collisions[i].x)
+ canMoveX = false;
+ if (collisions[i].y)
+ canMoveY = false;
+ }
+
+ if (canMoveX) {
+ setAttribute("position.x", next.x);
+ } else {
+ //Change ball direction and the angle if collision happens
+ if (hasPhysics) {
+ direction.x = -direction.x;
+ direction.y = -Math.sin(Math.atan2(collisionPosition.y - position.y,
+ collisionPosition.x - position.x));
+ physicsSpeed += 20;
+ }
+ }
+
+ if (canMoveY) {
+ setAttribute("position.y", next.y);
+ }
+ else {
+ if (hasPhysics)
+ direction.y = -direction.y;
+ }
+ }
+
+ function collidesWith(obstacle, position, next) {
+ if (obstacle === "")
+ return {x: false, y: false};
+
+ //Get obstacle position
+ var obstacleTransform = calculateGlobalTransform(obstacle);
+ var obstaclePosition = obstacleTransform.row(3).toVector3d();
+
+ var ballSize = 50;
+ var paddleWidth = 50;
+ var paddleHeight = 100;
+
+ var xCollides = true;
+ var yCollides = true;
+
+ //Rectangular collision check
+ //All collisions are between the ball and a paddle so sizes can be hard-coded
+ if (next.x + paddleWidth / 2 < obstaclePosition.x - ballSize / 2
+ || next.x - paddleWidth / 2 > obstaclePosition.x + ballSize / 2
+ || position.y + paddleHeight / 2 < obstaclePosition.y - ballSize / 2
+ || position.y - paddleHeight / 2 > obstaclePosition.y + ballSize / 2) {
+ xCollides = false;
+ }
+
+ if (position.x + paddleWidth / 2 < obstaclePosition.x - ballSize / 2
+ || position.x - paddleWidth / 2 > obstaclePosition.x + ballSize / 2
+ || next.y + paddleHeight / 2 < obstaclePosition.y - ballSize / 2
+ || next.y - paddleHeight / 2 > obstaclePosition.y + ballSize / 2) {
+ yCollides = false;
+ }
+
+ return {position: obstaclePosition, x: xCollides, y: yCollides};
+ }
+
+ function onMouseDown() {
+ mouseDown = true;
+ }
+
+ function onMouseUp() {
+ mouseDown = false;
+ }
+
+ function moveUp() {
+ input.y = 1;
+ }
+
+ function moveDown() {
+ input.y = -1;
+ }
+
+ function moveLeft() {
+ input.x = -1;
+ }
+
+ function moveRight() {
+ input.x = 1;
+ }
+
+ function stopHorizontal() {
+ input.x = 0;
+ }
+
+ function stopVertical() {
+ input.y = 0;
+ }
+}
diff --git a/TennisGame/scripts/Score.qml b/TennisGame/scripts/Score.qml
new file mode 100644
index 0000000000000000000000000000000000000000..02308739e2cf3345602475d7d11aad17445d6a07
--- /dev/null
+++ b/TennisGame/scripts/Score.qml
@@ -0,0 +1,36 @@
+/*[[
+
+
+
+
+
+
+]]*/
+
+import QtStudio3D.Behavior 1.0
+
+Behavior {
+ property var playerScore: 0
+ property var computerScore: 0
+
+ onUpdate: {
+ setAttribute("textstring", playerScore + " - " + computerScore);
+ }
+
+ function addPlayerScore() {
+ playerScore++;
+ if (playerScore >= 3)
+ fireEvent("onPlayerWins");
+ }
+
+ function addComputerScore() {
+ computerScore++;
+ if (computerScore >= 3)
+ fireEvent("onComputerWins");
+ }
+
+ function resetScores() {
+ playerScore = 0;
+ computerScore = 0;
+ }
+}