API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 19th, 2019
79
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 17.45 KB | None | 0 0
raw download clone embed print report
  1. #include scripts\_utils;
  2.  
  3. init()
  4. {
  5.     level.refreshTimeMin = 0.5;
  6.     level.refreshTimeMax = 1.0;
  7.  
  8.     level.AIs = [];
  9.     level.spawnAI = scripts\_ai::SpawnAI;
  10.     level.killAIs = scripts\_ai::KillAIs;
  11.  
  12.     level thread onPlayerConnect();
  13.     thread scripts\_friendlyai::init();
  14. }
  15.  
  16. onPlayerConnect()
  17. {
  18.     level endon("intermission");
  19.  
  20.     for (;;)
  21.     {
  22.         level waittill("connecting", player);
  23.         player thread onPlayerSpawned();
  24.     }
  25. }
  26.  
  27. onPlayerSpawned()
  28. {
  29.     self endon("disconnect");
  30.  
  31.     for (;;)
  32.     {
  33.         self waittill("spawned_player");
  34.         self updateClosestNode();
  35.     }
  36. }
  37.  
  38. updateClosestNode()
  39. {
  40.     self endon("disconnect");
  41.     self endon("killed_player");
  42.  
  43.     for (;;)
  44.     {
  45.         self.closestNode = getClosestNode( self.origin );
  46.        
  47.         t = RandomFloatRange(level.refreshTimeMin, level.refreshTimeMax);
  48.         wait t;
  49.     }
  50. }
  51.  
  52. Attack(ai, damage, argument)
  53. {
  54.     if (!isDefined(ai.hitbox))
  55.         return;
  56.    
  57.     ai.hitbox.trig notify("damage", damage, self, argument);
  58. }
  59.  
  60. GetTypeStruct(ai)
  61. {
  62.     return level.AItype[ai.type];
  63. }
  64.  
  65. haveHitbox( type )
  66. {
  67.     if (!isDefined(type) || type == "")
  68.         return true;
  69.  
  70.     for ( i = 0; i < level.hitbox[ type ].size; i++ )
  71.     {
  72.         if ( ! level.hitbox[ type ][ i ].use )
  73.             return true;
  74.     }
  75.  
  76.     return false;
  77. }
  78.  
  79. KillAIs(AItype)
  80. {
  81.     array = level.AIs;
  82.  
  83.     for ( i = 0; i < array.size; i++ )
  84.     {
  85.         if (isDefined( AItype ) && array[i].type != AItype)
  86.             continue;
  87.  
  88.         array[i] notify("killed_ai");
  89.     }
  90. }
  91.  
  92. SpawnAI(bottype, spawnorigin)
  93. {
  94.     if ( ! isDefined( bottype ) )
  95.         bottype = "default";
  96.  
  97.     while ( ! haveHitbox( level.AItype[bottype].hitboxtype ) ) // ha nincs el�rhet� hitbox
  98.         wait (randomFloatRange(0.05, 1));
  99.  
  100.     if (isDefined(spawnorigin))
  101.     {
  102.         origin = spawnorigin;
  103.         angles = (0, 0, 0);
  104.     }
  105.     else
  106.     {
  107.         spawnpointname  = level.AItype[bottype].spawnpointname;
  108.         spawnpoints     = getEntArray(spawnpointname, "classname");
  109.         spawnpoint      = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random(spawnpoints);
  110.  
  111.         origin = spawnpoint.origin;
  112.         angles = spawnpoint.angles;
  113.     }
  114.  
  115.     count = level.AIs.size;
  116.  
  117.     level.AIs[count]            = spawn("script_model", origin);
  118.     level.AIs[count].angles     = angles;
  119.     level.AIs[count].type       = bottype;
  120.     level.AIs[count].state      = "idle";
  121.     level.AIs[count].name       = (level.AItype[bottype].nameprefix + "_" + count);
  122.     level.AIs[count].speed      = level.AItype[bottype].speed;
  123.     level.AIs[count].maxhealth  = int(level.AItype[bottype].health * game["difficulty"]);
  124.     level.AIs[count].health     = level.AIs[count].maxhealth;
  125.     level.AIs[count].animtree   = level.AItype[bottype].animtree;
  126.     level.AIs[count].SFXgrumble = level.AItype[bottype].SFX_grumble;
  127.     level.AIs[count].SFXattack  = level.AItype[bottype].SFX_attack;
  128.     level.AIs[count].SFXdeath   = level.AItype[bottype].SFX_death;
  129.  
  130.     level.AIs[count] thread loopAnim();
  131.  
  132.     if (isDefined(level.AItype[bottype].hitboxtype) && level.AItype[bottype].hitboxtype != "")
  133.     {
  134.         for ( i = 0; i < level.hitbox[ level.AItype[bottype].hitboxtype ].size; i++ )
  135.         {
  136.             if ( level.hitbox[ level.AItype[bottype].hitboxtype ][ i ].use )
  137.                 continue;
  138.  
  139.             level.AIs[count].hitbox = level.hitbox[ level.AItype[bottype].hitboxtype ][ i ];
  140.             level.AIs[count].hitbox.use = true;
  141.             level.AIs[count].hitbox linkTo(level.AIs[count], "tag_origin", (0,0,0), (0,0,0));
  142.  
  143.             break;
  144.         }
  145.     }
  146.     else
  147.     {
  148.         level.AIs[count].hitbox = undefined;
  149.     }
  150.  
  151.     level.AIs[count] thread deleteAI();
  152.     level.AIs[count] thread monitorDamage();
  153.     level.AIs[count] thread movePath();
  154.     level.AIs[count] thread hitPlayer();
  155.     level.AIs[count] thread grumble();
  156.     level.AIs[count] thread loopPathSearching();
  157.     level.AIs[count] thread sideFunction();
  158.  
  159.     level notify("spawned_ai", level.AIs[count]);
  160.  
  161.     return level.AIs[count];
  162. }
  163.  
  164. sideFunction()
  165. {
  166.     if (!isDefined(level.AItype[self.type].func2))
  167.         return;
  168.  
  169.     self endon("killed_ai");
  170.  
  171.     [[level.AItype[self.type].func2]]();
  172. }
  173.  
  174. respawn()
  175. {
  176.     spawnpointname  = level.AItype[ self.type ].spawnpointname;
  177.     spawnpoints     = getEntArray(spawnpointname, "classname");
  178.     spawnpoint      = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random(spawnpoints);
  179.  
  180.     self.origin = spawnpoint.origin;
  181.     self.angles = spawnpoint.angles;
  182. }
  183.  
  184. grumble()
  185. {
  186.     if (!isDefined(self.SFXgrumble))
  187.         return;
  188.  
  189.     self endon("killed_ai");
  190.  
  191.     for (;;)
  192.     {
  193.         wait 1.25;
  194.         if (random_percentage( 4 ))
  195.             self playSound( self.SFXgrumble );
  196.     }
  197. }
  198.  
  199. deleteAI()
  200. {
  201.     self waittill("killed_ai", attacker, damage, argument);
  202.  
  203.     self [[level.callbackAIKilled]](attacker, damage, argument);
  204.  
  205.     if (isDefined(level.AItype[ self.type ].deathFUNC))
  206.         self [[level.AItype[ self.type ].deathFUNC]]();
  207.  
  208.     if (isDefined(self.hitbox))
  209.     {
  210.         self unLink();
  211.         self.hitbox.use = false;
  212.         self.hitbox.origin = (0,0,10000);
  213.     }
  214.  
  215.     level.AIs = array_remove( level.AIs, self );
  216.     self delete();
  217.  
  218.     level notify("ai_destroyed");
  219. }
  220.  
  221. monitorDamage()
  222. {
  223.     if (!isDefined(self.hitbox))
  224.         return;
  225.  
  226.     self endon("killed_ai");
  227.    
  228.     wait (1.0); // spawn v�delem
  229.  
  230.     for (;;)
  231.     {
  232.         self.hitbox.trig waittill("damage", damage, attacker, argument);
  233.  
  234.         if (isDefined(level.AItype[self.type].dmgFUNC))
  235.             self thread [[level.AItype[self.type].dmgFUNC]](attacker, damage);
  236.        
  237.         self thread [[level.callbackAIDamage]](attacker, damage, argument);
  238.         self notify("damaged", attacker, damage);
  239.  
  240.         if (self.health <= 0)
  241.         {
  242.             self notify("killed_ai", attacker, damage, argument);
  243.         }
  244.     }
  245. }
  246.  
  247. loopAnim()
  248. {
  249.     if (!isDefined(self.animtree))
  250.         return;
  251.  
  252.     self endon("killed_ai");
  253.  
  254.     for (;;)
  255.     {
  256.         for ( i = 0; i < level.animtree[ self.animtree ][ self.state ].size; i++ )
  257.         {
  258.             self setModel( level.animtree[ self.animtree ][ self.state ][ i ] );
  259.             wait 0.05;
  260.         }
  261.     }
  262. }
  263.  
  264. loopPathSearching()
  265. {
  266.     self endon("killed_ai");
  267.  
  268.     for (;;)
  269.     {
  270.         t = RandomFloatRange(level.refreshTimeMin, level.refreshTimeMax);
  271.         self delay(t, "path_refresh");
  272.     }
  273. }
  274.  
  275. delay(time, note)
  276. {
  277.     self endon(note);
  278.     wait time;
  279.     self notify(note);
  280. }
  281.  
  282. movePath()
  283. {
  284.     self endon("killed_ai");
  285.  
  286.     for (;;)
  287.     {
  288.         self waittill("path_refresh");
  289.  
  290.         nextNodeORG = undefined;
  291.  
  292.         if (level.AItype[self.type].targettype == "player")
  293.             path = self pathToClosestPlayer();
  294.         else if (level.AItype[self.type].targettype == "random")
  295.             path = self pathToRandomWaypoint();
  296.         else if (level.AItype[self.type].targettype == "ai")
  297.             path = self pathToAI();
  298.         else
  299.             path = undefined;
  300.  
  301.  
  302.         if (!isDefined(path))
  303.         {
  304.             self.targetp = undefined;
  305.             self.state = "idle";
  306.             self stopMove();
  307.  
  308.             continue;
  309.         }
  310.  
  311.         self thread moving(path[0]);
  312.     }
  313. }
  314.  
  315. moving(nextEnt)
  316. {
  317.     self endon("killed_ai");
  318.     self endon("path_refresh");
  319.     self endon("stopmove");
  320.  
  321.     if ( ! isDefined( self.debug ) )
  322.         self.debug = -1;
  323.  
  324.     self.debug++;
  325.  
  326.     // K�vetkez� pont kisz�mol�sa -->
  327.     if (isPlayer(nextEnt))
  328.         nextPoint = plantOrigin(nextEnt.origin);
  329.     else
  330.         nextPoint = nextEnt.origin;
  331.  
  332.     nextPoint = calcEdgePoint( self.origin, nextPoint );
  333.     nextPoint = (nextPoint[0], nextPoint[1], int(nextPoint[2]) + 1);
  334.     // <--
  335.  
  336.  
  337.     // Hogy ne menjenek egym�sba -->
  338.     vector = ( nextPoint - self.origin );
  339.     forward = ( maps\mp\_utility::vectorscale( vectorNormalize( vector ), 48 ) + level.offset2 );
  340.     trace = bulletTrace(self.origin + level.offset2, self.origin + forward, false, self);
  341.  
  342.     if( self.debug < 10 && trace["fraction"] != 1 && ! isPlayer( trace["entity"] ) )
  343.     {
  344.         wait randomFloatRange(0.25, 0.5);
  345.         self.state = "idle";
  346.         self stopMove();
  347.     }
  348.     // <--
  349.  
  350.  
  351.     self.debug = -1;
  352.  
  353.  
  354.     // Id� kisz�mol�sa -->
  355.     time = length( vector ) / self.speed;
  356.     if ( time <= 0 )
  357.         time = 0.01;
  358.     // <--
  359.  
  360.  
  361.     // Sebezhet�s�g -->
  362.     if (isPlayer(nextEnt) && time < level.AItype[self.type].hitDIST / 25)
  363.         self.targetp = nextEnt;
  364.     else if (level.AItype[self.type].targettype == "ai" && is_in_array(level.AIs, nextEnt) && time < level.AItype[self.type].hitDIST / 25)
  365.         self.targetp = nextEnt;
  366.     else
  367.         self.targetp = undefined;
  368.     // <--
  369.  
  370.  
  371.     // Mozg�sok -->
  372.     self rotateTo( (0, vectorToAngles( vector )[1], 0), 0.25 );
  373.  
  374.     if ( ! self.enableMoving )
  375.         self notify("stopmove");
  376.  
  377.     self.state = "move";
  378.     self moveTo( nextPoint, time );
  379.     // <--
  380.  
  381.     self waittill("movedone");
  382.     self notify("path_refresh");
  383. }
  384.  
  385. stopMove()
  386. {
  387.     self moveTo( self.origin, 0.01 );
  388.     self notify("stopmove");
  389. }
  390.  
  391. hitPlayer()
  392. {
  393.     self endon("killed_ai");
  394.  
  395.     self.enableMoving = true;
  396.     self.targetp = undefined;
  397.  
  398.     if (!isDefined(level.AItype[ self.type ].hitFUNC))
  399.         return;
  400.  
  401.     for (;;)
  402.     {
  403.         wait 0.05;
  404.  
  405.         self.enableMoving = true;
  406.  
  407.         if ( ! isDefined( self.targetp ) )
  408.             continue;
  409.  
  410.         currentDist = distanceSquared( self.origin, self.targetp.origin );
  411.         if ( currentDist < pow(level.AItype[ self.type ].hitDIST, 2) )
  412.         {
  413.             self.enableMoving = false;
  414.             self stopMove();
  415.             self.state = "hurt";
  416.             self.debug = -1;
  417.  
  418.             if (isDefined(self.SFXattack))
  419.                 self playSound(self.SFXattack);
  420.  
  421.             self [[ level.AItype[ self.type ].hitFUNC ]]( self.targetp );
  422.         }
  423.         else
  424.         {
  425.             self.enableMoving = true;
  426.         }
  427.     }
  428. }
  429.  
  430. pathToClosestPlayer()
  431. {
  432.     shortestDist = undefined;
  433.     shortestPath = undefined;
  434.  
  435.     players = getEntArray("player", "classname");
  436.  
  437.     for (i = 0; i < players.size; i++)
  438.     {
  439.         player = players[i];
  440.  
  441.         if ( player.sessionstate != "playing" || isDefined(player.invisible) )
  442.             continue;
  443.  
  444.         vec     = maps\mp\_utility::vectorScale( anglesToRight( vectorToAngles( player.origin - self.origin) ), 16);
  445.         right   = sightTracePassed(self.origin + level.offset2 + vec, player.origin + level.offset2, false, undefined);
  446.         left    = sightTracePassed(self.origin + level.offset2 - vec, player.origin + level.offset2, false, undefined);
  447.  
  448.         // Ha l�tja a j�t�kost, akkor nem keres �tvonalat
  449.         if ( right && left )
  450.         {
  451.             path = array( player );
  452.             dist = distanceSquared( self.origin, player.origin );
  453.         }
  454.         else
  455.         {
  456.             arr = self getPathToPlayer( player );
  457.  
  458.             if ( ! isDefined( arr ) )
  459.                 continue;
  460.  
  461.             path = arr[0];
  462.             dist = arr[1];
  463.         }
  464.  
  465.         if ( ! isDefined( path ) || ! isDefined( dist ) )
  466.         {
  467.             //iPrintln( "^1ERROR: Undefined path from " + self.name + " to " + player.name );
  468.             wait 3;
  469.             continue;
  470.         }
  471.  
  472.         if ( ! isDefined( shortestDist ) || dist < shortestDist )
  473.         {
  474.             shortestDist = dist;
  475.             shortestPath = path;
  476.         }
  477.     }
  478.  
  479.     return shortestPath;
  480. }
  481.  
  482. pathToAI()
  483. {
  484.     ai = self.targetAI;
  485.     if (!isDefined(ai))
  486.         return;
  487.  
  488.     vec     = maps\mp\_utility::vectorScale( anglesToRight( vectorToAngles(ai.origin - self.origin)), 16);
  489.     right   = sightTracePassed(self.origin + level.offset2 + vec, ai.origin + level.offset2, false, undefined);
  490.     left    = sightTracePassed(self.origin + level.offset2 - vec, ai.origin + level.offset2, false, undefined);
  491.  
  492.     if ( right && left )
  493.     {
  494.         path = array(ai);
  495.         dist = distanceSquared(self.origin, ai.origin);
  496.     }
  497.     else
  498.     {
  499.         arr = self getPathToAI(ai);
  500.  
  501.         if (!isDefined(arr))
  502.             return;
  503.  
  504.         path = arr[0];
  505.         dist = arr[1];
  506.     }
  507.  
  508.     if (!isDefined(path) || !isDefined(dist))
  509.         return;
  510.  
  511.     return path;
  512. }
  513.  
  514. pathToRandomWaypoint()
  515. {
  516.     startNode = getClosestNode(self.origin);
  517.  
  518.     if (!isDefined(self.endNode)) // only get a new random endNode if the previous one is reached
  519.         self.endNode = level.waypoints[randomInt(level.waypoints.size)];
  520.  
  521.     arr = self getPathToNode(startNode, self.endNode);
  522.  
  523.     if (!isDefined(arr))
  524.         return;
  525.  
  526.     if (arr[1] < 1)
  527.         self.endNode = undefined;
  528.  
  529.     return arr[0];
  530. }
  531.  
  532. getPathToPlayer( player )
  533. {
  534.     startNode = getClosestNode( self.origin );
  535.     endNode = player.closestNode;
  536.  
  537.     if ( ! isDefined( startNode ) )
  538.     {
  539.         self respawn(); // debug
  540.         return;
  541.     }
  542.     else if ( ! isDefined( endNode ) )
  543.     {
  544.         return;
  545.     }
  546.  
  547.     if ( startNode == endNode )
  548.     {
  549.         path = array( endNode, player );
  550.  
  551.         dist = distanceSquared( endNode.origin, player.origin );
  552.     }
  553.     else
  554.     {
  555.         path = level.paths[ startNode.id ][ endNode.id ].path;
  556.         path = array_add( path, player );
  557.  
  558.         dist = level.paths[ startNode.id ][ endNode.id ].dist;
  559.         dist += distanceSquared( endNode.origin, player.origin );
  560.     }
  561.  
  562.     path = self simplifyPath( path ); // l�that� node-ok t�rl�se
  563.  
  564.     return array(path, dist);
  565. }
  566.  
  567. getPathToAI(ai)
  568. {
  569.     startNode = getClosestNode(self.origin);
  570.     endNode = getClosestNode(ai.origin);
  571.  
  572.     if (!isDefined(startNode))
  573.     {
  574.         self respawn(); // debug
  575.         return;
  576.     }
  577.     else if (!isDefined(endNode))
  578.     {
  579.         return;
  580.     }
  581.  
  582.     if (startNode == endNode)
  583.     {
  584.         path = array(endNode, ai);
  585.  
  586.         dist = distanceSquared(endNode.origin, ai.origin);
  587.     }
  588.     else
  589.     {
  590.         path = level.paths[startNode.id][endNode.id].path;
  591.         path = array_add(path, ai);
  592.  
  593.         dist = level.paths[startNode.id][endNode.id].dist;
  594.         dist += distanceSquared(endNode.origin, ai.origin);
  595.     }
  596.  
  597.     path = self simplifyPath(path);
  598.  
  599.     return array(path, dist);
  600. }
  601.  
  602. getPathToNode(startNode, endNode)
  603. {
  604.     if ( startNode == endNode )
  605.     {
  606.         path = array(endNode);
  607.         dist = 0;
  608.     }
  609.     else
  610.     {
  611.         path = level.paths[ startNode.id ][ endNode.id ].path;
  612.         dist = level.paths[ startNode.id ][ endNode.id ].dist;
  613.     }
  614.  
  615.     path = self simplifyPath( path ); // l�that� node-ok t�rl�se
  616.  
  617.     return array(path, dist);
  618. }
  619.  
  620. simplifyPath( path )
  621. {
  622.     while ( isDefined( path[ 1 ] ) && ! isPlayer( path[ 1 ] ) )
  623.     {
  624.         if ( sightTracePassed(self.origin + level.offset, path[ 1 ].origin + level.offset, false, undefined) )
  625.             path = array_remove( path, path[ 0 ] );
  626.         else
  627.             break;
  628.     }
  629.  
  630.     return path;
  631. }
  632.  
  633. calcEdgePoint( startPoint, endPoint )
  634. {
  635.     // bot-node szakasz egyenes
  636.     x1 = startPoint[0];
  637.     y1 = startPoint[1];
  638.     z1 = startPoint[2];
  639.     x2 = endPoint[0];
  640.     y2 = endPoint[1];
  641.     z2 = endPoint[2];
  642.  
  643.     if ( x1 == x2 && y1 == y2 ) // ha a bot-node s�kbeli szakasz hossza 0
  644.         return endPoint;
  645.  
  646.     segments = [];
  647.  
  648.     for (i = 0; i < level.edges.size; i++)
  649.     {
  650.         // sarok szakasz egyenes
  651.         x3 = level.edges[i].origin[0];
  652.         y3 = level.edges[i].origin[1];
  653.         z3 = level.edges[i].origin[2];
  654.         x4 = level.edges[i].pair.origin[0];
  655.         y4 = level.edges[i].pair.origin[1];
  656.         z4 = level.edges[i].pair.origin[2];
  657.  
  658.         // iprintln(level.edges[i].id + " - " + level.edges[i].pair.id); // debug
  659.         temp = segmentVectors( int(x1), int(y1), int(z1), int(x2), int(y2), int(z2), int(x3), int(y3), int(z3), int(x4), int(y4), int(z4) );
  660.  
  661.         if ( ! temp[1] ) // ha nem metszi a k�t szakasz egym�st
  662.             continue;
  663.  
  664.         if ( distanceSquared( temp[0], startPoint ) < 4 ) // ha �pp rajta �ll egy �len, azt nem adja hozz�
  665.             continue;
  666.  
  667.         segments[ segments.size ] = temp[0];
  668.     }
  669.  
  670.  
  671.  
  672.     edgePoint = undefined;
  673.     shortestDist = undefined;
  674.     if ( segments.size > 1 ) // Ha t�bb �lt elmetszett, akkor kisz�molja a legk�zelebbit
  675.     {
  676.         for (i = 0; i < segments.size; i++)
  677.         {
  678.             dist = distanceSquared( startPoint, segments[ i ] );
  679.  
  680.             if ( (! isDefined( shortestDist ) || dist < shortestDist) )
  681.             {
  682.                 shortestDist = dist;
  683.                 edgePoint = segments[ i ];
  684.             }
  685.         }
  686.     }
  687.     else if ( segments.size ) // Ha csak egy �lt metszett el
  688.     {
  689.         edgePoint = segments[ 0 ];
  690.     }
  691.     else // Ha egy �lt sem metszett el, vagy nem l�tja
  692.     {
  693.         edgePoint = endPoint;
  694.     }
  695.  
  696.     return edgePoint;
  697. }
  698.  
  699. getClosestNode( origin )
  700. {
  701.     closestDist = undefined;
  702.     closestNode = undefined;
  703.  
  704.     for (i = 0; i < level.waypoints.size; i++)
  705.     {
  706.         if ( ! sightTracePassed(origin + level.offset, level.waypoints[i].origin + level.offset, false, undefined) )
  707.             continue;
  708.  
  709.         if ( ! isDefined( closestNode ) || closer( origin, level.waypoints[i].origin, closestNode.origin ) )
  710.             closestNode = level.waypoints[i];
  711.     }
  712.  
  713.     return closestNode;
  714. }
  715.  
  716. segmentVectors( e1X, e1Y, e1Z, e2X, e2Y, e2Z, e3X, e3Y, e3Z, e4X, e4Y, e4Z )
  717. {
  718.     // v�gpontokhoz sz�m�tott relat�v poz�ci�
  719.     A1 = e2Y - e1Y; // ha A1 == 0, akkor B1 != 0
  720.     B1 = (e2X - e1X) * -1;
  721.     A2 = e4Y - e3Y;
  722.     B2 = (e4X - e3X) * -1;
  723.  
  724.     if ( A1 == A2 || B1 == B2 ) // p�rhuzamosak
  725.         return array((0, 0, 0), false);
  726.  
  727.     // kezd�pontok �s az elt�r�s szorzata
  728.     c = A1 * e1X + B1 * e1Y;
  729.     f = A2 * e3X + B2 * e3Y;
  730.  
  731.     X = ((B2 * c - B1 * f) / (B2 * A1 - B1 * A2));
  732.     Y = ((A2 * c - A1 * f) / (A2 * B1 - A1 * B2));
  733.  
  734.     if (e3Z != e4Z)
  735.     {
  736.         if (e4X != e3X)
  737.             Z = ((e4Z - e3Z) / (e4X - e3X) * X + e3Z);
  738.         else
  739.             Z = ((e4Z - e3Z) / (e4Y - e3Y) * Y + e3Z);
  740.     }
  741.     else
  742.     {
  743.         Z = e3Z;
  744.     }
  745.  
  746.     isCovering = cover( e1X, e1Y, e2X, e2Y, e3X, e3Y, e4X, e4Y, X, Y );
  747.  
  748.     return array((X, Y, Z), isCovering);
  749. }
  750.  
  751. cover( e1X, e1Y, e2X, e2Y, e3X, e3Y, e4X, e4Y, mX, mY )
  752. {
  753.     // Elv: megvizsg�lom, hogy a metsz�spont a befoglal� t�glalapon bel�lre esik-e
  754.  
  755.     // Els� szakasz v�gpontjai
  756.     x1 = min(e1X, e2X);
  757.     x2 = max(e1X, e2X);
  758.     y1 = min(e1Y, e2Y);
  759.     y2 = max(e1Y, e2Y);
  760.  
  761.     // M�sodik szakasz v�gpontjai
  762.     x3 = min(e3X, e4X);
  763.     x4 = max(e3X, e4X);
  764.     y3 = min(e3Y, e4Y);
  765.     y4 = max(e3Y, e4Y);
  766.  
  767. /* // debug
  768.     color = randomInt(10);
  769.     if (mX < x1)
  770.     {
  771.         iprintln("^" + color + "mX < x1: " + mX + " < " + x1);
  772.     }
  773.     if (mX > x2)
  774.     {
  775.         iprintln("^" + color + "mX > x2: " + mX + " > " + x2);
  776.     }
  777.     if (mY < y1)
  778.     {
  779.         iprintln("^" + color + "mY < y1: " + mY + " < " + y1);
  780.     }
  781.     if (mY > y2)
  782.     {
  783.         iprintln("^" + color + "mY > y2: " + mY + " > " + y2);
  784.     }
  785.     if (mX < x3)
  786.     {
  787.         iprintln("^" + color + "mX < x3: " + mX + " < " + x3);
  788.     }
  789.     if (mX > x4)
  790.     {
  791.         iprintln("^" + color + "mX > x4: " + mX + " > " + x4);
  792.     }
  793.     if (mY < y3)
  794.     {
  795.         iprintln("^" + color + "mY < y3: " + mY + " < " + y3);
  796.     }
  797.     if (mY > y4)
  798.     {
  799.         iprintln("^" + color + "mY > y4: " + mY + " > " + y4);
  800.     }
  801. */
  802.  
  803.     if ( mX < x1 || mX > x2 || mY < y1 || mY > y2 || mX < x3 || mX > x4 || mY < y3 || mY > y4 ) // a metsz�spont rajta van-e a szakaszokon
  804.         return false; // nem!
  805.     else
  806.         return true; // igen!
  807. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!