From 679aaeebaa04f2ff78ee41ee9f8552f2014dc61f Mon Sep 17 00:00:00 2001
From: tkarrass <tkarrass@bitsetter.de>
Date: Mon, 8 Feb 2016 15:29:43 +0100
Subject: [PATCH] =?UTF-8?q?push=20f=C3=BCr=20lennart=20:p?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 cmd/server.go                  | 27 ++++++++++++----------
 data/level.go                  | 42 +++++++++++++++++++++++++++++++---
 levels/locoworld/Manifest.json |  2 +-
 3 files changed, 55 insertions(+), 16 deletions(-)

diff --git a/cmd/server.go b/cmd/server.go
index 5cdc94e..d53e5ec 100644
--- a/cmd/server.go
+++ b/cmd/server.go
@@ -23,6 +23,8 @@ gosl.json for configuration (Port/Address, Level)
 	//	Run:
 }
 
+const ClientOffset = 10
+
 type goslClient struct {
 	con *net.TCPConn
 	id  int
@@ -36,11 +38,11 @@ var (
 	LevelFile  string
 	level      *data.Level
 	ServerPort int
-	TotalWidth int                = 0
-	clients    map[int]goslClient = make(map[int]goslClient)
-	clientKeys []int              = make([]int, 0)
+	TotalWidth int                 = 0
+	clients    map[int]*goslClient = make(map[int]*goslClient)
+	clientKeys []int               = make([]int, 0)
 	// big server canvas
-	canvas       [][]rune
+	//canvas       [][]rune
 	canvasX      int
 	frameCounter int = 0
 )
@@ -54,7 +56,7 @@ func handleConn(conn *net.TCPConn) {
 	// memorize client in server state
 	clientKeys = append(clientKeys, hs.ID)
 	sort.Ints(clientKeys)
-	clients[hs.ID] = goslClient{con: conn, id: hs.ID, w: hs.W, h: hs.H}
+	clients[hs.ID] = &goslClient{con: conn, id: hs.ID, w: hs.W, h: hs.H}
 	TotalWidth += hs.W
 	// reset server
 	resetServer()
@@ -62,19 +64,18 @@ func handleConn(conn *net.TCPConn) {
 
 func resetServer() {
 	// adjust canvas width
-	canvasX = 0
+	canvasX = -1 * ClientOffset
 	for _, k := range clientKeys {
 		_, client := k, clients[k]
-		canvasX += client.w
+		canvasX += client.w + ClientOffset
 	}
 	canvasX += level.Width()
 	// adjust client offsets
 	off := 0
 	for _, k := range clientKeys {
-		_, client := k, clients[k]
-		client.off = off
-		off += client.w
-		off += 10
+		clients[k].off = off
+		off += clients[k].w
+		off += ClientOffset
 	}
 }
 
@@ -86,7 +87,7 @@ func serveClients() {
 			for _, k := range clientKeys {
 				id, client := k, clients[k]
 				if id > 0 {
-					oFrame := level.GetFrame(client.off, client.w, frameCounter)
+					oFrame := level.GetFrame(client.off, client.w, canvasX, frameCounter)
 					enc := gob.NewEncoder(client.con)
 					err := enc.Encode(oFrame)
 					if err != nil {
@@ -100,8 +101,10 @@ func serveClients() {
 						idInKeys := sort.SearchInts(clientKeys, client.id)
 						clientKeys = append(clientKeys[:idInKeys], clientKeys[idInKeys+1:]...)
 						//log.Println("AFTER remove: clients:", clients, " clientKeys:", clientKeys)
+						resetServer()
 					}
 					//log.Println("ID:", id, "Client:", client)
+
 				}
 			}
 			frameCounter++
diff --git a/data/level.go b/data/level.go
index dc64a68..6da17d4 100644
--- a/data/level.go
+++ b/data/level.go
@@ -17,7 +17,7 @@ const (
 	DIR_W                         //  W  4 5 6  E
 	DIR_NONE                      //     1 2 3
 	DIR_E                         //  SW   S   SE
-	DIR_NW
+	DIR_NW                        //  only 4,5,6 supported
 	DIR_N
 	DIR_NE
 )
@@ -74,7 +74,19 @@ func (lvl *Level) Height() int {
 	return max
 }
 
-// this is a func also ;)
+func (l *Layer) Width() (max int) {
+	max = 0
+	for _, frame := range l.Frames {
+		for _, row := range frame {
+			if len(row) > max {
+				max = len(row)
+			}
+		}
+	}
+	return
+}
+
+// Funzt so nicht: Layer liegen nicht zwingend übereinander
 func (lvl *Level) Width() (max int) {
 	for _, lay := range lvl.Layers {
 		for _, fra := range lay.Frames {
@@ -89,15 +101,18 @@ func (lvl *Level) Width() (max int) {
 }
 
 //testcomment
-func (lvl *Level) GetFrame(off, w, frameNo int) (ret *Frame) {
+func (lvl *Level) GetFrame(o, w, maxW, frameNo int) (ret *Frame) {
 	h := lvl.Height()
 
 	ret = &Frame{
 		W: w,
 		H: h,
 	}
+
+	// generate an array by initializing a slice and …
 	var mdata = make([]rune, w*h)
 	for y := 0; y < h; y++ {
+		// … let the resulting Frame data point into it:
 		ret.Data = append(ret.Data, mdata[y*w:(y+1)*w])
 	}
 
@@ -105,8 +120,29 @@ func (lvl *Level) GetFrame(off, w, frameNo int) (ret *Frame) {
 		if layer.Z == 0 {
 			for row := 0; row < h; row++ {
 				//ret.Data = append(ret.Data, []rune{})
+
+				// which frame of the layer to use
 				f := (frameNo % len(layer.Frames)) + 1
+				off := 0
+				switch layer.D {
+				case 4:
+					off = -(frameNo * layer.S) + o
+				case 6:
+					off = (frameNo * layer.S) + o
+				}
+				for off < 0 {
+					off += layer.Width()
+				}
+				off %= layer.Width()
 				if row <= len(layer.Frames[f]) {
+					r := layer.Frames[f][row][:]
+					for col := 0; col < w; col++ {
+						ro := (off + col) % layer.Width()
+
+						if (ro) < len(r) && string(r[ro]) != layer.T {
+							ret.Data[row][col] = r[ro]
+						}
+					}
 					//for col := 0
 					//log.Println(len(layer.Frames[f][row]))
 					//ret.Data[row] = append(ret.Data[row], (layer.Frames[f][row][off%w:])...)
diff --git a/levels/locoworld/Manifest.json b/levels/locoworld/Manifest.json
index b7eb521..bcc81f2 100644
--- a/levels/locoworld/Manifest.json
+++ b/levels/locoworld/Manifest.json
@@ -5,7 +5,7 @@
     "locomotive": {
       "Z-Index": 0,
       "Direction": 6,
-      "Speed": 2,
+      "Speed": 1,
       "Repeat": false,
       "Transparent": "•"
     }