7351367576

Committed 28 Dec 2023 06:50PM UTC coverage: 51.185% (-0.1%) from 51.312%

Build # 7351367576

Build Type

push

github

Committed by

Martomate

Commit Message

Refactor: Made Chunk not know if it has been saved to file

Run Details

9 of 12 new or added lines in 2 files covered. (75.0%)

110 existing lines in 32 files now uncovered.

2829 of 5527 relevant lines covered (51.19%)

0.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.49

/game/src/main/scala/hexacraft/world/gen/tree/strategies.scala

package hexacraft.world.gen.tree

import hexacraft.world.block.Block
import hexacraft.world.coord.{NeighborOffsets, Offset}

import scala.collection.mutable.ArrayBuffer
import scala.util.Random

trait TreeGenStrategy {
  protected final type BlockSpec = (Offset, Block)

  def blocks(rand: Random): Seq[BlockSpec]
}

class HugeTreeGenStrategy(logBlock: Block, leavesBlock: Block) extends TreeGenStrategy {
  override def blocks(rand: Random): Seq[(Offset, Block)] = {
    val builder = new Builder(rand)

    builder.generateStem(Offset(0, 0, 0), 7, 3, 40)
    builder.generateTreeCrown(Offset(0, 40, 0), 60, 0.7f, 0.5f, 0.5f)

    builder.blocks
  }

  private class Builder(rand: Random) {
    val logs: ArrayBuffer[BlockSpec] = ArrayBuffer.empty
    val leaves: ArrayBuffer[BlockSpec] = ArrayBuffer.empty

    def generateStem(
        start: Offset,
        crossSectionBottom: Int,
        crossSectionTop: Int,
        length: Int
    ): Unit = {
      require(crossSectionBottom <= 7, "Trees with cross section greater than 7 are not supported")
      require(
        crossSectionBottom >= crossSectionTop,
        "Trees with a wider top than bottom are not supported"
      )

      val firstNeighborIndex = rand.nextInt(6)
      val neighbors = NeighborOffsets.all.filter(_.dy == 0).map(start + _)
      val reorderedNeighbors =
        rand.shuffle(neighbors.drop(firstNeighborIndex) ++ neighbors.take(firstNeighborIndex))
      val neighborRoots = reorderedNeighbors.slice(crossSectionTop - 1, crossSectionBottom - 1)
      val neighborHeights =
        randomlyDivideInterval(crossSectionBottom - crossSectionTop + 1, 0.1f, length).map(_.round)

      logs ++= PillarGenerator(length).generate(start, logBlock)
      for (i <- 0 until crossSectionTop - 1)
        logs ++= PillarGenerator(length).generate(reorderedNeighbors(i), logBlock)

      for ((r, h) <- neighborRoots.zip(neighborHeights))
        logs ++= PillarGenerator(h).generate(r, logBlock)
    }

    private def randomlyDivideInterval(parts: Int, randomness: Float, length: Int): Seq[Float] = {
      val dists = for (_ <- 1 to parts) yield 1.0f + randomness * (rand.nextFloat() * 2 - 1)
      val acc = dists.scanLeft(0.0f)(_ + _).drop(1)
      val totalDist = acc.last
      acc.map(_ / totalDist * length).dropRight(1)
    }

    def generateTreeCrown(
        center: Offset,
        size: Float,
        irregularity: Float,
        flatnessBottom: Float,
        flatnessTop: Float
    ): Unit = {
      val blobGen =
        BlobGenerator(rand, (size * 40 + 1).toInt, irregularity, flatnessBottom, flatnessTop)
      leaves ++= blobGen.generate(center, leavesBlock)
    }

    def blocks: Seq[BlockSpec] = (leaves ++ logs).toSeq
  }

}

class TallTreeGenStrategy(height: Int)(logBlock: Block, leavesBlock: Block) extends TreeGenStrategy {
  override def blocks(rand: Random): Seq[BlockSpec] = {
    val arr = ArrayBuffer.empty[BlockSpec]
    val treeTop = Offset(0, height, 0)
    arr ++= BlobGenerator(rand, 60, 0.05f, 0.7f, 0.7f).generate(treeTop, leavesBlock)
    arr ++= PillarGenerator(height - 1).generate(0, 0, 0, logBlock)
    arr.toSeq
  }
}

class ShortTreeGenStrategy(logBlock: Block, leavesBlock: Block) extends TreeGenStrategy {
  override def blocks(rand: Random): Seq[BlockSpec] =
    PlatformGenerator(1).generate(0, 6, 0, leavesBlock) ++
      PlatformGenerator(2).generate(0, 7, 0, leavesBlock) ++
      PlatformGenerator(1).generate(0, 8, 0, leavesBlock) ++
      PlatformGenerator(0).generate(0, 9, 0, leavesBlock) ++
      PillarGenerator(9).generate(0, 0, 0, logBlock)
}

1	package hexacraft.world.gen.tree
2
3	import hexacraft.world.block.Block
4	import hexacraft.world.coord.{NeighborOffsets, Offset}
5
6	import scala.collection.mutable.ArrayBuffer
7	import scala.util.Random
8
9	trait TreeGenStrategy {
10	protected final type BlockSpec = (Offset, Block)
11
12	def blocks(rand: Random): Seq[BlockSpec]
13	}
14
15	class HugeTreeGenStrategy(logBlock: Block, leavesBlock: Block) extends TreeGenStrategy {	1✔
16	override def blocks(rand: Random): Seq[(Offset, Block)] = {	1✔
17	val builder = new Builder(rand)
18		1✔
19	builder.generateStem(Offset(0, 0, 0), 7, 3, 40)	1✔
20	builder.generateTreeCrown(Offset(0, 40, 0), 60, 0.7f, 0.5f, 0.5f)
21		1✔
22	builder.blocks
23	}
24
25	private class Builder(rand: Random) {	1✔
26	val logs: ArrayBuffer[BlockSpec] = ArrayBuffer.empty	1✔
27	val leaves: ArrayBuffer[BlockSpec] = ArrayBuffer.empty
28		1✔
29	def generateStem(
30	start: Offset,
31	crossSectionBottom: Int,
32	crossSectionTop: Int,
33	length: Int
34	): Unit = {	1✔
35	require(crossSectionBottom <= 7, "Trees with cross section greater than 7 are not supported")	1✔
36	require(
37	crossSectionBottom >= crossSectionTop,
38	"Trees with a wider top than bottom are not supported"
39	)
40		1✔
UNCOV 41	val firstNeighborIndex = rand.nextInt(6)	×
42	val neighbors = NeighborOffsets.all.filter(_.dy == 0).map(start + _)
43	val reorderedNeighbors =	1✔
44	rand.shuffle(neighbors.drop(firstNeighborIndex) ++ neighbors.take(firstNeighborIndex))	1✔
45	val neighborRoots = reorderedNeighbors.slice(crossSectionTop - 1, crossSectionBottom - 1)
46	val neighborHeights =	1✔
47	randomlyDivideInterval(crossSectionBottom - crossSectionTop + 1, 0.1f, length).map(_.round)
48		1✔
49	logs ++= PillarGenerator(length).generate(start, logBlock)	×
50	for (i <- 0 until crossSectionTop - 1)	1✔
51	logs ++= PillarGenerator(length).generate(reorderedNeighbors(i), logBlock)
52		×
53	for ((r, h) <- neighborRoots.zip(neighborHeights))	1✔
54	logs ++= PillarGenerator(h).generate(r, logBlock)
55	}
56		1✔
57	private def randomlyDivideInterval(parts: Int, randomness: Float, length: Int): Seq[Float] = {	×
58	val dists = for (_ <- 1 to parts) yield 1.0f + randomness * (rand.nextFloat() * 2 - 1)	1✔
59	val acc = dists.scanLeft(0.0f)(_ + _).drop(1)	1✔
60	val totalDist = acc.last	1✔
61	acc.map(_ / totalDist * length).dropRight(1)
62	}
63		1✔
64	def generateTreeCrown(
65	center: Offset,
66	size: Float,
67	irregularity: Float,
68	flatnessBottom: Float,
69	flatnessTop: Float
70	): Unit = {
71	val blobGen =
72	BlobGenerator(rand, (size * 40 + 1).toInt, irregularity, flatnessBottom, flatnessTop)	1✔
73	leaves ++= blobGen.generate(center, leavesBlock)
74	}
75		1✔
76	def blocks: Seq[BlockSpec] = (leaves ++ logs).toSeq
77	}
78
79	}
80
81	class TallTreeGenStrategy(height: Int)(logBlock: Block, leavesBlock: Block) extends TreeGenStrategy {	1✔
82	override def blocks(rand: Random): Seq[BlockSpec] = {	1✔
83	val arr = ArrayBuffer.empty[BlockSpec]
84	val treeTop = Offset(0, height, 0)	1✔
85	arr ++= BlobGenerator(rand, 60, 0.05f, 0.7f, 0.7f).generate(treeTop, leavesBlock)	1✔
86	arr ++= PillarGenerator(height - 1).generate(0, 0, 0, logBlock)	1✔
87	arr.toSeq
88	}
89	}
90
91	class ShortTreeGenStrategy(logBlock: Block, leavesBlock: Block) extends TreeGenStrategy {	1✔
92	override def blocks(rand: Random): Seq[BlockSpec] =	×
93	PlatformGenerator(1).generate(0, 6, 0, leavesBlock) ++	×
94	PlatformGenerator(2).generate(0, 7, 0, leavesBlock) ++	×
95	PlatformGenerator(1).generate(0, 8, 0, leavesBlock) ++	×
96	PlatformGenerator(0).generate(0, 9, 0, leavesBlock) ++	1✔
97	PillarGenerator(9).generate(0, 0, 0, logBlock)
98	}

Martomate / Hexacraft / 7351367576

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous