Adding modding folder with a hacked build.

modding/hacked/editor/movies/CompressingStartState.go

@@ -0,0 +1,36 @@
+package movies
+
+import (
+	"github.com/inkyblackness/imgui-go/v3"
+
+	"github.com/inkyblackness/hacked/ss1/content/movie"
+	"github.com/inkyblackness/hacked/ui/gui"
+)
+
+type compressionListenerFunc func(compressionResult)
+
+type compressingStartState struct {
+	machine gui.ModalStateMachine
+	view    *View
+
+	width    int
+	height   int
+	input    movie.Scene
+	listener compressionListenerFunc
+}
+
+func (state compressingStartState) Render() {
+	imgui.OpenPopup("Compressing...")
+	task := newCompressionTask(state.input, state.width, state.height)
+	state.machine.SetState(&compressingWaitingState{
+		machine:  state.machine,
+		view:     state.view,
+		input:    state.input,
+		listener: state.listener,
+		task:     task,
+	})
+	go task.run()
+}
+
+func (state compressingStartState) HandleFiles(names []string) {
+}

modding/hacked/editor/movies/CompressingWaitingState.go

@@ -0,0 +1,45 @@
+package movies
+
+import (
+	"github.com/inkyblackness/imgui-go/v3"
+
+	"github.com/inkyblackness/hacked/ss1/content/movie"
+	"github.com/inkyblackness/hacked/ui/gui"
+)
+
+type compressingWaitingState struct {
+	machine gui.ModalStateMachine
+	view    *View
+
+	input    movie.Scene
+	listener compressionListenerFunc
+	task     *compressionTask
+}
+
+func (state *compressingWaitingState) Render() {
+	if imgui.BeginPopupModalV("Compressing...", nil,
+		imgui.WindowFlagsNoResize|imgui.WindowFlagsNoMove|imgui.WindowFlagsNoSavedSettings|imgui.WindowFlagsAlwaysAutoResize) {
+		imgui.Text("This may take a while.\n" +
+			"Yes, your PC is probably capable of recoding HD movies way quicker;\n" +
+			"Sadly, this codec of '94 is quite tricky.")
+
+		if imgui.Button("Cancel") {
+			state.task.cancel()
+		}
+
+		result := state.task.update()
+		if result != nil {
+			state.machine.SetState(nil)
+			imgui.CloseCurrentPopup()
+
+			state.listener(result)
+		}
+
+		imgui.EndPopup()
+	} else {
+		state.machine.SetState(nil)
+	}
+}
+
+func (state *compressingWaitingState) HandleFiles(names []string) {
+}

modding/hacked/editor/movies/CompressionTask.go

@@ -0,0 +1,65 @@
+package movies
+
+import (
+	"context"
+
+	"github.com/inkyblackness/hacked/ss1/content/movie"
+)
+
+type compressionTask struct {
+	width      int
+	height     int
+	input      movie.Scene
+	ctx        context.Context
+	ctxCancel  context.CancelFunc
+	resultChan chan compressionResult
+}
+
+type compressionResult interface{}
+
+type compressionAborted struct{}
+
+type compressionFailed struct{ err error }
+
+type compressionFinished struct{ scene movie.HighResScene }
+
+func newCompressionTask(scene movie.Scene, width, height int) *compressionTask {
+	task := &compressionTask{
+		width:      width,
+		height:     height,
+		input:      scene,
+		resultChan: make(chan compressionResult),
+	}
+	task.ctx, task.ctxCancel = context.WithCancel(context.Background())
+
+	return task
+}
+
+func (task *compressionTask) run() {
+	defer close(task.resultChan)
+	highResScene, err := movie.HighResSceneFrom(task.ctx, task.input, task.width, task.height)
+	switch {
+	case task.ctx.Err() != nil:
+		task.resultChan <- compressionAborted{}
+	case err != nil:
+		task.resultChan <- compressionFailed{err: err}
+	default:
+		task.resultChan <- compressionFinished{scene: highResScene}
+	}
+}
+
+func (task *compressionTask) update() compressionResult {
+	select {
+	case result, ok := <-task.resultChan:
+		if ok {
+			return result
+		}
+		return compressionAborted{}
+	default:
+		return nil
+	}
+}
+
+func (task *compressionTask) cancel() {
+	task.ctxCancel()
+}

modding/hacked/editor/movies/View.go

@@ -0,0 +1,615 @@
+package movies
+
+import (
+	"fmt"
+	"image"
+	"image/color"
+	"image/gif"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/asticode/go-astisub"
+	"github.com/inkyblackness/imgui-go/v3"
+
+	"github.com/inkyblackness/hacked/editor/external"
+	"github.com/inkyblackness/hacked/editor/graphics"
+	"github.com/inkyblackness/hacked/editor/render"
+	"github.com/inkyblackness/hacked/ss1/content/audio"
+	"github.com/inkyblackness/hacked/ss1/content/bitmap"
+	"github.com/inkyblackness/hacked/ss1/content/movie"
+	"github.com/inkyblackness/hacked/ss1/edit/undoable"
+	"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/ids"
+	"github.com/inkyblackness/hacked/ui/gui"
+)
+
+type movieInfo struct {
+	title     string
+	multilang bool
+}
+
+var knownMovies = map[resource.ID]movieInfo{
+	ids.MovieIntro: {title: "Intro", multilang: true},
+	ids.MovieDeath: {title: "Death", multilang: false},
+	ids.MovieEnd:   {title: "End", multilang: false},
+}
+
+var knownMoviesOrder = []resource.ID{ids.MovieIntro, ids.MovieDeath, ids.MovieEnd}
+
+// View provides edit controls for animations.
+type View struct {
+	mod *world.Mod
+
+	frameCache    *graphics.FrameCache
+	frameCacheKey graphics.FrameCacheKey
+
+	movieService undoable.MovieService
+
+	modalStateMachine gui.ModalStateMachine
+	guiScale          float32
+	commander         cmd.Commander
+
+	model viewModel
+}
+
+// NewMoviesView returns a new instance.
+func NewMoviesView(mod *world.Mod, frameCache *graphics.FrameCache,
+	movieService undoable.MovieService,
+	modalStateMachine gui.ModalStateMachine, guiScale float32, commander cmd.Commander) *View {
+	view := &View{
+		mod: mod,
+
+		frameCache:    frameCache,
+		frameCacheKey: frameCache.AllocateKey(),
+
+		movieService: movieService,
+
+		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: 800 * view.guiScale, Y: 300 * view.guiScale}, imgui.ConditionFirstUseEver)
+		if imgui.BeginV("Movies", view.WindowOpen(), imgui.WindowFlagsNoCollapse|imgui.WindowFlagsHorizontalScrollbar) {
+			view.renderContent()
+		}
+		imgui.End()
+	}
+}
+
+func (view *View) renderContent() {
+	if imgui.BeginChildV("Properties", imgui.Vec2{X: 350 * view.guiScale, Y: 0}, false, 0) {
+		imgui.PushItemWidth(-150 * view.guiScale)
+		if imgui.BeginCombo("Movie", knownMovies[view.model.currentKey.ID].title) {
+			for _, id := range knownMoviesOrder {
+				if imgui.SelectableV(knownMovies[id].title, id == view.model.currentKey.ID, 0, imgui.Vec2{}) {
+					view.model.currentKey.ID = id
+					view.model.currentKey.Index = 0
+					view.model.currentScene = 0
+					view.model.currentFrame = 0
+					view.model.frameTimeFraction = -1
+				}
+			}
+			imgui.EndCombo()
+		}
+
+		if knownMovies[view.model.currentKey.ID].multilang {
+			if imgui.BeginCombo("Language", view.model.currentKey.Lang.String()) {
+				languages := resource.Languages()
+				for _, lang := range languages {
+					if imgui.SelectableV(lang.String(), lang == view.model.currentKey.Lang, 0, imgui.Vec2{}) {
+						view.model.currentKey.Lang = lang
+					}
+				}
+				imgui.EndCombo()
+			}
+		} else {
+			imgui.LabelText("Language", "(not localized)")
+		}
+
+		imgui.Separator()
+
+		view.renderProperties()
+
+		imgui.PopItemWidth()
+	}
+	imgui.EndChild()
+
+	scenes := view.movieService.Video(view.model.currentKey)
+	imgui.SameLine()
+	imgui.BeginGroup()
+	imgui.BeginChildV("Scenes", imgui.Vec2{X: 200 * view.guiScale, Y: -60 * view.guiScale}, true,
+		imgui.WindowFlagsHorizontalScrollbar|imgui.WindowFlagsAlwaysVerticalScrollbar)
+	for index, scene := range scenes {
+		sceneInfo := fmt.Sprintf("Scene %02d (%d frames)", index, len(scene.Frames))
+		if imgui.SelectableV(sceneInfo, view.model.currentScene == index, 0, imgui.Vec2{}) {
+			view.model.currentScene = index
+			view.model.currentFrame = 0
+			view.model.frameTimeFraction = -1
+		}
+	}
+	imgui.EndChild()
+	if imgui.Button("Up") {
+		view.requestMoveSceneEarlier()
+	}
+	imgui.SameLine()
+	if imgui.Button("Down") {
+		view.requestMoveSceneLater()
+	}
+	imgui.SameLine()
+	if imgui.Button("Remove") {
+		view.requestRemoveScene()
+	}
+	if imgui.Button("Import") {
+		view.requestImportScene("")
+	}
+	imgui.SameLine()
+	if imgui.Button("Export") {
+		view.requestExportScene()
+	}
+	imgui.EndGroup()
+	imgui.SameLine()
+	if imgui.BeginChildV("Frames", imgui.Vec2{X: -1, Y: 0}, false, 0) {
+		var scene *movie.Scene
+		if (view.model.currentScene >= 0) && (view.model.currentScene < len(scenes)) {
+			scene = &scenes[view.model.currentScene]
+		}
+		if scene != nil {
+			var frame *movie.Frame
+			if (view.model.currentFrame >= 0) && (view.model.currentFrame < len(scene.Frames)) {
+				frame = &scene.Frames[view.model.currentFrame]
+			}
+			if frame != nil {
+				// This code updates the texture every render cycle. In case of performance loss, this is a point to optimize.
+				view.frameCache.SetTexture(view.frameCacheKey, 600, 300, frame.Pixels, &scene.Palette)
+
+				render.FrameImage("Frame", view.frameCache, view.frameCacheKey,
+					imgui.Vec2{
+						X: float32(movie.HighResDefaultWidth) * view.guiScale,
+						Y: float32(movie.HighResDefaultHeight) * view.guiScale,
+					})
+			}
+
+			imgui.PushItemWidth(-150 * view.guiScale)
+			gui.StepSliderInt("Frame Index", &view.model.currentFrame, 0, len(scene.Frames)-1)
+			imgui.PopItemWidth()
+			if (frame != nil) && (frame.DisplayTime < (time.Second / 4)) {
+				imgui.Separator()
+				if view.model.frameTimeFraction < 0 {
+					view.model.frameTimeFraction = int((frame.DisplayTime * 0x10000) / time.Second)
+				}
+				imgui.PushItemWidth(-150 * view.guiScale)
+				gui.StepSliderInt("Frame time fraction", &view.model.frameTimeFraction, 0, 0x3FFF)
+				imgui.PopItemWidth()
+				if imgui.Button("Set for scene") {
+					displayTime := (time.Duration(view.model.frameTimeFraction) * time.Second) / 0x10000
+					view.requestSetFramesDisplayTime(displayTime)
+				}
+			}
+		}
+	}
+	imgui.EndChild()
+}
+
+func (view *View) renderProperties() {
+	view.renderAudioProperties()
+	view.renderSubtitlesProperties()
+
+	if view.movieService.SizeWarning(view.model.currentKey) {
+		view.renderSizeWarning()
+	}
+}
+
+func (view *View) renderAudioProperties() {
+	imgui.PushID("audio")
+	imgui.Separator()
+	sound := view.currentSound()
+	imgui.LabelText("Audio", fmt.Sprintf("%.2f sec", sound.Duration()))
+	if imgui.Button("Import") {
+		view.requestImportAudio()
+	}
+	if !sound.Empty() {
+		imgui.SameLine()
+		if imgui.Button("Export") {
+			view.requestExportAudio(sound)
+		}
+		imgui.SameLine()
+		if imgui.Button("Clear") {
+			view.requestClearAudio()
+		}
+	}
+	imgui.PopID()
+}
+
+func (view *View) renderSubtitlesProperties() {
+	imgui.PushID("subtitles")
+	imgui.Separator()
+	if imgui.BeginCombo("Sub Language", view.model.currentSubtitleLang.String()) {
+		languages := resource.Languages()
+		for _, lang := range languages {
+			if imgui.SelectableV(lang.String(), lang == view.model.currentSubtitleLang, 0, imgui.Vec2{}) {
+				view.model.currentSubtitleLang = lang
+			}
+		}
+		imgui.EndCombo()
+	}
+	sub := view.currentSubtitles()
+	imgui.Text(fmt.Sprintf("%d lines", len(sub.Entries)))
+	if imgui.Button("Import") {
+		view.requestImportSubtitles()
+	}
+	if len(sub.Entries) > 0 {
+		imgui.SameLine()
+		if imgui.Button("Export") {
+			view.requestExportSubtitles()
+		}
+		imgui.SameLine()
+		if imgui.Button("Clear") {
+			view.requestClearSubtitles()
+		}
+	}
+	imgui.PopID()
+}
+
+func (view *View) renderSizeWarning() {
+	imgui.Separator()
+	imgui.PushStyleColor(imgui.StyleColorText, imgui.Vec4{X: 1, Y: 0, Z: 0, W: 1})
+	imgui.Text("Size warning - reduce content!")
+	imgui.PopStyleColor()
+	if imgui.IsItemHovered() {
+		imgui.BeginTooltip()
+		imgui.SetTooltip("The movie has reached a size larger than officially supported.\n" +
+			"While the game might still show the movie, a future update may stop supporting it.")
+		imgui.EndTooltip()
+	}
+}
+
+func (view *View) restoreFunc() func() {
+	return view.restoreFuncWithScene(view.model.currentScene)
+}
+
+func (view *View) restoreFuncWithScene(oldScene int) func() {
+	oldKey := view.model.currentKey
+	oldSubtitlesLang := view.model.currentSubtitleLang
+	oldFrame := view.model.currentFrame
+
+	return func() {
+		view.model.restoreFocus = true
+		view.model.currentKey = oldKey
+		view.model.currentSubtitleLang = oldSubtitlesLang
+		view.model.currentScene = oldScene
+		view.model.currentFrame = oldFrame
+		view.model.frameTimeFraction = -1
+	}
+}
+
+func (view *View) currentSound() audio.L8 {
+	return view.movieService.Audio(view.model.currentKey)
+}
+
+func (view *View) requestExportAudio(sound audio.L8) {
+	filename := fmt.Sprintf("%s_%s.wav", knownMovies[view.model.currentKey.ID].title, view.model.currentKey.Lang.String())
+
+	external.ExportAudio(view.modalStateMachine, filename, sound)
+}
+
+func (view *View) requestImportAudio() {
+	external.ImportAudio(view.modalStateMachine, func(sound audio.L8) {
+		view.movieService.RequestSetAudio(view.model.currentKey, sound, view.restoreFunc())
+	})
+}
+
+func (view *View) requestClearAudio() {
+	view.movieService.RequestSetAudio(view.model.currentKey, audio.L8{}, view.restoreFunc())
+}
+
+func (view *View) currentSubtitles() movie.SubtitleList {
+	return view.movieService.Subtitles(view.model.currentKey, view.model.currentSubtitleLang)
+}
+
+func (view View) requestExportSubtitles() {
+	filename := fmt.Sprintf("%s_%s.srt", knownMovies[view.model.currentKey.ID].title, view.model.currentSubtitleLang.String())
+	info := "File to be written: " + filename
+	var exportTo func(string)
+	currentSubtitles := view.currentSubtitles()
+
+	exportTo = func(dirname string) {
+		writer, err := os.Create(filepath.Join(dirname, filename))
+		if err != nil {
+			external.Export(view.modalStateMachine, "Could not create file.\n"+info, exportTo, true)
+			return
+		}
+		defer func() { _ = writer.Close() }()
+
+		sub := astisub.NewSubtitles()
+
+		var lastItem *astisub.Item
+		for _, entry := range currentSubtitles.Entries {
+			var item astisub.Item
+			var line astisub.Line
+			line.Items = append(line.Items, astisub.LineItem{Text: entry.Text})
+			item.Lines = []astisub.Line{line}
+			item.StartAt = entry.Timestamp
+			item.EndAt = item.StartAt
+			if lastItem != nil {
+				lastItem.EndAt = item.StartAt
+			}
+			lastItem = &item
+			sub.Items = append(sub.Items, lastItem)
+		}
+
+		err = sub.WriteToSRT(writer)
+		if err != nil {
+			external.Export(view.modalStateMachine, "Could not export subtitles.\n"+info, exportTo, true)
+			return
+		}
+	}
+
+	external.Export(view.modalStateMachine, info, exportTo, false)
+}
+
+func (view *View) requestImportSubtitles() {
+	info := "File must be an .SRT file."
+	types := []external.TypeInfo{{Title: "Subtitle files (*.srt)", Extensions: []string{"srt"}}}
+	var fileHandler func(string)
+
+	fileHandler = func(filename string) {
+		reader, err := os.Open(filename)
+		if err != nil {
+			external.Import(view.modalStateMachine, "Could not open file.\n"+info, types, fileHandler, true)
+			return
+		}
+		defer func() { _ = reader.Close() }()
+
+		subtitles, err := astisub.ReadFromSRT(reader)
+		if err != nil {
+			external.Import(view.modalStateMachine, "File not recognized as SRT.\n"+info, types, fileHandler, true)
+			return
+		}
+		var newSubtitles movie.SubtitleList
+		for _, item := range subtitles.Items {
+			var newEntry movie.Subtitle
+			newEntry.Timestamp = item.StartAt
+			for _, line := range item.Lines {
+				for _, lineItem := range line.Items {
+					if len(newEntry.Text) > 0 {
+						newEntry.Text += "\n"
+					}
+					newEntry.Text += lineItem.Text
+				}
+			}
+			newSubtitles.Entries = append(newSubtitles.Entries, newEntry)
+		}
+
+		view.movieService.RequestSetSubtitles(view.model.currentKey, view.model.currentSubtitleLang,
+			newSubtitles, view.restoreFunc())
+	}
+
+	external.Import(view.modalStateMachine, info, types, fileHandler, false)
+}
+
+func (view *View) requestClearSubtitles() {
+	view.movieService.RequestSetSubtitles(view.model.currentKey, view.model.currentSubtitleLang,
+		movie.SubtitleList{}, view.restoreFunc())
+}
+
+func (view *View) requestImportScene(returningInfo string) {
+	info := fmt.Sprintf("File must be an animated GIF file in size %dx%d.",
+		movie.HighResDefaultWidth, movie.HighResDefaultHeight)
+	types := []external.TypeInfo{{Title: "Animation files (*.gif)", Extensions: []string{"gif"}}}
+	var fileHandler func(string)
+
+	fileHandler = func(filename string) {
+		reader, err := os.Open(filename)
+		if err != nil {
+			external.Import(view.modalStateMachine, "Could not open file.\n"+info, types, fileHandler, true)
+			return
+		}
+		defer func() { _ = reader.Close() }()
+		data, err := gif.DecodeAll(reader)
+		if err != nil {
+			external.Import(view.modalStateMachine, "File not recognized as GIF.\n"+info, types, fileHandler, true)
+			return
+		}
+
+		if (data.Config.Width != movie.HighResDefaultWidth) || (data.Config.Height != movie.HighResDefaultHeight) {
+			external.Import(view.modalStateMachine, info, types, fileHandler, true)
+			return
+		}
+
+		var scene movie.Scene
+		scene.Frames = make([]movie.Frame, len(data.Image))
+		var palette bitmap.Palette
+		if gifPalette, isPal := data.Config.ColorModel.(color.Palette); isPal {
+			for index, clr := range gifPalette {
+				r, g, b, _ := clr.RGBA()
+				palette[index].Red = byte(r >> 8)
+				palette[index].Green = byte(g >> 8)
+				palette[index].Blue = byte(b >> 8)
+			}
+		}
+		framebuffer := make([]byte, data.Config.Width*data.Config.Height)
+		framebufferSnapshot := func() []byte {
+			buf := make([]byte, len(framebuffer))
+			copy(buf, framebuffer)
+			return buf
+		}
+
+		var usedColors [256]bool
+		for _, img := range data.Image {
+			for y := img.Bounds().Min.Y; y < img.Bounds().Max.Y; y++ {
+				for x := img.Bounds().Min.X; x < img.Bounds().Max.X; x++ {
+					colorIndex := img.ColorIndexAt(x, y)
+					usedColors[colorIndex] = true
+				}
+			}
+		}
+		var indexMap [256]byte
+		for i := 0; i < 256; i++ {
+			indexMap[byte(i)] = byte(i)
+		}
+		// Ensure color index 0 is not used.
+		if usedColors[0] && (data.BackgroundIndex != 0) {
+			if data.BackgroundIndex == 255 {
+				indexMap[0] = palette.IndexClosestTo(palette[0], []byte{0, 255})
+			} else {
+				palette[0], palette[data.BackgroundIndex] = palette[data.BackgroundIndex], palette[0]
+				indexMap[0] = data.BackgroundIndex
+				indexMap[data.BackgroundIndex] = 0
+			}
+		}
+		palette[0] = bitmap.RGB{Red: 0x00, Green: 0x00, Blue: 0x00} // default color for background
+		// In case the last index is in use by the animation, use a similar color as this entry is reserved for subtitles.
+		if usedColors[255] && (data.BackgroundIndex != 255) {
+			indexMap[255] = palette.IndexClosestTo(palette[255], []byte{0, 255})
+		}
+		palette[255] = bitmap.RGB{Red: 0x9A, Green: 0x35, Blue: 0x35} // default color in intro
+
+		scene.Palette = palette
+		for index, img := range data.Image {
+			for y := img.Bounds().Min.Y; y < img.Bounds().Max.Y; y++ {
+				for x := img.Bounds().Min.X; x < img.Bounds().Max.X; x++ {
+					colorIndex := img.ColorIndexAt(x, y)
+					if colorIndex != data.BackgroundIndex {
+						framebuffer[y*data.Config.Width+x] = indexMap[colorIndex]
+					}
+				}
+			}
+
+			scene.Frames[index].DisplayTime = time.Duration(data.Delay[index]) * 10 * time.Millisecond // nolint: durationcheck
+			scene.Frames[index].Pixels = framebufferSnapshot()
+		}
+
+		view.compressAndAddScene(scene, data.Config.Width, data.Config.Height)
+	}
+
+	external.Import(view.modalStateMachine, returningInfo+info, types, fileHandler, false)
+}
+
+func (view *View) compressAndAddScene(scene movie.Scene, width, height int) {
+	view.modalStateMachine.SetState(&compressingStartState{
+		machine:  view.modalStateMachine,
+		view:     view,
+		width:    width,
+		height:   height,
+		input:    scene,
+		listener: view.onCompressionResult,
+	})
+}
+
+func (view *View) onCompressionResult(result compressionResult) {
+	switch typedResult := result.(type) {
+	case compressionAborted:
+	case compressionFinished:
+		view.requestAddScene(typedResult.scene)
+	case compressionFailed:
+		view.requestImportScene("Could not compress. Follow recommendations and retry.\n" +
+			"Technical details:\n" + typedResult.err.Error() + "\n\n")
+	}
+}
+
+func (view *View) requestAddScene(scene movie.HighResScene) {
+	view.movieService.RequestAddScene(view.model.currentKey, scene, view.restoreFunc())
+}
+
+func (view *View) requestExportScene() {
+	filename := fmt.Sprintf("%s_Scene%02d_%s.gif",
+		knownMovies[view.model.currentKey.ID].title,
+		view.model.currentScene,
+		view.model.currentKey.Lang.String())
+	info := "File to be written: " + filename
+	var exportTo func(string)
+
+	scenes := view.movieService.Video(view.model.currentKey)
+	var scene *movie.Scene
+	if view.model.currentScene >= 0 && view.model.currentScene < len(scenes) {
+		scene = &scenes[view.model.currentScene]
+	}
+
+	if (scene == nil) || len(scene.Frames) == 0 {
+		return
+	}
+
+	exportTo = func(dirname string) {
+		writer, err := os.Create(filepath.Join(dirname, filename))
+		if err != nil {
+			external.Export(view.modalStateMachine, "Could not create file.\n"+info, exportTo, true)
+			return
+		}
+		defer func() { _ = writer.Close() }()
+
+		colorPalette := scene.Palette.ColorPalette(false)
+		data := gif.GIF{
+			Config: image.Config{
+				Width:      600,
+				Height:     300,
+				ColorModel: colorPalette,
+			},
+			LoopCount: -1,
+		}
+
+		imageRect := image.Rect(0, 0, data.Config.Width, data.Config.Height)
+		for _, frame := range scene.Frames {
+			frameImg := image.NewPaletted(imageRect, colorPalette)
+			frameImg.Pix = frame.Pixels
+			frameImg.Stride = data.Config.Width
+			data.Image = append(data.Image, frameImg)
+			data.Delay = append(data.Delay, int(((frame.DisplayTime/time.Millisecond)+5)/10))
+		}
+
+		err = gif.EncodeAll(writer, &data)
+		if err != nil {
+			external.Export(view.modalStateMachine, info, exportTo, true)
+			return
+		}
+	}
+
+	external.Export(view.modalStateMachine, info, exportTo, false)
+}
+
+func (view *View) requestMoveSceneEarlier() {
+	scenes := view.movieService.Video(view.model.currentKey)
+	if (view.model.currentScene > 0) && (view.model.currentScene < len(scenes)) {
+		view.movieService.RequestMoveSceneEarlier(view.model.currentKey, view.model.currentScene,
+			view.restoreFuncWithScene(view.model.currentScene-1))
+	}
+}
+
+func (view *View) requestMoveSceneLater() {
+	scenes := view.movieService.Video(view.model.currentKey)
+	if (view.model.currentScene >= 0) && (view.model.currentScene < (len(scenes) - 1)) {
+		view.movieService.RequestMoveSceneLater(view.model.currentKey, view.model.currentScene,
+			view.restoreFuncWithScene(view.model.currentScene+1))
+	}
+}
+
+func (view *View) requestRemoveScene() {
+	scenes := view.movieService.Video(view.model.currentKey)
+	if (view.model.currentScene >= 0) && (view.model.currentScene < len(scenes)) {
+		view.movieService.RequestRemoveScene(view.model.currentKey, view.model.currentScene, view.restoreFunc())
+	}
+}
+
+func (view *View) requestSetFramesDisplayTime(displayTime time.Duration) {
+	view.movieService.RequestSetSceneFramesDisplayTime(view.model.currentKey, view.model.currentScene, displayTime, view.restoreFunc())
+}

modding/hacked/editor/movies/ViewModel.go

@@ -0,0 +1,26 @@
+package movies
+
+import (
+	"github.com/inkyblackness/hacked/ss1/resource"
+	"github.com/inkyblackness/hacked/ss1/world/ids"
+)
+
+type viewModel struct {
+	windowOpen   bool
+	restoreFocus bool
+
+	currentKey          resource.Key
+	currentSubtitleLang resource.Language
+	currentScene        int
+	currentFrame        int
+
+	frameTimeFraction int
+}
+
+func freshViewModel() viewModel {
+	return viewModel{
+		currentKey:          resource.KeyOf(ids.MovieIntro, resource.LangDefault, 0),
+		currentSubtitleLang: resource.LangDefault,
+		frameTimeFraction:   -1,
+	}
+}