thefish/alchemyst
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

resolve conflicts

Browse Source
This commit is contained in:
anton.gurov 2019-11-05 12:42:05 +03:00
commit e9dec9ac0a
33 changed files with 1004 additions and 360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,4 +1,5 @@
.idea/*
tmp/*
logs/*
dist/*
*.swp

21
Makefile
View File

@ -2,26 +2,27 @@ PROJECT_NAME := "alchemyst-go"
PKG := "lab.zaar.be/thefish/$(PROJECT_NAME)"
GO=$(shell which go)
CWD=$(shell pwd)
DISTFOLDER=$(CWD)/dist
CP=$(shell cp)
GLIDE=$(shell which glide)
LDFLAGS="-X \"main.versionInfo=${PKG_VER}-${CI_PIPELINE_ID} built at $(shell date) on $(shell hostname) with $(shell go version)\""
.PHONY: all build test get-dep
.PHONY: all build test
all: build test
#build: build.spec build.server
build: build.server
build: build.game
#build.spec:
# $(CWD)/bin/oapi-codegen --generate types,spec -o $(CWD)/api/inner/inner.gen.go $(CWD)/public/schema/api.yaml
build.deps:
GIT_SSL_NO_VERIFY=true $(GO) mod vendor
build.server:
$(GO) build -ldflags $(LDFLAGS) -o $(CWD)/bin/game $(CWD)/cmd/game/main.go
build.game:
cp $(CWD)/vendor/lab.zaar.be/thefish/bearlibterminal/libBearLibTerminal.so $(DISTFOLDER)
cp $(CWD)/config.json $(DISTFOLDER)
cp -r $(CWD)/resources $(DISTFOLDER)
$(GO) build -ldflags $(LDFLAGS) -o $(DISTFOLDER)/game $(CWD)/cmd/game/main.go
test:
$(GO) test -v $(go list ./... | grep -v /vendor/)
get-dep:
GIT_SSL_NO_VERIFY=true go mod vendor

108
cmd/game/main.go
View File

@ -3,8 +3,13 @@ package main
import (
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
"lab.zaar.be/thefish/alchemyst-go/engine/ecs"
"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
"lab.zaar.be/thefish/alchemyst-go/engine/gamemap/mapgens"
"lab.zaar.be/thefish/alchemyst-go/engine/gamestate"
"lab.zaar.be/thefish/alchemyst-go/engine/mob"
"lab.zaar.be/thefish/alchemyst-go/engine/screens"
"lab.zaar.be/thefish/alchemyst-go/engine/types"
"lab.zaar.be/thefish/alchemyst-go/ui"
"lab.zaar.be/thefish/alchemyst-go/ui/mainwindow"
"lab.zaar.be/thefish/alchemyst-go/util"
@ -22,23 +27,6 @@ func init() {
runtime.LockOSThread()
}
type GameState struct {
mainfunc chan func()
exit chan struct{}
input chan string
rawInput chan int
}
// do runs f on the main thread.
func (*GameState) Do(f func()) {
done := make(chan struct{}, 1)
State.mainfunc <- func() {
f()
done <- struct{}{}
}
<-done
}
//we can run logic in separate goroutines
//
// go doSometing(State,...)
@ -47,17 +35,18 @@ func (*GameState) Do(f func()) {
// func doSomething(State main.GameState, args...) {
// ...
// State.Do(func() {
// ...do stuff in main thread, ie render something
// ...do stuff in main thread
// })
// ...
// }
// Use this trick CAREFULLY, cause closures may cause memleaks
var State = GameState{
mainfunc: make(chan func()),
exit: make(chan struct{}, 1),
input: make(chan string, 1),
rawInput: make(chan int, 1),
var State = gamestate.GameState{
Mainfunc: make(chan func()),
Exit: make(chan struct{}, 1),
Input: make(chan string, 1),
RawInput: make(chan int, 1),
FovRecompute: make(chan struct{}, 1),
Redraw: make(chan struct{}, 1),
}
func main() {
@ -79,29 +68,53 @@ func main() {
vp.Render()
go decodeInput(mainCtx, mw.GetLayer("base"))
go vp.Listen(State)
controller := ecs.NewController()
controller.MapComponentClass("coords", types.Coords{})
controller.MapComponentClass("appearance", types.Appearance{})
controller.MapComponentClass("mob", mob.Mob{})
player := controller.CreateEntity([]ecs.Component{})
controller.AddComponent(player, &types.Appearance{
Glyph: &types.PlainGlyphHolder{"@"},
ColorSet: &types.TileColorSet{
Fg: &types.PlainColorHolder{255, 255, 255, 255},
},
})
controller.AddComponent(player, rooms[0].Center) //implicit Coords
render := mob.MobRenderSystem{EntityController: controller}
controller.AddSystem(render, 1)
//but every call to bearlibterminal must be wrapped to closure and passed to mainfunc
var exit = false
for !exit {
select {
case State.rawInput <- ui.ReadKeyCode():
case State.RawInput <- ui.ReadKeyCode():
break
case pressed := <-State.input:
mw.GetLayer("base").ClearArea(0, 3, 40, 1)
mw.GetLayer("base").Print(1, 3, "Key: "+pressed)
mw.GetLayer("base").Print(1, 6, "█")
case pressed := <-State.Input:
screenMgr.CurrentScreen.HandleInput(pressed)
break
//case f := <-State.mainfunc:
// f()
// break
case <-State.exit:
//case f := <-State.mainfunc:
// f()
// break
case <-State.Exit:
mainCtx.Logger().Warn().Msg("quitting NOW")
exit = true
break
// не оставляйте default в бесконесчном select {} - сожрет всё CPU
// не оставляйте default в бесконесчном select {} - сожрет всё CPU
default:
vp.Render()
screenMgr.CurrentScreen.Render()
blt.Refresh()
}
@ -117,23 +130,21 @@ func setupLayers(mainwindow *mainwindow.MainWindow) {
func decodeInput(ctx util.ClientCtx, baseLayer *mainwindow.Layer) {
var exit = false
//for some reason blt's input queue gots spammed with 0xE0 on start.
//with this crutch we can wait out this WindowCloseEvent burst.
var waitForStartingWindowCloseBurst = true
for !exit{
var waitForWCspam = true
for !exit {
select {
case keycode := <-State.rawInput:
case keycode := <-State.RawInput:
if keycode == blt.TK_NONE {
continue
}
if keycode == blt.TK_CLOSE && !waitForStartingWindowCloseBurst {
if keycode == blt.TK_CLOSE && !waitForWCspam {
ctx.Logger().Warn().Msg("exiting on window close...")
State.exit <- struct{}{}
State.Exit <- struct{}{}
ctx.Logger().Warn().Msg("...done")
return
}
var pressed= ""
var isModifier, _= util.InArray(keycode, modifiers)
var pressed = ""
var isModifier, _ = util.InArray(keycode, modifiers)
if !isModifier {
pressed = ui.Scancodemap[keycode]
@ -150,6 +161,7 @@ func decodeInput(ctx util.ClientCtx, baseLayer *mainwindow.Layer) {
//global hotkeys
switch pressed {
//fixme testing only
case "F10":
State.Do(func() {
blt.Set("window: size=100x47; font: ./resources/fonts-ttf/UbuntuMono-R.ttf, size=11;")
@ -158,13 +170,15 @@ func decodeInput(ctx util.ClientCtx, baseLayer *mainwindow.Layer) {
fallthrough
case "Escape":
ctx.Logger().Info().Msg("exiting on quit command...")
State.exit <- struct{}{}
State.Exit <- struct{}{}
ctx.Logger().Info().Msg("...done")
exit = true
return
default:
waitForStartingWindowCloseBurst = false
State.input <- pressed
if pressed != "" {
waitForWCspam = false;
State.Input <- pressed
}
}
}
}

3
config.json
View File

@ -1,9 +1,10 @@
{
"version": "0.0.0.1",
"title" : "Test Go+BLT App",
"title" : "Alchemyst",
"sizeX": 100,
"sizeY": 47,
"fpsLimit" : 60,
"font": "./resources/fonts-ttf/LiberationMono-Bold.ttf",
"fontSize": "8x12",
"verbosity": "debug"
}

0
dist/.gitkeep vendored Normal file
View File

9
engine/ecs/component.go Normal file
View File

@ -0,0 +1,9 @@
package ecs
// ECS system by jcerise, github.com/jcerise/gogue
import "reflect"
type Component interface {
TypeOf() reflect.Type
}

247
engine/ecs/controller.go Normal file
View File

@ -0,0 +1,247 @@
package ecs
// ECS system by jcerise, github.com/jcerise/gogue
import (
"fmt"
"reflect"
"sort"
)
type Controller struct {
systems map[reflect.Type]System
sortedSystems map[int][]System
priorityKeys []int
nextEntityID int
components map[reflect.Type][]int
entities map[int]map[reflect.Type]Component
deadEntities []int
// The component map will keep track of what components are available
componentMap map[string]Component
}
// NewController is a convenience/constructor method to properly initialize a new processor
func NewController() *Controller {
controller := Controller{}
controller.systems = make(map[reflect.Type]System)
controller.sortedSystems = make(map[int][]System)
controller.priorityKeys = []int{}
controller.nextEntityID = 0
controller.components = make(map[reflect.Type][]int)
controller.entities = make(map[int]map[reflect.Type]Component)
controller.deadEntities = []int{}
controller.componentMap = make(map[string]Component)
return &controller
}
// Create a new entity in the world. An entity is simply a unique integer.
// If any components are provided, they will be associated with the created entity
func (c *Controller) CreateEntity(components []Component) int {
c.nextEntityID += 1
if len(components) > 0 {
for _, v := range components {
c.AddComponent(c.nextEntityID, v)
}
}
c.entities[c.nextEntityID] = make(map[reflect.Type]Component)
return c.nextEntityID
}
// DeleteEntity removes an entity, all component instances attached to that entity, and any components associations with
// that entity
func (c *Controller) DeleteEntity(entity int) {
// First, delete all the component associations for the entity to be removed
for k, _ := range c.entities[entity] {
c.RemoveComponent(entity, k)
}
// Then, delete the entity itself. The components have already been removed and disassociated with it, so a simple
// delete will do here
delete(c.entities, entity)
}
// MapComponent registers a component with the controller. This map of components gives the controller access to the
// valid components for a game system, and allows for dynamic loading of components from the data loader.
func (c *Controller) MapComponentClass(componentName string, component Component) {
// TODO: Possible to overwrite existing components with old name...
c.componentMap[componentName] = component
}
// GetMappedComponentClass returns a component class based on the name it was registered under. This allows for dyanamic
// mapping of components to entities, for example, from the data loader.
func (c *Controller) GetMappedComponentClass(componentName string) Component {
if _, ok := c.componentMap[componentName]; ok {
return c.componentMap[componentName]
} else {
// TODO: Add better (read: actual) error handling here
fmt.Printf("Component[%s] not registered on Controller.\n", componentName)
return nil
}
}
// AddComponent adds a component to an entity. The component is added to the global list of components for the
// processor, and also directly associated with the entity itself. This allows for flexible checking of components,
// as you can check which entites are associated with a component, and vice versa.
func (c *Controller) AddComponent(entity int, component Component) {
// First, get the type of the component
componentType := reflect.TypeOf(component)
// Record that the component type is associated with the entity.
c.components[componentType] = append(c.components[componentType], entity)
// Now, check to see if the entity is already tracked in the controller entity list. If it is not, add it, and
// associate the component with it
if _, ok := c.entities[entity]; !ok {
c.entities[entity] = make(map[reflect.Type]Component)
}
c.entities[entity][componentType] = component
}
// HasComponent checks a given entity to see if it has a given component associated with it
func (c *Controller) HasComponent(entity int, componentType reflect.Type) bool {
if _, ok := c.entities[entity][componentType]; ok {
return true
} else {
return false
}
}
// GetComponent returns the component instance for a component type, if one exists for the provided entity
func (c *Controller) GetComponent(entity int, componentType reflect.Type) Component {
// Check the given entity has the provided component
if c.HasComponent(entity, componentType) {
return c.entities[entity][componentType]
}
return nil
}
// GetEntity gets a specific entity, and all of its component instances
func (c *Controller) GetEntity(entity int) map[reflect.Type]Component {
for i, _ := range c.entities {
if i == entity {
return c.entities[entity]
}
}
return nil
}
// GetEntities returns a map of all entities and their component instances
func (c *Controller) GetEntities() map[int]map[reflect.Type]Component {
return c.entities
}
// GetEntitiesWithComponent returns a list of all entities with a given component attached
// TODO: Allow for passing a list of components
func (c *Controller) GetEntitiesWithComponent(componentType reflect.Type) []int {
entitiesWithComponent := make([]int, 0)
for entity := range c.entities {
if c.HasComponent(entity, componentType) {
entitiesWithComponent = append(entitiesWithComponent, entity)
}
}
return entitiesWithComponent
}
// UpdateComponent updates a component on an entity with a new version of the same component
func (c *Controller) UpdateComponent(entity int, componentType reflect.Type, newComponent Component) int {
// First, remove the component in question (Don't actually update things, but rather remove and replace)
c.RemoveComponent(entity, componentType)
// Next, replace the removed component with the updated one
c.AddComponent(entity, newComponent)
return entity
}
// DeleteComponent will delete a component instance from an entity, based on component type. It will also remove the
// association between the component and the entity, and remove the component from the processor completely if no
// other entities are using it.
func (c *Controller) RemoveComponent(entity int, componentType reflect.Type) int {
// Find the index of the entity to operate on in the components slice
index := -1
for i, v := range c.components[componentType] {
if (v == entity) {
index = i
}
}
// If the component was found on the entity, remove the association between the component and the entity
if index != -1 {
c.components[componentType] = append(c.components[componentType][:index], c.components[componentType][index+1:]...)
// If this was the last entity associated with the component, remove the component entry as well
if len(c.components[componentType]) == 0 {
delete(c.components, componentType)
}
}
// Now, remove the component instance from the entity
delete(c.entities[entity], componentType)
return entity
}
// AddSystem registers a system to the controller. A priority can be provided, and systems will be processed in
// numeric order, low to high. If multiple systems are registered as the same priority, they will be randomly run within
// that priority group.
func (c *Controller) AddSystem(system System, priority int) {
systemType := reflect.TypeOf(system)
if _, ok := c.systems[systemType]; !ok {
// A system of this type has not been added yet, so add it to the systems list
c.systems[systemType] = system
// Now, append the system to a special list that will be used for sorting by priority
if !IntInSlice(priority, c.priorityKeys) {
c.priorityKeys = append(c.priorityKeys, priority)
}
c.sortedSystems[priority] = append(c.sortedSystems[priority], system)
sort.Ints(c.priorityKeys)
} else {
fmt.Printf("A system of type %v was already added to the controller %v!", systemType, c)
}
}
// Process kicks off system processing for all systems attached to the controller. Systems will be processed in the
// order they are found, or if they have a priority, in priority order. If there is a mix of systems with priority and
// without, systems with priority will be processed first (in order).
func (c *Controller) Process(excludedSystems []reflect.Type) {
for _, key := range c.priorityKeys {
for _, system := range c.sortedSystems[key] {
systemType := reflect.TypeOf(system)
// Check if the current system type was marked as excluded on this call. If it was, not process it.
if !TypeInSlice(systemType, excludedSystems) {
system.Process()
}
}
}
}
// HasSystem checks the controller to see if it has a given system associated with it
func (c *Controller) HasSystem(systemType reflect.Type) bool {
if _, ok := c.systems[systemType]; ok {
return true
} else {
return false
}
}
// ProcessSystem allows for on demand processing of individual systems, rather than processing all at once via Process
func (c *Controller) ProcessSystem(systemType reflect.Type) {
if c.HasSystem(systemType) {
system := c.systems[systemType]
system.Process()
}
}

6
engine/ecs/entity.go
View File

@ -1,3 +1,9 @@
package ecs
// ECS system by jcerise, github.com/jcerise/gogue
type Entity int
func (e *Entity) HasComponent(c Component) bool {
return true
}

7
engine/ecs/system.go Normal file
View File

@ -0,0 +1,7 @@
package ecs
// ECS system by jcerise, github.com/jcerise/gogue
type System interface {
Process()
}

87
engine/ecs/systemMessages.go Normal file
View File

@ -0,0 +1,87 @@
package ecs
type SystemMessageType struct {
Name string
}
type SystemMessage struct {
MessageType SystemMessageType
Originator System
MessageContent map[string]string
}
// SystemMessageQueue is a super simple way of messaging between systems. Essentially, it is nothing more than a list of
// messages. Each message has a type, and an originator. Each system can "subscribe" to a type of message, which
// basically just means that it will check the queue for any messages of that type before it does anything else.
// Messages can contain a map of information, which each system that creates messages of that type, and those that
// subscribe to it should know how to handle any information contained in the message. Ideally, the message queue will
// be cleared out occasionally, either by the subscribing systems, or the game loop. Pretty simple for now, but should
// solve a subset of problems nicely.
type SystemMessageQueue struct {
Messages map[System][]SystemMessage
Subscriptions map[System][]SystemMessageType
}
func InitializeSystemMessageQueue() *SystemMessageQueue {
smq := SystemMessageQueue{}
smq.Messages = make(map[System][]SystemMessage)
smq.Subscriptions = make(map[System][]SystemMessageType)
return &smq
}
// BroadcastMessage appends a system message onto the games SystemMessageQueue, allowing it to consumed by a service
// subscribes to the MessageType.
func (smq *SystemMessageQueue) BroadcastMessage(messageType SystemMessageType, messageContent map[string]string, originator System) {
newMessage := SystemMessage{MessageType: messageType, MessageContent: messageContent, Originator: originator}
// Find all subscriptions to this message type, and add this message to the subscribers message queue
for subscribedSystem, typeList := range smq.Subscriptions {
if MessageTypeInSlice(messageType, typeList) {
smq.Messages[subscribedSystem] = append(smq.Messages[subscribedSystem], newMessage)
}
}
}
// GetSubscribedMessages returns a list of SystemMessages that have messageType. Can return an empty list
func (smq *SystemMessageQueue) GetSubscribedMessages(system System) []SystemMessage {
messages := []SystemMessage{}
for _, message := range smq.Messages[system] {
messages = append(messages, message)
}
return messages
}
// DeleteMessages deletes a processed message from the queue (for example, if the event has been processed)
func (smq *SystemMessageQueue) DeleteMessages(messageName string, system System) {
modifiedQueue := smq.Messages[system]
for index, message := range smq.Messages[system] {
if message.MessageType.Name == messageName {
modifiedQueue[index] = modifiedQueue[len(modifiedQueue)-1]
modifiedQueue = modifiedQueue[:len(modifiedQueue)-1]
}
}
smq.Messages[system] = modifiedQueue
}
//MessageTypeInSlice will return true if the MessageType provided is present in the slice provided, false otherwise
func MessageTypeInSlice(a SystemMessageType, list []SystemMessageType) bool {
for _, b := range list {
if b == a {
return true
}
}
return false
}
//MessageTypeInSliceOfMessages will return true if the MessageType provided is present in the slice provided, false otherwise
func MessageTypeInSliceOfMessages(a SystemMessageType, list []SystemMessage) bool {
for _, b := range list {
if b.MessageType == a {
return true
}
}
return false
}

25
engine/ecs/util.go Normal file
View File

@ -0,0 +1,25 @@
package ecs
// ECS system by jcerise, github.com/jcerise/gogue
import "reflect"
// IntInSlice will return true if the integer value provided is present in the slice provided, false otherwise.
func IntInSlice(a int, list []int) bool {
for _, b := range list {
if b == a {
return true
}
}
return false
}
// TypeInSlice will return true if the reflect.Type provided is present in the slice provided, false otherwise.
func TypeInSlice(a reflect.Type, list []reflect.Type) bool {
for _, b := range list {
if b == a {
return true
}
}
return false
}

9
engine/fov/precomputed_shade/precomputed_shade.go
View File

@ -195,7 +195,9 @@ func (ps *precomputedShade) PrecomputeFovMap() {
}
func (ps *precomputedShade) recalc(level *gamemap.Level, initCoords types.Coords, radius int) {
for i, _ := range ps.CellList {
ps.CellList[i].lit = 0
}
ps.originCoords = initCoords
if radius > ps.MaxTorchRadius {
@ -250,6 +252,7 @@ func (ps *precomputedShade) recalc(level *gamemap.Level, initCoords types.Coords
func (ps *precomputedShade) ComputeFov(level *gamemap.Level, initCoords types.Coords, radius int) {
level.SetAllInvisible()
ps.recalc(level, initCoords, radius)
for _, cell := range ps.CellList {
@ -260,6 +263,7 @@ func (ps *precomputedShade) ComputeFov(level *gamemap.Level, initCoords types.Co
continue
}
level.GetTile(cs).Visible = true
level.GetTile(cs).Explored = true
}
//light walls, crutch
@ -270,9 +274,10 @@ func (ps *precomputedShade) ComputeFov(level *gamemap.Level, initCoords types.Co
for _, maybeNb := range ps.CellList {
if //int(maybeNb.distance) == int(cell.distance-1) &&
maybeNb.IsAdjacentTo(&cell.Coords) &&
(maybeNb.X == cell.X || maybeNb.Y == cell.Y) &&
//(maybeNb.X == cell.X || maybeNb.Y == cell.Y) &&
maybeNb.lit > 0 { //magic constant!
level.GetTile(cs).Visible = true
level.GetTile(cs).Explored = true
}
}
}

2
engine/fov/precomputed_shade/precomputed_shade_test.go
View File

@ -67,7 +67,7 @@ func TestPrecompShade(t *testing.T) {
if playerCoords.X == x && playerCoords.Y == y {
return "@"
}
result := level.GetTileByXY(x, y).Char
result := level.GetTileByXY(x, y).Glyph.GetGlyph()
if !level.GetTileByXY(x, y).Visible {
result = "?"
}

11
engine/gamemap/level.go
View File

@ -8,7 +8,7 @@ import (
//fixme move to config
var mapWidth = 150
var mapHeight = 100
var mapHeight = 90
type Level struct {
@ -17,7 +17,7 @@ type Level struct {
Name string
Branch string
Depth int
Objects []ecs.Entity
Objects *[]ecs.Entity
Tiles []*Tile
}
@ -49,6 +49,7 @@ func (l *Level) Put (x, y int, tileFunc interface{}) {
func NewLevel(ctx util.ClientCtx, branch string, depth int) *Level {
l := &Level{
ctx: ctx,
Name: branch + string(depth),
Depth: depth,
Rect: types.NewRect(0,0, mapWidth, mapHeight),
@ -58,6 +59,12 @@ func NewLevel(ctx util.ClientCtx, branch string, depth int) *Level {
return l
}
func (l *Level) SetAllInvisible() {
for idx, _ := range l.Tiles {
l.Tiles[idx].Visible = false
}
}
type Room struct {
*types.Rect
Center types.Coords

74
engine/gamemap/mapgens/default.go
View File

@ -8,10 +8,10 @@ import (
//fixme move to config
var minRoomSize = 3
var maxRoomSize = 22
var maxrooms = 50
var maxrooms = 30
//fixme make closure to stack them
func DefaultGen(l *gamemap.Level) *gamemap.Level {
func DefaultGen(l *gamemap.Level) (*gamemap.Level, []*gamemap.Room) {
rng := util.NewRNG()
@ -56,53 +56,49 @@ func DefaultGen(l *gamemap.Level) *gamemap.Level {
if !failed {
rooms = append(rooms, newRoom)
}
//addStairs(rooms)
//itemize(rooms)
}
fges := map[int]types.RectFill{
1: types.RectFill{
Top: func() *gamemap.Tile { return gamemap.NewWall() },
Bottom: func() *gamemap.Tile { return gamemap.NewWall() },
Left: func() *gamemap.Tile { return gamemap.NewWall() },
Right: func() *gamemap.Tile { return gamemap.NewWall() },
BottomLeft: func() *gamemap.Tile { return gamemap.NewWall() },
BottomRight: func() *gamemap.Tile { return gamemap.NewWall() },
TopLeft: func() *gamemap.Tile { return gamemap.NewWall() },
TopRight: func() *gamemap.Tile { return gamemap.NewWall() },
Body: func() *gamemap.Tile { return gamemap.NewFloor() },
},
2: types.RectFill{
Top: func() *gamemap.Tile { return gamemap.NewWaterTile() },
Bottom: func() *gamemap.Tile { return gamemap.NewWaterTile() },
Left: func() *gamemap.Tile { return gamemap.NewWaterTile() },
Right: func() *gamemap.Tile { return gamemap.NewWaterTile() },
BottomLeft: func() *gamemap.Tile { return gamemap.NewWaterTile() },
BottomRight: func() *gamemap.Tile { return gamemap.NewWaterTile() },
TopLeft: func() *gamemap.Tile { return gamemap.NewWaterTile() },
TopRight: func() *gamemap.Tile { return gamemap.NewWaterTile() },
Body: func() *gamemap.Tile { return gamemap.NewDeepWaterTile() },
},
}
//fillage := types.RectFill{
// Top: func() *gamemap.Tile {return gamemap.NewWall()},
// Bottom: func() *gamemap.Tile {return gamemap.NewWall()},
// Left: func() *gamemap.Tile {return gamemap.NewWall()},
// Right: func() *gamemap.Tile {return gamemap.NewWall()},
// BottomLeft: func() *gamemap.Tile {return gamemap.NewWall()},
// BottomRight: func() *gamemap.Tile {return gamemap.NewWall()},
// TopLeft: func() *gamemap.Tile {return gamemap.NewWall()},
// TopRight: func() *gamemap.Tile {return gamemap.NewWall()},
// Body: func() *gamemap.Tile {return gamemap.NewFloor()},
//}
//fillage := types.RectFill{
// Top: func() *gamemap.Tile {return gamemap.NewWaterTile()},
// Bottom: func() *gamemap.Tile {return gamemap.NewWaterTile()},
// Left: func() *gamemap.Tile {return gamemap.NewWaterTile()},
// Right: func() *gamemap.Tile {return gamemap.NewWaterTile()},
// BottomLeft: func() *gamemap.Tile {return gamemap.NewWaterTile()},
// BottomRight: func() *gamemap.Tile {return gamemap.NewWaterTile()},
// TopLeft: func() *gamemap.Tile {return gamemap.NewWaterTile()},
// TopRight: func() *gamemap.Tile {return gamemap.NewWaterTile()},
// Body: func() *gamemap.Tile {return gamemap.NewDeepWaterTile()},
//}
fillage := types.RectFill{
Top: func() *gamemap.Tile {return gamemap.NewFloor()},
Bottom: func() *gamemap.Tile {return gamemap.NewFloor()},
Left: func() *gamemap.Tile {return gamemap.NewFloor()},
Right: func() *gamemap.Tile {return gamemap.NewFloor()},
BottomLeft: func() *gamemap.Tile {return gamemap.NewFloor()},
BottomRight: func() *gamemap.Tile {return gamemap.NewFloor()},
TopLeft: func() *gamemap.Tile {return gamemap.NewFloor()},
TopRight: func() *gamemap.Tile {return gamemap.NewFloor()},
Body: func() *gamemap.Tile {return gamemap.NewFloor()},
var fillage types.RectFill
for _, room := range rooms {
fillage = fges[rng.GetWeightedEntity(map[int]int{1:10, 2:1})]
room.Blit(fillage, l)
}
for idx, room := range rooms {
room.Blit(fillage, l)
if idx > 0 {
connectRooms(l, room, rooms[idx-1], fillage, rng.Range(0,1))
}
}
return l
return l, rooms
}
func connectRooms (l *gamemap.Level, room, otherRoom *gamemap.Room, fillage types.RectFill, toss int) {

133
engine/gamemap/tile.go
View File

@ -1,69 +1,8 @@
package gamemap
import (
"github.com/gammazero/deque"
"lab.zaar.be/thefish/alchemyst-go/util"
. "lab.zaar.be/thefish/alchemyst-go/engine/types"
)
import blt "lab.zaar.be/thefish/bearlibterminal"
type ColorHolder interface {
GetColor() uint32
}
type cdeque struct {
deque.Deque
}
func (c *cdeque) Next() uint8 {
c.Rotate(1)
return c.Front().(uint8)
}
type DanceColorHolder struct {
A uint8
R *cdeque
G *cdeque
B *cdeque
}
func (chd *DanceColorHolder) GetColor() uint32 {
return blt.ColorFromARGB(
chd.A,
chd.R.Next(),
chd.G.Next(),
chd.B.Next(),
)
}
type PlainColorHolder struct {
A uint8
R uint8
G uint8
B uint8
}
func (chb *PlainColorHolder) GetColor() uint32 {
return blt.ColorFromARGB(
chb.A,
chb.R,
chb.G,
chb.B,
)
}
type TileColorSet struct {
Fg ColorHolder
Bg ColorHolder
DarkFg ColorHolder
DarkBg ColorHolder
}
type Appearance struct {
Char string `json:"char"`
ColorSet *TileColorSet `json:"colorSet"`
}
var crng = util.NewRNG()
type Tile struct {
*Appearance `json:"app"`
@ -78,12 +17,11 @@ type Tile struct {
}
func (t *Tile) GetChar() string {
return t.Char
return t.Glyph.GetGlyph()
}
func (t *Tile) GetRawColor() uint32 {
//if !t.Visible {
if !t.Visible {
if t.Visible {
return t.Appearance.ColorSet.Fg.GetColor()
} else {
return t.Appearance.ColorSet.DarkFg.GetColor()
@ -91,7 +29,6 @@ func (t *Tile) GetRawColor() uint32 {
}
func (t *Tile) GetRawBgColor() uint32 {
//if !t.Visible {
if t.Visible {
return t.Appearance.ColorSet.Bg.GetColor()
} else {
@ -99,38 +36,6 @@ func (t *Tile) GetRawBgColor() uint32 {
}
}
func singleColorRing(colorValue uint8) *cdeque {
c := &cdeque{}
c.PushBack(colorValue)
return c
}
func fillColorRing(colorValue uint8, minGlow, maxGlow, step int) *cdeque {
q := make([]uint8, 0)
color := int(colorValue)
for color < maxGlow {
q = append(q, uint8(color))
color = crng.Range(1, step) + color
}
color = crng.Range(0, step+minGlow)
q = append(q, uint8(color))
//for uint8(color) < uint8(colorValue) {
// q = append(q, uint8(color))
// color = crng.Range(1, step+minGlow)
//}
c := &cdeque{}
toss := crng.Range(0, 1) //Хаха
for _, v := range q {
if toss == 1 {
c.PushBack(uint8(v))
} else {
c.PushFront(uint8(v))
}
}
return c
}
func NewWall() *Tile {
return &Tile{
Name: "Wall",
@ -140,7 +45,7 @@ func NewWall() *Tile {
Explored: false,
MustDraw: false,
Appearance: &Appearance{
Char: "#",
Glyph: &PlainGlyphHolder{"#"},
ColorSet: &TileColorSet{
Fg: &PlainColorHolder{255, 130, 110, 150},
Bg: &PlainColorHolder{255, 172, 170, 173},
@ -160,7 +65,7 @@ func NewFloor() *Tile {
Explored: false,
MustDraw: false,
Appearance: &Appearance{
Char: ".",
Glyph: &PlainGlyphHolder{"."},
ColorSet: &TileColorSet{
Fg: &PlainColorHolder{255, 220, 220, 250},
Bg: &PlainColorHolder{255, 19, 19, 70},
@ -183,17 +88,17 @@ func NewWaterTile() *Tile {
Colordance: true,
Appearance: &Appearance{
Char: " ",
Glyph: &PlainGlyphHolder{" "},
ColorSet: &TileColorSet{
Fg: &PlainColorHolder{255, 220, 220, 250},
Fg: &PlainColorHolder{255, 220, 220, 250},
Bg: &DanceColorHolder{
255,
singleColorRing(19),
fillColorRing(22, 2, 42, 4),
fillColorRing(204, 180, 229, 12),
SingleColorRing(19),
FillColorRing(19, 0, 15, 2),
FillColorRing(127, 120, 176, 12),
},
DarkFg: &PlainColorHolder{255, 30, 20, 50 },
DarkBg: &PlainColorHolder{255, 7, 7, 80},
DarkFg: &PlainColorHolder{255, 30, 20, 50},
DarkBg: &PlainColorHolder{255, 7, 7, 30},
},
},
}
@ -210,18 +115,18 @@ func NewDeepWaterTile() *Tile {
MustDraw: true, //fixme debug
Colordance: true,
Appearance: &Appearance{
Char: " ",
Glyph: &PlainGlyphHolder{" "},
ColorSet: &TileColorSet{
Fg: &PlainColorHolder{255, 220, 220, 250},
Fg: &PlainColorHolder{255, 220, 220, 250},
Bg: &DanceColorHolder{
255,
singleColorRing(5),
fillColorRing(2,0,15,2),
fillColorRing(154, 120, 180, 5),
SingleColorRing(5),
FillColorRing(2, 2, 42, 4),
FillColorRing(154, 150, 229, 12),
},
DarkFg: &PlainColorHolder{255, 30, 20, 50},
DarkBg: &PlainColorHolder{255, 7, 7, 80},
DarkBg: &PlainColorHolder{255, 7, 7, 30},
},
},
}
}
}

28
engine/gamestate/gamestate.go Normal file
View File

@ -0,0 +1,28 @@
package gamestate
import (
"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
"lab.zaar.be/thefish/alchemyst-go/engine/mob"
)
type GameState struct {
Mainfunc chan func()
Exit chan struct{}
Input chan string
RawInput chan int
FovRecompute chan struct{}
Redraw chan struct{}
Level *gamemap.Level
Player *mob.Player
}
// do runs f on the main thread.
func (g *GameState) Do(f func()) {
done := make(chan struct{}, 1)
g.Mainfunc <- func() {
f()
f = nil //zero pointer for closure function
done <- struct{}{}
}
<-done
}

20
engine/mob/mob.go
View File

@ -1,19 +1,27 @@
package mob
import (
"fmt"
"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
"lab.zaar.be/thefish/alchemyst-go/engine/types"
"reflect"
)
type Mob struct {
*gamemap.Appearance
*types.Coords
*types.Appearance
types.Coords
BlocksPass bool
}
func (m *Mob) Walk(level *gamemap.Level, dx, dy int) {
newCoords := types.Coords{m.X + dx, m.Y + dy}
if level.GetTile(newCoords).BlocksPass {
return
}
if level.Objects.At(newCoords).HasComponent("block_pass") {
func (m *Mob) Walk(dx, dy int) {
}
fmt.Printf("new coords: %d, %d\n", m.Coords.X, m.Coords.Y)
}
func (m *Mob) Render() {
@ -22,4 +30,8 @@ func (m *Mob) Render() {
func (m *Mob) MoveToCoords(c types.Coords) {
}
func (mob Mob) TypeOf() reflect.Type {
return reflect.TypeOf(mob)
}

29
engine/mob/mob_render_system.go Normal file
View File

@ -0,0 +1,29 @@
package mob
import (
"lab.zaar.be/thefish/alchemyst-go/engine/ecs"
"lab.zaar.be/thefish/alchemyst-go/engine/types"
)
type MobRenderSystem struct {
EntityController *ecs.Controller
}
func (mrs MobRenderSystem) Process(){
for e := range mrs.EntityController.GetEntities() {
if mrs.EntityController.HasComponent(e, types.Coords{}.TypeOf()) &&
mrs.EntityController.HasComponent(e, types.Appearance{}.TypeOf()) {
pos := mrs.EntityController.GetComponent(e, types.Coords{}.TypeOf()).(types.Coords)
appearance := mrs.EntityController.GetComponent(e, types.Appearance{}.TypeOf()).(types.Appearance)
// Clear the cell this entity occupies, so it is the only glyph drawn there
for i := 0; i <= 2; i++ {
//fixme
gogue.ClearArea(pos.X, pos.Y, 1, 1, i)
}
//fixme
gogue.PrintGlyph(pos.X, pos.Y, appearance.Glyph, "", appearance.Layer)
}
}
}

2
engine/mob/player.go
View File

@ -1,5 +1,5 @@
package mob
type Player struct {
*Mob
Mob
}

11
engine/screens/character.go Normal file
View File

@ -0,0 +1,11 @@
package screens
type CharacterScreen struct {
}
func (ts *CharacterScreen) UseEcs() bool {return false}
func (ts *CharacterScreen) Enter() {}
func (ts *CharacterScreen) HandleInput(input string) {}
func (ts *CharacterScreen) Exit() {}
func (ts *CharacterScreen) Render() {}

58
engine/screens/game.go Normal file
View File

@ -0,0 +1,58 @@
package screens
import (
"lab.zaar.be/thefish/alchemyst-go/engine/gamestate"
"lab.zaar.be/thefish/alchemyst-go/ui/mainwindow"
)
type GameScreen struct {
mw *mainwindow.MainWindow
state *gamestate.GameState
vp *mainwindow.ViewPort
}
func NewGameScreen(mw *mainwindow.MainWindow, state *gamestate.GameState, viewPort *mainwindow.ViewPort) *GameScreen {
return &GameScreen{mw: mw, state: state, vp: viewPort}
}
func (ts *GameScreen) UseEcs() bool { return true }
func (ts *GameScreen) Enter() {}
func (ts *GameScreen) HandleInput(input string) {
//ts.state.Do(func(){
switch input {
case "Up", "k", "8":
ts.state.Player.Walk(ts.state.Level, 0, -1)
break
case "Down", "j", "2":
ts.state.Player.Walk(ts.state.Level,0, 1)
break
case "Left", "h", "4":
ts.state.Player.Walk(ts.state.Level,-1, 0)
break
case "Right", "l", "6":
ts.state.Player.Walk(ts.state.Level,1, 0)
break
case "y", "7":
ts.state.Player.Walk(ts.state.Level,-1, -1)
break
case "u", "9":
ts.state.Player.Walk(ts.state.Level,1, -1)
break
case "b", "1":
ts.state.Player.Walk(ts.state.Level,-1, 1)
break
case "n", "3":
ts.state.Player.Walk(ts.state.Level,1, 1)
break
default:
ts.mw.GetLayer("base").ClearArea(0, 3, 40, 1)
ts.mw.GetLayer("base").Print(1, 3, "Key: "+input)
ts.mw.GetLayer("base").Print(1, 6, "█")
}
//})
}
func (ts *GameScreen) Exit() {}
func (ts *GameScreen) Render() {
ts.vp.Render(ts.state)
}

11
engine/screens/inventory.go Normal file
View File

@ -0,0 +1,11 @@
package screens
type InventoryScreen struct {
}
func (ts *InventoryScreen) UseEcs() bool {return true}
func (ts *InventoryScreen) Enter() {}
func (ts *InventoryScreen) HandleInput(input string) {}
func (ts *InventoryScreen) Exit() {}
func (ts *InventoryScreen) Render() {}

11
engine/screens/target.go Normal file
View File

@ -0,0 +1,11 @@
package screens
type TargetScreen struct {
}
func (ts *TargetScreen) UseEcs() bool {return true}
func (ts *TargetScreen) Enter() {}
func (ts *TargetScreen) HandleInput(input string) {}
func (ts *TargetScreen) Exit() {}
func (ts *TargetScreen) Render() {}

11
engine/screens/title.go Normal file
View File

@ -0,0 +1,11 @@
package screens
type TitleScreen struct {
}
func (ts *TitleScreen) UseEcs() bool {return false}
func (ts *TitleScreen) Enter() {}
func (ts *TitleScreen) HandleInput(input string) {}
func (ts *TitleScreen) Exit() {}
func (ts *TitleScreen) Render() {}

111
engine/types/appearance.go Normal file
View File

@ -0,0 +1,111 @@
package types
import (
"github.com/gammazero/deque"
"lab.zaar.be/thefish/alchemyst-go/util"
"reflect"
)
import blt "lab.zaar.be/thefish/bearlibterminal"
var crng = util.NewRNG()
type ColorHolder interface {
GetColor() uint32
}
type cdeque struct {
deque.Deque
}
func (c *cdeque) Next() uint8 {
c.Rotate(1)
return c.Front().(uint8)
}
type DanceColorHolder struct {
A uint8
R *cdeque
G *cdeque
B *cdeque
}
func (chd *DanceColorHolder) GetColor() uint32 {
return blt.ColorFromARGB(
chd.A,
chd.R.Next(),
chd.G.Next(),
chd.B.Next(),
)
}
type PlainColorHolder struct {
A uint8
R uint8
G uint8
B uint8
}
func (chb *PlainColorHolder) GetColor() uint32 {
return blt.ColorFromARGB(
chb.A,
chb.R,
chb.G,
chb.B,
)
}
type TileColorSet struct {
Fg ColorHolder
Bg ColorHolder
DarkFg ColorHolder
DarkBg ColorHolder
}
type GlyphHolder interface {
GetGlyph() string
}
type PlainGlyphHolder struct {
Glyph string
}
func (pch *PlainGlyphHolder) GetGlyph() string {
return pch.Glyph
}
type Appearance struct {
Glyph GlyphHolder `json:"char"`
ColorSet *TileColorSet `json:"colorSet"`
}
func SingleColorRing(colorValue uint8) *cdeque {
c := &cdeque{}
c.PushBack(colorValue)
return c
}
func FillColorRing(colorValue uint8, minGlow, maxGlow, step int) *cdeque {
q := make([]uint8, 0)
color := int(colorValue)
for color < maxGlow {
q = append(q, uint8(color))
color = crng.Range(1, step) + color
}
color = crng.Range(0, step+minGlow)
q = append(q, colorValue)
//for uint8(color) < uint8(colorValue) {
// q = append(q, uint8(color))
// color = crng.Range(1, step+minGlow)
//}
c := &cdeque{}
for _, v := range q {
c.PushBack(uint8(v))
}
return c
}
func (app Appearance) TypeOf() reflect.Type {
return reflect.TypeOf(app)
}

9
engine/types/coords.go
View File

@ -1,11 +1,18 @@
package types
import "math"
import (
"math"
"reflect"
)
type Coords struct {
X, Y int
}
func (сс Coords) TypeOf() reflect.Type {
return reflect.TypeOf(сс)
}
func (c *Coords) Get() (int, int) {
return c.X, c.Y
}

88
engine/types/screen.go Normal file
View File

@ -0,0 +1,88 @@
package types
import (
"lab.zaar.be/thefish/alchemyst-go/util"
)
type Screen interface {
Enter()
Exit()
Render()
HandleInput(input string)
UseEcs() bool
}
type ScreenManager struct {
ctx util.ClientCtx
Screens map[string]Screen
CurrentScreen Screen
PreviousScreen Screen
}
// NewScreenManager is a convenience/constructor method to properly initialize a new ScreenManager
func NewScreenManager(ctx util.ClientCtx) *ScreenManager {
manager := ScreenManager{
ctx:ctx,
Screens: make(map[string]Screen),
CurrentScreen: nil,
}
return &manager
}
func (sm *ScreenManager) AddScreen(screenName string, screen Screen) {
// Check to see if a screen with the given screenName has already been added
if _, ok := sm.Screens[screenName]; !ok {
// A screen with the given name does not yet exist on the ScreenManager, go ahead and add it
sm.Screens[screenName] = screen
} else {
sm.ctx.Logger().Warn().Msgf("A screen with name %v was already added to the ScreenManager %v!", screenName, sm)
}
}
// RemoveScreen will remove a screen from the ScreenManager. This can be useful when a temporary screen needs to be
// created, as it can be quickly added (rather than registering at game creation), and then removed when it is no
// longer needed
func (sm *ScreenManager) RemoveScreen(screenName string, screen Screen) {
// Check if the given screenName exists in the ScreenManager
if _, ok := sm.Screens[screenName]; ok {
delete(sm.Screens, screenName)
} else {
// A screen with the given name does not exist
sm.ctx.Logger().Warn().Msgf("A screen with name %v was not found on ScreenManager %v!", screenName, sm)
}
}
// SetScreen will set the current screen property of the screen manager to the provided screen
func (sm *ScreenManager) SetScreen(screen Screen) {
// Call the exit function of the currentScreen, and set the currentScreen as the previousScreen
// Only do this if there is a currentScreen
if sm.CurrentScreen != nil {
sm.CurrentScreen.Exit()
sm.PreviousScreen = sm.CurrentScreen
}
// Set the provided screen as the currentScreen, and call the enter() function of the new currentScreen
sm.CurrentScreen = screen
sm.CurrentScreen.Enter()
}
// SetScreenByName takes a string representing the screen desired to navigate to. It will then transition the
// ScreenManager to the specified screen, if one is found.
func (sm *ScreenManager) SetScreenByName(screenName string) {
// Check if the given screenName exists in the ScreenManager
if _, ok := sm.Screens[screenName]; ok {
// Call the exit function of the currentScreen, and set the currentScreen as the previousScreen
// Only do this if there is a currentScreen
if sm.CurrentScreen != nil {
sm.CurrentScreen.Exit()
sm.PreviousScreen = sm.CurrentScreen
}
// Set the provided screen as the currentScreen, and call the enter() function of the new currentScreen
sm.CurrentScreen = sm.Screens[screenName]
sm.CurrentScreen.Enter()
} else {
// A screen with the given name does not exist
sm.ctx.Logger().Warn().Msgf("A screen with name %v was not found on ScreenManager %v!", screenName, sm)
}
}

2
link.sh
View File

@ -1,2 +1,2 @@
#!/bin/bash
ln -s src/bearlibterminal/libBearLibTerminal.so .
ln -s vendor/lab.zaar.be/thefish/bearlibterminal/libBearLibTerminal.so .

2
ui/mainwindow/layer.go
View File

@ -98,7 +98,7 @@ func (layer *Layer) Decorate(f func(args ...interface{})) func(args ...interface
}
}
func (layer *Layer) Clear(r *types.Rect) {
func (layer *Layer) ClearRect(r *types.Rect) {
blt.ClearArea(r.X, r.Y, r.W, r.H)
}

3
ui/mainwindow/mainwindow.go
View File

@ -42,13 +42,14 @@ func (mw *MainWindow) Open() {
blt.Set(
fmt.Sprintf(
//"window: size=%dx%d, title='%s v%s'; font: ./resources/fonts-bitmap/ibmnew8x12.png, size=8x12;",
"window: size=%dx%d, title='%s v%s'; font: %s, size=8x16;",
"window: size=%dx%d, title='%s v%s'; font: %s, size=%s;",
//"window: size=%dx%d, title='%s v%s'",
config.MainWindowSizeX,
config.MainWindowSizeY,
config.Title,
config.Version,
config.Font,
config.FontSize,
),
)
}

224
ui/mainwindow/viewport.go
View File

@ -2,43 +2,51 @@ package mainwindow
import (
"errors"
"fmt"
"lab.zaar.be/thefish/alchemyst-go/engine/fov"
"lab.zaar.be/thefish/alchemyst-go/engine/fov/precomputed_shade"
"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
"lab.zaar.be/thefish/alchemyst-go/engine/gamestate"
"lab.zaar.be/thefish/alchemyst-go/engine/types"
"time"
)
var NotInViewError = errors.New("not in ViewPort")
const FPS_LIMIT = 60
type ViewPort struct {
*types.Rect
level *gamemap.Level
cameraCoords types.Coords
layer *Layer
Fov fov.Fov
playerCoords types.Coords
playerTorchRadius int
PlayerCoords types.Coords
PlayerTorchRadius int
animateTiles *time.Ticker
}
func NewViewPort(x, y, w, h int, level *gamemap.Level, layer *Layer) *ViewPort {
//fixme
fov := precomputed_shade.NewPrecomputedShade(15)
fov.Init()
func NewViewPort(x, y, w, h int, layer *Layer) *ViewPort {
computedFov := precomputed_shade.NewPrecomputedShade(15)
computedFov.Init()
vp := ViewPort{
Rect: &types.Rect{x, y, w, h},
level: level,
layer: layer,
Fov: fov,
Fov: computedFov,
}
vp.playerCoords = types.Coords{10, 10}
vp.playerTorchRadius = 10
vp.PlayerTorchRadius = 11
vp.animateTiles = time.NewTicker(time.Second / 12)
return &vp
}
func (vp *ViewPort) Move(c *types.Coords) {
func (vp *ViewPort) Close() {
vp.animateTiles.Stop()
vp.animateTiles = nil //free pointer to ticker
}
func (vp *ViewPort) Move(state *gamestate.GameState) {
c := &state.Player.Coords
x := c.X - vp.Rect.W/2
y := c.Y - vp.Rect.H/2
@ -48,138 +56,84 @@ func (vp *ViewPort) Move(c *types.Coords) {
if y < 0 {
y = 0
}
if x > vp.level.W-vp.W {
x = vp.level.W - vp.W
if x > state.Level.W - vp.W - 1 {
x = state.Level.W - vp.W
}
if y > vp.level.H-vp.H {
x = vp.level.H - vp.H
if y > state.Level.H-vp.H - 1 {
y = state.Level.H - vp.H
}
//if x != vp.X || y != vp.Y { State.FovRecompute <- struct{}{}}
vp.X, vp.Y = x, y
if x != vp.cameraCoords.X || y != vp.cameraCoords.Y {
state.FovRecompute <- struct{}{}
}
vp.cameraCoords.X = x
vp.cameraCoords.Y = y
}
func (vp *ViewPort) ToVPCoords(c *types.Coords) (newCoords *types.Coords, err error) {
func (vp *ViewPort) ToVPCoords(c types.Coords) (newCoords types.Coords, err error) {
//coords on map to coords on vp
x, y := c.X-vp.X, c.Y-vp.Y
if x < 0 || y < 0 || x >= vp.W || y >= vp.H {
return &types.Coords{-1, -1}, NotInViewError
x, y := c.X-vp.cameraCoords.X, c.Y-vp.cameraCoords.Y
if x < 0 || y < 0 || x > vp.W || y > vp.H {
return types.Coords{-1, -1}, NotInViewError
}
return &types.Coords{x, y}, nil
return types.Coords{x, y}, nil
}
////call only from main thread
//func (vp *ViewPort) Render() {
// //fixme get these from state chan(s)
// var fpsTicker int
// var fovRecompute bool = true
// redraw := false
// //fixme get player instance
//
// vp.Move(&vp.playerCoords)
// //fixme detect fovRecompute
// if fovRecompute {
// vp.layer.Clear(vp.Rect)
// fovRecompute = false
// redraw = true
// //fixme
//
// vp.Fov.ComputeFov(vp.level, vp.playerCoords, vp.playerTorchRadius)
// }
// //increase ticker
// fpsTicker++
//
// if redraw || fpsTicker%(FPS_LIMIT/10) == 0 {
// fpsTicker = 0
//
// for y := 0; y < vp.H; y++ {
// for x := 0; x < vp.W; x++ {
// mapCoords := types.Coords{vp.X + x, vp.Y + y}
// tile := vp.level.Tiles[mapCoords.X][mapCoords.Y]
// visible := vp.Fov.IsInFov(mapCoords)
// if !visible {
// if tile.MustDraw {
// //darkened version of landscape
// vp.layer.WithRawColor(tile.ColorSet.DarkFg()).
// PutWithRawBackground(mapCoords.X, mapCoords.Y, tile.Char, tile.ColorSet.DarkBg())
// }
// } else {
// if redraw == true || tile.Colordance {
// vp.layer.WithRawColor(tile.ColorSet.Fg()).
// PutWithRawBackground(mapCoords.X, mapCoords.Y, tile.Char, tile.ColorSet.Bg())
// tile.Explored = true
// tile.MustDraw = true
// }
// }
// }
// }
//
// }
//}
var redraw = true
var fovRecompute = true
func (vp *ViewPort) Render() {
if fovRecompute {
vp.layer.Clear(vp.Rect)
fovRecompute = false
redraw = true
//fixme
vp.Fov.ComputeFov(vp.level, vp.playerCoords, vp.playerTorchRadius)
}
//for y := 0; y < vp.H; y++ {
// for x := 0; x < vp.W; x++ {
// mapCoords := types.Coords{vp.X + x, vp.Y + y}
// tile := vp.level.Tiles[mapCoords.X][mapCoords.Y]
//
// if tile.Visible {
// if tile.MustDraw {
// //darkened version of landscape
// vp.layer.WithRawColor(tile.ColorSet.DarkFg()).
// PutWithRawBackground(mapCoords.X, mapCoords.Y, tile.Char, tile.ColorSet.DarkBg())
// }
// } else {
// if redraw == true || tile.Colordance {
// vp.layer.WithRawColor(tile.ColorSet.Fg()).
// PutWithRawBackground(mapCoords.X, mapCoords.Y, tile.Char, tile.ColorSet.Bg())
// tile.Explored = true
// tile.MustDraw = true
// }
// }
// }
//}
for y := 0; y < vp.H; y++ {
for x := 0; x < vp.W; x++ {
mapCoords := types.Coords{vp.X + x, vp.Y + y}
//vp.level.GetTile(mapCoords).Render()
tile := vp.level.GetTile(mapCoords)
//vp.layer.
// WithRawColor(tile.GetRawColor()).
// PutWithBackground(mapCoords.X, mapCoords.Y, tile.GetChar(), "grey")
vp.layer.PutToBase(mapCoords.X,mapCoords.Y,tile.GetChar(), tile.GetRawColor(), tile.GetRawBgColor())
//if tile.Visible {
// if tile.MustDraw {
// //darkened version of landscape
// vp.layer.WithColor("green").
// Put(mapCoords.X, mapCoords.Y, tile.Char)
// }
//} else {
// if redraw == true || tile.Colordance {
// vp.layer.WithColor("grey").
// Put(mapCoords.X, mapCoords.Y, tile.Char)
// tile.Explored = true
// tile.MustDraw = true
// }
//}
func (vp *ViewPort) Listen(state gamestate.GameState) {
for {
select {
case <-state.FovRecompute:
fovRecompute = true
case <-state.Redraw:
redraw = true
case <-vp.animateTiles.C:
redraw = true
}
}
}
func (vp *ViewPort) Render(state *gamestate.GameState) {
vp.Move(state)
if fovRecompute {
vp.layer.ClearRect(vp.Rect)
fovRecompute = true
redraw = true
vp.Fov.ComputeFov(state.Level, state.Player.Coords, vp.PlayerTorchRadius)
}
//if redraw {
//terrain
for y := 0; y < vp.H; y++ {
for x := 0; x < vp.W; x++ {
mapCoords := types.Coords{vp.cameraCoords.X + x, vp.cameraCoords.Y + y}
if state.Level.InBounds(mapCoords) {
tile := state.Level.GetTile(mapCoords)
if tile.Explored || tile.Visible {
vp.layer.PutToBase(x+vp.X, y+vp.Y, tile.GetChar(), tile.GetRawColor(), tile.GetRawBgColor())
}
}
}
}
//mobs
pc, err := vp.ToVPCoords(state.Player.Coords)
_ = pc
if err != nil {
fmt.Println("error on getting player position")
} else {
vp.layer.WithColor("white").Put(pc.X+vp.X, pc.Y+vp.Y, "@")
//mw.GetLayer("base").WithColor("white").Put(42, 10, "B")
//mw.GetLayer("overlay").WithColor("white").Put(59, 10, "O")
}
//redraw = true
//redraw = false
//}
}

1
util/config.go
View File

@ -14,6 +14,7 @@ type Config struct {
MainWindowSizeX int `json:"sizeX"`
MainWindowSizeY int `json:"sizeY"`
Font string `json:"font"`
FontSize string `json:"fontSize"` //format is "8x12"
Verbosity string `json:"verbosity"`
}