1 /* 2 Copyright 2008-2025 3 Matthias Ehmann, 4 Michael Gerhaeuser, 5 Carsten Miller, 6 Bianca Valentin, 7 Alfred Wassermann, 8 Peter Wilfahrt 9 10 This file is part of JSXGraph. 11 12 JSXGraph is free software dual licensed under the GNU LGPL or MIT License. 13 14 You can redistribute it and/or modify it under the terms of the 15 16 * GNU Lesser General Public License as published by 17 the Free Software Foundation, either version 3 of the License, or 18 (at your option) any later version 19 OR 20 * MIT License: https://github.com/jsxgraph/jsxgraph/blob/master/LICENSE.MIT 21 22 JSXGraph is distributed in the hope that it will be useful, 23 but WITHOUT ANY WARRANTY; without even the implied warranty of 24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 25 GNU Lesser General Public License for more details. 26 27 You should have received a copy of the GNU Lesser General Public License and 28 the MIT License along with JSXGraph. If not, see <https://www.gnu.org/licenses/> 29 and <https://opensource.org/licenses/MIT/>. 30 */ 31 32 /*global JXG: true, define: true*/ 33 /*jslint nomen: true, plusplus: true*/ 34 35 /** 36 * @fileoverview The JSXGraph object Turtle is defined. It acts like 37 * "turtle graphics". 38 * @author A.W. 39 */ 40 41 import JXG from "../jxg.js"; 42 import Const from "./constants.js"; 43 import Mat from "../math/math.js"; 44 import GeometryElement from "./element.js"; 45 import Type from "../utils/type.js"; 46 47 /** 48 * Constructs a new Turtle object. 49 * @class This is the Turtle class. 50 * It is derived from {@link JXG.GeometryElement}. 51 * It stores all properties required 52 * to move a turtle. 53 * @constructor 54 * @param {JXG.Board} board The board the new turtle is drawn on. 55 * @param {Array} parents Start position and start direction of the turtle. Possible values are 56 * [x, y, angle] 57 * [[x, y], angle] 58 * [x, y] 59 * [[x, y]] 60 * @param {Object} attributes Attributes to change the visual properties of the turtle object 61 * All angles are in degrees. 62 * 63 * @example 64 * 65 * //creates a figure 8 animation 66 * var board = JXG.JSXGraph.initBoard('jxgbox',{boundingbox: [-250, 250, 250, -250]}); 67 * var t = board.create('turtle',[0, 0], {strokeOpacity:0.5}); 68 * t.setPenSize(3); 69 * t.right(90); 70 * var alpha = 0; 71 * 72 * var run = function() { 73 * t.forward(2); 74 * if (Math.floor(alpha / 360) % 2 === 0) { 75 * t.left(1); // turn left by 1 degree 76 * } else { 77 * t.right(1); // turn right by 1 degree 78 * } 79 * alpha += 1; 80 * 81 * if (alpha < 1440) { // stop after two rounds 82 * setTimeout(run, 20); 83 * } 84 * } 85 * 86 *run(); 87 * 88 * </pre><div class="jxgbox" id="JXG14167b1c-2ad3-11e5-8dd9-901b0e1b8723" style="width: 300px; height: 300px;"></div> 89 * <script type="text/javascript"> 90 * (function() { 91 * var brd = JXG.JSXGraph.initBoard('JXG14167b1c-2ad3-11e5-8dd9-901b0e1b8723', 92 * {boundingbox: [-250, 250, 250, -250], axis: true, showcopyright: false, shownavigation: false}); 93 * var t = brd.create('turtle',[0, 0], {strokeOpacity:0.5}); 94 * t.setPenSize(3); 95 * t.right(90); 96 * var alpha = 0; 97 * 98 * var run = function() { 99 * t.forward(2); 100 * if (Math.floor(alpha / 360) % 2 === 0) { 101 * t.left(1); // turn left by 1 degree 102 * } else { 103 * t.right(1); // turn right by 1 degree 104 * } 105 * alpha += 1; 106 * 107 * if (alpha < 1440) { // stop after two rounds 108 * setTimeout(run, 20); 109 * } 110 * } 111 * 112 * run(); 113 * 114 * })(); 115 * 116 * </script><pre> 117 */ 118 JXG.Turtle = function (board, parents, attributes) { 119 var x, y, dir; 120 121 this.constructor(board, attributes, Const.OBJECT_TYPE_TURTLE, Const.OBJECT_CLASS_OTHER); 122 123 this.turtleIsHidden = false; 124 this.board = board; 125 this.visProp.curveType = "plot"; 126 127 // Save visProp in this._attributes. 128 // this._attributes is overwritten by setPenSize, setPenColor... 129 // Setting the color or size affects the turtle from the time of 130 // calling the method, 131 // whereas Turtle.setAttribute affects all turtle curves. 132 this._attributes = Type.copyAttributes(this.visProp, board.options, "turtle"); 133 delete this._attributes.id; 134 135 x = 0; 136 y = 0; 137 dir = 90; 138 139 if (parents.length !== 0) { 140 // [x,y,dir] 141 if (parents.length === 3) { 142 // Only numbers are accepted at the moment 143 x = parents[0]; 144 y = parents[1]; 145 dir = parents[2]; 146 } else if (parents.length === 2) { 147 // [[x,y],dir] 148 if (Type.isArray(parents[0])) { 149 x = parents[0][0]; 150 y = parents[0][1]; 151 dir = parents[1]; 152 // [x,y] 153 } else { 154 x = parents[0]; 155 y = parents[1]; 156 } 157 // [[x,y]] 158 } else { 159 x = parents[0][0]; 160 y = parents[0][1]; 161 } 162 } 163 164 this.init(x, y, dir); 165 166 this.methodMap = Type.deepCopy(this.methodMap, { 167 forward: 'forward', 168 fd: 'forward', 169 back: 'back', 170 bk: 'back', 171 right: 'right', 172 rt: 'right', 173 left: 'left', 174 lt: 'left', 175 penUp: 'penUp', 176 pu: 'penUp', 177 up: 'penUp', 178 penDown: 'penDown', 179 pd: 'penDown', 180 down: 'penDown', 181 clearScreen: 'clearScreen', 182 cs: 'clearScreen', 183 clean: 'clean', 184 setPos: 'setPos', 185 home: 'home', 186 hideTurtle: 'hideTurtle', 187 ht: 'hideTurtle', 188 hide: 'hideTurtle', 189 showTurtle: 'showTurtle', 190 st: 'showTurtle', 191 show: 'showTurtle', 192 penSize: 'setPenSize', 193 setPenSize: 'setPenSize', 194 penColor: 'setPenColor', 195 setPenColor: 'setPenColor', 196 highlightPenColor: 'setHighlightPenColor', 197 setHighlightPenColor: 'setHighlightPenColor', 198 getPenColor: 'getPenColor', 199 Color: 'getPenColor', 200 getHighlightPenColor: 'getHighlightPenColor', 201 HighlightColor: 'getHighlightPenColor', 202 getPenSize: 'getPenSize', 203 Size: 'getPenSize', 204 pushTurtle: 'pushTurtle', 205 push: 'pushTurtle', 206 popTurtle: 'popTurtle', 207 pop: 'popTurtle', 208 lookTo: 'lookTo', 209 pos: 'pos', 210 Pos: 'pos', 211 moveTo: 'moveTo', 212 X: 'X', 213 Y: 'Y' 214 }); 215 216 return this; 217 }; 218 219 JXG.Turtle.prototype = new GeometryElement(); 220 221 JXG.extend( 222 JXG.Turtle.prototype, 223 /** @lends JXG.Turtle.prototype */ { 224 /** 225 * Initialize a new turtle or reinitialize a turtle after {@link JXG.Turtle#clearScreen}. 226 * @private 227 */ 228 init: function (x, y, dir) { 229 var hiddenPointAttr = { 230 fixed: true, 231 name: "", 232 visible: false, 233 withLabel: false 234 }; 235 236 this.arrowLen = 237 20 / Mat.hypot(this.board.unitX, this.board.unitY); 238 239 this.pos = [x, y]; 240 this.isPenDown = true; 241 this.dir = 90; 242 this.stack = []; 243 this.objects = []; 244 this.curve = this.board.create( 245 "curve", 246 [[this.pos[0]], [this.pos[1]]], 247 this._attributes 248 ); 249 this.objects.push(this.curve); 250 251 this.turtle = this.board.create("point", this.pos, hiddenPointAttr); 252 this.objects.push(this.turtle); 253 254 this.turtle2 = this.board.create( 255 "point", 256 [this.pos[0], this.pos[1] + this.arrowLen], 257 hiddenPointAttr 258 ); 259 this.objects.push(this.turtle2); 260 261 this.visProp.arrow.lastArrow = true; 262 this.visProp.arrow.straightFirst = false; 263 this.visProp.arrow.straightLast = false; 264 this.arrow = this.board.create( 265 "line", 266 [this.turtle, this.turtle2], 267 this.visProp.arrow 268 ); 269 this.objects.push(this.arrow); 270 271 this.subs = { 272 arrow: this.arrow 273 }; 274 this.inherits.push(this.arrow); 275 276 this.right(90 - dir); 277 this.board.update(); 278 }, 279 280 /** 281 * Move the turtle forward. 282 * @param {Number} len of forward move in user coordinates 283 * @returns {JXG.Turtle} pointer to the turtle object 284 */ 285 forward: function (len) { 286 if (len === 0) { 287 return this; 288 } 289 290 var t, 291 dx = len * Math.cos((this.dir * Math.PI) / 180), 292 dy = len * Math.sin((this.dir * Math.PI) / 180); 293 294 if (!this.turtleIsHidden) { 295 t = this.board.create("transform", [dx, dy], { type: "translate" }); 296 297 t.applyOnce(this.turtle); 298 t.applyOnce(this.turtle2); 299 } 300 301 if (this.isPenDown) { 302 // IE workaround 303 if (this.curve.dataX.length >= 8192) { 304 this.curve = this.board.create( 305 "curve", 306 [[this.pos[0]], [this.pos[1]]], 307 this._attributes 308 ); 309 this.objects.push(this.curve); 310 } 311 } 312 313 this.pos[0] += dx; 314 this.pos[1] += dy; 315 316 if (this.isPenDown) { 317 this.curve.dataX.push(this.pos[0]); 318 this.curve.dataY.push(this.pos[1]); 319 } 320 321 this.board.update(); 322 return this; 323 }, 324 325 /** 326 * Move the turtle backwards. 327 * @param {Number} len of backwards move in user coordinates 328 * @returns {JXG.Turtle} pointer to the turtle object 329 */ 330 back: function (len) { 331 return this.forward(-len); 332 }, 333 334 /** 335 * Rotate the turtle direction to the right 336 * @param {Number} angle of the rotation in degrees 337 * @returns {JXG.Turtle} pointer to the turtle object 338 */ 339 right: function (angle) { 340 this.dir -= angle; 341 this.dir %= 360; 342 343 if (!this.turtleIsHidden) { 344 var t = this.board.create( 345 "transform", 346 [(-angle * Math.PI) / 180, this.turtle], 347 { type: "rotate" } 348 ); 349 t.applyOnce(this.turtle2); 350 } 351 352 this.board.update(); 353 return this; 354 }, 355 356 /** 357 * Rotate the turtle direction to the right. 358 * @param {Number} angle of the rotation in degrees 359 * @returns {JXG.Turtle} pointer to the turtle object 360 */ 361 left: function (angle) { 362 return this.right(-angle); 363 }, 364 365 /** 366 * Pen up, stops visible drawing 367 * @returns {JXG.Turtle} pointer to the turtle object 368 */ 369 penUp: function () { 370 this.isPenDown = false; 371 return this; 372 }, 373 374 /** 375 * Pen down, continues visible drawing 376 * @returns {JXG.Turtle} pointer to the turtle object 377 */ 378 penDown: function () { 379 this.isPenDown = true; 380 this.curve = this.board.create( 381 "curve", 382 [[this.pos[0]], [this.pos[1]]], 383 this._attributes 384 ); 385 this.objects.push(this.curve); 386 387 return this; 388 }, 389 390 /** 391 * Removes the turtle curve from the board. The turtle stays in its position. 392 * @returns {JXG.Turtle} pointer to the turtle object 393 */ 394 clean: function () { 395 var i, el; 396 397 for (i = 0; i < this.objects.length; i++) { 398 el = this.objects[i]; 399 if (el.type === Const.OBJECT_TYPE_CURVE) { 400 this.board.removeObject(el); 401 this.objects.splice(i, 1); 402 } 403 } 404 405 this.curve = this.board.create( 406 "curve", 407 [[this.pos[0]], [this.pos[1]]], 408 this._attributes 409 ); 410 this.objects.push(this.curve); 411 this.board.update(); 412 413 return this; 414 }, 415 416 /** 417 * Removes the turtle completely and resets it to its initial position and direction. 418 * @returns {JXG.Turtle} pointer to the turtle object 419 */ 420 clearScreen: function () { 421 var i, 422 el, 423 len = this.objects.length; 424 425 for (i = 0; i < len; i++) { 426 el = this.objects[i]; 427 this.board.removeObject(el); 428 } 429 430 this.init(0, 0, 90); 431 return this; 432 }, 433 434 /** 435 * Moves the turtle without drawing to a new position 436 * @param {Number} x new x- coordinate 437 * @param {Number} y new y- coordinate 438 * @returns {JXG.Turtle} pointer to the turtle object 439 */ 440 setPos: function (x, y) { 441 var t; 442 443 if (Type.isArray(x)) { 444 this.pos = x; 445 } else { 446 this.pos = [x, y]; 447 } 448 449 if (!this.turtleIsHidden) { 450 this.turtle.setPositionDirectly(Const.COORDS_BY_USER, [x, y]); 451 this.turtle2.setPositionDirectly(Const.COORDS_BY_USER, [x, y + this.arrowLen]); 452 t = this.board.create( 453 "transform", 454 [(-(this.dir - 90) * Math.PI) / 180, this.turtle], 455 { type: "rotate" } 456 ); 457 t.applyOnce(this.turtle2); 458 } 459 460 this.curve = this.board.create( 461 "curve", 462 [[this.pos[0]], [this.pos[1]]], 463 this._attributes 464 ); 465 this.objects.push(this.curve); 466 this.board.update(); 467 468 return this; 469 }, 470 471 /** 472 * Sets the pen size. Equivalent to setAttribute({strokeWidth:size}) 473 * but affects only the future turtle. 474 * @param {Number} size 475 * @returns {JXG.Turtle} pointer to the turtle object 476 */ 477 setPenSize: function (size) { 478 //this.visProp.strokewidth = size; 479 this.curve = this.board.create( 480 "curve", 481 [[this.pos[0]], [this.pos[1]]], 482 this.copyAttr("strokeWidth", size) 483 ); 484 this.objects.push(this.curve); 485 return this; 486 }, 487 488 /** 489 * Sets the pen color. Equivalent to setAttribute({strokeColor:color}) 490 * but affects only the future turtle. 491 * @param {String} color 492 * @returns {JXG.Turtle} pointer to the turtle object 493 */ 494 setPenColor: function (color) { 495 this.curve = this.board.create( 496 "curve", 497 [[this.pos[0]], [this.pos[1]]], 498 this.copyAttr("strokeColor", color) 499 ); 500 this.objects.push(this.curve); 501 502 return this; 503 }, 504 505 /** 506 * Get attribute of the last turtle curve object. 507 * 508 * @param {String} key 509 * @returns attribute value 510 * @private 511 */ 512 getPenAttribute: function(key) { 513 var pos, le = this.objects.length; 514 if (le === 4) { 515 // No new turtle objects have been created 516 pos = 0; 517 } else { 518 pos = le - 1; 519 } 520 return this.objects[pos].evalVisProp(key); 521 }, 522 523 /** 524 * Get most recently set turtle size (in pixel). 525 * @returns Number Size of the last turtle segment in pixel. 526 */ 527 getPenSize: function() { 528 return this.getPenAttribute('strokewidth'); 529 }, 530 531 /** 532 * Get most recently set turtle color. 533 * @returns String RGB color value of the last turtle segment. 534 */ 535 getPenColor: function() { 536 return this.getPenAttribute('strokecolor'); 537 }, 538 539 /** 540 * Get most recently set turtle color. 541 * @returns String RGB highlight color value of the last turtle segment. 542 */ 543 getHighlightPenColor: function() { 544 return this.getPenAttribute('highlightstrokecolor'); 545 }, 546 547 /** 548 * Sets the highlight pen color. Equivalent to setAttribute({highlightStrokeColor:color}) 549 * but affects only the future turtle. 550 * @param {String} color 551 * @returns {JXG.Turtle} pointer to the turtle object 552 */ 553 setHighlightPenColor: function (color) { 554 //this.visProp.highlightstrokecolor = colStr; 555 this.curve = this.board.create( 556 "curve", 557 [[this.pos[0]], [this.pos[1]]], 558 this.copyAttr("highlightStrokeColor", color) 559 ); 560 this.objects.push(this.curve); 561 return this; 562 }, 563 564 /** 565 * Sets properties of the turtle, see also {@link JXG.GeometryElement#setAttribute}. 566 * Sets the property for all curves of the turtle in the past and in the future. 567 * @param {Object} attributes key:value pairs 568 * @returns {JXG.Turtle} pointer to the turtle object 569 */ 570 setAttribute: function (attributes) { 571 var i, 572 el, 573 tmp, 574 len = this.objects.length; 575 576 for (i = 0; i < len; i++) { 577 el = this.objects[i]; 578 if (el.type === Const.OBJECT_TYPE_CURVE) { 579 el.setAttribute(attributes); 580 } 581 } 582 583 // Set visProp of turtle 584 tmp = this.visProp.id; 585 this.visProp = Type.deepCopy(this.curve.visProp); 586 this.visProp.id = tmp; 587 this._attributes = Type.deepCopy(this.visProp); 588 delete this._attributes.id; 589 590 return this; 591 }, 592 593 /** 594 * Set a future attribute of the turtle. 595 * @private 596 * @param {String} key 597 * @param {Number|String} val 598 * @returns {Object} pointer to the attributes object 599 */ 600 copyAttr: function (key, val) { 601 this._attributes[key.toLowerCase()] = val; 602 return this._attributes; 603 }, 604 605 /** 606 * Sets the visibility of the turtle head to true, 607 * @returns {JXG.Turtle} pointer to the turtle object 608 */ 609 showTurtle: function () { 610 this.turtleIsHidden = false; 611 this.arrow.setAttribute({ visible: true }); 612 this.visProp.arrow.visible = false; 613 this.setPos(this.pos[0], this.pos[1]); 614 this.board.update(); 615 616 return this; 617 }, 618 619 /** 620 * Sets the visibility of the turtle head to false, 621 * @returns {JXG.Turtle} pointer to the turtle object 622 */ 623 hideTurtle: function () { 624 this.turtleIsHidden = true; 625 this.arrow.setAttribute({ visible: false }); 626 this.visProp.arrow.visible = false; 627 this.board.update(); 628 629 return this; 630 }, 631 632 /** 633 * Moves the turtle to position [0,0]. 634 * @returns {JXG.Turtle} pointer to the turtle object 635 */ 636 home: function () { 637 this.pos = [0, 0]; 638 this.setPos(this.pos[0], this.pos[1]); 639 640 return this; 641 }, 642 643 /** 644 * Pushes the position of the turtle on the stack. 645 * @returns {JXG.Turtle} pointer to the turtle object 646 */ 647 pushTurtle: function () { 648 this.stack.push([this.pos[0], this.pos[1], this.dir]); 649 650 return this; 651 }, 652 653 /** 654 * Gets the last position of the turtle on the stack, sets the turtle to this position and removes this 655 * position from the stack. 656 * @returns {JXG.Turtle} pointer to the turtle object 657 */ 658 popTurtle: function () { 659 var status = this.stack.pop(); 660 this.pos[0] = status[0]; 661 this.pos[1] = status[1]; 662 this.dir = status[2]; 663 this.setPos(this.pos[0], this.pos[1]); 664 665 return this; 666 }, 667 668 /** 669 * Rotates the turtle into a new direction. 670 * There are two possibilities: 671 * @param {Number|Array} target If a number is given, it is interpreted as the new direction to look to; If an array 672 * consisting of two Numbers is given targeted is used as a pair coordinates. 673 * @returns {JXG.Turtle} pointer to the turtle object 674 */ 675 lookTo: function (target) { 676 var ax, ay, bx, by, beta; 677 678 if (Type.isArray(target)) { 679 ax = this.pos[0]; 680 ay = this.pos[1]; 681 bx = target[0]; 682 by = target[1]; 683 684 // Rotate by the slope of the line [this.pos, target] 685 beta = Math.atan2(by - ay, bx - ax); 686 this.right(this.dir - (beta * 180) / Math.PI); 687 } else if (Type.isNumber(target)) { 688 this.right(this.dir - target); 689 } 690 return this; 691 }, 692 693 /** 694 * Moves the turtle to a given coordinate pair. 695 * The direction is not changed. 696 * @param {Array} target Coordinates of the point where the turtle looks to. 697 * @returns {JXG.Turtle} pointer to the turtle object 698 */ 699 moveTo: function (target) { 700 var dx, dy, t; 701 702 if (Type.isArray(target)) { 703 dx = target[0] - this.pos[0]; 704 dy = target[1] - this.pos[1]; 705 706 if (!this.turtleIsHidden) { 707 t = this.board.create("transform", [dx, dy], { type: "translate" }); 708 t.applyOnce(this.turtle); 709 t.applyOnce(this.turtle2); 710 } 711 712 if (this.isPenDown) { 713 // IE workaround 714 if (this.curve.dataX.length >= 8192) { 715 this.curve = this.board.create( 716 "curve", 717 [[this.pos[0]], [this.pos[1]]], 718 this._attributes 719 ); 720 this.objects.push(this.curve); 721 } 722 } 723 724 this.pos[0] = target[0]; 725 this.pos[1] = target[1]; 726 727 if (this.isPenDown) { 728 this.curve.dataX.push(this.pos[0]); 729 this.curve.dataY.push(this.pos[1]); 730 } 731 this.board.update(); 732 } 733 734 return this; 735 }, 736 737 /** 738 * Alias for {@link JXG.Turtle#forward} 739 */ 740 fd: function (len) { 741 return this.forward(len); 742 }, 743 /** 744 * Alias for {@link JXG.Turtle#back} 745 */ 746 bk: function (len) { 747 return this.back(len); 748 }, 749 /** 750 * Alias for {@link JXG.Turtle#left} 751 */ 752 lt: function (angle) { 753 return this.left(angle); 754 }, 755 /** 756 * Alias for {@link JXG.Turtle#right} 757 */ 758 rt: function (angle) { 759 return this.right(angle); 760 }, 761 /** 762 * Alias for {@link JXG.Turtle#penUp} 763 */ 764 pu: function () { 765 return this.penUp(); 766 }, 767 /** 768 * Alias for {@link JXG.Turtle#penDown} 769 */ 770 pd: function () { 771 return this.penDown(); 772 }, 773 /** 774 * Alias for {@link JXG.Turtle#hideTurtle} 775 */ 776 ht: function () { 777 return this.hideTurtle(); 778 }, 779 /** 780 * Alias for {@link JXG.Turtle#showTurtle} 781 */ 782 st: function () { 783 return this.showTurtle(); 784 }, 785 /** 786 * Alias for {@link JXG.Turtle#clearScreen} 787 */ 788 cs: function () { 789 return this.clearScreen(); 790 }, 791 /** 792 * Alias for {@link JXG.Turtle#pushTurtle} 793 */ 794 push: function () { 795 return this.pushTurtle(); 796 }, 797 /** 798 * Alias for {@link JXG.Turtle#popTurtle} 799 */ 800 pop: function () { 801 return this.popTurtle(); 802 }, 803 804 /** 805 * The "co"-coordinate of the turtle curve at position t is returned. 806 * 807 * @param {Number} t parameter 808 * @param {String} co. Either 'X' or 'Y'. 809 * @returns {Number} x-coordinate of the turtle position or x-coordinate of turtle at position t 810 */ 811 evalAt: function (t, co) { 812 var i, 813 j, 814 el, 815 tc, 816 len = this.objects.length; 817 818 for (i = 0, j = 0; i < len; i++) { 819 el = this.objects[i]; 820 821 if (el.elementClass === Const.OBJECT_CLASS_CURVE) { 822 if (j <= t && t < j + el.numberPoints) { 823 tc = t - j; 824 return el[co](tc); 825 } 826 j += el.numberPoints; 827 } 828 } 829 830 return this[co](); 831 }, 832 833 /** 834 * if t is not supplied the x-coordinate of the turtle is returned. Otherwise 835 * the x-coordinate of the turtle curve at position t is returned. 836 * @param {Number} t parameter 837 * @returns {Number} x-coordinate of the turtle position or x-coordinate of turtle at position t 838 */ 839 X: function (t) { 840 if (!Type.exists(t)) { 841 return this.pos[0]; 842 } 843 844 return this.evalAt(t, "X"); 845 }, 846 847 /** 848 * if t is not supplied the y-coordinate of the turtle is returned. Otherwise 849 * the y-coordinate of the turtle curve at position t is returned. 850 * @param {Number} t parameter 851 * @returns {Number} x-coordinate of the turtle position or x-coordinate of turtle at position t 852 */ 853 Y: function (t) { 854 if (!Type.exists(t)) { 855 return this.pos[1]; 856 } 857 return this.evalAt(t, "Y"); 858 }, 859 860 /** 861 * @returns {Number} z-coordinate of the turtle position 862 */ 863 Z: function (t) { 864 return 1.0; 865 }, 866 867 /** 868 * Gives the lower bound of the parameter if the turtle is treated as parametric curve. 869 */ 870 minX: function () { 871 return 0; 872 }, 873 874 /** 875 * Gives the upper bound of the parameter if the turtle is treated as parametric curve. 876 * May be overwritten in @see generateTerm. 877 */ 878 maxX: function () { 879 var i, 880 el, 881 len = this.objects.length, 882 np = 0; 883 884 for (i = 0; i < len; i++) { 885 el = this.objects[i]; 886 if (el.elementClass === Const.OBJECT_CLASS_CURVE) { 887 np += this.objects[i].numberPoints; 888 } 889 } 890 return np; 891 }, 892 893 /** 894 * Checks whether (x,y) is near the curve. 895 * @param {Number} x Coordinate in x direction, screen coordinates. 896 * @param {Number} y Coordinate in y direction, screen coordinates. 897 * @returns {Boolean} True if (x,y) is near the curve, False otherwise. 898 */ 899 hasPoint: function (x, y) { 900 var i, el; 901 902 // run through all curves of this turtle 903 for (i = 0; i < this.objects.length; i++) { 904 el = this.objects[i]; 905 906 if (el.type === Const.OBJECT_TYPE_CURVE) { 907 if (el.hasPoint(x, y)) { 908 // So what??? All other curves have to be notified now (for highlighting) 909 return true; 910 // This has to be done, yet. 911 } 912 } 913 } 914 return false; 915 } 916 } 917 ); 918 919 /** 920 * @class A turtle is a graphic paradigm similar to the programming languages Logo or PostScript. 921 * @pseudo 922 * @description Creates a new turtle 923 * @name Turtle 924 * @augments JXG.Turtle 925 * @constructor 926 * @type JXG.Turtle 927 * 928 * @param {JXG.Board} board The board the turtle is put on. 929 * @param {Array} parents 930 * @param {Object} attributes Object containing properties for the element such as stroke-color and visibility. See {@link JXG.GeometryElement#setAttribute} 931 * @returns {JXG.Turtle} Reference to the created turtle object. 932 */ 933 JXG.createTurtle = function (board, parents, attributes) { 934 var attr; 935 parents = parents || []; 936 937 attr = Type.copyAttributes(attributes, board.options, "turtle"); 938 return new JXG.Turtle(board, parents, attr); 939 }; 940 941 JXG.registerElement("turtle", JXG.createTurtle); 942 943 export default JXG.Turtle; 944 // export default { 945 // Turtle: JXG.Turtle, 946 // createTurtle: JXG.createTurtle 947 // }; 948