Astronand/Mindustry
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branches '6.0' and 'splinterface-impl' of https://github.com/Anuken/Mindustry into splinterface-impl

Browse Source 
# Conflicts:
#	core/assets/sprites/block_colors.png
#	core/assets/sprites/sprites.atlas
#	core/assets/sprites/sprites.png
#	core/assets/sprites/sprites3.png
#	core/assets/sprites/sprites5.png
#	core/src/mindustry/Vars.java
#	core/src/mindustry/entities/traits/SaveTrait.java
#	core/src/mindustry/maps/generators/MapGenerator.java
#	core/src/mindustry/ui/dialogs/DeployDialog.java
#	core/src/mindustry/world/blocks/Floor.java
#	desktop/src/mindustry/desktop/DesktopLauncher.java
#	gradle.properties
This commit is contained in:
Anuken
2020-02-04 12:25:18 -05:00
parent 878f570472 2fe3fea7f4
commit be50997f94
82 changed files with 1708 additions and 502 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
core/src/mindustry/maps/Maps.java
View File

@@ -212,7 +212,7 @@ public class Maps{
for(int x = 0; x < map.width; x++){
for(int y = 0; y < map.height; y++){
Tile tile = world.getTiles()[x][y];
Tile tile = world.rawTile(x, y);
if(tile.block() instanceof CoreBlock){
map.teams.add(tile.getTeamID());
@@ -228,7 +228,7 @@ public class Maps{
Core.assets.unload(map.previewFile().path() + "." + mapExtension);
}
Pixmap pix = MapIO.generatePreview(world.getTiles());
Pixmap pix = MapIO.generatePreview(world.tiles);
executor.submit(() -> map.previewFile().writePNG(pix));
writeCache(map);

22
core/src/mindustry/maps/filters/BlendFilter.java
View File

@@ -1,6 +1,7 @@
package mindustry.maps.filters;
import arc.math.*;
import arc.util.*;
import mindustry.content.*;
import mindustry.maps.filters.FilterOption.*;
import mindustry.world.*;
@@ -11,16 +12,21 @@ public class BlendFilter extends GenerateFilter{
float radius = 2f;
Block block = Blocks.stone, floor = Blocks.ice, ignore = Blocks.air;
{
buffered = true;
options(
new SliderOption("radius", () -> radius, f -> radius = f, 1f, 10f),
new BlockOption("block", () -> block, b -> block = b, anyOptional),
new BlockOption("floor", () -> floor, b -> floor = b, floorsOnly),
new BlockOption("ignore", () -> ignore, b -> ignore = b, floorsOptional)
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("radius", () -> radius, f -> radius = f, 1f, 10f),
new BlockOption("block", () -> block, b -> block = b, anyOptional),
new BlockOption("floor", () -> floor, b -> floor = b, floorsOnly),
new BlockOption("ignore", () -> ignore, b -> ignore = b, floorsOptional)
);
}
@Override
public boolean isBuffered(){
return true;
}
@Override
public void apply(){
if(in.floor == block || block == Blocks.air || in.floor == ignore) return;
@@ -31,7 +37,7 @@ public class BlendFilter extends GenerateFilter{
outer:
for(int x = -rad; x <= rad; x++){
for(int y = -rad; y <= rad; y++){
if(Mathf.dst2(x, y) > rad*rad) continue;
if(Mathf.within(x, y, rad)) continue;
Tile tile = in.tile(in.x + x, in.y + y);
if(tile.floor() == block || tile.block() == block || tile.overlay() == block){

8
core/src/mindustry/maps/filters/ClearFilter.java
View File

@@ -1,5 +1,6 @@
package mindustry.maps.filters;
import arc.util.*;
import mindustry.content.*;
import mindustry.world.*;
@@ -8,10 +9,9 @@ import static mindustry.maps.filters.FilterOption.*;
public class ClearFilter extends GenerateFilter{
protected Block block = Blocks.air;
{
options(
new BlockOption("block", () -> block, b -> block = b, wallsOnly)
);
@Override
public FilterOption[] options(){
return Structs.arr(new BlockOption("block", () -> block, b -> block = b, wallsOnly));
}
@Override

43
core/src/mindustry/maps/filters/CoreSpawnFilter.java Normal file
View File

@@ -0,0 +1,43 @@
package mindustry.maps.filters;
import arc.struct.*;
import arc.util.*;
import mindustry.maps.filters.FilterOption.*;
import mindustry.world.*;
import mindustry.world.blocks.storage.*;
import static mindustry.Vars.*;
/** Selects X spawns from the core spawn pool.*/
public class CoreSpawnFilter extends GenerateFilter{
int amount = 1;
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("amount", () -> amount, f -> amount = (int)f, 1, 10).display()
);
}
@Override
public void apply(Tiles tiles, GenerateInput in){
IntArray spawns = new IntArray();
for(Tile tile : tiles){
if(tile.getTeam() == state.rules.defaultTeam && tile.block() instanceof CoreBlock){
spawns.add(tile.pos());
}
}
spawns.shuffle();
int used = Math.min(spawns.size, amount);
for(int i = used; i < spawns.size; i++){
tiles.getp(spawns.get(i)).remove();
}
}
@Override
public boolean isPost(){
return true;
}
}

16
core/src/mindustry/maps/filters/DistortFilter.java
View File

@@ -1,5 +1,6 @@
package mindustry.maps.filters;
import arc.util.*;
import mindustry.maps.filters.FilterOption.*;
import mindustry.world.*;
import mindustry.world.blocks.*;
@@ -7,14 +8,19 @@ import mindustry.world.blocks.*;
public class DistortFilter extends GenerateFilter{
float scl = 40, mag = 5;
{
buffered = true;
options(
new SliderOption("scale", () -> scl, f -> scl = f, 1f, 200f),
new SliderOption("mag", () -> mag, f -> mag = f, 0.5f, 100f)
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("scale", () -> scl, f -> scl = f, 1f, 200f),
new SliderOption("mag", () -> mag, f -> mag = f, 0.5f, 100f)
);
}
@Override
public boolean isBuffered(){
return true;
}
@Override
public void apply(){
Tile tile = in.tile(in.x + noise(in.x, in.y, scl, mag) - mag / 2f, in.y + noise(in.x, in.y + o, scl, mag) - mag / 2f);

42
core/src/mindustry/maps/filters/EnemySpawnFilter.java Normal file
View File

@@ -0,0 +1,42 @@
package mindustry.maps.filters;
import arc.struct.*;
import arc.util.*;
import mindustry.content.*;
import mindustry.maps.filters.FilterOption.*;
import mindustry.world.*;
/** Selects X spawns from the spawn pool.*/
public class EnemySpawnFilter extends GenerateFilter{
int amount = 1;
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("amount", () -> amount, f -> amount = (int)f, 1, 10).display()
);
}
@Override
public void apply(Tiles tiles, GenerateInput in){
IntArray spawns = new IntArray();
for(Tile tile : tiles){
if(tile.overlay() == Blocks.spawn){
spawns.add(tile.pos());
}
}
spawns.shuffle();
int used = Math.min(spawns.size, amount);
for(int i = used; i < spawns.size; i++){
Tile tile = tiles.getp(spawns.get(i));
tile.clearOverlay();
}
}
@Override
public boolean isPost(){
return true;
}
}

13
core/src/mindustry/maps/filters/FilterOption.java
View File

@@ -35,6 +35,8 @@ public abstract class FilterOption{
final Floatc setter;
final float min, max, step;
boolean display;
SliderOption(String name, Floatp getter, Floatc setter, float min, float max){
this(name, getter, setter, min, max, (max - min) / 200);
}
@@ -48,9 +50,18 @@ public abstract class FilterOption{
this.step = step;
}
public SliderOption display(){
display = true;
return this;
}
@Override
public void build(Table table){
table.add("$filter.option." + name);
if(!display){
table.add("$filter.option." + name);
}else{
table.label(() -> Core.bundle.get("filter.option." + name) + ": " + (int)getter.get());
}
table.row();
Slider slider = table.addSlider(min, max, step, setter).growX().get();
slider.setValue(getter.get());

39
core/src/mindustry/maps/filters/GenerateFilter.java
View File

@@ -7,32 +7,37 @@ import arc.util.*;
import arc.util.noise.*;
import mindustry.content.*;
import mindustry.world.*;
import mindustry.world.blocks.*;
public abstract class GenerateFilter{
protected transient float o = (float)(Math.random() * 10000000.0);
protected transient long seed;
protected transient GenerateInput in;
public transient boolean buffered = false;
public transient FilterOption[] options;
public void apply(Tiles tiles, GenerateInput in){
this.in = in;
for(Tile tile : tiles){
in.apply(tile.x, tile.y, tile.floor(), tile.block(), tile.overlay());
apply();
tile.setFloor(in.floor.asFloor());
tile.setOverlay(in.floor.asFloor().isLiquid ? Blocks.air : in.ore);
if(!tile.block().synthetic() && !in.block.synthetic()){
tile.setBlock(in.block);
}
}
}
public final void apply(GenerateInput in){
this.in = in;
apply();
//remove extra ores on liquids
if(((Floor)in.floor).isLiquid){
in.ore = Blocks.air;
}
}
/** sets up the options; this is necessary since the constructor can't access subclass variables. */
protected void options(FilterOption... options){
this.options = options;
}
/** @return a new array of options for configuring this filter */
public abstract FilterOption[] options();
/** apply the actual filter on the input */
protected abstract void apply();
protected void apply(){}
/** draw any additional guides */
public void draw(Image image){}
@@ -47,6 +52,16 @@ public abstract class GenerateFilter{
seed = Mathf.random(99999999);
}
/** @return whether this filter needs a read/write buffer (e.g. not a 1:1 tile mapping). */
public boolean isBuffered(){
return false;
}
/** @return whether this filter can *only* be used while generating the map, e.g. is not undoable. */
public boolean isPost(){
return false;
}
//utility generation functions
protected float noise(float x, float y, float scl, float mag){

16
core/src/mindustry/maps/filters/MedianFilter.java
View File

@@ -2,6 +2,7 @@ package mindustry.maps.filters;
import arc.struct.*;
import arc.math.*;
import arc.util.*;
import mindustry.maps.filters.FilterOption.*;
import mindustry.world.*;
@@ -12,14 +13,19 @@ public class MedianFilter extends GenerateFilter{
float percentile = 0.5f;
IntArray blocks = new IntArray(), floors = new IntArray();
{
buffered = true;
options(
new SliderOption("radius", () -> radius, f -> radius = f, 1f, 12f),
new SliderOption("percentile", () -> percentile, f -> percentile = f, 0f, 1f)
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("radius", () -> radius, f -> radius = f, 1f, 12f),
new SliderOption("percentile", () -> percentile, f -> percentile = f, 0f, 1f)
);
}
@Override
public boolean isBuffered(){
return true;
}
@Override
public void apply(){
int rad = (int)radius;

7
core/src/mindustry/maps/filters/MirrorFilter.java
View File

@@ -15,8 +15,11 @@ public class MirrorFilter extends GenerateFilter{
int angle = 45;
{
options(new SliderOption("angle", () -> angle, f -> angle = (int)f, 0, 360, 45));
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("angle", () -> angle, f -> angle = (int)f, 0, 360, 45)
);
}
@Override

6
core/src/mindustry/maps/filters/NoiseFilter.java
View File

@@ -1,5 +1,6 @@
package mindustry.maps.filters;
import arc.util.*;
import mindustry.content.Blocks;
import mindustry.maps.filters.FilterOption.BlockOption;
import mindustry.maps.filters.FilterOption.SliderOption;
@@ -12,8 +13,9 @@ public class NoiseFilter extends GenerateFilter{
float scl = 40, threshold = 0.5f, octaves = 3f, falloff = 0.5f;
Block floor = Blocks.stone, block = Blocks.rocks;
{
options(
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("scale", () -> scl, f -> scl = f, 1f, 500f),
new SliderOption("threshold", () -> threshold, f -> threshold = f, 0f, 1f),
new SliderOption("octaves", () -> octaves, f -> octaves = f, 1f, 10f),

16
core/src/mindustry/maps/filters/OreFilter.java
View File

@@ -1,5 +1,6 @@
package mindustry.maps.filters;
import arc.util.*;
import mindustry.content.Blocks;
import mindustry.maps.filters.FilterOption.SliderOption;
import mindustry.world.Block;
@@ -11,13 +12,14 @@ public class OreFilter extends GenerateFilter{
public float scl = 23, threshold = 0.81f, octaves = 2f, falloff = 0.3f;
public Block ore = Blocks.oreCopper;
{
options(
new SliderOption("scale", () -> scl, f -> scl = f, 1f, 500f),
new SliderOption("threshold", () -> threshold, f -> threshold = f, 0f, 1f),
new SliderOption("octaves", () -> octaves, f -> octaves = f, 1f, 10f),
new SliderOption("falloff", () -> falloff, f -> falloff = f, 0f, 1f),
new BlockOption("ore", () -> ore, b -> ore = b, oresOnly)
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("scale", () -> scl, f -> scl = f, 1f, 500f),
new SliderOption("threshold", () -> threshold, f -> threshold = f, 0f, 1f),
new SliderOption("octaves", () -> octaves, f -> octaves = f, 1f, 10f),
new SliderOption("falloff", () -> falloff, f -> falloff = f, 0f, 1f),
new BlockOption("ore", () -> ore, b -> ore = b, oresOnly)
);
}

16
core/src/mindustry/maps/filters/OreMedianFilter.java
View File

@@ -2,6 +2,7 @@ package mindustry.maps.filters;
import arc.struct.*;
import arc.math.*;
import arc.util.*;
import mindustry.*;
import mindustry.content.*;
import mindustry.maps.filters.FilterOption.*;
@@ -13,14 +14,19 @@ public class OreMedianFilter extends GenerateFilter{
private IntArray blocks = new IntArray();
{
buffered = true;
options(
new SliderOption("radius", () -> radius, f -> radius = f, 1f, 12f),
new SliderOption("percentile", () -> percentile, f -> percentile = f, 0f, 1f)
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("radius", () -> radius, f -> radius = f, 1f, 12f),
new SliderOption("percentile", () -> percentile, f -> percentile = f, 0f, 1f)
);
}
@Override
public boolean isBuffered(){
return true;
}
@Override
public void apply(){
if(in.ore == Blocks.spawn) return;

35
core/src/mindustry/maps/filters/RandomItemFilter.java Normal file
View File

@@ -0,0 +1,35 @@
package mindustry.maps.filters;
import arc.math.*;
import arc.struct.*;
import mindustry.type.*;
import mindustry.world.*;
import mindustry.world.blocks.storage.*;
public class RandomItemFilter extends GenerateFilter{
public Array<ItemStack> drops = new Array<>();
public float chance = 0.3f;
@Override
public FilterOption[] options(){
return new FilterOption[0];
}
@Override
public void apply(Tiles tiles, GenerateInput in){
for(Tile tile : tiles){
if(tile.block() instanceof StorageBlock && !(tile.block() instanceof CoreBlock)){
for(ItemStack stack : drops){
if(Mathf.chance(chance)){
tile.entity.items.add(stack.item, Math.min(Mathf.random(stack.amount), tile.block().itemCapacity));
}
}
}
}
}
@Override
public boolean isPost(){
return true;
}
}

6
core/src/mindustry/maps/filters/RiverNoiseFilter.java
View File

@@ -1,5 +1,6 @@
package mindustry.maps.filters;
import arc.util.*;
import mindustry.content.Blocks;
import mindustry.maps.filters.FilterOption.BlockOption;
import mindustry.maps.filters.FilterOption.SliderOption;
@@ -12,8 +13,9 @@ public class RiverNoiseFilter extends GenerateFilter{
float scl = 40, threshold = 0f, threshold2 = 0.1f;
Block floor = Blocks.water, floor2 = Blocks.deepwater, block = Blocks.sandRocks;
{
options(
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("scale", () -> scl, f -> scl = f, 1f, 500f),
new SliderOption("threshold", () -> threshold, f -> threshold = f, -1f, 0.3f),
new SliderOption("threshold2", () -> threshold2, f -> threshold2 = f, -1f, 0.3f),

6
core/src/mindustry/maps/filters/ScatterFilter.java
View File

@@ -1,5 +1,6 @@
package mindustry.maps.filters;
import arc.util.*;
import mindustry.content.Blocks;
import mindustry.maps.filters.FilterOption.BlockOption;
import mindustry.maps.filters.FilterOption.SliderOption;
@@ -11,8 +12,9 @@ public class ScatterFilter extends GenerateFilter{
protected float chance = 0.014f;
protected Block flooronto = Blocks.air, floor = Blocks.air, block = Blocks.air;
{
options(
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("chance", () -> chance, f -> chance = f, 0f, 1f),
new BlockOption("flooronto", () -> flooronto, b -> flooronto = b, floorsOptional),
new BlockOption("floor", () -> floor, b -> floor = b, floorsOptional),

6
core/src/mindustry/maps/filters/TerrainFilter.java
View File

@@ -1,6 +1,7 @@
package mindustry.maps.filters;
import arc.math.Mathf;
import arc.util.*;
import mindustry.content.Blocks;
import mindustry.maps.filters.FilterOption.BlockOption;
import mindustry.maps.filters.FilterOption.SliderOption;
@@ -13,8 +14,9 @@ public class TerrainFilter extends GenerateFilter{
float scl = 40, threshold = 0.9f, octaves = 3f, falloff = 0.5f, magnitude = 1f, circleScl = 2.1f;
Block floor = Blocks.stone, block = Blocks.rocks;
{
options(
@Override
public FilterOption[] options(){
return Structs.arr(
new SliderOption("scale", () -> scl, f -> scl = f, 1f, 500f),
new SliderOption("mag", () -> magnitude, f -> magnitude = f, 0f, 2f),
new SliderOption("threshold", () -> threshold, f -> threshold = f, 0f, 1f),

4
core/src/mindustry/maps/generators/BaseGenerator.java Normal file
View File

@@ -0,0 +1,4 @@
package mindustry.maps.generators;
public class BaseGenerator{
}

60
core/src/mindustry/maps/generators/BasicGenerator.java
View File

@@ -26,14 +26,14 @@ public abstract class BasicGenerator extends RandomGenerator{
}
@Override
public void generate(Tile[][] tiles){
public void generate(Tiles tiles){
int seed = Mathf.random(99999999);
sim.setSeed(seed);
sim2.setSeed(seed + 1);
super.generate(tiles);
}
public void ores(Tile[][] tiles){
public void ores(Tiles tiles){
pass(tiles, (x, y) -> {
if(ores != null){
int offsetX = x - 4, offsetY = y + 23;
@@ -49,7 +49,7 @@ public abstract class BasicGenerator extends RandomGenerator{
});
}
public void terrain(Tile[][] tiles, Block dst, float scl, float mag, float cmag){
public void terrain(Tiles tiles, Block dst, float scl, float mag, float cmag){
pass(tiles, (x, y) -> {
double rocks = sim.octaveNoise2D(5, 0.5, 1f / scl, x, y) * mag
+ Mathf.dst((float)x / width, (float)y / height, 0.5f, 0.5f) * cmag;
@@ -66,11 +66,11 @@ public abstract class BasicGenerator extends RandomGenerator{
});
}
public void noise(Tile[][] tiles, Block floor, Block block, int octaves, float falloff, float scl, float threshold){
public void noise(Tiles tiles, Block floor, Block block, int octaves, float falloff, float scl, float threshold){
sim.setSeed(Mathf.random(99999));
pass(tiles, (x, y) -> {
if(sim.octaveNoise2D(octaves, falloff, 1f / scl, x, y) > threshold){
Tile tile = tiles[x][y];
Tile tile = tiles.getn(x, y);
this.floor = floor;
if(tile.block().solid){
this.block = block;
@@ -79,16 +79,16 @@ public abstract class BasicGenerator extends RandomGenerator{
});
}
public void overlay(Tile[][] tiles, Block floor, Block block, float chance, int octaves, float falloff, float scl, float threshold){
public void overlay(Tiles tiles, Block floor, Block block, float chance, int octaves, float falloff, float scl, float threshold){
sim.setSeed(Mathf.random(99999));
pass(tiles, (x, y) -> {
if(sim.octaveNoise2D(octaves, falloff, 1f / scl, x, y) > threshold && Mathf.chance(chance) && tiles[x][y].floor() == floor){
if(sim.octaveNoise2D(octaves, falloff, 1f / scl, x, y) > threshold && Mathf.chance(chance) && tiles.getn(x, y).floor() == floor){
ore = block;
}
});
}
public void tech(Tile[][] tiles){
public void tech(Tiles tiles){
Block[] blocks = {Blocks.darkPanel3};
int secSize = 20;
pass(tiles, (x, y) -> {
@@ -109,13 +109,13 @@ public abstract class BasicGenerator extends RandomGenerator{
});
}
public void distort(Tile[][] tiles, float scl, float mag){
public void distort(Tiles tiles, float scl, float mag){
Block[][] blocks = new Block[width][height];
Floor[][] floors = new Floor[width][height];
each((x, y) -> {
float cx = x + noise(x, y, scl, mag) - mag / 2f, cy = y + noise(x, y + 1525215f, scl, mag) - mag / 2f;
Tile other = tiles[Mathf.clamp((int)cx, 0, width-1)][Mathf.clamp((int)cy, 0, height-1)];
Tile other = tiles.getn(Mathf.clamp((int)cx, 0, width-1), Mathf.clamp((int)cy, 0, height-1));
blocks[x][y] = other.block();
floors[x][y] = other.floor();
});
@@ -126,7 +126,7 @@ public abstract class BasicGenerator extends RandomGenerator{
});
}
public void scatter(Tile[][] tiles, Block target, Block dst, float chance){
public void scatter(Tiles tiles, Block target, Block dst, float chance){
pass(tiles, (x, y) -> {
if(!Mathf.chance(chance)) return;
if(floor == target){
@@ -149,40 +149,40 @@ public abstract class BasicGenerator extends RandomGenerator{
return (float)sim2.octaveNoise2D(1f, 0f, 1f / scl, x + 0x361266f, y + 0x251259f) * mag;
}
public void pass(Tile[][] tiles, Intc2 r){
public void pass(Tiles tiles, Intc2 r){
for(int x = 0; x < width; x++){
for(int y = 0; y < height; y++){
floor = tiles[x][y].floor();
block = tiles[x][y].block();
ore = tiles[x][y].overlay();
floor = tiles.getn(x, y).floor();
block = tiles.getn(x, y).block();
ore = tiles.getn(x, y).overlay();
r.get(x, y);
tiles[x][y] = new Tile(x, y, floor.id, ore.id, block.id);
tiles.set(x, y, new Tile(x, y, floor, ore, block));
}
}
}
public void brush(Tile[][] tiles, Array<Tile> path, int rad){
public void brush(Tiles tiles, Array<Tile> path, int rad){
path.each(tile -> erase(tiles, tile.x, tile.y, rad));
}
public void erase(Tile[][] tiles, int cx, int cy, int rad){
public void erase(Tiles tiles, int cx, int cy, int rad){
for(int x = -rad; x <= rad; x++){
for(int y = -rad; y <= rad; y++){
int wx = cx + x, wy = cy + y;
if(Structs.inBounds(wx, wy, width, height) && Mathf.dst(x, y, 0, 0) <= rad){
Tile other = tiles[wx][wy];
Tile other = tiles.getn(wx, wy);
other.setBlock(Blocks.air);
}
}
}
}
public Array<Tile> pathfind(Tile[][] tiles, int startX, int startY, int endX, int endY, TileHueristic th, DistanceHeuristic dh){
Tile start = tiles[startX][startY];
Tile end = tiles[endX][endY];
public Array<Tile> pathfind(Tiles tiles, int startX, int startY, int endX, int endY, TileHueristic th, DistanceHeuristic dh){
Tile start = tiles.getn(startX, startY);
Tile end = tiles.getn(endX, endY);
GridBits closed = new GridBits(width, height);
IntFloatMap costs = new IntFloatMap();
PriorityQueue<Tile> queue = new PriorityQueue<>(tiles.length * tiles[0].length / 2, (a, b) -> Float.compare(costs.get(a.pos(), 0f) + dh.cost(a.x, a.y, end.x, end.y), costs.get(b.pos(), 0f) + dh.cost(b.x, b.y, end.x, end.y)));
PriorityQueue<Tile> queue = new PriorityQueue<>(tiles.width() * tiles.height()/4, (a, b) -> Float.compare(costs.get(a.pos(), 0f) + dh.cost(a.x, a.y, end.x, end.y), costs.get(b.pos(), 0f) + dh.cost(b.x, b.y, end.x, end.y)));
queue.add(start);
boolean found = false;
while(!queue.isEmpty()){
@@ -196,7 +196,7 @@ public abstract class BasicGenerator extends RandomGenerator{
for(Point2 point : Geometry.d4){
int newx = next.x + point.x, newy = next.y + point.y;
if(Structs.inBounds(newx, newy, width, height)){
Tile child = tiles[newx][newy];
Tile child = tiles.getn(newx, newy);
if(!closed.get(child.x, child.y)){
closed.set(child.x, child.y);
child.rotation(child.relativeTo(next.x, next.y));
@@ -215,7 +215,7 @@ public abstract class BasicGenerator extends RandomGenerator{
while(current != start){
out.add(current);
Point2 p = Geometry.d4(current.rotation());
current = tiles[current.x + p.x][current.y + p.y];
current = tiles.getn(current.x + p.x, current.y + p.y);
}
out.reverse();
@@ -223,17 +223,17 @@ public abstract class BasicGenerator extends RandomGenerator{
return out;
}
public void inverseFloodFill(Tile[][] tiles, Tile start, Block block){
public void inverseFloodFill(Tiles tiles, Tile start, Block block){
IntArray arr = new IntArray();
arr.add(start.pos());
while(!arr.isEmpty()){
int i = arr.pop();
int x = Pos.x(i), y = Pos.y(i);
tiles[x][y].cost = 2;
tiles.getn(x, y).cost = 2;
for(Point2 point : Geometry.d4){
int newx = x + point.x, newy = y + point.y;
if(Structs.inBounds(newx, newy, width, height)){
Tile child = tiles[newx][newy];
if(tiles.in(newx, newy)){
Tile child = tiles.getn(newx, newy);
if(child.block() == Blocks.air && child.cost != 2){
child.cost = 2;
arr.add(child.pos());
@@ -244,7 +244,7 @@ public abstract class BasicGenerator extends RandomGenerator{
for(int x = 0; x < width; x ++){
for(int y = 0; y < height; y++){
Tile tile = tiles[x][y];
Tile tile = tiles.getn(x, y);
if(tile.cost != 2 && tile.block() == Blocks.air){
tile.setBlock(block);
}

2
core/src/mindustry/maps/generators/Generator.java
View File

@@ -19,5 +19,5 @@ public abstract class Generator{
this.loadout = loadout;
}
public abstract void generate(Tile[][] tiles);
public abstract void generate(Tiles tiles);
}

136
core/src/mindustry/maps/generators/MapGenerator.java
View File

@@ -1,53 +1,33 @@
package mindustry.maps.generators;
import arc.struct.*;
import arc.math.*;
import arc.math.geom.*;
import arc.util.*;
import mindustry.content.*;
import mindustry.game.*;
import mindustry.io.*;
import mindustry.maps.*;
import mindustry.type.*;
import mindustry.world.*;
import mindustry.world.blocks.*;
import mindustry.world.blocks.storage.*;
import static mindustry.Vars.*;
//TODO:
//- limited # of enemy spawns as filter
//- spawn loadout selection as filter
//- configure map loadout, make 1 core the default
public class MapGenerator extends Generator{
private Map map;
private String mapName;
private Array<Decoration> decorations = Array.with(new Decoration(Blocks.stone, Blocks.rock, 0.003f));
/**
* The amount of final enemy spawns used. -1 to use everything in the map.
* This amount of enemy spawns is selected randomly from the map.
*/
public int enemySpawns = -1;
/** Whether floor is distorted along with blocks. */
public boolean distortFloor = false;
public MapGenerator(String mapName){
this.mapName = mapName;
}
public MapGenerator(String mapName, int enemySpawns){
this.mapName = mapName;
this.enemySpawns = enemySpawns;
}
public MapGenerator decor(Decoration... decor){
this.decorations.addAll(decor);
return this;
}
public void removePrefix(String name){
this.mapName = this.mapName.substring(name.length() + 1);
}
{
decor(new Decoration(Blocks.snow, Blocks.snowrock, 0.01), new Decoration(Blocks.ignarock, Blocks.pebbles, 0.03f));
}
public Map getMap(){
return map;
}
@@ -61,110 +41,44 @@ public class MapGenerator extends Generator{
}
@Override
public void generate(Tile[][] tiles){
for(int x = 0; x < width; x++){
for(int y = 0; y < height; y++){
tiles[x][y] = new Tile(x, y);
}
}
public void generate(Tiles tiles){
tiles.fill();
SaveIO.load(map.file);
Array<Point2> players = new Array<>();
Array<Point2> enemies = new Array<>();
for(int x = 0; x < width; x++){
for(int y = 0; y < height; y++){
if(tiles[x][y].block() instanceof CoreBlock && tiles[x][y].getTeam() == state.rules.defaultTeam){
players.add(new Point2(x, y));
tiles[x][y].setBlock(Blocks.air);
}
if(tiles[x][y].overlay() == Blocks.spawn && enemySpawns != -1){
enemies.add(new Point2(x, y));
tiles[x][y].setOverlay(Blocks.air);
}
if(tiles[x][y].block() instanceof BlockPart){
tiles[x][y].setBlock(Blocks.air);
}
}
}
for(int x = 0; x < width; x++){
for(int y = 0; y < height; y++){
Tile tile = tiles[x][y];
for(Decoration decor : decorations){
if(x > 0 && y > 0 && (tiles[x - 1][y].block() == decor.wall || tiles[x][y - 1].block() == decor.wall)){
continue;
}
if(tile.block() == Blocks.air && !(decor.wall instanceof Floor) && tile.floor() == decor.floor && Mathf.chance(decor.chance)){
tile.setBlock(decor.wall);
}else if(tile.floor() == decor.floor && decor.wall.isOverlay() && Mathf.chance(decor.chance)){
tile.setOverlay(decor.wall);
}else if(tile.floor() == decor.floor && decor.wall.isFloor() && !decor.wall.isOverlay() && Mathf.chance(decor.chance)){
tile.setFloor((Floor)decor.wall);
}
}
if(tile.block() instanceof StorageBlock && !(tile.block() instanceof CoreBlock) && world.getZone() != null){
for(Item item : world.getZone().resources){
if(Mathf.chance(0.3)){
tile.entity.items().add(item, Math.min(Mathf.random(500), tile.block().itemCapacity));
}
for(Tile tile : tiles){
if(tile.block() instanceof StorageBlock && !(tile.block() instanceof CoreBlock) && world.getZone() != null){
for(Item item : world.getZone().resources){
if(Mathf.chance(0.3)){
tile.entity.items().add(item, Math.min(Mathf.random(500), tile.block().itemCapacity));
}
}
}
}
if(enemySpawns != -1){
if(enemySpawns > enemies.size){
throw new IllegalArgumentException("Enemy spawn pool greater than map spawn number for map: " + mapName);
boolean anyCores = false;
for(Tile tile : tiles){
if(tile.overlay() == Blocks.spawn){
int rad = 10;
Geometry.circle(tile.x, tile.y, tiles.width(), tiles.height(), rad, (wx, wy) -> {
if(tile.overlay().itemDrop != null){
tile.clearOverlay();
}
});
}
enemies.shuffle();
for(int i = 0; i < enemySpawns; i++){
Point2 point = enemies.get(i);
tiles[point.x][point.y].setOverlay(Blocks.spawn);
int rad = 10, frad = 12;
for(int x = -rad; x <= rad; x++){
for(int y = -rad; y <= rad; y++){
int wx = x + point.x, wy = y + point.y;
double dst = Mathf.dst(x, y);
if(dst < frad && Structs.inBounds(wx, wy, tiles) && (dst <= rad || Mathf.chance(0.5))){
Tile tile = tiles[wx][wy];
if(tile.overlay() != Blocks.spawn){
tile.clearOverlay();
}
}
}
}
if(tile.block() instanceof CoreBlock && tile.getTeam() == state.rules.defaultTeam){
schematics.placeLoadout(loadout, tile.x, tile.y);
anyCores = true;
}
}
Point2 core = players.random();
if(core == null){
if(!anyCores){
throw new IllegalArgumentException("All zone maps must have a core.");
}
schematics.placeLoadout(loadout, core.x, core.y);
world.prepareTiles(tiles);
world.setMap(map);
}
public static class Decoration{
public final Block floor;
public final Block wall;
public final double chance;
public Decoration(Block floor, Block wall, double chance){
this.floor = floor;
this.wall = wall;
this.chance = chance;
}
}
}

15
core/src/mindustry/maps/generators/RandomGenerator.java
View File

@@ -1,10 +1,9 @@
package mindustry.maps.generators;
import arc.struct.StringMap;
import mindustry.content.Blocks;
import mindustry.maps.Map;
import mindustry.world.Block;
import mindustry.world.Tile;
import arc.struct.*;
import mindustry.content.*;
import mindustry.maps.*;
import mindustry.world.*;
import static mindustry.Vars.world;
@@ -18,14 +17,14 @@ public abstract class RandomGenerator extends Generator{
}
@Override
public void generate(Tile[][] tiles){
public void generate(Tiles tiles){
for(int x = 0; x < width; x++){
for(int y = 0; y < height; y++){
floor = Blocks.air;
block = Blocks.air;
ore = Blocks.air;
generate(x, y);
tiles[x][y] = new Tile(x, y, floor.id, ore.id, block.id);
tiles.set(x, y, new Tile(x, y, floor, ore, block));
}
}
@@ -34,7 +33,7 @@ public abstract class RandomGenerator extends Generator{
world.setMap(new Map(new StringMap()));
}
public abstract void decorate(Tile[][] tiles);
public abstract void decorate(Tiles tiles);
/**
* Sets {@link #floor} and {@link #block} to the correct values as output.

11
core/src/mindustry/maps/planet/PlanetGenerator.java Normal file
View File

@@ -0,0 +1,11 @@
package mindustry.maps.planet;
import arc.graphics.*;
import arc.math.geom.*;
import mindustry.world.*;
public interface PlanetGenerator{
float getHeight(Vec3 position);
Color getColor(Vec3 position);
void generate(Vec3 position, TileGen tile);
}

60
core/src/mindustry/maps/planet/TestPlanetGenerator.java Normal file
View File

@@ -0,0 +1,60 @@
package mindustry.maps.planet;
import arc.graphics.*;
import arc.math.*;
import arc.math.geom.*;
import arc.struct.*;
import arc.util.*;
import arc.util.noise.*;
import mindustry.content.*;
import mindustry.world.*;
public class TestPlanetGenerator implements PlanetGenerator{
Pixmap pix;
Simplex noise = new Simplex();
int waterLevel = 5;
float water;
float scl = 5f;
Array<Block> blocks = Array.with(Blocks.sporeMoss, Blocks.moss, Blocks.ice, Blocks.snow, Blocks.sand, Blocks.darksand, Blocks.darksandWater, Blocks.darksandTaintedWater);
public TestPlanetGenerator(){
try{
pix = new Pixmap("planets/colors.png");
water = waterLevel / (float)(pix.getHeight());
}catch(Exception ignored){
}
}
@Override
public float getHeight(Vec3 position){
position = Tmp.v33.set(position).scl(scl);
float height = Mathf.pow((float)noise.octaveNoise3D(7, 0.48f, 1f/3f, position.x, position.y, position.z), 2.4f);
if(height <= water){
return water;
}
return height;
}
@Override
public Color getColor(Vec3 position){
float height = getHeight(position);
position = Tmp.v33.set(position).scl(scl);
float rad = scl;
float temp = Mathf.clamp(Math.abs(position.y * 2f) / (rad));
float tnoise = (float)noise.octaveNoise3D(7, 0.48f, 1f/3f, position.x, position.y + 999f, position.z);
temp = Mathf.lerp(temp, tnoise, 0.5f);
height *= 1.2f;
height = Mathf.clamp(height);
Color color = Tmp.c1.set(pix.getPixel((int)(temp * (pix.getWidth()-1)), (int)((1f-height) * (pix.getHeight()-1))));
return blocks.min(c -> color.diff(c.color)).color;
}
@Override
public void generate(Vec3 position, TileGen tile){
Color color = getColor(position);
tile.floor = blocks.min(c -> color.diff(c.color));
}
}

8
core/src/mindustry/maps/zonegen/DesertWastesGenerator.java
View File

@@ -3,7 +3,7 @@ package mindustry.maps.zonegen;
import arc.math.Mathf;
import mindustry.content.Blocks;
import mindustry.maps.generators.BasicGenerator;
import mindustry.world.Tile;
import mindustry.world.*;
import static mindustry.Vars.schematics;
@@ -19,7 +19,7 @@ public class DesertWastesGenerator extends BasicGenerator{
}
@Override
public void decorate(Tile[][] tiles){
public void decorate(Tiles tiles){
ores(tiles);
terrain(tiles, Blocks.sandRocks, 60f, 1.5f, 0.9f);
@@ -34,7 +34,7 @@ public class DesertWastesGenerator extends BasicGenerator{
erase(tiles, endX, endY, 10);
erase(tiles, spawnX, spawnY, 20);
distort(tiles, 20f, 4f);
inverseFloodFill(tiles, tiles[spawnX][spawnY], Blocks.sandRocks);
inverseFloodFill(tiles, tiles.getn(spawnX, spawnY), Blocks.sandRocks);
noise(tiles, Blocks.salt, Blocks.saltRocks, 5, 0.6f, 200f, 0.55f);
noise(tiles, Blocks.darksand, Blocks.duneRocks, 5, 0.7f, 120f, 0.5f);
@@ -43,7 +43,7 @@ public class DesertWastesGenerator extends BasicGenerator{
overlay(tiles, Blocks.sand, Blocks.pebbles, 0.15f, 5, 0.8f, 30f, 0.62f);
//scatter(tiles, Blocks.sandRocks, Blocks.creeptree, 1f);
tiles[endX][endY].setOverlay(Blocks.spawn);
tiles.getn(endX, endY).setOverlay(Blocks.spawn);
schematics.placeLoadout(loadout, spawnX, spawnY);
}
}

14
core/src/mindustry/maps/zonegen/OvergrowthGenerator.java
View File

@@ -1,9 +1,9 @@
package mindustry.maps.zonegen;
import arc.math.Mathf;
import mindustry.content.Blocks;
import mindustry.maps.generators.BasicGenerator;
import mindustry.world.Tile;
import arc.math.*;
import mindustry.content.*;
import mindustry.maps.generators.*;
import mindustry.world.*;
import static mindustry.Vars.schematics;
@@ -19,7 +19,7 @@ public class OvergrowthGenerator extends BasicGenerator{
}
@Override
public void decorate(Tile[][] tiles){
public void decorate(Tiles tiles){
ores(tiles);
terrain(tiles, Blocks.sporePine, 70f, 1.4f, 1f);
@@ -34,12 +34,12 @@ public class OvergrowthGenerator extends BasicGenerator{
erase(tiles, endX, endY, 10);
erase(tiles, spawnX, spawnY, 20);
distort(tiles, 20f, 4f);
inverseFloodFill(tiles, tiles[spawnX][spawnY], Blocks.sporerocks);
inverseFloodFill(tiles, tiles.getn(spawnX, spawnY), Blocks.sporerocks);
noise(tiles, Blocks.darksandTaintedWater, Blocks.duneRocks, 4, 0.7f, 120f, 0.64f);
//scatter(tiles, Blocks.sporePine, Blocks.whiteTreeDead, 1f);
tiles[endX][endY].setOverlay(Blocks.spawn);
tiles.getn(endX, endY).setOverlay(Blocks.spawn);
schematics.placeLoadout(loadout, spawnX, spawnY);
}
}