schobers/tins2021
1
0
Fork 0
Code Issues Pull Requests Releases 6 Wiki Activity

Initial version, includes simple level renderer & player movement.

Browse Source
This commit is contained in:
Sander Schobers 2021-08-07 00:00:18 +02:00
commit 9792953849
21 changed files with 1181 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored Normal file
View File

@ -0,0 +1,3 @@
.vscode/launch.json
scripts/build

295
README.md Normal file
View File

@ -0,0 +1,295 @@
# TINS 2020
## Content
- [Introduction](##Introduction)
- [Additional Rules](##Additional-Rules)
* [Implementation](###Implementation)
* [Definition](###Definition)
- [Building](##Building)
- [Sources](##Sources)
- [Licenses (third party)](##Licenses)
* [Go-SDL2](###Go-SDL2)
* [SDL 2.0](###SDL-2.0)
* [Fira Mono font](###Fira-Mono-font)
* [Escher font](###Escher-font)
* [Escheresk font](###Escheresk-font)
## Introduction
**Welcome to Qbitter!**
TODO: description of the game.
**Controls:**
TODO: fill in.
## Additional Rules
### Implementation
**genre rule #143**
This rule has been omitted by applying the bonus rule.
**artistical rule #60**
The least obvious and not finished within the time contraint: when researching you'll have to dial a phone number like you used to do with an old rotary dial (works by repeating the number on the keyboard an exact number of times).
**artistical rule #94**
TODO: describe plug.
**technical rule #113**
The main grid is made of cubes (faux 3D) that are regular hexagons in 2D.
**bonus rule #13**
TODO: describe tests.
### Definition
### Genre requirement
**** There will be 1 genre rule
**genre rule #143**
Humoristic/Funny. Make the player laugh out loud at least once by funny situations, dialogue, or anything else in your game.
Comments: If you need inspiriation take a look at [this list of 27 funniest video games of all time](https://www.theguardian.com/technology/2017/sep/07/the-27-funniest-video-games-of-all-time-hitman-grand-theft-auto) (Which includes some of my personal favorites, like monkey island or THHGTTG text adventure).
### Artistic requirements
**** There will be 2 artistical rules
**artistical rule #147**
Inspired by MC Escher
Comments: M.C. Escher created math-inspired graphical art. He created well known artworks that use impossible objects, symmetry and tesselations. One might say he was the very first creative coder. All his works can be browsed on this [online gallery](https://mcescher.com/).
**artistical rule #94**
The game should contain a plug for another program or thing you made.
Comments: It's not uncommon for a game to contain ads for other games by the same publisher. But you can get creative with it. Take for example Kings quest II. In that game you can find a complete [trailer for Space Quest](https://youtu.be/rKZwVQYV34g?t=1115) hidden as an easter egg.
### Technical requirement
**** There will be 1 technical rule
**technical rule #113**
Hexagonal - something in the game must be hexagonal
Comments: [Hexagons are the bestagons](https://www.youtube.com/watch?v=thOifuHs6eY).
### Bonus rule
**** There will be 1 bonus rule
**bonus rule #13**
Test of Might - you may skip another rule if your code contains automated test coverage (integration or unit tests).
Comments: You may use this as an escape clause to remove one of the other rules. Your automated test code should be included with your submission. For clarity, explain whether you applied this rule, and which rule you skipped, in the README of your game.
## Building
Prerequisites:
- [SDL 2.0](https://www.libsdl.org/) (SDL2, SDL2_image, SDL2_ttf and SDL2_gfx development libraries are required; for [more information](https://github.com/veandco/go-sdl2)).
- [Go](https://golang.org/dl/) 1.12 or later.
- GCC or a compatible compiler.
- [Git](https://git-scm.com/download).
With all prequisites installed you can run:
```
go get -u opslag.de/schobers/tins2021/cmd/tins2021
```
This will create the binary `$HOME/go/bin/tins2021`. Additionally you can embed the resources and build a static release with the following commands (this assumes `$HOME/go/bin` is available in the `PATH`):
```
go generate opslag.de/schobers/tins2021/cmd/tins2021
go install -tags static -ldflags "-s -w" opslag.de/schobers/tins2021/cmd/tins2021
```
If you want to use the Allegro backend you can add the build tag `allegro` to the `go install` command. E.g.:
```
go get -u opslag.de/schobers/allg5
go install -tags static,allegro -ldflags "-s -w" opslag.de/schobers/tins2021/cmd/tins2021
```
In this case the SDL 2.0 prerequisite is replaced by the Allegro 5.2 (development libraries must be available for your C compiler).
## Command line interface
You can extract all resources embedded in the executable by running it from the command line with the `--extract-resources` flag. The resources will be extract in the current working directory. Note that the game will use the resources on disk first if they are available.
## Sources
Can be found at https://opslag.de/schobers/tins2021 (Git repository).
## Licenses
### SDL 2.0
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
### Go-SDL2
Copyright (c) 2013, Go-SDL2 Authors
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of Go-SDL2 nor the names of its contributors may be
used to endorse or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
### Fira Mono font
Copyright (c) 2012-2013, The Mozilla Corporation and Telefonica S.A.
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL
-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.
The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.
DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.
"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).
"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).
"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.
"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.
PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:
1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.
2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.
3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.
5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.
TERMINATION
This license becomes null and void if any of the above conditions are
not met.
DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.
### Escher font
Licensed under WTFPL (https://isene.org/2019/12/Escher.html)
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
Version 2, December 2004
Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
Everyone is permitted to copy and distribute verbatim or modified
copies of this license document, and changing it is allowed as long
as the name is changed.
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. You just DO WHAT THE FUCK YOU WANT TO.
### Escheresk font
**Note of the author**
If you want to use this for commercial projects, please contact me: tobias (dot) sommer (at) gmx (dot) ch
I also appreciate it if you send me links/images of your non-commercial work featuring this font.
Enjoy! :)

138
cmd/tins2021/app.go Normal file
View File

@ -0,0 +1,138 @@
package main
import (
"image"
"opslag.de/schobers/geom"
"opslag.de/schobers/tins2021"
"opslag.de/schobers/zntg/play"
"opslag.de/schobers/zntg/ui"
)
type app struct {
ui.Proxy
settings *tins2021.Settings
intro *introView
}
type fontDescriptor struct {
Name string
Path string
Size int
}
func (a *app) loadFonts(ctx ui.Context, descriptors ...fontDescriptor) error {
fonts := ctx.Fonts()
for _, desc := range descriptors {
_, err := fonts.CreateFontPath(desc.Name, desc.Path, desc.Size)
if err != nil {
return err
}
}
return nil
}
const fpsOverlayName = `fps`
func (a *app) Init(ctx ui.Context) error {
if err := a.loadFonts(ctx,
fontDescriptor{"debug", "fonts/FiraMono-Regular.ttf", 12},
fontDescriptor{"default", "fonts/escheresk.ttf", 32},
fontDescriptor{"title", "fonts/escher.ttf", 80},
); err != nil {
return err
}
textureLoader := tins2021.NewResourceLoader()
textures := ctx.Textures()
if err := textureLoader.LoadFromFile(ctx.Resources(), "textures.txt", func(name, content string) error {
_, err := textures.CreateTexturePath(name, content, true)
return err
}); err != nil {
return err
}
ctx.Overlays().AddOnTop(fpsOverlayName, &play.FPS{Align: ui.AlignRight}, false)
a.intro = newIntroView(ctx)
a.Content = a.intro
return nil
}
func (a *app) Handle(ctx ui.Context, e ui.Event) bool {
switch e := e.(type) {
case *ui.DisplayMoveEvent:
location := e.Bounds.Min.ToInt()
a.settings.Window.Location = &location
case *ui.DisplayResizeEvent:
a.Arrange(ctx, e.Bounds, geom.ZeroPtF32, nil)
size := e.Bounds.Size().ToInt()
a.settings.Window.Size = &size
case *ui.KeyDownEvent:
switch e.Key {
case ui.KeyEscape:
ctx.Quit()
case ui.KeyF3:
ctx.Overlays().Toggle(ui.DefaultDebugOverlay)
ctx.Overlays().Toggle(fpsOverlayName)
}
}
return a.Proxy.Handle(ctx, e)
}
func (a *app) Render(ctx ui.Context) {
ctx.Renderer().Clear(ctx.Style().Palette.Background)
a.Proxy.Render(ctx)
}
type introView struct {
ui.StackPanel
}
type Scene struct {
ui.ControlBase
Sprites []Sprite
}
func (s *Scene) Render(ctx ui.Context) {
renderer := ctx.Renderer()
for _, sprite := range s.Sprites {
renderer.DrawTexturePoint(sprite.Texture, sprite.Position)
}
}
type Sprite struct {
Position geom.PointF32
Texture ui.Texture
}
func newSpriteImage(ctx ui.Context, im image.Image) Sprite {
texture, err := ctx.Textures().CreateTextureGo("cube_1", im, false)
if err != nil {
panic("couldn't create texture")
}
return Sprite{geom.ZeroPtF32, texture}
}
func (s Sprite) Destroy() { s.Texture.Destroy() }
func newIntroView(ctx ui.Context) *introView {
view := &introView{}
level := tins2021.NewRandomLevel()
view.Children = []ui.Control{
label("QBITTER", "title"),
paragraph("Welcome at Qbitter!\n"+
"ABCDEFGHIJKLMNOPQRSTUVWXYZ, abcdefghijklmnopqrstuvwxyz\n"+
"",
"default"),
newLevelControl(ctx, level),
}
return view
}

38
cmd/tins2021/extract.go Normal file
View File

@ -0,0 +1,38 @@
package main
import (
"embed"
"io"
"io/fs"
"os"
"path/filepath"
)
func copyFile(path string, file fs.File) error {
dir := filepath.Dir(path)
os.MkdirAll(dir, 0777)
dst, err := os.Create(path)
if err != nil {
return err
}
defer dst.Close()
_, err = io.Copy(dst, file)
return err
}
func copyBoxToDisk(resources embed.FS) error {
return fs.WalkDir(resources, "", func(path string, entry fs.DirEntry, err error) error {
if err != nil {
return err
}
if entry.IsDir() {
return nil
}
src, err := resources.Open(path)
if err != nil {
return err
}
defer src.Close()
return copyFile(filepath.Join(`resources`, path), src)
})
}

86
cmd/tins2021/levelcontrol.go Normal file
View File

@ -0,0 +1,86 @@
package main
import (
"opslag.de/schobers/geom"
"opslag.de/schobers/tins2021"
"opslag.de/schobers/zntg"
"opslag.de/schobers/zntg/ui"
)
type levelControl struct {
ui.ControlBase
Scale float32
Level *tins2021.Level
}
func newLevelControl(ctx ui.Context, level *tins2021.Level) *levelControl {
renderer := &levelControl{Level: level, Scale: .3}
ctx.Textures().CreateTextureGo("cube1", tins2021.GenerateCube(tins2021.Orange), true)
ctx.Textures().CreateTextureGo("cube1_inversed", tins2021.GenerateHole(tins2021.Orange), true)
return renderer
}
func IsModifierPressed(modifiers ui.KeyModifier, pressed ui.KeyModifier) bool {
return modifiers&pressed == pressed
}
func (r levelControl) Handle(ctx ui.Context, e ui.Event) bool {
switch e := e.(type) {
case *ui.KeyDownEvent:
switch e.Key {
case ui.KeyW:
r.Level.MovePlayer(tins2021.DirectionUpLeft)
case ui.KeyD:
r.Level.MovePlayer(tins2021.DirectionUpRight)
case ui.KeyS:
r.Level.MovePlayer(tins2021.DirectionDownRight)
case ui.KeyA:
r.Level.MovePlayer(tins2021.DirectionDownLeft)
}
}
return false
}
func (r levelControl) Render(ctx ui.Context) {
const twelfth = (1. / 6) * geom.Pi
renderer := ctx.Renderer()
size := geom.Floor32(256. * r.Scale)
scale := size / 256
centerTopSquare := geom.PtF32(.5, .5*geom.Sin32(twelfth))
delta := geom.PtF32(geom.Cos32(twelfth), .5+centerTopSquare.Y).Mul(size)
centerTopSquare = centerTopSquare.Mul(size)
delta.X = geom.Round32(delta.X)
delta.Y = geom.Round32(delta.Y)
toScreen := func(p geom.Point) geom.PointF32 {
if p.Y%2 == 0 {
return p.ToF32().Mul2D(delta.XY()).Add2D(.5*delta.X, 0)
}
return p.ToF32().Mul2D(delta.XY())
}
cube := ctx.Textures().ScaledByName("cube1", scale)
inversed := ctx.Textures().ScaledByName("cube1_inversed", scale)
player := ctx.Textures().ScaledByName("dwarf", scale)
for pos, tile := range r.Level.Tiles {
if tile.Inversed {
renderer.DrawTexturePoint(inversed, toScreen(pos))
} else {
renderer.DrawTexturePoint(cube, toScreen(pos))
}
}
playerPosition := toScreen(r.Level.Player).Sub(geom.Pt(player.Width()/2, player.Height()).ToF32())
if r.Level.Tiles[r.Level.Player].Inversed {
centerBottomSquare := geom.PtF32(centerTopSquare.X, size-centerTopSquare.Y)
renderer.DrawTexturePointOptions(player, playerPosition.Add(centerBottomSquare), ui.DrawOptions{
Tint: zntg.MustHexColor(tins2021.Blue),
})
} else {
renderer.DrawTexturePointOptions(player, playerPosition.Add(centerTopSquare), ui.DrawOptions{
Tint: zntg.MustHexColor(tins2021.Lighten(tins2021.Blue, 0.1)),
})
}
}

93
cmd/tins2021/resources/fonts/FiraMono-OFL.txt Normal file
View File

@ -0,0 +1,93 @@
Copyright (c) 2012-2013, The Mozilla Corporation and Telefonica S.A.
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL
-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.
The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.
DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.
"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).
"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).
"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.
"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.
PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:
1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.
2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.
3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.
5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.
TERMINATION
This license becomes null and void if any of the above conditions are
not met.
DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.

BIN
cmd/tins2021/resources/fonts/FiraMono-Regular.ttf Normal file
View File

Binary file not shown.

BIN
cmd/tins2021/resources/fonts/escher.ttf Normal file
View File

Binary file not shown.

BIN
cmd/tins2021/resources/fonts/escheresk.ttf Normal file
View File

Binary file not shown.

BIN
cmd/tins2021/resources/images/dwarf.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 20 KiB

1
cmd/tins2021/resources/textures.txt Normal file
View File

@ -0,0 +1 @@
dwarf: images/dwarf.png

95
cmd/tins2021/tins2021.go Normal file
View File

@ -0,0 +1,95 @@
package main
import (
"embed"
"flag"
"image/color"
"log"
"opslag.de/schobers/geom"
"opslag.de/schobers/tins2021"
"opslag.de/schobers/zntg"
"opslag.de/schobers/zntg/addons/embedres"
"opslag.de/schobers/zntg/ui"
)
//go:embed resources/*
var resources embed.FS
func main() {
err := run()
if err != nil {
log.Fatal(err)
}
}
func openResources() ui.Resources {
embedded := embedres.New(resources)
return ui.NewFallbackResources(ui.NewPathResources(nil, `resources`), embedded)
}
func run() error {
var extract bool
flag.BoolVar(&extract, "extract-resources", false, "extracts all resources to the current working directory")
flag.Parse()
if extract {
return copyBoxToDisk(resources)
}
res := openResources()
ptPtr := func(x, y int) *geom.Point {
p := geom.Pt(x, y)
return &p
}
settings := &tins2021.Settings{}
err := settings.Init()
if err != nil {
return err
}
defer settings.Store()
var location *geom.PointF32
if settings.Window.Location != nil {
location = &geom.PointF32{X: float32(settings.Window.Location.X), Y: float32(settings.Window.Location.Y)}
}
if settings.Window.Size == nil {
settings.Window.Size = ptPtr(800, 600)
}
if settings.Window.VSync == nil {
vsync := true
settings.Window.VSync = &vsync
}
renderer, err := ui.NewRenderer("Qbitter - TINS 2021", settings.Window.Size.X, settings.Window.Size.Y, ui.NewRendererOptions{
Location: location,
Resizable: true,
VSync: *settings.Window.VSync,
})
if err != nil {
return err
}
defer renderer.Destroy()
renderer.SetResourceProvider(res)
app := &app{
settings: settings,
}
style := ui.DefaultStyle()
style.Palette = &ui.Palette{
Background: zntg.MustHexColor(`#494949`),
Disabled: zntg.MustHexColor(`#DEDEDE`),
Primary: zntg.MustHexColor(`#356DAD`),
PrimaryDark: zntg.MustHexColor(`#15569F`),
PrimaryLight: zntg.MustHexColor(`#ABCAED`),
Secondary: zntg.MustHexColor(`#4AC69A`),
SecondaryDark: zntg.MustHexColor(`#0AA36D`),
SecondaryLight: zntg.MustHexColor(`#A6EED4`),
Text: zntg.MustHexColor(`#EFEFEF`),
TextOnPrimary: color.White,
TextOnSecondary: color.White,
TextNegative: zntg.MustHexColor(`#F3590E`),
TextPositive: zntg.MustHexColor(`#65D80D`),
}
return ui.Run(renderer, style, app)
}

16
cmd/tins2021/tins2021_allegro.go Normal file
View File

@ -0,0 +1,16 @@
// +build allegro
package main
import (
"log"
_ "opslag.de/schobers/zntg/allg5ui" // rendering backend
)
// #cgo windows,allegro LDFLAGS: -Wl,-subsystem,windows
import "C"
func init() {
log.Println("Using Allegro5 rendering backend")
}

13
cmd/tins2021/tins2021_sdl.go Normal file
View File

@ -0,0 +1,13 @@
// +build !allegro
package main
import (
"log"
_ "opslag.de/schobers/zntg/sdlui" // SDL rendering backend
)
func init() {
log.Println("Using SDL rendering backend")
}

26
cmd/tins2021/ui.go Normal file
View File

@ -0,0 +1,26 @@
package main
import "opslag.de/schobers/zntg/ui"
func label(text, font string) *ui.Label {
return ui.BuildLabel(text, func(l *ui.Label) {
l.Font.Name = font
})
}
type labelOptions struct {
TextAlignment ui.HorizontalAlignment
}
func labelOpts(text, font string, opts labelOptions) *ui.Label {
return ui.BuildLabel(text, func(l *ui.Label) {
l.Font.Name = font
l.TextAlignment = opts.TextAlignment
})
}
func paragraph(text, font string) *ui.Paragraph {
return ui.BuildParagraph(text, func(l *ui.Paragraph) {
l.Font.Name = font
})
}

110
cube.go Normal file
View File

@ -0,0 +1,110 @@
package tins2021
import (
"image"
"image/color"
"github.com/llgcode/draw2d/draw2dimg"
"github.com/lucasb-eyer/go-colorful"
"opslag.de/schobers/geom"
)
var Orange = `#FF9849`
var Blue = `#499BFF`
func Clamp(f float64) float64 {
if f < 0 {
return 0
}
if f > 1 {
return 1
}
return f
}
const hexagonRadius = 128
func drawToGC(gc *draw2dimg.GraphicContext, color color.Color, points ...geom.PointF) {
gc.SetStrokeColor(color)
gc.SetFillColor(color)
gc.MoveTo(points[0].XY())
for _, p := range points[1:] {
gc.LineTo(p.XY())
}
gc.Close()
gc.FillStroke()
}
func Lighten(hexColor string, lighten float64) string {
color := mustHexColor(hexColor)
h, c, l := color.Hcl()
lightened := colorful.Hcl(h, c, Clamp(l+lighten)).Clamped()
return lightened.Hex()
}
func GenerateCube(hexColor string) image.Image {
im := image.NewRGBA(image.Rect(0, 0, 2*hexagonRadius, 2*hexagonRadius))
normal := mustHexColor(hexColor)
h, c, l := normal.Hcl()
light := colorful.Hcl(h, c, Clamp(l+0.1)).Clamped()
dark := colorful.Hcl(h, c, Clamp(l-0.1)).Clamped()
center, points := Hexagon(hexagonRadius)
gc := draw2dimg.NewGraphicContext(im)
drawToGC(gc, dark, points[2], points[3], points[4], center)
drawToGC(gc, normal, points[4], points[5], points[0], center)
drawToGC(gc, light, points[0], points[1], points[2], center)
return im
}
func GenerateHexagon(hexColor string) image.Image {
im := image.NewRGBA(image.Rect(0, 0, 2*hexagonRadius, 2*hexagonRadius))
color := mustHexColor(hexColor)
center, points := Hexagon(hexagonRadius)
gc := draw2dimg.NewGraphicContext(im)
drawToGC(gc, color, points[2], points[3], points[4], center)
drawToGC(gc, color, points[4], points[5], points[0], center)
drawToGC(gc, color, points[0], points[1], points[2], center)
return im
}
func Hexagon(radius float64) (geom.PointF, []geom.PointF) {
points := make([]geom.PointF, 6)
center := geom.PtF(radius, radius)
for i := range points {
a := geom.Pi * (float64(i)/3 + (1. / 6))
points[i] = center.Add(geom.PtF(radius*geom.Cos(a), -radius*geom.Sin(a)))
}
return center, points
}
func GenerateHole(hexColor string) image.Image {
im := image.NewRGBA(image.Rect(0, 0, 2*hexagonRadius, 2*hexagonRadius))
normal := mustHexColor(hexColor)
h, c, l := normal.Hcl()
light := colorful.Hcl(h, c, Clamp(l+0.1)).Clamped()
dark := colorful.Hcl(h, c, Clamp(l-0.1)).Clamped()
center, points := Hexagon(hexagonRadius)
gc := draw2dimg.NewGraphicContext(im)
drawToGC(gc, dark, points[5], points[0], points[1], center)
drawToGC(gc, normal, points[1], points[2], points[3], center)
drawToGC(gc, light, points[3], points[4], points[5], center)
return im
}
func mustHexColor(s string) colorful.Color {
c, err := colorful.Hex(s)
if err != nil {
panic("invalid color")
}
return c
}

11
io.go Normal file
View File

@ -0,0 +1,11 @@
package tins2021
import (
"opslag.de/schobers/zntg"
)
const appName = "tins2021_qbitter"
func UserDir() (string, error) { return zntg.UserDir(appName) }
func UserFile(name string) (string, error) { return zntg.UserFile(appName, name) }

102
level.go Normal file
View File

@ -0,0 +1,102 @@
package tins2021
import (
"math/rand"
"opslag.de/schobers/geom"
)
type Direction int
const (
DirectionDownRight Direction = iota
DirectionDownLeft
DirectionUpLeft
DirectionUpRight
)
type Level struct {
Player geom.Point
Tiles map[geom.Point]*Tile
}
func AdjacentPosition(pos geom.Point, dir Direction) geom.Point {
if pos.Y%2 == 0 {
switch dir {
case DirectionDownRight:
return geom.Pt(pos.X+1, pos.Y+1)
case DirectionDownLeft:
return geom.Pt(pos.X, pos.Y+1)
case DirectionUpLeft:
return geom.Pt(pos.X, pos.Y-1)
case DirectionUpRight:
return geom.Pt(pos.X+1, pos.Y-1)
default:
panic("invalid direction")
}
}
switch dir {
case DirectionDownRight:
return geom.Pt(pos.X, pos.Y+1)
case DirectionDownLeft:
return geom.Pt(pos.X-1, pos.Y+1)
case DirectionUpLeft:
return geom.Pt(pos.X-1, pos.Y-1)
case DirectionUpRight:
return geom.Pt(pos.X, pos.Y-1)
default:
panic("invalid direction")
}
}
func (l Level) CanPlayerMove(dir Direction) (geom.Point, bool) {
towards := AdjacentPosition(l.Player, dir)
from := l.Tiles[l.Player]
to := l.Tiles[towards]
if to == nil {
return geom.ZeroPt, false
}
if dir == DirectionDownRight || dir == DirectionDownLeft {
if !from.Inversed && to.Inversed {
return geom.ZeroPt, false
}
} else {
if from.Inversed && !to.Inversed {
return geom.ZeroPt, false
}
}
return towards, true
}
func (l *Level) MovePlayer(dir Direction) bool {
towards, allowed := l.CanPlayerMove(dir)
if !allowed {
return false
}
l.Tiles[l.Player].Invert()
l.Player = towards
return true
}
func NewRandomLevel() *Level {
f := &Level{
Tiles: map[geom.Point]*Tile{},
Player: geom.Pt(1, 1),
}
for y := 1; y <= 10; y++ {
endX := 10
if y%2 == 0 {
endX--
}
for x := 1; x <= endX; x++ {
f.Tiles[geom.Pt(x, y)] = &Tile{Inversed: rand.Intn(6) == 0}
}
}
return f
}
type Tile struct {
Inversed bool
}
func (t *Tile) Invert() { t.Inversed = !t.Inversed }

53
resourceloader.go Normal file
View File

@ -0,0 +1,53 @@
package tins2021
import (
"bufio"
"fmt"
"strings"
"opslag.de/schobers/zntg/ui"
)
type ResourceLoader struct {
Resources map[string]string
}
func NewResourceLoader() *ResourceLoader {
return &ResourceLoader{}
}
func (l *ResourceLoader) parseResourcesFile(res ui.Resources, name string) error {
f, err := res.OpenResource(name)
if err != nil {
return err
}
defer f.Close()
l.Resources = map[string]string{}
scanner := bufio.NewScanner(f)
for scanner.Scan() {
definition := scanner.Text()
sep := strings.Index(definition, ":")
if sep == -1 {
continue
}
name := strings.TrimSpace(definition[:sep])
content := strings.TrimSpace(definition[sep+1:])
l.Resources[name] = content
}
return nil
}
func (l *ResourceLoader) LoadFromFile(res ui.Resources, name string, action func(string, string) error) error {
err := l.parseResourcesFile(res, name)
if err != nil {
return err
}
for name, content := range l.Resources {
err = action(name, content)
if err != nil {
return fmt.Errorf("cannot load resource '%s'; error: %v", name, err)
}
}
return nil
}

60
scripts/release.sh Normal file
View File

@ -0,0 +1,60 @@
#!/bin/bash
if [ -z "$1" ]
then
version="0.0.0"
else
version="$1"
fi
version_safe=${version//\./_}
echo "Creating ${version} release"
rm -rf build/linux*
rm -rf build/macosx*
rm -rf build/windows*
mkdir -p build/release
go generate ../cmd/tins2021
mkdir -p build/linux
go build -tags static -ldflags "-s -w" -o build/linux/qbitter ../cmd/tins2021
cp ../README.md build/linux
cd build/linux
zip -9 -q ../release/qbitter_${version_safe}_linux_amd64.zip *
echo "Created Linux release: build/release/qbitter_${version_safe}_linux_amd64.zip"
cd ../..
mkdir -p build/linux-allegro
go build -tags static,allegro -ldflags "-s -w" -o build/linux-allegro/qbitter ../cmd/tins2021
cp ../README.md build/linux-allegro
cd build/linux-allegro
zip -9 -q ../release/qbitter_allegro_${version_safe}_linux_amd64.zip *
echo "Created Linux (Allegro) release: build/release/qbitter_allegro_${version_safe}_linux_amd64.zip"
cd ../..
mkdir -p build/macosx
CGO_ENABLED=1 CC=o64-clang CXX=o64-clang++ GOOS=darwin GOARCH=amd64 go build -tags static -ldflags "-s -w" -o build/macosx/qbitter ../cmd/tins2021
cp ../README.md build/macosx
cd build/macosx
zip -9 -q ../release/qbitter_${version_safe}_macosx_amd64.zip *
echo "Created Mac OS X release: build/release/qbitter_${version_safe}_macosx_amd64.zip"
cd ../..
mkdir -p build/windows
CGO_ENABLED=1 CC=x86_64-w64-mingw32-gcc GOOS=windows GOARCH=amd64 go build -tags static -ldflags "-s -w" -o build/windows/qbitter.exe ../cmd/tins2021
cp ../README.md build/windows
cd build/windows
zip -9 -q ../release/qbitter_${version_safe}_windows_amd64.zip *
echo "Created Windows release: build/release/qbitter_${version_safe}_windows_amd64.zip"
cd ../..
mkdir -p build/windows-allegro
CGO_ENABLED=1 CC=x86_64-w64-mingw32-gcc GOOS=windows GOARCH=amd64 go build -tags static,allegro,mingw64_7_3 -ldflags "-s -w" -o build/windows-allegro/qbitter.exe ../cmd/tins2021
cp ../README.md build/windows-allegro
cd build/windows-allegro
zip -9 -q ../release/qbitter_allegro_${version_safe}_windows_amd64.zip *
echo "Created Windows (Allegro) release: build/release/qbitter_allegro_${version_safe}_windows_amd64.zip"
cd ../..

41
settings.go Normal file
View File

@ -0,0 +1,41 @@
package tins2021
import (
"os"
"opslag.de/schobers/geom"
"opslag.de/schobers/zntg"
)
type Settings struct {
Window WindowSettings
}
func SettingsPath() (string, error) {
return UserFile("settings.json")
}
func (s *Settings) Init() error {
path, err := SettingsPath()
if err != nil {
return err
}
if _, err := os.Stat(path); os.IsNotExist(err) {
return nil
}
return zntg.DecodeJSON(path, s)
}
func (s *Settings) Store() error {
path, err := SettingsPath()
if err != nil {
return err
}
return zntg.EncodeJSON(path, s)
}
type WindowSettings struct {
Location *geom.Point
Size *geom.Point
VSync *bool
}