View.go

package archives

import (
	"fmt"
	"math"
	"strings"

	"github.com/inkyblackness/imgui-go/v3"

	"github.com/inkyblackness/hacked/editor/values"
	"github.com/inkyblackness/hacked/ss1/content/archive"
	"github.com/inkyblackness/hacked/ss1/content/archive/level"
	"github.com/inkyblackness/hacked/ss1/content/archive/level/lvlids"
	"github.com/inkyblackness/hacked/ss1/content/archive/level/lvlobj"
	"github.com/inkyblackness/hacked/ss1/content/interpreters"
	"github.com/inkyblackness/hacked/ss1/content/numbers"
	"github.com/inkyblackness/hacked/ss1/content/object"
	"github.com/inkyblackness/hacked/ss1/content/text"
	"github.com/inkyblackness/hacked/ss1/edit"
	"github.com/inkyblackness/hacked/ss1/edit/undoable/cmd"
	"github.com/inkyblackness/hacked/ss1/resource"
	"github.com/inkyblackness/hacked/ss1/world"
	"github.com/inkyblackness/hacked/ss1/world/citadel"
	"github.com/inkyblackness/hacked/ss1/world/ids"
	"github.com/inkyblackness/hacked/ui/gui"
)

const (
	hintUnknown = "???"
)

var variableContextList = map[edit.VariableBaseContextIdentifier]struct {
	title string
	info  string
}{
	edit.VariableContextCitadel: {
		title: "Citadel Mission",
		info: "Variables are listed based on use on Citadel.\n" +
			"Useful for Citadel-based savegames and mods, such as 'New Game+' variants.",
	},
	edit.VariableContextEngine: {
		title: "Engine",
		info: "Variables are listed based on the hardcoded engine behaviour.\n" +
			"Useful for dedicated missions.",
	},
}

// View provides edit controls for the archive.
type View struct {
	registry         cmd.Registry
	gameStateService *edit.GameStateService
	mod              *world.Mod
	textCache        *text.Cache
	cp               text.Codepage

	modalStateMachine gui.ModalStateMachine
	guiScale          float32
	commander         cmd.Commander

	model viewModel
}

// NewArchiveView returns a new instance.
func NewArchiveView(registry cmd.Registry,
	gameStateService *edit.GameStateService, mod *world.Mod,
	textCache *text.Cache, cp text.Codepage,
	modalStateMachine gui.ModalStateMachine, guiScale float32, commander cmd.Commander) *View {
	view := &View{
		registry:         registry,
		gameStateService: gameStateService,
		mod:              mod,
		textCache:        textCache,
		cp:               cp,

		modalStateMachine: modalStateMachine,
		guiScale:          guiScale,
		commander:         commander,

		model: freshViewModel(),
	}
	return view
}

// WindowOpen returns the flag address, to be used with the main menu.
func (view *View) WindowOpen() *bool {
	return &view.model.windowOpen
}

// Render renders the view.
func (view *View) Render() {
	if view.model.restoreFocus {
		imgui.SetNextWindowFocus()
		view.model.restoreFocus = false
		view.model.windowOpen = true
	}
	if view.model.windowOpen {
		imgui.SetNextWindowSizeV(imgui.Vec2{X: 650 * view.guiScale, Y: 400 * view.guiScale}, imgui.ConditionFirstUseEver)
		if imgui.BeginV("Archive", view.WindowOpen(), imgui.WindowFlagsNoCollapse) {
			view.renderContent()
		}
		imgui.End()
	}
}

func (view *View) renderContent() {
	imgui.BeginTabBar("archive-tab")

	if imgui.BeginTabItem("Levels") {
		view.renderLevelsContent()
		imgui.EndTabItem()
	}
	if imgui.BeginTabItem("Game State") {
		view.renderGameStateContent()
		imgui.EndTabItem()
	}

	imgui.EndTabBar()
}

func (view *View) renderLevelsContent() {
	imgui.BeginChildV("Levels", imgui.Vec2{X: -100 * view.guiScale, Y: 0}, true, 0)
	for id := 0; id < archive.MaxLevels; id++ {
		inMod := view.hasLevelInMod(id)
		info := fmt.Sprintf("%d", id)
		if !inMod {
			if view.hasGameStateInMod() && (id == view.effectiveGameState().CurrentLevel()) {
				// current level should really be in the archive.
				imgui.PushStyleColor(imgui.StyleColorText, imgui.Vec4{X: 1.0, Y: 0.0, Z: 0.0, W: 1.0})
			} else {
				imgui.PushStyleColor(imgui.StyleColorText, imgui.Vec4{X: 1.0, Y: 1.0, Z: 1.0, W: 0.8})
			}
			info += " (not in mod, read-only)"
		}
		if imgui.SelectableV(info, id == view.model.selectedLevel, 0, imgui.Vec2{}) {
			view.model.selectedLevel = id
		}
		if !inMod {
			imgui.PopStyleColor()
		}
	}
	imgui.EndChild()
	imgui.SameLine()
	imgui.BeginGroup()
	if imgui.ButtonV("Clear", imgui.Vec2{X: -1, Y: 0}) {
		view.requestClearLevel(view.model.selectedLevel)
	}
	if imgui.ButtonV("Remove", imgui.Vec2{X: -1, Y: 0}) {
		view.requestRemoveLevel(view.model.selectedLevel)
	}
	imgui.EndGroup()
}

func (view *View) renderGameStateContent() {
	data := view.gameStateData()
	modStateIsDefaulting := false

	imgui.PushItemWidth(-350 * view.guiScale)
	if data.isPresent() {
		modState := data.toInstance()
		if !modState.IsSavegame() {
			modStateIsDefaulting = modState.IsDefaulting()
			if modStateIsDefaulting {
				if imgui.Button("Override") {
					view.requestSetGameState(citadel.DefaultGameState().Raw())
				}
				if imgui.IsItemHovered() {
					imgui.SetTooltip("Values of new game archives are only considered by special engines.\n" +
						"Overriding them will only work in those.")
				}
			} else if imgui.Button("Remove") {
				view.requestSetGameState(archive.ZeroGameStateData())
			}
		}
	}

	readOnly := false
	var editState *archive.GameState
	if !data.isPresent() || modStateIsDefaulting {
		editState = citadel.DefaultGameState()
		readOnly = true
	} else {
		editState = data.imported().toInstance()
	}

	onChange := func() {
		view.requestSetGameState(editState.Raw())
	}
	if imgui.TreeNodeV("Game State: General", imgui.TreeNodeFlagsDefaultOpen|imgui.TreeNodeFlagsFramed) {
		imgui.LabelText("Hacker Name", "\""+editState.HackerName(view.cp)+"\"")
		view.createPropertyControls(readOnly, editState.Instance, func(key string, modifier func(uint32) uint32) {
			view.setInterpreterValueKeyed(editState.Instance, key, modifier)
			onChange()
		})
		imgui.TreePop()
	}
	if imgui.TreeNodeV("Inventory", imgui.TreeNodeFlagsFramed) {
		view.createInventoryControls(readOnly, editState, onChange)
		imgui.TreePop()
	}
	if imgui.TreeNodeV("Hard-/Software", imgui.TreeNodeFlagsFramed) {
		view.createWareControls(readOnly, editState, onChange)
		imgui.TreePop()
	}
	if imgui.TreeNodeV("Game State: Variables", imgui.TreeNodeFlagsFramed) {
		view.createVariableControls(readOnly, editState, onChange)
		imgui.TreePop()
	}
	if imgui.TreeNodeV("Game State: Messages", imgui.TreeNodeFlagsFramed) {
		view.createMessageControls(readOnly, editState, onChange)
		imgui.TreePop()
	}

	imgui.PopItemWidth()
}

type gameStateData struct{ raw []byte }

func (data gameStateData) isPresent() bool {
	return len(data.raw) > 0
}

func (data gameStateData) toInstance() *archive.GameState {
	return archive.NewGameState(data.raw)
}

func (data gameStateData) snapshot() gameStateData {
	copied := make([]byte, len(data.raw))
	copy(copied, data.raw)
	return gameStateData{raw: copied}
}

func (data gameStateData) imported() gameStateData {
	// Avoid truncating data when working with savegames.
	if len(data.raw) >= archive.GameStateSize {
		return data.snapshot()
	}
	copied := archive.ZeroGameStateData()
	copy(copied, data.raw)
	return gameStateData{raw: copied}
}

func (view *View) gameStateData() gameStateData {
	raw := view.mod.ModifiedBlock(resource.LangAny, ids.GameState, 0)
	return gameStateData{raw: raw}
}

func (view *View) effectiveGameState() *archive.GameState {
	state := view.gameStateData().toInstance()
	if state.IsDefaulting() {
		return citadel.DefaultGameState()
	}
	return state
}

func (view *View) hasGameStateInMod() bool {
	return len(view.mod.ModifiedBlocks(resource.LangAny, ids.GameState)) > 0
}

func (view *View) hasLevelInMod(id int) bool {
	return len(view.mod.ModifiedBlocks(resource.LangAny, ids.LevelResourcesStart.Plus(lvlids.PerLevel*id+lvlids.FirstUsed))) > 0
}

func (view *View) requestClearLevel(id int) {
	if (id >= 0) && (id < archive.MaxLevels) {
		command := setArchiveDataCommand{
			model:         &view.model,
			selectedLevel: id,
			newData:       make(map[resource.ID][]byte),
			oldData:       make(map[resource.ID][]byte),
		}

		if !view.hasGameStateInMod() {
			command.newData[ids.ArchiveName] = text.DefaultCodepage().Encode("Starting Game | by InkyBlackness HackEd")
			command.newData[ids.GameState] = archive.ZeroGameStateData()
		}

		param := level.EmptyLevelParameters{
			Cyberspace: world.IsConsideredCyberspaceByDefault(id),
		}
		effectiveGameState := view.effectiveGameState()
		if id == effectiveGameState.CurrentLevel() {
			posX, posY := effectiveGameState.HackerMapPosition()
			param.MapModifier = func(x, y int, entry *level.TileMapEntry) {
				if (x == int(posX.Tile())) && (y == int(posY.Tile())) {
					entry.Type = level.TileTypeOpen
				}
			}
		}

		levelData := level.EmptyLevelData(param)
		levelIDBegin := ids.LevelResourcesStart.Plus(lvlids.PerLevel * id)
		for offset, newData := range &levelData {
			if (offset < lvlids.FirstUsed) || (offset >= lvlids.FirstUnused) {
				continue
			}
			resourceID := levelIDBegin.Plus(offset)
			oldData := view.mod.ModifiedBlock(resource.LangAny, resourceID, 0)
			if len(oldData) > 0 {
				command.oldData[resourceID] = oldData
			}
			if len(newData) > 0 {
				command.newData[resourceID] = newData
			}
		}

		view.commander.Queue(command)
	}
}

func (view *View) requestRemoveLevel(id int) {
	if (id >= 0) && (id < archive.MaxLevels) && view.hasLevelInMod(id) {
		command := setArchiveDataCommand{
			model:         &view.model,
			selectedLevel: id,
			newData:       make(map[resource.ID][]byte),
			oldData:       make(map[resource.ID][]byte),
		}

		levelIDBegin := ids.LevelResourcesStart.Plus(lvlids.PerLevel * id)
		for offset := lvlids.FirstUsed; offset < lvlids.PerLevel; offset++ {
			resourceID := levelIDBegin.Plus(offset)
			oldData := view.mod.ModifiedBlock(resource.LangAny, resourceID, 0)
			if len(oldData) > 0 {
				command.oldData[resourceID] = oldData
			}
		}

		view.commander.Queue(command)
	}
}

func (view *View) requestSetGameState(newData []byte) {
	command := setArchiveDataCommand{
		model:         &view.model,
		selectedLevel: view.model.selectedLevel,
		newData:       make(map[resource.ID][]byte),
		oldData:       make(map[resource.ID][]byte),
	}

	command.oldData[ids.GameState] = view.gameStateData().snapshot().raw
	command.newData[ids.GameState] = newData

	view.commander.Queue(command)
}

func (view *View) createPropertyControls(readOnly bool, rootInterpreter *interpreters.Instance,
	updater func(string, func(uint32) uint32)) {
	objTypeRenderer := values.ObjectTypeControlRenderer{
		Meta:      view.mod.ObjectProperties(),
		TextCache: view.textCache,
	}

	var processInterpreter func(string, *interpreters.Instance)
	processInterpreter = func(path string, interpreter *interpreters.Instance) {
		for _, key := range interpreter.Keys() {
			fullKey := path + key
			unifier := values.NewUnifier()
			unifier.Add(int32(interpreter.Get(key)))
			simplifier := values.StandardSimplifier(readOnly, fullKey, unifier,
				func(modifier func(uint32) uint32) {
					updater(fullKey, modifier)
				}, objTypeRenderer)

			interpreter.Describe(key, simplifier)
		}

		for _, key := range interpreter.ActiveRefinements() {
			fullKey := path + key
			if len(fullKey) > 0 {
				imgui.Separator()
				imgui.Text(fullKey + ":")
			}
			processInterpreter(fullKey+".", interpreter.Refined(key))
		}
	}
	processInterpreter("", rootInterpreter)
}

func (view *View) setInterpreterValueKeyed(instance *interpreters.Instance, key string, modifier func(uint32) uint32) {
	resolvedInterpreter := instance
	keys := strings.Split(key, ".")
	keyCount := len(keys)
	if len(keys) > 1 {
		for _, subKey := range keys[:keyCount-1] {
			resolvedInterpreter = resolvedInterpreter.Refined(subKey)
		}
	}
	resolvedInterpreter.Set(keys[keyCount-1], modifier(resolvedInterpreter.Get(keys[keyCount-1])))
}

func (view *View) createInventoryControls(readOnly bool, gameState *archive.GameState, onChange func()) {
	if imgui.TreeNodeV("Weapons", imgui.TreeNodeFlagsFramed) {
		for i := 0; i < archive.InventoryWeaponSlots; i++ {
			if i > 0 {
				imgui.Separator()
			}
			imgui.PushID(fmt.Sprintf("weapon%d", i))
			view.createInventoryWeaponSlotControls(readOnly, gameState.InventoryWeaponSlot(i), onChange)
			imgui.PopID()
		}
		imgui.TreePop()
	}
	if imgui.TreeNodeV("Ammo", imgui.TreeNodeFlagsFramed) {
		for i := 0; i < archive.AmmoTypeCount; i++ {
			imgui.Separator()
			imgui.PushID(fmt.Sprintf("ammo%d", i))
			view.createInventoryAmmoControls(readOnly, gameState.InventoryAmmo(i), onChange)
			imgui.PopID()
		}
		imgui.TreePop()
	}
	if imgui.TreeNodeV("Grenades", imgui.TreeNodeFlagsFramed) {
		for i := 0; i < archive.GrenadeTypeCount; i++ {
			imgui.Separator()
			imgui.PushID(fmt.Sprintf("grenade%d", i))
			view.createInventoryGrenadeControls(readOnly, gameState.InventoryGrenade(i), onChange)
			imgui.PopID()
		}
		imgui.TreePop()
	}
	if imgui.TreeNodeV("Patches", imgui.TreeNodeFlagsFramed) {
		for i := 0; i < archive.GrenadeTypeCount; i++ {
			imgui.PushID(fmt.Sprintf("patch%d", i))
			view.createPatchStateControls(readOnly, gameState.PatchState(i), onChange)
			imgui.PopID()
		}
		imgui.TreePop()
	}
	if imgui.TreeNodeV("General", imgui.TreeNodeFlagsFramed) {
		for i := 0; i < archive.GeneralInventorySlotCount; i++ {
			imgui.PushID(fmt.Sprintf("general%d", i))
			view.createGeneralInventoryControls(readOnly, gameState.GeneralInventorySlot(i), onChange)
			imgui.PopID()
		}
		imgui.TreePop()
	}
}

func (view *View) createWareControls(readOnly bool, gameState *archive.GameState, onChange func()) {
	if imgui.TreeNodeV("Hardware", imgui.TreeNodeFlagsFramed) {
		for i := 0; i < archive.HardwareTypeCount; i++ {
			imgui.PushID(fmt.Sprintf("hw%d", i))
			view.createHardwareControls(readOnly, gameState.HardwareState(i), onChange)
			imgui.PopID()
		}
		imgui.TreePop()
	}

	if imgui.TreeNodeV("Software", imgui.TreeNodeFlagsFramed) {
		for i := 0; i < archive.SoftwareOffenseTypeCount; i++ {
			imgui.PushID(fmt.Sprintf("swoffense%d", i))
			view.createVersionedSoftwareControls(readOnly, gameState.VersionedOffenseSoftwareState(i), 0, onChange)
			imgui.PopID()
		}
		for i := 0; i < archive.SoftwareDefenseTypeCount; i++ {
			imgui.PushID(fmt.Sprintf("swdefense%d", i))
			view.createVersionedSoftwareControls(readOnly, gameState.VersionedDefenseSoftwareState(i), 1, onChange)
			imgui.PopID()
		}
		for i := 0; i < archive.SoftwareOneshotTypeCount; i++ {
			imgui.PushID(fmt.Sprintf("swoneshot%d", i))
			view.createCountedSoftwareControls(readOnly, gameState.OneshotSoftwareState(i), 2, onChange)
			imgui.PopID()
		}
		imgui.TreePop()
	}
}

func (view *View) createHardwareControls(readOnly bool, state archive.HardwareState, onChange func()) {
	values.RenderUnifiedSliderInt(readOnly,
		fmt.Sprintf("Version (%s)", view.indexedName(object.ClassHardware, state.Index)),
		values.UnifierFor(state.Version()),
		func(u values.Unifier) int {
			return u.Unified().(int)
		}, func(value int) string {
			return "%d"
		}, 0, 4,
		func(newValue int) {
			state.SetVersion(newValue)
			onChange()
		})

	values.RenderUnifiedCheckboxCombo(readOnly, "Is Active", values.UnifierFor(state.IsActive()), func(newActive bool) {
		state.SetActive(newActive)
		onChange()
	})
}

func (view *View) createVersionedSoftwareControls(readOnly bool, sw archive.VersionedSoftwareState, subclass int, onChange func()) {
	values.RenderUnifiedSliderInt(readOnly,
		fmt.Sprintf("Version (%s)", view.tripleName(object.TripleFrom(int(object.ClassSoftware), subclass, sw.Index))),
		values.UnifierFor(sw.Version()),
		func(u values.Unifier) int {
			return u.Unified().(int)
		}, func(value int) string {
			return "%d"
		}, 0, 0xFF,
		func(newValue int) {
			sw.SetVersion(newValue)
			onChange()
		})
}

func (view *View) createCountedSoftwareControls(readOnly bool, sw archive.CountedSoftwareState, subclass int, onChange func()) {
	values.RenderUnifiedSliderInt(readOnly,
		fmt.Sprintf("Count (%s)", view.tripleName(object.TripleFrom(int(object.ClassSoftware), subclass, sw.Index))),
		values.UnifierFor(sw.Count()),
		func(u values.Unifier) int {
			return u.Unified().(int)
		}, func(value int) string {
			return "%d"
		}, 0, 0xFF,
		func(newValue int) {
			sw.SetCount(newValue)
			onChange()
		})
}

func (view *View) createGeneralInventoryControls(readOnly bool, slot archive.GeneralInventorySlot, onChange func()) {
	values.RenderUnifiedSliderInt(readOnly,
		fmt.Sprintf("ObjectIndex (Slot %d)", slot.Index+1),
		values.UnifierFor(slot.ObjectID()),
		func(u values.Unifier) int {
			return int(u.Unified().(level.ObjectID))
		}, func(value int) string {
			return "%d"
		}, 0, 871, // TODO: get ID limit of current level
		func(newValue int) {
			slot.SetObjectID(level.ObjectID(newValue))
			onChange()
		})
}

func (view *View) createPatchStateControls(readOnly bool, patch archive.PatchState, onChange func()) {
	values.RenderUnifiedSliderInt(readOnly,
		fmt.Sprintf("Patch Count (%s)", view.indexedName(object.ClassDrug, patch.Index)),
		values.UnifierFor(patch.Count()),
		func(u values.Unifier) int {
			return u.Unified().(int)
		}, func(value int) string {
			return "%d"
		}, 0, 0xFF,
		func(newValue int) {
			patch.SetCount(newValue)
			onChange()
		})
}

func (view *View) createInventoryGrenadeControls(readOnly bool, grenade archive.InventoryGrenade, onChange func()) {
	values.RenderUnifiedSliderInt(readOnly,
		fmt.Sprintf("Grenade Count (%s)", view.indexedName(object.ClassGrenade, grenade.Index)),
		values.UnifierFor(grenade.Count()),
		func(u values.Unifier) int {
			return u.Unified().(int)
		}, func(value int) string {
			return "%d"
		}, 0, 0xFF,
		func(newValue int) {
			grenade.SetCount(newValue)
			onChange()
		})

	values.RenderUnifiedSliderInt(readOnly, "Timer", values.UnifierFor(grenade.TimerSetting()),
		func(u values.Unifier) int {
			return int(u.Unified().(archive.GrenadeTimerSetting))
		}, func(value int) string {
			setting := archive.GrenadeTimerSetting(value)
			return fmt.Sprintf("%.01fs  -- raw: %%d", setting.InSeconds())
		}, 0, archive.GrenadeTimerMaximum,
		func(newValue int) {
			grenade.SetTimerSetting(archive.GrenadeTimerSetting(newValue))
			onChange()
		})
}

func (view *View) createInventoryAmmoControls(readOnly bool, ammo archive.InventoryAmmo, onChange func()) {
	values.RenderUnifiedSliderInt(readOnly,
		fmt.Sprintf("Clip Count (%s)", view.indexedName(object.ClassAmmo, ammo.Index)),
		values.UnifierFor(ammo.FullClipCount()),
		func(u values.Unifier) int {
			return u.Unified().(int)
		}, func(value int) string {
			return "%d"
		}, 0, 0xFF,
		func(newValue int) {
			ammo.SetFullClipCount(newValue)
			onChange()
		})
	values.RenderUnifiedSliderInt(readOnly,
		"Extra rounds",
		values.UnifierFor(ammo.ExtraRoundsCount()),
		func(u values.Unifier) int {
			return u.Unified().(int)
		}, func(value int) string {
			return "%d"
		}, 0, 0xFF,
		func(newValue int) {
			ammo.SetExtraRoundsCount(newValue)
			onChange()
		})
}

func (view *View) createInventoryWeaponSlotControls(readOnly bool, slot archive.InventoryWeaponSlot, onChange func()) {
	isInUse := slot.IsInUse()
	inUseName := fmt.Sprintf("Weapon %d In Use", slot.Index+1)

	values.RenderUnifiedCheckboxCombo(readOnly, inUseName, values.UnifierFor(isInUse), func(newUse bool) {
		if newUse {
			slot.SetInUse(0, 0)
		} else {
			slot.SetFree()
		}
		onChange()
	})
	if !isInUse {
		return
	}

	currentWeaponTriple := slot.Triple()
	if imgui.BeginCombo("Type", view.tripleName(currentWeaponTriple)) {
		allTypes := view.mod.ObjectProperties().TriplesInClass(currentWeaponTriple.Class)
		for _, triple := range allTypes {
			if imgui.SelectableV(view.tripleName(triple), triple == currentWeaponTriple, 0, imgui.Vec2{}) {
				slot.SetInUse(triple.Subclass, triple.Type)
				onChange()
			}
		}
		imgui.EndCombo()
	}
	isEnergyWeapon := currentWeaponTriple.Subclass >= 4
	if isEnergyWeapon {
		temperature, chargeAndOverload := slot.WeaponState()
		values.RenderUnifiedSliderInt(readOnly, "Temperature", values.UnifierFor(int(temperature)),
			func(u values.Unifier) int {
				return u.Unified().(int)
			}, func(value int) string {
				return fmt.Sprintf("%.02f%%%%  -- raw: %%d", (float32(value)/float32(lvlobj.EnergyWeaponMaxTemperature))*100)
			}, 0x00, lvlobj.EnergyWeaponMaxTemperature,
			func(newValue int) {
				slot.SetWeaponState(byte(newValue), chargeAndOverload)
				onChange()
			})

		overloadState := chargeAndOverload & 0x80
		charge := chargeAndOverload & 0x7F
		values.RenderUnifiedCheckboxCombo(readOnly, "Overload", values.UnifierFor(overloadState != 0), func(newOverload bool) {
			if newOverload {
				slot.SetWeaponState(temperature, 0x80|charge)
			} else {
				slot.SetWeaponState(temperature, charge)
			}
			onChange()
		})
		values.RenderUnifiedSliderInt(readOnly, "Charge", values.UnifierFor(int(charge)),
			func(u values.Unifier) int {
				return u.Unified().(int)
			}, func(value int) string {
				return fmt.Sprintf("%.02f%%%%  -- raw: %%d", (float32(value)/float32(lvlobj.EnergyWeaponMaxEnergy))*100)
			}, 0x00, 0x7F,
			func(newValue int) {
				slot.SetWeaponState(temperature, overloadState|byte(newValue))
				onChange()
			})
	} else {
		rounds, ammoType := slot.WeaponState()
		values.RenderUnifiedSliderInt(readOnly, "Rounds", values.UnifierFor(int(rounds)),
			func(u values.Unifier) int {
				return u.Unified().(int)
			}, func(value int) string {
				return fmt.Sprintf("%d", value)
			}, 0x00, 0xFF,
			func(newValue int) {
				slot.SetWeaponState(byte(newValue), ammoType)
				onChange()
			})
		values.RenderUnifiedCombo(readOnly, "Ammo Type", values.UnifierFor(int(ammoType)),
			func(u values.Unifier) int {
				return u.Unified().(int)
			},
			func(value int) string {
				switch value {
				case 0:
					return "Standard"
				case 1:
					return "Special"
				default:
					return fmt.Sprintf("Unknown %d", ammoType)
				}
			}, 2,
			func(newValue int) {
				slot.SetWeaponState(rounds, byte(newValue))
				onChange()
			})
	}
}

func (view *View) createVariableControls(readOnly bool, gameState *archive.GameState, onChange func()) {
	currentContextIdentifier := view.gameStateService.VariableBaseContext()
	if imgui.BeginCombo("Base Context", variableContextList[currentContextIdentifier].title) {
		contextIdentifiers := edit.VariableContextIdentifiers()
		for _, identifier := range contextIdentifiers {
			contextInfo := variableContextList[identifier]
			if imgui.SelectableV(contextInfo.title, identifier == currentContextIdentifier, 0, imgui.Vec2{}) {
				view.gameStateService.SetVariableBaseContext(identifier)
			}
			if imgui.IsItemHovered() {
				imgui.SetTooltip(contextInfo.info)
			}
		}
		imgui.EndCombo()
	}
	if imgui.IsItemHovered() {
		imgui.SetTooltip("The base context defines to what variables default to\n" +
			"in case they are not overridden by the project.")
	}

	if imgui.Button("Remove All Overrides") {
		_ = view.gameStateService.DefaultAllVariables()
	}
	if imgui.IsItemHovered() {
		imgui.SetTooltip("Removes all overrides and their parameters.")
	}
	if !readOnly {
		imgui.SameLine()
		if imgui.Button("Reset All") {
			for i := 0; i < archive.BooleanVarCount; i++ {
				gameState.SetBooleanVar(i, view.gameStateService.BooleanVariable(i).ResetValueBool())
			}
			for i := 0; i < archive.IntegerVarCount; i++ {
				gameState.SetIntegerVar(i, view.gameStateService.IntegerVariable(i).ResetValueInt())
			}
			onChange()
		}
		if imgui.IsItemHovered() {
			imgui.SetTooltip("Resets all variables to their configured initial value.\n" +
				"To reset a single variable, hover over the specific variable and use the context menu.")
		}
	}

	isSavegame := gameState.IsSavegame()
	if imgui.TreeNodeV("Boolean Variables", imgui.TreeNodeFlagsFramed) {
		intConverter := func(u values.Unifier) int {
			bValue := u.Unified().(bool)
			if bValue {
				return 1
			}
			return 0
		}
		defaultNames := map[int]string{0: "False", 1: "True"}

		for i := 0; i < archive.BooleanVarCount; i++ {
			varIndex := i
			info := view.gameStateService.BooleanVariable(varIndex)

			varReadOnly := readOnly || (info.Hardcoded && !isSavegame)
			varLabel := fmt.Sprintf("Var%03d", varIndex)
			varName := fmt.Sprintf("Var%03d: %s", varIndex, info.Name)
			varUnifier := values.UnifierFor(gameState.BooleanVar(varIndex))

			values.RenderUnifiedCombo(varReadOnly, varName, varUnifier, intConverter,
				func(value int) string {
					name, found := info.ValueNames[int16(value)]
					if found {
						return name
					}
					return defaultNames[value]
				},
				2,
				func(newValue int) {
					gameState.SetBooleanVar(varIndex, newValue != 0)
					onChange()
				})

			if imgui.BeginPopupContextItemV(varLabel+"-Popup", 1) {
				if imgui.Selectable("Edit info...") {
					view.modalStateMachine.SetState(&editBooleanVariableDialog{
						machine: view.modalStateMachine,
						view:    view,
						service: view.gameStateService,
						index:   varIndex,
					})
				}
				if !varReadOnly {
					imgui.Separator()
					if imgui.Selectable("Reset") {
						gameState.SetBooleanVar(varIndex, info.ResetValueBool())
						onChange()
					}
				}
				imgui.EndPopup()
			} else if imgui.IsItemHovered() && (len(info.Description) > 0) {
				imgui.SetTooltip(info.Description)
			}
		}
		imgui.TreePop()
	}
	if imgui.TreeNodeV("Integer Variables", imgui.TreeNodeFlagsFramed) {
		intConverter := func(u values.Unifier) int {
			return int(u.Unified().(int16))
		}
		for i := 0; i < archive.IntegerVarCount; i++ {
			varIndex := i
			info := view.gameStateService.IntegerVariable(varIndex)

			varReadOnly := readOnly || (info.Hardcoded && !isSavegame)
			varLabel := fmt.Sprintf("Var%02d", varIndex)
			varName := fmt.Sprintf("Var%02d: %s", varIndex, info.Name)
			varUnifier := values.UnifierFor(gameState.IntegerVar(varIndex))
			changeHandler := func(newValue int) {
				gameState.SetIntegerVar(varIndex, int16(newValue))
				onChange()
			}

			switch {
			case archive.IsRandomIntegerVariable(varIndex):
				values.RenderUnifiedSliderInt(readOnly, varName, varUnifier,
					func(u values.Unifier) int { return int(numbers.FromBinaryCodedDecimal(uint16(intConverter(u)))) },
					func(value int) string { return "%03d" },
					0, 999,
					func(newValue int) {
						changeHandler(int(numbers.ToBinaryCodedDecimal(uint16(newValue))))
					})
			case len(info.ValueNames) > 0:
				var max int16
				for key := range info.ValueNames {
					if key > max {
						max = key
					}
				}
				values.RenderUnifiedCombo(varReadOnly, varName, varUnifier, intConverter,
					func(value int) string {
						name, found := info.ValueNames[int16(value)]
						if found {
							return name
						}
						return fmt.Sprintf("Unknown %d", value)
					},
					int(max+1),
					changeHandler)
			default:
				min := math.MinInt16
				max := math.MaxInt16
				if info.Limits != nil {
					min = int(info.Limits.Minimum)
					max = int(info.Limits.Maximum)
				}

				values.RenderUnifiedSliderInt(varReadOnly, varName, varUnifier, intConverter,
					func(value int) string {
						return "%d"
					},
					min, max,
					changeHandler)
			}
			if imgui.BeginPopupContextItemV(varLabel+"-Popup", 1) {
				if imgui.Selectable("Edit info...") {
					view.modalStateMachine.SetState(&editIntegerVariableDialog{
						machine: view.modalStateMachine,
						view:    view,
						service: view.gameStateService,
						index:   varIndex,
					})
				}
				if !varReadOnly {
					imgui.Separator()
					if imgui.Selectable("Reset") {
						gameState.SetIntegerVar(varIndex, info.ResetValueInt())
						onChange()
					}
				}
				imgui.EndPopup()
			} else if imgui.IsItemHovered() && (len(info.Description) > 0) {
				imgui.SetTooltip(info.Description)
			}
		}
		imgui.TreePop()
	}
}

func (view *View) createMessageControls(readOnly bool, gameState *archive.GameState, onChange func()) {
	view.createMessageControlsFor(readOnly, "EMail",
		&view.model.emailIndex, archive.EMailCount, gameState.EMailState, onChange)
	view.createMessageControlsFor(readOnly, "Log",
		&view.model.logIndex, archive.LogCount, gameState.LogState, onChange)
	view.createMessageControlsFor(readOnly, "Fragment",
		&view.model.fragmentIndex, archive.FragmentCount, gameState.FragmentState, onChange)
}

func (view *View) createMessageControlsFor(readOnly bool, name string, index *int, limit int,
	retriever func(int) archive.MessageState, onChange func()) {
	imgui.PushID(name)
	gui.StepSliderInt(name+" Index", index, 0, limit-1)
	messageState := retriever(*index)
	values.RenderUnifiedCheckboxCombo(readOnly, "Received", values.UnifierFor(messageState.Received()),
		func(newState bool) {
			messageState.SetReceived(newState)
			onChange()
		})
	values.RenderUnifiedCheckboxCombo(readOnly, "Read", values.UnifierFor(messageState.Read()),
		func(newState bool) {
			messageState.SetRead(newState)
			onChange()
		})
	imgui.PopID()
}

func (view *View) tripleName(triple object.Triple) string {
	suffix := hintUnknown
	linearIndex := view.mod.ObjectProperties().TripleIndex(triple)
	if linearIndex >= 0 {
		key := resource.KeyOf(ids.ObjectLongNames, resource.LangDefault, linearIndex)
		objName, err := view.textCache.Text(key)
		if err == nil {
			suffix = singleLineString(objName)
		}
	}
	return triple.String() + ": " + suffix
}

func (view *View) indexedName(class object.Class, index int) string {
	startIndex := view.mod.ObjectProperties().TripleIndex(object.TripleFrom(int(class), 0, 0))
	if startIndex >= 0 {
		key := resource.KeyOf(ids.ObjectLongNames, resource.LangDefault, startIndex+index)
		objName, err := view.textCache.Text(key)
		if err == nil {
			return singleLineString(objName)
		}
	}
	return hintUnknown
}

func singleLineString(str string) string {
	return strings.ReplaceAll(strings.ReplaceAll(str, "\r", ""), "\n", "")
}