curioustorvald/Terrarum
1
0
Fork 0
mirror of https://github.com/curioustorvald/Terrarum.git synced 2026-03-10 22:01:52 +09:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'newworldgen'

Browse Source 
# Conflicts:
#	.idea/workspace.xml
#	src/net/torvald/terrarum/gameactors/Actor.kt


Former-commit-id: 533aeed3cd26565478a3b8c602c9e9aa7e15b43f
Former-commit-id: e7e851ed9734b47cc05144df1c6187ea50f7ecab
This commit is contained in:
Song Minjae
2017-01-31 01:05:38 +09:00
parent 361f322d78 abad2eb1a6
commit 2f7eaea6b8
15 changed files with 512 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/net/torvald/terrarum/StateInGame.kt
View File

@@ -194,7 +194,7 @@ constructor() : BasicGameState() {
///////////////////////////
TilePropUtil.dynamicLumFuncTickClock()
world.updateWorldTime(delta)
WorldSimulator(player, delta)
//WorldSimulator(player, delta)
WeatherMixer.update(gc, delta)
TileStats.update()
if (!(CommandDict["setgl"] as SetGlobalLightOverride).lightOverride)
@@ -300,8 +300,8 @@ constructor() : BasicGameState() {
private fun setAppTitle() {
Terrarum.appgc.setTitle(
Terrarum.NAME +
" — F: ${Terrarum.appgc.fps} (${Terrarum.TARGET_INTERNAL_FPS})" +
" — M: ${Terrarum.memInUse}M / ${Terrarum.memTotal}M / ${Terrarum.memXmx}M")
" — F: ${Terrarum.appgc.fps} (${Terrarum.TARGET_INTERNAL_FPS})")
//" — M: ${Terrarum.memInUse}M / ${Terrarum.memTotal}M / ${Terrarum.memXmx}M")
}
override fun render(gc: GameContainer, sbg: StateBasedGame, gwin: Graphics) {
@@ -405,12 +405,12 @@ constructor() : BasicGameState() {
// velocity
worldG.color = GameFontBase.codeToCol["g"]
worldG.drawString(
"${0x7F.toChar()}X ${actor.velocity.x}", // doesn't work for NPCs/Player
"${0x7F.toChar()}X ${actor.moveDelta.x}",
actor.hitbox.posX.toFloat(),
actor.hitbox.pointedY.toFloat() + 4 + 8
)
worldG.drawString(
"${0x7F.toChar()}Y ${actor.velocity.y}",
"${0x7F.toChar()}Y ${actor.moveDelta.y}",
actor.hitbox.posX.toFloat(),
actor.hitbox.pointedY.toFloat() + 4 + 8 * 2
)

281
src/net/torvald/terrarum/StateNoiseTester.kt Normal file
View File

@@ -0,0 +1,281 @@
package net.torvald.terrarum
import com.sudoplay.joise.Joise
import com.sudoplay.joise.module.*
import net.torvald.random.HQRNG
import net.torvald.terrarum.concurrent.ThreadParallel
import net.torvald.terrarum.gameactors.roundInt
import org.newdawn.slick.Color
import org.newdawn.slick.GameContainer
import org.newdawn.slick.Graphics
import org.newdawn.slick.ImageBuffer
import org.newdawn.slick.state.BasicGameState
import org.newdawn.slick.state.StateBasedGame
import java.util.*
/**
* WARNING! HAS SERIOUS MEMORY LEAK
*
* Created by SKYHi14 on 2017-01-30.
*/
class StateNoiseTester : BasicGameState() {
companion object {
val imagesize = 512
val sampleDensity = 1.0
val noiseImageBuffer = ImageBuffer(imagesize, imagesize)
var generating = false
}
override fun init(p0: GameContainer?, p1: StateBasedGame?) {
generateNoiseImage()
}
private fun noise(seed: Long): Joise {
/* Init */
val joiseSeed = seed
val lowlandMagic: Long = 0x44A21A114DBE56 // maria lindberg
val highlandMagic: Long = 0x0114E091 // olive oyl
val mountainMagic: Long = 0x115AA4DE2504 // lisa anderson
val selectionMagic: Long = 0x44E10D9B100 // melody blue
val ground_gradient = ModuleGradient()
ground_gradient.setGradient(0.0, 0.0, 0.0, 1.0)
/* Lowlands */
val lowland_shape_fractal = ModuleFractal()
lowland_shape_fractal.setType(ModuleFractal.FractalType.FBM)
lowland_shape_fractal.setAllSourceBasisTypes(ModuleBasisFunction.BasisType.GRADIENT)
lowland_shape_fractal.setAllSourceInterpolationTypes(ModuleBasisFunction.InterpolationType.QUINTIC)
lowland_shape_fractal.setNumOctaves(2)
lowland_shape_fractal.setFrequency(1.0)
lowland_shape_fractal.seed = joiseSeed xor lowlandMagic
val lowland_autocorrect = ModuleAutoCorrect()
lowland_autocorrect.setSource(lowland_shape_fractal)
lowland_autocorrect.setLow(0.0)
lowland_autocorrect.setHigh(1.0)
val lowland_scale = ModuleScaleOffset()
lowland_scale.setSource(lowland_autocorrect)
lowland_scale.setScale(0.2)
lowland_scale.setOffset(-0.25)
val lowland_y_scale = ModuleScaleDomain()
lowland_y_scale.setSource(lowland_scale)
lowland_y_scale.setScaleY(0.0)
val lowland_terrain = ModuleTranslateDomain()
lowland_terrain.setSource(ground_gradient)
lowland_terrain.setAxisYSource(lowland_y_scale)
/* highlands */
val highland_shape_fractal = ModuleFractal()
highland_shape_fractal.setType(ModuleFractal.FractalType.RIDGEMULTI)
highland_shape_fractal.setAllSourceBasisTypes(ModuleBasisFunction.BasisType.GRADIENT)
highland_shape_fractal.setAllSourceInterpolationTypes(ModuleBasisFunction.InterpolationType.QUINTIC)
highland_shape_fractal.setNumOctaves(2)
highland_shape_fractal.setFrequency(2.0)
highland_shape_fractal.seed = joiseSeed xor highlandMagic
val highland_autocorrect = ModuleAutoCorrect()
highland_autocorrect.setSource(highland_shape_fractal)
highland_autocorrect.setLow(0.0)
highland_autocorrect.setHigh(1.0)
val highland_scale = ModuleScaleOffset()
highland_scale.setSource(highland_autocorrect)
highland_scale.setScale(0.45)
highland_scale.setOffset(0.0)
val highland_y_scale = ModuleScaleDomain()
highland_y_scale.setSource(highland_scale)
highland_y_scale.setScaleY(0.0)
val highland_terrain = ModuleTranslateDomain()
highland_terrain.setSource(ground_gradient)
highland_terrain.setAxisYSource(highland_y_scale)
/* mountains */
val mountain_shape_fractal = ModuleFractal()
mountain_shape_fractal.setType(ModuleFractal.FractalType.BILLOW)
mountain_shape_fractal.setAllSourceBasisTypes(ModuleBasisFunction.BasisType.GRADIENT)
mountain_shape_fractal.setAllSourceInterpolationTypes(ModuleBasisFunction.InterpolationType.QUINTIC)
mountain_shape_fractal.setNumOctaves(4)
mountain_shape_fractal.setFrequency(1.0)
mountain_shape_fractal.seed = joiseSeed xor mountainMagic
val mountain_autocorrect = ModuleAutoCorrect()
mountain_autocorrect.setSource(mountain_shape_fractal)
mountain_autocorrect.setLow(0.0)
mountain_autocorrect.setHigh(1.0)
val mountain_scale = ModuleScaleOffset()
mountain_scale.setSource(mountain_autocorrect)
mountain_scale.setScale(0.75)
mountain_scale.setOffset(0.25)
val mountain_y_scale = ModuleScaleDomain()
mountain_y_scale.setSource(mountain_scale)
mountain_y_scale.setScaleY(0.1) // controls "quirkiness" of the mountain
val mountain_terrain = ModuleTranslateDomain()
mountain_terrain.setSource(ground_gradient)
mountain_terrain.setAxisYSource(mountain_y_scale)
/* selection */
val terrain_type_fractal = ModuleFractal()
terrain_type_fractal.setType(ModuleFractal.FractalType.FBM)
terrain_type_fractal.setAllSourceBasisTypes(ModuleBasisFunction.BasisType.GRADIENT)
terrain_type_fractal.setAllSourceInterpolationTypes(ModuleBasisFunction.InterpolationType.QUINTIC)
terrain_type_fractal.setNumOctaves(3)
terrain_type_fractal.setFrequency(0.5)
terrain_type_fractal.seed = joiseSeed xor selectionMagic
val terrain_autocorrect = ModuleAutoCorrect()
terrain_autocorrect.setSource(terrain_type_fractal)
terrain_autocorrect.setLow(0.0)
terrain_autocorrect.setHigh(1.0)
val terrain_type_cache = ModuleCache()
terrain_type_cache.setSource(terrain_autocorrect)
val highland_mountain_select = ModuleSelect()
highland_mountain_select.setLowSource(highland_terrain)
highland_mountain_select.setHighSource(mountain_terrain)
highland_mountain_select.setControlSource(terrain_type_cache)
highland_mountain_select.setThreshold(0.55)
highland_mountain_select.setFalloff(0.15)
val highland_lowland_select = ModuleSelect()
highland_lowland_select.setLowSource(lowland_terrain)
highland_lowland_select.setHighSource(highland_mountain_select)
highland_lowland_select.setControlSource(terrain_type_cache)
highland_lowland_select.setThreshold(0.25)
highland_lowland_select.setFalloff(0.15)
val ground_select = ModuleSelect()
ground_select.setLowSource(0.0)
ground_select.setHighSource(1.0)
ground_select.setThreshold(0.5)
ground_select.setControlSource(highland_lowland_select)
val joise = Joise(ground_select)
return joise
}
fun generateNoiseImage() {
val noiseModule = noise(HQRNG().nextLong()) // change noise function here
for (y in 0..imagesize - 1) {
for (x in 0..imagesize - 1) {
noiseImageBuffer.setRGBA(x, y, 0, 0, 0, 255)
}
}
for (i in 0..Terrarum.THREADS - 1) {
ThreadParallel.map(
i,
ThreadRunNoiseSampling(
imagesize.toFloat().div(Terrarum.THREADS).times(i).roundInt(),
imagesize.toFloat().div(Terrarum.THREADS).times(i.plus(1)).roundInt() - 1,
noiseModule
),
"SampleJoiseMap"
)
}
ThreadParallel.startAll()
}
override fun update(gc: GameContainer, sbg: StateBasedGame, delta: Int) {
Terrarum.appgc.setTitle("${Terrarum.NAME} — F: ${Terrarum.appgc.fps}"
+ " — M: ${Terrarum.memInUse}M / ${Terrarum.totalVMMem}M")
if (ThreadParallel.allFinished()) generating = false
}
override fun getID() = Terrarum.STATE_ID_TOOL_NOISEGEN
override fun render(gc: GameContainer, sbg: StateBasedGame, g: Graphics) {
g.color = Color.red
g.drawString("Press SPACE to generate new noise", 8f, 8f)
g.drawString("CPUs: ${Terrarum.THREADS}", Terrarum.WIDTH - 90f, 8f)
g.background = Color.cyan
g.drawImage(noiseImageBuffer.image,//noiseImage,
Terrarum.WIDTH.minus(imagesize).div(2).toFloat(),
Terrarum.HEIGHT.minus(imagesize).div(2).toFloat()
)
}
override fun keyPressed(key: Int, c: Char) {
if (c == ' ' && !generating) {
println("Generating noise, may take a while")
generating = true
generateNoiseImage()
}
}
class ThreadRunNoiseSampling(val startIndex: Int, val endIndex: Int, val joise: Joise) : Runnable {
/*override fun run() {
for (sy in startIndex..endIndex) {
for (sx in 0..imagesize - 1) {
val y = sy.toDouble() / imagesize
val x = sx.toDouble() / imagesize
val sampleOffset = sampleDensity
// 4-D toroidal sampling (looped H and V)
val sampleTheta1 = x * Math.PI * 2.0
val sampleTheta2 = y * Math.PI * 2.0
val sampleX = Math.sin(sampleTheta1) * sampleDensity + sampleDensity
val sampleY = Math.cos(sampleTheta1) * sampleDensity + sampleDensity
val sampleZ = Math.sin(sampleTheta2) * sampleDensity + sampleDensity
val sampleW = Math.cos(sampleTheta2) * sampleDensity + sampleDensity
val noise = joise.get(
sampleX, sampleY, sampleZ, sampleW
) // autocorrection REQUIRED!
val noiseCol = noise.times(255f).toInt()
noiseImageBuffer.setRGBA(sx, sy, noiseCol, noiseCol, noiseCol, 255)
}
}
}*/
override fun run() {
for (sy in startIndex..endIndex) {
for (sx in 0..imagesize - 1) {
val y = sy.toDouble() / imagesize * 1.5 -.6
val x = sx.toDouble() / imagesize
val sampleOffset = sampleDensity
// 4-D toroidal sampling (looped H and V)
val sampleTheta1 = x * Math.PI * 2.0
val sampleX = Math.sin(sampleTheta1) * sampleDensity + sampleDensity
val sampleZ = Math.cos(sampleTheta1) * sampleDensity + sampleDensity
val sampleY = y
val noise = joise.get(
sampleX, sampleY, sampleZ
) // autocorrection REQUIRED!
val noiseCol = noise.times(255f).toInt()
noiseImageBuffer.setRGBA(sx, sy, noiseCol, noiseCol, noiseCol, 255)
}
}
}
}
}

1
src/net/torvald/terrarum/Terrarum.kt
View File

@@ -133,6 +133,7 @@ constructor(gamename: String) : StateBasedGame(gamename) {
//addState(StateNoiseTexGen())
//addState(StateBlurTest())
//addState(StateShaderTest())
//addState(StateNoiseTester())
ingame = StateInGame()
addState(ingame)

17
src/net/torvald/terrarum/console/Authenticator.kt
View File

@@ -5,6 +5,23 @@ import net.torvald.terrarum.ui.ConsoleWindow
import org.apache.commons.codec.digest.DigestUtils
/**
*
* Password setting rules:
*
* For each releases new password should be set. The new password must:
* - start with next alphabet of previous password
* if previous password started with Z, the new password must start with A
* - be a name appear in the Legend of Zelda series which officially released by Nintendo
* - be lowercase
* - BE CRACKABLE (crackstation.net)
*
* Example passwords would be:
* aryll -> biggoron -> ciela -> ... -> linebeck -> midna -> navi -> ...
*
* Notes:
* do NOT put plaintext anywhere in the code (except for comments maybe)
* must use SHA-256
*
* Created by minjaesong on 16-02-19.
*/
internal object Authenticator : ConsoleCommand {

4
src/net/torvald/terrarum/gameactors/Actor.kt
View File

@@ -39,7 +39,7 @@ abstract class Actor(val renderOrder: ActorOrder) : Comparable<Actor>, Runnable
* override var referenceID: Int = generateUniqueReferenceID()
*/
fun generateUniqueReferenceID(): Int {
fun itIsNotValid(value: Int) =
fun checkForCollision(value: Int) =
Terrarum.ingame.theGameHasActor(value) ||
value < ItemCodex.ITEM_COUNT_MAX ||
value < when (renderOrder) {
@@ -58,7 +58,7 @@ abstract class Actor(val renderOrder: ActorOrder) : Comparable<Actor>, Runnable
var ret: Int
do {
ret = HQRNG().nextInt().and(0x7FFFFFFF) // set new ID
} while (itIsNotValid(ret)) // check for collision
} while (checkForCollision(ret)) // check for collision
return ret
}

122
src/net/torvald/terrarum/gameactors/ActorWithSprite.kt
View File

@@ -65,39 +65,31 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
)
/**
* Elevators/Movingwalks/etc.: edit hitbox manually!
*
* Velocity vector for newtonian sim.
* Acceleration: used in code like:
* veloY += 3.0
* +3.0 is acceleration. You __accumulate__ acceleration to the velocity.
*/
internal val velocity = Vector2(0.0, 0.0)
var veloX: Double
get() = velocity.x
protected set(value) {
velocity.x = value
}
var veloY: Double
get() = velocity.y
protected set(value) {
velocity.y = value
}
internal val externalForce = Vector2(0.0, 0.0)
val moveDelta = Vector2(0.0, 0.0)
val moveDelta = Vector2(0.0, 0.0) // moveDelta = velocity + controllerMoveDelta
@Transient private val VELO_HARD_LIMIT = 100.0
/**
* for "Controllable" actors
*/
var controllerVel: Vector2? = if (this is Controllable) Vector2() else null
var controllerMoveDelta: Vector2? = if (this is Controllable) Vector2() else null
var walkX: Double
get() = controllerVel!!.x
get() = controllerMoveDelta!!.x
protected set(value) {
controllerVel!!.x = value
controllerMoveDelta!!.x = value
}
var walkY: Double
get() = controllerVel!!.y
get() = controllerMoveDelta!!.y
protected set(value) {
controllerVel!!.y = value
controllerMoveDelta!!.y = value
}
/**
@@ -155,8 +147,6 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
}
get() = 1.0 - elasticity
@Transient private val CEILING_HIT_ELASTICITY = 0.3
var density = 1000.0
set(value) {
if (value < 0)
@@ -342,7 +332,7 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
* @param acc : Acceleration in Vector2
*/
fun applyForce(acc: Vector2) {
velocity += acc.times(speedMultByTile)
externalForce += acc * speedMultByTile
}
private val bounceDampenVelThreshold = 0.5
@@ -375,8 +365,8 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
}
// hard limit velocity
veloX = veloX.bipolarClamp(VELO_HARD_LIMIT)
veloY = veloY.bipolarClamp(VELO_HARD_LIMIT)
externalForce.x = externalForce.x.bipolarClamp(VELO_HARD_LIMIT)
externalForce.y = externalForce.y.bipolarClamp(VELO_HARD_LIMIT)
// Set 'next' position (hitbox) from canonical and walking velocity
setNewNextHitbox()
@@ -391,8 +381,12 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
applyNormalForce()
}
setHorizontalFriction()
if (immobileBody || isPlayerNoClip) { // TODO also hanging on the rope, etc.
if (!immobileBody) { // TODO test no friction on immobileBody
setHorizontalFriction()
}
//if (immobileBody || isPlayerNoClip) { // TODO also hanging on the rope, etc.
// TODO test no friction on immobileBody
if (isPlayerNoClip) { // TODO also hanging on the rope, etc.
setVerticalFriction()
}
@@ -429,28 +423,28 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
if (!(isCollidingSide(hitbox, COLLIDING_LEFT) && walkX < 0)
|| !(isCollidingSide(hitbox, COLLIDING_RIGHT) && walkX > 0)
) {
moveDelta.x = veloX + walkX
moveDelta.x = externalForce.x + walkX
}
// decide whether to ignore walkY
if (!(isCollidingSide(hitbox, COLLIDING_TOP) && walkY < 0)
|| !(isCollidingSide(hitbox, COLLIDING_BOTTOM) && walkY > 0)
) {
moveDelta.y = veloY + walkY
moveDelta.y = externalForce.y + walkY
}
}
else {
if (!isCollidingSide(hitbox, COLLIDING_LEFT)
|| !isCollidingSide(hitbox, COLLIDING_RIGHT)
) {
moveDelta.x = veloX
moveDelta.x = externalForce.x
}
// decide whether to ignore walkY
if (!isCollidingSide(hitbox, COLLIDING_TOP)
|| !isCollidingSide(hitbox, COLLIDING_BOTTOM)
) {
moveDelta.y = veloY
moveDelta.y = externalForce.y
}
}
}
@@ -466,18 +460,18 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
* weight; gravitational force in action
* W = mass * G (9.8 [m/s^2])
*/
val W: Vector2 = gravitation * mass
val W: Vector2 = gravitation * Terrarum.TARGET_FPS.toDouble()
/**
* Area
*/
val A: Double = scale * scale
val A: Double = (scale * baseHitboxW / METER) * (scale * baseHitboxW / METER)
/**
* Drag of atmosphere
* D = Cd (drag coefficient) * 0.5 * rho (density) * V^2 (velocity sqr) * A (area)
*/
val D: Vector2 = Vector2(veloX.magnSqr(), veloY.magnSqr()) * dragCoefficient * 0.5 * A// * tileDensityFluid.toDouble()
val D: Vector2 = Vector2(moveDelta.x.magnSqr(), moveDelta.y.magnSqr()) * dragCoefficient * 0.5 * A// * tileDensityFluid.toDouble()
val V: Vector2 = (W - D) / mass * SI_TO_GAME_ACC
val V: Vector2 = (W - D) / Terrarum.TARGET_FPS.toDouble() * SI_TO_GAME_ACC
applyForce(V)
}
@@ -488,7 +482,7 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
// axis Y. Using operand >= and hitting the ceiling will lock the player to the position
if (moveDelta.y > 0.0) { // was moving downward?
if (isColliding(nextHitbox, COLLIDING_TOP)) { // hit the ceiling
hitAndForciblyReflectY()
hitAndReflectY() //hitAndForciblyReflectY()
grounded = false
}
else if (isColliding(nextHitbox)) {
@@ -512,9 +506,12 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
}
}
// axis X
if (isTouchingSide(nextHitbox, COLLIDING_LEFT) || isTouchingSide(nextHitbox, COLLIDING_RIGHT)
&& moveDelta.x != 0.0) { // check right and left
if (isTouchingSide(nextHitbox, COLLIDING_LEFT) || isTouchingSide(nextHitbox, COLLIDING_RIGHT)) { // check right and left
// the actor is hitting the wall
// FIXME balls are stuck in this
if (referenceID != 321321321)
println("$this trying to reflectX")
hitAndReflectX()
}
}
@@ -534,7 +531,7 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
val ccdDelta = (nextHitbox.toVector() - hitbox.toVector())
if (ccdDelta.x != 0.0 || ccdDelta.y != 0.0) {
//ccdDelta.set(ccdDelta.setMagnitude(CCD_TICK)) // fixed tick
val displacement = Math.min(1.0.div(velocity.magnitude * 2), 0.5) // adaptive tick
val displacement = Math.min(1.0.div(moveDelta.magnitude * 2), 0.5) // adaptive tick
ccdDelta.set(ccdDelta.setMagnitude(displacement))
}
@@ -551,35 +548,44 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
}
private fun hitAndReflectX() {
if ((veloX * elasticity).abs() > Epsilon.E) {
veloX *= -elasticity
if ((externalForce.x * elasticity).abs() >= MINIMUM_BOUNCE_THRESHOLD) { // > Epsilon.E) {
externalForce.x *= -elasticity
if (this is Controllable) walkX *= -elasticity
}
else {
veloX = 0.0
externalForce.x = 0.0
if (this is Controllable) walkX = 0.0
}
}
private fun hitAndReflectY() {
if ((veloY * elasticity).abs() > Epsilon.E) {
veloY *= -elasticity
if (externalForce.y.abs() >= MINIMUM_BOUNCE_THRESHOLD) { //> Epsilon.E) {
externalForce.y *= -elasticity
if (this is Controllable) walkY *= -elasticity
}
else {
veloY = 0.0
externalForce.y = 0.0
if (this is Controllable) walkY *= 0.0
}
}
@Transient private val CEILING_HIT_ELASTICITY = 0.3
@Transient private val MINIMUM_BOUNCE_THRESHOLD = 0.1
/**
* prevents sticking to the ceiling
*/
private fun hitAndForciblyReflectY() {
if (veloY.abs() * CEILING_HIT_ELASTICITY > A_PIXEL)
veloY = -veloY * CEILING_HIT_ELASTICITY
else
veloY = veloY.sign() * -A_PIXEL
// TODO HARK! I have changed veloX/Y to moveDelta.x/y
if (moveDelta.y < 0) {
if (moveDelta.y.abs() * CEILING_HIT_ELASTICITY > A_PIXEL)
moveDelta.y = -moveDelta.y * CEILING_HIT_ELASTICITY
else
moveDelta.y = moveDelta.y.sign() * -A_PIXEL
}
else {
throw Error("Check this out bitch (moveDelta.y = ${moveDelta.y})")
}
}
private fun isColliding(hitbox: Hitbox) = isColliding(hitbox, 0)
@@ -792,13 +798,13 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
BASE_FRICTION * if (grounded) feetFriction else bodyFriction
}
if (veloX < 0) {
veloX += friction
if (veloX > 0) veloX = 0.0 // compensate overshoot
if (externalForce.x < 0) {
externalForce.x += friction
if (externalForce.x > 0) externalForce.x = 0.0 // compensate overshoot
}
else if (veloX > 0) {
veloX -= friction
if (veloX < 0) veloX = 0.0 // compensate overshoot
else if (externalForce.x > 0) {
externalForce.x -= friction
if (externalForce.x < 0) externalForce.x = 0.0 // compensate overshoot
}
if (this is Controllable) {
@@ -819,13 +825,13 @@ open class ActorWithSprite(renderOrder: ActorOrder, val immobileBody: Boolean =
else
BASE_FRICTION * bodyFriction
if (veloY < 0) {
veloY += friction
if (veloY > 0) veloX = 0.0 // compensate overshoot
if (externalForce.y < 0) {
externalForce.y += friction
if (externalForce.y > 0) externalForce.y = 0.0 // compensate overshoot
}
else if (veloY > 0) {
veloY -= friction
if (veloY < 0) veloY = 0.0 // compensate overshoot
else if (externalForce.y > 0) {
externalForce.y -= friction
if (externalForce.y < 0) externalForce.y = 0.0 // compensate overshoot
}
if (this is Controllable) {

2
src/net/torvald/terrarum/gameactors/PlayerBuilderSigrid.kt
View File

@@ -56,7 +56,7 @@ object PlayerBuilderSigrid {
p.actorValue[AVKey.INTELLIGENT] = true
//p.actorValue[AVKey.LUMINOSITY] = Color(0x434aff).to10bit()
p.actorValue[AVKey.LUMINOSITY] = Color(0x434aff).to10bit()
p.actorValue[AVKey.BASEDEFENCE] = 141

4
src/net/torvald/terrarum/gameactors/ProjectileSimple.kt
View File

@@ -53,7 +53,7 @@ open class ProjectileSimple(
posPre = Point2d(fromPoint.x, fromPoint.y)
// lightbox sized 8x8 centered to the bullet
lightBoxList.add(Hitbox(-4.0, -4.0, 8.0, 8.0))
this.velocity.set(velocity)
//this.externalForce.set(velocity)
damage = bulletDatabase[type][OFFSET_DAMAGE] as Int
displayColour = bulletDatabase[type][OFFSET_COL] as Color
@@ -63,7 +63,7 @@ open class ProjectileSimple(
setHitboxDimension(2, 2, 0, 0) // should be following sprite's properties if there IS one
velocity.set((fromPoint to toPoint).setMagnitude(speed.toDouble()))
externalForce.set((fromPoint to toPoint).setMagnitude(speed.toDouble()))

4
src/net/torvald/terrarum/gameactors/ai/AILuaAPI.kt
View File

@@ -60,8 +60,8 @@ internal class AILuaAPI(g: Globals, actor: ActorWithSprite) {
t["posX"] = actor.hitbox.centeredX.toLua()
t["posY"] = actor.hitbox.centeredY.toLua()
t["veloX"] = actor.veloX.toLua()
t["veloY"] = actor.veloY.toLua()
t["veloX"] = actor.moveDelta.x.toLua()
t["veloY"] = actor.moveDelta.y.toLua()
t["width"] = actor.hitbox.width.toLua()
t["height"] = actor.hitbox.height.toLua()

8
src/net/torvald/terrarum/gameactors/physicssolver/CollisionSolver.kt
View File

@@ -150,10 +150,10 @@ object CollisionSolver {
// if they actually makes collision (e.g. player vs ball), solve it
if (a makesCollisionWith b) {
val ux_1 = a.veloX
val ux_2 = b.veloX
val uy_1 = a.veloY
val uy_2 = b.veloY
val ux_1 = a.moveDelta.x
val ux_2 = b.moveDelta.x
val uy_1 = a.moveDelta.y
val uy_2 = b.moveDelta.y
val m1 = a.mass
val m2 = b.mass

4
src/net/torvald/terrarum/mapgenerator/ThreadProcessNoiseLayers.kt
View File

@@ -24,8 +24,8 @@ class ThreadProcessNoiseLayers(val startIndex: Int, val endIndex: Int,
val sampleTheta = (x.toDouble() / WorldGenerator.WIDTH) * WorldGenerator.TWO_PI
val sampleOffset = (WorldGenerator.WIDTH / sampleDensity) / 8.0
val sampleX = Math.sin(sampleTheta) * sampleOffset + sampleOffset // plus sampleOffset to make only
val sampleY = Math.cos(sampleTheta) * sampleOffset + sampleOffset // positive points are to be sampled
val sampleZ = y / sampleDensity
val sampleZ = Math.cos(sampleTheta) * sampleOffset + sampleOffset // positive points are to be sampled
val sampleY = y / sampleDensity
val noise: Double = record.noiseModule.get(sampleX, sampleY, sampleZ)
val fromTerr = record.replaceFromTerrain

164
src/net/torvald/terrarum/mapgenerator/WorldGenerator.kt
View File

@@ -38,9 +38,7 @@ object WorldGenerator {
private val NOISE_SIMPLEX_ORE_START = 1.42
private val NOISE_SIMPLEX_ORE_END = 1.28
private val HILL_WIDTH = 256 // power of two!
//private val MAX_HILL_HEIGHT = 100
private val TERRAIN_UNDULATION = 250
private val TERRAIN_UNDULATION = 200
private val SIMPLEXGEN_LARGEST_FEATURE = 200
@@ -51,8 +49,8 @@ object WorldGenerator {
private var GLACIER_MOUNTAIN_WIDTH = 900
private val GLACIER_MOUNTAIN_HEIGHT = 300
private val CAVEGEN_THRE_START = 0.95
private val CAVEGEN_THRE_END = 0.67
private val CAVEGEN_THRE_START = 0.4
private val CAVEGEN_THRE_END = 0.1
private var worldOceanPosition: Int = -1
@@ -109,12 +107,18 @@ object WorldGenerator {
* Todo: Lakes! Aquifers! Lava chambers!
* Todo: deserts (variants: SAND_DESERT, SAND_RED)
* Todo: volcano(es?)
* Done: variants of beach (SAND, SAND_BEACH, SAND_BLACK, SAND_GREEN)
* TODO: variants of beach (SAND, SAND_BEACH, SAND_BLACK, SAND_GREEN)
*
*
* Hark! We use cylindrical sampling
*
* x, z: X-axis sampling
* y: Y-axis sampling
*/
val noiseArray = arrayOf(
TaggedJoise("Carving caves", noiseRidged(1.7, 1.4), 1.0, TILE_MACRO_ALL, TILE_MACRO_ALL, Tile.AIR, NoiseFilterSqrt, CAVEGEN_THRE_START, CAVEGEN_THRE_END)
, TaggedJoise("Collapsing caves", noiseBlobs(0.5), 0.3, Tile.AIR, Tile.STONE, Tile.STONE, NoiseFilterUniform)
// TODO cave one featured in http://accidentalnoise.sourceforge.net/minecraftworlds.html
TaggedJoise("Carving caves", noiseCave(), 1.0, TILE_MACRO_ALL, TILE_MACRO_ALL, Tile.AIR, NoiseFilterSqrt, CAVEGEN_THRE_START, CAVEGEN_THRE_END)
// , TaggedJoise("Collapsing caves", noiseBlobs(0.5), 0.3, Tile.AIR, Tile.STONE, Tile.STONE, NoiseFilterUniform)
//
//, TaggedJoise("Putting stone patches on the ground", noiseBlobs(0.8), 1.02f, intArrayOf(Tile.DIRT, Tile.GRASS), Tile.DIRT, Tile.STONE, NoiseFilterQuadratic, NOISE_GRAD_END, NOISE_GRAD_START)
//, TaggedJoise("Placing dirt spots in the cave", noiseBlobs(0.5), 0.98f, Tile.STONE, Tile.STONE, Tile.DIRT, NoiseFilterQuadratic, NOISE_GRAD_END, NOISE_GRAD_START)
@@ -179,19 +183,69 @@ object WorldGenerator {
val ridged_scale = ModuleScaleDomain()
ridged_scale.setScaleX(xStretch.toDouble())
ridged_scale.setScaleY(yStretch.toDouble())
ridged_scale.setScaleY(xStretch.toDouble())
ridged_scale.setScaleZ(yStretch.toDouble())
ridged_scale.setSource(ridged_autocorrect)
return Joise(ridged_scale)
}
private fun noiseCave(): Joise {
val caveMagic: Long = 0x00215741CDF // Urist McDF
val cavePerturbMagic: Long = 0xA2410C // Armok
val arbitraryScale = 4.0
val cave_shape = ModuleFractal()
cave_shape.setType(ModuleFractal.FractalType.RIDGEMULTI)
cave_shape.setAllSourceBasisTypes(ModuleBasisFunction.BasisType.GRADIENT)
cave_shape.setAllSourceInterpolationTypes(ModuleBasisFunction.InterpolationType.QUINTIC)
cave_shape.setNumOctaves(1)
cave_shape.setFrequency(4.0)
cave_shape.seed = SEED xor caveMagic
val cave_select = ModuleSelect()
cave_select.setLowSource(1.0)
cave_select.setHighSource(0.0)
cave_select.setControlSource(cave_shape)
cave_select.setThreshold(0.8)
cave_select.setFalloff(0.0)
val cave_perturb_fractal = ModuleFractal()
cave_perturb_fractal.setType(ModuleFractal.FractalType.FBM)
cave_perturb_fractal.setAllSourceBasisTypes(ModuleBasisFunction.BasisType.GRADIENT)
cave_perturb_fractal.setAllSourceInterpolationTypes(ModuleBasisFunction.InterpolationType.QUINTIC)
cave_perturb_fractal.setNumOctaves(6)
cave_perturb_fractal.setFrequency(3.0)
cave_perturb_fractal.seed = SEED xor cavePerturbMagic
val cave_perturb_scale = ModuleScaleOffset()
cave_perturb_scale.setSource(cave_perturb_fractal)
cave_perturb_scale.setScale(0.5)
cave_perturb_scale.setOffset(0.0)
val cave_perturb = ModuleTranslateDomain()
cave_perturb.setSource(cave_perturb_fractal)
cave_perturb.setAxisXSource(cave_perturb_scale)
val cave_scale = ModuleScaleDomain()
cave_scale.setScaleX(1.0 / arbitraryScale)
cave_scale.setScaleZ(1.0 / arbitraryScale)
cave_scale.setScaleY(1.0 / arbitraryScale)
cave_scale.setSource(cave_perturb)
return Joise(cave_scale)
}
private fun noiseBlobs(frequency: Double): Joise {
val ridgedMagic: Long = 0x4114EC2AF7 // minecraft
val ridged = ModuleFractal()
ridged.setType(ModuleFractal.FractalType.FBM)
ridged.setAllSourceInterpolationTypes(ModuleBasisFunction.InterpolationType.QUINTIC)
ridged.setNumOctaves(2)
ridged.setFrequency(frequency)
ridged.seed = Random().nextLong()
ridged.seed = SEED xor ridgedMagic
val brownian_select = ModuleSelect()
brownian_select.setControlSource(ridged)
@@ -269,8 +323,15 @@ object WorldGenerator {
val noiseMap = Array(HEIGHT, { BitSet(WIDTH) })
// Height = Terrain undulation times 2.
val SCALE_X: Double = (TERRAIN_UNDULATION * 0.5).toDouble()
val SCALE_Y: Double = (TERRAIN_UNDULATION * 0.25).toDouble()
val SCALE_X: Double = TERRAIN_UNDULATION * 1.33
val SCALE_Y: Double = TERRAIN_UNDULATION * 1.0
/* Init */
val lowlandMagic: Long = 0x41A21A114DBE56 // Maria Lindberg
val highlandMagic: Long = 0x0114E091 // Olive Oyl
val mountainMagic: Long = 0x115AA4DE2504 // Lisa Anderson
val selectionMagic: Long = 0x41E10D9B100 // Melody Blue
val ground_gradient = ModuleGradient()
ground_gradient.setGradient(0.0, 0.0, 0.0, 1.0)
@@ -281,19 +342,19 @@ object WorldGenerator {
lowland_shape_fractal.setType(ModuleFractal.FractalType.FBM)
lowland_shape_fractal.setAllSourceBasisTypes(ModuleBasisFunction.BasisType.GRADIENT)
lowland_shape_fractal.setAllSourceInterpolationTypes(ModuleBasisFunction.InterpolationType.QUINTIC)
lowland_shape_fractal.setNumOctaves(4)
lowland_shape_fractal.setFrequency(0.6)
lowland_shape_fractal.seed = SEED xor random.nextLong()
//println(lowland_shape_fractal.seed)
lowland_shape_fractal.setNumOctaves(2)
lowland_shape_fractal.setFrequency(1.0)
lowland_shape_fractal.seed = SEED xor lowlandMagic
val lowland_autocorrect = ModuleAutoCorrect()
lowland_autocorrect.setRange(0.0, 1.0)
lowland_autocorrect.setSource(lowland_shape_fractal)
lowland_autocorrect.setLow(0.0)
lowland_autocorrect.setHigh(1.0)
val lowland_scale = ModuleScaleOffset()
lowland_scale.setSource(lowland_autocorrect)
lowland_scale.setScale(0.8)
lowland_scale.setOffset(-2.75)
lowland_scale.setScale(0.2)
lowland_scale.setOffset(-0.25)
val lowland_y_scale = ModuleScaleDomain()
lowland_y_scale.setSource(lowland_scale)
@@ -303,25 +364,26 @@ object WorldGenerator {
lowland_terrain.setSource(ground_gradient)
lowland_terrain.setAxisYSource(lowland_y_scale)
/* highlands */
val highland_shape_fractal = ModuleFractal()
highland_shape_fractal.setType(ModuleFractal.FractalType.RIDGEMULTI)
highland_shape_fractal.setAllSourceBasisTypes(ModuleBasisFunction.BasisType.GRADIENT)
highland_shape_fractal.setAllSourceInterpolationTypes(ModuleBasisFunction.InterpolationType.QUINTIC)
highland_shape_fractal.setNumOctaves(4)
highland_shape_fractal.setFrequency(0.5) // horizontal size. Higher == narrower
highland_shape_fractal.seed = SEED xor random.nextLong()
//println(highland_shape_fractal.seed)
highland_shape_fractal.setNumOctaves(2)
highland_shape_fractal.setFrequency(2.0)
highland_shape_fractal.seed = SEED xor highlandMagic
val highland_autocorrect = ModuleAutoCorrect()
highland_autocorrect.setSource(highland_shape_fractal)
highland_autocorrect.setRange(0.0, 1.0)
highland_autocorrect.setLow(0.0)
highland_autocorrect.setHigh(1.0)
val highland_scale = ModuleScaleOffset()
highland_scale.setSource(highland_autocorrect)
highland_scale.setScale(1.4) // vertical size. Higher == taller
highland_scale.setOffset(-2.25)
highland_scale.setScale(0.45)
highland_scale.setOffset(0.0)
val highland_y_scale = ModuleScaleDomain()
highland_y_scale.setSource(highland_scale)
@@ -331,55 +393,53 @@ object WorldGenerator {
highland_terrain.setSource(ground_gradient)
highland_terrain.setAxisYSource(highland_y_scale)
/* mountains */
val mountain_shape_fractal = ModuleFractal()
mountain_shape_fractal.setType(ModuleFractal.FractalType.BILLOW)
mountain_shape_fractal.setAllSourceBasisTypes(ModuleBasisFunction.BasisType.GRADIENT)
mountain_shape_fractal.setAllSourceInterpolationTypes(ModuleBasisFunction.InterpolationType.QUINTIC)
mountain_shape_fractal.setNumOctaves(6)
mountain_shape_fractal.setFrequency(0.55)
mountain_shape_fractal.seed = SEED xor random.nextLong()
//println(mountain_shape_fractal.seed)
mountain_shape_fractal.setNumOctaves(4)
mountain_shape_fractal.setFrequency(1.0)
mountain_shape_fractal.seed = SEED xor mountainMagic
val mountain_autocorrect = ModuleAutoCorrect()
mountain_autocorrect.setSource(mountain_shape_fractal)
mountain_autocorrect.setRange(0.0, 1.0)
mountain_autocorrect.setLow(0.0)
mountain_autocorrect.setHigh(1.0)
val mountain_scale = ModuleScaleOffset()
mountain_scale.setSource(mountain_autocorrect)
mountain_scale.setScale(1.66)
mountain_scale.setOffset(-1.25)
mountain_scale.setScale(0.75)
mountain_scale.setOffset(0.25)
val mountain_y_scale = ModuleScaleDomain()
mountain_y_scale.setSource(mountain_scale)
mountain_y_scale.setScaleY(0.1)
mountain_y_scale.setScaleY(0.1) // controls "quirkiness" of the mountain
val mountain_terrain = ModuleTranslateDomain()
mountain_terrain.setSource(ground_gradient)
mountain_terrain.setAxisYSource(mountain_y_scale)
/* selection */
val terrain_type_fractal = ModuleFractal()
terrain_type_fractal.setType(ModuleFractal.FractalType.MULTI)
terrain_type_fractal.setType(ModuleFractal.FractalType.FBM)
terrain_type_fractal.setAllSourceBasisTypes(ModuleBasisFunction.BasisType.GRADIENT)
terrain_type_fractal.setAllSourceInterpolationTypes(ModuleBasisFunction.InterpolationType.QUINTIC)
terrain_type_fractal.setNumOctaves(5)
terrain_type_fractal.setFrequency(0.4) // <= 0.33
terrain_type_fractal.seed = SEED xor random.nextLong()
//println(terrain_type_fractal.seed)
terrain_type_fractal.setNumOctaves(3)
terrain_type_fractal.setFrequency(0.5)
terrain_type_fractal.seed = SEED xor selectionMagic
val terrain_autocorrect = ModuleAutoCorrect()
terrain_autocorrect.setSource(terrain_type_fractal)
terrain_autocorrect.setRange(0.0, 1.0)
val terrain_type_scale = ModuleScaleDomain()
terrain_type_scale.setScaleY(0.33)
terrain_type_scale.setSource(terrain_autocorrect)
terrain_autocorrect.setLow(0.0)
terrain_autocorrect.setHigh(1.0)
val terrain_type_cache = ModuleCache()
terrain_type_cache.setSource(terrain_type_scale)
terrain_type_cache.setSource(terrain_autocorrect)
val highland_mountain_select = ModuleSelect()
highland_mountain_select.setLowSource(highland_terrain)
@@ -395,13 +455,13 @@ object WorldGenerator {
highland_lowland_select.setThreshold(0.25)
highland_lowland_select.setFalloff(0.15)
val ground_select = ModuleSelect()
ground_select.setLowSource(0.0)
ground_select.setHighSource(1.0)
ground_select.setThreshold(0.5)
ground_select.setControlSource(highland_lowland_select)
val joise = Joise(ground_select)
// fill the area as Joise map
@@ -414,17 +474,17 @@ object WorldGenerator {
x / SCALE_X,
y / SCALE_Y
) == 1.0)*/
// circular sampling
// cylindrical sampling
// Mapping function:
// World(x, y) -> Joise(sin x, y, cos x)
val sampleTheta = (x.toDouble() / WIDTH) * TWO_PI
val sampleOffset = (WIDTH / SCALE_X) / 4.0
val sampleX = Math.sin(sampleTheta) * sampleOffset + sampleOffset // plus sampleOffset to make only
val sampleZ = Math.cos(sampleTheta) * sampleOffset + sampleOffset // positive points are to be sampled
val sampleY = y / SCALE_Y
val map: Boolean = (
joise.get(sampleX, sampleY, sampleZ) == 1.0
)
val sampleY = y / SCALE_Y * 1.5 - 0.6
val map: Boolean = joise.get(sampleX, sampleY, sampleZ) == 1.0
// FIXME joise.get(sampleX, sampleY, sampleZ) returns all zero
noiseMap[y + TERRAIN_AVERAGE_HEIGHT - (TERRAIN_UNDULATION / 2)].set(x, map)
}
}