1 /****************************************************************************
  2  Copyright (c) 2008-2010 Ricardo Quesada
  3  Copyright (c) 2011-2012 cocos2d-x.org
  4  Copyright (c) 2013-2014 Chukong Technologies Inc.
  5 
  6  http://www.cocos2d-x.org
  7 
  8  Permission is hereby granted, free of charge, to any person obtaining a copy
  9  of this software and associated documentation files (the "Software"), to deal
 10  in the Software without restriction, including without limitation the rights
 11  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 12  copies of the Software, and to permit persons to whom the Software is
 13  furnished to do so, subject to the following conditions:
 14 
 15  The above copyright notice and this permission notice shall be included in
 16  all copies or substantial portions of the Software.
 17 
 18  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 19  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 20  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 21  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 22  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 23  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 24  THE SOFTWARE.
 25  ****************************************************************************/
 26 
 27 /**
 28  * cc.ShakyTiles3D action. <br />
 29  * Reference the test cases (Effects Test)
 30  * @class
 31  * @extends cc.TiledGrid3DAction
 32  * @param {Number} duration
 33  * @param {cc.Size} gridSize
 34  * @param {Number} range
 35  * @param {Boolean} shakeZ
 36  */
 37 cc.ShakyTiles3D = cc.TiledGrid3DAction.extend(/** @lends cc.ShakyTiles3D# */{
 38     _randRange:0,
 39     _shakeZ:false,
 40 
 41 	/**
 42      * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
 43 	 * Creates the action with a range, whether or not to shake Z vertices, a grid size, and duration.
 44 	 * @param {Number} duration
 45 	 * @param {cc.Size} gridSize
 46 	 * @param {Number} range
 47 	 * @param {Boolean} shakeZ
 48 	 */
 49     ctor:function (duration, gridSize, range, shakeZ) {
 50         cc.GridAction.prototype.ctor.call(this);
 51 		shakeZ !== undefined && this.initWithDuration(duration, gridSize, range, shakeZ);
 52     },
 53 
 54     /**
 55      * Initializes the action with a range, whether or not to shake Z vertices, a grid size, and duration.
 56      * @param {Number} duration
 57      * @param {cc.Size} gridSize
 58      * @param {Number} range
 59      * @param {Boolean} shakeZ
 60      * @return {Boolean}
 61      */
 62     initWithDuration:function (duration, gridSize, range, shakeZ) {
 63         if (cc.TiledGrid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
 64             this._randRange = range;
 65             this._shakeZ = shakeZ;
 66             return true;
 67         }
 68         return false;
 69     },
 70 
 71     /**
 72      * Called once per frame. Time is the number of seconds of a frame interval.  <br />
 73      * @param {Number}  dt
 74      */
 75     update:function (dt) {
 76         var locGridSize = this._gridSize, locRandRange = this._randRange;
 77         var locPos = cc.p(0, 0);
 78         for (var i = 0; i < locGridSize.width; ++i) {
 79             for (var j = 0; j < locGridSize.height; ++j) {
 80                 locPos.x = i;
 81                 locPos.y = j;
 82                 var coords = this.originalTile(locPos);
 83 
 84                 // X
 85                 coords.bl.x += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
 86                 coords.br.x += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
 87                 coords.tl.x += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
 88                 coords.tr.x += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
 89 
 90                 // Y
 91                 coords.bl.y += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
 92                 coords.br.y += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
 93                 coords.tl.y += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
 94                 coords.tr.y += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
 95 
 96                 if (this._shakeZ) {
 97                     coords.bl.z += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
 98                     coords.br.z += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
 99                     coords.tl.z += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
100                     coords.tr.z += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
101                 }
102 
103                 this.setTile(locPos, coords);
104             }
105         }
106     }
107 });
108 
109 /**
110  * Creates the action with a range, whether or not to shake Z vertices, a grid size, and duration. <br />
111  * Reference the test cases (Effects Test)
112  * @function
113  * @param {Number} duration
114  * @param {cc.Size} gridSize
115  * @param {Number} range
116  * @param {Boolean} shakeZ
117  * @return {cc.ShakyTiles3D}
118  */
119 cc.shakyTiles3D = function (duration, gridSize, range, shakeZ) {
120     return new cc.ShakyTiles3D(duration, gridSize, range, shakeZ);
121 };
122 
123 /**
124  * Please use cc.shakyTiles3D instead. <br />
125  * creates the action with a range, whether or not to shake Z vertices, a grid size, and duration. <br />
126  * Reference the test cases (Effects Test)
127  * @param {Number} duration
128  * @param {cc.Size} gridSize
129  * @param {Number} range
130  * @param {Boolean} shakeZ
131  * @return {cc.ShakyTiles3D}
132  * @static
133  * @deprecated since v3.0 <br /> Please use cc.shakyTiles3D instead.
134  */
135 cc.ShakyTiles3D.create = cc.shakyTiles3D;
136 
137 /**
138  * cc.ShatteredTiles3D action. <br />
139  * Reference the test cases (Effects Test)
140  * @class
141  * @extends cc.TiledGrid3DAction
142  * @param {Number} duration
143  * @param {cc.Size} gridSize
144  * @param {Number} range
145  * @param {Boolean} shatterZ
146  */
147 cc.ShatteredTiles3D = cc.TiledGrid3DAction.extend(/** @lends cc.ShatteredTiles3D# */{
148     _randRange:0,
149     _once:false,
150     _shatterZ:false,
151 
152 	/**
153      * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
154 	 * Creates the action with a range, whether of not to shatter Z vertices, a grid size and duration.
155 	 * @param {Number} duration
156 	 * @param {cc.Size} gridSize
157 	 * @param {Number} range
158 	 * @param {Boolean} shatterZ
159 	 */
160     ctor:function (duration, gridSize, range, shatterZ) {
161         cc.GridAction.prototype.ctor.call(this);
162 		shatterZ !== undefined && this.initWithDuration(duration, gridSize, range, shatterZ);
163     },
164 
165     /**
166      * Initializes the action with a range, whether or not to shatter Z vertices, a grid size and duration. <br />
167      * @param {Number} duration
168      * @param {cc.Size} gridSize
169      * @param {Number} range
170      * @param {Boolean} shatterZ
171      * @return {Boolean}
172      */
173     initWithDuration:function (duration, gridSize, range, shatterZ) {
174         if (cc.TiledGrid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
175             this._once = false;
176             this._randRange = range;
177             this._shatterZ = shatterZ;
178             return true;
179         }
180         return false;
181     },
182 
183     /**
184      * Called once per frame. Time is the number of seconds of a frame interval. <br />
185      * @param {Number}  dt
186      */
187     update:function (dt) {
188         if (this._once === false) {
189             var locGridSize = this._gridSize, locRandRange = this._randRange;
190             var coords, locPos = cc.p(0, 0);
191             for (var i = 0; i < locGridSize.width; ++i) {
192                 for (var j = 0; j < locGridSize.height; ++j) {
193                     locPos.x = i;
194                     locPos.y = j;
195                     coords = this.originalTile(locPos);
196 
197                     // X
198                     coords.bl.x += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
199                     coords.br.x += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
200                     coords.tl.x += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
201                     coords.tr.x += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
202 
203                     // Y
204                     coords.bl.y += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
205                     coords.br.y += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
206                     coords.tl.y += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
207                     coords.tr.y += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
208 
209                     if (this._shatterZ) {
210                         coords.bl.z += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
211                         coords.br.z += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
212                         coords.tl.z += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
213                         coords.tr.z += ( cc.rand() % (locRandRange * 2) ) - locRandRange;
214                     }
215                     this.setTile(locPos, coords);
216                 }
217             }
218             this._once = true;
219         }
220     }
221 });
222 
223 /**
224  * Creates the action with a range, whether of not to shatter Z vertices, a grid size and duration. <br />
225  * Reference the test cases (Effects Test)
226  * @function
227  * @param {Number} duration
228  * @param {cc.Size} gridSize
229  * @param {Number} range
230  * @param {Boolean} shatterZ
231  * @return {cc.ShatteredTiles3D}
232  */
233 cc.shatteredTiles3D = function (duration, gridSize, range, shatterZ) {
234     return new cc.ShatteredTiles3D(duration, gridSize, range, shatterZ);
235 };
236 
237 /**
238  * Please use cc.shatteredTiles3D instead. <br />
239  * Creates the action with a range, whether of not to shatter Z vertices, a grid size and duration. <br />
240  * Reference the test cases (Effects Test)
241  * @param {Number} duration
242  * @param {cc.Size} gridSize
243  * @param {Number} range
244  * @param {Boolean} shatterZ
245  * @return {cc.ShatteredTiles3D}
246  * @static
247  * @deprecated since v3.0 <br /> Please use cc.shatteredTiles3D instead.
248  */
249 cc.ShatteredTiles3D.create = cc.shatteredTiles3D;
250 
251 /**
252  * A Tile composed of position, startPosition and delta.
253  * @Class
254  * @constructor
255  * @param {cc.Point} [position=cc.p(0,0)]
256  * @param {cc.Point} [startPosition=cc.p(0,0)]
257  * @param {cc.Size} [delta=cc.p(0,0)]
258  */
259 cc.Tile = function (position, startPosition, delta) {
260     this.position = position || cc.p(0,0);
261     this.startPosition = startPosition || cc.p(0,0);
262     this.delta = delta || cc.p(0,0);
263 };
264 
265 /**
266  * cc.ShuffleTiles action, Shuffle the tiles in random order. <br />
267  * Reference the test cases (Effects Test)
268  * @class
269  * @extends cc.TiledGrid3DAction
270  * @param {Number} duration
271  * @param {cc.Size} gridSize
272  * @param {Number} seed
273  */
274 cc.ShuffleTiles = cc.TiledGrid3DAction.extend(/** @lends cc.ShuffleTiles# */{
275     _seed:0,
276     _tilesCount:0,
277     _tilesOrder:null,
278     _tiles:null,
279 
280 	/**
281      * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
282 	 * Creates the action with a random seed, the grid size and the duration.
283 	 * @param {Number} duration
284 	 * @param {cc.Size} gridSize
285 	 * @param {Number} seed
286 	 */
287     ctor:function (duration, gridSize, seed) {
288         cc.GridAction.prototype.ctor.call(this);
289         this._tilesOrder = [];
290         this._tiles = [];
291 
292 		seed !== undefined && this.initWithDuration(duration, gridSize, seed);
293     },
294 
295     /**
296      * Initializes the action with a random seed, the grid size and the duration.
297      * @param {Number} duration
298      * @param {cc.Size} gridSize
299      * @param {Number} seed
300      * @return {Boolean}
301      */
302     initWithDuration:function (duration, gridSize, seed) {
303         if (cc.TiledGrid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
304             this._seed = seed;
305             this._tilesOrder.length = 0;
306             this._tiles.length = 0;
307             return true;
308         }
309         return false;
310     },
311 
312     /**
313      * Shuffle
314      * @param {Array} array
315      * @param {Number} len
316      */
317     shuffle:function (array, len) {
318         for (var i = len - 1; i >= 0; i--) {
319             var j = 0 | (cc.rand() % (i + 1));
320             var v = array[i];
321             array[i] = array[j];
322             array[j] = v;
323         }
324     },
325 
326     /**
327      * Get Delta
328      * @param {cc.Size} pos
329      */
330     getDelta:function (pos) {
331         var locGridSize = this._gridSize;
332         var idx = pos.width * locGridSize.height + pos.height;
333         return cc.size(((this._tilesOrder[idx] / locGridSize.height) - pos.width),
334             ((this._tilesOrder[idx] % locGridSize.height) - pos.height));
335     },
336 
337     /**
338      * Place Tile
339      * @param {cc.Point} pos
340      * @param {cc.Tile} tile
341      */
342     placeTile:function (pos, tile) {
343         var coords = this.originalTile(pos);
344 
345         var step = this.target.grid.getStep();
346         var locPosition = tile.position;
347         coords.bl.x += (locPosition.x * step.x);
348         coords.bl.y += (locPosition.y * step.y);
349 
350         coords.br.x += (locPosition.x * step.x);
351         coords.br.y += (locPosition.y * step.y);
352 
353         coords.tl.x += (locPosition.x * step.x);
354         coords.tl.y += (locPosition.y * step.y);
355 
356         coords.tr.x += (locPosition.x * step.x);
357         coords.tr.y += (locPosition.y * step.y);
358 
359         this.setTile(pos, coords);
360     },
361 
362     /**
363      * Start with target
364      * @param {cc.Node} target
365      */
366     startWithTarget:function (target) {
367         cc.TiledGrid3DAction.prototype.startWithTarget.call(this, target);
368         var locGridSize = this._gridSize;
369 
370         this._tilesCount = locGridSize.width * locGridSize.height;
371         var locTilesOrder = this._tilesOrder;
372         locTilesOrder.length = 0;
373 
374         /**
375          * Use k to loop. Because m_nTilesCount is unsigned int,
376          * and i is used later for int.
377          */
378         for (var k = 0; k < this._tilesCount; ++k)
379             locTilesOrder[k] = k;
380         this.shuffle(locTilesOrder, this._tilesCount);
381 
382         var locTiles = this._tiles ;
383         locTiles.length = 0;
384         var tileIndex = 0, tempSize = cc.size(0,0);
385         for (var i = 0; i < locGridSize.width; ++i) {
386             for (var j = 0; j < locGridSize.height; ++j) {
387                 locTiles[tileIndex] = new cc.Tile();
388                 locTiles[tileIndex].position = cc.p(i, j);
389                 locTiles[tileIndex].startPosition = cc.p(i, j);
390                 tempSize.width = i;
391                 tempSize.height = j;
392                 locTiles[tileIndex].delta = this.getDelta(tempSize);
393                 ++tileIndex;
394             }
395         }
396     },
397 
398     /**
399      * Called once per frame. Time is the number of seconds of a frame interval.
400      * @param {Number}  dt
401      */
402     update:function (dt) {
403         var tileIndex = 0, locGridSize = this._gridSize, locTiles = this._tiles;
404         var selTile, locPos = cc.p(0, 0);
405         for (var i = 0; i < locGridSize.width; ++i) {
406             for (var j = 0; j < locGridSize.height; ++j) {
407                 locPos.x = i;
408                 locPos.y = j;
409                 selTile = locTiles[tileIndex];
410                 selTile.position.x = selTile.delta.width * dt;
411                 selTile.position.y = selTile.delta.height * dt;
412                 this.placeTile(locPos, selTile);
413                 ++tileIndex;
414             }
415         }
416     }
417 });
418 
419 /**
420  * Creates the action with a random seed, the grid size and the duration. <br />
421  * Reference the test cases (Effects Test)
422  * @function
423  * @param {Number} duration
424  * @param {cc.Size} gridSize
425  * @param {Number} seed
426  * @return {cc.ShuffleTiles}
427  */
428 cc.shuffleTiles = function (duration, gridSize, seed) {
429     return new cc.ShuffleTiles(duration, gridSize, seed);
430 };
431 
432 /**
433  * Please use cc.shuffleTiles instead. <br />
434  * Creates the action with a random seed, the grid size and the duration. <br />
435  * Reference the test cases (Effects Test)
436  * @param {Number} duration
437  * @param {cc.Size} gridSize
438  * @param {Number} seed
439  * @return {cc.ShuffleTiles}
440  * @static
441  * @deprecated since v3.0 <br /> Please use cc.shuffleTiles instead.
442  */
443 cc.ShuffleTiles.create = cc.shuffleTiles;
444 
445 /**
446  * cc.FadeOutTRTiles action. Fades out the tiles in a Top-Right direction. <br />
447  * Reference the test cases (Effects Test)
448  * @class
449  * @extends cc.TiledGrid3DAction
450  */
451 cc.FadeOutTRTiles = cc.TiledGrid3DAction.extend(/** @lends cc.FadeOutTRTiles# */{
452     /**
453      * Test function
454      * @param {cc.Size} pos
455      * @param {Number} time
456      */
457     testFunc:function (pos, time) {
458         var locX = this._gridSize.width * time;
459         var locY = this._gridSize.height * time;
460         if ((locX + locY) == 0.0)
461             return 1.0;
462         return Math.pow((pos.width + pos.height) / (locX + locY), 6);
463     },
464 
465     /**
466      * Turn on Tile
467      * @param {cc.Point} pos
468      */
469     turnOnTile:function (pos) {
470         this.setTile(pos, this.originalTile(pos));
471     },
472 
473     /**
474      * Turn Off Tile
475      * @param {cc.Point} pos
476      */
477     turnOffTile:function (pos) {
478         this.setTile(pos, new cc.Quad3());
479     },
480 
481     /**
482      * Transform tile
483      * @param {cc.Point} pos
484      * @param {Number} distance
485      */
486     transformTile:function (pos, distance) {
487         var coords = this.originalTile(pos);
488         var step = this.target.grid.getStep();
489 
490         coords.bl.x += (step.x / 2) * (1.0 - distance);
491         coords.bl.y += (step.y / 2) * (1.0 - distance);
492 
493         coords.br.x -= (step.x / 2) * (1.0 - distance);
494         coords.br.y += (step.y / 2) * (1.0 - distance);
495 
496         coords.tl.x += (step.x / 2) * (1.0 - distance);
497         coords.tl.y -= (step.y / 2) * (1.0 - distance);
498 
499         coords.tr.x -= (step.x / 2) * (1.0 - distance);
500         coords.tr.y -= (step.y / 2) * (1.0 - distance);
501 
502         this.setTile(pos, coords);
503     },
504 
505     /**
506      * Called once per frame. Time is the number of seconds of a frame interval.
507      * @param {Number}  dt
508      */
509     update:function (dt) {
510         var locGridSize = this._gridSize;
511         var locPos = cc.p(0, 0), locSize = cc.size(0, 0), distance;
512         for (var i = 0; i < locGridSize.width; ++i) {
513             for (var j = 0; j < locGridSize.height; ++j) {
514                 locPos.x = i;
515                 locPos.y = j;
516                 locSize.width = i;
517                 locSize.height = j;
518                 distance = this.testFunc(locSize, dt);
519                 if (distance == 0)
520                     this.turnOffTile(locPos);
521                 else if (distance < 1)
522                     this.transformTile(locPos, distance);
523                 else
524                     this.turnOnTile(locPos);
525             }
526         }
527     }
528 });
529 
530 /**
531  * Creates the action with the grid size and the duration. <br />
532  * Reference the test cases (Effects Test)
533  * @function
534  * @param duration
535  * @param gridSize
536  * @return {cc.FadeOutTRTiles}
537  */
538 cc.fadeOutTRTiles = function (duration, gridSize) {
539     return new cc.FadeOutTRTiles(duration, gridSize);
540 };
541 
542 /**
543  * Please use cc.fadeOutTRTiles instead. <br />
544  * Creates the action with the grid size and the duration. <br />
545  * Reference the test cases (Effects Test)
546  * @param duration
547  * @param gridSize
548  * @return {cc.FadeOutTRTiles}
549  * @static
550  * @deprecated since v3.0 <br /> Please use cc.fadeOutTRTiles instead.
551  */
552 cc.FadeOutTRTiles.create = cc.fadeOutTRTiles;
553 
554 /**
555  * cc.FadeOutBLTiles action. Fades out the tiles in a Bottom-Left direction. <br />
556  * Reference the test cases (Effects Test)
557  * @class
558  * @extends cc.FadeOutTRTiles
559  */
560 cc.FadeOutBLTiles = cc.FadeOutTRTiles.extend(/** @lends cc.FadeOutBLTiles# */{
561     /**
562      * Test function
563      * @param {cc.Size} pos
564      * @param {Number} time
565      */
566     testFunc:function (pos, time) {
567         var locX = this._gridSize.width * (1.0 - time);
568         var locY = this._gridSize.height * (1.0 - time);
569         if ((pos.width + pos.height) == 0)
570             return 1.0;
571 
572         return Math.pow((locX + locY) / (pos.width + pos.height), 6);
573     }
574 });
575 
576 /**
577  * Creates the action with the grid size and the duration. <br />
578  * Reference the test cases (Effects Test)
579  * @function
580  * @param duration
581  * @param gridSize
582  * @return {cc.FadeOutBLTiles}
583  */
584 cc.fadeOutBLTiles = function (duration, gridSize) {
585     return new cc.FadeOutBLTiles(duration, gridSize);
586 };
587 
588 /**
589  * Please use cc.fadeOutBLTiles instead. <br />
590  * Creates the action with the grid size and the duration. <br />
591  * Reference the test cases (Effects Test)
592  * @param duration
593  * @param gridSize
594  * @return {cc.FadeOutBLTiles}
595  * @static
596  * @deprecated since v3.0 <br /> Please use cc.fadeOutBLTiles instead.
597  */
598 cc.FadeOutBLTiles.create = cc.fadeOutBLTiles;
599 
600 /**
601  * cc.FadeOutUpTiles action. Fades out the tiles in upwards direction. <br />
602  * Reference the test cases (Effects Test)
603  * @class
604  * @extends cc.FadeOutTRTiles
605  */
606 cc.FadeOutUpTiles = cc.FadeOutTRTiles.extend(/** @lends cc.FadeOutUpTiles# */{
607     testFunc:function (pos, time) {
608         var locY = this._gridSize.height * time;
609         if (locY == 0.0)
610             return 1.0;
611         return Math.pow(pos.height / locY, 6);
612     },
613 
614     transformTile:function (pos, distance) {
615         var coords = this.originalTile(pos);
616         var step = this.target.grid.getStep();
617 
618         coords.bl.y += (step.y / 2) * (1.0 - distance);
619         coords.br.y += (step.y / 2) * (1.0 - distance);
620         coords.tl.y -= (step.y / 2) * (1.0 - distance);
621         coords.tr.y -= (step.y / 2) * (1.0 - distance);
622 
623         this.setTile(pos, coords);
624     }
625 });
626 
627 /**
628  * Creates the action with the grid size and the duration. <br />
629  * Reference the test cases (Effects Test)
630  * @function
631  * @param {Number} duration
632  * @param {cc.Size} gridSize
633  * @return {cc.FadeOutUpTiles}
634  */
635 cc.fadeOutUpTiles = function (duration, gridSize) {
636     return new cc.FadeOutUpTiles(duration, gridSize);
637 };
638 
639 /**
640  * Please use cc.fadeOutUpTiles instead. <br />
641  * Creates the action with the grid size and the duration. <br />
642  * Reference the test cases (Effects Test)
643  * @param {Number} duration
644  * @param {cc.Size} gridSize
645  * @return {cc.FadeOutUpTiles}
646  * @static
647  * @deprecated since v3.0 <br /> Please use cc.fadeOutUpTiles instead.
648  */
649 cc.FadeOutUpTiles.create = cc.fadeOutUpTiles;
650 
651 /**
652  * cc.FadeOutDownTiles action. Fades out the tiles in downwards direction. <br />
653  * Reference the test cases (Effects Test)
654  * @class
655  * @extends cc.FadeOutUpTiles
656  */
657 cc.FadeOutDownTiles = cc.FadeOutUpTiles.extend(/** @lends cc.FadeOutDownTiles# */{
658     testFunc:function (pos, time) {
659         var locY = this._gridSize.height * (1.0 - time);
660         if (pos.height == 0)
661             return 1.0;
662         return Math.pow(locY / pos.height, 6);
663     }
664 });
665 
666 /**
667  * Creates the action with the grid size and the duration. <br />
668  * Reference the test cases (Effects Test)
669  * @function
670  * @param {Number} duration
671  * @param {cc.Size} gridSize
672  * @return {cc.FadeOutDownTiles}
673  */
674 cc.fadeOutDownTiles = function (duration, gridSize) {
675     return new cc.FadeOutDownTiles(duration, gridSize);
676 };
677 /**
678  * Please use cc.fadeOutDownTiles instead. <br />
679  * Creates the action with the grid size and the duration. <br />
680  * Reference the test cases (Effects Test)
681  * @param {Number} duration
682  * @param {cc.Size} gridSize
683  * @return {cc.FadeOutDownTiles}
684  * @static
685  * @deprecated since v3.0 <br /> Please use cc.fadeOutDownTiles instead.
686  */
687 cc.FadeOutDownTiles.create = cc.fadeOutDownTiles;
688 
689 /**
690  * cc.TurnOffTiles action.<br/>
691  * Turn off the files in random order. <br />
692  * Reference the test cases (Effects Test)
693  * @class
694  * @extends cc.TiledGrid3DAction
695  * @param {Number} duration
696  * @param {cc.Size} gridSize
697  * @param {Number|Null} [seed=0]
698  * @example
699  * // turnOffTiles without seed
700  * var toff = new cc.TurnOffTiles(this._duration, cc.size(x, y));
701  *
702  * // turnOffTiles with seed
703  * var toff = new cc.TurnOffTiles(this._duration, cc.size(x, y), 0);
704  */
705 cc.TurnOffTiles = cc.TiledGrid3DAction.extend(/** @lends cc.TurnOffTiles# */{
706     _seed:null,
707     _tilesCount:0,
708     _tilesOrder:null,
709 
710 	/**
711      * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
712 	 * Creates the action with a random seed, the grid size and the duration.
713 	 * @param {Number} duration
714 	 * @param {cc.Size} gridSize
715 	 * @param {Number|Null} [seed=0]
716 	 */
717     ctor:function (duration, gridSize, seed) {
718         cc.GridAction.prototype.ctor.call(this);
719         this._tilesOrder = [];
720 
721 		gridSize !== undefined && this.initWithDuration(duration, gridSize, seed);
722     },
723 
724     /**
725      * Initializes the action with a random seed, the grid size and the duration.
726      * @param {Number} duration
727      * @param {cc.Size} gridSize
728      * @param {Number|Null} [seed=0]
729      * @return {Boolean}
730      */
731     initWithDuration:function (duration, gridSize, seed) {
732         if (cc.TiledGrid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
733             this._seed = seed || 0;
734             this._tilesOrder.length = 0;
735             return true;
736         }
737         return false;
738     },
739 
740     /**
741      * Shuffle
742      * @param {Array} array
743      * @param {Number} len
744      */
745     shuffle:function (array, len) {
746         for (var i = len - 1; i >= 0; i--) {
747             var j = 0 | (cc.rand() % (i + 1));
748             var v = array[i];
749             array[i] = array[j];
750             array[j] = v;
751         }
752     },
753 
754     /**
755      * Turn on tile.
756      * @param {cc.Point} pos
757      */
758     turnOnTile:function (pos) {
759         this.setTile(pos, this.originalTile(pos));
760     },
761 
762     /**
763      * Turn off title.
764      * @param {cc.Point} pos
765      */
766     turnOffTile:function (pos) {
767         this.setTile(pos, new cc.Quad3());
768     },
769 
770     /**
771      * called before the action start. It will also set the target.
772      * @param {cc.Node} target
773      */
774     startWithTarget:function (target) {
775         cc.TiledGrid3DAction.prototype.startWithTarget.call(this, target);
776 
777         this._tilesCount = this._gridSize.width * this._gridSize.height;
778         var locTilesOrder = this._tilesOrder;
779         locTilesOrder.length = 0;
780         for (var i = 0; i < this._tilesCount; ++i)
781             locTilesOrder[i] = i;
782         this.shuffle(locTilesOrder, this._tilesCount);
783     },
784 
785     /**
786      * Called once per frame. Time is the number of seconds of a frame interval.
787      * @param {Number}  dt
788      */
789     update:function (dt) {
790         var l = 0 | (dt * this._tilesCount), locGridSize = this._gridSize;
791         var t,tilePos = cc.p(0,0), locTilesOrder = this._tilesOrder;
792         for (var i = 0; i < this._tilesCount; i++) {
793             t = locTilesOrder[i];
794             tilePos.x = 0 | (t / locGridSize.height);
795             tilePos.y = t % (0 | locGridSize.height);
796             if (i < l)
797                 this.turnOffTile(tilePos);
798             else
799                 this.turnOnTile(tilePos);
800         }
801     }
802 });
803 
804 /**
805  * Creates the action with a random seed, the grid size and the duration. <br />
806  * Reference the test cases (Effects Test)
807  * @function
808  * @param {Number} duration
809  * @param {cc.Size} gridSize
810  * @param {Number|Null} [seed=0]
811  * @return {cc.TurnOffTiles}
812  * @example
813  * // example
814  * // turnOffTiles without seed
815  * var toff = cc.turnOffTiles(this._duration, cc.size(x, y));
816  *
817  * // turnOffTiles with seed
818  * var toff = cc.turnOffTiles(this._duration, cc.size(x, y), 0);
819  */
820 cc.turnOffTiles = function (duration, gridSize, seed) {
821     return new cc.TurnOffTiles(duration, gridSize, seed);
822 };
823 /**
824  * Please use cc.turnOffTiles instead. <br />
825  * Creates the action with a random seed, the grid size and the duration. <br />
826  * Reference the test cases (Effects Test)
827  * @param {Number} duration
828  * @param {cc.Size} gridSize
829  * @param {Number|Null} [seed=0]
830  * @return {cc.TurnOffTiles}
831  * @static
832  * @deprecated since v3.0 <br /> Please use cc.turnOffTiles instead.
833  */
834 cc.TurnOffTiles.create = cc.turnOffTiles;
835 
836 /**
837  * cc.WavesTiles3D action. <br />
838  * Reference the test cases (Effects Test)
839  * @class
840  * @extends cc.TiledGrid3DAction
841  * @param {Number} duration
842  * @param {cc.Size} gridSize
843  * @param {Number} waves
844  * @param {Number} amplitude
845  */
846 cc.WavesTiles3D = cc.TiledGrid3DAction.extend(/** @lends cc.WavesTiles3D# */{
847     _waves:0,
848     _amplitude:0,
849     _amplitudeRate:0,
850 
851 	/**
852      * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
853 	 * creates the action with a number of waves, the waves amplitude, the grid size and the duration.
854 	 * @param {Number} duration
855 	 * @param {cc.Size} gridSize
856 	 * @param {Number} waves
857 	 * @param {Number} amplitude
858 	 */
859     ctor:function (duration, gridSize, waves, amplitude) {
860         cc.GridAction.prototype.ctor.call(this);
861 		amplitude !== undefined && this.initWithDuration(duration, gridSize, waves, amplitude);
862     },
863 
864     /**
865      * get amplitude of waves
866      * @return {Number}
867      */
868     getAmplitude:function () {
869         return this._amplitude;
870     },
871 
872     /**
873      * set amplitude of waves
874      * @param {Number} amplitude
875      */
876     setAmplitude:function (amplitude) {
877         this._amplitude = amplitude;
878     },
879 
880     /**
881      * get amplitude rate of waves
882      * @return {Number}
883      */
884     getAmplitudeRate:function () {
885         return this._amplitudeRate;
886     },
887 
888     /**
889      * set amplitude rate of waves
890      * @param {Number} amplitudeRate
891      */
892     setAmplitudeRate:function (amplitudeRate) {
893         this._amplitudeRate = amplitudeRate;
894     },
895 
896     /**
897      * initializes the action with a number of waves, the waves amplitude, the grid size and the duration
898      * @param {Number} duration
899      * @param {cc.Size} gridSize
900      * @param {Number} waves
901      * @param {Number} amplitude
902      * @return {Boolean}
903      */
904     initWithDuration:function (duration, gridSize, waves, amplitude) {
905         if (cc.TiledGrid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
906             this._waves = waves;
907             this._amplitude = amplitude;
908             this._amplitudeRate = 1.0;
909             return true;
910         }
911         return false;
912     },
913 
914     /**
915      * Called once per frame. Time is the number of seconds of a frame interval.
916      * @param {Number}  dt
917      */
918     update:function (dt) {
919         var locGridSize = this._gridSize, locWaves = this._waves, locAmplitude = this._amplitude, locAmplitudeRate = this._amplitudeRate;
920         var locPos = cc.p(0, 0), coords;
921         for (var i = 0; i < locGridSize.width; i++) {
922             for (var j = 0; j < locGridSize.height; j++) {
923                 locPos.x = i;
924                 locPos.y = j;
925                 coords = this.originalTile(locPos);
926                 coords.bl.z = (Math.sin(dt * Math.PI * locWaves * 2 +
927                     (coords.bl.y + coords.bl.x) * 0.01) * locAmplitude * locAmplitudeRate);
928                 coords.br.z = coords.bl.z;
929                 coords.tl.z = coords.bl.z;
930                 coords.tr.z = coords.bl.z;
931                 this.setTile(locPos, coords);
932             }
933         }
934     }
935 });
936 
937 /**
938  * creates the action with a number of waves, the waves amplitude, the grid size and the duration. <br />
939  * Reference the test cases (Effects Test)
940  * @function
941  * @param {Number} duration
942  * @param {cc.Size} gridSize
943  * @param {Number} waves
944  * @param {Number} amplitude
945  * @return {cc.WavesTiles3D}
946  */
947 cc.wavesTiles3D = function (duration, gridSize, waves, amplitude) {
948     return new cc.WavesTiles3D(duration, gridSize, waves, amplitude);
949 };
950 /**
951  * Please use cc.wavesTiles3D instead
952  * creates the action with a number of waves, the waves amplitude, the grid size and the duration. <br />
953  * Reference the test cases (Effects Test)
954  * @param {Number} duration
955  * @param {cc.Size} gridSize
956  * @param {Number} waves
957  * @param {Number} amplitude
958  * @return {cc.WavesTiles3D}
959  * @static
960  * @deprecated since v3.0 <br /> Please use cc.wavesTiles3D instead.
961  */
962 cc.WavesTiles3D.create = cc.wavesTiles3D;
963 
964 /**
965  * cc.JumpTiles3D action.  A sin function is executed to move the tiles across the Z axis. <br />
966  * Reference the test cases (Effects Test)
967  * @class
968  * @extends cc.TiledGrid3DAction
969  * @param {Number} duration
970  * @param {cc.Size} gridSize
971  * @param {Number} numberOfJumps
972  * @param {Number} amplitude
973  */
974 cc.JumpTiles3D = cc.TiledGrid3DAction.extend(/** @lends cc.JumpTiles3D# */{
975     _jumps:0,
976     _amplitude:0,
977     _amplitudeRate:0,
978 
979 	/**
980      * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
981 	 * creates the action with the number of jumps, the sin amplitude, the grid size and the duration.
982 	 * @param {Number} duration
983 	 * @param {cc.Size} gridSize
984 	 * @param {Number} numberOfJumps
985 	 * @param {Number} amplitude
986 	 */
987     ctor:function (duration, gridSize, numberOfJumps, amplitude) {
988         cc.GridAction.prototype.ctor.call(this);
989 		amplitude !== undefined && this.initWithDuration(duration, gridSize, numberOfJumps, amplitude);
990     },
991 
992     /**
993      * get amplitude of the sin
994      * @return {Number}
995      */
996     getAmplitude:function () {
997         return this._amplitude;
998     },
999 
1000     /**
1001      * set amplitude of the sin
1002      * @param {Number} amplitude
1003      */
1004     setAmplitude:function (amplitude) {
1005         this._amplitude = amplitude;
1006     },
1007 
1008     /**
1009      * get amplitude rate
1010      * @return {Number}
1011      */
1012     getAmplitudeRate:function () {
1013         return this._amplitudeRate;
1014     },
1015 
1016     /**
1017      * set amplitude rate
1018      * @param amplitudeRate
1019      */
1020     setAmplitudeRate:function (amplitudeRate) {
1021         this._amplitudeRate = amplitudeRate;
1022     },
1023 
1024     /**
1025      * initializes the action with the number of jumps, the sin amplitude, the grid size and the duration
1026      * @param {Number} duration
1027      * @param {cc.Size} gridSize
1028      * @param {Number} numberOfJumps
1029      * @param {Number} amplitude
1030      */
1031     initWithDuration:function (duration, gridSize, numberOfJumps, amplitude) {
1032         if (cc.TiledGrid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
1033             this._jumps = numberOfJumps;
1034             this._amplitude = amplitude;
1035             this._amplitudeRate = 1.0;
1036             return true;
1037         }
1038         return false;
1039     },
1040 
1041     /**
1042      * Called once per frame. Time is the number of seconds of a frame interval.
1043      * @param {Number}  dt
1044      */
1045     update:function (dt) {
1046         var sinz = (Math.sin(Math.PI * dt * this._jumps * 2) * this._amplitude * this._amplitudeRate );
1047         var sinz2 = (Math.sin(Math.PI * (dt * this._jumps * 2 + 1)) * this._amplitude * this._amplitudeRate );
1048 
1049         var locGridSize = this._gridSize;
1050         var locGrid = this.target.grid;
1051         var coords, locPos = cc.p(0, 0);
1052         for (var i = 0; i < locGridSize.width; i++) {
1053             for (var j = 0; j < locGridSize.height; j++) {
1054                 locPos.x = i;
1055                 locPos.y = j;
1056                 //hack for html5
1057                 //var coords = this.originalTile(cc.p(i, j));
1058                 coords = locGrid.originalTile(locPos);
1059 
1060                 if (((i + j) % 2) == 0) {
1061                     coords.bl.z += sinz;
1062                     coords.br.z += sinz;
1063                     coords.tl.z += sinz;
1064                     coords.tr.z += sinz;
1065                 } else {
1066                     coords.bl.z += sinz2;
1067                     coords.br.z += sinz2;
1068                     coords.tl.z += sinz2;
1069                     coords.tr.z += sinz2;
1070                 }
1071                 //hack for html5
1072                 //this.setTile(cc.p(i, j), coords);
1073                 locGrid.setTile(locPos, coords);
1074             }
1075         }
1076     }
1077 });
1078 
1079 /**
1080  * creates the action with the number of jumps, the sin amplitude, the grid size and the duration. <br />
1081  * Reference the test cases (Effects Test)
1082  * @function
1083  * @param {Number} duration
1084  * @param {cc.Size} gridSize
1085  * @param {Number} numberOfJumps
1086  * @param {Number} amplitude
1087  * @return {cc.JumpTiles3D}
1088  */
1089 cc.jumpTiles3D = function (duration, gridSize, numberOfJumps, amplitude) {
1090     return new cc.JumpTiles3D(duration, gridSize, numberOfJumps, amplitude);
1091 };
1092 
1093 /**
1094  * Please use cc.jumpTiles3D instead
1095  * creates the action with the number of jumps, the sin amplitude, the grid size and the duration. <br />
1096  * Reference the test cases (Effects Test)
1097  * @param {Number} duration
1098  * @param {cc.Size} gridSize
1099  * @param {Number} numberOfJumps
1100  * @param {Number} amplitude
1101  * @return {cc.JumpTiles3D}
1102  * @static
1103  * @deprecated since v3.0 <br /> Please use cc.jumpTiles3D instead.
1104  */
1105 cc.JumpTiles3D.create = cc.jumpTiles3D;
1106 
1107 /**
1108  * cc.SplitRows action. <br />
1109  * Reference the test cases (Effects Test)
1110  * @class
1111  * @extends cc.TiledGrid3DAction
1112  * @param {Number} duration
1113  * @param {Number} rows
1114  */
1115 cc.SplitRows = cc.TiledGrid3DAction.extend(/** @lends cc.SplitRows# */{
1116     _rows:0,
1117     _winSize:null,
1118 
1119 	/**
1120      * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
1121 	 * creates the action with the number of rows to split and the duration.
1122 	 * @param {Number} duration
1123 	 * @param {Number} rows
1124 	 */
1125     ctor:function (duration, rows) {
1126         cc.GridAction.prototype.ctor.call(this);
1127 		rows !== undefined && this.initWithDuration(duration, rows);
1128     },
1129 
1130     /**
1131      * initializes the action with the number of rows to split and the duration
1132      * @param {Number} duration
1133      * @param {Number} rows
1134      * @return {Boolean}
1135      */
1136     initWithDuration:function (duration, rows) {
1137         this._rows = rows;
1138         return cc.TiledGrid3DAction.prototype.initWithDuration.call(this, duration, cc.size(1, rows));
1139     },
1140 
1141     /**
1142      * Called once per frame. Time is the number of seconds of a frame interval.
1143      * @param {Number}  dt
1144      */
1145     update:function (dt) {
1146         var locGridSize = this._gridSize, locWinSizeWidth = this._winSize.width;
1147         var coords, direction, locPos = cc.p(0, 0);
1148         for (var j = 0; j < locGridSize.height; ++j) {
1149             locPos.y = j;
1150             coords = this.originalTile(locPos);
1151             direction = 1;
1152 
1153             if ((j % 2 ) == 0)
1154                 direction = -1;
1155 
1156             coords.bl.x += direction * locWinSizeWidth * dt;
1157             coords.br.x += direction * locWinSizeWidth * dt;
1158             coords.tl.x += direction * locWinSizeWidth * dt;
1159             coords.tr.x += direction * locWinSizeWidth * dt;
1160 
1161             this.setTile(locPos, coords);
1162         }
1163     },
1164 
1165     /**
1166      * called before the action start. It will also set the target.
1167      * @param {cc.Node} target
1168      */
1169     startWithTarget:function (target) {
1170         cc.TiledGrid3DAction.prototype.startWithTarget.call(this, target);
1171         this._winSize = cc.director.getWinSizeInPixels();
1172     }
1173 });
1174 
1175 /**
1176  * creates the action with the number of rows to split and the duration. <br />
1177  * Reference the test cases (Effects Test)
1178  * @function
1179  * @param {Number} duration
1180  * @param {Number} rows
1181  * @return {cc.SplitRows}
1182  */
1183 cc.splitRows = function (duration, rows) {
1184     return new cc.SplitRows(duration, rows);
1185 };
1186 
1187 /**
1188  * Please use cc.splitRows instead
1189  * creates the action with the number of rows to split and the duration. <br />
1190  * Reference the test cases (Effects Test)
1191  * @param {Number} duration
1192  * @param {Number} rows
1193  * @return {cc.SplitRows}
1194  * @static
1195  * @deprecated since v3.0 <br /> Please use cc.splitRows instead.
1196  */
1197 cc.SplitRows.create = cc.splitRows;
1198 
1199 /**
1200  * cc.SplitCols action. <br />
1201  * Reference the test cases (Effects Test)
1202  * @class
1203  * @extends cc.TiledGrid3DAction
1204  * @param {Number} duration
1205  * @param {Number} cols
1206  */
1207 cc.SplitCols = cc.TiledGrid3DAction.extend(/** @lends cc.SplitCols# */{
1208     _cols:0,
1209     _winSize:null,
1210 
1211 	/**
1212      * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
1213 	 * Creates the action with the number of columns to split and the duration.
1214 	 * @param {Number} duration
1215 	 * @param {Number} cols
1216 	 */
1217     ctor:function (duration, cols) {
1218         cc.GridAction.prototype.ctor.call(this);
1219 		cols !== undefined && this.initWithDuration(duration, cols);
1220     },
1221     /**
1222      * initializes the action with the number of columns to split and the duration
1223      * @param {Number} duration
1224      * @param {Number} cols
1225      * @return {Boolean}
1226      */
1227     initWithDuration:function (duration, cols) {
1228         this._cols = cols;
1229         return cc.TiledGrid3DAction.prototype.initWithDuration.call(this, duration, cc.size(cols, 1));
1230     },
1231 
1232     /**
1233      * Called once per frame. Time is the number of seconds of a frame interval.
1234      * @param {Number}  dt
1235      */
1236     update:function (dt) {
1237         var locGridSizeWidth = this._gridSize.width, locWinSizeHeight = this._winSize.height;
1238         var coords, direction, locPos = cc.p(0, 0);
1239         for (var i = 0; i < locGridSizeWidth; ++i) {
1240             locPos.x = i;
1241             coords = this.originalTile(locPos);
1242             direction = 1;
1243 
1244             if ((i % 2 ) == 0)
1245                 direction = -1;
1246 
1247             coords.bl.y += direction * locWinSizeHeight * dt;
1248             coords.br.y += direction * locWinSizeHeight * dt;
1249             coords.tl.y += direction * locWinSizeHeight * dt;
1250             coords.tr.y += direction * locWinSizeHeight * dt;
1251 
1252             this.setTile(locPos, coords);
1253         }
1254     },
1255 
1256     /**
1257      * called before the action start. It will also set the target.
1258      * @param {cc.Node} target
1259      */
1260     startWithTarget:function (target) {
1261         cc.TiledGrid3DAction.prototype.startWithTarget.call(this, target);
1262         this._winSize = cc.director.getWinSizeInPixels();
1263     }
1264 });
1265 
1266 /**
1267  * creates the action with the number of columns to split and the duration.  <br />
1268  * Reference the test cases (Effects Test)
1269  * @function
1270  * @param {Number} duration
1271  * @param {Number} cols
1272  * @return {cc.SplitCols}
1273  */
1274 cc.splitCols = function (duration, cols) {
1275     return new cc.SplitCols(duration, cols);
1276 };
1277 
1278 /**
1279  * Please use cc.splitCols instead.
1280  * creates the action with the number of columns to split and the duration.  <br />
1281  * Reference the test cases (Effects Test)
1282  * @param {Number} duration
1283  * @param {Number} cols
1284  * @return {cc.SplitCols}
1285  * @static
1286  * @deprecated since v3.0 <br /> Please use cc.splitCols instead.
1287  */
1288 cc.SplitCols.create = cc.splitCols;