home *** CD-ROM | disk | FTP | other *** search
/ 600 Games / 600games.iso / Diversos / 3_puck_shuck.swf / scripts / frame_3 / DoAction.as
Encoding:
Text File  |  2007-03-20  |  16.5 KB  |  587 lines
  1. function init()
  2. {
  3.    _root.timeslice = 33;
  4.    _root.level = 1;
  5.    _root.p1_init = "01";
  6.    _root.p2_init = "02";
  7. }
  8. function rads2degrees(theta)
  9. {
  10.    return theta / 6.283185307179586 * 360;
  11. }
  12. function degrees2rads(theta)
  13. {
  14.    return theta / 360 * 2 * 3.141592653589793;
  15. }
  16. function getMagnitude(deltax, deltay)
  17. {
  18.    trace("get magnitude: ### Square Root!");
  19.    var magnitude = Math.pow(Math.pow(deltay,2) + Math.pow(deltax,2),0.5);
  20.    return magnitude;
  21. }
  22. function getMagnitudeSq(deltax, deltay)
  23. {
  24.    magsq = deltax * deltax + deltay * deltay;
  25.    return magsq;
  26. }
  27. function getAngle(deltax, deltay)
  28. {
  29.    if(deltax == 0)
  30.    {
  31.       if(deltay > 0)
  32.       {
  33.          theta = 1.5707963267948966;
  34.       }
  35.       else
  36.       {
  37.          theta = 4.71238898038469;
  38.       }
  39.    }
  40.    else if(deltax < 0)
  41.    {
  42.       theta = Math.atan(deltay / deltax) + 3.141592653589793;
  43.    }
  44.    else
  45.    {
  46.       theta = Math.atan(deltay / deltax);
  47.    }
  48.    trace("getAngle");
  49.    return theta;
  50. }
  51. function getDeltax(angle, magnitude)
  52. {
  53.    deltax = magnitude * Math.cos(angle);
  54.    return deltax;
  55. }
  56. function getDeltay(angle, magnitude)
  57. {
  58.    deltay = magnitude * Math.sin(angle);
  59.    return deltay;
  60. }
  61. function dotProdXY(vector1, vector2)
  62. {
  63.    var ai = vector1.deltax;
  64.    var bi = vector1.deltay;
  65.    var xi = vector2.deltax;
  66.    var yi = vector2.deltay;
  67.    trace(ai + "," + bi + ";" + xi + "," + yi);
  68.    dotprod = ai * xi + bi * yi;
  69.    return dotprod;
  70. }
  71. function dotProdAM(vector1, vector2)
  72. {
  73.    diffangle = vector1.angle - vector2.angle;
  74.    var dotprod = vector1.magnitude * vector2.magnitude * Math.cos(diffangle);
  75.    return dotprod;
  76. }
  77. function findAngle(vector1, vector2)
  78. {
  79.    if(!vector1.magnitude)
  80.    {
  81.       vector1.magnitude = vector1.vecmagnitude();
  82.    }
  83.    if(!vector2.magnitude)
  84.    {
  85.       vector2.magnitude = vector2.vecmagnitude();
  86.    }
  87.    theta = Math.acos(dotProdXY(vector1,vector2) / vector1.magnitude * vector2.magnitude);
  88.    return theta;
  89. }
  90. function findAngleAM(vector1, vector2)
  91. {
  92.    theta = Math.acos(dotProdXY(vector1,vector2) / vector1.magnitude * vector2.magnitude);
  93.    return theta;
  94. }
  95. function getVectorObj(obj1, obj2)
  96. {
  97.    return newVectorPts(obj1._x,obj2._x,obj1._y,obj2._y);
  98. }
  99. function newVectorPts(x1, x2, y1, y2)
  100. {
  101.    deltax = x2 - x1;
  102.    deltay = y2 - y1;
  103.    return new Vector(deltax,deltay);
  104. }
  105. function VectorAM(angle, magnitude)
  106. {
  107.    this.angle = angle;
  108.    this.magnitude = magnitude;
  109.    this.finddy = function()
  110.    {
  111.       this.deltay = getDeltay(this.angle,this.magnitude);
  112.       return this.deltay;
  113.    };
  114.    this.finddx = function()
  115.    {
  116.       this.deltax = getDeltax(this.angle,this.magnitude);
  117.       return this.deltax;
  118.    };
  119. }
  120. function Vector(deltax, deltay)
  121. {
  122.    this.deltax = deltax;
  123.    this.deltay = deltay;
  124.    this.vecmagnitude = function()
  125.    {
  126.       this.magnitude = Math.pow(Math.pow(deltay,2) + Math.pow(deltax,2),0.5);
  127.       trace("  ROOT! in vector class");
  128.       return this.magnitude;
  129.    };
  130.    this.vecangle = function()
  131.    {
  132.       this.angle = _root.getAngle(this.deltax,this.deltay);
  133.       trace("vecangle");
  134.       return this.angle;
  135.    };
  136.    this.finddy = function()
  137.    {
  138.       this.deltay = getDeltay(this.angle,this.magnitude);
  139.       return this.deltay;
  140.    };
  141.    this.finddx = function()
  142.    {
  143.       this.deltax = getDeltax(this.angle,this.magnitude);
  144.       return this.deltax;
  145.    };
  146. }
  147. function vectorSumAM(vector1, vector2)
  148. {
  149.    vector1.finddx();
  150.    vector1.finddy();
  151.    vector2.finddx();
  152.    vector2.finddy();
  153.    deltax3 = vector1.deltax + vector2.deltax;
  154.    deltay3 = vector1.deltay + vector2.deltay;
  155.    ang = getAngle(deltax3,deltay3);
  156.    mag = getMagnitude(deltax3,deltay3);
  157.    vec = new Vector(ang,mag);
  158.    vec.deltax = deltax3;
  159.    vec.deltay = deltay3;
  160.    return vec;
  161. }
  162. function vectorSum(vector1, vector2)
  163. {
  164.    trace("sum: " + vector1.deltax + " + " + vector2.deltax);
  165.    deltax3 = vector1.deltax + vector2.deltax;
  166.    deltay3 = vector1.deltay + vector2.deltay;
  167.    vec = new Vector(deltax3,deltay3);
  168.    return vec;
  169. }
  170. function vectorMultAM(vector1, scalar)
  171. {
  172.    newmag = vector1.magnitude * scalar;
  173.    vec = new Vector(vector1.angle,newmag);
  174.    return vec;
  175. }
  176. function vectorMult(vector1, scalar)
  177. {
  178.    if(!vector1.magnitude)
  179.    {
  180.       vector1.magnitude = vector1.vecmagnitude();
  181.    }
  182.    newmag = vector1.magnitude * scalar;
  183.    vec = new VectorAM(vector1.angle,newmag);
  184.    return vec;
  185. }
  186. function checkCollision(obj1, obj2)
  187. {
  188.    distV = getVectorObj(obj1,obj2);
  189.    distsq = getMagnitudeSq(distV.deltax,distV.deltay);
  190.    sumRadii = obj2.radius + obj1.radius;
  191.    mvcheck = obj1.movementvec.magnitude + sumRadii;
  192.    if(mvcheck * mvcheck < distsq)
  193.    {
  194.       return false;
  195.    }
  196.    norm = new VectorAM(obj1.movementvec.angle,1);
  197.    norm.finddx();
  198.    norm.finddy();
  199.    movD = dotProdXY(distV,norm);
  200.    if(movD <= 0)
  201.    {
  202.       return false;
  203.    }
  204.    Fsquared = distsq - movD * movD;
  205.    sumRadii2 = sumRadii * sumRadii;
  206.    if(Fsquared >= sumRadii2)
  207.    {
  208.       return false;
  209.    }
  210.    Tsquared = sumRadii2 - Fsquared;
  211.    trace("Fsquared: " + Fsquared);
  212.    trace("Tsquared: " + Tsquared + "(" + sumRadii2 + "-" + Fsquared + ")");
  213.    trace("movD: " + movD);
  214.    if(Tsquared < 0)
  215.    {
  216.       return false;
  217.    }
  218.    alongmove = movD - Math.pow(Tsquared,0.5);
  219.    trace(" ROOT ! fourth check");
  220.    if(obj1.movementvec.magnitude < alongmove)
  221.    {
  222.       return false;
  223.    }
  224.    trace("radii: " + obj2.radius + "&" + obj1.radius);
  225.    dist = Math.pow(distsq,0.5);
  226.    trace(" ROOT!  getting distance");
  227.    obj1.tempdist = dist;
  228.    if(alongmove > 1)
  229.    {
  230.       alongmove == 1;
  231.    }
  232.    tmpvec = new VectorAM(obj1.movementvec.angle,alongmove);
  233.    obj1.newxtemp = obj1._x + tmpvec.finddx();
  234.    obj1.newytemp = obj1._y + tmpvec.finddy();
  235.    trace("want to go " + obj1.movementvec.magnitude + " but am going " + alongmove);
  236.    return true;
  237. }
  238. function checkOut(obj, arena)
  239. {
  240.    nextx = obj._x + obj.movementvec.deltax;
  241.    nexty = obj._y + obj.movementvec.deltay;
  242.    if(nextx >= arena.xleft && nextx <= arena.xright)
  243.    {
  244.       if(nexty - obj.radius >= arena.ytop && nexty + obj.radius <= arena.ybottom)
  245.       {
  246.          return false;
  247.       }
  248.       normvec = new VectorAM(obj.movementvec.angle,1);
  249.       normvec.finddx();
  250.       normvec.finddy();
  251.       if(nexty - obj.radius < arena.ytop)
  252.       {
  253.          trace("my Y: " + obj._y);
  254.          distmag = obj._y - obj.radius - arena.ytop;
  255.          anglebetween = obj.movementvec.angle - 4.71238898038469;
  256.       }
  257.       else if(nexty + obj.radius > arena.ybottom)
  258.       {
  259.          distmag = obj._y + obj.radius - arena.ybottom;
  260.          anglebetween = obj.movementvec.angle + 4.71238898038469;
  261.       }
  262.       alongVec = Math.abs(distmag / Math.cos(anglebetween));
  263.       trace("distmag: " + distmag + " angle: " + obj.movementvec.angle + " cos: " + Math.cos(obj.movementvec.angle));
  264.       trace(" I want to go another " + obj.movementvec.magnitude + " but I\'ll only go " + alongVec + " because distvec=" + distvec.vecmagnitude());
  265.       tmpvec = new VectorAM(obj.movementvec.angle,alongVec);
  266.       tmpvec.finddx();
  267.       tmpvec.finddy();
  268.       obj.newx = obj._x + tmpvec.deltax;
  269.       obj.newy = obj._y + tmpvec.deltay;
  270.       trace("out of the square!" + obj.newy + " vs. " + arena.ytop);
  271.       return true;
  272.    }
  273.    if(nextx <= arena.xleft)
  274.    {
  275.       deltax = nextx - arena.xleft;
  276.    }
  277.    else
  278.    {
  279.       if(nextx < arena.xright)
  280.       {
  281.          return false;
  282.       }
  283.       deltax = nextx - arena.xright;
  284.    }
  285.    deltay = nexty - arena.center;
  286.    deltaxsq = deltax * deltax;
  287.    deltaysq = deltay * deltay;
  288.    dsum = deltaxsq + deltaysq;
  289.    radsq = (arena.radius - obj.radius) * (arena.radius - obj.radius);
  290.    if(dsum < radsq)
  291.    {
  292.       return false;
  293.    }
  294.    distV = new Vector(deltax,deltay);
  295.    distV.vecmagnitude();
  296.    distV.vecangle();
  297.    trace(" ROOT - hitting the wall of the arena " + distV.magnitude + ", my magnitude:" + obj.movementvec.magnitude);
  298.    alongmove = Math.abs(distV.magnitude) - arena.radius + obj.radius;
  299.    anglebetween = distV.angle - obj.movementvec.angle;
  300.    alongVec = Math.abs(alongmove / Math.cos(anglebetween));
  301.    movalong = obj.movementvec.magnitude - Math.abs(alongVec);
  302.    trace(" I want to go another " + obj.movementvec.magnitude + " but I\'ll only go " + movalong + " because alongVec=" + alongVec + " and alongMove=" + alongMove);
  303.    trace(" My dist would be " + distV.magnitude + " on a radius of " + arena.radius);
  304.    tmpvec = new VectorAM(obj.movementvec.angle,movalong);
  305.    tmpvec.finddx();
  306.    tmpvec.finddy();
  307.    obj.newx = obj._x + tmpvec.deltax;
  308.    obj.newy = obj._y + tmpvec.deltay;
  309.    return true;
  310. }
  311. function checkCollisionWall(obj, wall)
  312. {
  313.    distV = getVectorObj(obj,wall);
  314.    dist = distV.magnitude;
  315.    sumRadii = wall.radius + obj.radius;
  316.    dist -= sumRadii;
  317.    if(obj.movementvec.magnitude < dist)
  318.    {
  319.       return false;
  320.    }
  321.    trace("** in the circle");
  322.    vecV = new Vector(wall.angle,1);
  323.    vecV.finddx();
  324.    vecV.finddy();
  325.    distV.finddx();
  326.    distV.finddy();
  327.    dotF = dotProdXY(obj.movementvec,vecV);
  328.    if(dotF >= 0)
  329.    {
  330.       trace(" wrong way roger? ");
  331.       return false;
  332.    }
  333.    dotG = dotProdXY(distV,vecV);
  334.    trace("F and G are " + dotF + ", " + dotG);
  335.    if(dotF - obj.radius > dotG)
  336.    {
  337.       trace("** the movement vector (plus the radius of the disc) is smaller than the distance to the plane");
  338.       return false;
  339.    }
  340.    vecZ = new Vector(wall.angle + 1.5707963267948966,1);
  341.    vecZ.finddx();
  342.    vecZ.finddy();
  343.    dotH = dotProdXY(obj.movementvec.vecZ);
  344.    dotI = dotProdXY(distV,vecZ);
  345.    addem = dotH + dotI;
  346.    trace("H and I are " + dotH + ", " + dotI + " and " + addem + "=" + wall.radius);
  347.    if(Math.abs(dotH - dotI) > wall.radius)
  348.    {
  349.       trace("** too far left or right of center");
  350.       return false;
  351.    }
  352.    trace(" HIT THE WALLL!!!!!!!");
  353.    return true;
  354. }
  355. function collide(obj1, obj2)
  356. {
  357.    distV = getVectorObj(obj1,obj2);
  358.    temp = distV.vecangle();
  359.    normdist = new VectorAM(temp,1);
  360.    normdist.finddx();
  361.    normdist.finddy();
  362.    _root.colcount = _root.colcount + 1;
  363.    trace(obj1._name + "colllllide with " + obj2._name + "(mag " + obj2._movementvec.magnitude + ")");
  364.    match = false;
  365.    if(_root.colcount > 50)
  366.    {
  367.       obj1.stoppuck();
  368.       obj2.stoppuck();
  369.    }
  370.    if(obj2.mass < 1000)
  371.    {
  372.       for(m in _root.arena.moving)
  373.       {
  374.          if(_root.arena.moving[m] == obj2)
  375.          {
  376.             match = true;
  377.          }
  378.       }
  379.       tempvec = new Vector(0,0);
  380.       if(!match)
  381.       {
  382.          _root.arena.moving.push(obj2);
  383.          trace("add " + obj2._name);
  384.       }
  385.       else
  386.       {
  387.          tempvec = obj2.movementvec;
  388.       }
  389.    }
  390.    else
  391.    {
  392.       tempvec = new Vector(0,0);
  393.    }
  394.    dot1 = dotProdXY(obj1.movementvec,normdist);
  395.    dot2 = dotProdXY(tempvec,normdist);
  396.    optP = 2 * (dot1 - dot2) / (obj1.mass + obj2.mass);
  397.    mult1 = -1 * optP * obj2.mass;
  398.    nextvec1 = vectorMult(normdist,mult1);
  399.    mult2 = optP * obj1.mass;
  400.    nextvec2 = vectorMult(normdist,mult2);
  401.    nextvec1.finddx();
  402.    nextvec1.finddy();
  403.    nextvec2.finddx();
  404.    nextvec2.finddy();
  405.    newvec1 = vectorSum(obj1.movementvec,nextvec1);
  406.    newvec2 = vectorSum(obj2.movementvec,nextvec2);
  407.    trace("ROOT - new vectors");
  408.    newvec1.vecmagnitude();
  409.    newvec1.vecangle();
  410.    newvec2.vecmagnitude();
  411.    newvec2.vecangle();
  412.    trace("nextvecs:" + newvec1.magnitude + " and " + newvec1.angle);
  413.    obj1.movementvec = newvec1;
  414.    obj2.movementvec = newvec2;
  415.    _root.arena.hitpuck.start();
  416. }
  417. function collidearena(obj, arena)
  418. {
  419.    nextx = obj._x + obj.movementvec.deltax;
  420.    nexty = obj._y + obj.movementvec.deltay;
  421.    trace("  ***   BOING    ***");
  422.    if(nextx >= arena.xleft && nextx <= arena.xright)
  423.    {
  424.       if(nexty - obj.radius <= arena.ytop)
  425.       {
  426.          trace("bouncing off the top");
  427.          normdist = new VectorAM(1.5707963267948966,1);
  428.       }
  429.       else if(nexty + obj.radius >= arena.ybottom)
  430.       {
  431.          trace("bouncing off the bottom");
  432.          normdist = new VectorAM(4.71238898038469,1);
  433.       }
  434.    }
  435.    else
  436.    {
  437.       if(nextx >= arena.xright)
  438.       {
  439.          distV = newVectorPts(nextx,arena.xright,nexty,arena.center);
  440.          trace("bouncing off the right curve");
  441.       }
  442.       else if(nextx <= arena.xleft)
  443.       {
  444.          distV = newVectorPts(nextx,arena.xleft,nexty,arena.center);
  445.          trace("bouncing off the left curve");
  446.       }
  447.       else
  448.       {
  449.          trace("tried to bounce but don\'t know where I am! X,Y=" + nextx + "," + nexty);
  450.          clearInterval(_root.arena.motion);
  451.       }
  452.       normdist = new VectorAM(distV.vecangle(),1);
  453.    }
  454.    normdist.finddx();
  455.    normdist.finddy();
  456.    dot1 = dotProdXY(obj.movementvec,normdist);
  457.    tempvec = new Vector(0,0);
  458.    dot2 = dotProdXY(tempvec,normdist);
  459.    optP = 2 * (dot1 - dot2) / (obj.mass + arena.mass);
  460.    mult1 = -1 * optP * arena.mass;
  461.    nextvec1 = vectorMult(normdist,mult1);
  462.    nextvec1.finddx();
  463.    nextvec1.finddy();
  464.    newvec1 = vectorSum(obj.movementvec,nextvec1);
  465.    newvec1.vecmagnitude();
  466.    newvec1.vecangle();
  467.    trace(" ROOT - from collision with arena mag: " + newvec1.magnitude + " old mag: " + obj.movementvec.magnitude);
  468.    obj.movementvec = newvec1;
  469.    _root.arena.hitarena.start();
  470. }
  471. function whack(forcevec, obj)
  472. {
  473.    trace("whack!!!");
  474.    forcevec.finddx();
  475.    forcevec.finddy();
  476.    trace("f: " + forcevec.deltax + "," + forcevec.deltay);
  477.    trace("a-m: " + forcevec.angle + "," + forcevec.magnitude);
  478.    trace(obj.movementvec.magnitude);
  479.    newvec1 = vectorSum(obj.movementvec,forcevec);
  480.    obj.movementvec = newvec1;
  481.    obj.movementvec.vecmagnitude();
  482.    obj.movementvec.vecangle();
  483.    trace("WHACKED: " + obj.movementvec.magnitude);
  484. }
  485. function checkGoal(obj)
  486. {
  487.    hdeltax = obj._x - _root.arena.target_mc._x;
  488.    hdeltay = obj._y - _root.arena.target_mc._y;
  489.    hdeltarad = _root.arena.target_mc.goalradius - 18;
  490.    trace("goal check X: " + hdeltax + ", Y: " + hdeltay + ", Rad: " + hdeltarad);
  491.    trace("goal puck X: " + obj._x + ", Y: " + obj._y);
  492.    if(hdeltax * hdeltax + hdeltay * hdeltay <= hdeltarad * hdeltarad)
  493.    {
  494.       return true;
  495.    }
  496.    return false;
  497. }
  498. function checkDeath(zone, obj)
  499. {
  500.    if((obj._x - zone._x) * (obj._x - zone._x) + (obj._y - zone._y) * (obj._y - zone._y) > 90)
  501.    {
  502.       return false;
  503.    }
  504.    if((obj._x - zone._x) * (obj._x - zone._x) + (obj._y - zone._y) * (obj._y - zone._y) <= (zone.radius - obj._radius * 2) * (zone.radius - obj._radius * 2))
  505.    {
  506.       return true;
  507.    }
  508.    return false;
  509. }
  510. function moveforlaunch(obj)
  511. {
  512.    deltx = obj._x - _root.arena.launchpad._x;
  513.    delty = obj._y - _root.arena.launchpad._y;
  514.    ang = getAngle(deltx,delty);
  515.    mag = _root.arena.launchpad.radius + obj.radius;
  516.    vec = new VectorAM(ang,mag);
  517.    nex = vec.finddx();
  518.    ney = vec.finddy();
  519.    obj._x += nex;
  520.    obj._y += ney;
  521.    for(d in _root.arena.objects)
  522.    {
  523.       disc = _root.arena.objects[d];
  524.       if(disc != this && disc.owner != "n")
  525.       {
  526.          test = _root.checkCollision(this,disc);
  527.          if(test)
  528.          {
  529.             separate(obj,disc);
  530.          }
  531.       }
  532.    }
  533. }
  534. function separate(obj1, obj2)
  535. {
  536.    trace("separate " + obj1._name + " from " + obj2._name);
  537.    deltx = obj1._x - obj2._x;
  538.    delty = obj1._y - obj2._y;
  539.    ang = getAngle(deltx,delty);
  540.    mag = getMagnitude(deltx,delty);
  541.    newmag = obj1.radius + obj2.radius + 2 - mag;
  542.    vec = new VectorAM(ang,newmag);
  543.    nex = vec.finddx();
  544.    ney = vec.finddy();
  545.    trace("move " + obj1._name + " this far: " + mag);
  546.    obj1._x += nex;
  547.    obj1._y += ney;
  548.    for(d in _root.arena.objects)
  549.    {
  550.       disc = _root.arena.objects[d];
  551.       if(disc != obj1)
  552.       {
  553.          test = _root.checkOntop(obj1,disc);
  554.          if(test)
  555.          {
  556.             if(disc.owner != "n")
  557.             {
  558.                separate(disc,obj1);
  559.             }
  560.          }
  561.       }
  562.    }
  563.    if(checkOut(obj1,_root.arena))
  564.    {
  565.       obj1._x = obj1.newx;
  566.       obj1._y = obj1.newy;
  567.    }
  568. }
  569. function checkOntop(obj1, obj2)
  570. {
  571.    trace("Check: is " + obj1._name + " on " + obj2._name + "? " + obj1._x + "=" + obj2._x);
  572.    deltx = obj1._x - obj2._x;
  573.    delty = obj1._y - obj2._y;
  574.    trace(deltx + "^2 + " + delty + "^2 <= (" + obj2.radius + " + " + obj1.radius + ")^2");
  575.    trace(deltx * deltx + delty * delty + "<=" + (obj2.radius + obj1.radius) * (obj2.radius + obj1.radius));
  576.    if(deltx * deltx + delty * delty <= (obj2.radius + obj1.radius) * (obj2.radius + obj1.radius))
  577.    {
  578.       trace(" YES IT IS!");
  579.       return true;
  580.    }
  581.    trace("Apparently not.");
  582.    return false;
  583. }
  584. trace("INITIALISE!");
  585. init();
  586. trace("geo incl");
  587.