Sprite.java

Go to the documentation of this file.

// -*- mode: java; c-basic-offset: 2; -*-
// Copyright 2009-2011 Google, All Rights reserved
// Copyright 2011-2019 MIT, All rights reserved
// Released under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
 
package com.google.appinventor.components.runtime;
 
import com.google.appinventor.components.annotations.DesignerProperty;
import com.google.appinventor.components.annotations.PropertyCategory;
import com.google.appinventor.components.annotations.SimpleEvent;
import com.google.appinventor.components.annotations.SimpleFunction;
import com.google.appinventor.components.annotations.SimpleObject;
import com.google.appinventor.components.annotations.SimpleProperty;
import com.google.appinventor.components.common.PropertyTypeConstants;
import com.google.appinventor.components.runtime.errors.AssertionFailure;
import com.google.appinventor.components.runtime.errors.IllegalArgumentError;
import com.google.appinventor.components.runtime.util.BoundingBox;
import com.google.appinventor.components.runtime.util.TimerInternal;
 
import android.os.Handler;
 
import java.util.HashSet;
import java.util.Set;
 
@SimpleObject
public abstract class Sprite extends VisibleComponent
    implements AlarmHandler, OnDestroyListener, Deleteable {
  private static final String LOG_TAG = "Sprite";
  private static final boolean DEFAULT_ENABLED = true;  // Enable timer for movement
  private static final int DEFAULT_HEADING = 0;      // degrees
  private static final int DEFAULT_INTERVAL = 100;  // ms
  private static final float DEFAULT_SPEED = 0.0f;   // pixels per interval
  private static final boolean DEFAULT_VISIBLE = true;
  private static final double DEFAULT_Z = 1.0;
  protected static final boolean DEFAULT_ORIGIN_AT_CENTER = false;
 
  protected final Canvas canvas;              // enclosing Canvas
  private final TimerInternal timerInternal;  // timer to control movement
  private final Handler androidUIHandler;     // for posting actions
 
  // Keeps track of which other sprites are currently colliding with this one.
  // That way, we don't raise CollidedWith() more than once for each collision.
  // Events are only raised when sprites are added to this collision set.  They
  // are removed when they no longer collide.
  private final Set<Sprite> registeredCollisions;
 
  // This variable prevents events from being raised before construction of
  // all components has taken place.  This was added to fix bug 2262218.
  protected boolean initialized = false;
 
  // Properties: These are protected, instead of private, both so they
  // can be used by subclasses and tests.
  protected int interval;      // number of milliseconds until next move
  protected boolean visible = true;
  protected double xLeft;      // leftmost x-coordinate
  protected double yTop;       // uppermost y-coordinate
  protected double zLayer;     // z-coordinate, higher values go in front
  protected float speed;       // magnitude in pixels
 
  // Added to support having coordinates at center.
  protected boolean originAtCenter;
  protected double xCenter;
  protected double yCenter;
 
  protected Form form;
 
  protected double userHeading;
 
  protected double heading;
  protected double headingRadians;  // heading in radians
  protected double headingCos;      // cosine(heading)
  protected double headingSin;      // sine(heading)
 
  protected Sprite(ComponentContainer container, Handler handler) {
    super();
    androidUIHandler = handler;
 
    // Add to containing Canvas.
    if (!(container instanceof Canvas)) {
      throw new IllegalArgumentError("Sprite constructor called with container " + container);
    }
    this.canvas = (Canvas) container;
    this.canvas.addSprite(this);
 
    // Maintain a list of collisions.
    registeredCollisions = new HashSet<Sprite>();
 
    // Set in motion.
    timerInternal = new TimerInternal(this, DEFAULT_ENABLED, DEFAULT_INTERVAL, handler);
 
    this.form = container.$form();
 
    // Set default property values.
    OriginAtCenter(DEFAULT_ORIGIN_AT_CENTER);
    Heading(0);  // Default initial heading
    Enabled(DEFAULT_ENABLED);
    Interval(DEFAULT_INTERVAL);
    Speed(DEFAULT_SPEED);
    Visible(DEFAULT_VISIBLE);
    Z(DEFAULT_Z);
 
    container.$form().registerForOnDestroy(this);
  }
 
  protected Sprite(ComponentContainer container) {
    // Note that although this is creating a new Handler, there is
    // only one UI thread in an Android app and posting to this
    // handler queues up a Runnable for execution on that thread.
    this(container, new Handler());
  }
 
  public void Initialize() {
    initialized = true;
    canvas.registerChange(this);
  }
 
  // Properties (Enabled, Heading, Interval, Speed, Visible, X, Y, Z, OriginAtCenter)
  // The SimpleProperty annotations for X and Y appear in the concrete
  // subclasses so each can have its own description. Currently, OriginAtCenter
  // is a property of Ball only.
 
  @SimpleProperty(
      description = "Controls whether the %type% moves and can be interacted with " +
          "through collisions, dragging, touching, and flinging.")
  public boolean Enabled() {
    return timerInternal.Enabled();
  }
 
  @DesignerProperty(
      editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN,
      defaultValue = DEFAULT_ENABLED ? "True" : "False")
  @SimpleProperty
  public void Enabled(boolean enabled) {
    timerInternal.Enabled(enabled);
  }
 
  @SimpleProperty(
      description = "Returns the %type%'s heading in degrees above the positive " +
          "x-axis.  Zero degrees is toward the right of the screen; 90 degrees is toward the " +
          "top of the screen.")
  public double Heading() {
    return userHeading;
  }
 
  @SimpleProperty
  @DesignerProperty(
      editorType = PropertyTypeConstants.PROPERTY_TYPE_FLOAT,
      defaultValue = DEFAULT_HEADING + "")
  public void Heading(double userHeading) {
    this.userHeading = userHeading;
    // Flip, because y increases in the downward direction on Android canvases
    heading = -userHeading;
    headingRadians = Math.toRadians(heading);
    headingCos = Math.cos(headingRadians);
    headingSin = Math.sin(headingRadians);
    // changing the heading needs to force a redraw for image sprites that rotate
    registerChange();
  }
 
  @SimpleProperty(
      description = "The interval in milliseconds at which the %type%'s " +
          "position is updated.  For example, if the interval is 50 and the speed is 10, " +
          "then every 50 milliseconds the sprite will move 10 pixels in the heading direction.")
  public int Interval() {
    return timerInternal.Interval();
  }
 
  @DesignerProperty(
      editorType = PropertyTypeConstants.PROPERTY_TYPE_NON_NEGATIVE_INTEGER,
      defaultValue = DEFAULT_INTERVAL + "")
  @SimpleProperty
  public void Interval(int interval) {
    timerInternal.Interval(interval);
  }
 
  @SimpleProperty(
      description = "The number of pixels that the %type% should move every interval, if enabled.")
  @DesignerProperty(
      editorType = PropertyTypeConstants.PROPERTY_TYPE_FLOAT,
      defaultValue = DEFAULT_SPEED + "")
  public void Speed(float speed) {
    this.speed = speed;
  }
 
  @SimpleProperty(
    description = "The speed at which the %type% moves. The %type% moves " +
        "this many pixels every interval if enabled.")
  public float Speed() {
    return speed;
  }
 
  @SimpleProperty(description = "Whether the %type% is visible.")
  public boolean Visible() {
    return visible;
  }
 
  @DesignerProperty(
      editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN,
      defaultValue = DEFAULT_VISIBLE ? "True" : "False")
  @SimpleProperty
  public void Visible(boolean visible) {
    this.visible = visible;
    registerChange();
  }
 
  public double X() {
    return originAtCenter ? xCenter : xLeft;
  }
 
  private double xLeftToCenter(double xLeft) {
    return xLeft + Width() / 2;
  }
 
  private double xCenterToLeft(double xCenter) {
    return xCenter - Width() / 2;
  }
 
  // Note that this does not call registerChange(). This was pulled out of X()
  // so both X and Y could be changed with only a single call to registerChange().
  private void updateX(double x) {
    if (originAtCenter) {
      xCenter = x;
      xLeft = xCenterToLeft(x);
    } else {
      xLeft = x;
      xCenter = xLeftToCenter(x);
    }
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_FLOAT,
      defaultValue = "0.0")
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE)
  public void X(double x) {
    updateX(x);
    registerChange();
  }
 
  private double yTopToCenter(double yTop) {
    return yTop + Width() / 2;
  }
 
  private double yCenterToTop(double yCenter) {
    return yCenter - Width() / 2;
  }
 
  // Note that this does not call registerChange(). This was pulled out of Y()
  // so both X and Y could be changed with only a single call to registerChange().
  private void updateY(double y) {
    if (originAtCenter) {
      yCenter = y;
      yTop = yCenterToTop(y);
    } else {
      yTop = y;
      yCenter = yTopToCenter(y);
    }
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_FLOAT,
      defaultValue = "0.0")
  @SimpleProperty
  public void Y(double y) {
    updateY(y);
    registerChange();
  }
 
  public double Y() {
    return originAtCenter ? yCenter : yTop;
  }
 
  @SimpleProperty
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_FLOAT,
                    defaultValue = DEFAULT_Z + "")
  public void Z(double layer) {
    this.zLayer = layer;
    canvas.changeSpriteLayer(this);  // Tell canvas about change
  }
 
  @SimpleProperty(
      description = "How the %type% should be layered relative to other Balls and ImageSprites, " +
          "with higher-numbered layers in front of lower-numbered layers.")
  public double Z() {
    return zLayer;
  }
 
  // This gets overridden in Ball with the @SimpleProperty and @DesignerProperty
  // annotations so it can be made a property for Ball but not for ImageSprite.
  protected void OriginAtCenter(boolean b) {
    originAtCenter = b;
  }
 
  // Methods for event handling: general purpose method postEvent() and
  // Simple events: CollidedWith, Dragged, EdgeReached, Touched, NoLongerCollidingWith,
  // Flung, TouchUp, and TouchDown.
 
  protected void postEvent(final Sprite sprite,
                           final String eventName,
                           final Object... args) {
    androidUIHandler.post(new Runnable() {
        public void run() {
          EventDispatcher.dispatchEvent(sprite, eventName, args);
        }});
  }
 
  // TODO(halabelson): Fix collision detection for rotated sprites.
  @SimpleEvent
  public void CollidedWith(Sprite other) {
    if (!registeredCollisions.contains(other)) {
      registeredCollisions.add(other);
      postEvent(this, "CollidedWith", other);
    }
  }
 
  @SimpleEvent(
      description = "Event handler called when a %type% is dragged. " +
          "On all calls, the starting coordinates " +
          "are where the screen was first touched, and the \"current\" coordinates " +
          "describe the endpoint of the current line segment. On the first call " +
          "within a given drag, the \"previous\" coordinates are the same as the " +
          "starting coordinates; subsequently, they are the \"current\" coordinates " +
          "from the prior call. Note that the %type% won't actually move " +
          "anywhere in response to the Dragged event unless MoveTo is explicitly called. " +
          "For smooth movement, each of its coordinates should be set to the sum of its " +
          "initial value and the difference between its current and previous values.")
  public void Dragged(float startX, float startY,
                      float prevX, float prevY,
                      float currentX, float currentY) {
    postEvent(this, "Dragged", startX, startY, prevX, prevY, currentX, currentY);
  }
 
  @SimpleEvent(
      description = "Event handler called when the %type% reaches an edge of the screen. " +
          "If Bounce is then called with that edge, the %type% will appear to " +
          "bounce off of the edge it reached. Edge here is represented as an integer that " +
          "indicates one of eight directions north (1), northeast (2), east (3), southeast (4), " +
          "south (-1), southwest (-2), west (-3), and northwest (-4).")
  public void EdgeReached(int edge) {
    if (edge == Component.DIRECTION_NONE
        || edge < Component.DIRECTION_MIN
        || edge > Component.DIRECTION_MAX) {
      // This should never be reached.
      return;
    }
    postEvent(this, "EdgeReached", edge);
  }
 
  @SimpleEvent(
      description = "Event handler called when a pair of sprites (Balls and ImageSprites) are no " +
          "longer colliding.")
  public void NoLongerCollidingWith(Sprite other) {
    registeredCollisions.remove(other);
    postEvent(this, "NoLongerCollidingWith", other);
  }
 
  @SimpleEvent(
    description = "Event handler called when the user touches an enabled " +
        "%type% and then immediately lifts their finger. The provided x and y coordinates " +
        "are relative to the upper left of the canvas.")
   public void Touched(float x, float y) {
    postEvent(this, "Touched", x, y);
  }
 
  @SimpleEvent(
      description = "Event handler called when a fling gesture (quick swipe) is made on " +
          "an enabled %type%. This provides the x and y coordinates of the start of the " +
          "fling (relative to the upper left of the canvas), the speed (pixels per millisecond), " +
          "the heading (0-360 degrees), and the x and y velocity components of " +
          "the fling's vector.")
  public void Flung(float x, float y, float speed, float heading, float xvel, float yvel) {
    postEvent(this, "Flung", x, y, speed, heading, xvel, yvel);
  }
 
  @SimpleEvent(
      description = "Event handler called when the user stops touching an enabled %type% " +
          "(lifting their finger after a TouchDown event). This provides the " +
          "x and y coordinates of the touch, relative to the upper left of the canvas.")
  public void TouchUp(float x, float y) {
    postEvent(this, "TouchUp", x, y);
  }
 
  @SimpleEvent(
      description = "Event handler called when the user begins touching an enabled %type% " +
          "(placing their finger on a %type% and leaving it there). This provides the " +
          "x and y coordinates of the touch, relative to the upper left of the canvas.")
  public void TouchDown(float x, float y) {
    postEvent(this, "TouchDown", x, y);
  }
 
  // Methods providing Simple functions:
  // Bounce, CollidingWith, MoveIntoBounds, MoveTo, PointTowards.
 
  @SimpleFunction(
    description = "Makes the %type% bounce, as if off a wall. " +
        "For normal bouncing, the edge argument should be the one returned by EdgeReached.")
  public void Bounce (int edge) {
    MoveIntoBounds();
 
    // Normalize heading to [0, 360)
    double normalizedAngle = userHeading % 360;
    // The following step is necessary because Java's modulus operation yields a
    // negative number if the dividend is negative and the divisor is positive.
    if (normalizedAngle < 0) {
      normalizedAngle += 360;
    }
 
    // Only transform heading if sprite was moving in that direction.
    // This avoids oscillations.
    if ((edge == Component.DIRECTION_EAST
         && (normalizedAngle < 90 || normalizedAngle > 270))
        || (edge == Component.DIRECTION_WEST
            && (normalizedAngle > 90 && normalizedAngle < 270))) {
      Heading(180 - normalizedAngle);
    } else if ((edge == Component.DIRECTION_NORTH
                && normalizedAngle > 0 && normalizedAngle < 180)
               || (edge == Component.DIRECTION_SOUTH && normalizedAngle > 180)) {
      Heading(360 - normalizedAngle);
    } else if ((edge == Component.DIRECTION_NORTHEAST
                && normalizedAngle > 0 && normalizedAngle < 90)
              || (edge == Component.DIRECTION_NORTHWEST
                  && normalizedAngle > 90 && normalizedAngle < 180)
              || (edge == Component.DIRECTION_SOUTHWEST
                  && normalizedAngle > 180 && normalizedAngle < 270)
              || (edge == Component.DIRECTION_SOUTHEAST && normalizedAngle > 270)) {
      Heading(180 + normalizedAngle);
    }
  }
 
  // This is primarily used to enforce raising only
  // one {@link #CollidedWith(Sprite)} event per collision but is also
  // made available to the Simple programmer.
  @SimpleFunction(
      description = "Indicates whether a collision has been registered between this %type% " +
          "and the passed sprite (Ball or ImageSprite).")
  public boolean CollidingWith(Sprite other) {
    return registeredCollisions.contains(other);
  }
 
  @SimpleFunction(
      description = "Moves the %type% back in bounds if part of it extends out of bounds, " +
          "having no effect otherwise. If the %type% is too wide to fit on the " +
          "canvas, this aligns the left side of the %type% with the left side of the " +
          "canvas. If the %type% is too tall to fit on the canvas, this aligns the " +
          "top side of the %type% with the top side of the canvas.")
  public void MoveIntoBounds() {
    moveIntoBounds(canvas.Width(), canvas.Height());
  }
 
  // Description is different for Ball and ImageSprite so overridden and described in subclasses.
  public void MoveTo(double x, double y) {
    updateX(x);
    updateY(y);
    registerChange();
  }
 
  @SimpleFunction(
    description = "Turns the %type% to point towards a designated " +
        "target sprite (Ball or ImageSprite). The new heading will be parallel to the line joining " +
        "the centerpoints of the two sprites.")
  public void PointTowards(Sprite target) {
    Heading(-Math.toDegrees(Math.atan2(target.yCenter - yCenter, target.xCenter - xCenter)));
  }
 
  @SimpleFunction(
    description = "Sets the heading of the %type% toward the point " +
        "with the coordinates (x, y).")
  public void PointInDirection(double x, double y) {
    Heading(-Math.toDegrees(Math.atan2(y - yCenter, x - xCenter)));
  }
 
  // Internal methods supporting move-related functionality
 
  protected void registerChange() {
    // This was added to fix bug 2262218, where Ball.CollidedWith() was called
    // before all components had been constructed.
    if (!initialized) {
      // During REPL, components are not initalized, but we still want to repaint the canvas.
      canvas.getView().invalidate();
      return;
    }
    int edge = hitEdge();
    if (edge != Component.DIRECTION_NONE) {
      EdgeReached(edge);
    }
    canvas.registerChange(this);
  }
 
  protected int hitEdge() {
    if (!canvas.ready()) {
      return Component.DIRECTION_NONE;
    }
 
    return hitEdge(canvas.Width(), canvas.Height());
  }
 
  protected final void moveIntoBounds(int canvasWidth, int canvasHeight) {
    boolean moved = false;
 
    // We set the xLeft and/or yTop fields directly, instead of calling X(123) and Y(123), to avoid
    // having multiple calls to registerChange.
 
    // Check if the sprite is too wide to fit on the canvas.
    if (Width() > canvasWidth) {
      // Sprite is too wide to fit. If it isn't already at the left edge, move it there.
      // It is important not to set moved to true if xLeft is already 0. Doing so can cause a stack
      // overflow.
      if (xLeft != 0) {
        xLeft = 0;
        xCenter = xLeftToCenter(xLeft);
        moved = true;
      }
    } else if (overWestEdge()) {
      xLeft = 0;
      xCenter = xLeftToCenter(xLeft);
      moved = true;
    } else if (overEastEdge(canvasWidth)) {
      xLeft = canvasWidth - Width();
      xCenter = xLeftToCenter(xLeft);
      moved = true;
    }
 
    // Check if the sprite is too tall to fit on the canvas. We don't want to cause a stack
    // overflow by moving the sprite to the top edge and then to the bottom edge, repeatedly.
    if (Height() > canvasHeight) {
      // Sprite is too tall to fit. If it isn't already at the top edge, move it there.
      // It is important not to set moved to true if yTop is already 0. Doing so can cause a stack
      // overflow.
      if (yTop != 0) {
        yTop = 0;
        yCenter = yTopToCenter(yTop);
        moved = true;
      }
    } else if (overNorthEdge()) {
      yTop = 0;
      yCenter = yTopToCenter(yTop);
      moved = true;
    } else if (overSouthEdge(canvasHeight)) {
      yTop = canvasHeight - Height();
      yCenter = yTopToCenter(yTop);
      moved = true;
    }
 
    // Then, call registerChange (just once!) if necessary.
    if (moved) {
      registerChange();
    }
  }
 
  protected void updateCoordinates() {
    xLeft += speed * headingCos;
    xCenter = xLeftToCenter(xLeft);
    yTop += speed * headingSin;
    yCenter = yTopToCenter(yTop);
  }
 
  // Methods for determining collisions with other Sprites and the edge
  // of the Canvas.
 
  private final boolean overWestEdge() {
    return xLeft < 0;
  }
 
  private final boolean overEastEdge(int canvasWidth) {
    return xLeft + Width() > canvasWidth;
  }
 
  private final boolean overNorthEdge() {
    return yTop < 0;
  }
 
  private final boolean overSouthEdge(int canvasHeight) {
    return yTop + Height() > canvasHeight;
  }
 
  protected int hitEdge(int canvasWidth, int canvasHeight) {
    // Determine in which direction(s) we are out of bounds, if any.
    // Note that more than one boolean value can be true.  For example, if
    // the sprite is past the northwest boundary, north and west will be true.
    boolean west = overWestEdge();
    boolean north = overNorthEdge();
    boolean east = overEastEdge(canvasWidth);
    boolean south = overSouthEdge(canvasHeight);
 
    // If no edge was hit, return.
    if (!(north || south || east || west)) {
      return Component.DIRECTION_NONE;
    }
 
    // Move the sprite back into bounds.  Note that we don't just reverse the
    // last move, since that might have been multiple pixels, and we'd only need
    // to undo part of it.
    MoveIntoBounds();
 
    // Determine the appropriate return value.
    if (west) {
      if (north) {
        return Component.DIRECTION_NORTHWEST;
      } else if (south) {
        return Component.DIRECTION_SOUTHWEST;
      } else {
        return Component.DIRECTION_WEST;
      }
    }
 
    if (east) {
      if (north) {
        return Component.DIRECTION_NORTHEAST;
      } else if (south) {
        return Component.DIRECTION_SOUTHEAST;
      } else {
        return Component.DIRECTION_EAST;
      }
    }
 
    if (north) {
      return Component.DIRECTION_NORTH;
    }
    if (south) {
      return Component.DIRECTION_SOUTH;
    }
 
    // This should never be reached.
    return Component.DIRECTION_NONE;
  }
 
  public BoundingBox getBoundingBox(int border) {
    return new BoundingBox(xLeft - border, yTop - border,
        xLeft + Width() - 1 + border, yTop + Height() - 1 + border);
  }
 
  public static boolean colliding(Sprite sprite1, Sprite sprite2) {
    // If the bounding boxes don't intersect, there can be no collision.
    BoundingBox rect1 = sprite1.getBoundingBox(1);
    BoundingBox rect2 = sprite2.getBoundingBox(1);
    if (!rect1.intersectDestructively(rect2)) {
      return false;
    }
 
    // If we get here, rect1 has been mutated to hold the intersection of the
    // two bounding boxes.  Now check every point in the intersection to see if
    // both sprites contain that point.
    // TODO(user): Handling abutting sprites properly
    for (double x = rect1.getLeft(); x <= rect1.getRight(); x++) {
      for (double y = rect1.getTop(); y <= rect1.getBottom(); y++) {
        if (sprite1.containsPoint(x, y) && sprite2.containsPoint(x, y)) {
          return true;
        }
      }
    }
    return false;
  }
 
  public boolean intersectsWith(BoundingBox rect) {
    // If the bounding boxes don't intersect, there can be no intersection.
    BoundingBox rect1 = getBoundingBox(0);
    if (!rect1.intersectDestructively(rect)) {
      return false;
    }
 
    // If we get here, rect1 has been mutated to hold the intersection of the
    // two bounding boxes.  Now check every point in the intersection to see if
    // the sprite contains it.
    for (double x = rect1.getLeft(); x < rect1.getRight(); x++) {
      for (double y = rect1.getTop(); y < rect1.getBottom(); y++) {
        if (containsPoint(x, y)) {
            return true;
        }
      }
    }
    return false;
  }
 
  public boolean containsPoint(double qx, double qy) {
    return qx >= xLeft && qx < xLeft + Width() &&
        qy >= yTop && qy < yTop + Height();
  }
 
  // Convenience methods for dealing with hitting the screen edge and collisions
 
  // AlarmHandler implementation
 
  public void alarm() {
    // This check on initialized is currently redundant, since registerChange()
    // checks it too.
    if (initialized && speed != 0) {
      updateCoordinates();
      registerChange();
    }
  }
 
  // Component implementation
 
  @Override
  public HandlesEventDispatching getDispatchDelegate() {
    return canvas.$form();
  }
 
  // OnDestroyListener implementation
 
  @Override
  public void onDestroy() {
    timerInternal.Enabled(false);
  }
 
  // Deleteable implementation
 
  @Override
  public void onDelete() {
    timerInternal.Enabled(false);
    canvas.removeSprite(this);
  }
 
  // Abstract methods that must be defined by subclasses
 
  protected abstract void onDraw(android.graphics.Canvas canvas);
}