mirror of
https://github.com/genxium/DelayNoMore
synced 2024-12-27 12:08:21 +00:00
471 lines
16 KiB
Go
471 lines
16 KiB
Go
package models
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/zlib"
|
|
"encoding/base64"
|
|
"encoding/xml"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/ByteArena/box2d"
|
|
"go.uber.org/zap"
|
|
"io/ioutil"
|
|
"math"
|
|
. "server/common"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
LOW_SCORE_TREASURE_TYPE = 1
|
|
HIGH_SCORE_TREASURE_TYPE = 2
|
|
SPEED_SHOES_TYPE = 3
|
|
|
|
LOW_SCORE_TREASURE_SCORE = 100
|
|
HIGH_SCORE_TREASURE_SCORE = 200
|
|
|
|
FLIPPED_HORIZONTALLY_FLAG uint32 = 0x80000000
|
|
FLIPPED_VERTICALLY_FLAG uint32 = 0x40000000
|
|
FLIPPED_DIAGONALLY_FLAG uint32 = 0x20000000
|
|
)
|
|
|
|
// For either a "*.tmx" or "*.tsx" file. [begins]
|
|
type TmxOrTsxProperty struct {
|
|
Name string `xml:"name,attr"`
|
|
Value string `xml:"value,attr"`
|
|
}
|
|
|
|
type TmxOrTsxProperties struct {
|
|
Property []*TmxOrTsxProperty `xml:"property"`
|
|
}
|
|
|
|
type TmxOrTsxPolyline struct {
|
|
Points string `xml:"points,attr"`
|
|
}
|
|
|
|
type TmxOrTsxObject struct {
|
|
Id int `xml:"id,attr"`
|
|
Gid *int `xml:"gid,attr"`
|
|
X float64 `xml:"x,attr"`
|
|
Y float64 `xml:"y,attr"`
|
|
Properties *TmxOrTsxProperties `xml:"properties"`
|
|
Polyline *TmxOrTsxPolyline `xml:"polyline"`
|
|
Width *float64 `xml:"width,attr"`
|
|
Height *float64 `xml:"height,attr"`
|
|
}
|
|
|
|
type TmxOrTsxObjectGroup struct {
|
|
Draworder string `xml:"draworder,attr"`
|
|
Name string `xml:"name,attr"`
|
|
Objects []*TmxOrTsxObject `xml:"object"`
|
|
}
|
|
|
|
type TmxOrTsxImage struct {
|
|
Source string `xml:"source,attr"`
|
|
Width int `xml:"width,attr"`
|
|
Height int `xml:"height,attr"`
|
|
}
|
|
|
|
// For either a "*.tmx" or "*.tsx" file. [ends]
|
|
|
|
// Within a "*.tsx" file. [begins]
|
|
type Tsx struct {
|
|
Name string `xml:"name,attr"`
|
|
TileWidth int `xml:"tilewidth,attr"`
|
|
TileHeight int `xml:"tileheight,attr"`
|
|
TileCount int `xml:"tilecount,attr"`
|
|
Columns int `xml:"columns,attr"`
|
|
Image []*TmxOrTsxImage `xml:"image"`
|
|
Tiles []*TsxTile `xml:"tile"`
|
|
}
|
|
|
|
type TsxTile struct {
|
|
Id int `xml:"id,attr"`
|
|
ObjectGroup *TmxOrTsxObjectGroup `xml:"objectgroup"`
|
|
Properties *TmxOrTsxProperties `xml:"properties"`
|
|
}
|
|
|
|
// Within a "*.tsx" file. [ends]
|
|
|
|
// Within a "*.tmx" file. [begins]
|
|
type TmxLayerDecodedTileData struct {
|
|
Id uint32
|
|
Tileset *TmxTileset
|
|
FlipHorizontal bool
|
|
FlipVertical bool
|
|
FlipDiagonal bool
|
|
}
|
|
|
|
type TmxLayerEncodedData struct {
|
|
Encoding string `xml:"encoding,attr"`
|
|
Compression string `xml:"compression,attr"`
|
|
Value string `xml:",chardata"`
|
|
}
|
|
|
|
type TmxLayer struct {
|
|
Name string `xml:"name,attr"`
|
|
Width int `xml:"width,attr"`
|
|
Height int `xml:"height,attr"`
|
|
Data *TmxLayerEncodedData `xml:"data"`
|
|
Tile []*TmxLayerDecodedTileData
|
|
}
|
|
|
|
type TmxTileset struct {
|
|
FirstGid uint32 `xml:"firstgid,attr"`
|
|
Name string `xml:"name,attr"`
|
|
TileWidth int `xml:"tilewidth,attr"`
|
|
TileHeight int `xml:"tileheight,attr"`
|
|
Images []*TmxOrTsxImage `xml:"image"`
|
|
Source string `xml:"source,attr"`
|
|
}
|
|
|
|
type TmxMap struct {
|
|
Version string `xml:"version,attr"`
|
|
Orientation string `xml:"orientation,attr"`
|
|
Width int `xml:"width,attr"`
|
|
Height int `xml:"height,attr"`
|
|
TileWidth int `xml:"tilewidth,attr"`
|
|
TileHeight int `xml:"tileheight,attr"`
|
|
Properties []*TmxOrTsxProperties `xml:"properties"`
|
|
Tilesets []*TmxTileset `xml:"tileset"`
|
|
Layers []*TmxLayer `xml:"layer"`
|
|
ObjectGroups []*TmxOrTsxObjectGroup `xml:"objectgroup"`
|
|
}
|
|
|
|
// Within a "*.tmx" file. [ends]
|
|
|
|
func (d *TmxLayerEncodedData) decodeBase64() ([]byte, error) {
|
|
r := bytes.NewReader([]byte(strings.TrimSpace(d.Value)))
|
|
decr := base64.NewDecoder(base64.StdEncoding, r)
|
|
if d.Compression == "zlib" {
|
|
rclose, err := zlib.NewReader(decr)
|
|
if err != nil {
|
|
Logger.Error("tmx data decode zlib error: ", zap.Any("encoding", d.Encoding), zap.Any("compression", d.Compression), zap.Any("value", d.Value))
|
|
return nil, err
|
|
}
|
|
return ioutil.ReadAll(rclose)
|
|
}
|
|
Logger.Error("tmx data decode invalid compression: ", zap.Any("encoding", d.Encoding), zap.Any("compression", d.Compression), zap.Any("value", d.Value))
|
|
return nil, errors.New("Invalid compression.")
|
|
}
|
|
|
|
func (l *TmxLayer) decodeBase64() ([]uint32, error) {
|
|
databytes, err := l.Data.decodeBase64()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if l.Width == 0 || l.Height == 0 {
|
|
return nil, errors.New("Zero width or height.")
|
|
}
|
|
if len(databytes) != l.Height*l.Width*4 {
|
|
Logger.Error("TmxLayer decodeBase64 invalid data bytes:", zap.Any("width", l.Width), zap.Any("height", l.Height), zap.Any("data lenght", len(databytes)))
|
|
return nil, errors.New("Data length error.")
|
|
}
|
|
dindex := 0
|
|
gids := make([]uint32, l.Height*l.Width)
|
|
for h := 0; h < l.Height; h++ {
|
|
for w := 0; w < l.Width; w++ {
|
|
gid := uint32(databytes[dindex]) |
|
|
uint32(databytes[dindex+1])<<8 |
|
|
uint32(databytes[dindex+2])<<16 |
|
|
uint32(databytes[dindex+3])<<24
|
|
dindex += 4
|
|
gids[h*l.Width+w] = gid
|
|
}
|
|
}
|
|
return gids, nil
|
|
}
|
|
|
|
type Vec2DList []*Vec2D
|
|
type Polygon2DList []*Polygon2D
|
|
type StrToVec2DListMap map[string]*Vec2DList // Note that it's deliberately NOT using "map[string]Vec2DList", for the easy of passing return value to "models/room.go".
|
|
type StrToPolygon2DListMap map[string]*Polygon2DList // Note that it's deliberately NOT using "map[string]Polygon2DList", for the easy of passing return value to "models/room.go".
|
|
|
|
func TmxPolylineToPolygon2DInB2World(pTmxMapIns *TmxMap, singleObjInTmxFile *TmxOrTsxObject, targetPolyline *TmxOrTsxPolyline) (*Polygon2D, error) {
|
|
if nil == targetPolyline {
|
|
return nil, nil
|
|
}
|
|
|
|
singleValueArray := strings.Split(targetPolyline.Points, " ")
|
|
pointsCount := len(singleValueArray)
|
|
|
|
if pointsCount >= box2d.B2_maxPolygonVertices {
|
|
return nil, errors.New(fmt.Sprintf("During `TmxPolylineToPolygon2DInB2World`, you have a polygon with pointsCount == %v, exceeding or equal to box2d.B2_maxPolygonVertices == %v, of polyines [%v]", pointsCount, box2d.B2_maxPolygonVertices, singleValueArray))
|
|
}
|
|
|
|
theUntransformedAnchor := &Vec2D{
|
|
X: singleObjInTmxFile.X,
|
|
Y: singleObjInTmxFile.Y,
|
|
}
|
|
theTransformedAnchor := pTmxMapIns.continuousObjLayerOffsetToContinuousMapNodePos(theUntransformedAnchor)
|
|
thePolygon2DFromPolyline := &Polygon2D{
|
|
Anchor: &theTransformedAnchor,
|
|
Points: make([]*Vec2D, len(singleValueArray)),
|
|
}
|
|
|
|
for k, value := range singleValueArray {
|
|
thePolygon2DFromPolyline.Points[k] = &Vec2D{}
|
|
for kk, v := range strings.Split(value, ",") {
|
|
coordinateValue, err := strconv.ParseFloat(v, 64)
|
|
if nil != err {
|
|
panic(err)
|
|
}
|
|
if 0 == (kk % 2) {
|
|
thePolygon2DFromPolyline.Points[k].X = (coordinateValue)
|
|
} else {
|
|
thePolygon2DFromPolyline.Points[k].Y = (coordinateValue)
|
|
}
|
|
}
|
|
|
|
// Transform to B2World space coordinate.
|
|
tmp := &Vec2D{
|
|
X: thePolygon2DFromPolyline.Points[k].X,
|
|
Y: thePolygon2DFromPolyline.Points[k].Y,
|
|
}
|
|
transformedTmp := pTmxMapIns.continuousObjLayerVecToContinuousMapNodeVec(tmp)
|
|
thePolygon2DFromPolyline.Points[k].X = transformedTmp.X
|
|
thePolygon2DFromPolyline.Points[k].Y = transformedTmp.Y
|
|
}
|
|
|
|
return thePolygon2DFromPolyline, nil
|
|
}
|
|
|
|
func TsxPolylineToOffsetsWrtTileCenterInB2World(pTmxMapIns *TmxMap, singleObjInTsxFile *TmxOrTsxObject, targetPolyline *TmxOrTsxPolyline, pTsxIns *Tsx) (*Polygon2D, error) {
|
|
if nil == targetPolyline {
|
|
return nil, nil
|
|
}
|
|
var factorHalf float64 = 0.5
|
|
offsetFromTopLeftInTileLocalCoordX := singleObjInTsxFile.X
|
|
offsetFromTopLeftInTileLocalCoordY := singleObjInTsxFile.Y
|
|
|
|
singleValueArray := strings.Split(targetPolyline.Points, " ")
|
|
pointsCount := len(singleValueArray)
|
|
|
|
if pointsCount >= box2d.B2_maxPolygonVertices {
|
|
return nil, errors.New(fmt.Sprintf("During `TsxPolylineToOffsetsWrtTileCenterInB2World`, you have a polygon with pointsCount == %v, exceeding or equal to box2d.B2_maxPolygonVertices == %v", pointsCount, box2d.B2_maxPolygonVertices))
|
|
}
|
|
|
|
thePolygon2DFromPolyline := &Polygon2D{
|
|
Anchor: nil,
|
|
Points: make([]*Vec2D, pointsCount),
|
|
TileWidth: pTsxIns.TileWidth,
|
|
TileHeight: pTsxIns.TileHeight,
|
|
}
|
|
|
|
/*
|
|
[WARNING] In this case, the "Treasure"s and "GuardTower"s are put into Tmx file as "ImageObject"s, of each the "ProportionalAnchor" is (0.5, 0). Therefore we calculate that "thePolygon2DFromPolyline.Points" are "offsets(in B2World) w.r.t. the BottomCenter". See https://shimo.im/docs/SmLJJhXm2C8XMzZT for details.
|
|
*/
|
|
|
|
for k, value := range singleValueArray {
|
|
thePolygon2DFromPolyline.Points[k] = &Vec2D{}
|
|
for kk, v := range strings.Split(value, ",") {
|
|
coordinateValue, err := strconv.ParseFloat(v, 64)
|
|
if nil != err {
|
|
panic(err)
|
|
}
|
|
if 0 == (kk % 2) {
|
|
// W.r.t. center.
|
|
thePolygon2DFromPolyline.Points[k].X = (coordinateValue + offsetFromTopLeftInTileLocalCoordX) - factorHalf*float64(pTsxIns.TileWidth)
|
|
} else {
|
|
// W.r.t. bottom.
|
|
thePolygon2DFromPolyline.Points[k].Y = float64(pTsxIns.TileHeight) - (coordinateValue + offsetFromTopLeftInTileLocalCoordY)
|
|
}
|
|
}
|
|
|
|
// No need to transform for B2World space coordinate because the marks in a Tsx file is already rectilinear.
|
|
}
|
|
|
|
return thePolygon2DFromPolyline, nil
|
|
}
|
|
|
|
func DeserializeTsxToColliderDict(pTmxMapIns *TmxMap, byteArrOfTsxFile []byte, firstGid int, gidBoundariesMapInB2World map[int]StrToPolygon2DListMap) error {
|
|
pTsxIns := &Tsx{}
|
|
err := xml.Unmarshal(byteArrOfTsxFile, pTsxIns)
|
|
if nil != err {
|
|
panic(err)
|
|
}
|
|
/*
|
|
// For debug-printing only. -- YFLu, 2019-09-04.
|
|
|
|
reserializedTmxMap, err := pTmxMapIns.ToXML()
|
|
if nil != err {
|
|
panic(err)
|
|
}
|
|
*/
|
|
|
|
for _, tile := range pTsxIns.Tiles {
|
|
globalGid := (firstGid + int(tile.Id))
|
|
/**
|
|
A tile xml string could be
|
|
|
|
```
|
|
<tile id="13">
|
|
<objectgroup draworder="index">
|
|
<object id="1" x="-154" y="-159">
|
|
<properties>
|
|
<property name="boundary_type" value="guardTower"/>
|
|
</properties>
|
|
<polyline points="0,0 -95,179 18,407 361,434 458,168 333,-7"/>
|
|
</object>
|
|
</objectgroup>
|
|
</tile>
|
|
```
|
|
, we currently REQUIRE that "`an object of a tile` with ONE OR MORE polylines must come with a single corresponding '<property name=`type` value=`...` />', and viceversa".
|
|
|
|
Refer to https://shimo.im/docs/SmLJJhXm2C8XMzZT for how we theoretically fit a "Polyline in Tsx" into a "Polygon2D" and then into the corresponding "B2BodyDef & B2Body in the `world of colliding bodies`".
|
|
*/
|
|
|
|
theObjGroup := tile.ObjectGroup
|
|
if nil == theObjGroup {
|
|
continue
|
|
}
|
|
for _, singleObj := range theObjGroup.Objects {
|
|
if nil == singleObj.Polyline {
|
|
// Temporarily omit those non-polyline-containing objects.
|
|
continue
|
|
}
|
|
if nil == singleObj.Properties.Property || "boundary_type" != singleObj.Properties.Property[0].Name {
|
|
continue
|
|
}
|
|
|
|
key := singleObj.Properties.Property[0].Value
|
|
|
|
var theStrToPolygon2DListMap StrToPolygon2DListMap
|
|
if existingStrToPolygon2DListMap, ok := gidBoundariesMapInB2World[globalGid]; ok {
|
|
theStrToPolygon2DListMap = existingStrToPolygon2DListMap
|
|
} else {
|
|
gidBoundariesMapInB2World[globalGid] = make(StrToPolygon2DListMap, 0)
|
|
theStrToPolygon2DListMap = gidBoundariesMapInB2World[globalGid]
|
|
}
|
|
|
|
var pThePolygon2DList *Polygon2DList
|
|
if _, ok := theStrToPolygon2DListMap[key]; ok {
|
|
pThePolygon2DList = theStrToPolygon2DListMap[key]
|
|
} else {
|
|
thePolygon2DList := make(Polygon2DList, 0)
|
|
theStrToPolygon2DListMap[key] = &thePolygon2DList
|
|
pThePolygon2DList = theStrToPolygon2DListMap[key]
|
|
}
|
|
|
|
thePolygon2DFromPolyline, err := TsxPolylineToOffsetsWrtTileCenterInB2World(pTmxMapIns, singleObj, singleObj.Polyline, pTsxIns)
|
|
if nil != err {
|
|
panic(err)
|
|
}
|
|
*pThePolygon2DList = append(*pThePolygon2DList, thePolygon2DFromPolyline)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func ParseTmxLayersAndGroups(pTmxMapIns *TmxMap, gidBoundariesMapInB2World map[int]StrToPolygon2DListMap) (int32, int32, int32, int32, StrToVec2DListMap, StrToPolygon2DListMap, error) {
|
|
toRetStrToVec2DListMap := make(StrToVec2DListMap, 0)
|
|
toRetStrToPolygon2DListMap := make(StrToPolygon2DListMap, 0)
|
|
/*
|
|
Note that both
|
|
- "Vec2D"s of "toRetStrToVec2DListMap", and
|
|
- "Polygon2D"s of "toRetStrToPolygon2DListMap"
|
|
|
|
are already transformed into the "coordinate of B2World".
|
|
*/
|
|
|
|
for _, objGroup := range pTmxMapIns.ObjectGroups {
|
|
switch objGroup.Name {
|
|
case "PlayerStartingPos":
|
|
var pTheVec2DListToCache *Vec2DList
|
|
_, ok := toRetStrToVec2DListMap[objGroup.Name]
|
|
if false == ok {
|
|
theVec2DListToCache := make(Vec2DList, 0)
|
|
toRetStrToVec2DListMap[objGroup.Name] = &theVec2DListToCache
|
|
pTheVec2DListToCache = toRetStrToVec2DListMap[objGroup.Name]
|
|
} else {
|
|
pTheVec2DListToCache = toRetStrToVec2DListMap[objGroup.Name]
|
|
}
|
|
for _, singleObjInTmxFile := range objGroup.Objects {
|
|
theUntransformedPos := &Vec2D{
|
|
X: singleObjInTmxFile.X,
|
|
Y: singleObjInTmxFile.Y,
|
|
}
|
|
thePosInWorld := pTmxMapIns.continuousObjLayerOffsetToContinuousMapNodePos(theUntransformedPos)
|
|
*pTheVec2DListToCache = append(*pTheVec2DListToCache, &thePosInWorld)
|
|
}
|
|
case "Barrier":
|
|
// Note that in this case, the "Polygon2D.Anchor" of each "TmxOrTsxObject" is exactly overlapping with "Polygon2D.Points[0]" w.r.t. B2World.
|
|
var pThePolygon2DListToCache *Polygon2DList
|
|
_, ok := toRetStrToPolygon2DListMap[objGroup.Name]
|
|
if false == ok {
|
|
thePolygon2DListToCache := make(Polygon2DList, 0)
|
|
toRetStrToPolygon2DListMap[objGroup.Name] = &thePolygon2DListToCache
|
|
pThePolygon2DListToCache = toRetStrToPolygon2DListMap[objGroup.Name]
|
|
} else {
|
|
pThePolygon2DListToCache = toRetStrToPolygon2DListMap[objGroup.Name]
|
|
}
|
|
|
|
for _, singleObjInTmxFile := range objGroup.Objects {
|
|
if nil == singleObjInTmxFile.Polyline {
|
|
continue
|
|
}
|
|
if nil == singleObjInTmxFile.Properties.Property || "boundary_type" != singleObjInTmxFile.Properties.Property[0].Name || "barrier" != singleObjInTmxFile.Properties.Property[0].Value {
|
|
continue
|
|
}
|
|
|
|
thePolygon2DInWorld, err := TmxPolylineToPolygon2DInB2World(pTmxMapIns, singleObjInTmxFile, singleObjInTmxFile.Polyline)
|
|
if nil != err {
|
|
panic(err)
|
|
}
|
|
*pThePolygon2DListToCache = append(*pThePolygon2DListToCache, thePolygon2DInWorld)
|
|
}
|
|
default:
|
|
}
|
|
}
|
|
return int32(pTmxMapIns.Width), int32(pTmxMapIns.Height), int32(pTmxMapIns.TileWidth), int32(pTmxMapIns.TileHeight), toRetStrToVec2DListMap, toRetStrToPolygon2DListMap, nil
|
|
}
|
|
|
|
func (pTmxMap *TmxMap) ToXML() (string, error) {
|
|
ret, err := xml.Marshal(pTmxMap)
|
|
return string(ret[:]), err
|
|
}
|
|
|
|
type TileRectilinearSize struct {
|
|
Width float64
|
|
Height float64
|
|
}
|
|
|
|
func (pTmxMapIns *TmxMap) continuousObjLayerVecToContinuousMapNodeVec(continuousObjLayerVec *Vec2D) Vec2D {
|
|
var tileRectilinearSize TileRectilinearSize
|
|
tileRectilinearSize.Width = float64(pTmxMapIns.TileWidth)
|
|
tileRectilinearSize.Height = float64(pTmxMapIns.TileHeight)
|
|
tileSizeUnifiedLength := math.Sqrt(tileRectilinearSize.Width*tileRectilinearSize.Width*0.25 + tileRectilinearSize.Height*tileRectilinearSize.Height*0.25)
|
|
isometricObjectLayerPointOffsetScaleFactor := (tileSizeUnifiedLength / tileRectilinearSize.Height)
|
|
cosineThetaRadian := (tileRectilinearSize.Width * 0.5) / tileSizeUnifiedLength
|
|
sineThetaRadian := (tileRectilinearSize.Height * 0.5) / tileSizeUnifiedLength
|
|
|
|
transMat := [...][2]float64{
|
|
{isometricObjectLayerPointOffsetScaleFactor * cosineThetaRadian, -isometricObjectLayerPointOffsetScaleFactor * cosineThetaRadian},
|
|
{-isometricObjectLayerPointOffsetScaleFactor * sineThetaRadian, -isometricObjectLayerPointOffsetScaleFactor * sineThetaRadian},
|
|
}
|
|
convertedVecX := transMat[0][0]*continuousObjLayerVec.X + transMat[0][1]*continuousObjLayerVec.Y
|
|
convertedVecY := transMat[1][0]*continuousObjLayerVec.X + transMat[1][1]*continuousObjLayerVec.Y
|
|
converted := Vec2D{
|
|
X: convertedVecX,
|
|
Y: convertedVecY,
|
|
}
|
|
return converted
|
|
}
|
|
|
|
func (pTmxMapIns *TmxMap) continuousObjLayerOffsetToContinuousMapNodePos(continuousObjLayerOffset *Vec2D) Vec2D {
|
|
layerOffset := Vec2D{
|
|
X: 0,
|
|
Y: float64(pTmxMapIns.Height*pTmxMapIns.TileHeight) * 0.5,
|
|
}
|
|
|
|
calibratedVec := continuousObjLayerOffset
|
|
convertedVec := pTmxMapIns.continuousObjLayerVecToContinuousMapNodeVec(calibratedVec)
|
|
|
|
toRet := Vec2D{
|
|
X: layerOffset.X + convertedVec.X,
|
|
Y: layerOffset.Y + convertedVec.Y,
|
|
}
|
|
|
|
return toRet
|
|
}
|