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

various patches and renaming; thai-variable font sheet

Browse Source
This commit is contained in:
minjaesong
2017-05-27 20:05:12 +09:00
parent 06cbac1cc5
commit 85ab2a2066
22 changed files with 861 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -3,5 +3,4 @@ bin/*
hs_err_pid*
Thumbs.db
.DS_Store
/.idea/workspace.xml
~$*

1
.idea/codeStyleSettings.xml generated
View File

@@ -3,7 +3,6 @@
<component name="ProjectCodeStyleSettingsManager">
<option name="PER_PROJECT_SETTINGS">
<value>
<option name="RIGHT_MARGIN" value="100" />
<JetCodeStyleSettings>
<option name="ALIGN_IN_COLUMNS_CASE_BRANCH" value="true" />
</JetCodeStyleSettings>

BIN
assets/graphics/fonts/thai_variable.tga LFS Normal file
View File

Binary file not shown.

BIN
assets/graphics/fonts/thai_wide.tga LFS
View File

Binary file not shown.

2
src/net/torvald/imagefont/GameFontImpl.kt
View File

@@ -39,7 +39,7 @@ class GameFontImpl(noShadow: Boolean = false) : GameFontBase(noShadow = noShadow
GameFontBase.greekSheet = SpriteSheet(
"./assets/graphics/fonts/greek_variable.tga", 15, 19, 1)
GameFontBase.thaiSheet = SpriteSheet(
"./assets/graphics/fonts/thai_wide.tga", GameFontBase.W_LATIN_WIDE, GameFontBase.H)
"./assets/graphics/fonts/thai_variable.tga",15, 19, 1)
GameFontBase.keycapSheet = SpriteSheet(
"./assets/graphics/fonts/puae000-e0ff.tga", GameFontBase.SIZE_KEYCAP, GameFontBase.SIZE_KEYCAP)

4
src/net/torvald/terrarum/DefaultConfig.kt
View File

@@ -14,6 +14,10 @@ object DefaultConfig {
fun fetch(): JsonObject {
val jsonObject = JsonObject()
jsonObject.addProperty("displayfps", 60)
jsonObject.addProperty("usevsync", true)
jsonObject.addProperty("smoothlighting", true)
jsonObject.addProperty("imtooyoungtodie", false) // perma-death
jsonObject.addProperty("language", Terrarum.sysLang)

3
src/net/torvald/terrarum/StateFontTester.kt
View File

@@ -86,7 +86,8 @@ nopqrstuvwxyz
"Pijamalı hasta yağız şoföre çabucak güvendi",
"Also supports: ‛Unicode’ „quotation marks“—dashes…「括弧」‼",
"ASCII Latin-1 Latin_Ext-A Latin_Ext-B Greek Cyrillic CJK-Ideo Kana Hangul_Syllables",
""
"",
"…not seeing your language/writing system? Let me know on the Issue Tracker!"
)
val SP = "${0x3000.toChar()}${0x3000.toChar()}"

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

@@ -435,8 +435,8 @@ class StateInGame : BasicGameState() {
worldG.font = Terrarum.fontSmallNumbers
worldG.drawString(
actor.referenceID.toString(),
actor.hitbox.posX.toFloat(),
actor.hitbox.pointedY.toFloat() + 4
actor.hitbox.startX.toFloat(),
actor.hitbox.canonicalY.toFloat() + 4
)
}
}
@@ -449,8 +449,8 @@ class StateInGame : BasicGameState() {
worldG.font = Terrarum.fontSmallNumbers
worldG.lineWidth = 1f
worldG.drawRect(
actor.hitbox.posX.toFloat(),
actor.hitbox.posY.toFloat(),
actor.hitbox.startX.toFloat(),
actor.hitbox.startY.toFloat(),
actor.hitbox.width.toFloat(),
actor.hitbox.height.toFloat()
)
@@ -459,13 +459,13 @@ class StateInGame : BasicGameState() {
worldG.color = GameFontBase.codeToCol["g"]
worldG.drawString(
"${0x7F.toChar()}X ${actor.externalForce.x}",
actor.hitbox.posX.toFloat(),
actor.hitbox.pointedY.toFloat() + 4 + 8
actor.hitbox.startX.toFloat(),
actor.hitbox.canonicalY.toFloat() + 4 + 8
)
worldG.drawString(
"${0x7F.toChar()}Y ${actor.externalForce.y}",
actor.hitbox.posX.toFloat(),
actor.hitbox.pointedY.toFloat() + 4 + 8 * 2
actor.hitbox.startX.toFloat(),
actor.hitbox.canonicalY.toFloat() + 4 + 8 * 2
)
}
}
@@ -501,7 +501,6 @@ class StateInGame : BasicGameState() {
backG.flush()
gwin.drawImage(backDrawFrameBuffer, 0f, 0f)
// centre marker
/*gwin.color = Color(0x00FFFF)
gwin.lineWidth = 1f
@@ -639,12 +638,12 @@ class StateInGame : BasicGameState() {
)
private fun distToCameraSqr(a: ActorWithBody) =
min(
(a.hitbox.posX - WorldCamera.x).sqr() +
(a.hitbox.posY - WorldCamera.y).sqr(),
(a.hitbox.posX - WorldCamera.x + world.width * TILE_SIZE).sqr() +
(a.hitbox.posY - WorldCamera.y).sqr(),
(a.hitbox.posX - WorldCamera.x - world.width * TILE_SIZE).sqr() +
(a.hitbox.posY - WorldCamera.y).sqr()
(a.hitbox.startX - WorldCamera.x).sqr() +
(a.hitbox.startY - WorldCamera.y).sqr(),
(a.hitbox.startX - WorldCamera.x + world.width * TILE_SIZE).sqr() +
(a.hitbox.startY - WorldCamera.y).sqr(),
(a.hitbox.startX - WorldCamera.x - world.width * TILE_SIZE).sqr() +
(a.hitbox.startY - WorldCamera.y).sqr()
)
/** whether the actor is within screen */

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

@@ -34,13 +34,17 @@ typealias Millisec = Int
*/
object Terrarum : StateBasedGame(GAME_NAME) {
//////////////////////////////
// GLOBAL IMMUTABLE CONFIGS //
//////////////////////////////
var WIDTH = 1072
var HEIGHT = 742 // IMAX ratio
var VSYNC = true
val RENDER_FPS = getConfigInt("displayfps")
val USE_VSYNC = getConfigBoolean("usevsync")
var VSYNC = USE_VSYNC
val VSYNC_TRIGGER_THRESHOLD = 56
val HALFW: Int
@@ -516,8 +520,10 @@ fun main(args: Array<String>) {
Terrarum.appgc = AppGameContainer(Terrarum)
Terrarum.appgc.setDisplayMode(Terrarum.WIDTH, Terrarum.HEIGHT, false)
Terrarum.appgc.setTargetFrameRate(Terrarum.TARGET_INTERNAL_FPS)
Terrarum.appgc.setVSync(Terrarum.VSYNC)
if (Terrarum.RENDER_FPS > 0) {
Terrarum.appgc.setTargetFrameRate(Terrarum.RENDER_FPS)
}
//Terrarum.appgc.setVSync(Terrarum.VSYNC)
Terrarum.appgc.setMaximumLogicUpdateInterval(1000 / Terrarum.TARGET_INTERNAL_FPS) // 10 ms
Terrarum.appgc.setMinimumLogicUpdateInterval(1000 / Terrarum.TARGET_INTERNAL_FPS - 1) // 9 ms

4
src/net/torvald/terrarum/debuggerapp/ActorValueTracker.kt
View File

@@ -162,8 +162,8 @@ class ActorValueTracker constructor() : JFrame() {
if (actor != null) {
sb.append("toString: ${actor!!}\n")
sb.append("X: ${actor!!.hitbox.pointedX} (${(actor!!.hitbox.pointedX / FeaturesDrawer.TILE_SIZE).toInt()})\n")
sb.append("Y: ${actor!!.hitbox.pointedY} (${(actor!!.hitbox.pointedY / FeaturesDrawer.TILE_SIZE).toInt()})")
sb.append("X: ${actor!!.hitbox.canonicalX} (${(actor!!.hitbox.canonicalX / FeaturesDrawer.TILE_SIZE).toInt()})\n")
sb.append("Y: ${actor!!.hitbox.canonicalY} (${(actor!!.hitbox.canonicalY / FeaturesDrawer.TILE_SIZE).toInt()})")
avPosArea.text = "$sb"
sb.setLength(0) // clear stringbuffer

17
src/net/torvald/terrarum/gameactors/ActorHumanoid.kt
View File

@@ -71,7 +71,8 @@ open class ActorHumanoid(birth: GameDate, death: GameDate? = null)
* (Use ArrayList for normal circumstances)
*/
override val lightBoxList: List<Hitbox>
get() = arrayOf(Hitbox(0.0, 0.0, hitbox.width, hitbox.height)).toList() // use getter; dimension of the player may change by time.
get() = arrayOf(Hitbox(2.0, 2.0, hitbox.width - 3, hitbox.height - 3)).toList() // things are asymmetric!!
// use getter; dimension of the player may change by time.
@Transient val BASE_DENSITY = 980.0
@@ -156,7 +157,7 @@ open class ActorHumanoid(birth: GameDate, death: GameDate? = null)
if (vehicleRiding is Player)
throw Error("Attempted to 'ride' player object. ($vehicleRiding)")
if (vehicleRiding != null && (vehicleRiding == this))
if (vehicleRiding != null && vehicleRiding == this)
throw Error("Attempted to 'ride' itself. ($vehicleRiding)")
@@ -167,7 +168,7 @@ open class ActorHumanoid(birth: GameDate, death: GameDate? = null)
updateSprite(delta)
if (noClip) {
grounded = true
//grounded = true
}
// reset control box of AI
@@ -370,9 +371,9 @@ open class ActorHumanoid(birth: GameDate, death: GameDate? = null)
avAcceleration * (if (left) -1f else 1f) * absAxisVal
if (absAxisVal != AXIS_KEYBOARD)
walkX = walkX.plus(readonly_totalX).bipolarClamp(avSpeedCap * absAxisVal)
controllerMoveDelta?.x?.let { controllerMoveDelta!!.x = controllerMoveDelta!!.x.plus(readonly_totalX).bipolarClamp(avSpeedCap * absAxisVal) }
else
walkX = walkX.plus(readonly_totalX).bipolarClamp(avSpeedCap)
controllerMoveDelta?.x?.let { controllerMoveDelta!!.x = controllerMoveDelta!!.x.plus(readonly_totalX).bipolarClamp(avSpeedCap) }
if (absAxisVal == AXIS_KEYBOARD) {
walkCounterX += 1
@@ -399,9 +400,9 @@ open class ActorHumanoid(birth: GameDate, death: GameDate? = null)
avAcceleration * (if (up) -1f else 1f) * absAxisVal
if (absAxisVal != AXIS_KEYBOARD)
walkY = walkY.plus(readonly_totalY).bipolarClamp(avSpeedCap * absAxisVal)
controllerMoveDelta?.y?.let { controllerMoveDelta!!.y = controllerMoveDelta!!.y.plus(readonly_totalX).bipolarClamp(avSpeedCap * absAxisVal) }
else
walkY = walkY.plus(readonly_totalY).bipolarClamp(avSpeedCap)
controllerMoveDelta?.y?.let { controllerMoveDelta!!.y = controllerMoveDelta!!.y.plus(readonly_totalX).bipolarClamp(avSpeedCap) }
if (absAxisVal == AXIS_KEYBOARD) {
walkCounterY += 1
@@ -459,7 +460,7 @@ open class ActorHumanoid(birth: GameDate, death: GameDate? = null)
jumpAcc = pwr * timedJumpCharge * JUMP_ACCELERATION_MOD * Math.sqrt(scale) // positive value
walkY -= jumpAcc // feed negative value to the vector
controllerMoveDelta?.y?.let { controllerMoveDelta!!.y -= jumpAcc } // feed negative value to the vector
// do not think of resetting this to zero when counter hit the ceiling; that's HOW NOT
// newtonian physics work, stupid myself :(

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

@@ -44,8 +44,8 @@ open class ParticleBase(renderOrder: Actor.RenderOrder, maxLifeTime: Int? = null
if (velocity.isZero || lifetimeCounter >= lifetimeMax ||
// simple stuck check
BlockCodex[Terrarum.ingame!!.world.getTileFromTerrain(
hitbox.pointedX.div(TILE_SIZE).floorInt(),
hitbox.pointedY.div(TILE_SIZE).floorInt()
hitbox.canonicalX.div(TILE_SIZE).floorInt(),
hitbox.canonicalY.div(TILE_SIZE).floorInt()
) ?: Block.STONE].isSolid) {
flagDespawn = true
}

12
src/net/torvald/terrarum/gameactors/PhysTestBall.kt
View File

@@ -24,20 +24,20 @@ class PhysTestBall : ActorWithPhysics(Actor.RenderOrder.MIDDLE, immobileBody = t
override fun drawBody(g: Graphics) {
g.color = color
g.fillOval(
hitbox.posX.toFloat(),
hitbox.posY.toFloat(),
hitbox.startX.toFloat() - 1f,
hitbox.startY.toFloat() - 1f,
hitbox.width.toFloat(),
hitbox.height.toFloat())
g.fillOval(
hitbox.posX.toFloat() + Terrarum.ingame!!.world.width * TILE_SIZE,
hitbox.posY.toFloat(),
hitbox.startX.toFloat() + Terrarum.ingame!!.world.width * TILE_SIZE - 1f,
hitbox.startY.toFloat() - 1f,
hitbox.width.toFloat(),
hitbox.height.toFloat())
g.fillOval(
hitbox.posX.toFloat() - Terrarum.ingame!!.world.width * TILE_SIZE,
hitbox.posY.toFloat(),
hitbox.startX.toFloat() - Terrarum.ingame!!.world.width * TILE_SIZE - 1f,
hitbox.startY.toFloat() - 1f,
hitbox.width.toFloat(),
hitbox.height.toFloat())

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

@@ -49,8 +49,8 @@ object PlayerBuilderSigrid {
p.actorValue[AVKey.INTELLIGENT] = true
p.actorValue[AVKey.LUMINOSITY] = Color(0x434aff).to10bit()
//p.actorValue[AVKey.LUMINOSITY] = 214127943 // bright purple
//p.actorValue[AVKey.LUMINOSITY] = Color(0x434aff).to10bit()
p.actorValue[AVKey.LUMINOSITY] = 214127943 // bright purple
p.actorValue[AVKey.BASEDEFENCE] = 141

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

@@ -58,8 +58,8 @@ internal class AILuaAPI(g: Globals, actor: ActorWithPhysics) {
val moveDelta = actor.externalForce + actor.controllerMoveDelta
t["name"] = actor.actorValue.getAsString(AVKey.NAME).toLua()
t["posX"] = actor.hitbox.centeredX.toLua()
t["posY"] = actor.hitbox.centeredY.toLua()
t["startX"] = actor.hitbox.centeredX.toLua()
t["startY"] = actor.hitbox.centeredY.toLua()
t["veloX"] = moveDelta.x.toLua()
t["veloY"] = moveDelta.y.toLua()

73
src/net/torvald/terrarum/ui/BasicDebugInfoWindow.kt
View File

@@ -2,13 +2,11 @@ package net.torvald.terrarum.ui
import com.jme3.math.FastMath
import net.torvald.imagefont.GameFontBase
import net.torvald.terrarum.gameworld.PairedMapLayer
import net.torvald.terrarum.worlddrawer.LightmapRenderer
import net.torvald.terrarum.worlddrawer.FeaturesDrawer
import net.torvald.terrarum.Terrarum
import net.torvald.terrarum.blendNormal
import net.torvald.terrarum.blendScreen
import net.torvald.terrarum.gameactors.ActorWithPhysics
import net.torvald.terrarum.worlddrawer.WorldCamera
import org.newdawn.slick.Color
import org.newdawn.slick.GameContainer
@@ -47,11 +45,11 @@ class BasicDebugInfoWindow : UICanvas {
val player = Terrarum.ingame!!.player!!
val hitbox = player.hitbox
xdelta = hitbox.pointedX - prevPlayerX
ydelta = hitbox.pointedY - prevPlayerY
xdelta = hitbox.canonicalX - prevPlayerX
ydelta = hitbox.canonicalY - prevPlayerY
prevPlayerX = hitbox.pointedX
prevPlayerY = hitbox.pointedY
prevPlayerX = hitbox.canonicalX
prevPlayerY = hitbox.canonicalY
}
override fun render(gc: GameContainer, g: Graphics) {
@@ -73,34 +71,46 @@ class BasicDebugInfoWindow : UICanvas {
* First column
*/
printLine(g, 1, "pointedX "
+ ccG
+ "${hitbox?.pointedX}"
+ " ("
+ "${(hitbox?.pointedX?.div(FeaturesDrawer.TILE_SIZE))?.toInt()}"
+ ")")
printLine(g, 2, "endY "
+ ccG
+ hitbox?.endPointY.toString()
+ " ("
+ (hitbox?.endPointY?.div(FeaturesDrawer.TILE_SIZE))?.toInt().toString()
+ ")")
printLineColumn(g, 1, 1, "startX "
+ ccG
+ "${hitbox?.startX}"
+ " ("
+ "${(hitbox?.startX?.div(FeaturesDrawer.TILE_SIZE))?.toInt()}"
+ ")")
printLineColumn(g, 2, 1, "endX "
+ ccG
+ "${hitbox?.endX}"
+ " ("
+ "${(hitbox?.endX?.div(FeaturesDrawer.TILE_SIZE))?.toInt()}"
+ ")")
printLineColumn(g, 1, 2, "startY "
+ ccG
+ "${hitbox?.startY}"
+ " ("
+ "${(hitbox?.startY?.div(FeaturesDrawer.TILE_SIZE))?.toInt()}"
+ ")")
printLineColumn(g, 2, 2, "endY "
+ ccG
+ "${hitbox?.endY}"
+ " ("
+ "${(hitbox?.endY?.div(FeaturesDrawer.TILE_SIZE))?.toInt()}"
+ ")")
printLine(g, 3, "veloX reported $ccG${player?.externalForce?.x} ${player?.controllerMoveDelta?.x}")
printLine(g, 4, "veloY reported $ccG${player?.externalForce?.y} ${player?.controllerMoveDelta?.y}")
printLine(g, 3, "veloX reported $ccG${player?.externalForce?.x}")
printLine(g, 4, "veloY reported $ccG${player?.externalForce?.y}")
printLine(g, 5, "p_WalkX $ccG${player?.controllerMoveDelta?.x}")
printLine(g, 6, "p_WalkY $ccG${player?.controllerMoveDelta?.y}")
printLineColumn(g, 2, 3, "veloX measured $ccG${xdelta}")
printLineColumn(g, 2, 4, "veloY measured $ccG${ydelta}")
printLine(g, 5, "grounded $ccG${player?.grounded}")
printLine(g, 6, "noClip $ccG${player?.noClip}")
if (player != null) {
printLine(g, 7,
"walled ${if (player.walledLeft) "$ccR" else "$ccG"}L" +
"${if (player.walledTop) "$ccR" else "$ccG"}${0x1E.toChar()}" +
printLineColumn(g, 1, 7,
"walled " +
"${if (player.walledLeft) "$ccR" else "$ccG"}L" +
"${if (player.walledBottom) "$ccR" else "$ccG"}${0x1F.toChar()}" +
"${if (player.walledTop) "$ccR" else "$ccG"}${0x1E.toChar()}" +
"${if (player.walledRight) "$ccR" else "$ccG"}R"
)
}
@@ -132,14 +142,15 @@ class BasicDebugInfoWindow : UICanvas {
* Second column
*/
printLineColumn(g, 2, 1, "VSync $ccG" + Terrarum.appgc.isVSyncRequested)
printLineColumn(g, 2, 2, "Env colour temp $ccG" + FeaturesDrawer.colTemp)
//printLineColumn(g, 2, 1, "VSync $ccG" + Terrarum.appgc.isVSyncRequested)
//printLineColumn(g, 2, 2, "Env colour temp $ccG" + FeaturesDrawer.colTemp)
printLineColumn(g, 2, 5, "Time $ccG${Terrarum.ingame!!.world.time.todaySeconds.toString().padStart(5, '0')}" +
" (${Terrarum.ingame!!.world.time.getFormattedTime()})")
printLineColumn(g, 2, 6, "Mass $ccG${player?.mass}")
printLineColumn(g, 2, 7, "p_WalkX $ccG${player?.walkX}")
printLineColumn(g, 2, 8, "p_WalkY $ccG${player?.walkY}")
printLineColumn(g, 2, 7, "grounded $ccG${player?.grounded}")
printLineColumn(g, 2, 8, "noClip $ccG${player?.noClip}")
drawHistogram(g, LightmapRenderer.histogram,

52
src/net/torvald/terrarum/virtualcomputer/computer/TerrarumComputer.kt
View File

@@ -38,13 +38,13 @@ import kotlin.collections.HashMap
*/
class TerrarumComputer(peripheralSlots: Int) {
var maxPeripherals: Int = peripheralSlots
private set
val DEBUG_UNLIMITED_MEM = false
val DEBUG = true
val maxPeripherals: Int = if (DEBUG) 32 else peripheralSlots
lateinit var luaJ_globals: Globals
private set
@@ -80,7 +80,7 @@ class TerrarumComputer(peripheralSlots: Int) {
lateinit var term: Teletype
private set
val peripheralTable = ArrayList<Peripheral>()
val peripheralTable = Array<Peripheral?>(peripheralSlots, { null }) // index == slot number
var stdinInput: Int = -1
private set
@@ -139,26 +139,55 @@ class TerrarumComputer(peripheralSlots: Int) {
fun getPeripheral(tableName: String): Peripheral? {
peripheralTable.forEach {
if (it.tableName == tableName)
if (it?.tableName == tableName)
return it
}
return null
}
fun attachPeripheral(peri: Peripheral) {
if (peripheralTable.size < maxPeripherals) {
peripheralTable.add(peri)
fun getPeripheralSlot(tableName: String): Int? {
peripheralTable.forEachIndexed { index, peri ->
if (peri?.tableName == tableName)
return index
}
return null
}
/** @return installed slot */
fun attachPeripheral(peri: Peripheral): Int {
(0..maxPeripherals - 1).forEach {
try {
attachPeripheralTo(peri, it)
return it
}
catch (tryNext: RuntimeException) { }
}
throw RuntimeException("No vacant peripheral slot")
}
fun attachPeripheralTo(peri: Peripheral, slot: Int) {
if (peripheralTable[slot] == null) {
peripheralTable[slot] = peri
peri.loadLib(luaJ_globals)
println("[TerrarumComputer] loading peripheral $peri")
}
else {
throw Error("No vacant peripheral slot")
throw RuntimeException("Peripheral slot is already taken by: ${peripheralTable[slot]?.tableName}")
}
}
fun detachPeripheral(peri: Peripheral) {
if (peripheralTable.contains(peri)) {
peripheralTable.remove(peri)
// search for the peripheral
var found = -1
for (i in 0..maxPeripherals - 1) {
if (peripheralTable[i] == peri) {
found = i
break
}
}
if (found >= 0) {
peripheralTable[found] = null
println("[TerrarumComputer] unloading peripheral $peri")
}
else {
@@ -213,7 +242,6 @@ class TerrarumComputer(peripheralSlots: Int) {
// load every peripheral if we're in DEBUG
if (DEBUG) {
maxPeripherals = 32
attachPeripheral(PeripheralInternet(this))
attachPeripheral(PeripheralPSG(this))
// ...

4
src/net/torvald/terrarum/virtualcomputer/luaapi/FilesystemTEVD.kt
View File

@@ -126,9 +126,9 @@ internal class Filesystem(globals: Globals, computer: TerrarumComputer) {
return "$base$local".replace("//", "/")
}
private fun tryBool(action: (Unit) -> Unit): LuaValue {
private fun tryBool(action: () -> Unit): LuaValue {
try {
action(Unit)
action()
return LuaValue.valueOf(true)
}
catch (gottaCatchemAll: Exception) {

83
src/net/torvald/terrarum/worlddrawer/BlocksDrawer.kt
View File

@@ -13,26 +13,32 @@ import net.torvald.terrarum.worlddrawer.WorldCamera.y
import net.torvald.terrarum.worlddrawer.WorldCamera.height
import net.torvald.terrarum.worlddrawer.WorldCamera.width
import org.lwjgl.BufferUtils
import org.lwjgl.opengl.GL11
import org.lwjgl.opengl.GL15
import org.lwjgl.opengl.*
import org.newdawn.slick.*
import java.nio.ByteBuffer
import java.nio.FloatBuffer
/**
* Created by minjaesong on 16-01-19.
*/
object BlocksDrawer {
object BlocksDrawer_NEW {
private val world: GameWorld = Terrarum.ingame!!.world
private val TILE_SIZE = FeaturesDrawer.TILE_SIZE
private val TILE_SIZEF = FeaturesDrawer.TILE_SIZE.toFloat()
// TODO modular
val tilesTerrain = SpriteSheet(ModMgr.getPath("basegame", "blocks/terrain.tga.gz"), TILE_SIZE, TILE_SIZE) // 64 MB
val tilesTerrain = SpriteSheet(ModMgr.getPath("basegame", "blocks/test.tga.gz"), TILE_SIZE, TILE_SIZE) // 64 MB
val terrainHorizontalTiles = tilesTerrain.horizontalCount
val tilesWire = SpriteSheet(ModMgr.getPath("basegame", "blocks/wire.tga.gz"), TILE_SIZE, TILE_SIZE) // 4 MB
val wireHorizontalTiles = tilesWire.horizontalCount
val tilesTerrainTexBuffer: ByteBuffer = BufferUtils.createByteBuffer(tilesTerrain.texture.textureData.size)
init {
tilesTerrainTexBuffer.put(tilesTerrain.texture.textureData)
tilesTerrainTexBuffer.rewind()
}
val tileItemWall = Image(TILE_SIZE * 16, TILE_SIZE * GameWorld.TILES_SUPPORTED / 16) // 4 MB
@@ -57,8 +63,8 @@ object BlocksDrawer {
val VBO_WIDTH = Terrarum.ingame!!.ZOOM_MIN.inv().times(Terrarum.WIDTH).div(TILE_SIZE).ceil() + 2
val VBO_HEIGHT = Terrarum.ingame!!.ZOOM_MIN.inv().times(Terrarum.HEIGHT).div(TILE_SIZE).ceil() + 2
val VBO_WIDTH = Terrarum.ingame!!.ZOOM_MIN.inv().times(Terrarum.WIDTH).div(TILE_SIZE).ceil() + 3
val VBO_HEIGHT = Terrarum.ingame!!.ZOOM_MIN.inv().times(Terrarum.HEIGHT).div(TILE_SIZE).ceil() + 3
val cameraTileX: Int
get() = WorldCamera.x.div(TILE_SIZE)
val cameraTileY: Int
@@ -108,18 +114,22 @@ object BlocksDrawer {
// generate VBO
worldVBOTexture = BufferUtils.createFloatBuffer(12 * VBO_WIDTH * VBO_HEIGHT)
worldVBOVertex = BufferUtils.createFloatBuffer(12 * VBO_WIDTH * VBO_HEIGHT)
worldVBOTexture = BufferUtils.createFloatBuffer(8 * VBO_WIDTH * VBO_HEIGHT)
worldVBOVertex = BufferUtils.createFloatBuffer(8 * VBO_WIDTH * VBO_HEIGHT)
for (y in 0..VBO_HEIGHT - 1) {
for (x in 0..VBO_WIDTH - 1) {
val x = x * TILE_SIZEF
val y = y * TILE_SIZEF
worldVBOVertex.put(floatArrayOf(
worldVBOVertex.put(floatArrayOf( // fixed points (triangles); won't need to be re-assigned
//x , y ,
//x + TILE_SIZEF, y ,
//x , y + TILE_SIZEF,
//x + TILE_SIZEF, y ,
//x + TILE_SIZEF, y + TILE_SIZEF,
//x , y + TILE_SIZEF
x, y,
x + TILE_SIZEF, y,
x, y + TILE_SIZEF,
x + TILE_SIZEF, y,
x + TILE_SIZEF, y + TILE_SIZEF,
x, y + TILE_SIZEF
))
@@ -129,7 +139,7 @@ object BlocksDrawer {
worldVBOVertexID = GL15.glGenBuffers()
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, worldVBOVertexID) //Bind buffer (also specifies type of buffer)
GL15.glBufferData(GL15.GL_ARRAY_BUFFER, worldVBOVertex, GL15.GL_DYNAMIC_DRAW) //Send up the data and specify usage hint.
GL15.glBufferData(GL15.GL_ARRAY_BUFFER, worldVBOVertex, GL15.GL_STATIC_DRAW) //Send up the data and specify usage hint.
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0)
worldVBOTextureID = GL15.glGenBuffers()
@@ -494,7 +504,7 @@ object BlocksDrawer {
}
// draw a breakage
if (mode == TERRAIN || mode == WALL) {
/*if (mode == TERRAIN || mode == WALL) {
val breakage = if (mode == TERRAIN) world.getTerrainDamage(x, y) else world.getWallDamage(x, y)
val maxHealth = BlockCodex[world.getTileFromTerrain(x, y)].strength
val stage = (breakage / maxHealth).times(breakAnimSteps).roundInt()
@@ -503,7 +513,7 @@ object BlocksDrawer {
// alpha blending works, but no GL blend func...
drawTile(mode, x, y, 5 + stage, 0)
}
}
}*/
} // end if (is illuminated)
@@ -534,44 +544,55 @@ object BlocksDrawer {
}
// draw - fill up the VBO buffer
worldVBOTexture.rewind()
for (y in 0..VBO_HEIGHT - 1) {
for (x in 0..VBO_WIDTH - 1) {
val vx = x * TILE_SIZEF
val vy = y * TILE_SIZEF
val tileID = regionBuffer[y][x]
val tileX = (tileID % terrainHorizontalTiles) * TILE_SIZEF
val tileY = (tileID / terrainHorizontalTiles) * TILE_SIZEF
worldVBOTexture.put(floatArrayOf( // feed GL_TRIANGLE data
tileX, tileY,
tileX + TILE_SIZEF, tileY,
tileX, tileY + TILE_SIZEF,
tileX + TILE_SIZEF, tileY,
tileX + TILE_SIZEF, tileY + TILE_SIZEF,
tileX, tileY + TILE_SIZEF
))
worldVBOTexture.put(floatArrayOf( // feed GL_TRIANGLE data (note: bottom-left is zero)
Math.random().toFloat(), Math.random().toFloat(),
Math.random().toFloat(), Math.random().toFloat(),
Math.random().toFloat(), Math.random().toFloat(),
Math.random().toFloat(), Math.random().toFloat()
//Math.random().toFloat() * 4096f, Math.random().toFloat() * 4096f,
//Math.random().toFloat() * 4096f, Math.random().toFloat() * 4096f
)) // FIXME texCoords are wrong?!
}
}
worldVBOTexture.rewind()
// draw - render the VBO
GL11.glBindTexture(GL11.GL_TEXTURE_2D, when (mode) {
val texToBind = when (mode) {
TERRAIN, WALL -> tilesTerrain
WIRE -> tilesWire
else -> throw Error("mode not TERRAIN/WALL/WIRE")
}.texture.textureID)
}.texture
GL11.glBindTexture(GL11.GL_TEXTURE_2D, texToBind.textureID)
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_REPEAT)
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_REPEAT)
//inGLMatrixStack { // disabled for debugging: won't hotswap
GL11.glPushMatrix()
GL11.glTranslatef(WorldCamera.x.clampTileSize().toFloat() - TILE_SIZEF, WorldCamera.y.clampTileSize().toFloat(), 0f)
//GL11.glTranslatef(0f, 0f, 0f)
GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY)
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, worldVBOVertexID)
GL11.glVertexPointer(2, GL11.GL_FLOAT, 0, 0)
GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY)
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, worldVBOTextureID)
GL11.glTexCoordPointer(2, GL11.GL_FLOAT, 0, 0)
GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, 6 * VBO_WIDTH * VBO_HEIGHT)
// for some reason, using 2 VBOs are faster -- presumably because you must fill EVERY ELEMENT when you're using java.nio.Buffer
GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY)
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, worldVBOVertexID)
GL11.glVertexPointer(2, GL11.GL_FLOAT, 0, 0)
GL11.glDrawArrays(GL11.GL_QUADS, 0, 4 * VBO_WIDTH * VBO_HEIGHT)
GL11.glPopMatrix()
//}

657
src/net/torvald/terrarum/worlddrawer/BlocksDrawer_old.kt Normal file
View File

@@ -0,0 +1,657 @@
package net.torvald.terrarum.worlddrawer
import net.torvald.terrarum.gameworld.GameWorld
import net.torvald.terrarum.gameworld.PairedMapLayer
import net.torvald.terrarum.blockproperties.Block
import net.torvald.terrarum.blockproperties.BlockCodex
import com.jme3.math.FastMath
import net.torvald.terrarum.*
import net.torvald.terrarum.gameactors.roundInt
import net.torvald.terrarum.itemproperties.ItemCodex.ITEM_TILES
import net.torvald.terrarum.worlddrawer.WorldCamera.x
import net.torvald.terrarum.worlddrawer.WorldCamera.y
import net.torvald.terrarum.worlddrawer.WorldCamera.height
import net.torvald.terrarum.worlddrawer.WorldCamera.width
import org.lwjgl.opengl.GL11
import org.newdawn.slick.*
import org.newdawn.slick.imageout.ImageOut
/**
* Created by minjaesong on 16-01-19.
*/
object BlocksDrawer {
private val world: GameWorld = Terrarum.ingame!!.world
private val TILE_SIZE = FeaturesDrawer.TILE_SIZE
private val TILE_SIZEF = FeaturesDrawer.TILE_SIZE.toFloat()
// TODO modular
val tilesTerrain = SpriteSheet(ModMgr.getPath("basegame", "blocks/terrain.tga.gz"), TILE_SIZE, TILE_SIZE) // 64 MB
val tilesWire = SpriteSheet(ModMgr.getPath("basegame", "blocks/wire.tga.gz"), TILE_SIZE, TILE_SIZE) // 4 MB
val tileItemWall = Image(TILE_SIZE * 16, TILE_SIZE * GameWorld.TILES_SUPPORTED / 16) // 4 MB
val wallOverlayColour = Color(2f/3f, 2f/3f, 2f/3f, 1f)
val breakAnimSteps = 10
val WALL = GameWorld.WALL
val TERRAIN = GameWorld.TERRAIN
val WIRE = GameWorld.WIRE
private val NEARBY_TILE_KEY_UP = 0
private val NEARBY_TILE_KEY_RIGHT = 1
private val NEARBY_TILE_KEY_DOWN = 2
private val NEARBY_TILE_KEY_LEFT = 3
private val NEARBY_TILE_CODE_UP = 1
private val NEARBY_TILE_CODE_RIGHT = 2
private val NEARBY_TILE_CODE_DOWN = 4
private val NEARBY_TILE_CODE_LEFT = 8
init {
val tg = tileItemWall.graphics
// initialise item_wall images
(ITEM_TILES).forEach {
tg.drawImage(
tilesTerrain.getSubImage(
(it % 16) * 16,
(it / 16)
),
(it % 16) * TILE_SIZE.toFloat(),
(it / 16) * TILE_SIZE.toFloat(),
wallOverlayColour
)
}
//tg.flush()
//ImageOut.write(tileItemWall, "./tileitemwalltest.png")
tg.destroy()
}
/**
* Connectivity group 01 : artificial tiles
* It holds different shading rule to discriminate with group 02, index 0 is single tile.
* These are the tiles that only connects to itself, will not connect to colour variants
*/
private val TILES_CONNECT_SELF = hashSetOf(
Block.GLASS_CRUDE,
Block.GLASS_CLEAN,
Block.ILLUMINATOR_BLACK,
Block.ILLUMINATOR_BLUE,
Block.ILLUMINATOR_BROWN,
Block.ILLUMINATOR_CYAN,
Block.ILLUMINATOR_FUCHSIA,
Block.ILLUMINATOR_GREEN,
Block.ILLUMINATOR_GREEN_DARK,
Block.ILLUMINATOR_GREY_DARK,
Block.ILLUMINATOR_GREY_LIGHT,
Block.ILLUMINATOR_GREY_MED,
Block.ILLUMINATOR_ORANGE,
Block.ILLUMINATOR_PURPLE,
Block.ILLUMINATOR_RED,
Block.ILLUMINATOR_TAN,
Block.ILLUMINATOR_WHITE,
Block.ILLUMINATOR_YELLOW,
Block.ILLUMINATOR_BLACK_OFF,
Block.ILLUMINATOR_BLUE_OFF,
Block.ILLUMINATOR_BROWN_OFF,
Block.ILLUMINATOR_CYAN_OFF,
Block.ILLUMINATOR_FUCHSIA_OFF,
Block.ILLUMINATOR_GREEN_OFF,
Block.ILLUMINATOR_GREEN_DARK_OFF,
Block.ILLUMINATOR_GREY_DARK_OFF,
Block.ILLUMINATOR_GREY_LIGHT_OFF,
Block.ILLUMINATOR_GREY_MED_OFF,
Block.ILLUMINATOR_ORANGE_OFF,
Block.ILLUMINATOR_PURPLE_OFF,
Block.ILLUMINATOR_RED_OFF,
Block.ILLUMINATOR_TAN_OFF,
Block.ILLUMINATOR_WHITE_OFF,
Block.ILLUMINATOR_YELLOW,
Block.DAYLIGHT_CAPACITOR
)
/**
* To interact with external modules
*/
@JvmStatic fun addConnectSelf(blockID: Int): Boolean {
return TILES_CONNECT_SELF.add(blockID)
}
/**
* Connectivity group 02 : natural tiles
* It holds different shading rule to discriminate with group 01, index 0 is middle tile.
*/
private val TILES_CONNECT_MUTUAL = hashSetOf(
Block.STONE,
Block.STONE_QUARRIED,
Block.STONE_TILE_WHITE,
Block.STONE_BRICKS,
Block.DIRT,
Block.GRASS,
Block.GRASSWALL,
Block.PLANK_BIRCH,
Block.PLANK_BLOODROSE,
Block.PLANK_EBONY,
Block.PLANK_NORMAL,
Block.SAND,
Block.SAND_WHITE,
Block.SAND_RED,
Block.SAND_DESERT,
Block.SAND_BLACK,
Block.SAND_GREEN,
Block.GRAVEL,
Block.GRAVEL_GREY,
Block.SNOW,
Block.ICE_NATURAL,
Block.ICE_MAGICAL,
Block.ORE_COPPER,
Block.ORE_IRON,
Block.ORE_GOLD,
Block.ORE_SILVER,
Block.ORE_ILMENITE,
Block.ORE_AURICHALCUM,
Block.SANDSTONE,
Block.SANDSTONE_BLACK,
Block.SANDSTONE_DESERT,
Block.SANDSTONE_RED,
Block.SANDSTONE_WHITE,
Block.SANDSTONE_GREEN,
Block.WATER,
Block.WATER_1,
Block.WATER_2,
Block.WATER_3,
Block.WATER_4,
Block.WATER_5,
Block.WATER_6,
Block.WATER_7,
Block.WATER_8,
Block.WATER_9,
Block.WATER_10,
Block.WATER_11,
Block.WATER_12,
Block.WATER_13,
Block.WATER_14,
Block.WATER_15,
Block.LAVA,
Block.LAVA_1,
Block.LAVA_2,
Block.LAVA_3,
Block.LAVA_4,
Block.LAVA_5,
Block.LAVA_6,
Block.LAVA_7,
Block.LAVA_8,
Block.LAVA_9,
Block.LAVA_10,
Block.LAVA_11,
Block.LAVA_12,
Block.LAVA_13,
Block.LAVA_14,
Block.LAVA_15
)
/**
* To interact with external modules
*/
@JvmStatic fun addConnectMutual(blockID: Int): Boolean {
return TILES_CONNECT_MUTUAL.add(blockID)
}
/**
* Torches, levers, switches, ...
*/
private val TILES_WALL_STICKER = hashSetOf(
Block.TORCH,
Block.TORCH_FROST,
Block.TORCH_OFF,
Block.TORCH_FROST_OFF
)
/**
* To interact with external modules
*/
@JvmStatic fun addWallSticker(blockID: Int): Boolean {
return TILES_WALL_STICKER.add(blockID)
}
/**
* platforms, ...
*/
private val TILES_WALL_STICKER_CONNECT_SELF = hashSetOf(
Block.PLATFORM_BIRCH,
Block.PLATFORM_BLOODROSE,
Block.PLATFORM_EBONY,
Block.PLATFORM_STONE,
Block.PLATFORM_WOODEN
)
/**
* To interact with external modules
*/
@JvmStatic fun addWallStickerConnectSelf(blockID: Int): Boolean {
return TILES_WALL_STICKER_CONNECT_SELF.add(blockID)
}
/**
* Tiles that half-transparent and has hue
* will blend colour using colour multiplication
* i.e. red hues get lost if you dive into the water
*/
private val TILES_BLEND_MUL = hashSetOf(
Block.WATER,
Block.WATER_1,
Block.WATER_2,
Block.WATER_3,
Block.WATER_4,
Block.WATER_5,
Block.WATER_6,
Block.WATER_7,
Block.WATER_8,
Block.WATER_9,
Block.WATER_10,
Block.WATER_11,
Block.WATER_12,
Block.WATER_13,
Block.WATER_14,
Block.WATER_15,
Block.LAVA,
Block.LAVA_1,
Block.LAVA_2,
Block.LAVA_3,
Block.LAVA_4,
Block.LAVA_5,
Block.LAVA_6,
Block.LAVA_7,
Block.LAVA_8,
Block.LAVA_9,
Block.LAVA_10,
Block.LAVA_11,
Block.LAVA_12,
Block.LAVA_13,
Block.LAVA_14,
Block.LAVA_15
)
/**
* To interact with external modules
*/
@JvmStatic fun addBlendMul(blockID: Int): Boolean {
return TILES_BLEND_MUL.add(blockID)
}
fun renderWall(g: Graphics) {
/**
* render to camera
*/
blendNormal()
tilesTerrain.startUse()
drawTiles(g, WALL, false)
tilesTerrain.endUse()
blendMul()
g.color = wallOverlayColour
g.fillRect(WorldCamera.x.toFloat(), WorldCamera.y.toFloat(),
WorldCamera.width.toFloat() + 1, WorldCamera.height.toFloat() + 1
)
blendNormal()
}
fun renderTerrain(g: Graphics) {
/**
* render to camera
*/
blendNormal()
tilesTerrain.startUse()
drawTiles(g, TERRAIN, false) // regular tiles
tilesTerrain.endUse()
}
fun renderFront(g: Graphics, drawWires: Boolean) {
/**
* render to camera
*/
blendMul()
tilesTerrain.startUse()
drawTiles(g, TERRAIN, true) // blendmul tiles
tilesTerrain.endUse()
if (drawWires) {
tilesWire.startUse()
drawTiles(g, WIRE, false)
tilesWire.endUse()
}
blendNormal()
}
private val tileDrawLightThreshold = 2
private fun drawTiles(g: Graphics, mode: Int, drawModeTilesBlendMul: Boolean) {
val for_y_start = y / TILE_SIZE
val for_y_end = BlocksDrawer.clampHTile(for_y_start + (height / TILE_SIZE) + 2)
val for_x_start = x / TILE_SIZE - 1
val for_x_end = for_x_start + (width / TILE_SIZE) + 3
var zeroTileCounter = 0
// loop
for (y in for_y_start..for_y_end) {
for (x in for_x_start..for_x_end - 1) {
val thisTile: Int?
if (mode % 3 == WALL)
thisTile = world.getTileFromWall(x, y)
else if (mode % 3 == TERRAIN)
thisTile = world.getTileFromTerrain(x, y)
else if (mode % 3 == WIRE)
thisTile = world.getTileFromWire(x, y)
else
throw IllegalArgumentException()
val noDamageLayer = mode % 3 == WIRE
// draw a tile, but only when illuminated
try {
if ((mode == WALL || mode == TERRAIN) && // not an air tile
(thisTile ?: 0) != Block.AIR) {
// check if light level of nearby or this tile is illuminated
if ( LightmapRenderer.getHighestRGB(x, y) ?: 0 >= tileDrawLightThreshold ||
LightmapRenderer.getHighestRGB(x - 1, y) ?: 0 >= tileDrawLightThreshold ||
LightmapRenderer.getHighestRGB(x + 1, y) ?: 0 >= tileDrawLightThreshold ||
LightmapRenderer.getHighestRGB(x, y - 1) ?: 0 >= tileDrawLightThreshold ||
LightmapRenderer.getHighestRGB(x, y + 1) ?: 0 >= tileDrawLightThreshold ||
LightmapRenderer.getHighestRGB(x - 1, y - 1) ?: 0 >= tileDrawLightThreshold ||
LightmapRenderer.getHighestRGB(x + 1, y + 1) ?: 0 >= tileDrawLightThreshold ||
LightmapRenderer.getHighestRGB(x + 1, y - 1) ?: 0 >= tileDrawLightThreshold ||
LightmapRenderer.getHighestRGB(x - 1, y + 1) ?: 0 >= tileDrawLightThreshold) {
// blackness
if (zeroTileCounter > 0) {
/* unable to do anything */
zeroTileCounter = 0
}
val nearbyTilesInfo: Int
if (isPlatform(thisTile)) {
nearbyTilesInfo = getNearbyTilesInfoPlatform(x, y)
}
else if (isWallSticker(thisTile)) {
nearbyTilesInfo = getNearbyTilesInfoWallSticker(x, y)
}
else if (isConnectMutual(thisTile)) {
nearbyTilesInfo = getNearbyTilesInfoNonSolid(x, y, mode)
}
else if (isConnectSelf(thisTile)) {
nearbyTilesInfo = getNearbyTilesInfo(x, y, mode, thisTile)
}
else {
nearbyTilesInfo = 0
}
val thisTileX = if (!noDamageLayer)
PairedMapLayer.RANGE * ((thisTile ?: 0) % PairedMapLayer.RANGE) + nearbyTilesInfo
else
nearbyTilesInfo
val thisTileY = (thisTile ?: 0) / PairedMapLayer.RANGE
// draw a tile
if (drawModeTilesBlendMul) {
if (BlocksDrawer.isBlendMul(thisTile)) {
drawTile(mode, x, y, thisTileX, thisTileY)
}
}
else {
// do NOT add "if (!isBlendMul(thisTile))"!
// or else they will not look like they should be when backed with wall
drawTile(mode, x, y, thisTileX, thisTileY)
}
// draw a breakage
if (mode == TERRAIN || mode == WALL) {
val breakage = if (mode == TERRAIN) world.getTerrainDamage(x, y) else world.getWallDamage(x, y)
val maxHealth = BlockCodex[world.getTileFromTerrain(x, y)].strength
val stage = (breakage / maxHealth).times(breakAnimSteps).roundInt()
// actual drawing
if (stage > 0) {
// alpha blending works, but no GL blend func...
drawTile(mode, x, y, 5 + stage, 0)
}
}
} // end if (is illuminated)
// draw black patch
else {
zeroTileCounter++ // unused for now
GL11.glColor4f(0f, 0f, 0f, 1f)
GL11.glTexCoord2f(0f, 0f)
GL11.glVertex3f(x * TILE_SIZE.toFloat(), y * TILE_SIZE.toFloat(), 0f)
GL11.glTexCoord2f(0f, 0f + TILE_SIZE)
GL11.glVertex3f(x * TILE_SIZE.toFloat(), (y + 1) * TILE_SIZE.toFloat(), 0f)
GL11.glTexCoord2f(0f + TILE_SIZE, 0f + TILE_SIZE)
GL11.glVertex3f((x + 1) * TILE_SIZE.toFloat(), (y + 1) * TILE_SIZE.toFloat(), 0f)
GL11.glTexCoord2f(0f + TILE_SIZE, 0f)
GL11.glVertex3f((x + 1) * TILE_SIZE.toFloat(), y * TILE_SIZE.toFloat(), 0f)
GL11.glColor4f(1f, 1f, 1f, 1f)
}
} // end if (not an air)
} catch (e: NullPointerException) {
// do nothing. WARNING: This exception handling may hide erratic behaviour completely.
}
}
}
}
/**
* @param x
* *
* @param y
* *
* @return binary [0-15] 1: up, 2: right, 4: down, 8: left
*/
fun getNearbyTilesInfo(x: Int, y: Int, mode: Int, mark: Int?): Int {
val nearbyTiles = IntArray(4)
nearbyTiles[NEARBY_TILE_KEY_LEFT] = world.getTileFrom(mode, x - 1, y) ?: Block.NULL
nearbyTiles[NEARBY_TILE_KEY_RIGHT] = world.getTileFrom(mode, x + 1, y) ?: Block.NULL
nearbyTiles[NEARBY_TILE_KEY_UP] = world.getTileFrom(mode, x , y - 1) ?: 4906
nearbyTiles[NEARBY_TILE_KEY_DOWN] = world.getTileFrom(mode, x , y + 1) ?: Block.NULL
// try for
var ret = 0
for (i in 0..3) {
if (nearbyTiles[i] == mark) {
ret += 1 shl i // add 1, 2, 4, 8 for i = 0, 1, 2, 3
}
}
return ret
}
fun getNearbyTilesInfoNonSolid(x: Int, y: Int, mode: Int): Int {
val nearbyTiles = IntArray(4)
nearbyTiles[NEARBY_TILE_KEY_LEFT] = world.getTileFrom(mode, x - 1, y) ?: Block.NULL
nearbyTiles[NEARBY_TILE_KEY_RIGHT] = world.getTileFrom(mode, x + 1, y) ?: Block.NULL
nearbyTiles[NEARBY_TILE_KEY_UP] = world.getTileFrom(mode, x , y - 1) ?: 4906
nearbyTiles[NEARBY_TILE_KEY_DOWN] = world.getTileFrom(mode, x , y + 1) ?: Block.NULL
// try for
var ret = 0
for (i in 0..3) {
try {
if (!BlockCodex[nearbyTiles[i]].isSolid &&
!BlockCodex[nearbyTiles[i]].isFluid) {
ret += (1 shl i) // add 1, 2, 4, 8 for i = 0, 1, 2, 3
}
} catch (e: ArrayIndexOutOfBoundsException) {
}
}
return ret
}
fun getNearbyTilesInfoWallSticker(x: Int, y: Int): Int {
val nearbyTiles = IntArray(4)
val NEARBY_TILE_KEY_BACK = NEARBY_TILE_KEY_UP
nearbyTiles[NEARBY_TILE_KEY_LEFT] = world.getTileFrom(TERRAIN, x - 1, y) ?: Block.NULL
nearbyTiles[NEARBY_TILE_KEY_RIGHT] = world.getTileFrom(TERRAIN, x + 1, y) ?: Block.NULL
nearbyTiles[NEARBY_TILE_KEY_DOWN] = world.getTileFrom(TERRAIN, x , y + 1) ?: Block.NULL
nearbyTiles[NEARBY_TILE_KEY_BACK] = world.getTileFrom(WALL, x , y) ?: Block.NULL
try {
if (BlockCodex[nearbyTiles[NEARBY_TILE_KEY_DOWN]].isSolid)
// has tile on the bottom
return 3
else if (BlockCodex[nearbyTiles[NEARBY_TILE_KEY_RIGHT]].isSolid
&& BlockCodex[nearbyTiles[NEARBY_TILE_KEY_LEFT]].isSolid)
// has tile on both sides
return 0
else if (BlockCodex[nearbyTiles[NEARBY_TILE_KEY_RIGHT]].isSolid)
// has tile on the right
return 2
else if (BlockCodex[nearbyTiles[NEARBY_TILE_KEY_LEFT]].isSolid)
// has tile on the left
return 1
else if (BlockCodex[nearbyTiles[NEARBY_TILE_KEY_BACK]].isSolid)
// has tile on the back
return 0
else
return 3
} catch (e: ArrayIndexOutOfBoundsException) {
return if (BlockCodex[nearbyTiles[NEARBY_TILE_KEY_DOWN]].isSolid)
// has tile on the bottom
3 else 0
}
}
fun getNearbyTilesInfoPlatform(x: Int, y: Int): Int {
val nearbyTiles = IntArray(4)
nearbyTiles[NEARBY_TILE_KEY_LEFT] = world.getTileFrom(TERRAIN, x - 1, y) ?: Block.NULL
nearbyTiles[NEARBY_TILE_KEY_RIGHT] = world.getTileFrom(TERRAIN, x + 1, y) ?: Block.NULL
if ((BlockCodex[nearbyTiles[NEARBY_TILE_KEY_LEFT]].isSolid &&
BlockCodex[nearbyTiles[NEARBY_TILE_KEY_RIGHT]].isSolid) ||
isPlatform(nearbyTiles[NEARBY_TILE_KEY_LEFT]) &&
isPlatform(nearbyTiles[NEARBY_TILE_KEY_RIGHT])) // LR solid || LR platform
return 0
else if (BlockCodex[nearbyTiles[NEARBY_TILE_KEY_LEFT]].isSolid &&
!isPlatform(nearbyTiles[NEARBY_TILE_KEY_LEFT]) &&
!BlockCodex[nearbyTiles[NEARBY_TILE_KEY_RIGHT]].isSolid &&
!isPlatform(nearbyTiles[NEARBY_TILE_KEY_RIGHT])) // L solid and not platform && R not solid and not platform
return 4
else if (BlockCodex[nearbyTiles[NEARBY_TILE_KEY_RIGHT]].isSolid &&
!isPlatform(nearbyTiles[NEARBY_TILE_KEY_RIGHT]) &&
!BlockCodex[nearbyTiles[NEARBY_TILE_KEY_LEFT]].isSolid &&
!isPlatform(nearbyTiles[NEARBY_TILE_KEY_LEFT])) // R solid and not platform && L not solid and nto platform
return 6
else if (BlockCodex[nearbyTiles[NEARBY_TILE_KEY_LEFT]].isSolid &&
!isPlatform(nearbyTiles[NEARBY_TILE_KEY_LEFT])) // L solid && L not platform
return 3
else if (BlockCodex[nearbyTiles[NEARBY_TILE_KEY_RIGHT]].isSolid &&
!isPlatform(nearbyTiles[NEARBY_TILE_KEY_RIGHT])) // R solid && R not platform
return 5
else if ((BlockCodex[nearbyTiles[NEARBY_TILE_KEY_LEFT]].isSolid ||
isPlatform(nearbyTiles[NEARBY_TILE_KEY_LEFT])) &&
!BlockCodex[nearbyTiles[NEARBY_TILE_KEY_RIGHT]].isSolid &&
!isPlatform(nearbyTiles[NEARBY_TILE_KEY_RIGHT])) // L solid or platform && R not solid and not platform
return 1
else if ((BlockCodex[nearbyTiles[NEARBY_TILE_KEY_RIGHT]].isSolid ||
isPlatform(nearbyTiles[NEARBY_TILE_KEY_RIGHT])) &&
!BlockCodex[nearbyTiles[NEARBY_TILE_KEY_LEFT]].isSolid &&
!isPlatform(nearbyTiles[NEARBY_TILE_KEY_LEFT])) // R solid or platform && L not solid and not platform
return 2
else
return 7
}
private fun drawTile(mode: Int, tilewisePosX: Int, tilewisePosY: Int, sheetX: Int, sheetY: Int) {
if (mode == TERRAIN || mode == WALL)
tilesTerrain.renderInUse(
FastMath.floor((tilewisePosX * TILE_SIZE).toFloat()),
FastMath.floor((tilewisePosY * TILE_SIZE).toFloat()),
sheetX, sheetY
)
else if (mode == WIRE)
tilesWire.renderInUse(
FastMath.floor((tilewisePosX * TILE_SIZE).toFloat()),
FastMath.floor((tilewisePosY * TILE_SIZE).toFloat()),
sheetX, sheetY
)
else
throw IllegalArgumentException()
}
fun clampH(x: Int): Int {
if (x < 0) {
return 0
} else if (x > world.height * TILE_SIZE) {
return world.height * TILE_SIZE
} else {
return x
}
}
fun clampWTile(x: Int): Int {
if (x < 0) {
return 0
} else if (x > world.width) {
return world.width
} else {
return x
}
}
fun clampHTile(x: Int): Int {
if (x < 0) {
return 0
} else if (x > world.height) {
return world.height
} else {
return x
}
}
fun getRenderStartX(): Int = x / TILE_SIZE
fun getRenderStartY(): Int = y / TILE_SIZE
fun getRenderEndX(): Int = clampWTile(getRenderStartX() + (width / TILE_SIZE) + 2)
fun getRenderEndY(): Int = clampHTile(getRenderStartY() + (height / TILE_SIZE) + 2)
fun isConnectSelf(b: Int?): Boolean = TILES_CONNECT_SELF.contains(b)
fun isConnectMutual(b: Int?): Boolean = TILES_CONNECT_MUTUAL.contains(b)
fun isWallSticker(b: Int?): Boolean = TILES_WALL_STICKER.contains(b)
fun isPlatform(b: Int?): Boolean = TILES_WALL_STICKER_CONNECT_SELF.contains(b)
fun isBlendMul(b: Int?): Boolean = TILES_BLEND_MUL.contains(b)
fun tileInCamera(x: Int, y: Int) =
x >= WorldCamera.x.div(TILE_SIZE) && y >= WorldCamera.y.div(TILE_SIZE) &&
x <= WorldCamera.x.plus(width).div(TILE_SIZE) && y <= WorldCamera.y.plus(width).div(TILE_SIZE)
}

23
src/net/torvald/terrarum/worlddrawer/LightmapRenderer.kt
View File

@@ -7,8 +7,6 @@ import com.jme3.math.FastMath
import net.torvald.terrarum.gameactors.ActorWithPhysics
import net.torvald.terrarum.gameworld.GameWorld
import net.torvald.terrarum.blockproperties.Block
import net.torvald.terrarum.gamecontroller.Key
import net.torvald.terrarum.gamecontroller.KeyToggler
import org.newdawn.slick.Color
import org.newdawn.slick.Graphics
import java.util.*
@@ -20,12 +18,15 @@ import java.util.*
object LightmapRenderer {
private val world: GameWorld = Terrarum.ingame!!.world
// TODO if (VBO works on BlocksDrawer) THEN overscan of 256, utilise same technique in here
val overscan_open: Int = Math.min(32, 256f.div(BlockCodex[Block.AIR].opacity and 0xFF).ceil())
val overscan_opaque: Int = Math.min(8, 256f.div(BlockCodex[Block.STONE].opacity and 0xFF).ceil())
private val LIGHTMAP_WIDTH = Terrarum.ingame!!.ZOOM_MIN.inv().times(Terrarum.WIDTH)
val LIGHTMAP_WIDTH = Terrarum.ingame!!.ZOOM_MIN.inv().times(Terrarum.WIDTH)
.div(FeaturesDrawer.TILE_SIZE).ceil() + overscan_open * 2 + 3
private val LIGHTMAP_HEIGHT = Terrarum.ingame!!.ZOOM_MIN.inv().times(Terrarum.HEIGHT)
val LIGHTMAP_HEIGHT = Terrarum.ingame!!.ZOOM_MIN.inv().times(Terrarum.HEIGHT)
.div(FeaturesDrawer.TILE_SIZE).ceil() + overscan_open * 2 + 3
/**
@@ -215,8 +216,8 @@ object LightmapRenderer {
if (it is Luminous && it is ActorWithPhysics) {
// put lanterns to the area the luminantBox is occupying
for (lightBox in it.lightBoxList) {
val lightBoxX = it.hitbox.posX + lightBox.posX
val lightBoxY = it.hitbox.posY + lightBox.posY
val lightBoxX = it.hitbox.startX + lightBox.startX
val lightBoxY = it.hitbox.startY + lightBox.startY
val lightBoxW = lightBox.width
val lightBoxH = lightBox.height
for (y in lightBoxY.div(TILE_SIZE).floorInt()
@@ -364,10 +365,7 @@ object LightmapRenderer {
for (iy in 0..1) {
for (ix in 0..1) {
g.color = if (KeyToggler.isOn(Key.F9))
colourMapItoL[iy * 2 + ix].normaliseToColourHDR()
else
colourMapItoL[iy * 2 + ix].normaliseToColour()
g.color = colourMapItoL[iy * 2 + ix].normaliseToColourHDR()
g.fillRect(
@@ -395,10 +393,7 @@ object LightmapRenderer {
if (x + sameLevelCounter >= this_x_end) break
}
g.color = if (KeyToggler.isOn(Key.F9))
(getLight(x, y) ?: 0).normaliseToColourHDR()
else
(getLight(x, y) ?: 0).normaliseToColour()
g.color = (getLight(x, y) ?: 0).normaliseToColourHDR()
g.fillRect(
(x.toFloat() * TILE_SIZE).round().toFloat(),

BIN
work_files/graphics/fonts/thai_variable.psd LFS Normal file
View File

Binary file not shown.