423 lines
10 KiB
Java
423 lines
10 KiB
Java
package com.droidquest.items;
|
|
|
|
import java.awt.Color;
|
|
import java.awt.Graphics;
|
|
import java.awt.Graphics2D;
|
|
import java.awt.image.BufferedImage;
|
|
|
|
import javax.swing.ImageIcon;
|
|
|
|
import com.droidquest.Room;
|
|
|
|
public class Sentry extends Item
|
|
{
|
|
// Base class for all Sentries.
|
|
//
|
|
// Either individual Sentries will have different Animate functions, or
|
|
// they will be instances of this class and behave in a manner according
|
|
// to two arrays of numbers.
|
|
//
|
|
// int pace[] = {x1,y1} , {x2,y2}, ...
|
|
//
|
|
// int protect[] = {x1,y1, x2,y2, x3,y3}, ...
|
|
//
|
|
//
|
|
// The pace array is a list of XY pairs that define the path that the
|
|
// Sentry will follow. By default the Sentry paces by going to the first
|
|
// point, then the second, then third, and so on until the end of the
|
|
// list is reached at which point it goes back to the beginning. Most
|
|
// Sentries will probably have two points it paces back and forth
|
|
// between.
|
|
//
|
|
// The protect array consists of sets of 6 numbers, each set is three
|
|
// pairs of XY coordinates. The first two pairs define an area which
|
|
// triggers the Sentry to pounce. The third pair defines where the
|
|
// sentry will drag the player. This array can have any number of
|
|
// sextets of numbers. (The total size of the array must be divisable by
|
|
// six). Each block of six numbers defines an area and target the sentry
|
|
// guards.
|
|
//
|
|
// The smartblock variable tells the Sentry to pin a robot down if the
|
|
// player is inside it.
|
|
//
|
|
|
|
int animation = 0; // 0-3, 1 & 3 = icons[1]
|
|
public int behavior = 0; // 0+ for pacing, until pounce and drag. -1=pin.
|
|
public int previousBehavior;
|
|
int[] pace; // List of pacing cordinates
|
|
public int[] protect; // List of areas and targets
|
|
int goToX; // Current position pacing towards
|
|
int goToY; // ""
|
|
int carryToX; // Currently dragging towards
|
|
int carryToY; // ""
|
|
int pounce; // Pouncing behaviour number (pace.length/2)
|
|
int drag; // Dragging behavior number (pounce+1)
|
|
boolean smartblock; // Pins robots if they carry the player.
|
|
GenericRobot robot; // Robot to pin
|
|
|
|
public Sentry(int X, int Y, Room r)
|
|
{
|
|
x=X; y=Y; room=r;
|
|
width=28; height=18; orgY = 30;
|
|
grabbable = false;
|
|
GenerateIcons();
|
|
currentIcon = icons[0].getImage();
|
|
}
|
|
|
|
public Sentry(int X, int Y, Room r, int[] p1, int[] p2, boolean sb)
|
|
{
|
|
x=X; y=Y; room=r;
|
|
width=28; height=18; orgY = 30;
|
|
pace = p1;
|
|
protect = p2;
|
|
smartblock = sb;
|
|
pounce = pace.length /2;
|
|
drag = pounce+1;
|
|
grabbable = false;
|
|
behavior = 0;
|
|
goToX = pace[0];
|
|
goToY = pace[1];
|
|
GenerateIcons();
|
|
currentIcon = icons[0].getImage();
|
|
}
|
|
|
|
public void GenerateIcons()
|
|
{
|
|
icons = new ImageIcon[3];
|
|
icons[0]= new ImageIcon(new BufferedImage(width,height+orgY,BufferedImage.TYPE_4BYTE_ABGR));
|
|
icons[1]= new ImageIcon(new BufferedImage(width,height+orgY,BufferedImage.TYPE_4BYTE_ABGR));
|
|
icons[2]= new ImageIcon(new BufferedImage(width,height+orgY,BufferedImage.TYPE_4BYTE_ABGR));
|
|
Graphics g;
|
|
Graphics2D g2;
|
|
Color transparent = new Color(0,0,0,0);
|
|
|
|
// 0 = Legs out
|
|
try
|
|
{
|
|
g = icons[0].getImage().getGraphics();
|
|
}
|
|
catch (NullPointerException e)
|
|
{
|
|
System.out.println("Could not get Graphics pointer to " + getClass() + " Image");
|
|
return;
|
|
}
|
|
g2 = (Graphics2D) g;
|
|
g2.setBackground(transparent);
|
|
g2.clearRect(0,0,width,height+orgY);
|
|
g.setColor(Color.white);
|
|
if (smartblock) g.setColor(Color.blue);
|
|
g.fillRect(8,0,12,6);
|
|
g.fillRect(12,6,4,6);
|
|
g.fillRect(8,12,12,24);
|
|
g.fillRect(4,16,20,18);
|
|
g.fillRect(0,20,28,10);
|
|
g.fillRect(4,36,8,4);
|
|
g.fillRect(4,36,4,6);
|
|
g.fillRect(0,40,4,8);
|
|
g.fillRect(16,36,8,4);
|
|
g.fillRect(20,36,4,6);
|
|
g.fillRect(24,40,4,8);
|
|
g.setColor(Color.black);
|
|
g.fillRect(4,22,4,6);
|
|
g.fillRect(20,22,4,6);
|
|
g.fillRect(8,20,4,2);
|
|
g.fillRect(16,20,4,2);
|
|
g.fillRect(8,28,4,2);
|
|
g.fillRect(16,28,4,2);
|
|
g.fillRect(12,18,4,2);
|
|
g.fillRect(12,30,4,2);
|
|
g.fillRect(12,22,4,6);
|
|
|
|
|
|
// 1 = legs mid
|
|
try
|
|
{
|
|
g = icons[1].getImage().getGraphics();
|
|
}
|
|
catch (NullPointerException e)
|
|
{
|
|
System.out.println("Could not get Graphics pointer to " + getClass() + " Image");
|
|
return;
|
|
}
|
|
g2 = (Graphics2D) g;
|
|
g2.setBackground(transparent);
|
|
g2.clearRect(0,0,width,height+orgY);
|
|
g.setColor(Color.white);
|
|
if (smartblock) g.setColor(Color.blue);
|
|
g.fillRect(8,0,12,6);
|
|
g.fillRect(12,6,4,6);
|
|
g.fillRect(8,12,12,28);
|
|
g.fillRect(4,16,20,18);
|
|
g.fillRect(0,20,28,10);
|
|
g.fillRect(4,40,8,2);
|
|
g.fillRect(16,40,8,2);
|
|
g.fillRect(4,40,4,8);
|
|
g.fillRect(20,40,4,8);
|
|
g.setColor(Color.black);
|
|
g.fillRect(4,22,4,6);
|
|
g.fillRect(20,22,4,6);
|
|
g.fillRect(8,20,4,2);
|
|
g.fillRect(16,20,4,2);
|
|
g.fillRect(8,28,4,2);
|
|
g.fillRect(16,28,4,2);
|
|
g.fillRect(12,18,4,2);
|
|
g.fillRect(12,30,4,2);
|
|
g.fillRect(12,22,4,6);
|
|
|
|
|
|
// 2 = legs in
|
|
try
|
|
{
|
|
g = icons[2].getImage().getGraphics();
|
|
}
|
|
catch (NullPointerException e)
|
|
{
|
|
System.out.println("Could not get Graphics pointer to " + getClass() + " Image");
|
|
return;
|
|
}
|
|
g2 = (Graphics2D) g;
|
|
g2.setBackground(transparent);
|
|
g2.clearRect(0,0,width,height+orgY);
|
|
g.setColor(Color.white);
|
|
if (smartblock) g.setColor(Color.blue);
|
|
g.fillRect(8,0,12,6);
|
|
g.fillRect(12,6,4,36);
|
|
g.fillRect(8,12,12,24);
|
|
g.fillRect(4,16,20,18);
|
|
g.fillRect(0,20,28,10);
|
|
g.fillRect(8,40,4,8);
|
|
g.fillRect(16,40,4,8);
|
|
g.setColor(Color.black);
|
|
g.fillRect(4,22,4,6);
|
|
g.fillRect(20,22,4,6);
|
|
g.fillRect(8,20,4,2);
|
|
g.fillRect(16,20,4,2);
|
|
g.fillRect(8,28,4,2);
|
|
g.fillRect(16,28,4,2);
|
|
g.fillRect(12,18,4,2);
|
|
g.fillRect(12,30,4,2);
|
|
g.fillRect(12,22,4,6);
|
|
|
|
if (animation==3)
|
|
currentIcon = icons[1].getImage();
|
|
else
|
|
currentIcon = icons[animation].getImage();
|
|
|
|
}
|
|
|
|
public void Animate()
|
|
{
|
|
if (carrying==null) animation++;
|
|
if (animation==4) animation=0;
|
|
if (animation==3)
|
|
currentIcon = icons[1].getImage();
|
|
else
|
|
currentIcon = icons[animation].getImage();
|
|
|
|
if (behavior== -2)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (smartblock)
|
|
{
|
|
robot = PlayerInRobot(null);
|
|
if (robot != null)
|
|
{
|
|
previousBehavior = 0;
|
|
behavior=-1; // Pin Robot
|
|
}
|
|
else if (carrying!=null && behavior!=drag)
|
|
{
|
|
Drops();
|
|
behavior = previousBehavior;
|
|
}
|
|
}
|
|
|
|
if (behavior==-1)
|
|
{
|
|
if (carrying==null)
|
|
{
|
|
x=robot.x + robot.width/2 - width/2;
|
|
y=robot.y + robot.height/2 - height/2;
|
|
PicksUp(robot);
|
|
}
|
|
}
|
|
|
|
if (behavior >=0 && behavior < pounce)
|
|
if (protect.length >0 && level.player.room == room)
|
|
{
|
|
for (int p=0; p<protect.length/6; p++)
|
|
{
|
|
int x1= protect[p*6];
|
|
int y1= protect[p*6+1];
|
|
int x2= protect[p*6+2];
|
|
int y2= protect[p*6+3];
|
|
int x3= protect[p*6+4];
|
|
int y3= protect[p*6+5];
|
|
|
|
if (level.player.x >= x1
|
|
&& level.player.x <= x2
|
|
&& level.player.y >= y1
|
|
&& level.player.y <= y2)
|
|
{
|
|
carryToX = x3;
|
|
carryToY = y3;
|
|
previousBehavior = behavior;
|
|
if (previousBehavior >= pounce)
|
|
previousBehavior = 0;
|
|
behavior=pounce;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (behavior >=0 && behavior < pounce)
|
|
{
|
|
if (x == goToX && y == goToY)
|
|
{
|
|
behavior++;
|
|
if (behavior==pounce) behavior=0;
|
|
goToX = pace[behavior*2];
|
|
goToY = pace[behavior*2+1];
|
|
}
|
|
else
|
|
{
|
|
if (x != goToX)
|
|
{
|
|
int diff = Math.abs(goToX - x);
|
|
int dir = diff / (goToX - x);
|
|
if (diff > 8) diff = 8;
|
|
MoveRight(diff * dir);
|
|
}
|
|
if (y != goToY)
|
|
{
|
|
int diff = Math.abs(goToY - y);
|
|
int dir = diff / (goToY - y);
|
|
if (diff > 8) diff = 8;
|
|
MoveDown(diff * dir);
|
|
}
|
|
}
|
|
}
|
|
else if (behavior == pounce)
|
|
{
|
|
if (level.player.room != room)
|
|
behavior = previousBehavior;
|
|
if (animation==0)
|
|
{
|
|
x=level.player.x;
|
|
y=level.player.y;
|
|
}
|
|
if (x != level.player.x)
|
|
{
|
|
int diff = Math.abs(level.player.x - x);
|
|
int dir = diff / (level.player.x - x);
|
|
if (diff > 50) diff /= 2;
|
|
MoveRight(diff * dir);
|
|
}
|
|
if (y != level.player.y)
|
|
{
|
|
int diff = Math.abs(level.player.y - y);
|
|
int dir = diff / (level.player.y - y);
|
|
if (diff > 50) diff /= 2;
|
|
MoveDown(diff * dir);
|
|
}
|
|
if (x == level.player.x && y == level.player.y)
|
|
{
|
|
PicksUp(level.player);
|
|
// if (level.player.carrying != null)
|
|
// level.player.Drops();
|
|
behavior=drag;
|
|
}
|
|
}
|
|
else if (behavior == drag)
|
|
{
|
|
if (x == carryToX && y == carryToY)
|
|
{
|
|
Drops();
|
|
behavior=previousBehavior;
|
|
}
|
|
else
|
|
{
|
|
if (x != carryToX)
|
|
{
|
|
int diff = Math.abs(carryToX - x);
|
|
int dir = diff / (carryToX - x);
|
|
if (diff > 8) diff = 8;
|
|
MoveRight(diff * dir);
|
|
}
|
|
if (y != carryToY)
|
|
{
|
|
int diff = Math.abs(carryToY - y);
|
|
int dir = diff / (carryToY - y);
|
|
if (diff > 8) diff = 8;
|
|
MoveDown(diff * dir);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public GenericRobot PlayerInRobot(GenericRobot robot)
|
|
{
|
|
if (robot==null)
|
|
{
|
|
if (level.player.room.portalItem!=null)
|
|
{
|
|
if (level.player.room.portalItem.getClass().toString().endsWith("Robot"))
|
|
return (PlayerInRobot ((GenericRobot) level.player.room.portalItem));
|
|
else return (null);
|
|
}
|
|
else
|
|
return (null);
|
|
}
|
|
else
|
|
if (robot.room.portalItem != null)
|
|
{
|
|
if (robot.room.portalItem.getClass().toString().endsWith("Robot"))
|
|
return (PlayerInRobot ((GenericRobot) robot.room.portalItem));
|
|
else
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
if (robot.room == room)
|
|
return robot;
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public void MoveUp(int dist)
|
|
{
|
|
int newY = y-dist;
|
|
if (newY<0)
|
|
newY=0;
|
|
y=newY;
|
|
}
|
|
|
|
public void MoveDown(int dist)
|
|
{
|
|
int newY = y+dist;
|
|
if (newY>383)
|
|
newY=383;
|
|
y=newY;
|
|
}
|
|
|
|
public void MoveLeft(int dist)
|
|
{
|
|
int newX = x-dist;
|
|
if (newX<0)
|
|
newX=0;
|
|
x=newX;
|
|
}
|
|
|
|
public void MoveRight(int dist)
|
|
{
|
|
int newX = x+dist;
|
|
if (newX>579)
|
|
newX=579;
|
|
x=newX;
|
|
}
|
|
|
|
}
|
|
|