public void checkCollisions() {
Rectangle r3 = link.getBounds();
for (int j = 0; j < enemies.size(); j++) {
Enemy en = (Enemy) enemies.get(j);
Rectangle r2 = en.getBounds();
if (r3.intersects(r2)) {
link.setVisible(false);
en.setVisible(false);
ingame = false;
gamewin = false;
} // end if
} // end for loop
ArrayList as = link.getArrows();
for (int i = 0; i < as.size(); i++) {
Arrow aa = (Arrow) as.get(i);
Rectangle r1 = aa.getBounds();
for (int j = 0; j < enemies.size(); j++) {
Enemy a = (Enemy) enemies.get(j);
Rectangle r2 = a.getBounds();
if (r1.intersects(r2)) {
aa.setVisible(false);
a.setVisible(false);
} // end of if
} // end inner for loop
} // end outer for loop
} // end checkCollisions
public void move() {
double r = point.distance(arrow.getEnd());
g.setColor(Color.WHITE);
draw();
arrow.draw();
point.translate(arrow.getNext().getX() / 10, arrow.getNext().getY() / 10);
g.setColor(Color.BLACK);
draw();
g.setColor(Color.BLUE);
arrow.draw();
}
/** draw the arrows between items */
public void paintComponent(Graphics g) {
super.paintComponent(g);
if (_glist != null && _glist.size() > 1) {
Graphics2D g2 = (Graphics2D) g;
Arrow leftArrow = new Arrow();
leftArrow.setColor(Color.BLACK);
Arrow rightArrow = new Arrow();
rightArrow.setColor(Color.RED);
Iterator<GNode> iter = _glist.iterator();
while (iter.hasNext()) {
GNode nCur = iter.next();
if (nCur.left != null) {
leftArrow.setLine(nCur.getStart(), nCur.left.getEnd());
leftArrow.draw(g2);
}
if (nCur.right != null) {
rightArrow.setLine(nCur.getStart(), nCur.right.getEnd());
rightArrow.draw(g2);
}
}
}
}
protected final NoteBox createNoteBox(
StringBounder stringBounder,
Arrow arrow,
Component noteComp,
NotePosition notePosition,
Url url) {
final LivingParticipantBox p = arrow.getParticipantAt(stringBounder, notePosition);
final NoteBox noteBox = new NoteBox(arrow.getStartingY(), noteComp, p, null, notePosition, url);
if (arrow instanceof MessageSelfArrow && notePosition == NotePosition.RIGHT) {
noteBox.pushToRight(arrow.getPreferredWidth(stringBounder));
}
return noteBox;
}
private void bes(Graph graph) {
TetradLogger.getInstance().log("info", "** BACKWARD EQUIVALENCE SEARCH");
initializeArrowsBackward(graph);
while (!sortedArrows.isEmpty()) {
Arrow arrow = sortedArrows.first();
sortedArrows.remove(arrow);
Node x = arrow.getX();
Node y = arrow.getY();
clearArrow(x, y);
if (!validDelete(arrow.getHOrT(), arrow.getNaYX(), graph)) {
continue;
}
List<Node> h = arrow.getHOrT();
double bump = arrow.getBump();
delete(x, y, h, graph, bump);
score += bump;
rebuildPattern(graph);
storeGraph(graph);
initializeArrowsBackward(
graph); // Rebuilds Arrows from scratch each time. Fast enough for backwards.
}
}
@EventHandler(priority = EventPriority.HIGH)
public void removeItemFromFrame(EntityDamageByEntityEvent event) {
Entity victim = event.getEntity();
if (!victim.getType().equals(EntityType.ITEM_FRAME)) {
return;
}
Player p;
Entity attacker = event.getDamager();
// System.out.println("Attacker: "+attacker.getType().toString());
if (attacker.getType().toString().equals("PLAYER")) {
p = (Player) attacker;
OwnedLand land = OwnedLand.getApplicableLand(victim.getLocation());
if (land == null) {
return;
}
if (!land.hasPermTo(p, this)) {
p.sendMessage(
ChatColor.RED
+ getPlugin().getMessageConfig().getString("event.build.itemFrameRemoveWithMelee"));
event.setCancelled(true);
}
} else if (attacker.getType().toString().equals("ARROW")) {
Arrow a = (Arrow) attacker;
if (a.getShooter() instanceof Player) {
p = (Player) a.getShooter();
} else {
return;
}
OwnedLand land = OwnedLand.getApplicableLand(victim.getLocation());
if (land == null) {
return;
}
if (!land.hasPermTo(p, this)) {
p.sendMessage(
ChatColor.RED
+ getPlugin().getMessageConfig().getString("event.build.itemFrameRemoveWithArrow"));
event.setCancelled(true);
}
}
}
/**
* Paint the arrow in the panel, using the current style.
*
* @param g the graphic context.
*/
public void paintComponent(Graphics g) {
g.setColor(isSelected ? list.getSelectionBackground() : list.getBackground());
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(isSelected ? list.getSelectionForeground() : list.getForeground());
g.drawLine(getWidth() / 3, getHeight() / 2, 2 * getWidth() / 3, getHeight() / 2);
Arrow arrowDummy = new Arrow();
arrowDummy.drawArrowPixels(
new Graphics2DSwing(g),
getWidth() / 3,
getHeight() / 2,
2 * getWidth() / 3,
getHeight() / 2,
10,
4,
arrow.style);
}
Frontier prepareMessage(ConstraintSet constraintSet, InGroupablesStack inGroupablesStack) {
final Arrow graphic = createArrow();
final double arrowYStartLevel = graphic.getArrowYStartLevel(getStringBounder());
final double arrowYEndLevel = graphic.getArrowYEndLevel(getStringBounder());
for (LifeEvent lifeEvent : getMessage().getLiveEvents()) {
beforeMessage(lifeEvent, arrowYStartLevel);
}
final double length = graphic.getArrowOnlyWidth(getStringBounder());
incFreeY(graphic.getPreferredHeight(getStringBounder()));
double marginActivateAndDeactive = 0;
if (getMessage().isActivateAndDeactive()) {
marginActivateAndDeactive = 30;
incFreeY(marginActivateAndDeactive);
}
getDrawingSet().addEvent(getMessage(), graphic);
final LivingParticipantBox livingParticipantBox = getLivingParticipantBox();
if (messageArrow.getType().isRightBorder()) {
constraintSet
.getConstraint(livingParticipantBox.getParticipantBox(), constraintSet.getLastborder())
.ensureValue(length);
} else {
constraintSet
.getConstraint(constraintSet.getFirstBorder(), livingParticipantBox.getParticipantBox())
.ensureValue(length);
}
for (LifeEvent lifeEvent : getMessage().getLiveEvents()) {
afterMessage(getStringBounder(), lifeEvent, arrowYEndLevel + marginActivateAndDeactive);
}
assert graphic instanceof InGroupable;
if (graphic instanceof InGroupable) {
inGroupablesStack.addElement((InGroupable) graphic);
inGroupablesStack.addElement(livingParticipantBox);
}
return getFreeY();
}
@EventHandler
public void onProjectileHit(ProjectileHitEvent projectile) {
Heroes.debug.startTask("HeroesSkillListener");
if (!(projectile.getEntity() instanceof Arrow)) {
Heroes.debug.stopTask("HeroesSkillListener");
return;
}
Arrow arrow = (Arrow) projectile.getEntity();
if (!(arrow.getShooter() instanceof Player)) {
Heroes.debug.stopTask("HeroesSkillListener");
return;
}
Player player = (Player) arrow.getShooter();
Hero hero = SkillExplodingArrow.this.plugin.getCharacterManager().getHero(player);
if (!hero.hasEffect("ExplodingArrowBuff")) {
Heroes.debug.stopTask("HeroesSkillListener");
return;
}
int radius =
(int)
Math.pow(
SkillConfigManager.getUseSetting(hero, this.skill, "radius", 5, false), 2.0D);
float damage = SkillConfigManager.getUseSetting(hero, this.skill, "DAMAGE", 5, false);
float blockdamage = damage;
int block_dmg = SkillConfigManager.getUseSetting(hero, this.skill, "block-dmg", 0, false);
if (block_dmg == 0) {
blockdamage = 0.0F;
for (Entity t_entity : player.getWorld().getEntities()) {
if ((t_entity instanceof Player)) {
Player heroes = (Player) t_entity;
if ((heroes.equals(player))
|| (heroes.getLocation().distanceSquared(arrow.getLocation()) > radius)) continue;
damageEntity(
heroes, player, (int) damage, EntityDamageEvent.DamageCause.ENTITY_EXPLOSION);
} else if ((t_entity instanceof Creature)) {
Creature mob = (Creature) t_entity;
if (t_entity.getLocation().distanceSquared(arrow.getLocation()) <= radius) {
damageEntity(
mob, player, (int) damage, EntityDamageEvent.DamageCause.ENTITY_EXPLOSION);
}
}
}
}
arrow.getWorld().createExplosion(arrow.getLocation(), blockdamage);
Heroes.debug.stopTask("HeroesSkillListener");
}
@EventHandler(priority = EventPriority.HIGH)
public void destroyArmorStand(EntityDamageByEntityEvent event) {
Entity victim = event.getEntity();
// System.out.println("Victim: "+victim);
if (!victim.getType().equals(EntityType.ARMOR_STAND)) {
return;
}
OwnedLand land = OwnedLand.getApplicableLand(victim.getLocation());
if (land == null) {
return;
}
if (event.getDamager().getType().equals(EntityType.PLAYER)) {
Player attacker = (Player) event.getDamager();
// System.out.println(attacker.getName());
if (!land.hasPermTo(attacker, this)) {
attacker.sendMessage(
ChatColor.RED
+ getPlugin().getMessageConfig().getString("event.build.breakArmorStandWithMelee"));
event.setCancelled(true);
}
}
if (event.getDamager().getType().equals(EntityType.ARROW)) {
Arrow projectile = (Arrow) event.getDamager();
if (projectile.getShooter() instanceof Player) {
Player attacker = (Player) projectile.getShooter();
if (!land.hasPermTo(attacker, this)) {
attacker.sendMessage(
ChatColor.RED
+ getPlugin()
.getMessageConfig()
.getString("event.build.breakArmorStandWithArrow"));
event.setCancelled(true);
}
}
}
// System.out.println(event.getDamager().getType());
}
public Image getImage(Arrow a) {
if (a.getDirection() == GAUCHE) {
return liste.get(a.getActualFrame() - 1);
} else if (a.getDirection() == DROITE) {
return liste.get(a.getActualFrame() + frames - 1);
} else if (a.getDirection() == HAUT) {
return liste.get(a.getActualFrame() + 2 * frames - 1);
} else {
return liste.get(a.getActualFrame() + 3 * frames - 1);
}
}
public void actionPerformed(ActionEvent e) {
if (enemies.isEmpty()) {
newWave = true;
waveNum++;
incEnemies += 2;
if (waveNum == 14) {
ingame = false;
gamewin = true;
} // end if
else initEnemies();
} // end if
ArrayList as = link.getArrows();
for (int i = 0; i < as.size(); i++) {
Arrow a = (Arrow) as.get(i);
if (a.isVisible()) {
a.move();
} else {
as.remove(i);
}
} // end for
for (int i = 0; i < enemies.size(); i++) {
Enemy en = (Enemy) enemies.get(i);
if (en.isVisible()) {
en.move();
} else {
enemies.remove(i);
}
} // end for
link.move();
checkCollisions();
repaint();
} // end actionPerformed
private void updateArrows() {
switch (TouchPadInput.getCurrent().swipeDirection) {
case Up:
aroowUp.animateArrowOn();
break;
case Backward:
aroowLeft.animateArrowOn();
break;
case Down:
aroowDown.animateArrowOn();
break;
case Forward:
aroowRight.animateArrowOn();
break;
case Ignore:
break;
default:
break;
}
}
public void paintComponent(Graphics g) {
clearScreen(g);
drawGrid(g);
drawElements(g);
if (drawBondLine == true) {
Bond.drawDrag(g, Color.MAGENTA, elist.getSelected(), currentX, currentY);
}
if (drawArrowLine == true) {
Arrow.drawDrag(g, Color.BLUE, elist.getSelected(), currentX, currentY);
}
drawConnections(g);
}
/**
* Forward equivalence search.
*
* @param graph The graph in the state prior to the forward equivalence search.
*/
private void fes(Graph graph, List<Node> nodes) {
TetradLogger.getInstance().log("info", "** FORWARD EQUIVALENCE SEARCH");
lookupArrows = new HashMap<OrderedPair, Set<Arrow>>();
initializeArrowsForward(nodes);
while (!sortedArrows.isEmpty()) {
Arrow arrow = sortedArrows.first();
sortedArrows.remove(arrow);
Node x = arrow.getX();
Node y = arrow.getY();
clearArrow(x, y);
if (graph.isAdjacentTo(x, y)) {
continue;
}
if (!validInsert(x, y, arrow.getHOrT(), arrow.getNaYX(), graph)) {
continue;
}
List<Node> t = arrow.getHOrT();
double bump = arrow.getBump();
Set<Edge> edges = graph.getEdges();
insert(x, y, t, graph, bump);
score += bump;
rebuildPattern(graph);
// Try to avoid duplicating scoring calls. First clear out all of the edges that need to be
// changed,
// then change them, checking to see if they're already been changed. I know, roundabout, but
// there's
// a performance boost.
for (Edge edge : graph.getEdges()) {
if (!edges.contains(edge)) {
reevaluateForward(graph, nodes, edge.getNode1(), edge.getNode2());
}
}
storeGraph(graph);
}
}
private void mouseDown(MouseEvent e) {
if (game == null) return;
if (game.getGameState() != GameState.IN_PROGRESS) return;
if (e.button == 1) {
// check for drag event
if (beginDrag(e)) {
redraw();
return;
}
// update arrow on left mouse click
int x = e.x;
int y = e.y;
boolean del = true;
for (Iterator i = squareLocations.iterator(); i.hasNext(); ) {
Square s = (Square) i.next();
Rectangle r = s.r;
if (r.contains(x, y)) {
int n = s.x;
int m = s.y;
del = false;
if (arrow == null || n != arrow.x || m != arrow.y) {
arrow = new Arrow(n, m, Orientation.HORIZONTAL);
} else {
arrow.flip();
}
redraw();
}
}
if (del) {
getLocalTileRack().shuffle();
}
resetInput(del);
redraw();
} else {
// stop drag
doDrop(e);
// clear typed characters on right mouse click
resetInput(true);
redraw();
}
}
// Sorting is by bump, high to low.
public int compareTo(Object o) {
Arrow arrow = (Arrow) o;
return Double.compare(arrow.getBump(), getBump());
}
public void setForce(Point dir) {
arrow.setEnd(dir);
force.setLocation(dir);
}
protected IPrimitive<?> createExpandCollapseButton() {
final boolean isExpanded = presenter.isExpanded();
final double w = getGrid().getIconSize();
final double h = getGrid().getIconSize() / 1.5;
final Rectangle rectangle =
new Rectangle(w, h).setFillAlpha(0.01).setStrokeWidth(0).setStrokeAlpha(0);
final Arrow expandArrow =
new Arrow(
new Point2D(0, h / 2),
new Point2D(w, h / 2),
h / 2,
h,
45,
90,
ArrowType.AT_END_TAPERED)
.setFillColor(getArrowOutColor())
.setFillAlpha(0.5)
.setVisible(!isExpanded);
final Arrow collapseArrow =
new Arrow(
new Point2D(w, h / 2),
new Point2D(0, h / 2),
h / 2,
h,
45,
90,
ArrowType.AT_END_TAPERED)
.setFillColor(getArrowOutColor())
.setFillAlpha(0.5)
.setVisible(isExpanded);
handlerRegistrationManager.register(
rectangle.addNodeMouseClickHandler(
nodeMouseClickEvent -> {
if (presenter.isExpanded()) {
expandArrow.setVisible(true);
collapseArrow.setVisible(false);
presenter.collapse();
} else {
expandArrow.setVisible(false);
collapseArrow.setVisible(true);
presenter.expand();
}
}));
handlerRegistrationManager.register(
rectangle.addNodeMouseEnterHandler(
nodeMouseEnterEvent -> {
stopHoverTimeoutPalette();
if (presenter.isExpanded()) {
animate(collapseArrow, getArrowHoverColor(), 1, 1);
} else {
animate(expandArrow, getArrowHoverColor(), 1, 1);
}
}));
handlerRegistrationManager.register(
rectangle.addNodeMouseExitHandler(
nodeMouseExitEvent -> {
startHoverTimeoutPalette();
if (presenter.isExpanded()) {
animate(collapseArrow, getArrowOutColor(), 0.5, 0.5);
} else {
animate(expandArrow, getArrowOutColor(), 0.5, 0.5);
}
}));
return new Group().add(expandArrow).add(collapseArrow).add(rectangle.moveToTop());
}
public void paint(Graphics g) {
super.paint(g);
if (ingame) {
Graphics2D g2d = (Graphics2D) g;
if (link.isVisible()) {
g2d.drawImage(link.getImage(), link.getX(), link.getY(), this);
} // end inner if
ArrayList as = link.getArrows();
for (int i = 0; i < as.size(); i++) {
Arrow a = (Arrow) as.get(i);
g.setColor(new Color(96, 64, 32));
g.fillRect(a.getX(), a.getY(), a.width, a.height);
g.setColor(Color.GRAY);
int[] xPoints = {a.getX() + a.width, a.getX() + a.width + 10, a.getX() + a.width};
int[] yPoints = {a.getY() + a.height + 2, a.getY() + (a.height / 2), a.getY() - 2};
g.fillPolygon(xPoints, yPoints, 3);
} // end for
for (int i = 0; i < enemies.size(); i++) {
Enemy en = (Enemy) enemies.get(i);
if (en.isVisible()) {
g2d.drawImage(en.getImage(), en.getX(), en.getY(), this);
} // end inner if
} // end for
g2d.setColor(Color.WHITE);
g2d.drawString("Enemies left: " + enemies.size(), 5, 15);
if (waveNum < 13) {
g2d.setColor(Color.WHITE);
g2d.drawString("Wave: " + waveNum, 5, 30);
} else {
g2d.setColor(Color.WHITE);
g2d.drawString("Final Wave!", 5, 30);
}
} else if (gamewin) {
String msg = "You Win!";
Font small = new Font("Helvetica", Font.BOLD, 14);
FontMetrics metr = this.getFontMetrics(small);
g.setColor(Color.white);
g.setFont(small);
g.drawString(msg, (600 - metr.stringWidth(msg)) / 2, 600 / 2);
} else {
String msg = "Game Over";
Font small = new Font("Helvetica", Font.BOLD, 14);
FontMetrics metr = this.getFontMetrics(small);
g.setColor(Color.white);
g.setFont(small);
g.drawString(msg, (600 - metr.stringWidth(msg)) / 2, 600 / 2);
} // end outter if
Toolkit.getDefaultToolkit().sync();
g.dispose();
} // end paint
private void keyPressed(KeyEvent e) {
if (game == null) return;
if (game.getGameState() != GameState.IN_PROGRESS) return;
char c = Character.toLowerCase(e.character);
if (c >= 'a' && c <= 'z') {
// type letters on the board
if (arrow != null) {
IBoard board = game.getBoard();
if (arrow.x >= board.getWidth()) return;
if (arrow.y >= board.getHeight()) return;
Tile boardTile = game.getBoard().getTile(arrow.y, arrow.x);
if (!boardTile.equals(Tile.NONE)) {
if (c == boardTile.getLetter()) {
arrow.advance();
redraw();
}
return;
}
Tile tile = new Tile(c);
boolean wild = false;
if (!tileRack.contains(tile)) {
tile = new Tile('?');
if (!tileRack.contains(tile)) {
return;
}
wild = true;
}
tileRack.remove(tile);
tile = new Tile(c, wild);
placedTiles.put(new Point(arrow.x, arrow.y), tile);
arrow.advance();
}
updateMoveString();
redraw();
} else if (c == SWT.DEL || c == SWT.BS) {
// backspace a typed character on the board
if (placedTiles.size() > 0) {
arrow.backup();
Point point = new Point(arrow.x, arrow.y);
Tile tile = placedTiles.get(point);
if (tile != null) {
if (tile.isWild()) tile = new Tile('?');
tileRack.add(tile);
placedTiles.remove(point);
} else {
arrow.advance();
}
updateMoveString();
redraw();
}
} else if (c == '1') {
// toggle coordinates
showCoordinates = !showCoordinates;
redraw();
} else if (e.keyCode == SWT.ESC) {
// clear typed characters
resetInput(true);
redraw();
} else if (e.keyCode == SWT.CR || e.keyCode == SWT.KEYPAD_CR) {
// submit move on enter key
done.run();
} else if (c == ' ') {
getLocalTileRack().shuffle();
resetInput(true);
redraw();
}
}
