please answer correctly and show the result of the compiled code given in the qestio 5188805

please answer correctly and show the result of the compiled code. given in the qestion are all the required code needed to solve the problem.

Bubbles

Consider the world of bubbles. We will only consider red and blue bubbles for now. First, look at what is in the provided abstract Bubble class. Your task will be to implement two subclasses: RedBubble and BlueBubble. Their behaviour is described below.

Do not change the Bubble class.

RedBubble

Red bubbles bounce of the world boundaries and like to eat blue bubbles. They will move towards (chase) the closest blue bubble in the world. This class should have the constructor

public RedBubble(int x, int y, int speedX, int speedY, double radius, int health)

that sets its attributes based on the input parameters, and also sets its colour attribute to red (Bubble.COLOURS[0]).

The logic of a red bubble (applyLogic) is defined as follows:

red bubbles ignore each other. They can overlap in space and do nothing when they collide.

red bubbles will chase (move towards) the closest blue bubble in the world.

when a red bubble collides with a blue bubble (catches a blue bubble), the blue bubble gives all of its health points to the red bubble.

red bubbles bounce off of the world boundaries in a natural way. For example, if a red ball hits one of the vertical walls (left or right), it negates its speedX value.

BlueBubble

Blue bubbles always stay on either the left side of the world or the right. When two blue bubbles collide, they share some health points.

This class should have the constructor

public BlueBubble(int x, int y, int speedX, int speed, double radius, int health)

that sets its attributes based on the input parameters, and also sets its colour attribute to blue (Bubble.COLOURS[1]).

The logic of a blue bubble (applyLogic) is defined as follows:

a blue bubble will always stay on the left 1/2 of the world or the right 1/2 of the world. They will bounce (in a natural way) off of the world boundaries and the invisible boundary that separates the left and right sides of the world.

blue bubbles reverse their direction whenever they collide with another bubble (of any colour).

when a blue bubble collides with a red bubble (as described above), it loses all of its health points.

when a blue bubble collides with another blue bubble, if one of the bubbles has 2 or more health points compared to the other, it gives one of them to the other. That is, they share health points.

if a blue bubble has zero health points, it stops moving. If another blue bubble collides with it, and shares a health point with it, it will start to move in a random direction.

a blue bubble is allowed to move 1.5 times faster than a red bubble. (Override the update method of the blue bubble class to allow for this.)

Cards (Implementing the Comparable Interface)

Consider the provided abstract Card class. You will implement a concrete subclass called StandardCard. You will also modify the Card class by adding appropriate (hidden) state.

A standard deck of cards consist of 52 cards. Each card has a rank (2, 3, …, 9, 10, Jack, Queen, King, Ace) and a suit (spades, hearts, clubs, diamonds).

The ordering of standard cards is first specified by suits and then by rank if two cards have the same suits. The ordering of suits is

diamonds

If two standard cards have the same suit, then ordering is based on rank as follows

2

Two standard cards with the same suit and rank are equal to each other.

Be sure that all inherited methods are implemented as specified (either in this document or in the comments of Card).

BUBBLE.JAVA

public abstract class Bubble{
	/* maximum speed */
	public static double MAX_SPEED = 4;
	/* colours avaialable */
	public static final String[] COLOURS = {“Red”, “Blue”, “Green”};
	/* attributes */
	protected String name; // name of bubble
	protected int health; // health of bubble
	protected int treasure; // treasure of bubble
	protected String colour; // colour of bubble
	protected double radius; // size of bubble
	protected int x, y; // position of bubble
	protected double speedX, speedY; // speed of bubble
	protected int count = 0; // internal counter
	/* constructor */
	public Bubble(int x, int y, double radius){
	this.x = x;
	this.y = y;
	this.radius = radius;
	this.health = this.health = 0;
	this.speedX = this.speedY = 0.0;
	}
	/* getters */
	public String getName(){ return this.name; }
	public int getHealth(){ return this.health; }
	public int getTreasure(){ return this.treasure; }
	public String getColour(){ return this.colour; }
	public double getRadius(){ return this.radius; }
	public int getX(){ return this.x; }
	public int getY(){ return this.y; }
	public double getSpeedX(){ return this.speedX; }
	public double getSpeedY(){ return this.speedY; }
	/* setters */
	public void setName(String name){ this.name = name; }
	public void setHealth(int health){ this.health = health; }
	public void setTreasure(int treasure){ this.treasure = treasure; }
	public void setColour(String colour){ this.colour = colour; }
	public void setRadius(double radius){ this.radius = radius; }
	public void setX(int x){ this.x = x; }
	public void setY(int y){ this.y = y; }
	public void setSpeedX(double dx){ this.speedX = dx; }
	public void setSpeedY(double dy){ this.speedY = dy; }
	/* methods */
	/* make sure bubbles do not move too fast */
	public void capSpeed(double max){
	double s2 = speedX*speedX + speedY + speedY; // speed squared
	if( s2 > max*max ){
	double s = Math.sqrt(s2);
	speedX = speedX/s*max;
	speedY = speedY/s*max;
	}
	}
	/** checks if current bubble has collided with another bubble
	*
	* @param other is a bubble object
	* @return true if this and other are overlapping in space, false otherwise
	*/
	public boolean collidesWith(Bubble other){
	// distance between centres of bubbles squared
	double distance2 = (x-other.x)*(x-other.x) + (y-other.y)*(y-other.y);
	return distance2
	}
	/** checks if current bubble has collided with the border of its world.
	*
	* The world is is a rectangle defined by it top-left corner and
	* bottom-right corner. Bubbles live in the interior of this world.
	* Treat a bubble like a box centred at the bubble's centre. Do not
	* worry about the curvature of the bubble for this collision detection.
	*
	* @param x1 is x-coordinate of upper left corner boundary
	* @param y1 is y-coordinate of upper left corner boundary
	* @param x2 is x-coordinate of lower right corner boundary
	* @param y2 is y-coordinate of lower right corner boundary
	* @return true if this has hit the wall, false otherwise
	*/
	public boolean hitsWall(int x1, int y1, int x2, int y2){
	return y-radius <= y1 || y+radius >= y2 || x-radius <= x1 || x+radius >= y2;
	}
	/** the brain behind the bubble
	*
	* @param bubbles contains all bubbles in the world
	* @param x1 is x-coordinate of upper left corner boundary
	* @param y1 is y-coordinate of upper left corner boundary
	* @param x2 is x-coordinate of lower right corner boundary
	* @param y2 is y-coordinate of lower right corner boundary
	*/
	public abstract void applyLogic(Bubble[] bubbles, int x1, int y1, int x2, int y2);
	/** updates current bubble object */
	public void update(){
	this.capSpeed(MAX_SPEED);
	this.x = (int) (this.x + this.speedX);
	this.y = (int) (this.y + this.speedY);
	}
CARD.JAVA public abstract class Card implements Comparable{ /* handy arrays for ranks and suits */ /* do NOT change these */ public final static String[] RANKS = { “None”, “None”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “10”, “Jack”, “Queen”, “King”, “Ace”}; public final static String[] SUITS = { “Diamonds”, “Clubs”, “Hearts”, “Spades”}; /** creates a card with specified suit and rank * * @param suit is the suit of the card (must be a string from Card.SUITS) * @param rank is the rank of the card (must be a string from Card.RANKS) */ public Card(String suit, String rank){ // add code here if needed } /** the numerical representation of the rank of the current card * * ranks have the numerical values * 2 = 2, 3 = 3, …, 10 = 10 * Jack = 11, Queen = 12, King = 13, Ace = 14 * * @return the numerical rank of this card */ public abstract int getRank(); /** the string representation of the rank of the current card * * @return the string representation of the rank of this card (must be a string from Card.RANKS) */ public abstract String getRankString(); /** the suit of the current card * * @return the suit of this card (must be a string from Card.SUITS) */ public abstract String getSuit(); @Override public final String toString(){ // outputs a string representation of a card object int r = getRank(); if( r >= 2 && r return r + getSuit().substring(0,1); } return “invalid card”; } }	}