Printable View
I was watching this video, which is very interesting http://www.youtube.com/watch?v=Fy0aCDmgnxg
At about minute 4 in the video they show this formula I have in the title. How would this be translated to an event in MMF? Many of these effects are very cool, especially the one where the ball hits the walls and they "bounch" on the impact. I wonder how these could be translated to mmf code.
+= (stuff) just means Set X to X + (stuff) or Add to X (stuff).
This formula has something to do with easing object so they move smoothly instead of stopping and starting abrubtlyQuote:
Originally Posted by SolarB
Plugged it into MMF2, with a Target value of 50 and an initial X value of 0.
0
10
18
24.4
29.52
33.616
36.8928
39.5142
41.6114
43.2891
44.6313
45.705
46.564
47.2512
47.801
48.2408
48.5926
48.8741
49.0993
49.2794
49.4235
49.5388
49.6311
49.7049
49.7639
49.8111
49.8489
49.8791
49.9033
49.9226
49.9381
49.9505
49.9604
49.9683
49.9746
49.9797
49.9838
49.987
49.9896
49.9917
49.9934
49.9947
49.9957
49.9966
49.9973
49.9978
49.9983
49.9986
49.9989
49.9991
49.9993
49.9994
49.9995
49.9996
49.9997
49.9998
49.9998
49.9999
49.9999
49.9999
49.9999
49.9999
50
Can you show an example how you did it?Quote:
Originally Posted by ChrisBurrows
Chris I think your numbers are a little off, but I could be wrong...
Care to elaborate?
According to Chris' example, using the numbers 0 and 50 it should look like...
0 += (50-0) * 0.1, which becomes 0 += 5 which is 5
5 += (50-5) * 0.1, which becomes 5 += 4.5 which is 9.5
So yeah, I think Chris' numbers were a little off. I'd assume he was actually using the equation X += (target-X )*0.2, and the last number can obviously be changed to whatever you want anyway. The higher the decimal number is, the faster the object will approach its target. Just mess around with it to see what works best for you.
At any rate, here's an example.
Edit: Oh, I forgot to mention... for the example just press the spacebar to generate a random target location on screen.
Actually yeah, my mistake. I was playing around with different values and I guess I posted the results for the a slightly different equation, X += (target-X )*0.2
Nice example by the way gkinfinity.
Pretty cool stuff they manage to do in the video.
Ill deff check this out when i get the time.
Thanks for posting this Outcast :)
Very cool gkinfinity! Great video too Outcast!
Nice video :) Thanks for posting this.
Oh thanks!Quote:
Originally Posted by ChrisBurrows
Yeah, shoutouts to Outcast for posting the video though. I thoroughly enjoyed it
Nice example file! :) Anyone have any idea how they do that wall bounce effect? It looks really neat! :D
The source code for the project https://github.com/grapefrukt/juicy-...zipball/master
I think this is the code for the Bouncy Walls. Its hard to deciper for someone with 0 AC3 knowledge :/
package com.grapefrukt.games.juicy.effects
{
import com.bit101.charts.BarChart;
import com.grapefrukt.games.general.gameobjects.GameObjec t;
import com.grapefrukt.games.juicy.gameobjects.Ball;
import com.grapefrukt.games.juicy.Settings;
import flash.display.CapsStyle;
import flash.display.Shape;
import flash.geom.Point;
/**
* ...
* @author gummikana
*/
public class BouncyLine extends GameObject
{
public function BouncyLine( x1:Number = 0, y1:Number = 0, x2:Number = 0, y2:Number = 0 )
{
set( x1, y1, x2, y2 );
}
public function set( x1:Number, y1:Number, x2:Number, y2:Number ):void {
pos1.x = x1;
pos1.y = y1;
pos2.x = x2;
pos2.y = y2;
var delta:Point;
delta = pos2.clone();
delta = delta.subtract( pos1 ); // pos2 - pos1 ?
length = delta.length;
delta.normalize( 1 );
line_rotation = Math.atan2( delta.y, delta.x );
delta.normalize( length * 0.5 );
pos_middle = pos1.clone();
pos_middle = pos_middle.add( delta );
// wobble_middle.y = 500;
}
// wobble pos is the new position of the anchor, that is going to be wobbled to the middle
public function wobble( x:Number, y:Number ): void {
// move this to local coordinate system
var wobble_pos:Point = new Point( x - pos_middle.x, y - pos_middle.y );
var tx:Number = wobble_pos.x;
wobble_pos.x = wobble_pos.x * Math.cos( line_rotation ) - wobble_pos.y * Math.sin( line_rotation );
wobble_pos.y = tx * Math.sin( line_rotation ) + wobble_pos.y * Math.cos( line_rotation );
// wobble_pos = wobble_pos.add( pos_middle );
wobble_middle = wobble_pos; // wobble_middle.add( wobble_pos );
/*
CVector2< Type > D = *this - centre;
D.Rotate( angle );
D += centre;
Set( D.x, D.y );
*/
/*types::vector2 middle_result = end_pos.Rotate( paddle_pos_middle, paddle_rotation );
paddle_middle += middle_result - paddle_pos_middle;*/
}
override public function update(imeDelta:Number = 1):void {
if ( Math.abs( wobble_middle.y ) > 0 ) {
wobble_velocity.y += -bounce_speed * wobble_middle.y;
wobble_velocity.y *= bounciness;
}
/*
if( ceng::math::Absolute( paddle_middle.y ) > 0 ) {
paddle_middle_velocity.y += -bounce_speed * paddle_middle.y;
paddle_middle_velocity.y *= bounciness;
}*/
if ( Math.abs( wobble_middle.x ) > 0 ) {
wobble_middle.x *= 0.95;
}
wobble_middle = wobble_middle.add( wobble_velocity );
/*
if( ceng::math::Absolute( paddle_middle.x ) > 0 ) {
paddle_middle.x *= bounciness;
}
paddle_middle += paddle_middle_velocity;
*/
graphics.clear();
graphics.lineStyle( Settings.EFFECT_BOUNCY_LINES_WIDTH, Settings.COLOR_BOUNCY_LINES, 1, false, "normal", CapsStyle.SQUARE );
graphics.moveTo( pos1.x, pos1.y );
var m:Point = middle;
if( Settings.EFFECT_BOUNCY_LINES_ENABLED )
graphics.curveTo( m.x, m.y, pos2.x, pos2.y );
else
graphics.lineTo( pos2.x, pos2.y );
if ( collisionCounter > 0 ) collisionCounter--;
}
public function get position1():Point {
return pos1;
}
public function get position2():Point {
return pos2;
}
public function get middle():Point {
var temp:Point;
temp = wobble_middle.clone();
var angle:Number;
angle = -line_rotation;
var tx:Number;
tx = temp.x;
temp.x = temp.x * Math.cos( angle ) - temp.y * Math.sin( angle );
temp.y = tx * Math.sin( angle ) + temp.y * Math.cos( angle );
// x = (Type)x * (Type)cos(angle) - y * (Type)sin(angle);
// y = (Type)tx * (Type)sin(angle) + y * (Type)cos(angle);
temp = temp.add( pos_middle );
return temp;
}
public function checkCollision( ball:Ball ):void {
if ( collisionCounter > 0 ) return;
var dist:Number = distanceFromLine( pos1, pos2, new Point( ball.x, ball.y ) );
// var col:Point = lineIntersectLine( pos1, pos2, new Point( ball.x, ball.y ), new Point( ball.exX, ball.exY ) );
var max_distance:Number = 0.5 * Settings.EFFECT_BOUNCY_LINES_WIDTH + Settings.EFFECT_BOUNCY_LINES_DISTANCE_FROM_WALLS;
// we collided
if ( dist <= max_distance ) {
// this wobble
wobble( ball.x + Settings.EFFECT_BOUNCY_LINES_STRENGHT * ball.velocityX, ball.y + Settings.EFFECT_BOUNCY_LINES_STRENGHT * ball.velocityY );
/*
var v:Point = new Point( ball.velocityX, ball.velocityY );
var n:Point = pos2.subtract( pos1 ); // ( GetPaddleMaxPos() - GetPaddleMinPos() );
n = new Point( -n.y, n.x );
n.normalize( 1 );
// n = types::vector2( -n.y , n.x );
// n = n.Normalize();
// float dotVec = ceng::math::Dot( v, n ) * 2.f;
var dotVec:Number = ( v.x * n.x + v.y * n.y ) * 2.0;
n.normalize( dotVec );
// n = n * dotVec;
// var mvn:Point = new Point( v.x - n.x, v.y - n.y );
ball.collideSet( v.x - n.x, v.y - n.y );
// types::vector2 mvn = v - n;
// ball_velocity = 1.0f * mvn;
*/
collisionCounter = 2;
}
}
public function closestPointOnLineSegment( a:Point, b:Point, p:Point ):Point
{
var c:Point = new Point( p.x - a.x, p.y - a.y );
var v:Point = new Point( b.x - a.x, b.y - a.y );
var distance:Number = v.length;
// optimized normalized
// v = v.Normalise();
if( distance != 0 )
{
v.x /= distance;
v.y /= distance;
}
var t:Number = v.x * c.x + v.y * c.y;
// float t = Dot( v, c );
if (t < 0)
return a.clone();
if (t > distance )
return b.clone();
v.x *= t;
v.y *= t;
return a.add( v );
}
public function distanceFromLine( a:Point, b:Point, p:Point ):Number
{
var delta:Point = closestPointOnLineSegment( a, b, p );
delta.x = delta.x - p.x;
delta.y = delta.y - p.y;
return delta.length;
}
// Stolen from http://keith-hair.net/blog/2008/08/0...-lines-in-as3/
//---------------------------------------------------------------
//Checks for intersection of Segment if as_seg is true.
//Checks for intersection of Line if as_seg is false.
//Return intersection of Segment AB and Segment EF as a Point
//Return null if there is no intersection
//---------------------------------------------------------------
private function lineIntersectLine(A:Point,B:Point,E:Point,F:Point, as_seg:Boolean=true):Point {
var ip:Point;
var a1:Number;
var a2:Number;
var b1:Number;
var b2:Number;
var c1:Number;
var c2:Number;
a1= B.y-A.y;
b1= A.x-B.x;
c1= B.x*A.y - A.x*B.y;
a2= F.y-E.y;
b2= E.x-F.x;
c2= F.x*E.y - E.x*F.y;
var denom:Number=a1*b2 - a2*b1;
if (denom == 0) {
return null;
}
ip=new Point();
ip.x=(b1*c2 - b2*c1)/denom;
ip.y=(a2*c1 - a1*c2)/denom;
//---------------------------------------------------
//Do checks to see if intersection to endpoints
//distance is longer than actual Segments.
//Return null if it is with any.
//---------------------------------------------------
if(as_seg){
if(Math.pow(ip.x - B.x, 2) + Math.pow(ip.y - B.y, 2) > Math.pow(A.x - B.x, 2) + Math.pow(A.y - B.y, 2))
{
return null;
}
if(Math.pow(ip.x - A.x, 2) + Math.pow(ip.y - A.y, 2) > Math.pow(A.x - B.x, 2) + Math.pow(A.y - B.y, 2))
{
return null;
}
if(Math.pow(ip.x - F.x, 2) + Math.pow(ip.y - F.y, 2) > Math.pow(E.x - F.x, 2) + Math.pow(E.y - F.y, 2))
{
return null;
}
if(Math.pow(ip.x - E.x, 2) + Math.pow(ip.y - E.y, 2) > Math.pow(E.x - F.x, 2) + Math.pow(E.y - F.y, 2))
{
return null;
}
}
return ip;
}
private var pos1:Point = new Point;
private var pos2:Point = new Point;
private var pos_middle:Point = new Point;
private var length:Number = 0;
// offset from the center ...
private var wobble_middle:Point = new Point;
private var wobble_velocity:Point = new Point;
private var line_rotation:Number = 0;
//
private var bounce_speed:Number = 0.25; // 0.25f default
private var bounciness:Number = 0.85; // 0.85f default bigger the number, the longer the vibrations... over 1 adds to the vibrations
private var collisionCounter:Number = 0;
}
Andos's Easing object does all this really, er, easily.
It does this wall bounce effect I just posted about?Quote:
Originally Posted by SolarB
Yes.
We are being very vague here... :p How can you achieve these results? I have played a bit with the easing object but I can only get stuff to slow down or vobble.Quote:
Originally Posted by Stephen
http://grapefrukt.com/f/games/juicy-breakout/
If you look at this game and press Esc a menu appears where you can enable a lot of different effects, the bound wall one is the one in the bottom of the Stretch and squeeze tab
Oh you mean the wobbly lines? I thought we were talking about the blocks falling and bouncing like in the video.
Since this is done in flash using vectors I don't think it's possible to do with an active, unless you use some kind of distortion extension/shader. Alternatively maybe box2d can do it using some kind of system with distance joints ie:
http://www.uchidacoonga.com/2012/03/...cos2d-part-14/
What's the difference between using this and:
Always - X( "ActiveObj" )*(1-0.1)+X( "DestinationObj" )*0.1
Always - Y( "ActiveObj" )*(1-0.1)+Y( "DestinationObj" )*0.1
?
The equation is the same, but if you set the object's position to the result of the equation directly your decimal is going to be truncated
Hey Outcast is this what you're looking for?
Attachment 6756
I made it using the SineWave shader and implementing the formula (for speed of wobble).
Maybe you could modify it to track the point of contact by using the shader's freq or other parameters.
Yes that would be perfect if it worked in Flash! :/Quote:
Originally Posted by SolarB
Try Looki's FlashFX extension, If it doesn't support the sine shader I hear you can import custom shaders by converting them to whatever it needs (see the FlashFX page on this site). You could also try asking Looki if he can work it in for you! :)