Coord.java

/*
 *  This file is part of the Haven & Hearth game client.
 *  Copyright (C) 2009 Fredrik Tolf <fredrik@dolda2000.com>, and
 *                     Björn Johannessen <johannessen.bjorn@gmail.com>
 *
 *  Redistribution and/or modification of this file is subject to the
 *  terms of the GNU Lesser General Public License, version 3, as
 *  published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  Other parts of this source tree adhere to other copying
 *  rights. Please see the file `COPYING' in the root directory of the
 *  source tree for details.
 *
 *  A copy the GNU Lesser General Public License is distributed along
 *  with the source tree of which this file is a part in the file
 *  `doc/LPGL-3'. If it is missing for any reason, please see the Free
 *  Software Foundation's website at <http://www.fsf.org/>, or write
 *  to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 *  Boston, MA 02111-1307 USA
 */

package haven;

import static java.lang.Math.PI;

public class Coord implements Comparable<Coord>, java.io.Serializable {
    public int x, y;
    public static Coord z = new Coord(0, 0);
	
    public Coord(int x, int y) {
	this.x = x;
	this.y = y;
    }
	
    public Coord(Coord c) {
	this(c.x, c.y);
    }
	
    public Coord() {
	this(0, 0);
    }
    
    public Coord(String str) {
	int x,y;
	if((str == null)||(str.charAt(0)!='(')||(str.charAt(str.length()-1)!=')'))
	    x = y = 0;
	else {
	    str = str.substring(1,str.length()-1);
	    String val[] = str.split(", ");
	    x = Integer.parseInt(val[0]);
	    y = Integer.parseInt(val[1]);
	}
	this.x = x;
	this.y = y;
    }
    
    public Coord(java.awt.Dimension d) {
	this(d.width, d.height);
    }
	
    public static Coord sc(double a, double r) {
	return(new Coord((int)(Math.cos(a) * r), -(int)(Math.sin(a)* r)));
    }
	
    public boolean equals(Object o) {
	if(!(o instanceof Coord))
	    return(false);
	Coord c = (Coord)o;
	return((c.x == x) && (c.y == y));
    }
	
    public int compareTo(Coord c) {
	if(c.y != y)
	    return(c.y - y);
	if(c.x != x)
	    return(c.x - x);
	return(0);
    }
	
    public Coord add(int ax, int ay) {
	return(new Coord(x + ax, y + ay));
    }
	
    public Coord add(Coord b) {
	return(add(b.x, b.y));
    }
	
    public Coord sub(int ax, int ay) {
	return(new Coord(x - ax, y - ay));
    }
	
    public Coord sub(Coord b) {
	return(sub(b.x, b.y));
    }
	
    public Coord mul(int f) {
	return(new Coord(x * f, y * f));
    }
    
    public Coord mul(double f) {
	return(new Coord((int)(x * f), (int)(y * f)));
    }
	
    public Coord inv() {
	return(new Coord(-x, -y));
    }
	
    public Coord mul(Coord f) {
	return(new Coord(x * f.x, y * f.y));
    }
    
    public Coord mul(int a, int b) {
	return(new Coord(x * a, y * b));
    }
	
    public Coord div(Coord d) {
	int v, w;
		
	v = ((x < 0)?(x + 1):x) / d.x;
	w = ((y < 0)?(y + 1):y) / d.y;
	if(x < 0)
	    v--;
	if(y < 0)
	    w--;
	return(new Coord(v, w));
    }
	
    public Coord div(int d) {
	return(div(new Coord(d, d)));
    }

    public Coord div(double f) {
	return(new Coord((int)(x / f), (int)(y / f)));
    }
    
    public Coord mod(Coord d) {
	int v, w;
		
	v = x % d.x;
	w = y % d.y;
	if(v < 0)
	    v += d.x;
	if(w < 0)
	    w += d.y;
	return(new Coord(v, w));
    }

    public Coord swap(){
	return new Coord(y, x);
    }
    
    public Coord abs(){
	return new Coord(Math.abs(x), Math.abs(y));
    }
    
    public int sum(){
	return x+y;
    }
    
    public boolean isect(Coord c, Coord s) {
	return((x >= c.x) && (y >= c.y) && (x < c.x + s.x) && (y < c.y + s.y));
    }
	
    public String toString() {
	return("(" + x + ", " + y + ")");
    }
	
    public double angle(Coord o) {
	Coord c = o.add(this.inv());
	if(c.x == 0) {
	    if(c.y < 0)
		return(-PI / 2);
	    else
		return(PI / 2);
	} else {
	    if(c.x < 0) {
		if(c.y < 0)
		    return(-PI + Math.atan((double)c.y / (double)c.x));
		else
		    return(PI + Math.atan((double)c.y / (double)c.x));
	    } else {
		return(Math.atan((double)c.y / (double)c.x));
	    }
	}
    }
	
    public double dist(Coord o) {
	long dx = o.x - x;
	long dy = o.y - y;
	return(Math.sqrt((dx * dx) + (dy * dy)));
    }
}