valerie
/
hadean
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

stockpiles work

pull/1/head
valyrie97 2022-12-27 12:42:29 -05:00
parent aece757dde
commit b5bfa08869
19 changed files with 3310 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2611
src/main/java/xyz/valnet/engine/math/FastNoiseLite.java 100644
View File

File diff suppressed because it is too large Load Diff

64
src/main/java/xyz/valnet/engine/math/SimplexNoise.java 100644
View File

@ -0,0 +1,64 @@
package xyz.valnet.engine.math;
import java.util.Random;
// Just like in perlin noise you will in general combine several octaves of noise
// to create fractal noise (which gives you terrain like features).
// Note that 3D terrain heights are created by 2D noise.
public class SimplexNoise {
private SimplexNoiseOctave[] octaves;
private double[] frequencys;
private double[] amplitudes;
private int largestFeature;
private double persistence;
private int seed;
public SimplexNoise(int largestFeature, double persistence, int seed) {
this.largestFeature = largestFeature;
this.persistence = persistence;
this.seed = seed;
// recieves a number (eg 128) and calculates what power of 2 it is (eg 2^7)
// Math.ceil(7) = 7 = numberOfOctaves
int numberOfOctaves = (int)Math.ceil(Math.log10(this.largestFeature)/Math.log10(2));
octaves = new SimplexNoiseOctave[numberOfOctaves];
frequencys = new double[numberOfOctaves];
amplitudes = new double[numberOfOctaves];
Random rnd = new Random(this.seed);
for(int i=0; i<numberOfOctaves; i++) {
octaves[i] = new SimplexNoiseOctave(rnd.nextInt());
frequencys[i] = Math.pow(2,i);
amplitudes[i] = Math.pow(this.persistence, octaves.length-i);
}
}
public double getNoise2D(int x, int y) {
double result = 0;
for(int i=0;i<octaves.length;i++) {
// double frequency = Math.pow(2,i);
// double amplitude = Math.pow(persistence,octaves.length-i);
result = result+octaves[i].noise(x/frequencys[i], y/frequencys[i])* amplitudes[i];
}
return result;
}
public double getNoise3D(int x, int y, int z) {
double result=0;
for(int i=0;i<octaves.length;i++) {
double frequency = Math.pow(2,i);
double amplitude = Math.pow(persistence,octaves.length-i);
result = result+octaves[i].noise(x/frequency, y/frequency,z/frequency)* amplitude;
}
return result;
}
}

407
src/main/java/xyz/valnet/engine/math/SimplexNoiseOctave.java 100644
View File

@ -0,0 +1,407 @@
package xyz.valnet.engine.math;
import java.util.Random;
/*
* A speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
*
* Based on example code by Stefan Gustavson (stegu@itn.liu.se).
* Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
* Better rank ordering method by Stefan Gustavson in 2012.
*
* This could be speeded up even further, but it's useful as it is.
*
* Version 2012-03-09
*
* This code was placed in the public domain by its original author,
* Stefan Gustavson. You may use it as you see fit, but
* attribution is appreciated.
*
*/
public class SimplexNoiseOctave {
public static int RANDOMSEED=0;
private static int NUMBEROFSWAPS=400;
private static Grad grad3[] = {
new Grad(1,1,0),new Grad(-1,1,0),new Grad(1,-1,0),new Grad(-1,-1,0),
new Grad(1,0,1),new Grad(-1,0,1),new Grad(1,0,-1),new Grad(-1,0,-1),
new Grad(0,1,1),new Grad(0,-1,1),new Grad(0,1,-1),new Grad(0,-1,-1)
};
private static Grad grad4[]= {
new Grad(0,1,1,1),new Grad(0,1,1,-1),new Grad(0,1,-1,1),new Grad(0,1,-1,-1),
new Grad(0,-1,1,1),new Grad(0,-1,1,-1),new Grad(0,-1,-1,1),new Grad(0,-1,-1,-1),
new Grad(1,0,1,1),new Grad(1,0,1,-1),new Grad(1,0,-1,1),new Grad(1,0,-1,-1),
new Grad(-1,0,1,1),new Grad(-1,0,1,-1),new Grad(-1,0,-1,1),new Grad(-1,0,-1,-1),
new Grad(1,1,0,1),new Grad(1,1,0,-1),new Grad(1,-1,0,1),new Grad(1,-1,0,-1),
new Grad(-1,1,0,1),new Grad(-1,1,0,-1),new Grad(-1,-1,0,1),new Grad(-1,-1,0,-1),
new Grad(1,1,1,0),new Grad(1,1,-1,0),new Grad(1,-1,1,0),new Grad(1,-1,-1,0),
new Grad(-1,1,1,0),new Grad(-1,1,-1,0),new Grad(-1,-1,1,0),new Grad(-1,-1,-1,0)
};
//this contains all the numbers between 0 and 255, these are put in a random order depending upon the seed
private static short p_supply[] = {
151,160,137,91,90,15,
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180};
private short p[] = new short[p_supply.length];
// To remove the need for index wrapping, double the permutation table length
private short perm[] = new short[512];
private short permMod12[] = new short[512];
public SimplexNoiseOctave(int seed) {
p=p_supply.clone();
if (seed==RANDOMSEED){
Random rand=new Random();
seed=rand.nextInt();
}
//the random for the swaps
Random rand=new Random(seed);
//the seed determines the swaps that occur between the default order and the order we're actually going to use
for(int i=0;i<NUMBEROFSWAPS;i++) {
int swapFrom=rand.nextInt(p.length);
int swapTo=rand.nextInt(p.length);
short temp=p[swapFrom];
p[swapFrom]=p[swapTo];
p[swapTo]=temp;
}
for(int i=0; i<512; i++) {
perm[i]=p[i & 255];
permMod12[i] = (short)(perm[i] % 12);
}
}
// Skewing and unskewing factors for 2, 3, and 4 dimensions
private static final double F2 = 0.5*(Math.sqrt(3.0)-1.0);
private static final double G2 = (3.0-Math.sqrt(3.0))/6.0;
private static final double F3 = 1.0/3.0;
private static final double G3 = 1.0/6.0;
private static final double F4 = (Math.sqrt(5.0)-1.0)/4.0;
private static final double G4 = (5.0-Math.sqrt(5.0))/20.0;
// This method is a *lot* faster than using (int)Math.floor(x)
private static int fastfloor(double x) {
int xi = (int)x;
return x<xi ? xi-1 : xi;
}
private static double dot(Grad g, double x, double y) {
return g.x*x + g.y*y; }
private static double dot(Grad g, double x, double y, double z) {
return g.x*x + g.y*y + g.z*z;
}
private static double dot(Grad g, double x, double y, double z, double w) {
return g.x*x + g.y*y + g.z*z + g.w*w;
}
// 2D simplex noise
public double noise(double xin, double yin) {
double n0, n1, n2; // Noise contributions from the three corners
// Skew the input space to determine which simplex cell we're in
double s = (xin+yin)*F2; // Hairy factor for 2D
int i = fastfloor(xin+s);
int j = fastfloor(yin+s);
double t = (i+j)*G2;
double X0 = i-t; // Unskew the cell origin back to (x,y) space
double Y0 = j-t;
double x0 = xin-X0; // The x,y distances from the cell origin
double y0 = yin-Y0;
// For the 2D case, the simplex shape is an equilateral triangle.
// Determine which simplex we are in.
int i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
if(x0>y0) {i1=1; j1=0;} // lower triangle, XY order: (0,0)->(1,0)->(1,1)
else {i1=0; j1=1;} // upper triangle, YX order: (0,0)->(0,1)->(1,1)
// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
// c = (3-sqrt(3))/6
double x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
double y1 = y0 - j1 + G2;
double x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
double y2 = y0 - 1.0 + 2.0 * G2;
// Work out the hashed gradient indices of the three simplex corners
int ii = i & 255;
int jj = j & 255;
int gi0 = permMod12[ii+perm[jj]];
int gi1 = permMod12[ii+i1+perm[jj+j1]];
int gi2 = permMod12[ii+1+perm[jj+1]];
// Calculate the contribution from the three corners
double t0 = 0.5 - x0*x0-y0*y0;
if(t0<0) n0 = 0.0;
else {
t0 *= t0;
n0 = t0 * t0 * dot(grad3[gi0], x0, y0); // (x,y) of grad3 used for 2D gradient
}
double t1 = 0.5 - x1*x1-y1*y1;
if(t1<0) n1 = 0.0;
else {
t1 *= t1;
n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
}
double t2 = 0.5 - x2*x2-y2*y2;
if(t2<0) n2 = 0.0;
else {
t2 *= t2;
n2 = t2 * t2 * dot(grad3[gi2], x2, y2);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to return values in the interval [-1,1].
return 70.0 * (n0 + n1 + n2);
}
// 3D simplex noise
public double noise(double xin, double yin, double zin) {
double n0, n1, n2, n3; // Noise contributions from the four corners
// Skew the input space to determine which simplex cell we're in
double s = (xin+yin+zin)*F3; // Very nice and simple skew factor for 3D
int i = fastfloor(xin+s);
int j = fastfloor(yin+s);
int k = fastfloor(zin+s);
double t = (i+j+k)*G3;
double X0 = i-t; // Unskew the cell origin back to (x,y,z) space
double Y0 = j-t;
double Z0 = k-t;
double x0 = xin-X0; // The x,y,z distances from the cell origin
double y0 = yin-Y0;
double z0 = zin-Z0;
// For the 3D case, the simplex shape is a slightly irregular tetrahedron.
// Determine which simplex we are in.
int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
if(x0>=y0) {
if(y0>=z0) {
i1=1; j1=0; k1=0; i2=1; j2=1; k2=0;
} // X Y Z order
else if(x0>=z0) {
i1=1; j1=0; k1=0; i2=1; j2=0; k2=1;
} // X Z Y order
else {
i1=0; j1=0; k1=1; i2=1; j2=0; k2=1;
} // Z X Y order
}
else { // x0<y0
if(y0<z0) {
i1=0; j1=0; k1=1; i2=0; j2=1; k2=1;
} // Z Y X order
else if(x0<z0) {
i1=0; j1=1; k1=0; i2=0; j2=1; k2=1;
} // Y Z X order
else {
i1=0; j1=1; k1=0; i2=1; j2=1; k2=0;
} // Y X Z order
}
// A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
// a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
// a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
// c = 1/6.
double x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
double y1 = y0 - j1 + G3;
double z1 = z0 - k1 + G3;
double x2 = x0 - i2 + 2.0*G3; // Offsets for third corner in (x,y,z) coords
double y2 = y0 - j2 + 2.0*G3;
double z2 = z0 - k2 + 2.0*G3;
double x3 = x0 - 1.0 + 3.0*G3; // Offsets for last corner in (x,y,z) coords
double y3 = y0 - 1.0 + 3.0*G3;
double z3 = z0 - 1.0 + 3.0*G3;
// Work out the hashed gradient indices of the four simplex corners
int ii = i & 255;
int jj = j & 255;
int kk = k & 255;
int gi0 = permMod12[ii+perm[jj+perm[kk]]];
int gi1 = permMod12[ii+i1+perm[jj+j1+perm[kk+k1]]];
int gi2 = permMod12[ii+i2+perm[jj+j2+perm[kk+k2]]];
int gi3 = permMod12[ii+1+perm[jj+1+perm[kk+1]]];
// Calculate the contribution from the four corners
double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0;
if(t0<0) n0 = 0.0;
else {
t0 *= t0;
n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0);
}
double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1;
if(t1<0) n1 = 0.0;
else {
t1 *= t1;
n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1);
}
double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2;
if(t2<0) n2 = 0.0;
else {
t2 *= t2;
n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2);
}
double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3;
if(t3<0) n3 = 0.0;
else {
t3 *= t3;
n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to stay just inside [-1,1]
return 32.0*(n0 + n1 + n2 + n3);
}
// 4D simplex noise, better simplex rank ordering method 2012-03-09
public double noise(double x, double y, double z, double w) {
double n0, n1, n2, n3, n4; // Noise contributions from the five corners
// Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
double s = (x + y + z + w) * F4; // Factor for 4D skewing
int i = fastfloor(x + s);
int j = fastfloor(y + s);
int k = fastfloor(z + s);
int l = fastfloor(w + s);
double t = (i + j + k + l) * G4; // Factor for 4D unskewing
double X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
double Y0 = j - t;
double Z0 = k - t;
double W0 = l - t;
double x0 = x - X0; // The x,y,z,w distances from the cell origin
double y0 = y - Y0;
double z0 = z - Z0;
double w0 = w - W0;
// For the 4D case, the simplex is a 4D shape I won't even try to describe.
// To find out which of the 24 possible simplices we're in, we need to
// determine the magnitude ordering of x0, y0, z0 and w0.
// Six pair-wise comparisons are performed between each possible pair
// of the four coordinates, and the results are used to rank the numbers.
int rankx = 0;
int ranky = 0;
int rankz = 0;
int rankw = 0;
if(x0 > y0) rankx++; else ranky++;
if(x0 > z0) rankx++; else rankz++;
if(x0 > w0) rankx++; else rankw++;
if(y0 > z0) ranky++; else rankz++;
if(y0 > w0) ranky++; else rankw++;
if(z0 > w0) rankz++; else rankw++;
int i1, j1, k1, l1; // The integer offsets for the second simplex corner
int i2, j2, k2, l2; // The integer offsets for the third simplex corner
int i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
// simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
// Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
// impossible. Only the 24 indices which have non-zero entries make any sense.
// We use a thresholding to set the coordinates in turn from the largest magnitude.
// Rank 3 denotes the largest coordinate.
i1 = rankx >= 3 ? 1 : 0;
j1 = ranky >= 3 ? 1 : 0;
k1 = rankz >= 3 ? 1 : 0;
l1 = rankw >= 3 ? 1 : 0;
// Rank 2 denotes the second largest coordinate.
i2 = rankx >= 2 ? 1 : 0;
j2 = ranky >= 2 ? 1 : 0;
k2 = rankz >= 2 ? 1 : 0;
l2 = rankw >= 2 ? 1 : 0;
// Rank 1 denotes the second smallest coordinate.
i3 = rankx >= 1 ? 1 : 0;
j3 = ranky >= 1 ? 1 : 0;
k3 = rankz >= 1 ? 1 : 0;
l3 = rankw >= 1 ? 1 : 0;
// The fifth corner has all coordinate offsets = 1, so no need to compute that.
double x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
double y1 = y0 - j1 + G4;
double z1 = z0 - k1 + G4;
double w1 = w0 - l1 + G4;
double x2 = x0 - i2 + 2.0*G4; // Offsets for third corner in (x,y,z,w) coords
double y2 = y0 - j2 + 2.0*G4;
double z2 = z0 - k2 + 2.0*G4;
double w2 = w0 - l2 + 2.0*G4;
double x3 = x0 - i3 + 3.0*G4; // Offsets for fourth corner in (x,y,z,w) coords
double y3 = y0 - j3 + 3.0*G4;
double z3 = z0 - k3 + 3.0*G4;
double w3 = w0 - l3 + 3.0*G4;
double x4 = x0 - 1.0 + 4.0*G4; // Offsets for last corner in (x,y,z,w) coords
double y4 = y0 - 1.0 + 4.0*G4;
double z4 = z0 - 1.0 + 4.0*G4;
double w4 = w0 - 1.0 + 4.0*G4;
// Work out the hashed gradient indices of the five simplex corners
int ii = i & 255;
int jj = j & 255;
int kk = k & 255;
int ll = l & 255;
int gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
int gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
int gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
// Calculate the contribution from the five corners
double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0 - w0*w0;
if(t0<0) n0 = 0.0;
else {
t0 *= t0;
n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0);
}
double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1 - w1*w1;
if(t1<0) n1 = 0.0;
else {
t1 *= t1;
n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1);
}
double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2 - w2*w2;
if(t2<0) n2 = 0.0;
else {
t2 *= t2;
n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2);
}
double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3 - w3*w3;
if(t3<0) n3 = 0.0;
else {
t3 *= t3;
n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3);
}
double t4 = 0.6 - x4*x4 - y4*y4 - z4*z4 - w4*w4;
if(t4<0) n4 = 0.0;
else {
t4 *= t4;
n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4);
}
// Sum up and scale the result to cover the range [-1,1]
return 27.0 * (n0 + n1 + n2 + n3 + n4);
}
// Inner class to speed upp gradient computations
// (array access is a lot slower than member access)
private static class Grad
{
double x, y, z, w;
Grad(double x, double y, double z)
{
this.x = x;
this.y = y;
this.z = z;
}
Grad(double x, double y, double z, double w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
}
}

2
src/main/java/xyz/valnet/engine/scenegraph/GameObject.java
View File

@ -45,7 +45,7 @@ public class GameObject implements IRenderable, ITickable {
public void start() {}
public void remove(GameObject obj) {
protected void remove(GameObject obj) {
scene.remove(obj);
}
}

25
src/main/java/xyz/valnet/hadean/gameobjects/Job.java
View File

@ -3,6 +3,7 @@ package xyz.valnet.hadean.gameobjects;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import xyz.valnet.engine.math.Vector2f;
import xyz.valnet.engine.math.Vector2i;
@ -15,6 +16,7 @@ import xyz.valnet.hadean.interfaces.IWorkable;
public class Job extends GameObject {
private Job that = this;
private List<Callback> closedListeners = new ArrayList<Callback>();
public abstract class JobStep {
public abstract Vector2i[] getLocations();
@ -45,8 +47,10 @@ public class Job extends GameObject {
public Vector2i[] getLocations() {
Stockpile pile = that.get(Stockpile.class);
Vector4f box = pile.getWorldBox();
return new Vector2i[] { new Vector2f(box.x, box.y).asInt() };
// Vector4f box = pile.getWorldBox().toXYWH();
return new Vector2i[] {
pile.getFreeTile()
};
}
}
@ -89,7 +93,13 @@ public class Job extends GameObject {
public void nextStep() {
step ++;
if(isCompleted()) get(JobBoard.class).completeJob(this);
if(isCompleted()) {
get(JobBoard.class).completeJob(this);
for(Callback callback : closedListeners) {
callback.apply();
}
remove(this);
}
}
public boolean isCompleted() {
@ -104,4 +114,13 @@ public class Job extends GameObject {
public String getJobName() {
return name;
}
@FunctionalInterface
public interface Callback {
public void apply();
}
public void registerClosedListener(Callback callback) {
closedListeners.add(callback);
}
}

11
src/main/java/xyz/valnet/hadean/gameobjects/Terrain.java
View File

@ -1,5 +1,6 @@
package xyz.valnet.hadean.gameobjects;
import xyz.valnet.engine.math.FastNoiseLite;
import xyz.valnet.engine.math.Vector2i;
import xyz.valnet.engine.math.Vector4f;
import xyz.valnet.engine.scenegraph.GameObject;
@ -8,11 +9,17 @@ import xyz.valnet.hadean.pathfinding.IPathable;
public class Terrain extends GameObject implements IPathable, IWorldBoundsAdapter {
public static final int WORLD_SIZE = 24;
public static final int WORLD_SIZE = 30;
public static final int TILE_SIZE = 8;
// public static int left, top;
public float getNoise(int seed, float x, float y) {
FastNoiseLite noise = new FastNoiseLite(seed);
float base = ((noise.GetNoise(x * 10, y * 10) + 1) / 2) * 1.0f;
float highnoise = ((noise.GetNoise(x * 100, y * 100) + 1) / 2) * 1.0f;
return (base + highnoise) / 2.0f;
}
private Tile[][] tiles = new Tile[WORLD_SIZE][WORLD_SIZE];
private Camera camera;

75
src/main/java/xyz/valnet/hadean/gameobjects/Tile.java
View File

@ -2,14 +2,17 @@ package xyz.valnet.hadean.gameobjects;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
import xyz.valnet.engine.graphics.Sprite;
import xyz.valnet.engine.math.Vector2f;
import xyz.valnet.engine.math.Vector2i;
import xyz.valnet.engine.math.Vector4f;
import xyz.valnet.engine.scenegraph.GameObject;
import xyz.valnet.hadean.gameobjects.worldobjects.FarmPlot;
import xyz.valnet.hadean.gameobjects.worldobjects.Tree;
import xyz.valnet.hadean.gameobjects.worldobjects.WorldObject;
import xyz.valnet.hadean.gameobjects.worldobjects.items.Item;
import xyz.valnet.hadean.interfaces.ITileThing;
import xyz.valnet.hadean.interfaces.IWorkable;
import xyz.valnet.hadean.util.Assets;
@ -17,13 +20,18 @@ import xyz.valnet.hadean.util.Layers;
public class Tile extends WorldObject implements IWorkable {
private Camera camera;
private static int redSeed = (int)(Math.random() * 10000);
private static int greenSeed = (int)(Math.random() * 10000);
private static int blueSeed = (int)(Math.random() * 10000);
private final int x, y;
private final Vector4f color = new Vector4f((float) Math.random() * 0.1f, 0.4f + (float) Math.random() * 0.15f, (float) Math.random() * 0.05f, 1f);
// private final int x, y;
private Vector4f color;
private final Sprite sprite = Assets.defaultTerrain[(int)Math.floor(Math.random() * Assets.defaultTerrain.length)];
private List<ITileThing> stuff = new ArrayList<ITileThing>();
// TODO remove remove queue, cause like, we dont iterate over
// things? so why remove queue them? that just leads to unneccesary
// timing issues. you dumb fuck.
private List<ITileThing> toRemove = new ArrayList<ITileThing>();
public Tile(int x, int y) {
@ -32,18 +40,33 @@ public class Tile extends WorldObject implements IWorkable {
}
public Vector2i getCoords() {
return new Vector2i(x, y);
return new Vector2f(x, y).asInt();
}
public void start() {
camera = get(Camera.class);
super.start();
if(Math.random() > 0.97) {
Tree tree = new Tree(x, y);
Tree tree = new Tree((int)x, (int)y);
stuff.add(tree);
add(tree);
}
float scale = 1;
float red = (float) terrain.getNoise(redSeed, x * scale, y * scale);
float green = (float) terrain.getNoise(greenSeed, x * scale, y * scale);
float blue = (float) terrain.getNoise(blueSeed, x * scale, y * scale);
color = new Vector4f(red * 0.1f, 0.4f + green * 0.15f, blue * 0.05f, 1f);
// color = new Vector4f(red, green, blue, 1.0f);
}
public boolean isTileFree() {
if(!isWalkable()) return false;
for(ITileThing thing : stuff) {
if(thing instanceof Item) return false;
}
return true;
}
public void placeThing(ITileThing thing) {
@ -51,6 +74,7 @@ public class Tile extends WorldObject implements IWorkable {
if(thing instanceof GameObject) {
add((GameObject)thing);
}
thing.onPlaced(this);
if(thing instanceof FarmPlot) {
desiredTill = true;
@ -58,6 +82,14 @@ public class Tile extends WorldObject implements IWorkable {
}
}
public <T extends ITileThing> T removeThing(T thing) {
if(!(stuff.contains(thing))) return null;
if(toRemove.contains(thing)) return null;
toRemove.add(thing);
return thing;
}
@Override
public void update(float dTime) {
for(ITileThing thing : stuff) {
@ -106,15 +138,15 @@ public class Tile extends WorldObject implements IWorkable {
@Override
public Vector2i[] getWorkablePositions() {
return new Vector2i[] {
new Vector2i(x - 1, y - 1),
new Vector2i(x, y - 1),
new Vector2i(x + 1, y - 1),
new Vector2i(x - 1, y + 0),
new Vector2i(x, y + 0),
new Vector2i(x + 1, y + 0),
new Vector2i(x - 1, y + 1),
new Vector2i(x, y + 1),
new Vector2i(x + 1, y + 1),
new Vector2i((int)x - 1, (int)y - 1),
new Vector2i((int)x, (int)y - 1),
new Vector2i((int)x + 1, (int)y - 1),
new Vector2i((int)x - 1, (int)y + 0),
new Vector2i((int)x, (int)y + 0),
new Vector2i((int)x + 1, (int)y + 0),
new Vector2i((int)x - 1, (int)y + 1),
new Vector2i((int)x, (int)y + 1),
new Vector2i((int)x + 1, (int)y + 1),
};
}
@ -143,4 +175,13 @@ public class Tile extends WorldObject implements IWorkable {
public Vector4f getWorldBox() {
return new Vector4f(x, y, x+1, y+1);
}
public String toThingsString() {
if(stuff.size() == 0) return " - Nothing";
String str = "";
for(ITileThing thing : stuff) {
str += " - " + thing + "\n";
}
return str.stripTrailing();
}
}

13
src/main/java/xyz/valnet/hadean/gameobjects/ui/HoverQuery.java
View File

@ -8,8 +8,9 @@ import xyz.valnet.engine.math.Vector2f;
import xyz.valnet.engine.math.Vector4f;
import xyz.valnet.engine.scenegraph.GameObject;
import xyz.valnet.hadean.gameobjects.Camera;
import xyz.valnet.hadean.gameobjects.Terrain;
import xyz.valnet.hadean.gameobjects.Tile;
import xyz.valnet.hadean.gameobjects.worldobjects.WorldObject;
import xyz.valnet.hadean.interfaces.ITileThing;
import xyz.valnet.hadean.util.Assets;
public class HoverQuery extends GameObject {
@ -37,6 +38,10 @@ public class HoverQuery extends GameObject {
position.y < box.w
) {
thingStrings.add(obj.getName());
if(obj instanceof Tile) {
thingStrings.add(((Tile)obj).toThingsString());
}
}
}
}
@ -45,8 +50,10 @@ public class HoverQuery extends GameObject {
public void render() {
int i = 16;
for(String thingString : thingStrings) {
Assets.font.drawString(thingString, 16, i);
i += 14;
for(String str : thingString.split("\n")) {
Assets.font.drawString(str, 16, i);
i += 14;
}
}
}
}

2
src/main/java/xyz/valnet/hadean/gameobjects/ui/tabs/BuildTab.java
View File

@ -112,7 +112,7 @@ public class BuildTab extends Tab implements ISelectionChangeListener, IMouseCap
// draw the currently selected build item
Assets.flat.pushColor(new Vector4f(1f, 1f, 1f, 0.5f));
for(int i = 0; i < w; i ++) for(int j = 0; j < h; j ++) {{
camera.draw(Layers.BUILD_INTERACTABLE, Assets.stockpile, x + i, y + j);
camera.draw(Layers.BUILD_INTERACTABLE, Assets.checkerBoard, x + i, y + j);
}}
Assets.flat.popColor();
}

2
src/main/java/xyz/valnet/hadean/gameobjects/worldobjects/FarmPlot.java
View File

@ -27,7 +27,7 @@ public class FarmPlot extends WorldObject implements ISelectable, ITileThing, IB
return new Vector4f(x, y, x + w, y + h);
}
private static Action TOGGLE_VISIBILITY = new Action("Hide / Show");
private static Action TOGGLE_VISIBILITY = new Action("Hide\n----\nShow");
@Override
public Action[] getActions() {

27
src/main/java/xyz/valnet/hadean/gameobjects/worldobjects/Log.java
View File

@ -1,13 +1,11 @@
package xyz.valnet.hadean.gameobjects.worldobjects;
import xyz.valnet.engine.math.Vector4f;
import xyz.valnet.hadean.interfaces.ISelectable;
import xyz.valnet.hadean.interfaces.ITileThing;
import xyz.valnet.hadean.util.Action;
import xyz.valnet.hadean.gameobjects.worldobjects.items.Item;
import xyz.valnet.hadean.util.Assets;
import xyz.valnet.hadean.util.Layers;
public class Log extends WorldObject implements ITileThing, ISelectable {
public class Log extends Item {
@Override
public void start() {
@ -37,25 +35,6 @@ public class Log extends WorldObject implements ITileThing, ISelectable {
@Override
public void onRemove() {}
@Override
public Vector4f getWorldBox() {
return new Vector4f(x, y, x + 1, y + 1);
}
private static final Action ACTION_HAUL = new Action("Haul");
@Override
public Action[] getActions() {
return new Action[] {
ACTION_HAUL
};
}
@Override
public void runAction(Action action) {
}
@Override
public String details() {
return "A fat log";

26
src/main/java/xyz/valnet/hadean/gameobjects/worldobjects/Pawn.java
View File

@ -1,5 +1,8 @@
package xyz.valnet.hadean.gameobjects.worldobjects;
import java.util.ArrayList;
import java.util.List;
import xyz.valnet.engine.math.Vector2f;
import xyz.valnet.engine.math.Vector2i;
import xyz.valnet.engine.math.Vector4f;
@ -8,6 +11,8 @@ import xyz.valnet.hadean.gameobjects.JobBoard;
import xyz.valnet.hadean.gameobjects.Terrain;
import xyz.valnet.hadean.gameobjects.Job.JobStep;
import xyz.valnet.hadean.gameobjects.worldobjects.agents.Agent;
import xyz.valnet.hadean.gameobjects.worldobjects.items.Item;
import xyz.valnet.hadean.interfaces.ITileThing;
import xyz.valnet.hadean.interfaces.IWorker;
import xyz.valnet.hadean.util.Action;
import xyz.valnet.hadean.util.Assets;
@ -106,6 +111,8 @@ public class Pawn extends Agent implements IWorker {
return false;
}
private List<Item> inventory = new ArrayList<Item>();
private boolean doJob() {
if(!jobboard.workerHasJob(this)) return false;
JobStep step = jobboard.getJob(this).getCurrentStep();
@ -116,6 +123,25 @@ public class Pawn extends Agent implements IWorker {
Job.Work workStep = (Job.Work)step;
if(workStep.doWork()) step.next();
return true;
} else if(step instanceof Job.PickupItem) {
Job.PickupItem pickupStep = (Job.PickupItem) step;
Item item = getTile().removeThing(pickupStep.item);
remove(item);
inventory.add(item);
step.next();
return true;
} else if(step instanceof Job.DropoffAtStockpile) {
if(!getTile().isTileFree()) return false;
Job.DropoffAtStockpile dropoffStep = (Job.DropoffAtStockpile) step;
Item item = dropoffStep.item;
if(!inventory.contains(item)) {
return false;
}
inventory.remove(item);
add(item);
getTile().placeThing(item);
step.next();
return true;
}
return false;

4
src/main/java/xyz/valnet/hadean/gameobjects/worldobjects/Rice.java
View File

@ -3,13 +3,15 @@ package xyz.valnet.hadean.gameobjects.worldobjects;
import xyz.valnet.engine.math.Vector2f;
import xyz.valnet.engine.math.Vector4f;
import xyz.valnet.hadean.gameobjects.JobBoard;
import xyz.valnet.hadean.gameobjects.Tile;
import xyz.valnet.hadean.gameobjects.worldobjects.items.Item;
import xyz.valnet.hadean.interfaces.ISelectable;
import xyz.valnet.hadean.interfaces.ITileThing;
import xyz.valnet.hadean.util.Action;
import xyz.valnet.hadean.util.Assets;
import xyz.valnet.hadean.util.Layers;
public class Rice extends WorldObject implements ITileThing, ISelectable {
public class Rice extends Item implements ITileThing, ISelectable {
// private SmartBoolean haul;

30
src/main/java/xyz/valnet/hadean/gameobjects/worldobjects/Stockpile.java
View File

@ -1,6 +1,8 @@
package xyz.valnet.hadean.gameobjects.worldobjects;
import xyz.valnet.engine.math.Vector2i;
import xyz.valnet.engine.math.Vector4f;
import xyz.valnet.hadean.gameobjects.Tile;
import xyz.valnet.hadean.interfaces.BuildableMetadata;
import xyz.valnet.hadean.interfaces.IBuildable;
import xyz.valnet.hadean.interfaces.ISelectable;
@ -32,6 +34,27 @@ public class Stockpile extends WorldObject implements ISelectable, ITileThing, I
}
private Tile[] getTiles() {
Vector4f box = getWorldBox();
int count = 0;
Tile[] tiles = new Tile[(int)box.z * (int)box.w];
for(float x = box.x; x < box.z; x ++) {
for(float y = box.y; y < box.w; y ++) {
tiles[count] = terrain.getTile((int)x, (int)y);
count ++;
}
}
return tiles;
}
public Vector2i getFreeTile() {
Tile[] tiles = getTiles();
for(Tile tile : tiles) {
if(tile.isTileFree()) return tile.getCoords();
}
return null;
}
@Override
public void start() {
super.start();
@ -86,9 +109,7 @@ public class Stockpile extends WorldObject implements ISelectable, ITileThing, I
this.y = y;
this.w = w;
this.h = h;
System.out.println("<" + x + ", " + y + ", " + w + ", " + h + ">");
System.out.println(inScene());
terrain.getTile(x, y).placeThing(this);
for(int i = x; i < x + w; i ++) {
for(int j = y; j < y + h; j ++) {
terrain.getTile(i, j).placeThing(this);
@ -102,4 +123,7 @@ public class Stockpile extends WorldObject implements ISelectable, ITileThing, I
return "Stockpile";
}
@Override
public void onPlaced(Tile tile) {}
}

20
src/main/java/xyz/valnet/hadean/gameobjects/worldobjects/Tree.java
View File

@ -4,6 +4,7 @@ import xyz.valnet.engine.math.Vector2i;
import xyz.valnet.engine.math.Vector4f;
import xyz.valnet.hadean.gameobjects.Job;
import xyz.valnet.hadean.gameobjects.JobBoard;
import xyz.valnet.hadean.gameobjects.Tile;
import xyz.valnet.hadean.interfaces.ISelectable;
import xyz.valnet.hadean.interfaces.ITileThing;
import xyz.valnet.hadean.interfaces.IWorkable;
@ -17,8 +18,6 @@ public class Tree extends WorldObject implements ITileThing, ISelectable, IWorka
private String name = "Tree " + (++ counter);
private Job chopJob = null;
private int x, y;
public Tree(int x, int y) {
this.x = x;
@ -69,10 +68,10 @@ public class Tree extends WorldObject implements ITileThing, ISelectable, IWorka
@Override
public Vector2i[] getWorkablePositions() {
return new Vector2i[] {
new Vector2i(x, y - 1),
new Vector2i(x, y + 1),
new Vector2i(x - 1, y),
new Vector2i(x + 1, y)
new Vector2i((int)x, (int)y - 1),
new Vector2i((int)x, (int)y + 1),
new Vector2i((int)x - 1, (int)y),
new Vector2i((int)x + 1, (int)y)
};
}
@ -116,7 +115,8 @@ public class Tree extends WorldObject implements ITileThing, ISelectable, IWorka
@Override
public void onRemove() {
add(new Log(x, y));
Log log = new Log((int)x, (int)y);
getTile().placeThing(log);
}
@Override
@ -128,4 +128,10 @@ public class Tree extends WorldObject implements ITileThing, ISelectable, IWorka
public String getName() {
return "Tree";
}
@Override
public void onPlaced(Tile tile) {
// TODO Auto-generated method stub
}
}

66
src/main/java/xyz/valnet/hadean/gameobjects/worldobjects/items/Item.java
View File

@ -1,41 +1,71 @@
package xyz.valnet.hadean.gameobjects.worldobjects.items;
import xyz.valnet.engine.math.Vector2f;
import xyz.valnet.engine.math.Vector4f;
import xyz.valnet.hadean.gameobjects.Job;
import xyz.valnet.hadean.gameobjects.JobBoard;
import xyz.valnet.hadean.gameobjects.Tile;
import xyz.valnet.hadean.gameobjects.worldobjects.WorldObject;
import xyz.valnet.hadean.util.SmartBoolean;
import xyz.valnet.hadean.interfaces.ISelectable;
import xyz.valnet.hadean.interfaces.ITileThing;
import xyz.valnet.hadean.util.Action;
import xyz.valnet.hadean.util.Assets;
import xyz.valnet.hadean.util.Layers;
public class Item extends WorldObject {
public abstract class Item extends WorldObject implements ISelectable, ITileThing {
protected JobBoard jobboard;
private SmartBoolean haul;
// camera.draw(Layers.MARKERS, Assets.haulArrow, x, y);
private Job haulJob = null;
@Override
public void start() {
super.start();
haul = new SmartBoolean(false, new SmartBoolean.IListener() {
@Override
public void rise() {
}
@Override
public void fall() {
}
});
}
@Override
public String getName() {
// TODO Auto-generated method stub
return null;
}
@Override
public Vector4f getWorldBox() {
return null;
return new Vector4f(x, y, x + 1, y + 1);
}
private static final Action ACTION_HAUL = new Action("Haul");
@Override
public Action[] getActions() {
return new Action[] {
ACTION_HAUL
};
}
@Override
public void renderAlpha() {
if(haulJob != null) {
Assets.flat.pushColor(Vector4f.opacity(0.6f));
camera.draw(Layers.GENERAL_UI, Assets.haulArrow, getWorldPosition());
Assets.flat.popColor();
}
}
@Override
public void runAction(Action action) {
if (action == ACTION_HAUL) {
haulJob = add(new Job("Haul " + this.getName()));
haulJob.addStep(haulJob.new PickupItem(this, new Vector2f[] { this.getWorldPosition() }));
haulJob.addStep(haulJob.new DropoffAtStockpile(this));
haulJob.registerClosedListener(() -> {
haulJob = null;
});
get(JobBoard.class).postJob(haulJob);
}
}
@Override
public void onPlaced(Tile tile) {
this.x = tile.getCoords().x;
this.y = tile.getCoords().y;
}
}

3
src/main/java/xyz/valnet/hadean/interfaces/ITileThing.java
View File

@ -1,7 +1,10 @@
package xyz.valnet.hadean.interfaces;
import xyz.valnet.hadean.gameobjects.Tile;
public interface ITileThing {
public boolean isWalkable();
public boolean shouldRemove();
public void onRemove();
public void onPlaced(Tile tile);
}

2
src/main/java/xyz/valnet/hadean/util/Action.java
View File

@ -1,7 +1,7 @@
package xyz.valnet.hadean.util;
public class Action {
public String name;
public final String name;
public Action(String name) {
this.name = name;

4
src/main/java/xyz/valnet/hadean/util/Assets.java
View File

@ -32,7 +32,7 @@ public class Assets {
public static final Sprite log;
public static final Sprite lilAxe;
public static final Sprite haulArrow;
public static final Sprite stockpile;
public static final Sprite checkerBoard;
public static final Sprite riceBag;
public static final Sprite farmPlot;
public static final Sprite whiteBox;
@ -66,7 +66,7 @@ public class Assets {
log = new Sprite(atlas, 48, 96, 16, 16);
lilAxe = new Sprite(atlas, 64, 88, 16, 16);
haulArrow = new Sprite(atlas, 80, 88, 16, 16);
stockpile = new Sprite(atlas, 40, 64, 4, 4);
checkerBoard = new Sprite(atlas, 40, 64, 4, 4);
riceBag = new Sprite(atlas, 48, 112, 16, 16);
farmPlot = new Sprite(atlas, 40, 72, 8, 8);