Treer
/
amidstest
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleaned up mapviewer

master
flying sheep 2013-04-13 22:33:52 +02:00
parent f3f3b05faf
commit ab65ccfb83
4 changed files with 109 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

199
src/MoF/MapViewer.java
View File

@ -20,6 +20,7 @@ import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.awt.geom.Point2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
@ -38,68 +39,37 @@ public class MapViewer extends JComponent implements MouseListener, MouseWheelLi
private static final long serialVersionUID = -8309927053337294612L;
private Project proj;
private int fragXMax = 0, fragYMax = 0, fragX = 0, fragY = 0;
private boolean mTracking = false, resized = false;
private double mX = 0, mY = 0, tX = 0, tY = 0;
private PieChart chart;
private ArrayList<ArrayList<Fragment>> frags;
private JPopupMenu menu = new JPopupMenu();
private JPopupMenu menu = new JPopupMenu();
private double scale = 1;
private boolean dataChange, sizeChange, firstRun;
public int strongholdCount, villageCount;
private Map testMap;
private float lastMouseX, lastMouseY;
private float panSpeedX, panSpeedY;
private boolean mouseDown;
private Point lastMouse;
private Point2D.Double panSpeed;
private int zoomLevel = 0, zoomTicksRemaining = 0;
private float targetZoom = 1.0f, curZoom = 1.0f;
private float zoomMouseX, zoomMouseY;
private static int offset[] = new int[] {
-1,-1,
-1, 0,
-1, 1,
0,-1,
0, 1,
1,-1,
1, 0,
1, 1
};
private Point zoomMouse;
public void dispose() {
System.out.println("DISPOSING OF MAPVIEWER");
for (int ey = 0; ey < fragYMax; ey++) {
for (int ex = 0; ex < fragXMax; ex++) {
Fragment tempFrag = frags.get(ey).get(ex);
tempFrag.dispose();
}
frags.get(ey).clear();
}
frags.clear();
frags = null;
testMap.dispose();
chart.dispose();
menu.removeAll();
proj = null;
}
MapViewer(Project proj) {
dataChange = true;
sizeChange = true;
firstRun = true;
this.addMouseListener(this);
resized = true;
this.addComponentListener(this);
this.addMouseWheelListener(this);
chart = new PieChart(0, 0); //TODO: do something with chart
panSpeed = new Point2D.Double();
this.proj = proj;
testMap = new Map(proj.manager);
testMap.addLayer(new BiomeLayer());
testMap.load();
testMap = new Map(proj.manager, new BiomeLayer()); //TODO: implement more layers
addMouseListener(this);
addComponentListener(this);
addMouseWheelListener(this);
}
@Override
@ -112,105 +82,55 @@ public class MapViewer extends JComponent implements MouseListener, MouseWheelLi
g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
g2d.setFont(new Font("arial", Font.BOLD, 15));
g2d.drawString(Options.instance.getSeedMessage(), 20, 30);
if (mTracking) {
Point p = this.getMousePosition();
if (p!=null) {
mX += (p.x - tX);
mY += (p.y - tY);
tX = p.x;
tY = p.y;
}
}
if (zoomTicksRemaining-- > 0) {
float lastZoom = curZoom;
curZoom = (targetZoom + curZoom) * 0.5f;
double targetZoomX = testMap.getScaledX(lastZoom, curZoom, zoomMouseX);
double targetZoomY = testMap.getScaledY(lastZoom, curZoom, zoomMouseY);
testMap.moveBy(targetZoomX, targetZoomY);
Point2D.Double targetZoom = testMap.getScaled(lastZoom, curZoom, zoomMouse);
testMap.moveBy(targetZoom);
testMap.setZoom(curZoom);
}
if (mouseDown) {
Point curMouse = this.getMousePosition();
if (lastMouse != null) {
Point curMouse = getMousePosition();
if (curMouse != null) {
float difX = curMouse.x - lastMouseX;
float difY = curMouse.y - lastMouseY;
double difX = curMouse.x - lastMouse.x;
double difY = curMouse.y - lastMouse.y;
// TODO : Scale with time
panSpeedX = difX * 0.2f;
panSpeedY = difY * 0.2f;
lastMouseX += panSpeedX;
lastMouseY += panSpeedY;
panSpeed.setLocation(difX * 0.2f, difY * 0.2f);
}
lastMouse.translate((int) panSpeed.x, (int)panSpeed.y);
}
panSpeedX *= 0.95f;
panSpeedY *= 0.95f;
panSpeed.x *= 0.95f;
panSpeed.y *= 0.95f;
testMap.moveBy(panSpeedX, panSpeedY);
testMap.moveBy(panSpeed.x, panSpeed.y);
testMap.draw(g2d);
}
public Project getProject() {
return proj;
}
public void centerAt(double x, double y) {
double adjX, adjY, zx, zy;
zx = x;
zy = y;
scale = 1;
int fs = Project.FRAGMENT_SIZE;
adjX = Math.floor(zx/fs) - 1;
adjY = Math.floor(zy/fs) - 1;
mX = -1*(Math.floor(zx - getWidth()/(2)) - (adjX + 1)*fs);
mY = -1*(Math.floor(zy - getHeight()/(2)) - (adjY + 1)*fs);
fragX = (int)adjX;
fragY = (int)adjY;
testMap.centerOn(x, y);
}
public void centerAndReset(double x, double y) {
centerAt(x,y);
scale = 1;
centerAt(x, y);
}
public void setScale(double scale) {
if ((scale <= 8)&&(scale >= 0.25)) {
if ((scale <= 8) && (scale >= 0.25)) {
this.scale = scale;
sizeChange = true;
}
}
public void scaleBy(double scale) {
setScale(this.scale*scale);
}
private int getWriteX(int in) {
int ex = in % fragXMax;
if (ex < 0)
ex += fragXMax;
return ex;
}
private int getWriteY(int in) {
int ey = in % fragYMax;
if (ey < 0)
ey += fragYMax;
return ey;
}
@SuppressWarnings("unused")
private int getWrite(int in, int max) {
int ew = in % max;
if (ew < 0)
ew += max;
return ew;
}
public void mouseWheelMoved(MouseWheelEvent e) {
Point curMouse = getMousePosition();
zoomMouseX = curMouse.x;
zoomMouseY = curMouse.y;
zoomMouse = getMousePosition();
int notches = e.getWheelRotation();
if (notches > 0) {
@ -242,68 +162,45 @@ public class MapViewer extends JComponent implements MouseListener, MouseWheelLi
public void mouseExited(MouseEvent arg0) {
}
@Override
public void mousePressed(MouseEvent arg0) {
if (!arg0.isMetaDown()) {
mTracking = true;
Point curMouse = this.getMousePosition();
tX = curMouse.x;
tY = curMouse.y;
lastMouseX = curMouse.x;
lastMouseY = curMouse.y;
mouseDown = true;
}
public void mousePressed(MouseEvent e) {
if (!e.isMetaDown())
lastMouse = getMousePosition();
}
private int tempX, tempY;
@Override
public void mouseReleased(MouseEvent e) {
if (e.isPopupTrigger() && Options.instance.saveEnabled) {
if (proj.saveLoaded) {
tempX = e.getX();
tempY = e.getY();
menu.show(e.getComponent(), e.getX(), e.getY());
}
} else {
mouseDown = false;
mTracking = false;
}
} else lastMouse = null;
}
@Override
public void componentHidden(ComponentEvent arg0) {
}
@Override
public void componentMoved(ComponentEvent arg0) {
}
@Override
public void componentResized(ComponentEvent arg0) {
resized = true;
}
@Override
public void componentShown(ComponentEvent arg0) {
}
public void componentHidden(ComponentEvent arg0) {}
public void componentMoved(ComponentEvent arg0) {}
public void componentResized(ComponentEvent arg0) {}
public void componentShown(ComponentEvent arg0) {}
public MapObject getSelectedObject() {
return proj.curTarget;
}
public PieChart getChart() {
return chart;
}
public void setChart(PieChart chart) {
this.chart = chart;
}
public void movePlayer(String name, ActionEvent e) {
//PixelInfo p = getCursorInformation(new Point(tempX, tempY));
//proj.movePlayer(name, p);
}
public void saveToFile(File f) {
/*TODO
int fs = Project.FRAGMENT_SIZE;
BufferedImage img = new BufferedImage(fragXMax*fs,fragYMax*fs,BufferedImage.TYPE_INT_ARGB);
Graphics2D g2d = img.createGraphics();
@ -345,6 +242,6 @@ public class MapViewer extends JComponent implements MouseListener, MouseWheelLi
}
g2d.dispose();
img.flush();
*/
}
}

15
src/MoF/PieChart.java
View File

@ -1,7 +1,6 @@
package MoF;
import java.awt.Graphics2D;
public class PieChart {
private float[] slices;
private int sources;
@ -11,9 +10,8 @@ public class PieChart {
}
public void addData(float[] sData) {
for (int i = 0; i < slices.length; i++) {
slices[i] += sData[i]/(float)sources;
}
for (int i = 0; i < slices.length; i++)
slices[i] += sData[i] / (float)sources;
}
public void setSources(int num) {
@ -25,14 +23,15 @@ public class PieChart {
slices[i] = 0;
}
}
public void dispose() {
this.slices = null;
}
public void paint(Graphics2D g2d, int x, int y, int width, int height) {
float max = 0.0f;
for (int i = 0; i < slices.length; i++) {
max += slices[i];
}
for (float slice : slices)
max += slice;
int angle = 0;
float tp = 360f;
for (int i = 0; i < slices.length; i++) {
@ -42,8 +41,6 @@ public class PieChart {
newangle = 360 - angle;
g2d.fillArc(x, y, width, height, angle, newangle);
angle += newangle;
}
}
}

60
src/amidst/map/FragmentManager.java
View File

@ -2,6 +2,7 @@ package amidst.map;
import java.io.File;
import java.util.Arrays;
import java.util.Collections;
import java.util.Queue;
import java.util.Stack;
import java.util.concurrent.ConcurrentLinkedQueue;
@ -11,13 +12,11 @@ import amidst.Log;
public class FragmentManager extends Thread {
private static final int CACHE_SIZE = 512;
// TODO : Implement custom cache paths?
private boolean cacheEnabled = false;
private File cachePath;
private boolean running = true;
private boolean loaded = false;
private Fragment[] fragmentCache;
private ConcurrentLinkedQueue<Fragment> fragmentStack;
@ -27,46 +26,33 @@ public class FragmentManager extends Thread {
private Stack<Layer> layerList;
public FragmentManager() {
public FragmentManager(Layer... layers) {
cacheEnabled = false;
fragmentStack = new ConcurrentLinkedQueue<Fragment>();
requestQueue = new ConcurrentLinkedQueue<Fragment>();
recycleQueue = new ConcurrentLinkedQueue<Fragment>();
layerList = new Stack<Layer>();
}
public FragmentManager(File cachePath) {
this();
cacheEnabled = true;
this.cachePath = cachePath;
}
public void load() {
if (loaded) {
reset();
} else {
fragmentCache = new Fragment[CACHE_SIZE];
}
Layer[] layers = new Layer[layerList.size()];
for (int i = 0; i < layers.length; i++)
layers[i] = layerList.pop();
Collections.addAll(layerList, layers);
fragmentCache = new Fragment[CACHE_SIZE];
Arrays.sort(layers);
for (int i = 0; i < CACHE_SIZE; i++) {
fragmentCache[i] = new Fragment(layers);
fragmentStack.offer(fragmentCache[i]);
}
loaded = true;
}
public void reset() {
// TODO : Unload all fragments
start();
}
public void addLayer(Layer layer) {
layerList.add(layer);
public FragmentManager(File cachePath) {
this();
cacheEnabled = true;
this.cachePath = cachePath;
}
public void reset() {
// TODO : Unload all fragments
}
public Fragment requestFragment(int x, int y) {
@ -85,26 +71,22 @@ public class FragmentManager extends Thread {
recycleQueue.offer(frag);
}
@Override
public void run() {
this.setPriority(MIN_PRIORITY);
while (running) {
boolean needsSleep = false;
needsSleep = requestQueue.isEmpty();
boolean needsSleep = requestQueue.isEmpty();
if (!requestQueue.isEmpty()) {
Fragment frag = requestQueue.poll();
if (frag.isActive&&!frag.isLoaded) {
if (frag.isActive && !frag.isLoaded) {
frag.load();
sleepTick++;
if (sleepTick == 10) {
sleepTick = 0;
try {
Thread.sleep(1L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (InterruptedException ignored) {}
}
/**/
}
}
needsSleep &= recycleQueue.isEmpty();
@ -122,13 +104,11 @@ public class FragmentManager extends Thread {
e.printStackTrace();
}
}
}
}
public void close() {
this.running = false;
for (int i = 0; i < fragmentCache.length; i++) {
fragmentCache[i].recycle();
}
for (Fragment f : fragmentCache) f.recycle();
}
}

83
src/amidst/map/Map.java
View File

@ -2,6 +2,7 @@ package amidst.map;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.util.Stack;
@ -17,29 +18,27 @@ public class Map {
private Fragment startNode = new Fragment();
private double drawPadding = Fragment.SIZE;
private double scale = 1.0;
private Point2D.Double start;
private double scale = 1.0, startX, startY;
private int sBlockX = 0;
private int eBlockX = 0;
private int tileWidth, tileHeight;
private boolean isLoaded = false;
private final Object resizeLock = new Object();
private AffineTransform mat;
private ChunkManager chunkManager;
// TODO : This must be changed with the removal of ChunkManager
public Map(ChunkManager manager) {
chunkManager = manager;
fManager = new FragmentManager();
public Map(ChunkManager manager, Layer... layers) {
for (Layer layer : layers)
layer.setChunkManager(manager);
fManager = new FragmentManager(layers);
mat = new AffineTransform();
start = new Point2D.Double();
addStart(0, 0);
}
public void draw(Graphics2D g) {
if (!isLoaded) return;
Rectangle b = g.getClipBounds();
int size = (int) (Fragment.SIZE * scale);
@ -51,10 +50,10 @@ public class Map {
while (tileHeight < h) addRow(END);
while (tileHeight > h) removeRow(END);
while (startX > 0) { startX -= size; addColumn(START); removeColumn(END); }
while (startX < -size) { startX += size; addColumn(END); removeColumn(START); }
while (startY > 0) { startY -= size; addRow(START); removeRow(END); }
while (startY < -size) { startY += size; addRow(END); removeRow(START); }
while (start.x > 0) { start.x -= size; addColumn(START); removeColumn(END); }
while (start.x < -size) { start.x += size; addColumn(END); removeColumn(START); }
while (start.y > 0) { start.y -= size; addRow(START); removeRow(END); }
while (start.y < -size) { start.y += size; addRow(END); removeRow(START); }
//g.setColor(Color.pink);
//g.fillRect(5, 5, width - 10, height - 10);
@ -63,11 +62,9 @@ public class Map {
size = Fragment.SIZE;
if (frag.hasNext) {
Fragment corner = frag.nextFragment;
double drawX = startX;
double drawY = startY;
mat.setToIdentity();
mat.translate(drawX, drawY);
mat.translate(start.x, start.y);
mat.scale(scale, scale);
while (frag.hasNext) {
frag = frag.nextFragment;
@ -213,26 +210,17 @@ public class Map {
}
}
public void moveBy(Point2D.Double speed) {
moveBy(speed.x, speed.y);
}
public void moveBy(double x, double y) {
startX += x;
startY += y;
start.x += x;
start.y += y;
}
public void centerOn(int x, int y) {
}
public void addLayer(Layer layer) {
layer.setChunkManager(chunkManager);
fManager.addLayer(layer);
}
public void load() {
fManager.load();
fManager.start();
addStart(0, 0);
isLoaded = true;
public void centerOn(double x, double y) {
//TODO
}
public void setZoom(double scale) {
@ -241,18 +229,17 @@ public class Map {
public double getZoom() {
return scale;
}
public double getScaledX(double oldScale, double newScale, double x) {
double baseX = x - startX;
return baseX - (baseX/oldScale) * newScale;
public Point2D.Double getScaled(double oldScale, double newScale, Point p) {
double baseX = p.x - start.x;
double scaledX = baseX - (baseX/oldScale) * newScale;
double baseY = p.y - start.y;
double scaledY = baseY - (baseY/oldScale) * newScale;
return new Point2D.Double(scaledX, scaledY);
}
public double getScaledY(double oldScale, double newScale, double y) {
double baseY = y - startY;
return baseY - (baseY/oldScale) * newScale;
}
public void close() {
isLoaded = false;
synchronized (resizeLock) {
fManager.close();
}
public void dispose() {
fManager.close();
}
}