[Bundle][RO] Update (#4696)

This PR was tested in-game and is ready to merge at any time.

Changelog:

- New strings/changes up to commit 631e4d9eef
- Typo fixes & various other improvements

.github/workflows/deployment.yml

@@ -50,6 +50,7 @@ jobs:
         echo versionName=6-fdroid-${RELEASE_VERSION:1}$'\n'versionCode=${RELEASE_VERSION:1} > version_fdroid.txt
         git add .
         git commit -m "Updating to build ${RELEASE_VERSION:1}"
+        git push https://Anuken:${{ secrets.API_TOKEN_GITHUB }}@github.com/Anuken/MindustryBuilds
         cd ../Mindustry
     - name: Upload client artifacts
       uses: svenstaro/upload-release-action@v2

android/src/mindustry/android/AndroidLauncher.java

@@ -162,7 +162,6 @@ public class AndroidLauncher extends AndroidApplication{
         }, new AndroidApplicationConfiguration(){{
             useImmersiveMode = true;
             hideStatusBar = true;
-            stencil = 8;
         }});
         checkFiles(getIntent());
 

build.gradle

@@ -323,6 +323,10 @@ project(":core"){
         from sourceSets.main.allSource
     }
     
+    artifacts{
+        archives sourcesJar
+    }
+
     dependencies{
         compileJava.dependsOn(preGen)
 

core/assets/bundles/bundle.properties

@@ -796,6 +796,7 @@ setting.shadows.name = Shadows
 setting.blockreplace.name = Automatic Block Suggestions
 setting.linear.name = Linear Filtering
 setting.hints.name = Hints
+setting.logichints.name = Logic Hints
 setting.flow.name = Display Resource Flow Rate
 setting.backgroundpause.name = Pause In Background
 setting.buildautopause.name = Auto-Pause Building
@@ -956,6 +957,8 @@ rules.blockdamagemultiplier = Block Damage Multiplier
 rules.unitbuildspeedmultiplier = Unit Production Speed Multiplier
 rules.unithealthmultiplier = Unit Health Multiplier
 rules.unitdamagemultiplier = Unit Damage Multiplier
+rules.unitcapvariable = Cores Contribute To Unit Cap
+rules.unitcap = Base Unit Cap
 rules.enemycorebuildradius = Enemy Core No-Build Radius:[lightgray] (tiles)
 rules.wavespacing = Wave Spacing:[lightgray] (sec)
 rules.buildcostmultiplier = Build Cost Multiplier
@@ -1513,3 +1516,127 @@ unit.omura.description = Fires a long-range piercing railgun bolt at enemies. Co
 unit.alpha.description = Defends the Shard core from enemies. Builds structures.
 unit.beta.description = Defends the Foundation core from enemies. Builds structures.
 unit.gamma.description = Defends the Nucleus core from enemies. Builds structures.
+
+lst.read = Read a number from a linked memory cell.
+lst.write = Write a number to a linked memory cell.
+lst.print = Add text to the print buffer.\nDoes not display anything until [accent]Print Flush[] is used.
+lst.draw = Add an operation to the drawing buffer.\nDoes not display anything until [accent]Draw Flush[] is used.
+lst.drawflush = Flush queued [accent]Draw[] operations to a display.
+lst.printflush = Flush queued [accent]Print[] operations to a message block.
+lst.getlink = Get a processor link by index. Starts at 0.
+lst.control = Control a building.
+lst.radar = Locate units around a building with range.
+lst.sensor = Get data from a building or unit.
+lst.set = Set a variable.
+lst.operation = Perform an operation on 1-2 variables.
+lst.end = Jump to the top of the instruction stack.
+lst.jump = Conditionally jump to another statement.
+lst.unitbind = Bind to the next unit of a type, and store it in [accent]@unit[].
+lst.unitcontrol = Control the currently bound unit.
+lst.unitradar = Locate units around the currently bound unit.
+lst.unitlocate = Locate a specific type of position/building anywhere on the map.\nRequires a bound unit.
+
+lenum.type = Type of building/unit.\ne.g. for any router, this will return [accent]@router[].\nNot a string.
+lenum.shoot = Shoot at a position.
+lenum.shootp = Shoot at a unit/building with velocity prediction.
+lenum.configure = Building configuration, e.g. sorter item.
+lenum.enabled = Whether the block is enabled.
+lenum.color = Illuminator color.
+
+lenum.always = Always true.
+lenum.idiv = Integer division.
+lenum.div = Division.\nReturns [accent]null[] on divide-by-zero.
+lenum.mod = Modulo.
+lenum.equal = Equal. Coerces types.\nNon-null objects compared with numbers become 1, otherwise 0.
+lenum.notequal = Not equal. Coerces types.
+lenum.strictequal = Strict equality. Does not coerce types.\nCan be used to check for [accent]null[].
+lenum.shl = Bit-shift left.
+lenum.shr = Bit-shift right.
+lenum.or = Bitwise OR.
+lenum.land = Logical AND.
+lenum.and = Bitwise AND.
+lenum.not = Bitwise flip.
+lenum.xor = Bitwise XOR.
+
+lenum.min = Minimum of two numbers.
+lenum.max = Maximum of two numbers.
+lenum.angle = Angle of vector in degrees.
+lenum.len = Length of vector.
+lenum.sin = Sine, in degrees.
+lenum.cos = Cosine, in degrees.
+lenum.tan = Tangent, in degrees.
+#not a typo, look up 'range notation'
+lenum.rand = Random number in range [0, value).
+lenum.log = Natural logarithm (ln).
+lenum.log10 = Base 10 logarithm.
+lenum.noise = 2D simplex noise.
+lenum.abs = Absolute value.
+lenum.sqrt = Square root.
+
+lenum.any = Any unit.
+lenum.ally = Ally unit.
+lenum.attacker = Unit with a weapon.
+lenum.enemy = Enemy unit.
+lenum.boss = Guardian unit.
+lenum.flying = Flying unit.
+lenum.ground = Ground unit.
+lenum.player = Unit controlled by a player.
+
+lenum.ore = Ore deposit.
+lenum.damaged = Damaged ally building.
+lenum.spawn = Enemy spawn point.\nMay be a core or a position.
+lenum.building = Building in a specific group.
+
+lenum.core = Any core.
+lenum.storage = Storage building, e.g. Vault.
+lenum.generator = Buildings that generate power.
+lenum.factory = Buildings that transform resources.
+lenum.repair = Repair points.
+lenum.rally = Command center.
+lenum.battery = Any battery.
+lenum.resupply = Resupply points.\nOnly relevant when [accent]"Unit Ammo"[] is enabled.
+lenum.reactor = Impact/Thorium reactor.
+lenum.turret = Any turret.
+
+sensor.in = The building/unit to sense.
+
+radar.from = Building to sense from.\nSensor range is limited by building range.
+radar.target = Filter for units to sense.
+radar.and = Additional filters.
+radar.order = Sorting order. 0 to reverse.
+radar.sort = Metric to sort results by.
+radar.output = Variable to write output unit to.
+
+unitradar.target = Filter for units to sense.
+unitradar.and = Additional filters.
+unitradar.order = Sorting order. 0 to reverse.
+unitradar.sort = Metric to sort results by.
+unitradar.output = Variable to write output unit to.
+
+control.of = Building to control.
+control.unit = Unit/building to aim at.
+control.shoot = Whether to shoot.
+
+unitlocate.enemy = Whether to locate enemy buildings.
+unitlocate.found = Whether the object was found.
+unitlocate.building = Output variable for located building.
+unitlocate.outx = Output X coordinate.
+unitlocate.outy = Output Y coordinate.
+unitlocate.group = Building group to look for.
+
+lenum.stop = Stop moving/mining/building.
+lenum.move = Move to exact position.
+lenum.approach = Approach a position with a radius.
+lenum.pathfind = Pathfind to the enemy spawn.
+lenum.target = Shoot a position.
+lenum.targetp = Shoot a target with velocity prediction.
+lenum.itemdrop = Drop an item.
+lenum.itemtake = Take an item from a building.
+lenum.paydrop = Drop current payload.
+lenum.paytake = Pick up payload at current location.
+lenum.flag = Numeric unit flag.
+lenum.mine = Mine at a position.
+lenum.build = Build a structure.
+lenum.getblock = Fetch a building and type at coordinates.\nUnit must be in range of position.\nSolid non-buildings will have the type [accent]@solid[].
+lenum.within = Check if unit is near a position.
+lenum.boost = Start/stop boosting.

core/assets/bundles/bundle_de.properties

@@ -71,9 +71,9 @@ schematic.disabled = [scarlet]Entwürfe deaktiviert[]\nAuf dieser [accent]Karte[
 stats = Statistiken
 stat.wave = Wellen besiegt:[accent] {0}
 stat.enemiesDestroyed = Gegner zerstört:[accent] {0}
-stat.built = Gebäude gebaut:[accent] {0}
+stat.built = Blöcke gebaut:[accent] {0}
-stat.destroyed = Gebäude zerstört:[accent] {0}
+stat.destroyed = Blöcke zerstört:[accent] {0}
-stat.deconstructed = Gebäude abgebaut:[accent] {0}
+stat.deconstructed = Blöcke abgebaut:[accent] {0}
 stat.delivered = Übertragene Ressourcen:
 stat.playtime = Spielzeit:[accent] {0}
 stat.rank = Finaler Rang:[accent] {0}
@@ -312,6 +312,7 @@ cancelbuilding = [accent][[{0}][] um den Plan zu leeren
 selectschematic = [accent][[{0}][] zum Auswählen+Kopieren
 pausebuilding = [accent][[{0}][] um das Bauen zu pausieren
 resumebuilding = [scarlet][[{0}][] um das Bauen fortzusetzen
+enablebuilding = [scarlet][[{0}][] um zu bauen
 showui = Bedienflächen versteckt.\nDrücke [accent][[{0}][], um sie wieder anzuzeigen.
 wave = [accent]Welle {0}
 wave.cap = [accent]Welle {0}/{1}
@@ -683,6 +684,7 @@ stat.drillspeed = Bohrgeschwindigkeit
 stat.boosteffect = Verstärkungseffekt
 stat.maxunits = Max. aktive Einheiten
 stat.health = Lebenspunkte
+stat.armour = Panzer
 stat.buildtime = Baudauer
 stat.maxconsecutive = Max. Konsekutive
 stat.buildcost = Baukosten
@@ -794,6 +796,7 @@ setting.shadows.name = Schatten
 setting.blockreplace.name = Automatische Blockvorschläge
 setting.linear.name = Lineare Filterung
 setting.hints.name = Tipps
+setting.logichints.name = Logiktipps
 setting.flow.name = Ressourcen-Fluss anzeigen
 setting.backgroundpause.name = Im Hintergrund pausieren
 setting.buildautopause.name = Bauen automatisch pausieren
@@ -963,7 +966,7 @@ rules.waitForWaveToEnd = Warten bis Welle endet
 rules.dropzoneradius = Drop-Zonen-Radius:[lightgray] (Kacheln)
 rules.unitammo = Einheiten benötigen Munition
 rules.title.waves = Wellen
-rules.title.resourcesbuilding = Ressourcen & Gebäude
+rules.title.resourcesbuilding = Ressourcen & Blöcke
 rules.title.enemy = Gegner
 rules.title.unit = Einheiten
 rules.title.experimental = Experimentell
@@ -1318,7 +1321,7 @@ item.coal.details = Scheint versteinerte Pflanzenmasse zu sein, die sich schon l
 item.titanium.description = Wird im Flüssigkeitsbereich, im Bohrerbereich und für Flugzeuge vielfältig eingesetzt.
 item.thorium.description = Wird als festes Baumaterial oder radioaktiver Kraftstoff verwendet.
 item.scrap.description = Wird in Pulverisierer und Schmelzer zu anderen Materialien bearbeitet.
-item.scrap.details = Übriggebliebene Reste alter Gebäude oder Einheiten.
+item.scrap.details = Übriggebliebene Reste alter Blöcke oder Einheiten.
 item.silicon.description = Wird in Solarzellen, komplizierter Elektronik und als zielsuchende Munition verwendet.
 item.plastanium.description = Wird für fortgeschrittene Einheiten, Isolation und Munition eingesetzt.
 item.phase-fabric.description = Kann in Elektronik und selbstreparierende Blöcke verwendet werden.
@@ -1511,3 +1514,118 @@ unit.omura.description = Schießt eine Railgun mit hoher Reichweite, um Gegner z
 unit.alpha.description = Beschützt den Scherbenkern vor Feinden. Baut Blöcke.
 unit.beta.description = Beschützt den Fundamentkern vor Feinden. Baut Blöcke.
 unit.gamma.description = Beschützt den Nukleuskern vor Feinden. Baut Blöcke.
+
+lst.read = Liest einen Wert aus einer verbundenen Spiecherzelle.
+lst.write = Schreibt eine Zahl in einer verbundene Speicherzelle.
+lst.print = Fügt Text zum Textspeicher hinzu.\nZeigt nichts an, bis [accent]Print Flush[] verwendet wird.
+lst.draw = Fügt eine [accent]Draw[]-Aufgabe zum Bildspeicher hinzu.\nZeigt nichts an, bis [accent]Draw Flush[] verwendet wird.
+lst.drawflush = Druckt [accent]Draw[]-Aufgaben aus dem Bildspeicher auf einen Bildschirm.
+lst.printflush = Druckt [accent]Print[]-Aufgaben aus dem Textspeicher auf einen Nachrichtenblock.
+lst.getlink = Gibt ein verbundenen Block wieder. Fängt bei 0 an.
+lst.control = Steuert einen Block.
+lst.radar = Findet Einheiten.
+lst.sensor = Gibt Daten über einen Block oder eine Einheit wieder.
+lst.set = Setzt eine Variable fest.
+lst.operation = Verändert eine Variable.
+lst.end = Springt wieder nach oben.
+lst.jump = Falls die Bedingung erfüllt ist, wird woanders weitergemacht.
+lst.unitbind = Speichert eine Einheit einer Sorte als [accent]@unit[].
+lst.unitcontrol = Steuert [accent]@unit[].
+lst.unitradar = Findet Einheiten in der Nähe von [accent]@unit[].
+lst.unitlocate = Findet mit [accent]@unit[] bestimmte Positionen / Blöcke auf der ganzen Karte.
+
+lenum.type = Englischer Name eines Blocks / einer Einheit. Ein Verteiler gibt [accent]@router[] wieder.\nKein string.
+lenum.shoot = Schießt auf eine Position.
+lenum.shootp = Schießt auf eine Einheit / einen Block und sagt deren Position voraus.
+lenum.configure = Blockkonfiguration, z.B. das ausgewählte Item in einem Sortierer.
+lenum.enabled = Ob der Block an oder aus ist.
+lenum.color = Illuminiererfarbe.
+
+lenum.always = Immer.
+lenum.idiv = Division mit ganzen Zahlen.
+lenum.div = Division.\nGibt bei Teilung durch null [accent]null[] zurück.
+lenum.mod = Modulo.
+lenum.equal = Prüft Gleichheit.\nNicht-"null" Objekte, die mit Zahlen verglichen werden, werden 1.
+lenum.notequal = Prüft Ungleichheit.
+lenum.strictequal = Prüft strenge Gleichheit.\nKann verwendet werden, um "null" zu finden.
+lenum.shl = Bit-shift nacht links.
+lenum.shr = Bit-shift nach rechts.
+lenum.or = Bitwise ODER.
+lenum.land = Logisches AND.
+lenum.and = Bitwise UND.
+lenum.not = Bitwise NOT.
+lenum.xor = Bitwise XOR.
+
+lenum.min = Die Größte von zwei Zahlen.
+lenum.max = Die Kleinste von zwei Zahlen.
+lenum.angle = Angle of vector in degrees.
+lenum.len = Length of vector.
+lenum.sin = Sinus in Grad.
+lenum.cos = Cosinus in Grad.
+lenum.tan = Tangens in Grad.
+lenum.rand = Zufällige Zahl zwischen [0, <wert>).
+lenum.log = Logarithmus (ln).
+lenum.log10 = Logarithmus zur Basis 10.
+lenum.noise = 2D rauschen.
+lenum.abs = Betrag.
+lenum.sqrt = Quadratwurzel.
+
+lenum.any = Irgendeine Einheit.
+lenum.ally = Freundliche Einheit.
+lenum.attacker = Einheit mit Waffe.
+lenum.enemy = Gegnerische Einheit.
+lenum.boss = Bosseinheit.
+lenum.flying = Lufteinheit.
+lenum.ground = Bodeneinheit.
+lenum.player = Spielergesteuerte Einheit.
+
+lenum.ore = Erz.
+lenum.damaged = Beschädigter, alliierter Block.
+lenum.spawn = Gegnerischer Spawnpunkt.\nKann ein Kern oder eine Position sein.
+lenum.building = Ein Block einer bestimmten Sorte.
+
+lenum.core = Irgendein Kern.
+lenum.storage = Speicherblock, z.B. ein Tresor.
+
+sensor.in = Der Block / die Einheit.
+
+radar.from = Block zu benutzen. [accent]Sensor[]-Reichweite hängt von der Blockreichweite ab.
+radar.target = Einheitenfilter.
+radar.and = Weitere Filter.
+radar.order = Sortierreihenfolge der Ergebnisse. 0 bedeutet rückwärts.
+radar.sort = Sortiermethode der Ergebnisse.
+radar.output = Variable für das Ergebnis.
+
+unitradar.target = Einheitenfilter.
+unitradar.and = Weitere Filter.
+unitradar.order = Sortierreihenfolge der Ergebnisse. 0 bedeutet rückwärts.
+unitradar.sort = Sortiermethode der Ergebnisse.
+unitradar.output = Variable für das Ergebnis.
+
+control.of = Block, der gesteuert werden soll.
+control.unit = Zieleinheit / Zielblock. 
+control.shoot = Ob geschossen werden soll.
+
+unitlocate.enemy = Ob gegnerische Blöcke gesucht werden sollen.
+unitlocate.found = Ob der Block gefunden wurde.
+unitlocate.building = Variable für das Ergebnis.
+unitlocate.outx = Variable für die X-Koordinate.
+unitlocate.outy = Variable für die Y-Koordinate.
+unitlocate.group = Gesuchter Blocktyp.
+
+lenum.stop = Bewegung / Abbau / Bau abbrechen.
+lenum.move = Geht zu diese Position.
+lenum.approach = Geht auf einen Punkt mit einem bestimmten Radius zu.
+lenum.pathfind = Geht zum gegnerischen Spawnpunkt.
+lenum.target = Schießt auf eine Position.
+lenum.targetp = Schießt auf eine Einheit und sagt deren Position voraus.
+lenum.itemdrop = Items abwerfen.
+lenum.itemtake = Items aus einem Block nehmen.
+lenum.paydrop = Lässt einen Block / eine Einheit wieder fallen.
+lenum.paytake = Hebt einen Block / eine kleine Einheit auf.
+lenum.flag = Zahl, mit der eine Einheit identifiziert werden kann.
+lenum.mine = Erz von einer Position abbauen.
+lenum.build = Einen Block bauen.
+lenum.getblock = Gibt den Blocktyp an den Koordinaten zurück.\nEinheiten müssen nah genug dran sein.\nFeste nicht-Blöcke sind [accent]@solid[].
+lenum.within = Prüft, ob eine Einheit in einem Radius um einen Punkt ist.
+lenum.boost = Aktiviert / deaktiviert den Boost.

core/assets/bundles/bundle_ko.properties

@@ -4,10 +4,10 @@ contributors = 번역가와 기여자
 discord = Mindustry Discord 서버에 가입하세요!
 link.discord.description = Mindustry Discord 공식 대화방
 link.reddit.description = Mindustry 서브레딧
-link.github.description = Mindustry 개발 홈페이지
+link.github.description = Mindustry 소스코드
 link.changelog.description = 업데이트 내용 목록
 link.dev-builds.description = 불안정한 개발 버전
-link.trello.description = 출시 예정인 기능을 한다고 게시한 공식 Trello 보드
+link.trello.description = 출시 예정 기능 계획을 게시한 공식 Trello 보드
 link.itch.io.description = PC 다운로드가 있는 itch.io 페이지
 link.google-play.description = Google Play 스토어 목록
 link.f-droid.description = F-Droid 카탈로그 목록
@@ -22,7 +22,7 @@ gameover.disconnect = 연결 끊기
 gameover.pvp = [accent]{0}[] 팀이 승리했습니다!
 gameover.waiting = [accent]다음 맵 기다리는 중...
 highscore = [accent]새로운 최고 점수!
-copied = 복사 
+copied = 복사됨.
 indev.notready = 이 부분은 아직 준비되지 않았습니다.
 indev.campaign = [accent]당신은 캠페인의 끝에 도달했습니다![]\n\n이것으로 캠페인에 있는 대부분의 콘텐츠는 끝났으며, 행성 간 여행은 향후 업데이트에 추가될 예정입니다.
 
@@ -41,10 +41,11 @@ be.ignore = 무시
 be.noupdates = 업데이트가 없습니다.
 be.check = 업데이트 확인
 
-mod.featured.dialog.title = 모드 탐색 (WIP)
+mods.browser = 모드 탐색기
 mods.browser.selected = 선택된 모드
-mods.browser.add = 모드 설치
+mods.browser.add = 설치
-mods.github.open = 깃허브 사이트 열기
+mods.browser.reinstall = 재설치
+mods.github.open = 레포지토리 보기
 mods.browser.sortdate = 최근 업데이트
 mods.browser.sortstars = 추천(스타) 수
 
@@ -56,7 +57,7 @@ schematic.exists = 해당 이름의 설계도가 이미 존재합니다.
 schematic.import = 설계도 가져오기
 schematic.exportfile = 파일 내보내기
 schematic.importfile = 파일 가져오기
-schematic.browseworkshop = 창작마당 검색
+schematic.browseworkshop = 창작마당에 검색
 schematic.copy = 클립 보드에 복사
 schematic.copy.import = 클립 보드에서 가져오기
 schematic.shareworkshop = 창작마당에 공유
@@ -118,8 +119,10 @@ mods.none = [lightgray]모드를 찾을 수 없습니다!
 mods.guide = 모드 제작 가이드
 mods.report = 버그 제보하기
 mods.openfolder = 폴더 열기
+mods.viewcontent = 콘텐츠 보기
 mods.reload = 새로 고침
 mods.reloadexit = 게임이 종료된 후 모드를 불러올 것입니다.
+mod.installed = [[설치됨]
 mod.display = [gray]모드:[orange] {0}
 mod.enabled = [lightgray]활성화됨
 mod.disabled = [scarlet]비활성화됨
@@ -127,7 +130,7 @@ mod.disable = 비활성화
 mod.content = 콘텐츠:
 mod.delete.error = 모드를 삭제할 수 없습니다. 파일이 사용 중일 수 있습니다.
 mod.requiresversion = [scarlet]필요한 최소 게임 버전: [accent]{0}
-mod.outdated = [scarlet]V6 버전과 호환되지 않음 (minGameVersion이 105 이하인 모드는 사용할 수 없습니다.)
+mod.outdated = [scarlet]V6 버전과 호환되지 않음 (minGameVersion: 105 이상이 아님)
 mod.missingdependencies = [scarlet]누락된 필요 모드: {0}
 mod.erroredcontent = [scarlet]콘텐츠 오류
 mod.errors = 콘텐츠를 불러오는 중에 오류가 발생함.
@@ -139,8 +142,8 @@ mod.reloadrequired = [scarlet]재시작 필요
 mod.import = 모드 가져오기
 mod.import.file = 파일 가져오기
 mod.import.github = Github 에서 모드 가져오기
-mod.jarwarn = [scarlet]JAR 모드는 안전하지 않습니다.[]\n신뢰할 수 있는 모드 개발자에게서 얻은 모드만을 사용해야 합니다!
+mod.jarwarn = [scarlet]JAR 모드는 안전하지 않습니다.[]\n신뢰할 수 있는 개발자에게서 얻은 모드만을 사용해야 합니다!
-mod.item.remove = 이 자원은[accent] '{0}' 모드의 일부입니다. 이를 제거하려면 해당 모드를 제거하세요.
+mod.item.remove = 이 아이템은[accent] '{0}' 모드의 일부입니다. 이를 제거하려면 해당 모드를 제거하세요.
 mod.remove.confirm = 이 모드가 삭제될 것입니다.
 mod.author = [lightgray]제작자:[] {0}
 mod.missing = 이 저장 파일에는 최근에 업데이트되었거나 현재 기기에 설치되지 않은 모드가 포함되어 있습니다. 저장 파일이 손상될 수 있습니다. 정말로 불러오시겠습니까?\n[lightgray]모드들:\n{0}
@@ -150,10 +153,10 @@ mod.scripts.disable = 이 기기는 스크립트가 있는 모드를 지원하
 
 about.button = 정보
 name = 닉네임 : 
-noname = 먼저 [accent]닉네임[]을 설정하세요.
+noname = 먼저 [accent]플레이어 이름[]을 설정하세요.
 planetmap = 행성 지도
 launchcore = 코어 출격
-filename = 파일 이름 : 
+filename = 파일 이름: 
 unlocked = 새로운 콘텐츠가 해금되었습니다!
 available = 새로운 콘텐츠 해금이 가능합니다!
 completed = [accent]완료됨
@@ -173,17 +176,17 @@ server.closing = [accent]서버를 닫는 중...
 server.kicked.kick = 서버에서 추방되었습니다!
 server.kicked.whitelist = 당신은 이 서버의 화이트리스트에 등록되어 있지 않습니다.
 server.kicked.serverClose = 서버 닫힘.
-server.kicked.vote = 당신은 투표로 추방되었습니다. 안녕히 가세요!
+server.kicked.vote = 당신은 투표로 추방되었습니다. 안녕히 가세요.
 server.kicked.clientOutdated = 구버전 클라이언트입니다! 게임을 업데이트하세요!
 server.kicked.serverOutdated = 구버전 서버입니다! 호스트에게 업데이트를 요청하세요!
 server.kicked.banned = 당신은 이 서버에서 영구적으로 차단되었습니다.
-server.kicked.typeMismatch = 이 서버는 현재 빌드 유형과 호환되지 않습니다.
+server.kicked.typeMismatch = 이 서버는 현재 빌드와 호환되지 않습니다.
 server.kicked.playerLimit = 서버의 인원이 꽉 찼습니다. 빈 슬롯이 생길 때까지 기다려주세요.
 server.kicked.recentKick = 최근에 추방되었습니다.\n추방 쿨타임이 끝날 때까지 기다리세요.
 server.kicked.nameInUse = 이 서버에 해당 이름을 가진 사람이 있습니다.
 server.kicked.nameEmpty = 설정된 닉네임이 없습니다.
-server.kicked.idInUse = 당신은 이미 이 서버에 있습니다! 두 개의 계정으로 연결하는건 허용되지 않습니다.
+server.kicked.idInUse = 당신은 이미 이 서버에 있습니다! 두 개의 계정으로 연결하는 건 허용되지 않습니다.
-server.kicked.customClient = 이 서버는 사용자 정의 빌드를 지원하지 않습니다. 공식 버전을 다운로드 하세요.
+server.kicked.customClient = 이 서버는 사용자 정의 빌드를 지원하지 않습니다. 공식 버전을 내려받으세요.
 server.kicked.gameover = 게임 오버!
 server.kicked.serverRestarting = 서버가 다시 시작되고 있습니다.
 server.versions = 당신의 버전 : [accent] {0}[]\n서버 버전 : [accent] {1}[]
@@ -206,7 +209,7 @@ servers.remote = 원격 서버
 servers.global = 커뮤니티 서버
 
 servers.disclaimer = 커뮤니티 서버는 개발자가 소유하거나 제어하지 [accent]않습니다[].\n\n서버들은 전연령대에 적합하지 않은 사용자 지정 콘텐츠를 보유할 수도 있습니다.
-servers.showhidden = 서버 숨기기 / 보이기
+servers.showhidden = 숨겨진 서버 보이기/숨기기
 server.shown = 서버 숨기기
 server.hidden = 서버 보이기
 
@@ -219,7 +222,7 @@ trace.modclient = 사용자 지정 클라이언트: [accent]{0}
 invalidid = 잘못된 클라이언트 ID입니다! 버그 보고서를 보내주세요.
 server.bans = 차단 목록
 server.bans.none = 차단된 플레이어를 찾을 수 없습니다!
-server.admins = 관리자들
+server.admins = 관리자
 server.admins.none = 관리자를 찾을 수 없습니다!
 server.add = 서버 추가
 server.delete = 정말로 이 서버를 삭제하시겠습니까?
@@ -305,11 +308,12 @@ loading = [accent]불러오는중...
 reloading = [accent]모드 새로고침하는중...
 saving = [accent]저장중...
 respawn = [accent][[{0}][] 키를 눌러 코어에서 부활
-cancelbuilding = [accent][[{0}][] 를 눌러 건설 계획을 초기화
+cancelbuilding = [accent][[{0}][] 키를 눌러 건설 계획을 초기화
-selectschematic = [accent][[{0}][] 를 눌러 선택+복사
+selectschematic = [accent][[{0}][] 키를 눌러 선택+복사
-pausebuilding = [accent][[{0}][] 를 눌러 건설을 일시중지
+pausebuilding = [accent][[{0}][] 키를 눌러 건설을 일시중지
-resumebuilding = [scarlet][[{0}][] 를 눌러 건설을 재개
+resumebuilding = [scarlet][[{0}][] 키를 눌러 건설을 재개
-showui = [accent][[{0}][] 키를 눌러 UI를 활성화
+enablebuilding = [scarlet][[{0}][] 키를 눌러 건설을 활성
+showui = UI가 숨겨졌습니다. [accent][[{0}][] 키를 눌러 UI를 활성화하세요.
 wave = [accent]{0} 단계
 wave.cap = [accent]단계 {0}/{1}
 wave.waiting = 다음 단계까지[lightgray] {0}초
@@ -338,10 +342,10 @@ workshop.error = 창작마당 세부 사항을 가져오는 중 오류가 발생
 map.publish.confirm = 이 맵을 게시하시겠습니까?\n\n[lightgray]창작마당 EULA에 먼저 동의해야 하며, 그렇지 않으면 맵이 표시되지 않습니다!
 workshop.menu = 이 아이템으로 수행 할 작업을 선택하십시오.
 workshop.info = 아이템 정보
-changelog = 변경 점 (선택 사항) :
+changelog = 변경점 (선택 사항):
 eula = 스팀 EULA
 missing = 이 아이템은 삭제되거나 이동되었습니다.\n[lightgray]창작마당 목록이 자동으로 연결 해제되었습니다.
-publishing = [accent]업로드 중...
+publishing = [accent]게시 중...
 publish.confirm = 이것을 게시하시겠습니까?[lightgray]창작마당 EULA에 동의해야 합니다. 그렇지 않으면 아이템이 표시되지 않습니다!
 publish.error = 아이템 게시 오류: {0}
 steam.error = 스팀 서비스를 초기화하지 못했습니다.\n오류: {0}
@@ -375,7 +379,7 @@ waves.edit = 편집
 waves.copy = 클립보드로 복사
 waves.load = 클립보드에서 불러오기
 waves.invalid = 클립보드에 잘못된 단계 데이터가 있습니다.
-waves.copied = 단계 복사됨
+waves.copied = 단계 복사됨.
 waves.none = 적 단계가 설정되지 않았습니다.\n비어있을 시 자동으로 기본 적 단계 데이터로 설정됩니다.
 
 #these are intentionally in lower case
@@ -384,8 +388,8 @@ wavemode.totals = 총
 wavemode.health = 체력
 
 editor.default = [lightgray]<기본값>
-details = 설명
+details = 설명...
-edit = 편집
+edit = 편집...
 editor.name = 이름:
 editor.spawn = 유닛 생성
 editor.removeunit = 유닛 삭제
@@ -415,7 +419,7 @@ editor.importfile = 파일 가져오기
 editor.importfile.description = 외부 맵 파일 가져오기
 editor.importimage = 사진 파일 가져오기
 editor.importimage.description = 외부 맵 사진 파일 가져오기
-editor.export = 내보내기
+editor.export = 내보내기...
 editor.exportfile = 파일 내보내기
 editor.exportfile.description = 맵 파일 내보내기
 editor.exportimage = 지형 이미지 내보내기
@@ -448,15 +452,15 @@ toolmode.drawteams.description = 블록 대신 선택한 팀으로 블록 팀을
 filters.empty = [lightgray]필터가 없습니다! 아래 버튼을 눌러 하나를 추가하세요.
 filter.distort = 왜곡
 filter.noise = 노이즈
-filter.enemyspawn = 적 소환지점 제한
+filter.enemyspawn = 적 소환지점 선택
 filter.spawnpath = 자동생성된 적 이동경로 폭
-filter.corespawn = 코어 1개 제한
+filter.corespawn = 코어 선택
 filter.median = 중앙값
-filter.oremedian = 자원 중앙값
+filter.oremedian = 광물 중앙값
-filter.blend = 블렌드
+filter.blend = 가장자리
-filter.defaultores = 기본 자원
+filter.defaultores = 기본 광물
-filter.ore = 자원
+filter.ore = 광물
-filter.rivernoise = 협곡 노이즈
+filter.rivernoise = 강 노이즈
 filter.mirror = 거울
 filter.clear = 초기화
 filter.option.ignore = 무시
@@ -465,19 +469,19 @@ filter.terrain = 지형
 filter.option.scale = 크기
 filter.option.chance = 배치 빈도
 filter.option.mag = 크기
-filter.option.threshold = 경계선
+filter.option.threshold = 한계점
 filter.option.circle-scale = 원 크기
 filter.option.octaves = 옥타브
 filter.option.falloff = 경사
 filter.option.angle = 각도
 filter.option.amount = 개수
 filter.option.block = 블록
-filter.option.floor = 배치할 타일
+filter.option.floor = 타일
 filter.option.flooronto = 대상 타일
-filter.option.target = 대상 타일
+filter.option.target = 대상
 filter.option.wall = 벽
-filter.option.ore = 자원
+filter.option.ore = 광물
-filter.option.floor2 = 2층 바닥
+filter.option.floor2 = 2번째 타일
 filter.option.threshold2 = 2번째 경계선
 filter.option.radius = 반경
 filter.option.percentile = 백분율
@@ -488,7 +492,7 @@ menu = 메뉴
 play = 플레이
 campaign = 캠페인
 load = 불러오기
-save = 저장
+save = 저장하기
 fps = FPS: {0}
 ping = Ping: {0}ms
 memory = Mem: {0}mb
@@ -519,7 +523,7 @@ loadout = 출격
 resources = 자원
 bannedblocks = 금지된 블록들
 addall = 모두 추가
-launch.from = 점령 코어 송신 지역 : [accent]{0}
+launch.from = 출격 출발지 : [accent]{0}
 launch.destination = 목적지: {0}
 configure.invalid = 해당 값은 0에서 {0} 사이의 숫자여야 합니다.
 add = 추가...
@@ -534,7 +538,7 @@ error.alreadyconnected = 이미 접속 중입니다.
 error.mapnotfound = 맵 파일을 찾을 수 없습니다!
 error.io = 네트워크 I/O 오류.
 error.any = 알 수 없는 네트워크 오류.
-error.bloom = 블룸 그래픽 효과를 적용하지 못했습니다.\n당신의 기기가 이 기능을 지원하지 않는 것일 수도 있습니다.
+error.bloom = 블룸 그래픽 효과를 적용하지 못했습니다.\n기기가 이 기능을 지원하지 않는 것일 수도 있습니다.
 
 weather.rain.name = 비
 weather.snow.name = 눈
@@ -544,27 +548,27 @@ weather.fog.name = 안개
 
 sectors.unexplored = [lightgray]미개척지
 sectors.resources = 자원:
-sectors.production = 분당 자원 생산량:
+sectors.production = 생산량:
-sectors.export = 분당 자원 수출량:
+sectors.export = 수출량:
-sectors.time = 지역 진행 시간:
+sectors.time = 진행 시간:
-sectors.threat = 지역 위험도:
+sectors.threat = 위험도:
-sectors.wave = 진행 중 단계:
+sectors.wave = 단계:
-sectors.stored = 저장된 자원 목록:
+sectors.stored = 저장량:
 sectors.resume = 재개
 sectors.launch = 출격
 sectors.select = 선택
 sectors.nonelaunch = [lightgray]없음 (sun)
 sectors.rename = 구역 이름 변경
 sectors.enemybase = [scarlet]적 기지
-sectors.vulnerable = [scarlet]취약
+sectors.vulnerable = [scarlet]취약함
 sectors.underattack = [scarlet]공격받고 있습니다! [accent]{0}% 손상됨.
 sectors.survives = [accent]{0} 단계 이상 버티세요.
-sectors.go = 지역 진입
+sectors.go =진입
-sector.curcapture = 점령지
+sector.curcapture = 지역 점령됨
-sector.curlost = 잃은 지역
+sector.curlost = 지역 잃음
 sector.missingresources = [scarlet]자원 부족
 sector.attacked = [accent]{0}[white] 지역이 공격받고 있습니다!
-sector.lost = [accent]{0}[white] 지역을 잃었습니다...
+sector.lost = [accent]{0}[white] 지역을 잃었습니다!
 #note: the missing space in the line below is intentional
 sector.captured = [accent]{0}[white] 지역을 점령했습니다!
 
@@ -580,7 +584,7 @@ planet.serpulo.name = 세르플로
 planet.sun.name = 태양
 
 sector.impact0078.name = 폐허 : Impact 0078
-sector.groundZero.name = Zero 전초기지
+sector.groundZero.name = 전초기지
 sector.craters.name = 크레이터
 sector.frozenForest.name = 얼어붙은 숲
 sector.ruinousShores.name = 파괴된 해안가
@@ -599,15 +603,15 @@ sector.planetaryTerminal.name = 대행성 출격단지
 sector.groundZero.description = 이 장소는 다시 시작하기에 최적의 환경을 지닌 장소입니다. 적의 위협 수준이 낮으며, 자원이 거의 없습니다.\n가능 한 많은 양의 구리와 납을 수집하세요.\n이제 출격할 시간입니다!
 sector.frozenForest.description = 이곳에서도, 산에 가까운 곳에 포자가 퍼졌습니다. 추운 온도에서도 포자들을 막을 수 없을 것 같습니다.\n화력 발전기를 건설하고, 멘더를 사용하는 방법을 배우세요.
 sector.saltFlats.description = 이 소금 사막은 매우 척박하여 자원이 거의 없습니다.\n하지만 자원이 희소한 이곳에서도 적들의 요새가 발견되었습니다. 그들을 사막의 모래로 만들어버리십시오.
-sector.craters.description = 물이 가득한 이 크레이터에는 옛 전쟁의 유물들이 쌓여있습니다.\n이곳을 다시 점령해 강화 유리를 제작하고 물을 끌어 올려 포탑과 드릴에 공급하여 더 좋은 효율로 방어선을 강화하십시오.
+sector.craters.description = 물이 가득한 이 크레이터에는 옛 전쟁의 유물들이 쌓여있습니다.\n이곳을 다시 점령해 강화 유리를 제작하고 물을 끌어올려 포탑과 드릴에 공급하여 더 좋은 효율로 방어선을 강화하십시오.
 sector.ruinousShores.description = 이 지역은 과거 해안방어기지로 사용되었습니다.\n그러나 지금은 기본구조물만 남아있으니 이 지역을 어서 신속히 수리하여 외부로 세력을 확장한 뒤, 잃어버린 기술을 다시 회수하십시오.
 sector.stainedMountains.description = 더 안쪽에는 포자에 오염된 산맥이 있지만, 이곳은 아직 포자에 오염되지 않았습니다.\n이 지역에서 티타늄을 채굴하고 이것을 어떻게 사용하는지 배우십시오.\n\n적들은 이곳에서 더 강력합니다. 더 강한 유닛들이 나올 때까지 시간을 낭비하지 마십시오.
-sector.overgrowth.description = 이곳은 포자들의 근원과 가까이에 있는 과성장 지대입니다. 적이 이 곳에 전초기지를 설립했습니다. 디거를 생산해 적의 코어를 박살 내고 우리가 잃어버린 것들을 되돌려받으십시오!
+sector.overgrowth.description = 이곳은 포자들의 근원과 가까이에 있는 과성장 지대입니다. 적이 이곳에 전초기지를 설립했습니다. 대거를 생산해 적의 코어를 박살 내고 우리가 잃어버린 것들을 되돌려받으십시오!
 sector.tarFields.description = 산지와 사막 사이에 있는 석유 생산지의 외곽 지역이며, 사용 가능한 타르가 매장되어 있는 희귀한 지역 중 하나입니다. 버려진 지역이지만 이곳에는 위험한 적군들이 있습니다. 그들을 과소평가하지 마십시오.\n\n[lightgray]석유 생산기술을 익히는 것이 도움이 될 것입니다.
 sector.desolateRift.description = 극도로 위험한 지역입니다. 자원은 풍부하지만, 사용 가능한 공간은 거의 없습니다. 코어 파괴의 위험성이 높으니 가능한 한 빨리 떠나십시오. 또한, 적의 공격 딜레이가 길다고 안심하지 마십시오.
 sector.nuclearComplex.description = 과거 토륨의 생산, 연구와 처리를 위해 운영되었던 시설입니다. 지금은 그저 폐허로 전락했으며, 다수의 적이 배치된 지역입니다. 그들은 끊임없이 당신을 공격할 것입니다.\n\n[lightgray]토륨의 다양한 사용법을 연구하고 익히십시오.
-sector.fungalPass.description = 높은 산과 낮은 땅 사이의 전환 지역. 작은 적 정찰 기지가 여기에 있습니다.\n그것들을 파괴하세요.\n대거와 크롤러 유닛을 사용하여 두개의 코어를 파괴하세요.
+sector.fungalPass.description = 높은 산과 낮은 땅 사이의 전환 지역. 작은 적 정찰 기지가 여기에 있습니다.\n그것들을 파괴하세요.\n대거와 크롤러 유닛을 사용하여 두 개의 코어를 파괴하세요.
-sector.biomassFacility.description = 포자의 시작이 되는 지역입니다. 이 시설은 포자를 연구하고 그것들을 가장 처음 생산했습니다.\n이 시설에 기록된 기술을 배우고, 연료와 플라스터늄을 생산하기 위해 포자를 배양하세요. \n\n[lightgray]이 시설이 붕괴된 후에, 시설 내에 배양되던 포자들이 외부로 방출되었습니다. 이로 인해 생태계 교란종인 포자가 지역 생태계에서 번식하게 되었고, 그 무엇도 이 무자비하고 작은 침략자에게 대항할 수 없었습니다.
+sector.biomassFacility.description = 포자의 시작이 되는 지역입니다. 이 시설은 포자를 연구하고 그것들을 가장 처음 생산했습니다.\n이 시설에 기록된 기술을 배우고, 연료와 플라스터늄을 생산하기 위해 포자를 배양하세요. \n\n[lightgray]이 시설이 붕괴한 후에, 시설 내에 배양되던 포자들이 외부로 방출되었습니다. 이로 인해 생태계 교란종인 포자가 지역 생태계에서 번식하게 되었고, 그 무엇도 이 무자비하고 작은 침략자에게 대항할 수 없었습니다.
 sector.windsweptIslands.description = 육지에서 멀리 떨어진 이곳에는 작은 군도가 있습니다. 이 지역을 조사해보면 한 때 [accent]플라스터늄[]을 생산한 흔적이 남아있습니다.\n\n몰려오는 적 해군을 막으며, 섬에 기지를 건설하고, 공장들을 연구하십시오.
 sector.extractionOutpost.description = 적이 다른 지역에 자원을 보내기 위한 용도로 건설한 보급기지입니다.\n\n강력한 적들이 지키고 있거나, 침공해올 예정인 지역을 효과적으로 침공/수호하기 위해서는 우리도 이 수송 기술이 필요합니다. 적의 기지를 파괴하고, 그들의 수송 기술을 약탈하십시오.
 sector.impact0078.description = 이곳에는 시스템에 처음 진입한 우주 수송선의 잔해가 있습니다.\n\n우주선이 파괴된 잔해에서 최대한 많은 자원을 회수하고, 손상되지 않은 그들의 기술을 획득하세요.
@@ -615,9 +619,9 @@ sector.planetaryTerminal.description = 이 행성에서의 마지막 전투를
 
 settings.language = 언어
 settings.data = 게임 데이터
-settings.reset = 설정 초기화
+settings.reset = 기본값으로 초기화
-settings.rebind = 조작키 설정
+settings.rebind = 설정
-settings.resetKey = 조작키 설정 초기화
+settings.resetKey = 초기화
 settings.controls = 조작
 settings.game = 게임
 settings.sound = 소리
@@ -633,14 +637,14 @@ settings.clearcampaignsaves = 캠페인 맵 초기화
 settings.clearcampaignsaves.confirm = 정말로 캠페인을 초기화하시겠습니까?
 paused = [accent]< 일시정지 >
 clear = 초기화
-banned = [scarlet]차단됨
+banned = [scarlet]금지됨
 yes = O
 no = X
 info.title = 정보
-error.title = [scarlet]오류가 발생했습니다.
+error.title = [scarlet]오류가 발생했습니다
-error.crashtitle = 오류가 발생했습니다.
+error.crashtitle = 오류가 발생했습니다
 unit.nobuild = [scarlet]건설 불가
-lastaccessed = [lightgray]마지막 조작: {0}
+lastaccessed = [lightgray]마지막 접근: {0}
 block.unknown = [lightgray]???
 
 stat.description = 특성
@@ -649,63 +653,65 @@ stat.output = 출력
 stat.booster = 가속
 stat.tiles = 필요한 타일
 stat.affinities = 친화력
-stat.powercapacity = 전력량
+stat.powercapacity = 전력 용량
-stat.powershot = 전력량/발
+stat.powershot = 전력/발
-stat.damage = 공격력
+stat.damage = 피해량
-stat.targetsair = 공중 공격
+stat.targetsair = 공중 조준
-stat.targetsground = 지상 공격
+stat.targetsground = 지상 조준
 stat.itemsmoved = 이동 속도
-stat.launchtime = 발사 간격
+stat.launchtime = 출격 간격
 stat.shootrange = 사거리
 stat.size = 크기
 stat.displaysize = 화면 크기
-stat.liquidcapacity = 액체 수용량
+stat.liquidcapacity = 액체 용량
 stat.powerrange = 전선 길이
-stat.linkrange = 감지 길이
+stat.linkrange = 연결 길이
 stat.instructions = 연산 속도
-stat.powerconnections = 최대 연결 개수
+stat.powerconnections = 최대 연결
 stat.poweruse = 전력 요구량
-stat.powerdamage = 전력량/피해량
+stat.powerdamage = 전력/피해량
-stat.itemcapacity = 자원 수용량
+stat.itemcapacity = 자원 용량
-stat.memorycapacity = 최대 변수 개수
+stat.memorycapacity = 변수 용량
-stat.basepowergeneration = 기본 발전량
+stat.basepowergeneration = 기본 전력 발전량
 stat.productiontime = 소요 시간
-stat.repairtime = 건물 완전 복구 시간
+stat.repairtime = 건물 완전 수리 시간
 stat.weapons = 무기
 stat.bullet = 탄환
 stat.speedincrease = 속도 증가
 stat.range = 사거리
-stat.drilltier = 채굴 가능 자원
+stat.drilltier = 채굴 가능
 stat.drillspeed = 기본 채굴 속도
 stat.boosteffect = 버프 효과
 stat.maxunits = 최대 유닛 수
 stat.health = 체력
+stat.armor = 방어력
 stat.buildtime = 건설 시간
-stat.maxconsecutive = 최대 체인 길이
+stat.maxconsecutive = 최대 체인
 stat.buildcost = 건설 비용
 stat.inaccuracy = 오차각
-stat.shots = 발사 당 탄
+#stat.shots = 발사 수 (안쓰임)
-stat.reload = 발/초
+stat.reload = 초당 발사 수
 stat.ammo = 탄약
 stat.shieldhealth = 보호막 체력
 stat.cooldowntime = 쿨타임
 stat.explosiveness = 폭발성
 stat.basedeflectchance = 기본 반사 확률
 stat.lightningchance = 전격 확률
-stat.lightningdamage = 전격 공격량
+stat.lightningdamage = 전격 피해량
-stat.flammability = 휘발성
+stat.flammability = 인화성
 stat.radioactivity = 방사성
-stat.heatcapacity = 열용량
+stat.charge = 과충전율
+stat.heatcapacity = 열 용량
 stat.viscosity = 점성
 stat.temperature = 온도
 stat.speed = 속도
 stat.buildspeed = 건설 속도
 stat.minespeed = 채굴 속도
 stat.minetier = 채굴 티어
-stat.payloadcapacity = 화물 수용량
+stat.payloadcapacity = 화물 용량
 stat.commandlimit = 지휘 한계
 stat.abilities = 능력
-stat.canboost = 부스터
+stat.canboost = 이륙 가능
 stat.flying = 비행
 stat.ammouse = 탄약 사용
 
@@ -716,9 +722,9 @@ ability.unitspawn = {0} 공장
 ability.shieldregenfield = 방어막 복구 필드
 ability.movelightning = 가속 전격
 
-bar.drilltierreq = 더 좋은 드릴이 필요
+bar.drilltierreq = 더 좋은 드릴 필요
 bar.noresources = 자원 부족
-bar.corereq = 코어 필요
+bar.corereq = 기본 코어 필요
 bar.drillspeed = 드릴 속도: {0}/s
 bar.pumpspeed = 펌프 속도: {0}/s
 bar.efficiency = 효율: {0}%
@@ -734,14 +740,14 @@ bar.unitcap = {0} {1}/{2}
 bar.liquid = 액체
 bar.heat = 발열
 bar.power = 전력
-bar.progress = 생산 진행도
+bar.progress = 건설 진행도
 bar.input = 입력
 bar.output = 출력
 
-units.processorcontrol = [lightgray]프로세서 제어 중
+units.processorcontrol = [lightgray]프로세서 제어됨
 
-bullet.damage = [stat]{0}[lightgray] 데미지
+bullet.damage = [stat]{0}[lightgray] 피해량
-bullet.splashdamage = [stat]{0}[lightgray] 범위 데미지 ~ [stat] {1}[lightgray] 타일
+bullet.splashdamage = [stat]{0}[lightgray] 범위 피해량 ~ [stat] {1}[lightgray] 타일
 bullet.incendiary = [stat]방화
 bullet.sapping = [stat]흡혈
 bullet.homing = [stat]유도
@@ -749,7 +755,7 @@ bullet.shock = [stat]전격
 bullet.frag = [stat]파편
 bullet.buildingdamage = [stat]{0}%[lightgray] 건물 피해량
 bullet.knockback = [stat]{0}[lightgray] 넉백
-bullet.pierce = [stat]{0}[lightgray]배 관통
+bullet.pierce = [stat]{0}[lightgray]번 관통
 bullet.infinitepierce = [stat]관통
 bullet.healpercent = [stat]{0}[lightgray]% 회복
 bullet.freezing = [stat]빙결
@@ -761,7 +767,7 @@ unit.blocks = 블록
 unit.blockssquared = 블록²
 unit.powersecond = 전력/초
 unit.liquidsecond = 액체/초
-unit.itemssecond = 개/초
+unit.itemssecond = 자원/초
 unit.liquidunits = 액체
 unit.powerunits = 전력
 unit.degrees = 도
@@ -777,19 +783,20 @@ unit.thousands = k
 unit.millions = m
 unit.billions = b
 unit.pershot = /발
-category.purpose = 기능 / 목적
+category.purpose = 목적
 category.general = 일반
 category.power = 전력
 category.liquids = 액체
 category.items = 자원
 category.crafting = 입력/출력
 category.function = 기능
-category.optional = 보조 자원
+category.optional = 선택적 향상
 setting.landscape.name = 가로화면 잠금
 setting.shadows.name = 그림자
 setting.blockreplace.name = 자동 블록 제안
 setting.linear.name = 선형 필터링
-setting.hints.name = 힌트
+setting.hints.name = 힌트 표시
+setting.logichints.name = 로직 힌트 표시
 setting.flow.name = 자원 흐름량 표시
 setting.backgroundpause.name = 백그라운드에서 일시정지
 setting.buildautopause.name = 건설 자동 일시정지
@@ -813,14 +820,14 @@ setting.difficulty.hard = 혼돈
 setting.difficulty.insane = 박멸
 setting.difficulty.name = 난이도:
 setting.screenshake.name = 화면 흔들림
-setting.effects.name = 효과 보임
+setting.effects.name = 효과 표시
 setting.destroyedblocks.name = 파괴된 블록 표시
 setting.blockstatus.name = 블록 상태 표시
-setting.conveyorpathfinding.name = 컨베이어를 배치할 때 자동으로 경로 찾기
+setting.conveyorpathfinding.name = 컨베이어 배치 길찾기
 setting.sensitivity.name = 컨트롤러 감도
 setting.saveinterval.name = 저장 간격
 setting.seconds = {0}초
-setting.milliseconds = {0}ms
+setting.milliseconds = {0} 밀리초
 setting.fullscreen.name = 전체 화면
 setting.borderlesswindow.name = 테두리 없는 창 모드[lightgray] (재시작이 필요할 수 있습니다)
 setting.fps.name = FPS와 핑 표시
@@ -838,7 +845,7 @@ setting.sfxvol.name = 효과음 크기
 setting.mutesound.name = 소리 끄기
 setting.crashreport.name = 익명으로 오류 보고서 자동 전송
 setting.savecreate.name = 자동 저장 활성화
-setting.publichost.name = 멀티플레이 공용 서버로 표시
+setting.publichost.name = 공용 서버로 표시
 setting.playerlimit.name = 플레이어 제한
 setting.chatopacity.name = 채팅창 투명도
 setting.lasersopacity.name = 전선 투명도
@@ -858,7 +865,7 @@ category.view.name = 보기
 category.multiplayer.name = 멀티플레이어
 category.blocks.name = 블록 선택
 command.attack = 공격
-command.rally = 순찰
+command.rally = 집결
 command.retreat = 후퇴
 command.idle = 대기
 placement.blockselectkeys = \n[lightgray]단축키: [{0},
@@ -874,13 +881,13 @@ keybind.move_x.name = X축 이동
 keybind.move_y.name = Y축 이동
 keybind.mouse_move.name = 커서를 따라서 이동
 keybind.pan.name = 펜 보기
-keybind.boost.name = 비행
+keybind.boost.name = 이륙
 keybind.schematic_select.name = 영역 설정
 keybind.schematic_menu.name = 설계도 메뉴
 keybind.schematic_flip_x.name = 설계도 X축 뒤집기
 keybind.schematic_flip_y.name = 설계도 Y축 뒤집기
-keybind.category_prev.name = 이전 목록
+keybind.category_prev.name = 이전 카테고리
-keybind.category_next.name = 다음 목록
+keybind.category_next.name = 다음 카테고리
 keybind.block_select_left.name = 블록 왼쪽 선택
 keybind.block_select_right.name = 블록 오른쪽 선택
 keybind.block_select_up.name = 블록 위쪽 선택
@@ -905,7 +912,7 @@ keybind.pickupCargo.name = 화물 집기
 keybind.dropCargo.name = 화물 내려놓기
 keybind.command.name = 명령
 keybind.shoot.name = 사격
-keybind.zoom.name = 확대
+keybind.zoom.name = 확대/축소
 keybind.menu.name = 메뉴
 keybind.pause.name = 일시중지
 keybind.pause_building.name = 건설 일시정지/재개
@@ -922,13 +929,13 @@ keybind.chat_history_prev.name = 이전 채팅 기록
 keybind.chat_history_next.name = 다음 채팅 기록
 keybind.chat_scroll.name = 채팅 스크롤
 keybind.chat_mode = 대화 대상 변경
-keybind.drop_unit.name = 유닛 떨구기
+keybind.drop_unit.name = 유닛 내려놓기
 keybind.zoom_minimap.name = 미니맵 확대
 mode.help.title = 모드 설명
 mode.survival.name = 생존
 mode.survival.description = 기본 모드. 제한된 자원이 있으며, 단계가 자동으로 시작합니다.\n[gray]플레이하려면 맵에 적의 스폰지점이 필요합니다.
 mode.sandbox.name = 샌드박스
-mode.sandbox.description = 무한한 자원이 있으며, 단계 타이머가 없습니다.
+mode.sandbox.description = 무한한 자원이 있으며, 시간 제한이 없습니다.
 mode.editor.name = 편집기
 mode.pvp.name = PvP
 mode.pvp.description = 다른 플레이어와 현장에서 싸우십시오.\n[gray]플레이하려면 맵에 다른 색상의 코어가 2개 이상 있어야 합니다.
@@ -941,7 +948,7 @@ rules.reactorexplosions = 원자로 폭발 허용
 rules.coreincinerates = 코어 방화 비허용
 rules.schematic = 설계도 허용
 rules.wavetimer = 시간 제한이 있는 단계
-rules.waves = 일반 단계
+rules.waves = 단계
 rules.attack = 공격 모드
 rules.buildai = AI 건설
 rules.enemyCheat = 무한 AI (빨간팀) 자원
@@ -950,26 +957,28 @@ rules.blockdamagemultiplier = 블록 공격력 배수
 rules.unitbuildspeedmultiplier = 유닛 생산 속도 배수
 rules.unithealthmultiplier = 유닛 체력 배수
 rules.unitdamagemultiplier = 유닛 공격력 배수
+rules.unitcapvariable = 코어 유닛 제한 추가
+rules.unitcap = 기본 유닛 제한
 rules.enemycorebuildradius = 적 코어 건설 금지구역 범위:[lightgray] (타일)
 rules.wavespacing = 단계 간격:[lightgray] (초)
-rules.buildcostmultiplier = 건설 자원소모 배수
+rules.buildcostmultiplier = 건설 비용 배수
 rules.buildspeedmultiplier = 건설 속도 배수
-rules.deconstructrefundmultiplier = 해체 환불 배수
+rules.deconstructrefundmultiplier = 철거 환불 배수
 rules.waitForWaveToEnd = 한 단계가 끝날때까지 대기
 rules.dropzoneradius = 스폰 구역 범위: [lightgray] (타일)
-rules.unitammo = 탄약 필요
+rules.unitammo = 유닛 탄약 필요
 rules.title.waves = 단계
 rules.title.resourcesbuilding = 자원 & 건축
 rules.title.enemy = 적
 rules.title.unit = 유닛
 rules.title.experimental = 실험적인 기능
 rules.title.environment = 환경
-rules.lighting = 조명
+rules.lighting = 조명 표시
 rules.enemyLights = 상대에게 조명 표시
-rules.fire = 방화
+rules.fire = 방화 허용
 rules.explosions = 블록/유닛 폭발 데미지
 rules.ambientlight = 자연 조명 표시
-rules.weather = 날씨
+rules.weather = 날씨 추가
 rules.weather.frequency = 빈도:
 rules.weather.always = 항상 
 rules.weather.duration = 지속 시간:
@@ -1038,8 +1047,8 @@ unit.corvus.name = 코르버스
 block.resupply-point.name = 보급 지점
 block.parallax.name = 패럴랙스
 block.cliff.name = 언덕
-block.sand-boulder.name = 사암
+block.sand-boulder.name = 사암 바위
-block.basalt-boulder.name = 현무암
+block.basalt-boulder.name = 현무암 바위
 block.grass.name = 잔디
 block.slag.name = 용암
 block.space.name = 우주
@@ -1264,43 +1273,43 @@ team.purple.name = 보라색 팀
 
 hint.skip = 힌트 넘기기
 hint.desktopMove = [accent][[WASD][] 키를 이용해 자신의 유닛을 조종하세요.
-hint.zoom = [accent]마우스 스크롤[]를 사용해 확대 또는 축소가 가능합니다.
+hint.zoom = [accent]마우스 스크롤[]을 사용해 확대 또는 축소가 가능합니다.
-hint.mine =  \uf8c4 주변의 구리광석을 수동으로 채굴하려면 광석을 [accent]누르십시오[]. (추가설명)마우스가 있을 경우 마우스 오른쪽 클릭을 하면 채굴 중단이 가능합니다.
+hint.mine =\uf8c4 주변의 구리 광석을 수동으로 채굴하려면 광석을 [accent]누르십시오[]. (추가 설명) 마우스가 있으면 마우스 오른쪽 클릭을 하면 채굴 중단이 가능합니다.
-hint.desktopShoot = [accent][[마우스 왼클릭][]으로 발사할수 있습니다. 
+hint.desktopShoot = [accent][[마우스 좌클릭][]으로 발사할 수 있습니다.
-hint.depositItems = 자원을 코어로 옮기려면, 당신의 기체의 자원을 코어로 끌어놓으세요.
+hint.depositItems = 자원을 코어로 옮기려면, 기체의 자원을 코어로 끌어놓으세요.
-hint.respawn = 당신의 기체를 떠나려면 [accent][[V][]를 누르십시오.
+hint.respawn = 기체를 떠나려면 [accent][[V][]를 누르십시오.
-hint.respawn.mobile = 당신은 유닛 혹은 포탑을 조종할 수 있습니다. 당신의 기체를 떠나려면 [accent]왼쪽 위에 있는 아바타를 누르십시오.[]
+hint.respawn.mobile = 유닛 혹은 포탑을 조종할 수 있습니다. 기체를 떠나려면 [accent]왼쪽 위에 있는 아바타를 누르십시오.[]
-hint.desktopPause = 게임을 일시정지/재시작 하기 위해 [accent][[Space][]를 누르십시오.
+hint.desktopPause = 게임을 일시 정지/재시작하기 위해 [accent][[Space][]를 누르십시오.
 hint.placeDrill = 드릴을 설치하려면 오른쪽 아래의 \ue85e [accent]드릴[]을 선택하고, \uf870 [accent]드릴[]을 선택해서 구리 광석 위를 누르십시오.
-hint.placeDrill.mobile = 오른쪽 아래 메뉴의 \ue85e [accent]드릴[]을 선택하고, \uf870 [accent]드릴[] 를 선택해서 구리 광석 위를 누르십시오.\n\n설치를 완료하려면 오른쪽 아래의 \ue800 [accent]완료 버튼[]을 누르십시오.
+hint.placeDrill.mobile = 오른쪽 아래 메뉴의 \ue85e [accent] 드릴[]을 선택하고, \uf870 [accent]드릴[]을 선택해서 구리 광석 위를 누르십시오.\n\n설치를 완료하려면 오른쪽 아래의 \ue800 [accent]완료 버튼[]을 누르십시오.
-hint.placeConveyor = 컨베이어는 자원을 드릴에서 다른 블록으로 이동시켜줍니다. \ue814 [accent]분배[] 카테고리에서 \uf896 [accent]컨베이어[]를 선택하십시오.\n\n클릭하거나 드래그로 다수의 컨베이어를 설치할 수 있습니다.\n클릭하고 놓지 않은채로 마우스 [accent]휠을 돌리면 돌아갑니다.
+hint.placeConveyor = 컨베이어는 자원을 드릴에서 다른 블록으로 이동시켜줍니다. \ue814 [accent]분배[] 카테고리에서 \uf896 [accent]컨베이어[]를 선택하십시오.\n\n클릭하거나 드래그로 다수의 컨베이어를 설치할 수 있습니다.\n클릭하고 놓지 않은 채로 마우스 [accent]휠을 돌리면 돌아갑니다.
-hint.placeConveyor.mobile = 컨베이어는 자원을 드릴에서 다른 블록으로 이동시켜줍니다. \ue814 [accent]분배[] 카테고리에서 \uf896 [accent]컨베이어[]를 선택하십시오.\n\n여러개의 컨베이어를 놓으려면 손가락으로 누른채로 끌어서 설치 범위를 지정하십시오.
+hint.placeConveyor.mobile = 컨베이어는 자원을 드릴에서 다른 블록으로 이동시켜줍니다. \ue814 [accent]분배[] 카테고리에서 \uf896 [accent]컨베이어[]를 선택하십시오.\n\n여러 개의 컨베이어를 놓으려면 손가락으로 누른 채로 끌어서 설치 범위를 지정하십시오.
-hint.placeTurret = 적에게서 당신의 기지를 막아내려면 \uf861 [accent]포탑[]를 설치하십시오.\n\n포탑 탄약 필요 - 지금은 \uf838 구리가 필요합니다.\n컨베이어를 사용해 드릴에 구리를 공급하십시오. 
+hint.placeTurret = 적에게서 기지를 막아내려면 \uf861 [accent]포탑[]를 설치하십시오.\n\n포탑 탄약 필요 - 지금은 \uf838 구리가 필요합니다.\n컨베이어를 사용해 드릴에 구리를 공급하십시오.
-hint.breaking = 블록을 부수려면 [accent]오른클릭[]이나 드래그를 하십시오.
+hint.breaking = 블록을 부수려면 [accent]우클릭[]이나 드래그를 하십시오.
-hint.breaking.mobile = 블록을 부수려면 오른쪽 아래의 \ue817 [accent]망치[]를 눌러 해체 모드를 활성화 하십시오.\n\n손가락으로 누른채로 끌어서 해체 범위를 지정하십시오.
+hint.breaking.mobile = 블록을 부수려면 오른쪽 아래의 \ue817 [accent]망치[]를 눌러 해체 모드를 활성화하십시오.\n\n손가락으로 누른 채로 끌어서 해체 범위를 지정하십시오.
 hint.research = 새 기술을 연구하려면 \ue875 [accent]연구[]버튼을 누르십시오.
 hint.research.mobile = 새 기술을 연구하려면 \ue88c [accent]메뉴[] 아래의 \ue875 [accent]연구[]버튼을 누르십시오.
-hint.unitControl = 아군 유닛과 포탑을 조종하려면 [accent][[왼쪽 ctrl][]을 누른채로 [accent]클릭[] 하십시오.
+hint.unitControl = 아군 유닛과 포탑을 조종하려면 [accent][[왼쪽 ctrl][]을 누른 채로 [accent]클릭[] 하십시오.
-hint.unitControl.mobile = 아군 유닛과 포탑을 조종하려면 해당 개체를 [accent]빠르게 두번 누르십시오[].
+hint.unitControl.mobile = 아군 유닛과 포탑을 조종하려면 해당 개체를 [accent]빠르게 두 번 누르십시오[].
 hint.launch = 충분한 자원을 모았으면, 오른쪽 아래의 \ue827 [accent]Map[]에서 주변 지역을 선택해서 [accent]Launch[]할 수 있습니다.
 hint.launch.mobile = 충분한 자원을 모았으면, 오른쪽 아래의 \ue88c [accent]메뉴[]에 있는 \ue827 [accent]Map[]에서 주변 지역을 선택해서 [accent]Launch[]할 수 있습니다.
-hint.schematicSelect = 블록을 복사하고 붙여넣으려면 [accent][[F][]를 누른채로 끌어서 구역을 지정하십시오. \n\n [accent][[마우스 휠][]을 누르면 한개의 블록만 복사할 수 있습니다.
+hint.schematicSelect = 블록을 복사하고 붙여넣으려면 [accent][[F][]를 누른 채로 끌어서 구역을 지정하십시오. \n\n [accent][[마우스 휠][]을 누르면 한 개의 블록만 복사할 수 있습니다.
-hint.conveyorPathfind = [accent][[왼쪽 Ctrl][]을 누른채로 컨베이어를 대각선으로 끌면 길을 자동으로 만들어줍니다.
+hint.conveyorPathfind = [accent][[왼쪽 Ctrl][]을 누른 채로 컨베이어를 대각선으로 끌면 길을 자동으로 만들어줍니다.
 hint.conveyorPathfind.mobile = \ue844 [accent]diagonal mode[]를 활성화하고 컨베이어를 대각선으로 끌면 길을 자동으로 찾아줍니다.
-hint.boost = 당신의 유닛과 같이 장애물을 넘어가려면 [accent][[L-Shift][]을 누르고 이동하십시오. \n\n 적은 수의 지상 유닛만 날 수 있습니다.
+hint.boost = 유닛과 같이 장애물을 넘어가려면 [accent][[L-Shift][]을 누르고 이동하십시오. \n\n 적은 수의 지상 유닛만 날 수 있습니다.
 hint.command = 주변의 아군 유닛을 데리고 다니려면 비슷한 단계의 유닛 무리 주변에서 [accent][[G][]를 누르십시오. \n\n 지상 유닛을 데리고 다니기 위해서는 먼저 다른 지상 유닛을 조종하고 있어야 합니다.
-hint.command.mobile = 아군 유닛을 데리고 다니려면 비슷한 단계의 유닛 무리 주변에서 [accent]빠르게 두번 누르십시오[].
+hint.command.mobile = 아군 유닛을 데리고 다니려면 비슷한 단계의 유닛 무리 주변에서 [accent]빠르게 두 번 누르십시오[].
 hint.payloadPickup = 작은 블록이나 유닛을 집으려면 [accent][[[]를 누르십시오.
 hint.payloadPickup.mobile = 작은 블록이나 유닛을 집으려면 [accent]잠깐 누르십시오[].
 hint.payloadDrop = 다시 내려놓으려면 [accent]][]를 누르십시오.
 hint.payloadDrop.mobile = 다시 내려놓으려면 빈 공간에서 [accent]화면을 잠깐 누르십시오[].
 hint.waveFire = [accent]Wave[]포탑에 탄약으로 물을 넣으면 주변의 불을 자동으로 꺼줍니다.
 hint.generator = \uf879 [accent]화력 발전기[]는 석탄을 태워서 주변 블록에 전력을 전달합니다.\n\n \uf87f 더 넓은 범위의 블록에 전력을 전달하려면 [accent]Power Nodes[]를 사용하십시오.
-hint.guardian = [accent]수호자[] 유닛들은 방어력을 가집니다. [accent]구리[]와 [accent]납[]같은 약한 탄약으로는 [scarlet]아무런 효과도 없습니다[].\n\n그런 수호자를 없애려면 높은 단계의 포탑 또는 \uf835 [accent]흑연[]을 탄약으로 넣은 \uf861듀오/\uf859살보를 사용하십시오.
+hint.guardian = [accent]수호자[] 유닛들은 방어력을 가집니다. [accent]구리[]와 [accent]납[] 같은 약한 탄약으로는 [scarlet]아무런 효과도 없습니다[].\n\n그런 수호자를 없애려면 높은 단계의 포탑 또는 \uf835 [accent]흑연[]을 탄약으로 넣은 \uf861듀오/\uf859살보를 사용하십시오.
-hint.coreUpgrade = 코어는 [accent]상위 코어를 위에 설치함[]으로써 업그레이드할 수 있습니다.\n\n [accent]기반[] 코어를  [accent]조각[] 코어 위에 설치하십시오. 주변에 장애물이 없는지도 확인하십시오.
+hint.coreUpgrade = 코어는 [accent]상위 코어를 위에 설치함[]으로써 업그레이드할 수 있습니다.\n\n [accent]기반[] 코어를  [accent]조각[] 코어 위에 설치하십시오. 주변에 장애물이 없는지도 확인하십시오.
 hint.presetLaunch = [accent]얼어붙은 숲[]과 같은 회색[accent]캠페인 지역[]은 어디에서나 출격해서 올 수 있습니다. 주변 지역을 점령하지 않아도 됩니다.\n\n이와 같은 [accent]네임드 지역[]들은 [accent]선택적[]입니다.
 hint.coreIncinerate = 코어가 자원으로 가득 찬 후에 받는 모든 자원들은 [accent]소각[]될 것입니다.
-hint.coopCampaign = [accent]협동 캠페인[]을 할 떄, 현재 맵에서 생산된 자원들은 [accent]당신의 캠페인 지역으로[]도 보내집니다.\n\n호스트가 새로 해금한 모든 것들도 가져갑니다.
+hint.coopCampaign = [accent]협동 캠페인[]을 할 때, 현재 맵에서 생산된 자원들은 [accent]캠페인 지역[]으로도 보내집니다.\n\n호스트가 새로 해금한 모든 것들도 가져갑니다.
 
 item.copper.description = 가장 기본적인 건설 재료. 모든 유형의 블록에서 광범위하게 사용됩니다.
 item.copper.details = 평범한 구리. 세르플로에 비정상적으로 많이 분포합니다. 별다른 보강재 없이는 구조적 문제 때문에 내구성이 비교적 약합니다.
@@ -1317,9 +1326,9 @@ item.scrap.description = 오래된 건물과 유닛의 남은 잔해. 미량의
 item.scrap.details = 오래된 구조물과 유닛의 잔해.
 item.silicon.description = 매우 유용한 반도체. 복잡한 전자 장치나 유도탄에 사용됩니다.
 item.plastanium.description = 고급 기체 및 파편화 탄약에 사용되는 가볍고 연성이 있는 재료입니다.
-item.phase-fabric.description = 최첨단 전자 제품과 자기수리 기술에 사용되는 거의 무중력에 가까운 물질입니다.
+item.phase-fabric.description = 최첨단 전자 제품과 자가 수리 기술에 사용되는 거의 무중력에 가까운 물질입니다.
 item.surge-alloy.description = 독특한 전기적 특성을 가진 고급 합금.
-item.spore-pod.description = 산업 목적을 위해 대기 농도에서 합성된 포자 버섯. 석유, 폭발물 및 연료로 전환하는 데 사용됩니다.
+item.spore-pod.description = 산업 목적을 위해 대기 농도에서 합성된 포자 버섯. 석유, 폭발물과 연료로 전환하는 데 사용됩니다.
 item.spore-pod.details = 포자. 유기적인 생명체로 판단된다. 타 유기체에 치명적인 독가스를 내뿜는다. 침입성이 매우 강하다. 특정 조건에서 강력한 인화성을 보입니다.
 item.blast-compound.description = 폭탄과 폭발물에 사용되는 불안정한 화합물. 포자 버섯 및 기타 휘발성 물질로 합성할 수 있습니다. 연료로 사용하지 않는 것이 좋습니다.
 item.pyratite.description = 소이 무기에서 사용되는 가연성 매우 높은 물질.
@@ -1327,16 +1336,16 @@ item.pyratite.description = 소이 무기에서 사용되는 가연성 매우
 liquid.water.description = 기능성이 뛰어난 액체. 냉각기 및 폐기물 처리에 일반적으로 사용됩니다.
 liquid.slag.description = 다양한 종류의 금속들이 함께 섞여 녹아있습니다. 분리기를 이용해 다른 광물들로 분리하거나 탄약으로 사용해 적 부대를 향해 살포할 수 있습니다.
 liquid.oil.description = 고급 재료 생산에 사용되는 액체. 석탄으로 전환하거나 무기로 뿌려서 불을 지를 수 있습니다.
-liquid.cryofluid.description = 물과 티타늄으로 만든 비 부식성 액체. 열 용량이 매우 높으며 냉각수로 광범위하게 사용됩니다.
+liquid.cryofluid.description = 물과 티타늄으로 만든 비부식성 액체. 열용량이 매우 높으며 냉각수로 광범위하게 사용됩니다.
 
-block.resupply-point.description = 주변 유닛들에게 구리 탄약을 보급합니다. 배터리 전력이 필요한 유닛들은 호환되지 않습니다.
+block.resupply-point.description = 주변 유닛들에 구리 탄약을 보급합니다. 배터리 전력이 필요한 유닛들은 호환되지 않습니다.
 block.armored-conveyor.description = 앞으로 자원들을 운반합니다. 측면에서 자원들을 받아들이지 않습니다.
 block.illuminator.description = 발광합니다.
 block.message.description = 아군 간의 소통을 위한 메시지를 저장합니다.
 block.graphite-press.description = 석탄을 흑연으로 압축합니다.
 block.multi-press.description = 석탄을 흑연으로 압축합니다. 냉각수로써 물이 필요합니다.
 block.silicon-smelter.description = 석탄과 모래로부터 실리콘을 정제합니다.
-block.kiln.description = 모래와 납을 강화 유리로 재련합니다.
+block.kiln.description = 모래와 납을 강화 유리로 제련합니다.
 block.plastanium-compressor.description = 석유와 티타늄으로 플라스터늄을 생산합니다.
 block.phase-weaver.description = 토륨과 모래로 메타를 합성합니다.
 block.alloy-smelter.description = 티타늄, 납, 실리콘, 구리를 결합하여 설금을 생산합니다.
@@ -1349,32 +1358,32 @@ block.spore-press.description = 포자를 석유로 압축합니다.
 block.pulverizer.description = 고철을 갈아 모래로 만듭니다.
 block.coal-centrifuge.description = 석유에서 석탄을 추출합니다.
 block.incinerator.description = 넘치는 자원이나 액체를 증발시킵니다.
-block.power-void.description = 입력된 모든 전력을 무효화합니다. 샌드박스 전용.
+block.power-void.description = 입력된 모든 전력을 무효로 합니다. 샌드박스 전용.
 block.power-source.description = 무한한 전력을 공급해주는 블록입니다. 샌드박스 전용.
 block.item-source.description = 자원을 무한대로 출력합니다. 샌드박스 전용.
 block.item-void.description = 모든 자원을 파괴합니다. 샌드박스 전용.
 block.liquid-source.description = 액체를 무한히 출력합니다. 샌드박스 전용.
 block.liquid-void.description = 액체를 제거합니다. 샌드박스 전용.
-block.copper-wall.description = 저렴한 수비 블록.\n초반 단계에서 코어와 포탑을 보호하는데 유용합니다.
+block.copper-wall.description = 저렴한 수비 블록.\n초반 단계에서 코어와 포탑을 보호하는 데 유용합니다.
-block.copper-wall-large.description = 저렴한 수비 블록.\n초반 단계에서 코어와 포탑을 보호하는데 유용합니다.\n여러 타일을 차지합니다.
+block.copper-wall-large.description = 저렴한 수비 블록.\n초반 단계에서 코어와 포탑을 보호하는 데 유용합니다.\n여러 타일을 차지합니다.
 block.titanium-wall.description = 적당히 강한 방어 블록.\n적에게서 적절한 보호를 제공합니다.
 block.titanium-wall-large.description = 적당히 강한 방어 블록.\n적에게서 적절한 보호를 제공합니다.\n여러 타일을 차지합니다.
 block.plastanium-wall.description = 전격 공격을 흡수하고 전력 노드의 자동 연결을 차단하는 특수 유형의 벽.
 block.plastanium-wall-large.description = 전격 공격을 흡수하고 전력 노드의 자동 연결을 차단하는 특수 유형의 벽.\n여러 타일을 차지합니다.
 block.thorium-wall.description = 강력한 방어 블록.\n적으로부터 적절한 보호를 할 수 있습니다.
 block.thorium-wall-large.description = 강력한 방어 블록.\n적으로부터 적절한 보호를 할 수 있습니다.\n여러 타일을 차지합니다.
-block.phase-wall.description = 특수 메타기반 반사 화합물로 코팅된 벽. 총알 대부분을 반사시킵니다.
+block.phase-wall.description = 특수 메타기반 반사 화합물로 코팅된 벽. 총알 대부분을 반사합니다.
-block.phase-wall-large.description = 특수 메타기반 반사 화합물로 코팅된 벽. 총알 대부분을 반사시킵니다.\n여러 타일을 차지합니다.
+block.phase-wall-large.description = 특수 메타기반 반사 화합물로 코팅된 벽. 총알 대부분을 반사합니다.\n여러 타일을 차지합니다.
 block.surge-wall.description = 내구성이 매우 강한 방어 블록.\n총탄이 날아오면 충전량을 높여 무작위로 방출합니다.
 block.surge-wall-large.description = 내구성이 매우 강한 방어 블록.\n총탄이 날아오면 충전량을 높여 무작위로 방출합니다.\n여러 타일을 차지합니다.
-block.door.description = 작은 문. 탭하여 열거나 닫을 수 있습니다.
+block.door.description = 작은 문. 탭 하여 열거나 닫을 수 있습니다.
-block.door-large.description = 큰 문. 탭하여 열거나 닫을 수 있습니다.\n여러 타일을 차지합니다.
+block.door-large.description = 큰 문. 탭 하여 열거나 닫을 수 있습니다.\n여러 타일을 차지합니다.
 block.mender.description = 주변의 블록을 주기적으로 수리합니다. 각 단계 사이의 방어를 유지하게 합니다.\n선택적으로 실리콘을 사용하여 범위와 효율성을 향상합니다.
 block.mend-projector.description = 소형 수리 프로젝터의 강화 버전. 주변의 블록을 수리합니다.\n선택적으로 메타를 사용하여 범위와 효율성을 향상합니다.
 block.overdrive-projector.description = 주변 건물의 속도를 높입니다.\n선택적으로 메타를 사용하여 범위와 효율성을 높입니다.
 block.force-projector.description = 건물과 내부의 유닛을 공격으로부터 보호하며, 그 주위에 육각형 역장을 형성합니다.\n갑자기 많은 손상이 피해를 받으면 과열되며, 선택적으로 냉각수를 사용하여 과열을 방지할 수 있고, 메타는 역장의 크기를 늘리는 데 사용할 수 있습니다.
 block.shock-mine.description = 지뢰를 밟고 있는 적에게 피해를 줍니다. 적에게는 거의 보이지 않습니다.
-block.conveyor.description = 기본 자원 수송 레일. 자원을 배치된 방향을 따라 이동시켜 자동으로 건물에 넣어줍니다. 회전식.
+block.conveyor.description = 기본 자원 수송 레일. 자원을 배치된 방향을 따라 이동 시켜 자동으로 건물에 넣어줍니다. 회전식.
 block.titanium-conveyor.description = 고급 자원 수송 레일. 기본 컨베이어보다 자원을 더 빨리 이동시킵니다.
 block.plastanium-conveyor.description = 자원을 일괄적으로 운송시킵니다. 컨베이에 뒤에서 자원을 받고 앞쪽에 세 방향으로 내보냅니다.
 block.junction.description = 2개의 컨베이어 벨트를 교차시키는 다리 역할을 합니다. 서로 다른 재료를 다른 장소로 운반하는 두 개의 다른 컨베이어의 상황에서 유용합니다.
@@ -1388,13 +1397,13 @@ block.distributor.description = 고급 분배기. 자원을 최대 7개의 다
 block.overflow-gate.description = 전면 경로가 차단된 경우에만 왼쪽과 오른쪽으로 출력됩니다.
 block.underflow-gate.description = 오버플로 게이트의 반대. 왼쪽 및 오른쪽 경로가 차단되면 전면으로 출력됩니다.
 block.mass-driver.description = 최고의 자원 운송 블록. 여러 자원을 모아서 장거리에 걸쳐 다른 매스 드라이버에게 발사합니다. 작동하려면 전원이 필요합니다.
-block.mechanical-pump.description = 느린 속도로 액체를 퍼 올리지만, 전력를 사용하지 않는 펌프입니다.
+block.mechanical-pump.description = 느린 속도로 액체를 퍼 올리지만, 전력을 사용하지 않는 펌프입니다.
 block.rotary-pump.description = 고급 펌프. 더 많은 액체를 퍼 올리지만, 전력이 필요합니다.
 block.thermal-pump.description = 가장 강력한 펌프.
 block.conduit.description = 기본 액체 운송 블록. 액체를 앞으로 이동시킵니다. 펌프 및 기타 파이프와 함께 사용됩니다.
 block.pulse-conduit.description = 고급 액체 운송 블록. 액체를 더 빠르게 운반하고 표준 파이프보다 더 많이 저장합니다.
 block.plated-conduit.description = 펄스 파이프와 같은 속도로 이동하지만 더 높은 방어력을 가지고 있습니다. 측면에서 액체들을 받아들이지 않습니다.\n액체가 누설하지 않습니다.
-block.liquid-router.description = 한 방향에서 액체를 받아 최대 3개의 다른 방향으로 동일하게 출력합니다. 일정량의 액체를 저장할 수도 있으며 한 소스에서 여러 대상으로 액체를 분할하는 데 유용합니다.
+block.liquid-router.description = 한 방향에서 액체를 받아 최대 3개의 다른 방향으로 같이 출력합니다. 일정량의 액체를 저장할 수도 있으며 한 소스에서 여러 대상으로 액체를 나누는 데 유용합니다.
 block.liquid-tank.description = 대량의 액체를 저장합니다. 재료가 일정하지 않은 상황에서 버퍼를 생성하거나 중요한 블록을 냉각하기 위한 보호 장치로 사용하세요.
 block.liquid-junction.description = 두 개의 교차 파이프를 위한 다리 역할을 합니다. 다른 액체를 다른 위치로 운반하는 두 개의 다른 파이프가 있는 상황에서 유용합니다.
 block.bridge-conduit.description = 고급 액체 운송 블록. 지형이나 건물을 넘어 최대 3개 타일 위로 액체를 운반할 수 있습니다.
@@ -1403,9 +1412,9 @@ block.power-node.description = 연결된 노드에 전력을 전송합니다.
 block.power-node-large.description = 더 넓은 범위의 고급 전력 노드.
 block.surge-tower.description = 사용 가능한 연결 수가 적은 장거리 전력 노드.
 block.diode.description = 배터리 전력은 이 블록을 통해 한 방향으로만 흐를 수 있지만, 출력 방향 배터리의 전력이 더 적은 경우에만 가능합니다.
-block.battery.description = 전기가 넘쳐날 때 전력을 저장할 수 있습니다. 전력에 적자가 발생할 때 전력을 출력합니다.
+block.battery.description = 전력이 넘쳐날 때 저장할 수 있습니다. 전력에 적자가 발생할 때 전력을 출력합니다.
 block.battery-large.description = 일반 배터리보다 훨씬 더 많은 전력을 저장합니다.
-block.combustion-generator.description = 석탄과 같은 가연성 물질을 연소시켜 전력을 생산합니다.
+block.combustion-generator.description = 석탄과 같은 가연성 물질을 연소 시켜 전력을 생산합니다.
 block.thermal-generator.description = 열이 있는 곳에 설치하면 전력이 생성됩니다.
 block.steam-generator.description = 고급 연소 발전기. 더 효율적이지만 증기를 생성하기 위해 물이 필요합니다.
 block.differential-generator.description = 많은 양의 전력을 생성합니다. 냉각수와 불타는 파이라타이트의 온도 차이를 이용합니다.
@@ -1416,7 +1425,7 @@ block.thorium-reactor.description = 토륨으로부터 상당한 양의 전력
 block.impact-reactor.description = 최고 효율로 대량의 전력을 생산할 수 있는 고급 발전기. 가동을 시작하려면 상당한 전력 공급이 필요합니다.
 block.mechanical-drill.description = 가격이 싼 드릴. 적절한 타일에 설치하면 자원을 천천히 느린 속도로 출력합니다. 기본 자원만 채굴할 수 있습니다.
 block.pneumatic-drill.description = 티타늄을 캘 수 있는 향상된 드릴. 기계식 드릴보다 더 빠른 속도로 채굴합니다.
-block.laser-drill.description = 레이저 기술을 통해 더욱 빠르게 채광할 수 있지만, 전력이 필요합니다. 토륨 채굴 가능.
+block.laser-drill.description = 레이저 기술을 통해 더욱더 빠르게 채광할 수 있지만, 전력이 필요합니다. 토륨 채굴 가능.
 block.blast-drill.description = 최상위 드릴. 많은 양의 전력이 필요합니다.
 block.water-extractor.description = 지하수를 추출합니다. 물을 구하기 어려운 곳에서 사용합니다.
 block.cultivator.description = 대기 중의 작은 농도의 포자를 산업용 포자로 배양합니다.
@@ -1430,33 +1439,33 @@ block.core-nucleus.description = 기지의 핵심입니다. 방어력이 매우
 block.core-nucleus.details = 세 번째, 궁극의 버전.
 block.vault.description = 각 유형의 많은 양의 자원을 저장합니다. 언로더 블록을 사용하여 창고에서 자원을 빼낼 수 있습니다.
 block.container.description = 각 유형의 자원을 소량 저장합니다. 언로더 블록을 사용하여 컨테이너에서 자원을 빼낼 수 있습니다.
-block.unloader.description = 근처의 비 수송 블록에서 자원을 빼냅니다. 눌러서 빼낼 자원을 변경할 수 있십니다.
+block.unloader.description = 근처의 비 수송 블록에서 자원을 빼냅니다. 눌러서 빼낼 자원을 변경할 수 있습니다.
 block.launch-pad.description = 코어 출격 없이도 자원을 묶어 출격시킬 수 있습니다.
 block.duo.description = 적에게 탄환을 교대하며 발사합니다.
 block.scatter.description = 적군에게 납, 고철, 또는 강화 유리 조각 덩어리를 발사합니다.
 block.scorch.description = 주변의 모든 지상 적을 불태웁니다. 근거리에서 매우 효과적입니다.
 block.hail.description = 장거리에 걸쳐 지상 적에게 작은 포탄을 발사합니다.
 block.wave.description = 적에게 액체 줄기를 발사합니다. 물이 공급되면 자동으로 화재를 진압합니다.
-block.lancer.description = 지상 목표물에게 강력한 에너지 빔을 충전하여 발사합니다.
+block.lancer.description = 지상 목표물에 강력한 에너지 빔을 충전하여 발사합니다.
-block.arc.description = 지상 목표물에게 전격 아크를 발사합니다.
+block.arc.description = 지상 목표물에 전격 아크를 발사합니다.
 block.swarmer.description = 적에게 유도탄을 발사합니다.
 block.salvo.description = 적에게 총알을 빠르게 일제히 발사합니다.
 block.fuse.description = 주변 적에게 3개의 단거리 관통 레이저를 발사합니다.
 block.ripple.description = 장거리에 걸쳐 지상 적에게 포탄 무리를 발사합니다.
 block.cyclone.description = 근처 적에게 폭발 파편 덩어리를 발사합니다.
-block.spectre.description = 공중 및 지상 목표물에게 큰 관통 철갑탄을 발사합니다.
+block.spectre.description = 공중 및 지상 목표물에 큰 관통 철갑탄을 발사합니다.
 block.meltdown.description = 주변 적에게 지속적인 레이저 빔을 충전하여 발사합니다. 냉각 액체가 있어야 작동합니다.
 block.foreshadow.description = 장거리에 걸친 거대한 단일 목표 저격탄을 발사합니다.
-block.repair-point.description = 인근에 가장 가까운 유닛을 지속적으로 치료합니다.
+block.repair-point.description = 인근에 가장 가까운 유닛을 지속해서 치료합니다.
-block.segment.description = 날아오는 발사체를 요격합니다. 큰 발사체에겐 조준하지 않습니다.
+block.segment.description = 날아오는 발사체를 요격합니다. 큰 발사체엔 조준하지 않습니다.
 block.parallax.description = 공중 목표물을 끌어오는 견인 광선을 발사하며, 견인 과정에서 데미지를 줍니다.
 block.tsunami.description = 적에게 강력한 액체 줄기를 발사합니다. 물이 공급되면 자동으로 주변의 화재를 진압합니다.
-block.silicon-crucible.description = 추가적으로 파이라타이트를 사용하여 더 높은 온도에서 석탄과 모래를 제련합니다. 뜨거운 곳에서 더 효율적입니다.
+block.silicon-crucible.description = 추가로 파이라타이트를 사용하여 더 높은 온도에서 석탄과 모래를 제련합니다. 뜨거운 곳에서 더 효율적입니다.
 block.disassembler.description = 광재를 낮은 확률로 미량의 희귀한 광물들로 분리합니다. 토륨을 생산할 수 있습니다.
 block.overdrive-dome.description = 인근 블록들을 과부하시킵니다. 작동하기 위해 실리콘과 메타가 필요합니다.
 block.payload-conveyor.description = 유닛이나 공장같이 큰 화물들을 운반합니다.
 block.payload-router.description = 3가지 방향으로 번갈아서 화물들을 운반합니다.
-block.command-center.description = 4개의 명령어들로 유닛 행동을 제어합니다.
+block.command-center.description = 4개의 명령어로 유닛 행동을 제어합니다.
 block.ground-factory.description = 지상 유닛들을 생산합니다. 생산된 유닛들은 바로 사용될 수 있고, 또는 강화를 위해 재구성기에 들어가질 수 있습니다.
 block.air-factory.description = 공중 유닛들을 생산합니다. 생산된 유닛들은 바로 사용될 수 있고, 또는 강화를 위해 재구성기에 들어가질 수 있습니다.
 block.naval-factory.description = 해상 유닛들을 생산합니다. 생산된 유닛들은 바로 사용될 수 있고, 또는 강화를 위해 재구성기에 들어가질 수 있습니다.
@@ -1507,3 +1516,127 @@ unit.omura.description = 적에게 장거리 관통 레일건을 발사합니다
 unit.alpha.description = 적으로부터 코어: 조각을 방어합니다. 구조물을 짓습니다.
 unit.beta.description = 적으로부터 코어: 기반을 방어합니다. 구조물을 짓습니다.
 unit.gamma.description = 적으로부터 코어: 핵심을 방어합니다. 구조물을 짓습니다.
+
+lst.read = 연결된 메모리 셀에서 숫자 읽기
+lst.write = 연결된 메모리 셀에 숫자 쓰기
+lst.print = 프린트 버퍼에 텍스트 추가하기\n[accent]Print Flush[]가 사용되기 전까진 아무것도 보여주지 않습니다.
+lst.draw = 드로잉 버퍼에 실행문 추가하기\n[accent]Draw Flush[]가 사용되기 전까진 아무것도 보여주지 않습니다.
+lst.drawflush = 대기중인 [accent]Draw[]실행문을 디스플레이에 출력하기
+lst.printflush = 대기중인 [accent]Print[]실행문을 메시지 블록에 출력하기
+lst.getlink = 순서별로 프로세서 연결 가져오기. 0부터 시작
+lst.control = 건물 조종하기
+lst.radar = 건물 주변의 유닛 검색하기 
+lst.sensor = 건물 또는 유닛의 정보 얻기 
+lst.set = 변수 선언/할당하기
+lst.operation = 1~2개의 변수로 연산자하기
+lst.end = 실행줄의 가장 위로 점프하기
+lst.jump = 조건부로 다른 실행문으로 점프하기
+lst.unitbind = type 옆에 있는 유닛을 지정하고, [accent]@unit[]에 저장하기
+lst.unitcontrol = 현재 지정된 유닛을 조종하기
+lst.unitradar = 현재 지정된 유닛 주변의 유닛 검색하기
+lst.unitlocate = 특정 유형의 위치/건물을 지도상에서 찾기\n지정된 유닛이 필요합니다.
+
+lenum.type = 건물/유닛의 타입\n예로 분배기는 [accent]@router[]를 반환할 것입니다.\n문자열이 아니라.
+lenum.shoot = 특정 위치에 발사
+lenum.shootp = 목표물 속도를 예측하여 발사
+lenum.configure = 필터의 아이템같은 건물의 설정
+lenum.enabled = 블록의 활성 여부
+lenum.color = 조명 색 설정
+
+lenum.always = 항상 참
+lenum.idiv = 정수 나누기
+lenum.div = 나누기\n0으로 나누면 [accent]null[]을 반환합니다.
+lenum.mod = 나머지
+lenum.equal = 동치 비교. 형변환 가능\nNull이 아닌 객체가 숫자와 비교할려면 1이 되고, Null이면 0이 됩니다.
+lenum.notequal = 동치 부정. 형변환 가능
+lenum.strictequal = 엄격한 동치 비교. 형변환 불가능\n[accent]null[]를 확인하는데 쓸 수 있습니다.
+lenum.shl = 왼쪽으로 비트 이동
+lenum.shr = 오른쪽으로 비트 이동
+lenum.or = 비트연산자 OR
+lenum.land = 논리연산자 AND
+lenum.and = 비트연산자 AND
+lenum.not = 비트연산자 NOT
+lenum.xor = 비트연산자 XOR
+
+lenum.min = 두 수의 최솟값
+lenum.max = 두 수의 최댓값
+lenum.angle = 벡터의 각(도)
+lenum.len = 벡터의 길이
+lenum.sin = 사인(도)
+lenum.cos = 코사인(도)
+lenum.tan = 탄젠트(도)
+#not a typo, look up 'range notation'
+lenum.rand = 범위 내 난수[0 ~ 값)
+lenum.log = 자연 로그(진수)
+lenum.log10 = 상수 로그
+lenum.noise = 2D 심플렉스 노이즈
+lenum.abs = 절댓값
+lenum.sqrt = 제곱근
+
+lenum.any = 유닛
+lenum.ally = 아군 유닛
+lenum.attacker = 무기를 가진 유닛
+lenum.enemy = 적 유닛
+lenum.boss = 수호자 유닛
+lenum.flying = 공중 유닛
+lenum.ground = 지상 유닛
+lenum.player = 플레이어에 의해 조종된 유닛
+
+lenum.ore = 광석 매장지
+lenum.damaged = 손상된 아군 건물
+lenum.spawn = 적 스폰 지점\n코어 또는 지점일 수 있음.
+lenum.building = 특정 건물 집단에 속한 건물
+
+lenum.core = 코어
+lenum.storage = 창고같은 저장 건물
+lenum.generator = 전력을 생산하는 건물
+lenum.factory = 자원을 변환하는 건물
+lenum.repair = 수리 지점
+lenum.rally = 지휘소
+lenum.battery = 배터리
+lenum.resupply = 보급 지점.\n[accent]"유닛 탄약 필요"[]가 활성화되었을 때만 유의미합니다.
+lenum.reactor = 핵융합로/토륨 원자로
+lenum.turret = 포탑ㅁ
+
+sensor.in = 감지할 건물/유닛
+
+radar.from = 감지를 할 건물\n감지 범위는 건물의 감지 범위에 의해 제한됩니다.
+radar.target = 유닛 감지 필터
+radar.and = 추가 필터
+radar.order = 정렬 순서. 0은 반전
+radar.sort = 결과를 정렬할 측정 수단
+radar.output = 찾은 유닛을 대입할 변수
+
+unitradar.target = 유닛 감지 필터
+unitradar.and = 추가 필터
+unitradar.order = 정렬 순서. 0은 반전
+unitradar.sort = 결과를 정렬할 측정 수단
+unitradar.output = 찾은 유닛을 대입할 변수
+
+control.of = 조종할 건물
+control.unit = 조준할 유닛/건물
+control.shoot = 발사 여부
+
+unitlocate.enemy = 적 건물 포함 여부
+unitlocate.found = 대상 발견 여부
+unitlocate.building = 찾은 건물을 대입할 변수
+unitlocate.outx = X좌표
+unitlocate.outy = Y좌표
+unitlocate.group = 찾을 건물 집단
+
+lenum.stop = 이동/채광/건설 중단
+lenum.move = 특정 위치로 이동
+lenum.approach = 특정 위치로 반지름만큼 접근
+lenum.pathfind = 적 스폰 지점으로 길찾기
+lenum.target =  특정 위치에 발사
+lenum.targetp = 목표물 속도를 예측하여 발사
+lenum.itemdrop = 아이템 투하
+lenum.itemtake = 건물에서 아이템 수송
+lenum.paydrop = 현재 화물 투하
+lenum.paytake = 현재 위치에서 화물 수송
+lenum.flag = 깃발 수 설정
+lenum.mine = 특정 위치에서 채광
+lenum.build = 구조물 건설
+lenum.getblock = 특정 좌표의 빌딩과 블록을 반환합니다.\n위치는 유닛의 인지 범위 내여야 합니다.\n자연 지형은 [accent]@solid[]의 타입을 가집니다.
+lenum.within = 좌표 주변 유닛 발견 여부
+lenum.boost = 이륙 시작/중단

core/assets/bundles/bundle_ro.properties

@@ -43,8 +43,8 @@ be.check = Verifică updateurile
 
 mods.browser = Browser de Moduri
 mods.browser.selected = Mod selectat
-mods.browser.add = Instalează
+mods.browser.add = Instalare
-mods.browser.reinstall = Reinstalează
+mods.browser.reinstall = Reinstal.
 mods.github.open = Github
 mods.browser.sortdate = Cele mai recente
 mods.browser.sortstars = Cele mai multe stele
@@ -312,6 +312,7 @@ cancelbuilding = [accent][[{0}][] pt a curăța planul
 selectschematic = [accent][[{0}][] pt selectare+copiere
 pausebuilding = [accent][[{0}][] pt a face o pauză de la construit
 resumebuilding = [scarlet][[{0}][] pt a continua construitul
+enablebuilding = [scarlet][[{0}][] pt a construi
 showui = Interfață ascunsă.\nApasă [accent][[{0}][] pt a vedea interfața.
 wave = [accent]Valul {0}
 wave.cap = [accent]Valul {0}/{1}
@@ -683,6 +684,7 @@ stat.drillspeed = Viteză Burghiu (Bază)
 stat.boosteffect = Efect de Îmbunătățire
 stat.maxunits = Maxim Unități Active
 stat.health = Viață
+stat.armor = Armură
 stat.buildtime = Timp Construcție
 stat.maxconsecutive = Maxim Consecutive
 stat.buildcost = Cost Construcție
@@ -794,6 +796,7 @@ setting.shadows.name = Umbre
 setting.blockreplace.name = Sugestii Plasare Automats
 setting.linear.name = Filtrare Liniară
 setting.hints.name = Indicii
+setting.logichints.name = Indicii Procesoare Logice
 setting.flow.name = Afișează Rata de Curgere a lichidelor
 setting.buildautopause.name = Autopauză de la Construit
 setting.backgroundpause.name = Pune Pauză în Fundal
@@ -954,6 +957,8 @@ rules.blockdamagemultiplier = Multiplicatorul Deteriorării Blocurilor
 rules.unitbuildspeedmultiplier = Multiplicatorul Vitezei de Producere a Unităților
 rules.unithealthmultiplier = Multiplicatorul Vieții Unităților
 rules.unitdamagemultiplier = Multiplicatorul Deteriorării Unităților
+rules.unitcapvariable = Nucleele Contribuie la Limita Unităților
+rules.unitcap = Limita de Bază a Unităților
 rules.enemycorebuildradius = Interzisă Construirea în Jurul Nucleului Inamic:[lightgray] (pătrate)
 rules.wavespacing = Spațiul Dintre Valuri:[lightgray] (sec)
 rules.buildcostmultiplier = Multiplicatorul Costului Construcției
@@ -1144,10 +1149,6 @@ block.armored-conveyor.name = Bandă Armată
 block.junction.name = Intersecție
 block.router.name = Router
 block.distributor.name = Distributor
-#experimental, pot fi șterse în viitor
-block.block-forge.name = Forjă de Blocuri
-block.block-loader.name = Încărcător de Blocuri
-block.block-unloader.name = Descărcător de Blocuri
 block.sorter.name = Sortator
 block.inverted-sorter.name = Sortator Invers
 block.message.name = Mesaj
@@ -1248,6 +1249,10 @@ block.disassembler.name = Dezasamblator
 block.silicon-crucible.name = Creuzet de Silicon
 block.overdrive-dome.name = Dom de Suprasolicitare
 block.interplanetary-accelerator.name = Accelerator Interplanetar
+#experimental, pot fi șterse în viitor
+block.block-forge.name = Forjă de Blocuri
+block.block-loader.name = Încărcător de Blocuri
+block.block-unloader.name = Descărcător de Blocuri
 
 block.switch.name = Întrerupător
 block.micro-processor.name = Microprocesor
@@ -1450,6 +1455,7 @@ block.ripple.description = Lovește cu capsule către inamici pe distanțe mari.
 block.cyclone.description = Trage cu grămezi explozive de material către unitățile inamice din apropiere.
 block.spectre.description = Trage cu gloanțe mari care penetrează scuturile inamicilor din apropiere.
 block.meltdown.description = Se încarcă și trage cu un laser continuu la inamicii din apropiere. Necesită răcitor pt a opera.
+block.foreshadow.description = Trage către o țintă cu un glonț imens pe distanțe lungi.
 block.repair-point.description = Repară încontinuu cea mai deteriorată unitate din vecinătate.
 block.segment.description = Deteriorează și distruge proiectilele din apropiere. Laserele nu sunt afectate.
 block.parallax.description = Trage cu o rază tractoare care atrage aeronavele inamice, deteriorându-le.
@@ -1510,3 +1516,127 @@ unit.omura.description = Trage cu un railgun cu gloanțe care penetrează scutur
 unit.alpha.description = Apără nucleul Shard de inamici. Construiește structuri.
 unit.beta.description = Apără nucleul Foundation de inamici. Construiește structuri.
 unit.gamma.description = Apără nucleul Core de inamici. Construiește structuri.
+
+lst.read = Citește un număr dintr-o celulă de memorie conectată.
+lst.write = Scrie un număr într-o celulă de memorie conectată.
+lst.print = Adaugă text în bufferul de tipărire.\nNu tipărește decât când se execută [accent]Print Flush[].
+lst.draw = Adaugă o operație în bufferul de desenare.\nNu afișează decât când se execută [accent]Draw Flush[].
+lst.drawflush = Afișează pe un monitor instrucțiunile [accent]Draw[] aflate în așteptare.
+lst.printflush = Tipărește  într-un bloc Mesaj instrucțiunile [accent]Print[] aflate în așteptare.
+lst.getlink = Obține o conexiune a procesorului după index. Începe de la 0.
+lst.control = Controlează o clădire.
+lst.radar = Localizează unitățile aflate în jurul unei clădiri. Are o anumită rază de acțiune.
+lst.sensor = Obține date de la o clădire sau unitate.
+lst.set = Setează o variabilă.
+lst.operation = Efectuează o operație pe 1-2 variabile.
+lst.end = Sari la începutul listei de instrucțiuni.
+lst.jump = Dacă condiția este adevărată, mergi la o altă instrucțiune.
+lst.unitbind = Controlează următoarea unitate de tipul selectat și reține-o în [accent]@unit[].
+lst.unitcontrol = Controlează unitatea controlată de procesor.
+lst.unitradar = Localizează unitățile din jurul unității controlate de procesor.
+lst.unitlocate = Localizează o poziție/clădire specifică oriunde pe hartă.\nNecesită o unitate controlată de procesor.
+
+lenum.type = Tipul clădirii/unității.\nde ex.: pt orice Router, va returna [accent]@router[].\nNu e un șir de caractere.
+lenum.shoot = Lovește către o locație.
+lenum.shootp = Lovește către o unitate/clădire. Anticipează viteza țintei și a proiectilului.
+lenum.configure = Configurașia clădirii, de ex. materialul selectat pt Sortator.
+lenum.enabled = Specifică dacă clădirea este pornită.
+lenum.color = Culoarea Iluminatorului.
+
+lenum.always = Mereu adevărat.
+lenum.idiv = Împărțirea naturală a numerelor (int).
+lenum.div = Împărțirea.\nReturnează [accent]null[] dacă împarți la 0.
+lenum.mod = Modulo (restul împărțirii).
+lenum.equal = Egal. Convertește tipurile variabilelor.\nObiectele nenule comparate cu numere devin 1, cele nule devin 0.
+lenum.notequal = Nu e egal. Convertește tipurile variabilelor.
+lenum.strictequal = Egalitate strictă. Nu convertește tipurile variabilelor.\nPoate fi folosit pt a verifica dacă ceva este [accent]null[].
+lenum.shl = Shift left pe biți.
+lenum.shr = Shift right pe biți.
+lenum.or = OR/SAU. Ține cont de biți.
+lenum.land = Logical AND/ȘI logic. Nu ține cont de biți.
+lenum.and = AND/ȘI. Ține cont de biți.
+lenum.not = NOT. Inversează biții.
+lenum.xor = XOR/disjuncție exclusivă. Ține cont de biți.
+
+lenum.min = Minimul a două numere.
+lenum.max = Maximul a două numere.
+lenum.angle = Unghiul unui vector în grade.
+lenum.len = Lungimea unui vector.
+lenum.sin = Sinus în grade.
+lenum.cos = Cosinus în grade.
+lenum.tan = Tangentă în grade.
+#cea de mai jos nu-i o greșeală, caută pe net notarea intervalelor în matematică
+lenum.rand = Număr aleatoriu în intervalul [0, val).
+lenum.log = Logaritm natural (ln).
+lenum.log10 = Logaritm în baza 10.
+lenum.noise = 2D simplex noise.
+lenum.abs = Valoarea absolută.
+lenum.sqrt = Radical/rădăcina pătrată.
+
+lenum.any = Orice unitate.
+lenum.ally = Unitate aliată.
+lenum.attacker = Unitate cu armă.
+lenum.enemy = Unitate inamică.
+lenum.boss = Unitate gardian.
+lenum.flying = Unitate care zboară.
+lenum.ground = Unitate de artilerie.
+lenum.player = Unitate controlată de un jucător.
+
+lenum.ore = Depozit de minereu.
+lenum.damaged = Clădire aliată deteriorată.
+lenum.spawn = Punct de lansare inamic.\nPoate fi un nucleu sau o poziție.
+lenum.building = Clădire dintr-un grup specific.
+
+lenum.core = Orice nucleu.
+lenum.storage = Clădire de stocare, de ex. Containerul.
+lenum.generator = Clădiri care generează electricitate.
+lenum.factory = Clădiri care transformă resurse.
+lenum.repair = Puncte de Reparare.
+lenum.rally = Centre de Comandă.
+lenum.battery = Orice baterie.
+lenum.resupply = Puncte de Realimentare.\nRelevant doar când [accent]"Unitățile Necesită Muniție"[] este activată.
+lenum.reactor = Reactor de Toriu/Impact.
+lenum.turret = Orice armă.
+
+sensor.in = Clădirea/unitatea care trebuie detectată.
+
+radar.from = Clădirea de la care detectăm.\nRaza senzorului e limitată de raza de costrucție.
+radar.target = Filtru pt unitățile care trebuie detectate.
+radar.and = Adaugă filtre.
+radar.order = Ordinea de sortare. 0 pt a inversa ordinea.
+radar.sort = Modul cum sortăm rezultatele.
+radar.output = Variabila în care se va scrie unitatea detectată.
+
+unitradar.target = Filtru pt unitățile care trebuie detectate.
+unitradar.and = Adaugă filtre.
+unitradar.order = Ordinea de sortare. 0 pt a inversa ordinea.
+unitradar.sort = Modul cum sortăm rezultatele.
+unitradar.output = Variabila în care se reține unitatea detectată.
+
+control.of = Clădirea de controlat.
+control.unit = Unitatea/clădirea către care se țintește.
+control.shoot = Specifică dacă armele trag.
+
+unitlocate.enemy = Specifică dacă se detectează clădirile inamice.
+unitlocate.found = Specifică dacă obiectul a fost găsit.
+unitlocate.building = Clădirea detectată.
+unitlocate.outx = Coordonata X a obiectului detectat.
+unitlocate.outy = Coordonata Y a obiectului detectat.
+unitlocate.group = Grupul clădirilor de detectat.
+
+lenum.stop = Oprește acțiunea curentă. Nu mișca/mina/construi.
+lenum.move = Mergi la această poziție.
+lenum.approach = Apropie-te la o anumită distanță de poziție.
+lenum.pathfind = Găsește ruta către punctul de lansare inamic. Poate fi un nucleu.
+lenum.target = Lovește către o poziție.
+lenum.targetp = Lovește o țintă. Anticipează viteza țintei și a proiectilului.
+lenum.itemdrop = Descarcă o bucată de material.
+lenum.itemtake = Ia o bucată de material dintr-o clădire.
+lenum.paydrop = Descarcă încărcătura curentă.
+lenum.paytake = Ia o încărcătură de la locația curentă.
+lenum.flag = Oferă o etichetă numerică unității.
+lenum.mine = Minează din această locație.
+lenum.build = Construiește o structură.
+lenum.getblock = Obține clădirea și tipul clădirii aflate la coordonatele specificate.\nUnitatea trebuie să se afle în raza poziției.\nBlocurile solide care nu sunt clădiri vor avea tipul [accent]@solid[].
+lenum.within = Verifică dacă unitatea se află în apropierea poziției.
+lenum.boost = Pornește/oprește propulsorul.

core/assets/bundles/bundle_ru.properties

@@ -312,6 +312,7 @@ cancelbuilding = [accent][[{0}][] для очистки плана
 selectschematic = [accent][[{0}][] выделить и скопировать
 pausebuilding = [accent][[{0}][] для приостановки строительства
 resumebuilding = [scarlet][[{0}][] для продолжения строительства
+enablebuilding = [scarlet][[{0}][] для включения строительства
 showui = Интерфейс скрыт.\nНажмите [accent][[{0}][] для отображения интерфейса.
 wave = [accent]Волна {0}
 wave.cap = [accent]Волна {0}/{1}
@@ -683,6 +684,7 @@ stat.drillspeed = Базовая скорость бурения
 stat.boosteffect = Ускоряющий эффект
 stat.maxunits = Максимальное количество активных единиц
 stat.health = Прочность
+stat.armor = Броня
 stat.buildtime = Время строительства
 stat.maxconsecutive = Макс. последовательность
 stat.buildcost = Стоимость строительства
@@ -794,6 +796,7 @@ setting.shadows.name = Тени
 setting.blockreplace.name = Автоматическая замена блоков
 setting.linear.name = Линейная фильтрация
 setting.hints.name = Подсказки
+setting.logichints.name = Подсказки для логики
 setting.flow.name = Показывать скорость потока ресурсов
 setting.backgroundpause.name = Фоновая пауза
 setting.buildautopause.name = Автоматическая приостановка строительства
@@ -1511,3 +1514,127 @@ unit.omura.description = Стреляет дальнобойным пробив
 unit.alpha.description = Защищает ядро «Осколок» от врагов. Основная строительная единица.
 unit.beta.description =  Защищает ядро «Штаб» от врагов. Основная строительная единица.
 unit.gamma.description = Защищает ядро «Атом» от врагов. Основная строительная единица.
+
+lst.read = Считывает число из соединённой ячейки памяти.
+lst.write = Записывает число в соединённую ячейку памяти.
+lst.print = Добавляет текст в текстовый буфер. Ничего не отображает, пока не будет вызван [accent]Print Flush[].
+lst.draw = Добавляет операцию в буфер отрисовки. Ничего не отображает, пока не будет вызван [accent]Draw Flush[].
+lst.drawflush = Сбрасывает буфер [accent]Draw[] операций на дисплей.
+lst.printflush = Сбрасывает буфер [accent]Print[] операций в блок-сообщение.
+lst.getlink = Получает соединение процессора по индексу. Начинает с 0.
+lst.control = Контролирует блок.
+lst.radar = Обнаруживает единицы вокруг постройки с заданным радиусом. 
+lst.sensor = Получает данные из постройки или единицы.
+lst.set = Устанавливает переменную.
+lst.operation = Совершает операцию над 1-2 переменными.
+lst.end = Переходит к началу стека операций.
+lst.jump = Условно переходит к другой операции.
+lst.unitbind = Привязывается к единице определённого типа и сохраняет её в [accent]@unit[].
+lst.unitcontrol = Управляет привязанной в данный момент единицей.
+lst.unitradar = Обнаруживает единицы вокруг привязанной в данный момент единицы.
+lst.unitlocate = Обнаруживает позицию/постройку определённого типа где-либо на карте. Требует привязанную единицу.
+
+lenum.type = Тип постройки/единицы. \nНапример, для маршрутизатора это будет [accent]@router[].\nНе строка.
+lenum.shoot = Стрельба в определённую позицию.
+lenum.shootp = Стрельба в единицу/постройку с расчётом скорости.
+lenum.configure = Конфигурация постройки, например, предмет сортировки.
+lenum.enabled = Включён ли блок.
+lenum.color = Цвет осветителя.
+
+lenum.always = Всегда истина.
+lenum.idiv = Целочисленное деление.
+lenum.div = Деление.\nВозвращает [accent]null[] при делении на ноль.
+lenum.mod = Остаток от деления.
+lenum.equal = Равно. Приводит типы.\nНе-null объекты, по сравнению с числами, становятся 1, иначе — 0.
+lenum.notequal = Не равно. Приводит типы.
+lenum.strictequal = Строгое равенство. Не приводит типы.\nМожет быть использовано для проверки на [accent]null[].
+lenum.shl = Побитовый сдвиг влево.
+lenum.shr = Побитовый сдвиг вправо.
+lenum.or = Побитовое ИЛИ.
+lenum.land = Булевое И.
+lenum.and = Побитовое И.
+lenum.not = Побитовое НЕ.
+lenum.xor = Побитовое исключающее ИЛИ.
+
+lenum.min = Минимальное из двух чисел.
+lenum.max = Максимальное из двух чисел.
+lenum.angle = Угол вектора в градусах.
+lenum.len = Длина вектора.
+lenum.sin = Синус, в градусах.
+lenum.cos = Косинус, в градусах.
+lenum.tan = Тангенс, в градусах.
+#это не ошибка, поищите 'обозначение диапазонов'
+lenum.rand = Случайное число в диапазоне [0, значение).
+lenum.log = Натуральный логарифм (ln).
+lenum.log10 = Логарифм по основанию 10.
+lenum.noise = Симплексный шум, 2D.
+lenum.abs = Абсолютная величина.
+lenum.sqrt = Квадратный корень.
+
+lenum.any = Любая единица.
+lenum.ally = Дружеская единица.
+lenum.attacker = Единица с оружием.
+lenum.enemy = Вражеская единица.
+lenum.boss = Страж.
+lenum.flying = Летающая единица.
+lenum.ground = Наземная единица.
+lenum.player = Единица, управляемая игроком.
+
+lenum.ore = Источник руды.
+lenum.damaged = Повреждённая дружеская постройка.
+lenum.spawn = Точка появления врагов.\nМожет быть ядром или позицией на карте.
+lenum.building = Постройка определённой группы.
+
+lenum.core = Любое ядро.
+lenum.storage = Здание хранения, например, хранилище.
+lenum.generator = Постройки, вырабатывающие энергию.
+lenum.factory = Постройки, перерабатывающие предметы.
+lenum.repair = Ремонтные пункты.
+lenum.rally = Командный центр.
+lenum.battery = Любой аккумулятор.
+lenum.resupply = Пункты снабжения.\nАктуально только при включённом [accent]"Боев. ед. требуют боеприпасы"[].
+lenum.reactor = Импульсный/ториевый реактор.
+lenum.turret = Любая турель.
+
+sensor.in = Постройка/единица для распознавания.
+
+radar.from = Постройка, от которой распознавать.\nДальность сенсора ограничена дальностью постройки.
+radar.target = Фильтр для распознавания единиц.
+radar.and = Дополнительные фильтры.
+radar.order = Порядок сортировки. 0 для обратного.
+radar.sort = Показатель для сортировки результатов.
+radar.output = Переменная для записи конечной единицы.
+
+unitradar.target = Фильтр для распознавания единиц.
+unitradar.and = Дополнительные фильтры.
+unitradar.order = Порядок сортировки. 0 для обратного.
+unitradar.sort = Показатель для сортировки результатов.
+unitradar.output = Переменная для записи конечной единицы.
+
+control.of = Постройка для контролирования.
+control.unit = Единица/постройка для прицеливания.
+control.shoot = Стрелять ли.
+
+unitlocate.enemy = Обнаруживать ли вражеские постройки.
+unitlocate.found = Найден ли объект.
+unitlocate.building = Переменная для записи обнаруженной постройки.
+unitlocate.outx = Вывод X координаты.
+unitlocate.outy = Вывод Y координаты.
+unitlocate.group = Группа построек для поиска.
+
+lenum.stop = Остановка передвижения/копания/стротельства.
+lenum.move = Перемещение в определённую позицию.
+lenum.approach = Приближение к позиции с указанным радиусом.
+lenum.pathfind = Перемещение к точке появления врагов.
+lenum.target = Стрельба в определённую позицию.
+lenum.targetp = Стрельба в единицу/постройку с расчётом скорости.
+lenum.itemdrop = Сбрасывание предметов.
+lenum.itemtake = Взятие предметов из постройки.
+lenum.paydrop = Сбрасывание текущего груза.
+lenum.paytake = Взятие груза на текущей позиции.
+lenum.flag = Числовой флаг единицы.
+lenum.mine = Копание в позиции.
+lenum.build = Строительство структур.
+lenum.getblock = Распознавание блока и его типа на координатах.\nЕдиница должна находиться в пределах досягаемости.\nТвёрдые не-постройки будут иметь тип [accent]@solid[].
+lenum.within = Проверка на нахождение единицы рядом с позицией.
+lenum.boost = Включение/выключение полёта.

core/assets/bundles/bundle_zh_TW.properties

@@ -41,10 +41,11 @@ be.ignore = 忽略
 be.noupdates = 沒有新的更新。
 be.check = 檢查是否有新的更新
 
-mod.featured.dialog.title = 模組瀏覽器 (尚未完成)
+mods.browser = 模組瀏覽器
 mods.browser.selected = 已選模組
 mods.browser.add = 安裝
-mods.github.open = 查看
+mods.github.reinstall = 重新安裝
+mods.github.open = 查看Github
 mods.browser.sortdate = 以最近篩選
 mods.browser.sortstars = 以星數篩選
 
@@ -118,9 +119,11 @@ mods.none = [lightgray]找不到模組!
 mods.guide = 模組指南
 mods.report = 回報錯誤
 mods.openfolder = 開啟模組資料夾
+mods.viewcontent = 查看內容
 mods.reload = 重新載入
 mods.reloadexit = 遊戲將會結束以重新載入模組。
 mod.display = [gray]模組：[orange]{0}
+mod.installed = [[已安裝]
 mod.enabled = [lightgray]已啟用
 mod.disabled = [scarlet]已禁用
 mod.disable = 禁用
@@ -309,6 +312,7 @@ cancelbuilding = [accent][[{0}][]清除計畫
 selectschematic = [accent][[{0}][]選擇並複製
 pausebuilding = [accent][[{0}][]暫停建造
 resumebuilding = [scarlet][[{0}][]繼續建造
+enablebuilding = [scarlet][[{0}][]啟用建造
 showui = 已隱藏介面。\n按[accent][[{0}][]顯示介面。
 wave = [accent]第{0}波
 wave.cap = [accent]Wave {0}/{1}
@@ -422,7 +426,7 @@ editor.exportimage = 匯出地形圖片檔
 editor.exportimage.description = 匯出地形圖片檔
 editor.loadimage = 載入圖片
 editor.saveimage = 儲存圖片
-editor.unsaved = [scarlet]尚未儲存變更！[]\n您確定要退出嗎？
+editor.unsaved = 您確定要退出嗎？\n[scarlet](將遺失未儲存的變更)[]
 editor.resizemap = 調整地圖大小
 editor.mapname = 地圖名稱：
 editor.overwrite = [accent]警告！這將會覆蓋現有的地圖。
@@ -680,6 +684,7 @@ stat.drillspeed = 基本鑽取速度
 stat.boosteffect = 加速效果
 stat.maxunits = 最大活躍單位
 stat.health = 耐久度
+stat.armor = 裝甲
 stat.buildtime = 建設時間
 stat.maxconsecutive = 最大連續
 stat.buildcost = 建造成本
@@ -791,6 +796,7 @@ setting.shadows.name = 陰影
 setting.blockreplace.name = 方塊建造建議
 setting.linear.name = 線性過濾
 setting.hints.name = 提示
+setting.logichints.name = 邏輯提示
 setting.flow.name = 顯示資源輸送速度
 setting.backgroundpause.name = 背景執行時暫停
 setting.buildautopause.name = 自動暫停建築
@@ -1508,3 +1514,127 @@ unit.omura.description = 對敵人發射遠程穿透型砲彈。建造曳光戰
 unit.alpha.description = 抵禦敵軍對核心：碎片的攻擊。建造建築物。
 unit.beta.description = 抵禦敵軍對核心：基地的攻擊。建造建築物。
 unit.gamma.description = 抵禦敵軍對核心：核子的攻擊。建造建築物。
+
+lst.read = [accent]讀取[]記憶體中的一項數值
+lst.write = [accent]寫入[]一項數值到記憶體中
+lst.print = 將文字加入輸出的暫存中，搭配[accent]Print Flush[]使用
+lst.draw = 將圖形加入顯示的暫存中，搭配[accent]Draw Flush[]使用
+lst.drawflush = 將所有暫存的[accent]Draw[]指令推到顯示器上
+lst.printflush = 將所有暫存的[accent]Print[]指令推到訊息板上
+lst.getlink = 由連接順序回傳連接的建築，第一個從"0"開始
+lst.control = 控制一個建築
+lst.radar = 偵測建築範圍內的單位
+lst.sensor = 獲取該建築或單位的數據
+lst.set = 設一個變數
+lst.operation = 加減乘除和計算機概論
+lst.end = 跳到第一個重頭開始執行
+lst.jump = 條件式跳到其他指令執行
+lst.unitbind = 綁定下一同種單位，存入[accent]@unit[]中.
+lst.unitcontrol = 控制現在綁定的單位
+lst.unitradar = 偵測綁定單位附近的單位
+lst.unitlocate = 尋找整個地圖上特定的位置/建築\n需要綁定的單位
+
+lenum.type = 建築/單位種類。\n例：操控單位建造光矛砲應使用[accent]@lancer[]，而非字串
+lenum.shoot = 對該位置開火
+lenum.shootp = 對指定單位/建築開火，具自瞄功能
+lenum.configure = 建築設定，如分類器、兵器工廠
+lenum.enabled = 確認該建築是否啟用
+lenum.color = 設定照明燈的顏色
+
+lenum.always = 永遠 true (直接跳).
+lenum.idiv = 整數除法，無條件捨去.
+lenum.div = 除法.\n除以零時回傳 [accent]null[]
+lenum.mod = Modulo，求餘數
+lenum.equal = 是否相等，不管資料型態。\n非null 物件和數值相比時回傳1
+lenum.notequal = 不相等，不管資料型態.
+lenum.strictequal = 嚴格檢查是否相等，會看資料型態。\n可用來檢查[accent]null[]
+lenum.shl = Bit-shift left.
+lenum.shr = Bit-shift right.
+lenum.or = Bitwise OR.
+lenum.land = Logical AND.
+lenum.and = Bitwise AND.
+lenum.not = Bitwise flip.
+lenum.xor = Bitwise XOR.
+
+lenum.min = Minimum of two numbers.
+lenum.max = Maximum of two numbers.
+lenum.angle = Angle of vector in degrees.
+lenum.len = Length of vector.
+lenum.sin = Sine, in degrees.
+lenum.cos = Cosine, in degrees.
+lenum.tan = Tangent, in degrees.
+#not a typo, look up 'range notation'
+lenum.rand = Random number in range [0, value).
+lenum.log = Natural logarithm (ln).
+lenum.log10 = Base 10 logarithm.
+lenum.noise = 2D simplex noise.
+lenum.abs = 取絕對值
+lenum.sqrt = 開根號
+
+lenum.any = 任何單位
+lenum.ally = 友方單位
+lenum.attacker = 具武器的單位
+lenum.enemy = 敵方單位
+lenum.boss = 頭目單位
+lenum.flying = 飛行單位
+lenum.ground = 陸上單位
+lenum.player = 玩家單位
+
+lenum.ore = 尋找礦物
+lenum.damaged = 尋找受損友方建築
+lenum.spawn = 敵方重生點\n可以是核心或一個位置
+lenum.building = 尋找特定建築
+
+lenum.core = 任何核心
+lenum.storage = 儲藏建築
+lenum.generator = 會發電的建築
+lenum.factory = 生產加工資源的建築，如煉矽場
+lenum.repair = 維修點
+lenum.rally = 指揮中心
+lenum.battery = 電池
+lenum.resupply = 補給點\n只有在[accent]"單位需要彈藥"[]被啟用時才有效果
+lenum.reactor = 衝擊/釷反應爐
+lenum.turret = 任何砲塔
+
+sensor.in = 想查閱的建築/單位
+
+radar.from = 作為雷達的建築\n偵測範圍同該建築的範圍
+radar.target = 搜索條件
+radar.and = 額外條件
+radar.order = 輸出順序，1：距離最近、血量最大
+radar.sort = 篩選方式
+radar.output = 回傳該單位為變數
+
+unitradar.target = 搜索條件
+unitradar.and = 額外條件
+unitradar.order = 輸出順序，1：距離最近、血量最大
+unitradar.sort = 篩選方式
+unitradar.output = 存該單位的變數
+
+control.of = 要控制的建築
+control.unit = 指定的建築/單位
+control.shoot = 是否開火
+
+unitlocate.enemy = 搜索敵方或友方建築
+unitlocate.found = 回傳是否找到建築
+unitlocate.building = 回傳找到的建築為變數
+unitlocate.outx = 回傳 X 座標
+unitlocate.outy = 回傳 Y 座標
+unitlocate.group = 搜索建築種類
+
+lenum.stop = 停止移動/挖礦/建造
+lenum.move = 移動到指定位置
+lenum.approach = 移動到距離指定位置一段距離的地方
+lenum.pathfind = 由內建AI前往敵方重生點
+lenum.target = 射擊指定區域
+lenum.targetp = 帶自瞄射擊指定的目標
+lenum.itemdrop = 放下物品
+lenum.itemtake = 從建築拿取物品
+lenum.paydrop = 放下拾取的負載
+lenum.paytake = 拾取船身下方的單位/建築
+lenum.flag = 單位編號(可異)
+lenum.mine = 挖指定位置的礦物
+lenum.build = 建造一個建築
+lenum.getblock = 獲取指定位置的建築種類和該建築\n必須在單位的範圍內\n實體障礙物，如高山會回傳[accent]@solid[]
+lenum.within = 單位是否在指定範圍內
+lenum.boost = 使用推進器

core/assets/icons/icons.properties

@@ -14,7 +14,6 @@
 63730=magmarock|block-magmarock-medium
 63729=sand|block-sand-medium
 63728=darksand|block-darksand-medium
-63727=holostone|block-holostone-medium
 63726=grass|block-grass-medium
 63725=salt|block-salt-medium
 63724=snow|block-snow-medium
@@ -285,7 +284,6 @@
 63451=scepter|unit-scepter-medium
 63450=reign|unit-reign-medium
 63449=dirt|block-dirt-medium
-63448=dirtwall|block-dirtwall-medium
 63447=stone-wall|block-stone-wall-medium
 63446=spore-wall|block-spore-wall-medium
 63445=ice-wall|block-ice-wall-medium
@@ -295,7 +293,6 @@
 63441=salt-wall|block-salt-wall-medium
 63440=shale-wall|block-shale-wall-medium
 63439=dirt-wall|block-dirt-wall-medium
-63438=holostone-wall|block-holostone-wall-medium
 63437=basalt|block-basalt-medium
 63436=dacite|block-dacite-medium
 63435=boulder|block-boulder-medium

core/assets/scripts/global.js

@@ -133,6 +133,7 @@ const PlayerLeave = Packages.mindustry.game.EventType.PlayerLeave
 const PlayerConnect = Packages.mindustry.game.EventType.PlayerConnect
 const PlayerJoin = Packages.mindustry.game.EventType.PlayerJoin
 const UnitChangeEvent = Packages.mindustry.game.EventType.UnitChangeEvent
+const UnitUnloadEvent = Packages.mindustry.game.EventType.UnitUnloadEvent
 const UnitCreateEvent = Packages.mindustry.game.EventType.UnitCreateEvent
 const UnitDrownEvent = Packages.mindustry.game.EventType.UnitDrownEvent
 const UnitDestroyEvent = Packages.mindustry.game.EventType.UnitDestroyEvent
@@ -161,6 +162,7 @@ const LaunchItemEvent = Packages.mindustry.game.EventType.LaunchItemEvent
 const SectorInvasionEvent = Packages.mindustry.game.EventType.SectorInvasionEvent
 const SectorLoseEvent = Packages.mindustry.game.EventType.SectorLoseEvent
 const WorldLoadEvent = Packages.mindustry.game.EventType.WorldLoadEvent
+const FileTreeInitEvent = Packages.mindustry.game.EventType.FileTreeInitEvent
 const ClientLoadEvent = Packages.mindustry.game.EventType.ClientLoadEvent
 const ContentInitEvent = Packages.mindustry.game.EventType.ContentInitEvent
 const BlockInfoEvent = Packages.mindustry.game.EventType.BlockInfoEvent

core/src/mindustry/Vars.java

@@ -38,6 +38,8 @@ public class Vars implements Loadable{
     public static boolean loadedLogger = false, loadedFileLogger = false;
     /** Whether to enable various experimental features (e.g. cliffs) */
     public static boolean experimental = false;
+    /** Name of current Steam player. */
+    public static String steamPlayerName = "";
     /** Maximum extra padding around deployment schematics. */
     public static final int maxLoadoutSchematicPad = 5;
     /** Maximum schematic size.*/
@@ -54,16 +56,14 @@ public class Vars implements Loadable{
     public static final String ghApi = "https://api.github.com";
     /** URL for discord invite. */
     public static final String discordURL = "https://discord.gg/mindustry";
-    /** URL for sending crash reports to */
+    /** URL for sending crash reports to. Currently offline. */
     public static final String crashReportURL = "http://192.99.169.18/report";
     /** URL the links to the wiki's modding guide.*/
     public static final String modGuideURL = "https://mindustrygame.github.io/wiki/modding/1-modding/";
-    /** URL to the JSON file containing all the global, public servers. Not queried in BE. */
-    public static final String serverJsonURL = "https://raw.githubusercontent.com/Anuken/Mindustry/master/servers.json";
     /** URL to the JSON file containing all the BE servers. Only queried in BE. */
     public static final String serverJsonBeURL = "https://raw.githubusercontent.com/Anuken/Mindustry/master/servers_be.json";
-    /** URL to the JSON file containing all the BE servers. Only queried in the V6 alpha (will be removed once it's out). */
+    /** URL to the JSON file containing all the BE servers.  */
-    public static final String serverJsonV6URL = "https://raw.githubusercontent.com/Anuken/Mindustry/master/servers_v6.json";
+    public static final String serverJsonURL = "https://raw.githubusercontent.com/Anuken/Mindustry/master/servers_v6.json";
     /** URL of the github issue report template.*/
     public static final String reportIssueURL = "https://github.com/Anuken/Mindustry/issues/new?labels=bug&template=bug_report.md";
     /** list of built-in servers.*/

core/src/mindustry/ai/BlockIndexer.java

@@ -269,7 +269,6 @@ public class BlockIndexer{
     public Building findTile(Team team, float x, float y, float range, Boolf<Building> pred, boolean usePriority){
         Building closest = null;
         float dst = 0;
-        float range2 = range * range;
 
         for(int rx = Math.max((int)((x - range) / tilesize / quadrantSize), 0); rx <= (int)((x + range) / tilesize / quadrantSize) && rx < quadWidth(); rx++){
             for(int ry = Math.max((int)((y - range) / tilesize / quadrantSize), 0); ry <= (int)((y + range) / tilesize / quadrantSize) && ry < quadHeight(); ry++){
@@ -282,13 +281,13 @@ public class BlockIndexer{
 
                         if(e == null || e.team != team || !pred.get(e) || !e.block.targetable || e.team == Team.derelict) continue;
 
-                        float ndst = e.dst2(x, y);
+                        float bdst = e.dst(x, y) - e.hitSize() / 2f;
-                        if(ndst < range2 && (closest == null ||
+                        if(bdst < range && (closest == null ||
                         //this one is closer, and it is at least of equal priority
-                        (ndst < dst && (!usePriority || closest.block.priority.ordinal() <= e.block.priority.ordinal())) ||
+                        (bdst < dst && (!usePriority || closest.block.priority.ordinal() <= e.block.priority.ordinal())) ||
                         //priority is used, and new block has higher priority regardless of range
                         (usePriority && closest.block.priority.ordinal() < e.block.priority.ordinal()))){
-                            dst = ndst;
+                            dst = bdst;
                             closest = e;
                         }
                     }

core/src/mindustry/ai/types/BuilderAI.java

@@ -13,9 +13,12 @@ import mindustry.world.blocks.ConstructBlock.*;
 import static mindustry.Vars.*;
 
 public class BuilderAI extends AIController{
-    float buildRadius = 1500;
+    public static float buildRadius = 1500, retreatDst = 110f, fleeRange = 370f, retreatDelay = Time.toSeconds * 2f;
+
     boolean found = false;
     @Nullable Unit following;
+    @Nullable Teamc enemy;
+    float retreatTimer;
 
     @Override
     public void updateMovement(){
@@ -27,6 +30,7 @@ public class BuilderAI extends AIController{
         unit.updateBuilding = true;
 
         if(following != null){
+            retreatTimer = 0f;
             //try to follow and mimic someone
 
             //validate follower
@@ -39,9 +43,25 @@ public class BuilderAI extends AIController{
             //set to follower's first build plan, whatever that is
             unit.plans.clear();
             unit.plans.addFirst(following.buildPlan());
+        }else if(unit.buildPlan() == null){
+            //not following anyone or building
+            if(timer.get(timerTarget4, 40)){
+                enemy = target(unit.x, unit.y, fleeRange, true, true);
+            }
+
+            //fly away from enemy when not doing anything, but only after a delay
+            if((retreatTimer += Time.delta) >= retreatDelay){
+                if(enemy != null){
+                    var core = unit.closestCore();
+                    if(core != null && !unit.within(core, retreatDst)){
+                        moveTo(core, retreatDst);
+                    }
+                }
+            }
         }
 
         if(unit.buildPlan() != null){
+            retreatTimer = 0f;
             //approach request if building
             BuildPlan req = unit.buildPlan();
 

core/src/mindustry/ai/types/LogicAI.java

@@ -128,6 +128,9 @@ public class LogicAI extends AIController{
             vec.setZero();
         }
 
+        //do not move when infinite vectors are used.
+        if(vec.isNaN() || vec.isInfinite()) return;
+
         unit.approach(vec);
     }
 

core/src/mindustry/ai/types/RepairAI.java

@@ -1,11 +1,16 @@
 package mindustry.ai.types;
 
+import arc.util.*;
 import mindustry.entities.*;
 import mindustry.entities.units.*;
 import mindustry.gen.*;
 import mindustry.world.blocks.ConstructBlock.*;
 
 public class RepairAI extends AIController{
+    public static float retreatDst = 160f, fleeRange = 310f, retreatDelay = Time.toSeconds * 3f;
+
+    @Nullable Teamc avoid;
+    float retreatTimer;
 
     @Override
     protected void updateMovement(){
@@ -29,6 +34,25 @@ public class RepairAI extends AIController{
 
             unit.lookAt(target);
         }
+
+        //not repairing
+        if(!(target instanceof Building)){
+            if(timer.get(timerTarget4, 40)){
+                avoid = target(unit.x, unit.y, fleeRange, true, true);
+            }
+
+            if((retreatTimer += Time.delta) >= retreatDelay){
+                //fly away from enemy when not doing anything
+                if(avoid != null){
+                    var core = unit.closestCore();
+                    if(core != null && !unit.within(core, retreatDst)){
+                        moveTo(core, retreatDst);
+                    }
+                }
+            }
+        }else{
+            retreatTimer = 0f;
+        }
     }
 
     @Override

core/src/mindustry/ai/types/SuicideAI.java

@@ -1,5 +1,6 @@
 package mindustry.ai.types;
 
+import arc.math.geom.*;
 import mindustry.*;
 import mindustry.ai.*;
 import mindustry.entities.*;
@@ -47,7 +48,8 @@ public class SuicideAI extends GroundAI{
 
                 //raycast for target
                 boolean blocked = Vars.world.raycast(unit.tileX(), unit.tileY(), target.tileX(), target.tileY(), (x, y) -> {
-                    Tile tile = Vars.world.tile(x, y);
+                    for(Point2 p : Geometry.d4c){
+                        Tile tile = Vars.world.tile(x + p.x, y + p.y);
                         if(tile != null && tile.build == target) return false;
                         if(tile != null && tile.build != null && tile.build.team != unit.team()){
                             blockedByBlock = true;
@@ -55,6 +57,8 @@ public class SuicideAI extends GroundAI{
                         }else{
                             return tile == null || tile.solid();
                         }
+                    }
+                    return false;
                 });
 
                 //shoot when there's an enemy block in the way

core/src/mindustry/content/Blocks.java

@@ -1,8 +1,6 @@
 package mindustry.content;
 
-import arc.*;
 import arc.graphics.*;
-import arc.graphics.g2d.*;
 import arc.struct.*;
 import mindustry.*;
 import mindustry.ctype.*;
@@ -97,36 +95,9 @@ public class Blocks implements ContentList{
     public void load(){
         //region environment
 
-        air = new Floor("air"){
+        air = new AirBlock("air");
-            {
-                alwaysReplace = true;
-                hasShadow = false;
-                useColor = false;
-                wall = this;
-            }
 
-            @Override public void drawBase(Tile tile){}
+        spawn = new SpawnBlock("spawn");
-            @Override public void load(){}
-            @Override public void init(){}
-            @Override public boolean isHidden(){ return true; }
-
-            @Override
-            public TextureRegion[] variantRegions(){
-                if(variantRegions == null){
-                    variantRegions = new TextureRegion[]{Core.atlas.find("clear")};
-                }
-                return variantRegions;
-            }
-        };
-
-        spawn = new OverlayFloor("spawn"){
-            {
-                variants = 0;
-                needsSurface = false;
-            }
-            @Override
-            public void drawBase(Tile tile){}
-        };
 
         cliff = new Cliff("cliff"){{
             inEditor = false;
@@ -2076,6 +2047,7 @@ public class Blocks implements ContentList{
             hasPower = true;
             consumes.power(10f);
             buildCostMultiplier = 0.5f;
+            health = size * size * 80;
         }};
 
         //endregion campaign

core/src/mindustry/content/Fx.java

@@ -1609,6 +1609,12 @@ public class Fx{
         Fill.square(e.x, e.y, e.rotation * tilesize / 2f);
     }),
 
+    lightBlock = new Effect(60, e -> {
+        color(e.color);
+        alpha(e.fout() * 1);
+        Fill.square(e.x, e.y, e.rotation * tilesize / 2f);
+    }),
+
     overdriveBlockFull = new Effect(60, e -> {
         color(e.color);
         alpha(e.fslope() * 0.4f);

core/src/mindustry/content/UnitTypes.java

@@ -565,9 +565,9 @@ public class UnitTypes implements ContentList{
                     hitEffect = Fx.pulverize;
                     lifetime = 10f;
                     speed = 1f;
-                    splashDamageRadius = 70f;
+                    splashDamageRadius = 58f;
                     instantDisappear = true;
-                    splashDamage = 80f;
+                    splashDamage = 85f;
                     killShooter = true;
                     hittable = false;
                     collidesAir = true;
@@ -769,7 +769,7 @@ public class UnitTypes implements ContentList{
                     width = height = 19f;
                     collidesTiles = true;
                     ammoMultiplier = 4f;
-                    splashDamageRadius = 95f;
+                    splashDamageRadius = 80f;
                     splashDamage = 65f;
                     backColor = Pal.sapBulletBack;
                     frontColor = lightningColor = Pal.sapBullet;
@@ -867,7 +867,7 @@ public class UnitTypes implements ContentList{
                     width = height = 25f;
                     collidesTiles = collides = true;
                     ammoMultiplier = 4f;
-                    splashDamageRadius = 90f;
+                    splashDamageRadius = 80f;
                     splashDamage = 75f;
                     backColor = Pal.sapBulletBack;
                     frontColor = lightningColor = Pal.sapBullet;
@@ -888,7 +888,7 @@ public class UnitTypes implements ContentList{
                         lifetime = 90f;
                         width = height = 20f;
                         collidesTiles = false;
-                        splashDamageRadius = 80f;
+                        splashDamageRadius = 70f;
                         splashDamage = 40f;
                         backColor = Pal.sapBulletBack;
                         frontColor = lightningColor = Pal.sapBullet;
@@ -1366,8 +1366,8 @@ public class UnitTypes implements ContentList{
                     collides = false;
 
                     healPercent = 15f;
-                    splashDamage = 230f;
+                    splashDamage = 220f;
-                    splashDamageRadius = 120f;
+                    splashDamageRadius = 80f;
                 }};
             }});
         }};
@@ -1537,7 +1537,7 @@ public class UnitTypes implements ContentList{
                     width = 15f;
                     collidesTiles = false;
                     ammoMultiplier = 4f;
-                    splashDamageRadius = 60f;
+                    splashDamageRadius = 50f;
                     splashDamage = 80f;
                     backColor = Pal.missileYellowBack;
                     frontColor = Pal.missileYellow;

core/src/mindustry/core/NetClient.java

@@ -75,6 +75,7 @@ public class NetClient implements ApplicationListener{
 
             ConnectPacket c = new ConnectPacket();
             c.name = player.name;
+            c.locale = Core.settings.getString("locale");
             c.mods = mods.getModStrings();
             c.mobile = mobile;
             c.versionType = Version.type;
@@ -480,7 +481,7 @@ public class NetClient implements ApplicationListener{
             netClient.byteStream.setBytes(net.decompressSnapshot(coreData, coreDataLen));
             DataInputStream input = netClient.dataStream;
 
-            byte cores = input.readByte();
+            int cores = input.readInt();
             for(int i = 0; i < cores; i++){
                 int pos = input.readInt();
                 Tile tile = world.tile(pos);

core/src/mindustry/core/NetServer.java

@@ -195,6 +195,10 @@ public class NetServer implements ApplicationListener{
                 return;
             }
 
+            if(packet.locale == null){
+                packet.locale = "en_US";
+            }
+
             String ip = con.address;
 
             admins.updatePlayerJoined(uuid, ip, packet.name);
@@ -215,6 +219,7 @@ public class NetServer implements ApplicationListener{
             player.con.uuid = uuid;
             player.con.mobile = packet.mobile;
             player.name = packet.name;
+            player.locale = packet.locale;
             player.color.set(packet.color).a(1f);
 
             //save admin ID but don't overwrite it
@@ -847,7 +852,7 @@ public class NetServer implements ApplicationListener{
         syncStream.reset();
         int sum = state.teams.present.sum(t -> t.cores.size);
 
-        dataStream.writeByte(sum);
+        dataStream.writeInt(sum);
 
         for(TeamData data : state.teams.present){
             for(CoreBuild entity : data.cores){

core/src/mindustry/core/Renderer.java

@@ -67,7 +67,6 @@ public class Renderer implements ApplicationListener{
     @Override
     public void update(){
         Color.white.set(1f, 1f, 1f, 1f);
-        Gl.clear(Gl.stencilBufferBit);
 
         float dest = Mathf.round(targetscale, 0.5f);
         camerascale = Mathf.lerpDelta(camerascale, dest, 0.1f);
@@ -208,7 +207,7 @@ public class Renderer implements ApplicationListener{
         Draw.draw(Layer.background, this::drawBackground);
         Draw.draw(Layer.floor, blocks.floor::drawFloor);
         Draw.draw(Layer.block - 1, blocks::drawShadows);
-        Draw.draw(Layer.block, () -> {
+        Draw.draw(Layer.block - 0.09f, () -> {
             blocks.floor.beginDraw();
             blocks.floor.drawLayer(CacheLayer.walls);
             blocks.floor.endDraw();

core/src/mindustry/core/UI.java

@@ -108,7 +108,7 @@ public class UI implements ApplicationListener, Loadable{
         Dialog.setHideAction(() -> sequence(fadeOut(0.1f)));
 
         Tooltips.getInstance().animations = false;
-        Tooltips.getInstance().textProvider = text -> new Tooltip(t -> t.background(Styles.black5).margin(4f).add(text));
+        Tooltips.getInstance().textProvider = text -> new Tooltip(t -> t.background(Styles.black6).margin(4f).add(text));
 
         Core.settings.setErrorHandler(e -> {
             Log.err(e);

core/src/mindustry/core/World.java

@@ -4,6 +4,7 @@ import arc.*;
 import arc.func.*;
 import arc.math.*;
 import arc.math.geom.*;
+import arc.math.geom.Geometry.*;
 import arc.struct.*;
 import arc.struct.ObjectIntMap.*;
 import arc.util.*;
@@ -554,10 +555,6 @@ public class World{
         return dark;
     }
 
-    public interface Raycaster{
-        boolean accept(int x, int y);
-    }
-
     private class Context implements WorldContext{
 
         Context(){

core/src/mindustry/editor/MapEditor.java

@@ -8,6 +8,7 @@ import arc.math.geom.*;
 import arc.struct.*;
 import mindustry.content.*;
 import mindustry.editor.DrawOperation.*;
+import mindustry.entities.units.*;
 import mindustry.game.*;
 import mindustry.gen.*;
 import mindustry.io.*;
@@ -259,7 +260,7 @@ public class MapEditor{
         clearOp();
 
         Tiles previous = world.tiles;
-        int offsetX = -(width - width()) / 2, offsetY = -(height - height()) / 2;
+        int offsetX = (width() - width) / 2, offsetY = (height() - height) / 2;
         loading = true;
 
         Tiles tiles = world.resize(width, height);
@@ -275,7 +276,17 @@ public class MapEditor{
                     if(tile.build != null && tile.isCenter()){
                         tile.build.x = x * tilesize + tile.block().offset;
                         tile.build.y = y * tilesize + tile.block().offset;
+
+                        //shift links to account for map resize
+                        Object config = tile.build.config();
+                        if(config != null){
+                            Object out = BuildPlan.pointConfig(tile.block(), config, p -> p.sub(offsetX, offsetY));
+                            if(out != config){
+                                tile.build.configureAny(out);
                             }
+                        }
+                    }
+
                 }else{
                     tiles.set(x, y, new EditorTile(x, y, Blocks.stone.id, (short)0, (short)0));
                 }

core/src/mindustry/editor/MapEditorDialog.java

@@ -156,7 +156,10 @@ public class MapEditorDialog extends Dialog implements Disposable{
                 }
 
                 platform.publish(map);
-            }).padTop(-3).size(swidth * 2f + 10, 60f).update(b -> b.setText(editor.tags.containsKey("steamid") ? editor.tags.get("author").equals(player.name) ? "@workshop.listing" : "@view.workshop" : "@editor.publish.workshop"));
+            }).padTop(-3).size(swidth * 2f + 10, 60f).update(b ->
+                b.setText(editor.tags.containsKey("steamid") ?
+                    editor.tags.get("author").equals(steamPlayerName) ? "@workshop.listing" : "@view.workshop" :
+                "@editor.publish.workshop"));
 
             menu.cont.row();
         }

core/src/mindustry/entities/Damage.java

@@ -6,7 +6,6 @@ import arc.math.*;
 import arc.math.geom.*;
 import arc.struct.*;
 import arc.util.*;
-import mindustry.annotations.Annotations.*;
 import mindustry.content.*;
 import mindustry.core.*;
 import mindustry.game.EventType.*;
@@ -25,11 +24,10 @@ public class Damage{
     private static Rect hitrect = new Rect();
     private static Vec2 tr = new Vec2(), seg1 = new Vec2(), seg2 = new Vec2();
     private static Seq<Unit> units = new Seq<>();
-    private static GridBits bits = new GridBits(30, 30);
-    private static IntQueue propagation = new IntQueue();
     private static IntSet collidedBlocks = new IntSet();
     private static Building tmpBuilding;
     private static Unit tmpUnit;
+    private static IntFloatMap damages = new IntFloatMap();
 
     /** Creates a dynamic explosion based on specified parameters. */
     public static void dynamicExplosion(float x, float y, float flammability, float explosiveness, float power, float radius, boolean damage){
@@ -116,7 +114,15 @@ public class Damage{
      * Only enemies of the specified team are damaged.
      */
     public static void collideLine(Bullet hitter, Team team, Effect effect, float x, float y, float angle, float length, boolean large){
-        length = findLaserLength(hitter, length);
+        collideLine(hitter, team, effect, x, y, angle, length, large, true);
+    }
+
+    /**
+     * Damages entities in a line.
+     * Only enemies of the specified team are damaged.
+     */
+    public static void collideLine(Bullet hitter, Team team, Effect effect, float x, float y, float angle, float length, boolean large, boolean laser){
+        if(laser) length = findLaserLength(hitter, length);
 
         collidedBlocks.clear();
         tr.trns(angle, length);
@@ -207,9 +213,9 @@ public class Damage{
     public static Healthc linecast(Bullet hitter, float x, float y, float angle, float length){
         tr.trns(angle, length);
         
-        if(hitter.type.collidesGround){
         tmpBuilding = null;
 
+        if(hitter.type.collidesGround){
             world.raycastEachWorld(x, y, x + tr.x, y + tr.y, (cx, cy) -> {
                 Building tile = world.build(cx, cy);
                 if(tile != null && tile.team != hitter.team){
@@ -218,8 +224,6 @@ public class Damage{
                 }
                 return false;
             });
-
-            if(tmpBuilding != null) return tmpBuilding;
         }
 
         rect.setPosition(x, y).setSize(tr.x, tr.y);
@@ -263,6 +267,14 @@ public class Damage{
 
         Units.nearbyEnemies(hitter.team, rect, cons);
 
+        if(tmpBuilding != null && tmpUnit != null){
+            if(Mathf.dst2(x, y, tmpUnit.getX(), tmpUnit.getY()) <= Mathf.dst2(x, y, tmpBuilding.getX(), tmpBuilding.getY())){
+                return tmpUnit;
+            }
+        }else if(tmpBuilding != null){
+            return tmpBuilding;
+        }
+
         return tmpUnit;
     }
 
@@ -351,64 +363,85 @@ public class Damage{
 
         if(ground){
             if(!complete){
-                int trad = (int)(radius / tilesize);
+                //increase damage slightly to compensate for new algorithm
-                Tile tile = world.tileWorld(x, y);
+                tileDamage(team, World.toTile(x), World.toTile(y), radius / tilesize, damage * 1.1f);
-                if(tile != null){
-                    tileDamage(team, tile.x, tile.y, trad, damage);
-                }
             }else{
                 completeDamage(team, x, y, radius, damage);
             }
         }
     }
 
-    public static void tileDamage(Team team, int startx, int starty, int baseRadius, float baseDamage){
+    public static void tileDamage(Team team, int x, int y, float baseRadius, float damage){
-        //tile damage is posted, so that destroying a block that causes a chain explosion will run in the next frame
+
-        //this prevents recursive damage calls from messing up temporary variables
         Core.app.post(() -> {
 
-            bits.clear();
+            var in = world.build(x, y);
-            propagation.clear();
+            //spawned inside a multiblock. this means that damage needs to be dealt directly.
-            int bitOffset = bits.width() / 2;
+            //why? because otherwise the building would absorb everything in one cell, which means much less damage than a nearby explosion.
+            //this needs to be compensated
+            if(in != null && in.team != team && in.block.size > 1 && in.health > damage){
+                //deal the damage of an entire side + 1, to be equivalent with maximum 'standard' damage
+                in.damage(damage * (in.block.size + 1));
+                //no need to continue with the explosion
+                return;
+            }
 
-            propagation.addFirst(PropCell.get((byte)0, (byte)0, (short)baseDamage));
+            //cap radius to prevent lag
-            //clamp radius to fit bits
+            float radius = Math.min(baseRadius, 30), rad2 = radius * radius;
-            int radius = Math.min(baseRadius, bits.width() / 2);
+            int rays = Mathf.ceil(radius * 2 * Mathf.pi);
+            double spacing = Math.PI * 2.0 / rays;
+            damages.clear();
 
-            while(!propagation.isEmpty()){
+            //raycast from each angle
-                int prop = propagation.removeLast();
+            for(int i = 0; i <= rays; i++){
-                int x = PropCell.x(prop);
+                float dealt = 0f;
-                int y = PropCell.y(prop);
+                int startX = x;
-                int damage = PropCell.damage(prop);
+                int startY = y;
-                //manhattan distance used for calculating falloff, results in a diamond pattern
+                int endX = x + (int)(Math.cos(spacing * i) * radius), endY = y + (int)(Math.sin(spacing * i) * radius);
-                int dst = Math.abs(x) + Math.abs(y);
 
-                int scaledDamage = (int)(damage * (1f - (float)dst / radius));
+                int xDist = Math.abs(endX - startX);
+                int yDist = -Math.abs(endY - startY);
+                int xStep = (startX < endX ? +1 : -1);
+                int yStep = (startY < endY ? +1 : -1);
+                int error = xDist + yDist;
 
-                bits.set(bitOffset + x, bitOffset + y);
+                while(startX != endX || startY != endY){
-                Tile tile = world.tile(startx + x, starty + y);
+                    var build = world.build(startX, startY);
+                    if(build != null && build.team != team){
+                        //damage dealt at circle edge
+                        float edgeScale = 0.6f;
+                        float mult = (1f-(Mathf.dst2(startX, startY, x, y) / rad2) + edgeScale) / (1f + edgeScale);
+                        float next = damage * mult - dealt;
+                        //register damage dealt
+                        int p = Point2.pack(startX, startY);
+                        damages.put(p, Math.max(damages.get(p), next));
+                        //register as hit
+                        dealt += build.health;
 
-                if(scaledDamage <= 0 || tile == null) continue;
+                        if(next - dealt <= 0){
-
+                            break;
-                //apply damage to entity if needed
-                if(tile.build != null && tile.build.team != team){
-                    int health = (int)(tile.build.health / (tile.block().size * tile.block().size));
-                    if(tile.build.health > 0){
-                        tile.build.damage(scaledDamage);
-                        scaledDamage -= health;
-
-                        if(scaledDamage <= 0) continue;
                         }
                     }
 
-                for(Point2 p : Geometry.d4){
+                    if(2 * error - yDist > xDist - 2 * error){
-                    if(!bits.get(bitOffset + x + p.x, bitOffset + y + p.y)){
+                        error += yDist;
-                        propagation.addFirst(PropCell.get((byte)(x + p.x), (byte)(y + p.y), (short)scaledDamage));
+                        startX += xStep;
+                    }else{
+                        error += xDist;
+                        startY += yStep;
                     }
                 }
             }
+
+            //apply damage
+            for(var e : damages){
+                int cx = Point2.x(e.key), cy = Point2.y(e.key);
+                var build = world.build(cx, cy);
+                if(build != null){
+                    build.damage(e.value);
+                }
+            }
         });
-
     }
 
     private static void completeDamage(Team team, float x, float y, float radius, float damage){
@@ -429,11 +462,4 @@ public class Damage{
         float scaled = Mathf.lerp(1f - dist / radius, 1f, falloff);
         return damage * scaled;
     }
-
-    @Struct
-    static class PropCellStruct{
-        byte x;
-        byte y;
-        short damage;
-    }
 }

core/src/mindustry/entities/Units.java

@@ -6,6 +6,7 @@ import arc.math.geom.*;
 import arc.struct.*;
 import mindustry.annotations.Annotations.*;
 import mindustry.content.*;
+import mindustry.entities.comp.*;
 import mindustry.game.*;
 import mindustry.game.Teams.*;
 import mindustry.gen.*;
@@ -75,7 +76,7 @@ public class Units{
         if((team == state.rules.waveTeam && !state.rules.pvp) || (state.isCampaign() && team == state.rules.waveTeam)){
             return Integer.MAX_VALUE;
         }
-        return state.rules.unitCap + indexer.getExtraUnits(team);
+        return Math.max(0, state.rules.unitCapVariable ? state.rules.unitCap + indexer.getExtraUnits(team) : state.rules.unitCap);
     }
 
     /** @return whether this player can interact with a specific tile. if either of these are null, returns true.*/
@@ -93,7 +94,7 @@ public class Units{
      * @return whether the target is invalid
      */
     public static boolean invalidateTarget(Posc target, Team team, float x, float y, float range){
-        return target == null || (range != Float.MAX_VALUE && !target.within(x, y, range)) || (target instanceof Teamc && ((Teamc)target).team() == team) || (target instanceof Healthc && !((Healthc)target).isValid());
+        return target == null || (range != Float.MAX_VALUE && !target.within(x, y, range + (target instanceof Sized hb ? hb.hitSize()/2f : 0f))) || (target instanceof Teamc t && t.team() == team) || (target instanceof Healthc h && !h.isValid());
     }
 
     /** See {@link #invalidateTarget(Posc, Team, float, float, float)} */
@@ -217,7 +218,7 @@ public class Units{
         cdist = 0f;
 
         nearbyEnemies(team, x - range, y - range, range*2f, range*2f, e -> {
-            if(e.dead() || !predicate.get(e) || !e.within(x, y, range)) return;
+            if(e.dead() || !predicate.get(e) || !e.within(x, y, range + e.hitSize/2f)) return;
 
             float cost = sort.cost(e, x, y);
             if(result == null || cost < cdist){
@@ -292,7 +293,7 @@ public class Units{
     /** Iterates over all units in a circle around this position. */
     public static void nearby(Team team, float x, float y, float radius, Cons<Unit> cons){
         nearby(team, x - radius, y - radius, radius*2f, radius*2f, unit -> {
-            if(unit.within(x, y, radius)){
+            if(unit.within(x, y, radius + unit.hitSize/2f)){
                 cons.get(unit);
             }
         });

core/src/mindustry/entities/bullet/BulletType.java

@@ -273,7 +273,7 @@ public abstract class BulletType extends Content{
         if(homingPower > 0.0001f && b.time >= homingDelay){
             Teamc target = Units.closestTarget(b.team, b.x, b.y, homingRange, e -> (e.isGrounded() && collidesGround) || (e.isFlying() && collidesAir), t -> collidesGround);
             if(target != null){
-                b.vel.setAngle(Mathf.slerpDelta(b.rotation(), b.angleTo(target), homingPower));
+                b.vel.setAngle(Angles.moveToward(b.rotation(), b.angleTo(target), homingPower * Time.delta * 50f));
             }
         }
 

core/src/mindustry/entities/bullet/LightningBulletType.java

@@ -8,8 +8,8 @@ import mindustry.gen.*;
 import mindustry.graphics.*;
 
 public class LightningBulletType extends BulletType{
-    protected Color lightningColor = Pal.lancerLaser;
+    public Color lightningColor = Pal.lancerLaser;
-    protected int lightningLength = 25, lightningLengthRand = 0;
+    public int lightningLength = 25, lightningLengthRand = 0;
 
     public LightningBulletType(){
         super(0.0001f, 1f);

core/src/mindustry/entities/bullet/RailBulletType.java

@@ -54,7 +54,7 @@ public class RailBulletType extends BulletType{
         super.init(b);
 
         b.fdata = length;
-        Damage.collideLine(b, b.team, b.type.hitEffect, b.x, b.y, b.rotation(), length, false);
+        Damage.collideLine(b, b.team, b.type.hitEffect, b.x, b.y, b.rotation(), length, false, false);
         float resultLen = b.fdata;
 
         Vec2 nor = Tmp.v1.set(b.vel).nor();

core/src/mindustry/entities/comp/BuildingComp.java

@@ -43,7 +43,7 @@ import static mindustry.Vars.*;
 
 @EntityDef(value = {Buildingc.class}, isFinal = false, genio = false, serialize = false)
 @Component(base = true)
-abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc, QuadTreeObject, Displayable, Senseable, Controllable{
+abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc, QuadTreeObject, Displayable, Senseable, Controllable, Sized{
     //region vars and initialization
     static final float timeToSleep = 60f * 1, timeToUncontrol = 60f * 6;
     static final ObjectSet<Building> tmpTiles = new ObjectSet<>();
@@ -792,6 +792,7 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
 
         for(Building other : proximity){
             if(other != null && other.power != null
+            && other.team == team
             && !(block.consumesPower && other.block.consumesPower && !block.outputsPower && !other.block.outputsPower)
             && conductsTo(other) && other.conductsTo(self()) && !power.links.contains(other.pos())){
                 out.add(other);
@@ -800,7 +801,7 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
 
         for(int i = 0; i < power.links.size; i++){
             Tile link = world.tile(power.links.get(i));
-            if(link != null && link.build != null && link.build.power != null) out.add(link.build);
+            if(link != null && link.build != null && link.build.power != null && link.build.team == team) out.add(link.build);
         }
         return out;
     }
@@ -1277,6 +1278,11 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
         return tile.build == self() && !dead();
     }
 
+    @Override
+    public float hitSize(){
+        return tile.block().size * tilesize;
+    }
+
     @Replace
     @Override
     public void kill(){
@@ -1326,7 +1332,7 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
             case enabled -> enabled ? 1 : 0;
             case controlled -> this instanceof ControlBlock c ? c.isControlled() ? 1 : 0 : 0;
             case payloadCount -> getPayload() != null ? 1 : 0;
-            default -> 0;
+            default -> Float.NaN; //gets converted to null in logic
         };
     }
 
@@ -1339,14 +1345,13 @@ abstract class BuildingComp implements Posc, Teamc, Healthc, Buildingc, Timerc,
             case payloadType -> getPayload() instanceof UnitPayload p1 ? p1.unit.type : getPayload() instanceof BuildPayload p2 ? p2.block() : null;
             default -> noSensed;
         };
-
     }
 
     @Override
     public double sense(Content content){
-        if(content instanceof Item && items != null) return items.get((Item)content);
+        if(content instanceof Item i && items != null) return items.get(i);
-        if(content instanceof Liquid && liquids != null) return liquids.get((Liquid)content);
+        if(content instanceof Liquid l && liquids != null) return liquids.get(l);
-        return 0;
+        return Float.NaN; //invalid sense
     }
 
     @Override

core/src/mindustry/entities/comp/HitboxComp.java

@@ -8,7 +8,7 @@ import mindustry.annotations.Annotations.*;
 import mindustry.gen.*;
 
 @Component
-abstract class HitboxComp implements Posc, QuadTreeObject{
+abstract class HitboxComp implements Posc, Sized, QuadTreeObject{
     @Import float x, y;
 
     transient float lastX, lastY, deltaX, deltaY, hitSize;
@@ -28,6 +28,11 @@ abstract class HitboxComp implements Posc, QuadTreeObject{
         updateLastPosition();
     }
 
+    @Override
+    public float hitSize(){
+        return hitSize;
+    }
+
     void getCollisions(Cons<QuadTree> consumer){
 
     }

core/src/mindustry/entities/comp/PlayerComp.java

@@ -43,6 +43,8 @@ abstract class PlayerComp implements UnitController, Entityc, Syncc, Timerc, Dra
     String name = "noname";
     Color color = new Color();
 
+    //locale should not be synced.
+    transient String locale = "en";
     transient float deathTimer;
     transient String lastText = "";
     transient float textFadeTime;

core/src/mindustry/entities/comp/Sized.java

@@ -0,0 +1,5 @@
+package mindustry.entities.comp;
+
+public interface Sized{
+    float hitSize();
+}

core/src/mindustry/entities/effect/MultiEffect.java

@@ -25,8 +25,13 @@ public class MultiEffect extends Effect{
 
     @Override
     public void render(EffectContainer e){
+        int index = 0;
         for(Effect f : effects){
-            e.scaled(f.lifetime, f::render);
+            int i = ++index;
+            e.scaled(f.lifetime, cont -> {
+                cont.id = e.id + i;
+                f.render(cont);
+            });
             clip = Math.max(clip, f.clip);
         }
     }

core/src/mindustry/entities/units/AIController.java

@@ -15,7 +15,7 @@ import static mindustry.Vars.*;
 
 public class AIController implements UnitController{
     protected static final Vec2 vec = new Vec2();
-    protected static final int timerTarget = 0, timerTarget2 = 1, timerTarget3 = 2;
+    protected static final int timerTarget = 0, timerTarget2 = 1, timerTarget3 = 2, timerTarget4 = 3;
 
     protected Unit unit;
     protected Interval timer = new Interval(4);

core/src/mindustry/game/Rules.java

@@ -44,6 +44,8 @@ public class Rules{
     public boolean fire = true;
     /** Whether units use and require ammo. */
     public boolean unitAmmo = false;
+    /** Whether cores add to unit limit */
+    public boolean unitCapVariable = true;
     /** How fast unit pads build units. */
     public float unitBuildSpeedMultiplier = 1f;
     /** How much damage any other units deal. */
@@ -63,7 +65,7 @@ public class Rules{
     /** Radius around enemy wave drop zones.*/
     public float dropZoneRadius = 300f;
     /** Time between waves in ticks. */
-    public float waveSpacing = 60 * 60 * 2;
+    public float waveSpacing = 2 * Time.toMinutes;
     /** Wave after which the player 'wins'. Used in sectors. Use a value <= 0 to disable. */
     public int winWave = 0;
     /** Base unit cap. Can still be increased by blocks. */
@@ -137,7 +139,7 @@ public class Rules{
     }
 
     /** A simple map for storing TeamRules in an efficient way without hashing. */
-    public static class TeamRules implements Serializable{
+    public static class TeamRules implements JsonSerializable{
         final TeamRule[] values = new TeamRule[Team.all.length];
 
         public TeamRule get(Team team){

core/src/mindustry/game/SpawnGroup.java

@@ -18,7 +18,7 @@ import static mindustry.Vars.*;
  * weapon equipped, ammo used, and status effects.
  * Each spawn group can have multiple sub-groups spawned in different areas of the map.
  */
-public class SpawnGroup implements Serializable{
+public class SpawnGroup implements JsonSerializable{
     public static final int never = Integer.MAX_VALUE;
 
     /** The unit type spawned */

core/src/mindustry/graphics/FloorRenderer.java

@@ -119,6 +119,7 @@ public class FloorRenderer implements Disposable{
             return;
         }
 
+        Draw.flush();
         cbatch.setProjection(Core.camera.mat);
         cbatch.beginDraw();
 

core/src/mindustry/graphics/LoadRenderer.java

@@ -54,7 +54,7 @@ public class LoadRenderer implements Disposable{
         bars = new Bar[]{
             new Bar("s_proc#", OS.cores / 16f, OS.cores < 4),
             new Bar("c_aprog", () -> assets != null, () -> assets.getProgress(), () -> false),
-            new Bar("g_vtype", graphics.getGLVersion().type == Type.GLES ? 0.5f : 1f, graphics.getGLVersion().type == Type.GLES),
+            new Bar("g_vtype", graphics.getGLVersion().type == GlType.GLES ? 0.5f : 1f, graphics.getGLVersion().type == GlType.GLES),
             new Bar("s_mem#", () -> true, () -> Core.app.getJavaHeap() / 1024f / 1024f / 200f, () -> Core.app.getJavaHeap() > 1024 * 1024 * 110),
             new Bar("v_ver#", () -> Version.build != 0, () -> Version.build == -1 ? 0.3f : (Version.build - 103f) / 10f, () -> !Version.modifier.equals("release")),
             new Bar("s_osv", OS.isWindows ? 0.35f : OS.isLinux ? 0.9f : OS.isMac ? 0.5f : 0.2f, OS.isMac),

core/src/mindustry/graphics/Shaders.java

@@ -15,10 +15,10 @@ import mindustry.type.*;
 import static mindustry.Vars.*;
 
 public class Shaders{
-    public static BlockBuild blockbuild;
+    public static BlockBuildShader blockbuild;
     public static @Nullable ShieldShader shield;
     public static BuildBeamShader buildBeam;
-    public static UnitBuild build;
+    public static UnitBuildShader build;
     public static DarknessShader darkness;
     public static LightShader light;
     public static SurfaceShader water, mud, tar, slag, space;
@@ -31,7 +31,7 @@ public class Shaders{
 
     public static void init(){
         mesh = new MeshShader();
-        blockbuild = new BlockBuild();
+        blockbuild = new BlockBuildShader();
         try{
             shield = new ShieldShader();
         }catch(Throwable t){
@@ -40,7 +40,7 @@ public class Shaders{
             t.printStackTrace();
         }
         buildBeam = new BuildBeamShader();
-        build = new UnitBuild();
+        build = new UnitBuildShader();
         darkness = new DarknessShader();
         light = new LightShader();
         water = new SurfaceShader("water");
@@ -142,12 +142,16 @@ public class Shaders{
         }
     }
 
-    public static class UnitBuild extends LoadShader{
+    /** @deprecated transition class for mods; use UnitBuildShader instead. */
+    @Deprecated
+    public static class UnitBuild extends UnitBuildShader{}
+
+    public static class UnitBuildShader extends LoadShader{
         public float progress, time;
         public Color color = new Color();
         public TextureRegion region;
 
-        public UnitBuild(){
+        public UnitBuildShader(){
             super("unitbuild", "default");
         }
 
@@ -162,11 +166,11 @@ public class Shaders{
         }
     }
 
-    public static class BlockBuild extends LoadShader{
+    public static class BlockBuildShader extends LoadShader{
         public float progress;
         public TextureRegion region = new TextureRegion();
 
-        public BlockBuild(){
+        public BlockBuildShader(){
             super("blockbuild", "default");
         }
 

core/src/mindustry/input/DesktopInput.java

@@ -8,7 +8,6 @@ import arc.graphics.g2d.*;
 import arc.math.*;
 import arc.math.geom.*;
 import arc.scene.*;
-import arc.scene.event.*;
 import arc.scene.ui.*;
 import arc.scene.ui.layout.*;
 import arc.util.*;
@@ -42,39 +41,40 @@ public class DesktopInput extends InputHandler{
     /** Selected build request for movement. */
     public @Nullable BuildPlan sreq;
     /** Whether player is currently deleting removal requests. */
-    public boolean deleting = false, wasBuilding = true, shouldShoot = false, panning = false;
+    public boolean deleting = false, shouldShoot = false, panning = false;
     /** Mouse pan speed. */
     public float panScale = 0.005f, panSpeed = 4.5f, panBoostSpeed = 11f;
 
+    boolean showHint(){
+        return ui.hudfrag.shown && Core.settings.getBool("hints") && selectRequests.isEmpty() &&
+            (!isBuilding && !Core.settings.getBool("buildautopause") || player.unit().isBuilding() || !player.dead() && !player.unit().spawnedByCore());
+    }
+
     @Override
     public void buildUI(Group group){
-        //respawn hints
+        //building and respawn hints
         group.fill(t -> {
-            t.visible(() -> Core.settings.getBool("hints") && ui.hudfrag.shown && !player.dead() && !player.unit().spawnedByCore() && !(Core.settings.getBool("hints") && lastSchematic != null && !selectRequests.isEmpty()));
+            t.color.a = 0f;
+            t.visible(() -> (t.color.a = Mathf.lerpDelta(t.color.a, Mathf.num(showHint()), 0.15f)) > 0.001f);
             t.bottom();
             t.table(Styles.black6, b -> {
+                StringBuilder str = new StringBuilder();
                 b.defaults().left();
-                b.label(() -> Core.bundle.format("respawn", Core.keybinds.get(Binding.respawn).key.toString())).style(Styles.outlineLabel);
+                b.label(() -> {
-            }).margin(6f);
+                    if(!showHint()) return str;
-        });
+                    str.setLength(0);
-
+                    if(!isBuilding && !Core.settings.getBool("buildautopause") && !player.unit().isBuilding()){
-        //building hints
+                        str.append(Core.bundle.format("enablebuilding", Core.keybinds.get(Binding.pause_building).key.toString()));
-        group.fill(t -> {
+                    }else if(player.unit().isBuilding()){
-            t.bottom();
+                        str.append(Core.bundle.format(isBuilding ? "pausebuilding" : "resumebuilding", Core.keybinds.get(Binding.pause_building).key.toString()))
-            t.visible(() -> {
+                            .append("\n").append(Core.bundle.format("cancelbuilding", Core.keybinds.get(Binding.clear_building).key.toString()))
-                t.color.a = Mathf.lerpDelta(t.color.a, !isBuilding && !Core.settings.getBool("buildautopause") || player.unit().isBuilding() ? 1f : 0f, 0.15f);
+                            .append("\n").append(Core.bundle.format("selectschematic", Core.keybinds.get(Binding.schematic_select).key.toString()));
-
+                    }
-                return ui.hudfrag.shown && Core.settings.getBool("hints") && selectRequests.isEmpty() && t.color.a > 0.01f;
+                    if(!player.dead() && !player.unit().spawnedByCore()){
-            });
+                        str.append(str.length() != 0 ? "\n" : "").append(Core.bundle.format("respawn", Core.keybinds.get(Binding.respawn).key.toString()));
-            t.touchable(() -> t.color.a < 0.1f ? Touchable.disabled : Touchable.childrenOnly);
+                    }
-            t.table(Styles.black6, b -> {
+                    return str;
-                b.defaults().left();
+                }).style(Styles.outlineLabel);
-                b.label(() -> ((!isBuilding || !wasBuilding) && !Core.settings.getBool("buildautopause") && !player.unit().isBuilding() ?
-                    Core.bundle.format("enablebuilding", Core.keybinds.get(Binding.pause_building).key.toString()) :
-                    Core.bundle.format(isBuilding ? "pausebuilding" : "resumebuilding", Core.keybinds.get(Binding.pause_building).key.toString()) +
-                    "\n" + Core.bundle.format("cancelbuilding", Core.keybinds.get(Binding.clear_building).key.toString()) +
-                    "\n" + Core.bundle.format("selectschematic", Core.keybinds.get(Binding.schematic_select).key.toString())
-                )).style(Styles.outlineLabel);
             }).margin(10f);
         });
 
@@ -455,7 +455,6 @@ public class DesktopInput extends InputHandler{
             buildWasAutoPaused = false;
 
             if(isBuilding){
-                wasBuilding = player.unit().isBuilding();
                 player.shooting = false;
             }
         }
@@ -563,7 +562,6 @@ public class DesktopInput extends InputHandler{
             }
 
             mode = none;
-            wasBuilding = true;
         }
 
         if(Core.input.keyTap(Binding.toggle_block_status)){

core/src/mindustry/input/Placement.java

@@ -100,7 +100,7 @@ public class Placement{
             i ++;
         }
 
-        if(!addedLast) result.add(base.peek());
+        if(!addedLast && !base.isEmpty()) result.add(base.peek());
 
         points.clear();
         points.addAll(result);

core/src/mindustry/logic/ConditionOp.java

@@ -7,6 +7,7 @@ public enum ConditionOp{
     lessThanEq("<=", (a, b) -> a <= b),
     greaterThan(">", (a, b) -> a > b),
     greaterThanEq(">=", (a, b) -> a >= b),
+    strictEqual("===", (a, b) -> false),
     always("always", (a, b) -> true);
 
     public static final ConditionOp[] all = values();

core/src/mindustry/logic/LAssembler.java

@@ -13,6 +13,11 @@ public class LAssembler{
     public static ObjectMap<String, Func<String[], LStatement>> customParsers = new ObjectMap<>();
     public static final int maxTokenLength = 36;
 
+    private static final StringMap opNameChanges = StringMap.of(
+    "atan2", "angle",
+    "dst", "len"
+    );
+
     private int lastVar;
     /** Maps names to variable IDs. */
     public ObjectMap<String, BVar> vars = new ObjectMap<>();
@@ -28,6 +33,8 @@ public class LAssembler{
         putConst("@unit", null);
         //reference to self
         putConst("@this", null);
+        //global tick
+        putConst("@tick", 0);
     }
 
     public static LAssembler assemble(String data, int maxInstructions){
@@ -125,6 +132,11 @@ public class LAssembler{
                     }
                 }
 
+                //fix up changed operaiton names
+                if(type.equals("op")){
+                    arr[1] = opNameChanges.get(arr[1], arr[1]);
+                }
+
                 LStatement st = LogicIO.read(arr);
 
                 if(st != null){

core/src/mindustry/logic/LCanvas.java

@@ -41,6 +41,13 @@ public class LCanvas extends Table{
         return Core.graphics.getWidth() < Scl.scl(900f) * 1.2f;
     }
 
+    public static void tooltip(Cell<?> cell, String key){
+        String lkey = key.toLowerCase().replace(" ", "");
+        if(Core.settings.getBool("logichints", true) && Core.bundle.has(lkey)){
+            cell.get().addListener(new Tooltip(t -> t.background(Styles.black8).margin(4f).add("[lightgray]" + Core.bundle.get(lkey)).style(Styles.outlineLabel)));
+        }
+    }
+
     public void rebuild(){
         targetWidth = useRows() ? 400f : 900f;
         float s = pane != null ? pane.getScrollPercentY() : 0f;

core/src/mindustry/logic/LExecutor.java

@@ -1,5 +1,6 @@
 package mindustry.logic;
 
+import arc.*;
 import arc.math.geom.*;
 import arc.struct.*;
 import arc.util.*;
@@ -35,7 +36,8 @@ public class LExecutor{
     varCounter = 0,
     varTime = 1,
     varUnit = 2,
-    varThis = 3;
+    varThis = 3,
+    varTick = 4;
 
     public static final int
     maxGraphicsBuffer = 256,
@@ -60,6 +62,7 @@ public class LExecutor{
     public void runOnce(){
         //set time
         vars[varTime].numval = Time.millis();
+        vars[varTick].numval = Time.time;
 
         //reset to start
         if(vars[varCounter].numval >= instructions.length || vars[varCounter].numval < 0){
@@ -98,6 +101,10 @@ public class LExecutor{
 
     //region utility
 
+    private static boolean invalid(double d){
+        return Double.isNaN(d) || Double.isInfinite(d);
+    }
+
     public Var var(int index){
         //global constants have variable IDs < 0, and they are fetched from the global constants object after being negated
         return index < 0 ? constants.get(-index) : vars[index];
@@ -120,12 +127,12 @@ public class LExecutor{
 
     public double num(int index){
         Var v = var(index);
-        return v.isobj ? v.objval != null ? 1 : 0 : Double.isNaN(v.numval) || Double.isInfinite(v.numval) ? 0 : v.numval;
+        return v.isobj ? v.objval != null ? 1 : 0 : invalid(v.numval) ? 0 : v.numval;
     }
 
     public float numf(int index){
         Var v = var(index);
-        return v.isobj ? v.objval != null ? 1 : 0 : Double.isNaN(v.numval) || Double.isInfinite(v.numval) ? 0 : (float)v.numval;
+        return v.isobj ? v.objval != null ? 1 : 0 : invalid(v.numval) ? 0 : (float)v.numval;
     }
 
     public int numi(int index){
@@ -139,10 +146,15 @@ public class LExecutor{
     public void setnum(int index, double value){
         Var v = var(index);
         if(v.constant) return;
-        v.numval = Double.isNaN(value) || Double.isInfinite(value) ? 0 : value;
+        if(invalid(value)){
+            v.objval = null;
+            v.isobj = true;
+        }else{
+            v.numval = value;
             v.objval = null;
             v.isobj = false;
         }
+    }
 
     public void setobj(int index, Object value){
         Var v = var(index);
@@ -326,17 +338,19 @@ public class LExecutor{
         @Nullable
         public static LogicAI checkLogicAI(LExecutor exec, Object unitObj){
             if(unitObj instanceof Unit unit && exec.obj(varUnit) == unit && unit.team == exec.team && !unit.isPlayer() && !(unit.controller() instanceof FormationAI)){
-                if(!(unit.controller() instanceof LogicAI)){
+                if(unit.controller() instanceof LogicAI la){
-                    unit.controller(new LogicAI());
+                    return la;
-                    ((LogicAI)unit.controller()).controller = exec.building(varThis);
+                }else{
+                    var la = new LogicAI();
+                    la.controller = exec.building(varThis);
 
+                    unit.controller(la);
                     //clear old state
                     unit.mineTile = null;
                     unit.clearBuilding();
 
-                    return (LogicAI)unit.controller();
+                    return la;
                 }
-                return (LogicAI)unit.controller();
             }
             return null;
         }
@@ -622,21 +636,21 @@ public class LExecutor{
 
             //note that remote units/buildings can be sensed as well
             if(target instanceof Senseable se){
-                if(sense instanceof Content){
+                if(sense instanceof Content co){
-                    exec.setnum(to, se.sense(((Content)sense)));
+                    exec.setnum(to, se.sense(co));
-                }else if(sense instanceof LAccess){
+                }else if(sense instanceof LAccess la){
-                    Object objOut = se.senseObject((LAccess)sense);
+                    Object objOut = se.senseObject(la);
 
                     if(objOut == Senseable.noSensed){
                         //numeric output
-                        exec.setnum(to, se.sense((LAccess)sense));
+                        exec.setnum(to, se.sense(la));
                     }else{
                         //object output
                         exec.setobj(to, objOut);
                     }
                 }
             }else{
-                exec.setnum(to, 0);
+                exec.setobj(to, null);
             }
         }
     }
@@ -752,7 +766,7 @@ public class LExecutor{
                     v.objval = f.objval;
                     v.isobj = true;
                 }else{
-                    v.numval = Double.isNaN(f.numval) || Double.isInfinite(f.numval) ? 0 : f.numval;
+                    v.numval = invalid(f.numval) ? 0 : f.numval;
                     v.isobj = false;
                 }
             }
@@ -774,14 +788,17 @@ public class LExecutor{
 
         @Override
         public void run(LExecutor exec){
-            if(op.unary){
+            if(op == LogicOp.strictEqual){
+                Var v = exec.var(a), v2 = exec.var(b);
+                exec.setnum(dest, v.isobj == v2.isobj && ((v.isobj && v.objval == v2.objval) || (!v.isobj && v.numval == v2.numval)) ? 1 : 0);
+            }else if(op.unary){
                 exec.setnum(dest, op.function1.get(exec.num(a)));
             }else{
                 Var va = exec.var(a);
                 Var vb = exec.var(b);
 
                 if(op.objFunction2 != null && va.isobj && vb.isobj){
-                    //use object function if provided, and one of the variables is an object
+                    //use object function if both are objects
                     exec.setnum(dest, op.objFunction2.get(exec.obj(a), exec.obj(b)));
                 }else{
                     //otherwise use the numeric function
@@ -951,8 +968,10 @@ public class LExecutor{
                 Var vb = exec.var(compare);
                 boolean cmp;
 
-                if(op.objFunction != null && va.isobj && vb.isobj){
+                if(op == ConditionOp.strictEqual){
-                    //use object function if provided, and one of the variables is an object
+                    cmp = va.isobj == vb.isobj && ((va.isobj && va.objval == vb.objval) || (!va.isobj && va.numval == vb.numval));
+                }else if(op.objFunction != null && va.isobj && vb.isobj){
+                    //use object function if both are objects
                     cmp = op.objFunction.get(exec.obj(value), exec.obj(compare));
                 }else{
                     cmp = op.function.get(exec.num(value), exec.num(compare));
@@ -965,5 +984,37 @@ public class LExecutor{
         }
     }
 
+    public static class WaitI implements LInstruction{
+        public int value;
+
+        public float curTime;
+        public double wait;
+        public long frameId;
+
+        public WaitI(int value){
+            this.value = value;
+        }
+
+        public WaitI(){
+
+        }
+
+        @Override
+        public void run(LExecutor exec){
+            if(curTime >= exec.num(value)){
+                curTime = 0f;
+            }else{
+                //skip back to self.
+                exec.var(varCounter).numval --;
+            }
+
+            if(Core.graphics.getFrameId() != frameId){
+                curTime += Time.delta / 60f;
+                frameId = Core.graphics.getFrameId();
+            }
+        }
+    }
+
+
     //endregion
 }

core/src/mindustry/logic/LStatement.java

@@ -15,6 +15,8 @@ import mindustry.logic.LCanvas.*;
 import mindustry.logic.LExecutor.*;
 import mindustry.ui.*;
 
+import static mindustry.logic.LCanvas.*;
+
 /**
  * A statement is an intermediate representation of an instruction, to be used mostly in UI.
  * Contains all relevant variable information. */
@@ -38,13 +40,18 @@ public abstract class LStatement{
 
     //protected methods are only for internal UI layout utilities
 
+    protected void param(Cell<Label> label){
+        String text = name() + "." + label.get().getText().toString().trim();
+        tooltip(label, text);
+    }
+
     protected Cell<TextField> field(Table table, String value, Cons<String> setter){
         return table.field(value, Styles.nodeField, setter)
             .size(144f, 40f).pad(2f).color(table.color).maxTextLength(LAssembler.maxTokenLength).addInputDialog();
     }
 
     protected Cell<TextField> fields(Table table, String desc, String value, Cons<String> setter){
-        table.add(desc).padLeft(10).left();
+        table.add(desc).padLeft(10).left().self(this::param);;
         return field(table, value, setter).width(85f).padRight(10).left();
     }
 
@@ -58,29 +65,40 @@ public abstract class LStatement{
         }
     }
 
-    protected <T> void showSelect(Button b, T[] values, T current, Cons<T> getter, int cols, Cons<Cell> sizer){
+    protected <T extends Enum<T>> void showSelect(Button b, T[] values, T current, Cons<T> getter, int cols, Cons<Cell> sizer){
         showSelectTable(b, (t, hide) -> {
             ButtonGroup<Button> group = new ButtonGroup<>();
             int i = 0;
-            t.defaults().size(56f, 40f);
+            t.defaults().size(60f, 38f);
 
             for(T p : values){
-                sizer.get(t.button(p.toString(), Styles.clearTogglet, () -> {
+                sizer.get(t.button(p.toString(), Styles.logicTogglet, () -> {
                     getter.get(p);
                     hide.run();
-                }).checked(current == p).group(group));
+                }).self(c -> tooltip(c, "lenum." + p.name())).checked(current == p).group(group));
 
                 if(++i % cols == 0) t.row();
             }
         });
     }
 
-    protected <T> void showSelect(Button b, T[] values, T current, Cons<T> getter){
+    protected <T extends Enum<T>> void showSelect(Button b, T[] values, T current, Cons<T> getter){
         showSelect(b, values, current, getter, 4, c -> {});
     }
 
     protected void showSelectTable(Button b, Cons2<Table, Runnable> hideCons){
-        Table t = new Table(Tex.button);
+        Table t = new Table(Tex.paneSolid){
+            @Override
+            public float getPrefHeight(){
+                return Math.min(super.getPrefHeight(), Core.graphics.getHeight());
+            }
+
+            @Override
+            public float getPrefWidth(){
+                return Math.min(super.getPrefWidth(), Core.graphics.getWidth());
+            }
+        };
+        t.margin(4);
 
         //triggers events behind the element to simulate deselection
         Element hitter = new Element();
@@ -110,14 +128,15 @@ public abstract class LStatement{
             if(t.getWidth() > Core.scene.getWidth()) t.setWidth(Core.graphics.getWidth());
             if(t.getHeight() > Core.scene.getHeight()) t.setHeight(Core.graphics.getHeight());
             t.keepInStage();
+            t.invalidateHierarchy();
+            t.pack();
         });
         t.actions(Actions.alpha(0), Actions.fadeIn(0.3f, Interp.fade));
 
         t.top().pane(inner -> {
-            inner.marginRight(24f);
             inner.top();
             hideCons.get(inner, hide);
-        }).top();
+        }).pad(0f).top().get().setScrollingDisabled(true, false);
 
         t.pack();
     }
@@ -139,4 +158,5 @@ public abstract class LStatement{
     public String name(){
         return Strings.insertSpaces(getClass().getSimpleName().replace("Statement", ""));
     }
+
 }

core/src/mindustry/logic/LStatements.java

@@ -15,6 +15,7 @@ import mindustry.type.*;
 import mindustry.ui.*;
 import mindustry.world.meta.*;
 
+import static mindustry.logic.LCanvas.*;
 import static mindustry.world.blocks.logic.LogicDisplay.*;
 
 public class LStatements{
@@ -355,7 +356,7 @@ public class LStatements{
                 }, 2, cell -> cell.size(100, 50)));
             }, Styles.logict, () -> {}).size(90, 40).color(table.color).left().padLeft(2);
 
-            table.add(" of ");
+            table.add(" of ").self(this::param);
 
             field(table, target, v -> target = v);
 
@@ -394,7 +395,7 @@ public class LStatements{
             table.defaults().left();
 
             if(buildFrom()){
-                table.add(" from ");
+                table.add(" from ").self(this::param);
 
                 fields(table, radar, v -> radar = v);
 
@@ -405,7 +406,7 @@ public class LStatements{
                 int fi = i;
                 Prov<RadarTarget> get = () -> (fi == 0 ? target1 : fi == 1 ? target2 : target3);
 
-                table.add(i == 0 ? " target " : " and ");
+                table.add(i == 0 ? " target " : " and ").self(this::param);
 
                 table.button(b -> {
                     b.label(() -> get.get().name());
@@ -419,13 +420,13 @@ public class LStatements{
                 }
             }
 
-            table.add(" order ");
+            table.add(" order ").self(this::param);
 
             fields(table, sortOrder, v -> sortOrder = v);
 
             table.row();
 
-            table.add(" sort ");
+            table.add(" sort ").self(this::param);
 
             table.button(b -> {
                 b.label(() -> sort.name());
@@ -434,7 +435,7 @@ public class LStatements{
                 }, 2, cell -> cell.size(100, 50)));
             }, Styles.logict, () -> {}).size(90, 40).color(table.color).left().padLeft(2);
 
-            table.add(" output ");
+            table.add(" output ").self(this::param);
 
             fields(table, output, v -> output = v);
         }
@@ -511,7 +512,7 @@ public class LStatements{
                                 i.button(sensor.name(), Styles.cleart, () -> {
                                     stype("@" + sensor.name());
                                     hide.run();
-                                }).size(240f, 40f).row();
+                                }).size(240f, 40f).self(c -> tooltip(c, "lenum." + sensor.name())).row();
                             }
                         })
                     };
@@ -531,14 +532,14 @@ public class LStatements{
 
                             t.parent.parent.pack();
                             t.parent.parent.invalidateHierarchy();
-                        }).size(80f, 50f).growX().checked(selected == fi).group(group);
+                        }).height(50f).growX().checked(selected == fi).group(group);
                     }
                     t.row();
                     t.add(stack).colspan(3).width(240f).left();
                 }));
             }, Styles.logict, () -> {}).size(40f).padLeft(-1).color(table.color);
 
-            table.add(" in ");
+            table.add(" in ").self(this::param);
 
             field(table, from, str -> from = str);
         }
@@ -608,6 +609,20 @@ public class LStatements{
             }else{
                 row(table);
 
+                //"function"-type operations have the name at the left and arguments on the right
+                if(op.func){
+                    if(LCanvas.useRows()){
+                        table.left();
+                        table.row();
+                        table.table(c -> {
+                            c.color.set(color());
+                            c.left();
+                            funcs(c);
+                        }).colspan(2).left();
+                    }else{
+                        funcs(table);
+                    }
+                }else{
                     field(table, a, str -> a = str);
 
                     opButton(table);
@@ -615,6 +630,15 @@ public class LStatements{
                     field(table, b, str -> b = str);
                 }
             }
+        }
+
+        void funcs(Table table){
+            opButton(table);
+
+            field(table, a, str -> a = str);
+
+            field(table, b, str -> b = str);
+        }
 
         void opButton(Table table){
             table.button(b -> {
@@ -623,7 +647,7 @@ public class LStatements{
                     op = o;
                     rebuild(table);
                 }));
-            }, Styles.logict, () -> {}).size(60f, 40f).pad(4f).color(table.color);
+            }, Styles.logict, () -> {}).size(64f, 40f).pad(4f).color(table.color);
         }
 
         @Override
@@ -637,6 +661,28 @@ public class LStatements{
         }
     }
 
+    //TODO untested
+    //@RegisterStatement("wait")
+    public static class WaitStatement extends LStatement{
+        public String value = "0.5";
+
+        @Override
+        public void build(Table table){
+            field(table, value, str -> value = str);
+            table.add(" sec");
+        }
+
+        @Override
+        public Color color(){
+            return Pal.logicOperations;
+        }
+
+        @Override
+        public LInstruction build(LAssembler builder){
+            return new WaitI(builder.var(value));
+        }
+    }
+
     @RegisterStatement("end")
     public static class EndStatement extends LStatement{
         @Override
@@ -855,7 +901,7 @@ public class LStatements{
         void rebuild(Table table){
             table.clearChildren();
 
-            table.add(" find ").left();
+            table.add(" find ").left().self(this::param);;
 
             table.button(b -> {
                 b.label(() -> locate.name());
@@ -868,14 +914,14 @@ public class LStatements{
             switch(locate){
                 case building -> {
                     row(table);
-                    table.add(" type ").left();
+                    table.add(" group ").left().self(this::param);;
                     table.button(b -> {
                         b.label(() -> flag.name());
-                        b.clicked(() -> showSelect(b, BlockFlag.all, flag, t -> flag = t, 2, cell -> cell.size(110, 50)));
+                        b.clicked(() -> showSelect(b, BlockFlag.allLogic, flag, t -> flag = t, 2, cell -> cell.size(110, 50)));
                     }, Styles.logict, () -> {}).size(110, 40).color(table.color).left().padLeft(2);
                     row(table);
 
-                    table.add(" enemy ").left();
+                    table.add(" enemy ").left().self(this::param);;
 
                     fields(table, enemy, str -> enemy = str);
 
@@ -883,7 +929,7 @@ public class LStatements{
                 }
 
                 case ore -> {
-                    table.add(" ore ").left();
+                    table.add(" ore ").left().self(this::param);
                     table.table(ts -> {
                         ts.color.set(table.color);
 
@@ -920,19 +966,19 @@ public class LStatements{
                 }
             }
 
-            table.add(" outX ").left();
+            table.add(" outX ").left().self(this::param);
             fields(table, outX, str -> outX = str);
 
-            table.add(" outY ").left();
+            table.add(" outY ").left().self(this::param);
             fields(table, outY, str -> outY = str);
 
             row(table);
 
-            table.add(" found ").left();
+            table.add(" found ").left().self(this::param);
             fields(table, outFound, str -> outFound = str);
 
             if(locate != LLocate.ore){
-                table.add(" building ").left();
+                table.add(" building ").left().self(this::param);
                 fields(table, outBuild, str -> outBuild = str);
             }
 

core/src/mindustry/logic/LogicDialog.java

@@ -10,6 +10,7 @@ import mindustry.ui.*;
 import mindustry.ui.dialogs.*;
 
 import static mindustry.Vars.*;
+import static mindustry.logic.LCanvas.*;
 
 public class LogicDialog extends BaseDialog{
     public LCanvas canvas;
@@ -72,7 +73,7 @@ public class LogicDialog extends BaseDialog{
                     t.button(example.name(), style, () -> {
                         canvas.add(prov.get());
                         dialog.hide();
-                    }).size(140f, 50f);
+                    }).size(140f, 50f).self(c -> tooltip(c, "lst." + example.name()));
                     if(++i % 2 == 0) t.row();
                 }
             });

core/src/mindustry/logic/LogicOp.java

@@ -19,6 +19,7 @@ public enum LogicOp{
     lessThanEq("<=", (a, b) -> a <= b ? 1 : 0),
     greaterThan(">", (a, b) -> a > b ? 1 : 0),
     greaterThanEq(">=", (a, b) -> a >= b ? 1 : 0),
+    strictEqual("===", (a, b) -> 0), //this lambda is not actually used
 
     shl("<<", (a, b) -> (long)a << (long)b),
     shr(">>", (a, b) -> (long)a >> (long)b),
@@ -27,11 +28,11 @@ public enum LogicOp{
     xor("xor", (a, b) -> (long)a ^ (long)b),
     not("flip", a -> ~(long)(a)),
 
-    max("max", Math::max),
+    max("max", true, Math::max),
-    min("min", Math::min),
+    min("min", true, Math::min),
-    atan2("atan2", (x, y) -> Mathf.atan2((float)x, (float)y) * Mathf.radDeg),
+    angle("angle", true, (x, y) -> Angles.angle((float)x, (float)y)),
-    dst("dst", (x, y) -> Mathf.dst((float)x, (float)y)),
+    len("len", true, (x, y) -> Mathf.dst((float)x, (float)y)),
-    noise("noise", LExecutor.noise::rawNoise2D),
+    noise("noise", true, LExecutor.noise::rawNoise2D),
     abs("abs", a -> Math.abs(a)),
     log("log", Math::log),
     log10("log10", Math::log10),
@@ -48,19 +49,29 @@ public enum LogicOp{
     public final OpObjLambda2 objFunction2;
     public final OpLambda2 function2;
     public final OpLambda1 function1;
-    public final boolean unary;
+    public final boolean unary, func;
     public final String symbol;
 
     LogicOp(String symbol, OpLambda2 function){
         this(symbol, function, null);
     }
 
+    LogicOp(String symbol, boolean func, OpLambda2 function){
+        this.symbol = symbol;
+        this.function2 = function;
+        this.function1 = null;
+        this.unary = false;
+        this.objFunction2 = null;
+        this.func = func;
+    }
+
     LogicOp(String symbol, OpLambda2 function, OpObjLambda2 objFunction){
         this.symbol = symbol;
         this.function2 = function;
         this.function1 = null;
         this.unary = false;
         this.objFunction2 = objFunction;
+        this.func = false;
     }
 
     LogicOp(String symbol, OpLambda1 function){
@@ -69,6 +80,7 @@ public enum LogicOp{
         this.function2 = null;
         this.unary = true;
         this.objFunction2 = null;
+        this.func = false;
     }
 
     @Override

core/src/mindustry/mod/Scripts.java

@@ -24,7 +24,7 @@ public class Scripts implements Disposable{
     private final Seq<String> blacklist = Seq.with(".net.", "java.net", "files", "reflect", "javax", "rhino", "file", "channels", "jdk",
         "runtime", "util.os", "rmi", "security", "org.", "sun.", "beans", "sql", "http", "exec", "compiler", "process", "system",
         ".awt", "socket", "classloader", "oracle", "invoke", "java.util.function", "java.util.stream", "org.");
-    private final Seq<String> whitelist = Seq.with("mindustry.net", "netserver", "netclient", "com.sun.proxy.$proxy", "mindustry.gen.", "mindustry.logic.", "mindustry.async.", "saveio", "systemcursor");
+    private final Seq<String> whitelist = Seq.with("mindustry.net", "netserver", "netclient", "com.sun.proxy.$proxy", "mindustry.gen.", "mindustry.logic.", "mindustry.async.", "saveio", "systemcursor", "filetreeinitevent");
     private final Context context;
     private final Scriptable scope;
     private boolean errored;

core/src/mindustry/net/Packets.java

@@ -160,7 +160,7 @@ public class Packets{
         public int version;
         public String versionType;
         public Seq<String> mods;
-        public String name, uuid, usid;
+        public String name, locale, uuid, usid;
         public boolean mobile;
         public int color;
 
@@ -169,6 +169,7 @@ public class Packets{
             buffer.putInt(Version.build);
             TypeIO.writeString(buffer, versionType);
             TypeIO.writeString(buffer, name);
+            TypeIO.writeString(buffer, locale);
             TypeIO.writeString(buffer, usid);
 
             byte[] b = Base64Coder.decode(uuid);
@@ -190,6 +191,7 @@ public class Packets{
             version = buffer.getInt();
             versionType = TypeIO.readString(buffer);
             name = TypeIO.readString(buffer);
+            locale = TypeIO.readString(buffer);
             usid = TypeIO.readString(buffer);
             byte[] idbytes = new byte[16];
             buffer.get(idbytes);

core/src/mindustry/type/ItemSeq.java

@@ -10,7 +10,7 @@ import mindustry.world.modules.ItemModule.*;
 
 import java.util.*;
 
-public class ItemSeq implements Iterable<ItemStack>, Serializable{
+public class ItemSeq implements Iterable<ItemStack>, JsonSerializable{
     protected final int[] values = new int[Vars.content.items().size];
     public int total;
 

core/src/mindustry/ui/Styles.java

@@ -24,9 +24,9 @@ import static mindustry.gen.Tex.*;
 @StyleDefaults
 public class Styles{
     //TODO all these names are inconsistent and not descriptive
-    public static Drawable black, black9, black8, black6, black3, black5, none, flatDown, flatOver;
+    public static Drawable black, black9, black8, black6, black3, black5, none, flatDown, flatOver, accentDrawable;
     public static ButtonStyle defaultb, waveb, modsb;
-    public static TextButtonStyle defaultt, squaret, nodet, cleart, discordt, nonet, infot, clearPartialt, clearTogglet, clearToggleMenut, togglet, transt, fullTogglet, logict;
+    public static TextButtonStyle defaultt, squaret, nodet, cleart, discordt, nonet, infot, clearPartialt, clearTogglet, logicTogglet, clearToggleMenut, togglet, transt, fullTogglet, logict;
     public static ImageButtonStyle defaulti, nodei, righti, emptyi, emptytogglei, selecti, logici, geni, colori, accenti, cleari, clearFulli, clearPartiali, clearPartial2i, clearTogglei, clearTransi, clearToggleTransi, clearTogglePartiali;
     public static ScrollPaneStyle defaultPane, horizontalPane, smallPane;
     public static KeybindDialogStyle defaultKeybindDialog;
@@ -46,6 +46,7 @@ public class Styles{
         none = whiteui.tint(0f, 0f, 0f, 0f);
         flatDown = createFlatDown();
         flatOver = whiteui.tint(Color.valueOf("454545"));
+        accentDrawable = whiteui.tint(Pal.accent);
 
         defaultb = new ButtonStyle(){{
             down = buttonDown;
@@ -151,6 +152,16 @@ public class Styles{
             disabled = black;
             disabledFontColor = Color.gray;
         }};
+        logicTogglet = new TextButtonStyle(){{
+            font = Fonts.outline;
+            fontColor = Color.white;
+            checked = accentDrawable;
+            down = accentDrawable;
+            up = black;
+            over = flatOver;
+            disabled = black;
+            disabledFontColor = Color.gray;
+        }};
         clearToggleMenut = new TextButtonStyle(){{
             font = Fonts.def;
             fontColor = Color.white;

core/src/mindustry/ui/dialogs/ControlsDialog.java

@@ -17,7 +17,7 @@ public class ControlsDialog extends KeybindDialog{
 
     @Override
     public void addCloseButton(){
-        buttons.button("@back", Icon.left, this::hide).size(230f, 64f);
+        buttons.button("@back", Icon.left, this::hide).size(210f, 64f);
 
         keyDown(key -> {
             if(key == KeyCode.escape || key == KeyCode.back) hide();

core/src/mindustry/ui/dialogs/CustomRulesDialog.java

@@ -161,6 +161,8 @@ public class CustomRulesDialog extends BaseDialog{
 
         title("@rules.title.unit");
         check("@rules.unitammo", b -> rules.unitAmmo = b, () -> rules.unitAmmo);
+        check("@rules.unitcapvariable", b -> rules.unitCapVariable = b, () -> rules.unitCapVariable);
+        number("@rules.unitcap", true, f -> rules.unitCap = f, () -> rules.unitCap, -999, 999);
         number("@rules.unitdamagemultiplier", f -> rules.unitDamageMultiplier = f, () -> rules.unitDamageMultiplier);
         number("@rules.unitbuildspeedmultiplier", f -> rules.unitBuildSpeedMultiplier = f, () -> rules.unitBuildSpeedMultiplier, 0.001f, 50f);
 
@@ -204,6 +206,17 @@ public class CustomRulesDialog extends BaseDialog{
         number(text, false, cons, prov, condition, 0, Float.MAX_VALUE);
     }
 
+    void number(String text, boolean integer, Intc cons, Intp prov, int min, int max){
+        main.table(t -> {
+            t.left();
+            t.add(text).left().padRight(5);
+            t.field((integer ? (int)prov.get() : prov.get()) + "", s -> cons.get(Strings.parseInt(s)))
+                    .padRight(100f)
+                    .valid(f -> Strings.parseInt(f) >= min && Strings.parseInt(f) <= max).width(120f).left().addInputDialog();
+        }).padTop(0);
+        main.row();
+    }
+
     void number(String text, boolean integer, Floatc cons, Floatp prov, Boolp condition, float min, float max){
         main.table(t -> {
             t.left();

core/src/mindustry/ui/dialogs/JoinDialog.java

@@ -513,7 +513,7 @@ public class JoinDialog extends BaseDialog{
             Core.settings.remove("server-list");
         }
 
-        var url = becontrol.active() ? serverJsonBeURL : serverJsonV6URL;
+        var url = becontrol.active() ? serverJsonBeURL : serverJsonURL;
         Log.info("Fetching community servers at @", url);
 
         //get servers

core/src/mindustry/ui/dialogs/ModsDialog.java

@@ -38,7 +38,7 @@ public class ModsDialog extends BaseDialog{
 
     private String searchtxt = "";
     private @Nullable Seq<ModListing> modList;
-    private boolean orderDate = true;
+    private boolean orderDate = false;
     private BaseDialog currentContent;
 
     private BaseDialog browser;
@@ -266,7 +266,7 @@ public class ModsDialog extends BaseDialog{
                             title.table(text -> {
                                 boolean hideDisabled = !mod.isSupported() || mod.hasUnmetDependencies() || mod.hasContentErrors();
 
-                                text.add("" + Strings.stripColors(mod.meta.displayName()) + "\n[lightgray]v" + Strings.stripColors(trimText(mod.meta.version)) + (mod.enabled() || hideDisabled ? "" : "\n" + Core.bundle.get("mod.disabled") + ""))
+                                text.add("[accent]" + Strings.stripColors(mod.meta.displayName()) + "\n[lightgray]v" + Strings.stripColors(trimText(mod.meta.version)) + (mod.enabled() || hideDisabled ? "" : "\n" + Core.bundle.get("mod.disabled") + ""))
                                     .wrap().top().width(300f).growX().left();
 
                                 text.row();
@@ -384,7 +384,7 @@ public class ModsDialog extends BaseDialog{
 
                         }).tooltip(c.localizedName);
 
-                        if(++i % Math.min(Core.graphics.getWidth() / Scl.scl(70), 14) == 0) cs.row();
+                        if(++i % Math.min(Core.graphics.getWidth() / Scl.scl(110), 14) == 0) cs.row();
                     }
                 }).grow();
                 d.addCloseButton();

core/src/mindustry/ui/dialogs/PlanetDialog.java

@@ -208,11 +208,11 @@ public class PlanetDialog extends BaseDialog implements PlanetInterfaceRenderer{
     }
 
     void addBack(){
-        buttons.button("@back", Icon.left, this::hide).size(200, 54).pad(2).bottom();
+        buttons.button("@back", Icon.left, this::hide).size(200f, 54f).pad(2).bottom();
     }
 
     void addTech(){
-        buttons.button("@techtree", Icon.tree, () -> ui.research.show()).size(200, 54).pad(2).bottom();
+        buttons.button("@techtree", Icon.tree, () -> ui.research.show()).size(200f, 54f).pad(2).bottom();
     }
 
     public void showOverview(){
@@ -677,7 +677,7 @@ public class PlanetDialog extends BaseDialog implements PlanetInterfaceRenderer{
                     setFillParent(true);
                     cont.pane(t -> {
                         t.marginRight(19f);
-                        t.defaults().size(48);
+                        t.defaults().size(48f);
 
                         t.button(Icon.none, Styles.clearTogglei, () -> {
                             sector.info.icon = null;
@@ -701,6 +701,7 @@ public class PlanetDialog extends BaseDialog implements PlanetInterfaceRenderer{
                             if(++i % 8 == 0) t.row();
                         }
                     });
+                    buttons.button("@back", Icon.left, this::hide).size(210f, 64f);
                 }}.show();
             }).size(40f);
         }).row();

core/src/mindustry/ui/dialogs/SettingsMenuDialog.java

@@ -320,6 +320,7 @@ public class SettingsMenuDialog extends SettingsDialog{
         game.checkPref("blockreplace", true);
         game.checkPref("conveyorpathfinding", true);
         game.checkPref("hints", true);
+        game.checkPref("logichints", true);
 
         if(!mobile){
             game.checkPref("backgroundpause", true);
@@ -452,11 +453,24 @@ public class SettingsMenuDialog extends SettingsDialog{
         files.addAll(schematicDirectory.list());
         String base = Core.settings.getDataDirectory().path();
 
+        //add directories
+        for(Fi other : files.copy()){
+            Fi parent = other.parent();
+            while(!files.contains(parent) && !parent.equals(settings.getDataDirectory())){
+                files.add(parent);
+            }
+        }
+
         try(OutputStream fos = file.write(false, 2048); ZipOutputStream zos = new ZipOutputStream(fos)){
             for(Fi add : files){
-                if(add.isDirectory()) continue;
+                String path = add.path().substring(base.length());
-                zos.putNextEntry(new ZipEntry(add.path().substring(base.length())));
+                if(add.isDirectory()) path += "/";
+                //fix trailing / in path
+                path = path.startsWith("/") ? path.substring(1) : path;
+                zos.putNextEntry(new ZipEntry(path));
+                if(!add.isDirectory()){
                     Streams.copy(add.read(), zos);
+                }
                 zos.closeEntry();
             }
         }
@@ -500,13 +514,13 @@ public class SettingsMenuDialog extends SettingsDialog{
 
     @Override
     public void addCloseButton(){
-        buttons.button("@back", Icon.leftOpen, () -> {
+        buttons.button("@back", Icon.left, () -> {
             if(prefs.getChildren().first() != menu){
                 back();
             }else{
                 hide();
             }
-        }).size(230f, 64f);
+        }).size(210f, 64f);
 
         keyDown(key -> {
             if(key == KeyCode.escape || key == KeyCode.back){

core/src/mindustry/ui/fragments/ChatFragment.java

@@ -15,7 +15,6 @@ import arc.util.*;
 import mindustry.*;
 import mindustry.gen.*;
 import mindustry.input.*;
-import mindustry.type.*;
 import mindustry.ui.*;
 
 import static arc.Core.*;
@@ -206,7 +205,7 @@ public class ChatFragment extends Table{
             }
         }else{
             //sending chat has a delay; workaround for issue #1943
-            Time.run(2f, () ->{
+            Time.runTask(2f, () ->{
                 scene.setKeyboardFocus(null);
                 shown = false;
                 scrollPos = 0;

core/src/mindustry/ui/fragments/HudFragment.java

@@ -637,20 +637,11 @@ public class HudFragment extends Fragment{
 
                 if(Float.isNaN(value) || Float.isInfinite(value)) value = 1f;
 
-                drawInner(Pal.darkishGray);
+                drawInner(Pal.darkishGray, 1f);
-
+                drawInner(Tmp.c1.set(color).lerp(Color.white, blink), value);
-                Draw.beginStencil();
-
-                Fill.crect(x, y, width, height * value);
-
-                Draw.beginStenciled();
-
-                drawInner(Tmp.c1.set(color).lerp(Color.white, blink));
-
-                Draw.endStencil();
             }
 
-            void drawInner(Color color){
+            void drawInner(Color color, float fract){
                 if(flip){
                     x += width;
                     width = -width;
@@ -660,19 +651,26 @@ public class HudFragment extends Fragment{
                 float bh = height/2f;
                 Draw.color(color);
 
+                float f1 = Math.min(fract * 2f, 1f), f2 = (fract - 0.5f) * 2f;
+
+                float bo = -(1f - f1) * (width - stroke);
+
                 Fill.quad(
                 x, y,
                 x + stroke, y,
-                x + width, y + bh,
+                x + width + bo, y + bh * f1,
-                x + width - stroke, y + bh
+                x + width - stroke + bo, y + bh * f1
                 );
 
+                if(f2 > 0){
+                    float bx = x + (width - stroke) * (1f - f2);
                     Fill.quad(
                     x + width, y + bh,
                     x + width - stroke, y + bh,
-                x, y + height,
+                    bx, y + height * fract,
-                x + stroke, y + height
+                    bx + stroke, y + height * fract
                     );
+                }
 
                 Draw.reset();
 

core/src/mindustry/world/Block.java

@@ -160,8 +160,10 @@ public class Block extends UnlockableContent{
     public boolean canOverdrive = true;
     /** Outlined icon color.*/
     public Color outlineColor = Color.valueOf("404049");
-    /** Whether the icon region has an outline added. */
+    /** Whether any icon region has an outline added. */
     public boolean outlineIcon = false;
+    /** Which of the icon regions gets the outline added. */
+    public int outlinedIcon = -1;
     /** Whether this block has a shadow under it. */
     public boolean hasShadow = true;
     /** Sounds made when this block breaks.*/
@@ -768,7 +770,7 @@ public class Block extends UnlockableContent{
 
         if(outlineIcon){
             final int radius = 4;
-            PixmapRegion region = Core.atlas.getPixmap(getGeneratedIcons()[getGeneratedIcons().length-1]);
+            PixmapRegion region = Core.atlas.getPixmap(getGeneratedIcons()[outlinedIcon >= 0 ? outlinedIcon : getGeneratedIcons().length -1]);
             Pixmap out = new Pixmap(region.width, region.height);
             Color color = new Color();
             for(int x = 0; x < region.width; x++){

core/src/mindustry/world/Build.java

@@ -153,6 +153,7 @@ public class Build{
                 (type == check.block() && check.build != null && rotation == check.build.rotation && type.rotate) || //same block, same rotation
                 !check.interactable(team) || //cannot interact
                 !check.floor().placeableOn || //solid wall
+                (!checkVisible && !check.block().alwaysReplace) || //replacing a block that should be replaced (e.g. payload placement)
                     !((type.canReplace(check.block()) || //can replace type
                         //controversial change: allow rebuilding damaged blocks
                         //this could be buggy and abuse-able, so I'm not enabling it yet

core/src/mindustry/world/blocks/Attributes.java

@@ -6,7 +6,7 @@ import mindustry.world.meta.*;
 
 import java.util.*;
 
-public class Attributes implements Serializable{
+public class Attributes implements JsonSerializable{
     private final float[] arr = new float[Attribute.all.length];
 
     public void clear(){

core/src/mindustry/world/blocks/defense/ForceProjector.java

@@ -178,6 +178,12 @@ public class ForceProjector extends Block{
             return (radius + phaseHeat * phaseRadiusBoost) * radscl;
         }
 
+        @Override
+        public double sense(LAccess sensor){
+            if(sensor == LAccess.heat) return buildup;
+            return super.sense(sensor);
+        }
+
         @Override
         public void draw(){
             super.draw();

core/src/mindustry/world/blocks/defense/turrets/LiquidTurret.java

@@ -27,10 +27,11 @@ public class LiquidTurret extends Turret{
         hasLiquids = true;
         loopSound = Sounds.spray;
         shootSound = Sounds.none;
+        outlinedIcon = 1;
     }
 
     /** Initializes accepted ammo map. Format: [liquid1, bullet1, liquid2, bullet2...] */
-    protected void ammo(Object... objects){
+    public void ammo(Object... objects){
         ammoTypes = OrderedMap.of(objects);
     }
 
@@ -63,6 +64,12 @@ public class LiquidTurret extends Turret{
         super.init();
     }
 
+    @Override
+    public TextureRegion[] icons(){
+        if(topRegion.found()) return new TextureRegion[]{baseRegion, region, topRegion};
+        return super.icons();
+    }
+
     public class LiquidTurretBuild extends TurretBuild{
         @Override
         public void draw(){

core/src/mindustry/world/blocks/defense/turrets/TractorBeamTurret.java

@@ -98,7 +98,7 @@ public class TractorBeamTurret extends BaseTurret{
             any = false;
 
             //look at target
-            if(target != null && target.within(this, range) && target.team() != team && target.checkTarget(targetAir, targetGround) && efficiency() > 0.02f){
+            if(target != null && target.within(this, range + target.hitSize/2f) && target.team() != team && target.checkTarget(targetAir, targetGround) && efficiency() > 0.02f){
                 if(!headless){
                     control.sound.loop(shootSound, this, shootSoundVolume);
                 }

core/src/mindustry/world/blocks/environment/AirBlock.java

@@ -0,0 +1,43 @@
+package mindustry.world.blocks.environment;
+
+import arc.*;
+import arc.graphics.g2d.*;
+import mindustry.annotations.Annotations.*;
+import mindustry.world.*;
+
+public class AirBlock extends Floor{
+
+    public AirBlock(String name){
+        super(name);
+        alwaysReplace = true;
+        hasShadow = false;
+        useColor = false;
+        wall = this;
+    }
+
+    @Override
+    public void drawBase(Tile tile){}
+
+    @OverrideCallSuper
+    @Override
+    public void load(){}
+
+    @OverrideCallSuper
+    @Override
+    public void init(){
+        decoration = this;
+    }
+
+    @Override
+    public boolean isHidden(){
+        return true;
+    }
+
+    @Override
+    public TextureRegion[] variantRegions(){
+        if(variantRegions == null){
+            variantRegions = new TextureRegion[]{Core.atlas.find("clear")};
+        }
+        return variantRegions;
+    }
+}

core/src/mindustry/world/blocks/environment/Boulder.java

@@ -6,7 +6,7 @@ import arc.math.*;
 import mindustry.world.*;
 
 public class Boulder extends Block{
-    protected int variants;
+    public int variants;
 
     public Boulder(String name){
         super(name);

core/src/mindustry/world/blocks/environment/SpawnBlock.java

@@ -0,0 +1,15 @@
+package mindustry.world.blocks.environment;
+
+import mindustry.world.*;
+
+public class SpawnBlock extends OverlayFloor{
+
+    public SpawnBlock(String name){
+        super(name);
+        variants = 0;
+        needsSurface = false;
+    }
+
+    @Override
+    public void drawBase(Tile tile){}
+}

core/src/mindustry/world/blocks/power/ImpactReactor.java

@@ -4,6 +4,7 @@ import arc.*;
 import arc.graphics.*;
 import arc.graphics.g2d.*;
 import arc.math.*;
+import arc.struct.*;
 import arc.util.*;
 import arc.util.io.*;
 import mindustry.annotations.Annotations.*;
@@ -38,6 +39,7 @@ public class ImpactReactor extends PowerGenerator{
         liquidCapacity = 30f;
         hasItems = true;
         outputsPower = consumesPower = true;
+        flags = EnumSet.of(BlockFlag.reactor, BlockFlag.generator);
     }
 
     @Override

core/src/mindustry/world/blocks/power/NuclearReactor.java

@@ -33,8 +33,8 @@ public class NuclearReactor extends PowerGenerator{
     public float itemDuration = 120; //time to consume 1 fuel
     public float heating = 0.01f; //heating per frame * fullness
     public float smokeThreshold = 0.3f; //threshold at which block starts smoking
-    public int explosionRadius = 40;
+    public int explosionRadius = 20;
-    public int explosionDamage = 1350;
+    public int explosionDamage = 1250;
     public float flashThreshold = 0.46f; //heat threshold at which the lights start flashing
     public float coolantPower = 0.5f;
 
@@ -48,7 +48,7 @@ public class NuclearReactor extends PowerGenerator{
         hasItems = true;
         hasLiquids = true;
         rebuildable = false;
-        flags = EnumSet.of(BlockFlag.reactor);
+        flags = EnumSet.of(BlockFlag.reactor, BlockFlag.generator);
     }
 
     @Override

core/src/mindustry/world/blocks/units/RepairPoint.java

@@ -95,7 +95,7 @@ public class RepairPoint extends Block{
         @Override
         public void updateTile(){
             boolean targetIsBeingRepaired = false;
-            if(target != null && (target.dead() || target.dst(tile) > repairRadius || target.health() >= target.maxHealth())){
+            if(target != null && (target.dead() || target.dst(tile) - target.hitSize/2f > repairRadius || target.health() >= target.maxHealth())){
                 target = null;
             }else if(target != null && consValid()){
                 target.heal(repairSpeed * Time.delta * strength * efficiency());

core/src/mindustry/world/blocks/units/UnitBlock.java

@@ -27,7 +27,7 @@ public class UnitBlock extends PayloadAcceptor{
 
     @Remote(called = Loc.server)
     public static void unitBlockSpawn(Tile tile){
-        if(!(tile.build instanceof UnitBuild build)) return;
+        if(tile == null || !(tile.build instanceof UnitBuild build)) return;
         build.spawned();
     }
 

core/src/mindustry/world/consumers/ConsumeLiquidFilter.java

@@ -28,7 +28,8 @@ public class ConsumeLiquidFilter extends ConsumeLiquidBase{
     public void build(Building build, Table table){
         Seq<Liquid> list = content.liquids().select(l -> !l.isHidden() && filter.get(l));
         MultiReqImage image = new MultiReqImage();
-        list.each(liquid -> image.add(new ReqImage(liquid.icon(Cicon.medium), () -> build.liquids != null && build.liquids.get(liquid) >= Math.max(use(build), amount * build.delta()))));
+        list.each(liquid -> image.add(new ReqImage(liquid.icon(Cicon.medium), () ->
+            build.liquids != null && build.liquids.current() == liquid && build.liquids.get(liquid) >= Math.max(use(build), amount * build.delta()))));
 
         table.add(image).size(8 * 4);
     }

core/src/mindustry/world/meta/BlockFlag.java

@@ -28,4 +28,7 @@ public enum BlockFlag{
     extinguisher;
 
     public final static BlockFlag[] all = values();
+
+    /** Values for logic only. Filters out some internal flags. */
+    public final static BlockFlag[] allLogic = {core, storage, generator, turret, factory, repair, rally, battery, resupply, reactor};
 }

core/src/mindustry/world/meta/PowerType.java

@@ -1,7 +0,0 @@
-package mindustry.world.meta;
-
-public enum PowerType{
-    consumer,
-    producer,
-    bridge
-}

core/src/mindustry/world/meta/Producers.java

@@ -1,16 +0,0 @@
-package mindustry.world.meta;
-
-import arc.struct.*;
-import mindustry.gen.*;
-
-public class Producers{
-    private Seq<Produce> producers = new Seq<>();
-
-    public void add(Produce prod){
-        producers.add(prod);
-    }
-
-    interface Produce{
-        void add(Building entity);
-    }
-}

core/src/mindustry/world/meta/StatUnit.java

@@ -20,7 +20,7 @@ public enum StatUnit{
     minutes,
     perSecond,
     perMinute,
-    perShot,
+    perShot(false),
     timesSpeed(false),
     percent(false),
     shieldHealth,

desktop/src/mindustry/desktop/DesktopLauncher.java

@@ -36,7 +36,6 @@ public class DesktopLauncher extends ClientLauncher{
             new SdlApplication(new DesktopLauncher(arg), new SdlConfig(){{
                 title = "Mindustry";
                 maximized = true;
-                stencil = 1;
                 width = 900;
                 height = 700;
                 setWindowIcon(FileType.internal, "icons/icon_64.png");
@@ -130,6 +129,7 @@ public class DesktopLauncher extends ClientLauncher{
                 player.name = SVars.net.friends.getPersonaName();
                 Core.settings.put("name", player.name);
             }
+            steamPlayerName = SVars.net.friends.getPersonaName();
             //update callbacks
             Core.app.addListener(new ApplicationListener(){
                 @Override

desktop/src/mindustry/desktop/steam/SAchievement.java

@@ -56,6 +56,7 @@ public enum SAchievement{
     enablePixelation,
     openWiki,
     useAccelerator,
+    unlockAllZones,
 
     ;
 

desktop/src/mindustry/desktop/steam/SStats.java

@@ -54,6 +54,9 @@ public class SStats implements SteamUserStatsCallback{
 
             if(Items.thorium.unlocked()) obtainThorium.complete();
             if(Items.titanium.unlocked()) obtainTitanium.complete();
+            if(!content.sectors().contains(s -> s.locked())){
+                unlockAllZones.complete();
+            }
         });
     }
 
@@ -197,6 +200,9 @@ public class SStats implements SteamUserStatsCallback{
         Events.on(UnlockEvent.class, e -> {
             if(e.content == Items.thorium) obtainThorium.complete();
             if(e.content == Items.titanium) obtainTitanium.complete();
+            if(e.content instanceof SectorPreset && !content.sectors().contains(s -> s.locked())){
+                unlockAllZones.complete();
+            }
         });
 
         Events.run(Trigger.openWiki, openWiki::complete);

fastlane/metadata/android/en-US/changelogs/29813.txt

@@ -0,0 +1,6 @@
+[This is a truncated changelog, see Github for full notes]
+- Fixed mod list being fetched on startup, leading to potentially annoying error messages
+- Fixed crash when a mod without a version is viewed
+- Un-blacklisted arc.Net
+- Added unit armor stats to database
+- Added unit production time to unit factory database

fastlane/metadata/android/ko-KR/changelogs/29813.txt

@@ -0,0 +1,6 @@
+[대부분의 변경점이 생략되었습니다. 모든 변경점을 볼려면 Github를 보십시오.]
+- 시작 시 모드 목록을 가져와 잠재적으로 성가신 오류 메시지가 발생하는 문제점 고침
+- 버전이 없는 모드를 볼 때 게임이 터지는 문제점 고침
+- arc.Net 블랙리스트 해제
+- 코어 데이터베이스에 유닛 방어력 정보 추가
+- 코어 데이터베이스에 유닛 생산 시간 정보 추가 

fastlane/metadata/android/ko-KR/full_description.txt

@@ -1,14 +1,52 @@
 정교한 컨베이어 벨트 공급망을 만들어 포탑에 탄약을 공급하고 건물에 사용할 재료를 생산하여 적의 공격으로부터 기지를 방어하십시오. 크로스 플렛폼 멀티플레이어에서 친구와 함께 협동 대형 혹은 어려운 맵에서 협동전을 하거나, 팀 pvp를 통해 실력을 자랑해보세요.
 
-포함된 특징들 :
+<h2>게임플레이</h2>
-- 24개의 기본 내장 맵들
+
-- 해금 가능 지역과 테크 트리로 구성된 캠페인
+- 생산 건물을 사용하여 고급 자원을 조합하세요.
-- 당신을 파괴하기 위한 4개의 강력한 단계 보스
+- 단계에서 몰려오는 적들에게서 당신의 기지를 지키세요.
-- 전력, 액체 그리고 자원 수송 시스템
+- 크로스 플랫폼 멀티플레이어 협동 게임에서 친구와 함께 플레이하거나 팀 기반 PvP 게임에서 도전해보세요.
-- 19가지의 각기 다른 드론, 유닛, 배!
+- 액체를 분배하고 화재 발생이나 적의 급습과 같은 끊임없는 도전과 싸워보세요.
-- 120가지가 넘는 테크놀로지 블록들
+- 옵션인 냉각수 및 윤활유를 공급하여 생산 효과를 극대화하세요.
-- 75가지가 넘는 환경 블록들
+- 당신의 기지를 자동으로 관리하거나 적 기지를 공격할 수 있는 다양한 유닛을 생산해보세요.
-- 로컬 네트워크 또는 전용 서버를 통한 크로스 플랫폼 멀티플레이어
+
-- 사용자 정의 게임 규칙 : 블록 가격, 적 스텟 변경, 시작 자원, 단계 대기시간 그 이상을 변경해보세요.
+
-- 맵에 광물, 지형, 장식을 랜덤으로 생성하고, 대칭을 추가해보세요.
+<h2>캠페인</h2>
+
+- 250개 이상의 자동으로 생성된 지역들과 16개의 내장 맵들을 지나 전진하면서 세르플로 행성을 정복하세요. 
+- 지역을 점령하고 당신이 다른 지역에서 플레이하는 동안 자원을 만들도록 공장을 지으세요.
+- 주기적인 공격에게서 당신의 지역들을 지키세요.
+- 지역 자원 수송기를 통해 지역간 자원을 조직화하세요.
+- 발전을 촉진하기 위해 새로운 블록들을 연구하세요.
+- 친구를 초대해서 다같이 미션을 완료하세요.
+- 120개가 넘는 블록들을 연구해보세요.
+- 33가지 종류의 각기 다른 드론, 유닛, 그리고 배들이 있습니다.
+
+
+<h2><h2>게임모드</h2></h2>
+
+- <b>생존</b>: 포탑을 건설하고, 적의 공격을 방어하는 기본적인 타워디펜스 모드입니다. 더욱 길게 생존하여 연구하기 위한 자원을 모으고 출격하는 것도 가능합니다. 공중 보스의 기습 공격에 대비하세요.
+- <b>공격</b>: 공장을 건설하여 적의 코어를 파괴하기 위한 유닛들을 생산하고, 동시에 적의 유닛을 방어하기 위한 방어건물도 건설하세요. 다양한 지원 및 공격 유닛을 만들어서 목표를 달성하세요. 플레이어의 추가 공격을 막기 위한 방어선을 건설하는 적 AI를 선택적으로 활성화할 수 있습니다.
+- <b>PvP</b>: 서로의 코어를 파괴하는 4개 이상의 다른 팀과의 경쟁 모드입니다. 유닛을 생성하거나, 당신의 기체로 적의 기지를 바로 공격하세요.
+- <b>샌드박스</b>: 적의 위협 없이 무한한 자원으로 플레이하세요. 디자인을 시험해보기 위해 무한 자원, 전기, 액체와 같은 샌드박스 전용 블록들을 사용해보거나, 원한다면 적을 생성해보세요.
+
+
+<h2>사용자 정의 게임 &amp; 크로스플랫폼 멀티플레이어</h2>
+
+- 캠페인에 더하여 커스텀 게임을 위한 16개의 추가적인 맵들이 준비되어 있습니다.
+- 협동, PvP 또는 샌드박스를 플레이해보세요!
+- 유저들이 운영하는 공개되어있는 공용서버에 접속하거나, 당신만의 비공개서버를 만들고 친구들을 초대해보세요.
+- 자유로운 게임 규칙: 블록의 재료 요구량 변경, 적의 능력 수치변경, 시작자원 변경, 단계 대기시간 변경 등 많은 것을 직접 설정할 수 있습니다.
+- 게임모드 혼합!: PvP와 PvE를 합쳐 새로운 컨텐츠를 만들어보세요.
+
+
+<h2>사용자 정의 맵 에디터</h2>
+
+- 에디터 UI를 사용하여 지형을 그려보세요.
+- 인-게임 에디터를 사용하여 맵 미리보기와 수정을 해보세요.
+- 도구 모드 설정: 편집 도구의 모드를 바꿔보세요.
+- 다양한 타입의 필터와 지형 생성 조건을 설정하고, 강력한 맵 생성 시스템을 사용하여 맵을 만들어보세요.
+- 뿌리기, 왜곡, 매끄러움, 침식, 균형, 자원 생성 그리고 지형 무작위 생성 등을 당신의 맵에 적용해보세요.
+- 강이나 자원 타일을 배치하는 것 뿐만이 아니라 광물 생성도 랜덤화 하거나, 설정해보세요.
+- 적 단계 구성을 설정해보세요.
 - 맵 규칙을 마음대로 바꿔보세요.
+- 80개 이상의 각기 다른 지형 블록들을 사용해보세요.

fastlane/metadata/steam/korean/description.txt

@@ -17,7 +17,7 @@
 [h2]캠페인[/h2]
 
 [list]
-[*] 250개 이상의 자동으로 생성된 지역들과 16개의 수제 맵들을 지나 전진하면서 세르플로 행성을 정복하세요. 
+[*] 250개 이상의 자동으로 생성된 지역들과 16개의 내장 맵들을 지나 전진하면서 세르플로 행성을 정복하세요. 
 [*] 지역을 점령하고 당신이 다른 지역에서 플레이하는 동안 자원을 만들도록 공장을 지으세요.
 [*] 주기적인 공격에게서 당신의 지역들을 지키세요.
 [*] 지역 자원 수송기를 통해 지역간 자원을 조직화하세요.
@@ -52,7 +52,7 @@
 [h2]사용자 정의 맵 에디터[/h2]
 
 [list]
-[*] 에디터 ui를 사용하여 지형을 그려보세요.
+[*] 에디터 UI를 사용하여 지형을 그려보세요.
 [*] 인-게임 에디터를 사용하여 맵 미리보기와 수정을 해보세요.
 [*] 도구 모드 설정: 편집 도구의 모드를 바꿔보세요.
 [*] 다양한 타입의 필터와 지형 생성 조건을 설정하고, 강력한 맵 생성 시스템을 사용하여 맵을 만들어보세요.

gradle.properties

@@ -1,3 +1,3 @@
 org.gradle.daemon=true
 org.gradle.jvmargs=-Xms256m -Xmx1024m
-archash=6cf4a11de0770c3789face7fd32e3adee2b6792d
+archash=383cca56f16c9cb00c77db681860d6f420f25b53

ios/robovm.xml

@@ -2,7 +2,6 @@
     <executableName>${app.executable}</executableName>
     <mainClass>${app.mainclass}</mainClass>
     <os>ios</os>
-    <arch>thumbv7</arch>
     <target>ios</target>
     <iosInfoPList>Info.plist.xml</iosInfoPList>
     <resources>
@@ -24,6 +23,8 @@
         <pattern>mindustry.net.**</pattern>
         <pattern>mindustry.world.blocks.**</pattern>
         <pattern>mindustry.logic.**</pattern>
+        <pattern>mindustry.world.blocks.**</pattern>
+        <pattern>mindustry.entities.effect.**</pattern>
         <pattern>com.android.okhttp.HttpHandler</pattern>
         <pattern>com.android.okhttp.HttpsHandler</pattern>
         <pattern>com.android.org.conscrypt.**</pattern>

ios/src/mindustry/ios/IOSLauncher.java

@@ -16,7 +16,6 @@ import mindustry.net.*;
 import mindustry.ui.*;
 import org.robovm.apple.coregraphics.*;
 import org.robovm.apple.foundation.*;
-import org.robovm.apple.glkit.*;
 import org.robovm.apple.uikit.*;
 import org.robovm.objc.block.*;
 
@@ -25,7 +24,7 @@ import java.util.*;
 import java.util.zip.*;
 
 import static mindustry.Vars.*;
-import static org.robovm.apple.foundation.NSPathUtilities.getDocumentsDirectory;
+import static org.robovm.apple.foundation.NSPathUtilities.*;
 
 //warnings for deprecated functions related to multi-window applications are not applicable here
 @SuppressWarnings("deprecation")
@@ -175,9 +174,7 @@ public class IOSLauncher extends IOSApplication.Delegate{
                 forced = false;
                 UINavigationController.attemptRotationToDeviceOrientation();
             }
-        }, new IOSApplicationConfiguration(){{
+        }, new IOSApplicationConfiguration());
-            stencilFormat = GLKViewDrawableStencilFormat._8;
-        }});
     }
 
     @Override

servers_be.json

@@ -4,8 +4,5 @@
   },
   {
     "address": "nydustry.nydus.app:6060"
-  },
-  {
-    "address": "mindustry.pl:6660"
   }
 ]

servers_v6.json

@@ -1,4 +1,8 @@
 [ 
+  {
+    "name": "RCR",
+    "address": ["rcr.fvds.ru"]
+  },
   {
     "name": "mindustry.pl",
     "address": ["mindustry.pl:6000", "mindustry.pl:6666", "mindustry.pl"]
@@ -13,7 +17,7 @@
   },
   {
     "name": "C.A.M.S.",
-    "address": ["routerchain.ddns.net", "pandorum.su:8000", "nikochio.ddns.net"]
+    "address": ["routerchain.ddns.net", "nikochio.ddns.net"]
   },
   {
     "name": "BE6.RUN",
@@ -43,10 +47,6 @@
     "name": "mindustry.ddns.net",
     "address": ["mindustry.ddns.net:1000", "mindustry.ddns.net:2000", "mindustry.ddns.net:3000", "mindustry.ddns.net:4000"]
   },
-  {
-    "name": "Gearblock",
-    "address": ["attack.gearblock.app"]
-  },
   {
     "name": "Surrealment",
     "address": ["md.surrealment.com"]
@@ -73,10 +73,14 @@
   },
   {
     "name": "Omega",
-    "address": ["185.86.230.102:25906"] 
+    "address": ["185.86.230.102:25906", "185.86.230.104:25985", "185.86.230.101:25641"] 
   },
   {
     "name": "md.obvilionnetwork.ru",
     "address": ["obvilionnetwork.ru:7001", "obvilionnetwork.ru:7002"]
+  },
+  {
+    "name": "Mindustry PLAY",
+    "address": ["92.63.100.160"]
   }
 ]