[dali_1.2.0] Merge branch 'devel/master'
[platform/core/uifw/dali-demo.git] / examples / blocks / blocks-example.cpp
1 /*
2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 #include <sstream>
19 #include <iostream>
20 #include <string>
21 #include <map>
22 #include <algorithm>
23
24 #include <dali/dali.h>
25 #include <dali-toolkit/dali-toolkit.h>
26 #include "shared/view.h"
27
28 using namespace Dali;
29 using namespace Dali::Toolkit;
30 using namespace DemoHelper;
31
32 namespace
33 {
34 const char* BACKGROUND_IMAGE( DEMO_IMAGE_DIR "background-blocks.jpg" );
35 const char* TOOLBAR_IMAGE( DEMO_IMAGE_DIR "top-bar.png" );
36 const char* APPLICATION_TITLE( "DALi Blocks" );
37 const char* BALL_IMAGE = DEMO_IMAGE_DIR "blocks-ball.png";
38 const char* PADDLE_IMAGE = DEMO_IMAGE_DIR "blocks-paddle.png";
39 const char* PADDLE_HANDLE_IMAGE = DEMO_IMAGE_DIR "blocks-paddle-handle.png";
40
41 const char* BRICK_IMAGE_PATH[] =    { DEMO_IMAGE_DIR "blocks-brick-1.png",
42                                       DEMO_IMAGE_DIR "blocks-brick-2.png",
43                                       DEMO_IMAGE_DIR "blocks-brick-3.png",
44                                       DEMO_IMAGE_DIR "blocks-brick-4.png" };
45
46 const int TOTAL_BRICKS(4);                                                  ///< Total bricks in game.
47 const Vector3 ICON_SIZE(100.0f, 100.0f, 0.0f);
48
49 const float SCREEN_MARGIN = 10.0f;                                          ///< Margin indentation around screen
50 const Vector3 MENU_BUTTON_SIZE = Vector3(0.15f, 0.05f, 1.0f);               ///< Standard Menu Buttons.
51
52 const float MAX_ANIMATION_DURATION = 60.0f;                                 ///< 60 seconds animations. Long enough for ball to hit an obstacle.
53 const float BALL_VELOCITY = 300.0f;                                         ///< Ball velocity in pixels/second.
54 const float MAX_VELOCITY = 500.0f;                                          ///< Max. velocity in pixels/second.
55 const Vector3 PADDLE_COLLISION_MARGIN(0.0f, 0.0f, 0.0f);                    ///< Collision margin for ball-paddle detection.
56 const Vector3 BRICK_COLLISION_MARGIN(0.0f, 0.0f, 0.0f);                     ///< Collision margin for ball-brick detection.
57 const Vector3 INITIAL_BALL_DIRECTION(1.0f, 1.0f, 0.0f);                     ///< Initial ball direction.
58
59 const std::string WOBBLE_PROPERTY_NAME("wobbleProperty");                  ///< Wobble property name.
60 const std::string COLLISION_PROPERTY_NAME("collisionProperty");            ///< Collision property name.
61
62 const Vector2 BRICK_SIZE(0.1f, 0.05f );                                     ///< Brick size relative to width of stage.
63 const Vector2 BALL_SIZE( 0.05f, 0.05f );                                    ///< Ball size relative to width of stage.
64 const Vector2 PADDLE_SIZE( 0.2f, 0.05f );                                   ///< Paddle size relative to width of stage.
65 const Vector2 PADDLE_HANDLE_SIZE( 0.3f, 0.3f );                             ///< Paddle handle size relative to width of stage.
66 const Vector2 BALL_START_POSITION(0.5f, 0.8f);                              ///< Ball start position relative to stage size.
67 const Vector2 PADDLE_START_POSITION(0.5f, 0.9f);                            ///< Paddler start position relative to stage size.
68 const Vector2 PADDLE_HIT_MARGIN( 0.1, 0.15f );                              ///< Extra hit Area for Paddle when touching.
69
70 const int TOTAL_LIVES(3);                                                   ///< Total lives in game before it's game over!
71 const int TOTAL_LEVELS(3);                                                  ///< 3 Levels total, then repeats.
72
73 // constraints ////////////////////////////////////////////////////////////////
74
75 /**
76  * CollisionCircleRectangleConstraint generates a collision vector
77  * between two actors a (circle) and b (rectangle)
78  */
79 struct CollisionCircleRectangleConstraint
80 {
81   /**
82    * Collision Constraint constructor
83    * The adjust (optional) parameter can be used to add a margin
84    * to the actors. A +ve size will result in larger collisions,
85    * while a -ve size will result in tighter collisions.
86    *
87    * @param[in] adjustPosition (optional) Adjusts the position offset of detection
88    * @param[in] adjustSize (optional) Adjusts the rectangular size of detection
89    */
90   CollisionCircleRectangleConstraint(Vector3 adjustPosition = Vector3::ZERO,
91                                      Vector3 adjustSize = Vector3::ZERO)
92   : mAdjustPosition(adjustPosition),
93     mAdjustSize(adjustSize)
94   {
95   }
96
97   /**
98    * Generates collision vector indicating whether Actor's A and B
99    * have overlapped eachother, and the relative position of Actor B to A.
100    *
101    * @param[in,out] current The current collision-property
102    * @param[in] inputs Contains:
103    *                    Actor A's Position property.
104    *                    Actor B's Position property.
105    *                    Actor A's Size property.
106    *                    Actor B's Size property.
107    * @return The collision vector is returned.
108    */
109   void operator()( Vector3& current, const PropertyInputContainer& inputs )
110   {
111     const Vector3& a = inputs[0]->GetVector3();
112     const Vector3 b = inputs[1]->GetVector3() + mAdjustPosition;
113     const Vector3& sizeA = inputs[2]->GetVector3();
114     const Vector3& sizeB = inputs[3]->GetVector3();
115     const Vector3 sizeA2 = sizeA * 0.5f; // circle radius
116     const Vector3 sizeB2 = (sizeB + mAdjustSize) * 0.5f; // rectangle half rectangle.
117
118     // get collision relative to a (rectangle).
119     Vector3 delta = a - b;
120
121     // reduce rectangle to 0.
122     if (delta.x > sizeB2.x)
123     {
124       delta.x -= sizeB2.x;
125     }
126     else if (delta.x < -sizeB2.x)
127     {
128       delta.x += sizeB2.x;
129     }
130     else
131     {
132       delta.x = 0;
133     }
134
135     if (delta.y > sizeB2.y)
136     {
137       delta.y -= sizeB2.y;
138     }
139     else if (delta.y < -sizeB2.y)
140     {
141       delta.y += sizeB2.y;
142     }
143     else
144     {
145       delta.y = 0;
146     }
147
148     // now calculate collision vector vs origin. (assume A is a circle, not ellipse)
149     if(delta.Length() < sizeA2.x)
150     {
151       delta.Normalize();
152       current = delta;
153     }
154     else
155     {
156       current = Vector3::ZERO;
157     }
158   }
159
160   const Vector3 mAdjustPosition;            ///< Position Adjustment value
161   const Vector3 mAdjustSize;                ///< Size Adjustment value
162 };
163
164 /**
165  * WobbleConstraint generates a decaying sinusoidial rotation.
166  * The result when applied to an Actor, is the Actor rotating left/right
167  * initially a large amount (deviation degrees, when wobble property is 0.0f)
168  * then eventually coming to a stop (once wobble property reaches 1.0f)
169  */
170 struct WobbleConstraint
171 {
172   /**
173    * Wobble Constraint constructor
174    * Generates a sinusoidial rotation that starts with
175    * high amplitude (deviation), and then decays to zero over input 0.0f to 1.0f
176    *
177    * @param[in] deviation The max. deviation of wobble effect in degrees.
178    */
179   WobbleConstraint( Degree deviation )
180   : mDeviation( deviation )
181   {
182
183   }
184
185   /**
186    * @param[in,out] current The current rotation property
187    * @param[in] inputs Contains the wobble property (value from 0.0f to 1.0f)
188    * @return The rotation (quaternion) is generated.
189    */
190   void operator()( Quaternion& current, const PropertyInputContainer& inputs )
191   {
192     const float& wobble = inputs[0]->GetFloat();
193
194     float f = sinf(wobble * 10.0f) * (1.0f-wobble);
195
196     current = Quaternion(mDeviation * f, Vector3::ZAXIS);
197   }
198
199   Radian mDeviation;           ///< Deviation factor in radians.
200 };
201
202 } // unnamed namespace
203
204 /**
205  * This example shows how to use PropertyNotifications
206  */
207 class ExampleController : public ConnectionTracker
208 {
209 public:
210
211   /**
212    * Constructor
213    * @param application Application class, stored as reference
214    */
215   ExampleController( Application& application )
216   : mApplication( application ),
217     mView()
218   {
219     // Connect to the Application's Init and orientation changed signal
220     mApplication.InitSignal().Connect(this, &ExampleController::Create);
221   }
222
223   /**
224    * This method gets called once the main loop of application is up and running
225    * @param[in] application Reference to the application instance
226    */
227   void Create(Application& application)
228   {
229     Stage::GetCurrent().KeyEventSignal().Connect(this, &ExampleController::OnKeyEvent);
230
231     // Hide the indicator bar
232     application.GetWindow().ShowIndicator( Dali::Window::INVISIBLE );
233
234     // Creates a default view with a default tool bar.
235     // The view is added to the stage.
236     Toolkit::ToolBar toolBar;
237     mContentLayer = DemoHelper::CreateView( application,
238                                             mView,
239                                             toolBar,
240                                             BACKGROUND_IMAGE,
241                                             TOOLBAR_IMAGE,
242                                             APPLICATION_TITLE );
243
244     // Add an extra space on the right to center the title text.
245     toolBar.AddControl( Actor::New(), DemoHelper::DEFAULT_VIEW_STYLE.mToolBarButtonPercentage, Toolkit::Alignment::HorizontalRight );
246
247     // Create the content layer, which is where game actors appear.
248     AddContentLayer();
249   }
250
251 private:
252
253   /**
254    * Adds a new layer to the stage, containing game actors.
255    */
256   void AddContentLayer()
257   {
258     Stage stage = Stage::GetCurrent();
259     const Vector3 stageSize(stage.GetSize());
260
261     // Ball setup
262     mBallStartPosition = stageSize * Vector3( BALL_START_POSITION );
263     mBall = CreateImage(BALL_IMAGE);
264     mBall.SetPosition( mBallStartPosition );
265     mBall.SetSize( BALL_SIZE * stageSize.width );
266     mContentLayer.Add(mBall);
267     mBallVelocity = Vector3::ZERO;
268
269     // Paddle setup
270     mPaddleHitMargin = Vector2(stageSize) * PADDLE_HIT_MARGIN;
271     mPaddle = Actor::New();
272     mPaddleHandle = CreateImage(PADDLE_HANDLE_IMAGE);
273     mPaddleImage = CreateImage(PADDLE_IMAGE);
274     mPaddle.Add( mPaddleHandle );
275     mPaddle.Add( mPaddleImage );
276     mPaddleHandle.SetParentOrigin( ParentOrigin::TOP_CENTER );
277     mPaddleHandle.SetAnchorPoint( AnchorPoint::TOP_CENTER );
278     mPaddleHandle.SetPosition( 0.0f, stageSize.width * 0.0125f );
279     mPaddleImage.SetParentOrigin( ParentOrigin::TOP_CENTER );
280     mPaddleImage.SetAnchorPoint( AnchorPoint::TOP_CENTER );
281     mPaddle.SetParentOrigin( ParentOrigin::TOP_LEFT );
282     mPaddle.SetAnchorPoint( AnchorPoint::CENTER );
283     mPaddleFullSize = PADDLE_SIZE * stageSize.width;
284     mPaddle.SetSize( mPaddleFullSize + mPaddleHitMargin );
285     mPaddleHandle.SetSize( PADDLE_HANDLE_SIZE * stageSize.width );
286     mPaddleImage.SetSize( mPaddleFullSize );
287
288     mWobbleProperty = mPaddle.RegisterProperty(WOBBLE_PROPERTY_NAME, 0.0f);
289     Constraint wobbleConstraint = Constraint::New<Quaternion>( mPaddle, Actor::Property::ORIENTATION, WobbleConstraint(Degree( 10.0f )));
290     wobbleConstraint.AddSource( LocalSource(mWobbleProperty) );
291     wobbleConstraint.Apply();
292
293     mPaddle.SetPosition( stageSize * Vector3( PADDLE_START_POSITION ) );
294     mContentLayer.Add(mPaddle);
295     mPaddle.TouchSignal().Connect(this, &ExampleController::OnTouchPaddle);
296     mContentLayer.TouchSignal().Connect(this, &ExampleController::OnTouchLayer);
297
298     const float margin(BALL_SIZE.width * stageSize.width * 0.5f);
299
300     // Set up notifications for ball's collisions against walls.
301     PropertyNotification leftNotification = mBall.AddPropertyNotification( Actor::Property::POSITION_X, LessThanCondition(margin) );
302     leftNotification.NotifySignal().Connect( this, &ExampleController::OnHitLeftWall );
303
304     PropertyNotification rightNotification = mBall.AddPropertyNotification( Actor::Property::POSITION_X, GreaterThanCondition(stageSize.width - margin) );
305     rightNotification.NotifySignal().Connect( this, &ExampleController::OnHitRightWall );
306
307     PropertyNotification topNotification = mBall.AddPropertyNotification( Actor::Property::POSITION_Y, LessThanCondition(margin) );
308     topNotification.NotifySignal().Connect( this, &ExampleController::OnHitTopWall );
309
310     PropertyNotification bottomNotification = mBall.AddPropertyNotification( Actor::Property::POSITION_Y, GreaterThanCondition(stageSize.height + margin) );
311     bottomNotification.NotifySignal().Connect( this, &ExampleController::OnHitBottomWall );
312
313     // Set up notification for ball colliding against paddle.
314     Actor delegate = Actor::New();
315     stage.Add(delegate);
316     Property::Index property = delegate.RegisterProperty(COLLISION_PROPERTY_NAME, Vector3::ZERO);
317     Constraint constraint = Constraint::New<Vector3>( delegate, property, CollisionCircleRectangleConstraint( -Vector3(0.0f, mPaddleHitMargin.height * 0.575f, 0.0f),-Vector3(mPaddleHitMargin) ) );
318     constraint.AddSource( Source(mBall, Actor::Property::POSITION) );
319     constraint.AddSource( Source(mPaddle, Actor::Property::POSITION) );
320     constraint.AddSource( Source(mBall, Actor::Property::SIZE) );
321     constraint.AddSource( Source(mPaddle, Actor::Property::SIZE) );
322     constraint.Apply();
323
324     PropertyNotification paddleNotification = delegate.AddPropertyNotification( property, GreaterThanCondition(0.0f) );
325     paddleNotification.NotifySignal().Connect( this, &ExampleController::OnHitPaddle );
326
327     RestartGame();
328   }
329
330   /**
331    * Restarts Game
332    * Resets Lives count and other stats, and loads level
333    */
334   void RestartGame()
335   {
336     mLives = TOTAL_LIVES;
337     mLevel = 0;
338     mBall.SetPosition( mBallStartPosition );
339     mBallVelocity = Vector3::ZERO;
340     mPaddle.SetSize( mPaddleFullSize + mPaddleHitMargin );
341     mPaddleImage.SetSize( mPaddleFullSize );
342
343     LoadLevel(mLevel);
344   }
345
346   /**
347    * Loads level
348    * All existing level content is removed, and new bricks
349    * are added.
350    * @param[in] level Level index to load.
351    */
352   void LoadLevel(int level)
353   {
354     if(mLevelContainer && mLevelContainer.GetParent() == mContentLayer)
355     {
356       mContentLayer.Remove( mLevelContainer );
357     }
358
359     mLevelContainer = Actor::New();
360     mLevelContainer.SetAnchorPoint( AnchorPoint::CENTER );
361     mLevelContainer.SetParentOrigin( ParentOrigin::CENTER );
362     mLevelContainer.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
363
364     mContentLayer.Add( mLevelContainer );
365
366     mBrickCount = 0;
367
368     if( mBrickImageMap.Empty() )
369     {
370       Vector2 stageSize(Stage::GetCurrent().GetSize());
371       const Vector2 brickSize(BRICK_SIZE * Vector2(stageSize.x, stageSize.x));
372
373       mBrickImageMap["desiredWidth"] = static_cast<int>( brickSize.width );
374       mBrickImageMap["desiredHeight"] = static_cast<int>( brickSize.height );
375       mBrickImageMap["fittingMode"] = "SCALE_TO_FILL";
376       mBrickImageMap["samplingMode"] = "BOX_THEN_LINEAR";
377     }
378
379     switch(level%TOTAL_LEVELS)
380     {
381       case 0:
382       {
383         GenerateLevel0();
384         break;
385       }
386       case 1:
387       {
388         GenerateLevel1();
389         break;
390       }
391       case 2:
392       {
393         GenerateLevel2();
394         break;
395       }
396       default:
397       {
398         break;
399       }
400     } // end switch
401   }
402
403   /**
404    * Generates level 0
405    */
406   void GenerateLevel0()
407   {
408     Vector2 stageSize(Stage::GetCurrent().GetSize());
409     const Vector2 brickSize(BRICK_SIZE * stageSize.width);
410
411     const int columns = (0.85f * stageSize.width) / brickSize.width; // 85 percent of the width of the screen covered with bricks.
412     const int rows = (0.3f * stageSize.height) / brickSize.height;   // 30 percent of the height of the screen covered with bricks.
413     const Vector2 offset( (stageSize.x - (columns * brickSize.width)) * 0.5f,
414                            stageSize.y * 0.125f );
415
416     for(int j = 0; j < rows; j++)
417     {
418       for(int i = 0; i < columns; i++)
419       {
420         Actor brick = CreateBrick(Vector2(i * brickSize.width + offset.x, j * brickSize.height + offset.y) + (brickSize * 0.5f), j % TOTAL_BRICKS );
421         mLevelContainer.Add(brick);
422         mBrickCount++;
423       }
424     }
425   }
426
427   /**
428    * Generates level 1
429    */
430   void GenerateLevel1()
431   {
432     Vector2 stageSize(Stage::GetCurrent().GetSize());
433     const Vector2 brickSize(BRICK_SIZE * stageSize.width);
434
435     const int columns = (0.85f * stageSize.width) / brickSize.width; // 85 percent of the width of the screen covered with bricks.
436     const int rows = (0.3f * stageSize.height) / brickSize.height;   // 30 percent of the height of the screen covered with bricks.
437     const Vector2 offset( (stageSize.x - (columns * brickSize.width)) * 0.5f,
438                            stageSize.y * 0.125f );
439
440     for(int j = 0; j < rows; j++)
441     {
442       for(int i = 0; i < columns; i++)
443       {
444         int i2 = columns - i - 1;
445         int j2 = rows - j - 1;
446         int brickIndex = std::min( std::min(i, j), std::min(i2, j2) ) % TOTAL_BRICKS;
447
448         Actor brick = CreateBrick(Vector2(i * brickSize.width + offset.x, j * brickSize.height + offset.y) + (brickSize * 0.5f), brickIndex );
449
450         mLevelContainer.Add(brick);
451         mBrickCount++;
452       }
453     }
454   }
455
456   /**
457    * Generates level 2
458    */
459   void GenerateLevel2()
460   {
461     Vector2 stageSize(Stage::GetCurrent().GetSize());
462     const Vector2 brickSize(BRICK_SIZE * stageSize.width);
463
464     const int columns = (0.85f * stageSize.width) / brickSize.width; // 85 percent of the width of the screen covered with bricks.
465     const int rows = (0.3f * stageSize.height) / brickSize.height;   // 30 percent of the height of the screen covered with bricks.
466     const Vector2 offset( (stageSize.x - (columns * brickSize.width)) * 0.5f,
467                            stageSize.y * 0.125f );
468
469     // lays down bricks in a spiral formation starting at i,j = (0,0) top left corner
470     // travelling right di,dj = (1,0) initially
471     int i = 0;
472     int j = 0;
473     int di = 1;
474     int dj = 0;
475
476     // contracting boundaries
477     int left = 0;
478     int right = columns - 1;
479     int top = 2;
480     int bottom = rows - 1;
481
482     // length of current line. we stop laying down bricks when the length is 1 brick or less.
483     int length = 0;
484     while(true)
485     {
486       Actor brick = CreateBrick(Vector2(i * brickSize.width + offset.x, j * brickSize.height + offset.y) + (brickSize * 0.5f), 0 );
487       mLevelContainer.Add(brick);
488       i+=di;
489       j+=dj;
490       bool turn(false);
491       if((i==right) && (di==1))
492       {
493         right -= 2;
494         turn = true;
495       }
496       if((j==bottom) && (dj==1))
497       {
498         bottom -= 2;
499         turn = true;
500       }
501       if((i==left) && (di==-1))
502       {
503         left += 2;
504         turn = true;
505       }
506       if((j==top) && (dj==-1))
507       {
508         top += 2;
509         turn = true;
510       }
511       if(turn)
512       {
513         // turn 90 degrees clockwise.
514         std::swap(di, dj);
515         di = -di;
516         if (length<=1)
517         {
518           break;
519         }
520         length = 0;
521       }
522       length++;
523       mBrickCount++;
524     }
525   }
526
527
528   /**
529    * Creates a brick at a specified position on the stage
530    * @param[in] position the position for the brick
531    * @param[in] type the type of brick
532    * @return The Brick Actor is returned.
533    */
534   Actor CreateBrick( const Vector2& position, int type )
535   {
536     mBrickImageMap["url"] = BRICK_IMAGE_PATH[type];
537     ImageView brick = ImageView::New();
538     brick.SetProperty( ImageView::Property::IMAGE, mBrickImageMap );
539     brick.SetParentOrigin(ParentOrigin::TOP_LEFT);
540     brick.SetAnchorPoint(AnchorPoint::CENTER);
541     brick.SetPosition( Vector3( position ) );
542
543     // Add a constraint on the brick between it and the ball generating a collision-property
544     Property::Index property = brick.RegisterProperty(COLLISION_PROPERTY_NAME, Vector3::ZERO);
545     Constraint constraint = Constraint::New<Vector3>( brick, property, CollisionCircleRectangleConstraint(BRICK_COLLISION_MARGIN) );
546     constraint.AddSource( Source(mBall, Actor::Property::POSITION) );
547     constraint.AddSource( Source(brick, Actor::Property::POSITION) );
548     constraint.AddSource( Source(mBall, Actor::Property::SIZE) );
549     constraint.AddSource( Source(brick, Actor::Property::SIZE) );
550     constraint.Apply();
551
552     // Now add a notification on this collision-property
553
554     PropertyNotification brickNotification = brick.AddPropertyNotification( property, GreaterThanCondition(0.0f) );
555     brickNotification.NotifySignal().Connect( this, &ExampleController::OnHitBrick );
556
557     return brick;
558   }
559
560   /**
561    * Creates an Image (Helper)
562    *
563    * @param[in] filename the path of the image.
564    */
565   ImageView CreateImage(const std::string& filename)
566   {
567     ImageView actor = ImageView::New(filename);
568     actor.SetParentOrigin(ParentOrigin::TOP_LEFT);
569     actor.SetAnchorPoint(AnchorPoint::CENTER);
570     return actor;
571   }
572
573   /**
574    * Continue animation (based on current velocity)
575    */
576   void ContinueAnimation()
577   {
578     if(mBallAnimation)
579     {
580       mBallAnimation.Clear();
581     }
582
583     mBallAnimation = Animation::New(MAX_ANIMATION_DURATION);
584     mBallAnimation.AnimateBy( Property( mBall, Actor::Property::POSITION ), mBallVelocity * MAX_ANIMATION_DURATION);
585     mBallAnimation.Play();
586   }
587
588   /**
589    * Signal invoked whenever user touches the Paddle.
590    * @param[in] actor The actor touched
591    * @param[in] event The touch event
592    */
593   bool OnTouchPaddle(Actor actor, const TouchData& event)
594   {
595     if(event.GetPointCount()>0)
596     {
597       if( event.GetState( 0 ) == PointState::DOWN ) // Commence dragging
598       {
599         // Get point where user touched paddle (relative to paddle's center)
600         Vector2 screenPoint = event.GetScreenPosition( 0 );
601         mRelativeDragPoint = screenPoint;
602         mRelativeDragPoint -= actor.GetCurrentPosition();
603
604         mDragActor = actor;
605         mDragAnimation = Animation::New(0.25f);
606         mDragAnimation.AnimateTo( Property(mDragActor, Actor::Property::SCALE), Vector3(1.1f, 1.1f, 1.0f), AlphaFunction::EASE_OUT);
607         mDragAnimation.AnimateTo( Property(mPaddleHandle, Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, 0.0f), AlphaFunction::EASE_OUT);
608         mDragAnimation.Play();
609       }
610     }
611     return false;
612   }
613
614   /**
615    * Signal invoked whenever user touches anywhere on the screen.
616    * @param[in] actor The actor touched
617    * @param[in] event The touch event
618    */
619   bool OnTouchLayer(Actor actor, const TouchData& event)
620   {
621     if(event.GetPointCount()>0)
622     {
623       if(mDragActor)
624       {
625         Vector3 position( event.GetScreenPosition( 0 ) );
626         mPaddle.SetPosition( position - mRelativeDragPoint );
627
628         if( event.GetState( 0 ) == PointState::UP ) // Stop dragging
629         {
630           mDragAnimation = Animation::New(0.25f);
631           mDragAnimation.AnimateTo( Property(mDragActor, Actor::Property::SCALE), Vector3(1.0f, 1.0f, 1.0f), AlphaFunction::EASE_IN);
632           mDragAnimation.AnimateTo( Property(mPaddleHandle, Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, 1.0f), AlphaFunction::EASE_OUT);
633           mDragAnimation.Play();
634           mDragActor.Reset();
635         }
636       }
637     }
638     return false;
639   }
640
641   /**
642    * Notification: Ball hit left wall
643    * @param source The notification
644    */
645   void OnHitLeftWall(PropertyNotification& source)
646   {
647     mBallVelocity.x = fabsf(mBallVelocity.x);
648     ContinueAnimation();
649   }
650
651   /**
652    * Notification: Ball hit right wall
653    * @param source The notification
654    */
655   void OnHitRightWall(PropertyNotification& source)
656   {
657     mBallVelocity.x = -fabsf(mBallVelocity.x);
658     ContinueAnimation();
659   }
660
661   /**
662    * Notification: Ball hit top wall
663    * @param source The notification
664    */
665   void OnHitTopWall(PropertyNotification& source)
666   {
667     mBallVelocity.y = fabsf(mBallVelocity.y);
668     ContinueAnimation();
669   }
670
671   /**
672    * Notification: Ball hit bottom wall
673    * @param source The notification
674    */
675   void OnHitBottomWall(PropertyNotification& source)
676   {
677     if(mBallAnimation)
678     {
679       mBallAnimation.Clear();
680     }
681
682     if(mLives>0)
683     {
684       mLives--;
685       const float f(static_cast<float>(mLives) / TOTAL_LIVES);
686       mBallVelocity = Vector3::ZERO;
687
688       Animation shrink = Animation::New(0.5f);
689       shrink.AnimateTo( Property(mPaddle, Actor::Property::SIZE_WIDTH), mPaddleFullSize.x * f + mPaddleHitMargin.x);
690       shrink.AnimateTo( Property(mPaddleImage, Actor::Property::SIZE_WIDTH), mPaddleFullSize.x * f );
691
692       shrink.FinishedSignal().Connect( this, &ExampleController::OnPaddleShrunk );
693       shrink.Play();
694     }
695   }
696
697   /**
698    * Paddle Shrink Animation complete.
699    * @param[in] source The animation responsible for shrinking the paddle.
700    */
701   void OnPaddleShrunk( Animation &source )
702   {
703     // Reposition Ball in start position, and make ball appear.
704     mBall.SetPosition( mBallStartPosition );
705     mBall.SetColor( Vector4(1.0f, 1.0f, 1.0f, 0.1f) );
706     Animation appear = Animation::New(0.5f);
707     appear.AnimateTo( Property(mBall, Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, 1.0f) );
708     appear.Play();
709
710     if(!mLives)
711     {
712       RestartGame();
713     }
714   }
715
716   /**
717    * Notification: Ball hit paddle
718    * @param source The notification
719    */
720   void OnHitPaddle(PropertyNotification& source)
721   {
722     Actor delegate = Actor::DownCast(source.GetTarget());
723     Vector3 collisionVector = delegate.GetProperty<Vector3>(source.GetTargetProperty());
724     Vector3 ballRelativePosition(mBall.GetCurrentPosition() - mPaddle.GetCurrentPosition());
725     ballRelativePosition.Normalize();
726
727     collisionVector.x += ballRelativePosition.x * 0.5f;
728
729     if(mBallVelocity.LengthSquared() < Math::MACHINE_EPSILON_1)
730     {
731       mBallVelocity += collisionVector * BALL_VELOCITY;
732     }
733     else
734     {
735       const float normalVelocity = fabsf(mBallVelocity.Dot(collisionVector));
736       mBallVelocity += collisionVector * normalVelocity * 2.0f;
737       const float currentSpeed = mBallVelocity.Length();
738       const float limitedSpeed = std::min( currentSpeed, MAX_VELOCITY );
739       mBallVelocity = mBallVelocity * limitedSpeed / currentSpeed;
740     }
741
742     ContinueAnimation();
743
744     // wobble paddle
745     mWobbleAnimation = Animation::New(0.5f);
746     mWobbleAnimation.AnimateTo( Property( mPaddle, mWobbleProperty ), 1.0f );
747     mWobbleAnimation.Play();
748     mPaddle.SetProperty(mWobbleProperty, 0.0f);
749   }
750
751   /**
752    * Notification: Ball hit brick
753    * @param source The notification
754    */
755   void OnHitBrick(PropertyNotification& source)
756   {
757     Actor brick = Actor::DownCast(source.GetTarget());
758     Vector3 collisionVector = brick.GetProperty<Vector3>(source.GetTargetProperty());
759
760     const float normalVelocity = fabsf(mBallVelocity.Dot(collisionVector));
761     mBallVelocity += collisionVector * normalVelocity * 2.0f;
762     const float currentSpeed = mBallVelocity.Length();
763     const float limitedSpeed = std::min( currentSpeed, MAX_VELOCITY );
764     mBallVelocity = mBallVelocity * limitedSpeed / currentSpeed;
765
766     ContinueAnimation();
767
768     // remove collision-constraint and notification.
769     brick.RemovePropertyNotification(source);
770     brick.RemoveConstraints();
771
772     // fade brick (destroy)
773     Animation destroyAnimation = Animation::New(0.5f);
774     destroyAnimation.AnimateTo( Property( brick, Actor::Property::COLOR_ALPHA ), 0.0f, AlphaFunction::EASE_IN );
775     destroyAnimation.Play();
776     destroyAnimation.FinishedSignal().Connect( this, &ExampleController::OnBrickDestroyed );
777     mDestroyAnimationMap[destroyAnimation] = brick;
778   }
779
780   /**
781    * Brick Destruction Animation complete.
782    * @param[in] source The animation responsible for destroying the brick
783    */
784   void OnBrickDestroyed( Animation& source )
785   {
786     // Remove brick from stage, it's constraint and property notification should also remove themselves.
787     Actor brick = mDestroyAnimationMap[source];
788     mDestroyAnimationMap.erase(source);
789     brick.GetParent().Remove(brick);
790     mBrickCount--;
791
792     if(!mBrickCount)
793     {
794       mLevel++;
795       LoadLevel(mLevel);
796     }
797   }
798
799   /**
800    * Main key event handler
801    */
802   void OnKeyEvent(const KeyEvent& event)
803   {
804     if(event.state == KeyEvent::Down)
805     {
806       if( IsKey( event, Dali::DALI_KEY_ESCAPE) || IsKey( event, Dali::DALI_KEY_BACK) )
807       {
808         mApplication.Quit();
809       }
810     }
811   }
812
813 private:
814
815   Application& mApplication;                            ///< Application instance
816   Toolkit::Control mView;                               ///< The View instance.
817   Layer mContentLayer;                                  ///< The content layer (contains game actors)
818   ImageView mBall;                                      ///< The Moving ball image.
819   Vector3 mBallStartPosition;                           ///< Ball Start position
820   Vector3 mBallVelocity;                                ///< Ball's current direction.
821   Animation mBallAnimation;                             ///< Ball's animation
822   Actor mPaddle;                                        ///< The paddle including hit area.
823   ImageView mPaddleImage;                               ///< The paddle's image.
824   ImageView mPaddleHandle;                              ///< The paddle's handle (where the user touches)
825   Vector2 mPaddleHitMargin;                             ///< The paddle hit margin.
826   Animation mWobbleAnimation;                           ///< Paddle's animation when hit (wobbles)
827   Property::Index mWobbleProperty;                      ///< The wobble property (generated from animation)
828   Actor mLevelContainer;                                ///< The level container (contains bricks)
829   Property::Map mBrickImageMap;                       ///< The property map used to load the brick
830
831   // actor - dragging functionality
832
833   Animation mDragAnimation;                             ///< Animation for dragging. (grows - affects ACTOR::SCALE)
834   Actor mDragActor;                                     ///< The actor which is being dragged (if any)
835   Vector3 mRelativeDragPoint;                           ///< The point the user touched, relative to the actor.
836   std::map<Animation, Actor> mDestroyAnimationMap;      ///< Keep track of which actors are to be destroyed.
837   Vector2 mPaddleFullSize;                              ///< Initial 100% size of the paddle.
838   int mLevel;                                           ///< Current level
839   int mLives;                                           ///< Total lives.
840   int mBrickCount;                                      ///< Total bricks on screen.
841 };
842
843 void RunTest(Application& app)
844 {
845   ExampleController test(app);
846
847   app.MainLoop();
848 }
849
850 int DALI_EXPORT_API main(int argc, char **argv)
851 {
852   Application app = Application::New(&argc, &argv, DEMO_THEME_PATH);
853
854   RunTest(app);
855
856   return 0;
857 }