@makefully/platypus 4.1.4 → 4.1.6

package/src/components/LogicTimer.js

@@ -0,0 +1,178 @@
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.LogicTimer.prototype */{
+        id: 'LogicTimer',
+
+        properties: {
+            /**
+             * The starting time for the timer.
+             *
+             * @property time
+             * @type Number
+             * @default 0
+             */
+            time: 0,
+
+            /**
+             * The time when the alarm will trigger the alarm message. Defaults to `0``, which never triggers the alarm.
+             *
+             * @property alarmTime
+             * @type Number
+             * @default 0
+             */
+            alarmTime: 0,
+
+            /**
+             * Whether or not the alarm fires at intervals of the alarmTime.
+             *
+             * @property isInterval
+             * @type Boolean
+             * @default false
+             */
+            isInterval: false,
+
+            /**
+             * The message sent when the alarm goes off.
+             *
+             * @property alarmMessage
+             * @type String
+             * @default ''
+             */
+            alarmMessage: '',
+
+            /**
+             * The message sent when the timer updates.
+             *
+             * @property updateMessage
+             * @type String
+             * @default ''
+             */
+            updateMessage: '',
+
+            /**
+             * Whether the alarm starts on.
+             *
+             * @property isOn
+             * @type Boolean
+             * @default true
+             */
+            isOn: true,
+
+            /**
+             * Whether the timer is incrementing or decrementing. If the value is `false` it is decrementing.
+             *
+             * @property isIncrementing
+             * @type Boolean
+             * @default true
+             */
+            isIncrementing: true,
+
+            /**
+             * The max value in MS, positive or negative, that the timer will count to. Once reached, it stops counting. Defaults to one hour.
+             *
+             * @property maxTime
+             * @type Number
+             * @default 3600000
+             */
+            maxTime: 3600000,
+
+            /**
+             * Whether this alarm should reset to full initial time if restarted after being stopped.
+             *
+             * @property resetOnStop
+             * @type Boolean
+             * @default false
+             */
+            resetOnStop: false
+        },
+
+        /**
+         * A timer that can used to trigger events. The timer can increment and decrement. It can be an interval timer, going off over and over. Has a max time which it will not exceed by default this is 1 hour.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @listens platypus.Entity#handle-logic
+         * @listens platypus.Entity#set-timer
+         * @listens platypus.Entity#start-timer
+         * @listens platypus.Entity#stop-timer
+         */
+        initialize: function () {
+            this.prevTime = this.time;
+        },
+
+        events: {
+            "handle-logic": function (tick) {
+                if (this.isOn) {
+                    this.prevTime = this.time;
+                    if (this.isIncrementing) {
+                        this.time += tick.delta;
+                    } else {
+                        this.time -= tick.delta;
+                    }
+                    
+                    if (Math.abs(this.time) > this.maxTime) {
+                        //If the timer hits the max time we turn it off so we don't overflow anything.
+                        if (this.time > 0) {
+                            this.time = this.maxTime;
+                        } else if (this.time < 0) {
+                            this.time = -this.maxTime;
+                        }
+                        this.triggerEvent('stop-timer');
+                    }
+                    
+                    if (this.alarmTime !== 0) {
+                        if (this.isInterval) {
+                            if (this.isIncrementing) {
+                                if (Math.floor(this.time / this.alarmTime) > Math.floor(this.prevTime / this.alarmTime)) {
+                                    this.owner.trigger(this.alarmMessage);
+                                }
+                            } else if (Math.floor(this.time / this.alarmTime) < Math.floor(this.prevTime / this.alarmTime)) {
+                                this.owner.trigger(this.alarmMessage);
+                            }
+                        } else if (this.isIncrementing) {
+                            if (this.time > this.alarmTime && this.prevTime < this.alarmTime) {
+                                this.owner.trigger(this.alarmMessage);
+                            }
+                        } else if (this.time < this.alarmTime && this.prevTime > this.alarmTime) {
+                            this.owner.trigger(this.alarmMessage);
+                        }
+                    }
+                }
+                this.owner.trigger(this.updateMessage, {time: this.time});
+            },
+
+            /**
+             * Sets time for alarm.
+             *
+             * @event platypus.Entity#set-timer
+             * @param {Number} data.time Time to set for alarm.
+             */
+            "set-timer": function (data) {
+                this.time = data.time;
+            },
+
+            /**
+             * Starts the timer's countdown.
+             *
+             * @event platypus.Entity#start-timer
+             */
+            "start-timer": function () {
+                this.isOn = true;
+            },
+
+            /**
+             * Stops the timer's countdown. If `resetOnStop` is `true`, resets timer.
+             *
+             * @event platypus.Entity#stop-timer
+             */
+            "stop-timer": function () {
+                this.isOn = false;
+                if (this.resetOnStop) {
+                    this.time = 0;
+                }
+            }
+        }
+    });
+}());

package/src/components/LogicWindUpRacer.js

@@ -0,0 +1,179 @@
+import createComponentClass from '../factory.js';
+
+export default (function () {
+    return createComponentClass(/** @lends platypus.components.LogicWindUpRacer.prototype */{
+        
+        id: 'LogicWindUpRacer',
+        
+        properties: {
+            /**
+             * Velocity at which the entity should travel while racing.
+             *
+             * @property speed
+             * @type Number
+             * @default 0.3
+             */
+            speed: 0.3,
+            
+            /**
+             * Time in milliseconds that entity will race before coming to a stop.
+             *
+             * @property raceTime
+             * @type Number
+             * @default 5000
+             */
+            raceTime: 5000,
+            
+            /**
+             * Time in milliseconds that entity needs to receive wind-up calls before racing can begin.
+             *
+             * @property windTime
+             * @type Number
+             * @default 500
+             */
+            windTime: 500
+        },
+        
+        /**
+         * Replicates logic for a wind-up toy: listens for a wind-up message over a series of ticks to charge, and then begins racing once the charge is complete.
+         *
+         * @memberof platypus.components
+         * @uses platypus.Component
+         * @constructs
+         * @listens platypus.Entity#handle-logic
+         * @listens platypus.Entity#hit-solid
+         * @listens platypus.Entity#stop-racing
+         * @listens platypus.Entity#wind-up
+         * @fires platypus.Entity#racing
+         * @fires platypus.Entity#stopped-racing
+         * @fires platypus.Entity#winding
+         * @fires platypus.Entity#stopped-winding
+         * @fires platypus.Entity#blocked
+         */
+        initialize: function () {
+            const
+                {state} = this.owner;
+            
+            this.windProgress = 0;
+            
+            this.winding = false;
+            this.racing = false;
+            this.blocked = false;
+            this.right = false;
+            this.left = false;
+            
+            this.state = state;
+            state.set('windingUp', false);
+            state.set('racing', false);
+            state.set('blocked', false);
+        },
+
+        events: {
+            "handle-logic": function (resp) {
+                const
+                    {state} = this;
+                
+                if (this.racing) {
+
+                    /**
+                     * This event is triggered when winding is finished and the entity begins racing.
+                     *
+                     * @event platypus.Entity#racing
+                     */
+                    if (!this.blocked && this.right && state.get('right')) {
+                        this.owner.x += this.speed * resp.delta;
+                        this.owner.triggerEvent('racing');
+                    } else if (!this.blocked && this.left && state.get('left')) {
+                        this.owner.x -= this.speed * resp.delta;
+                        this.owner.triggerEvent('racing');
+                    } else {
+                        this.racing = false;
+
+                        /**
+                         * This event is triggered when the entity stops racing.
+                         *
+                         * @event platypus.Entity#stopped-racing
+                         */
+                        this.owner.triggerEvent('stopped-racing');
+                    }
+                } else if (this.winding) {
+                    if ((this.right && state.get('right')) || (this.left && state.get('left'))) {
+                        this.windProgress += resp.delta;
+                    }
+
+                    /**
+                     * This event is triggered as the entity winds up.
+                     *
+                     * @event platypus.Entity#winding
+                     * @param fraction {Number} The amount of progress that has been made from 0 to 1.
+                     */
+                    this.owner.triggerEvent('winding', this.windProgress / this.windTime);
+                } else if (this.windProgress) {
+                    if (this.windProgress >= this.windTime) {
+                        this.racing = true;
+                    }
+                    this.windProgress = 0;
+
+                    /**
+                     * This event is triggered when the entity stops winding.
+                     *
+                     * @event platypus.Entity#stopped-winding
+                     */
+                    this.owner.triggerEvent('stopped-winding');
+                }
+                
+                state.set('windingUp', this.winding);
+                state.set('racing', this.racing);
+                state.set('blocked', this.blocked);
+                this.blocked = false;
+            },
+            
+            /**
+             * Causes the entity to stop racing.
+             *
+             * @event platypus.Entity#stop-racing
+             */
+            "stop-racing": function () {
+                this.racing = false;
+                this.owner.triggerEvent('stopped-racing');
+            },
+            
+            /**
+             * Causes the entity to wind up for a race.
+             *
+             * @event platypus.Entity#wind-up
+             * @param message.pressed {Boolean} If `message` is included, the component checks the value of `pressed`: `false` causes winding to stop.
+             */
+            "wind-up": function (value) {
+                this.winding = !value || (value.pressed !== false);
+                this.right = this.state.get('right');
+                this.left  = this.state.get('left');
+            },
+            
+            "hit-solid": function (collision) {
+                if (collision.x) {
+                    if (this.racing && ((this.right && (collision.x > 0)) || (this.left && (collision.x < 0)))) {
+                        this.blocked = true;
+                        
+                        /**
+                         * This message is triggered if the entity collides while racing.
+                         *
+                         * @event platypus.Entity#blocked
+                         * @param collision {platypus.CollisionData} Collision information from the entity or tile that blocked movement.
+                         */
+                        this.owner.triggerEvent('blocked', collision);
+                    }
+                }
+            }
+        },
+    
+        methods: {
+            destroy: function () {
+                this.state.set('windingUp', false);
+                this.state.set('racing', false);
+                this.state.set('blocked', false);
+                this.state = null;
+            }
+        }
+    });
+}());