666 lines
13 KiB
Go
666 lines
13 KiB
Go
package d2ds1
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2path"
|
|
)
|
|
|
|
func exampleDS1() *DS1 {
|
|
return &DS1{
|
|
files: []string{"a.dt1", "b.dt1"},
|
|
objects: []Object{
|
|
{0, 0, 0, 0, 0, nil},
|
|
{0, 1, 0, 0, 0, []d2path.Path{{}}},
|
|
{0, 2, 0, 0, 0, nil},
|
|
{0, 3, 0, 0, 0, nil},
|
|
},
|
|
tiles: [][]Tile{ // 2x2
|
|
{
|
|
Tile{
|
|
[]Floor{{}},
|
|
[]Wall{{}},
|
|
[]Shadow{{}},
|
|
[]Substitution{{}},
|
|
},
|
|
Tile{
|
|
[]Floor{{}},
|
|
[]Wall{{}},
|
|
[]Shadow{{}},
|
|
[]Substitution{{}},
|
|
},
|
|
},
|
|
{
|
|
Tile{
|
|
[]Floor{{}},
|
|
[]Wall{{}},
|
|
[]Shadow{{}},
|
|
[]Substitution{{}},
|
|
},
|
|
Tile{
|
|
[]Floor{{}},
|
|
[]Wall{{}},
|
|
[]Shadow{{}},
|
|
[]Substitution{{}},
|
|
},
|
|
},
|
|
},
|
|
substitutionGroups: nil,
|
|
version: 17,
|
|
width: 2,
|
|
height: 2,
|
|
act: 1,
|
|
substitutionType: 0,
|
|
numberOfWallLayers: 1,
|
|
numberOfFloorLayers: 1,
|
|
numberOfShadowLayers: 1,
|
|
numberOfSubstitutionLayers: 1,
|
|
}
|
|
}
|
|
|
|
// checks, if DS1 structure could be marshaled and unmarshaled
|
|
func testIfRestorable(ds1 *DS1, test func(ds1 *DS1)) error {
|
|
test(ds1)
|
|
|
|
var err error
|
|
|
|
data := ds1.Marshal()
|
|
|
|
newDS1, err := LoadDS1(data)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
test(newDS1)
|
|
|
|
return nil
|
|
}
|
|
|
|
func TestDS1_Marshal(t *testing.T) {
|
|
a := exampleDS1()
|
|
|
|
bytes := a.Marshal()
|
|
|
|
b, err := LoadDS1(bytes)
|
|
if err != nil {
|
|
t.Error("could not load new ds1 from marshaled ds1 data")
|
|
return
|
|
}
|
|
|
|
if b.width != a.width {
|
|
t.Error("new ds1 does not match original")
|
|
}
|
|
|
|
if len(b.tiles) != len(a.tiles) {
|
|
t.Error("new ds1 does not batch original")
|
|
}
|
|
}
|
|
|
|
func TestDS1_Files(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
files := ds1.Files()
|
|
|
|
for idx := range files {
|
|
if ds1.files[idx] != files[idx] {
|
|
t.Error("unexpected files from ds1")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDS1_AddFile(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
numBefore := len(ds1.files)
|
|
|
|
ds1.AddFile("other.ds1")
|
|
|
|
numAfter := len(ds1.files)
|
|
|
|
test := func(ds1 *DS1) {
|
|
if (numBefore + 1) != numAfter {
|
|
t.Error("unexpected number of files in ds1")
|
|
}
|
|
}
|
|
|
|
if err := testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_RemoveFile(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
test := func(ds1 *DS1) {
|
|
numBefore := len(ds1.files)
|
|
|
|
err := ds1.RemoveFile("nonexistant file")
|
|
if err == nil {
|
|
t.Fatal("file 'nonexistant file' doesn't exist but ds1.RemoveFile doesn't return error")
|
|
}
|
|
|
|
if len(ds1.files) != numBefore {
|
|
t.Error("file removed when it should not have been")
|
|
}
|
|
|
|
filename := "c.ds1"
|
|
|
|
ds1.AddFile(filename)
|
|
|
|
if len(ds1.files) == numBefore {
|
|
t.Error("file not added when it should have been")
|
|
}
|
|
|
|
err = ds1.RemoveFile(filename)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if len(ds1.files) != numBefore {
|
|
t.Error("file not removed when it should have been")
|
|
}
|
|
}
|
|
|
|
if err := testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_Objects(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
objects := ds1.Objects()
|
|
|
|
for idx := range ds1.objects {
|
|
if !ds1.objects[idx].Equals(&objects[idx]) {
|
|
t.Error("unexpected object")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDS1_AddObject(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
numBefore := len(ds1.objects)
|
|
|
|
ds1.AddObject(Object{})
|
|
|
|
numAfter := len(ds1.objects)
|
|
|
|
test := func(ds1 *DS1) {
|
|
if (numBefore + 1) != numAfter {
|
|
t.Error("unexpected number of objects in ds1")
|
|
}
|
|
}
|
|
|
|
if err := testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_RemoveObject(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
nice := 69420
|
|
|
|
obj := Object{
|
|
ID: nice,
|
|
}
|
|
|
|
ds1.AddObject(obj)
|
|
|
|
numBefore := len(ds1.objects)
|
|
|
|
ds1.RemoveObject(obj)
|
|
|
|
test := func(ds1 *DS1) {
|
|
if len(ds1.objects) == numBefore {
|
|
t.Error("did not remove object when expected")
|
|
}
|
|
}
|
|
|
|
if err := testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_Tiles(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
tiles := ds1.Tiles()
|
|
|
|
for y := range tiles {
|
|
for x := range tiles[y] {
|
|
if len(ds1.tiles[y][x].Floors) != len(tiles[y][x].Floors) {
|
|
t.Fatal("number of tile's floors returned by ds1.Tiles() isn't same as real number")
|
|
}
|
|
|
|
if ds1.tiles[y][x].Walls[0] != tiles[y][x].Walls[0] {
|
|
t.Fatal("wall record returned by ds1.Tiles isn't equal to real")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDS1_SetTiles(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
exampleTile1 := Tile{
|
|
Floors: []floorShadow{
|
|
{8, 7, 2, 3, 4, 55, 33, true, 999},
|
|
},
|
|
Walls: []Wall{
|
|
{2, 3, 4, 5, 3, 2, 3, 0, 33, 99},
|
|
{2, 3, 4, 5, 3, 2, 3, 0, 33, 99},
|
|
},
|
|
Shadows: []floorShadow{
|
|
{2, 4, 5, 33, 6, 7, 0, false, 1024},
|
|
},
|
|
}
|
|
|
|
exampleTile2 := Tile{
|
|
Floors: []floorShadow{
|
|
{9, 9, 2, 3, 4, 55, 33, true, 999},
|
|
{9, 8, 2, 3, 102, 55, 33, true, 999},
|
|
},
|
|
Walls: []Wall{
|
|
{2, 3, 4, 5, 3, 2, 3, 0, 33, 99},
|
|
},
|
|
Shadows: []floorShadow{
|
|
{2, 4, 5, 33, 6, 7, 0, false, 1024},
|
|
},
|
|
}
|
|
|
|
tiles := [][]Tile{{exampleTile1, exampleTile2}, {exampleTile2, exampleTile1}}
|
|
|
|
ds1.SetTiles(tiles)
|
|
|
|
test := func(ds1 *DS1) {
|
|
if ds1.tiles[0][0].Floors[0].Prop1 != exampleTile1.Floors[0].Prop1 {
|
|
t.Fatal("1,unexpected tile was set")
|
|
}
|
|
|
|
if len(ds1.tiles[0][0].Walls) != len(exampleTile1.Walls) {
|
|
t.Fatal("2,unexpected tile was set")
|
|
}
|
|
|
|
if ds1.tiles[0][1].Walls[0].Style != exampleTile2.Walls[0].Style {
|
|
t.Fatal("3,unexpected tile was set")
|
|
}
|
|
|
|
if len(ds1.tiles[0][0].Walls) != len(exampleTile1.Walls) {
|
|
t.Fatal("4,unexpected tile was set")
|
|
}
|
|
}
|
|
|
|
if err := testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_Tile(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
x, y := 1, 0
|
|
|
|
if ds1.tiles[y][x].Floors[0] != ds1.Tile(x, y).Floors[0] {
|
|
t.Fatal("ds1.Tile returned invalid value")
|
|
}
|
|
}
|
|
|
|
func TestDS1_SetTile(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
exampleTile := Tile{
|
|
Floors: []floorShadow{
|
|
{5, 8, 9, 4, 3, 0, 0, true, 1024},
|
|
},
|
|
Walls: []Wall{
|
|
{2, 0, 4, 5, 3, 2, 3, 0, 33, 99},
|
|
{5, 8, 9, 4, 3, 0, 0, 124, 221, 12},
|
|
},
|
|
Shadows: []floorShadow{
|
|
{2, 44, 99, 2, 4, 3, 2, true, 933},
|
|
},
|
|
}
|
|
|
|
ds1.SetTile(0, 0, &exampleTile)
|
|
|
|
test := func(ds1 *DS1) {
|
|
if ds1.tiles[0][0].Floors[0].Prop1 != exampleTile.Floors[0].Prop1 {
|
|
t.Fatal("unexpected tile was set")
|
|
}
|
|
|
|
if ds1.tiles[0][0].Walls[0].Zero != exampleTile.Walls[0].Zero {
|
|
t.Fatal("unexpected tile was set")
|
|
}
|
|
|
|
if len(ds1.tiles[0][0].Walls) != len(exampleTile.Walls) {
|
|
t.Fatal("unexpected tile was set")
|
|
}
|
|
}
|
|
|
|
if err := testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_Version(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
version := ds1.version
|
|
|
|
if version != int32(ds1.Version()) {
|
|
t.Fatal("version returned by ds1.Version() and real aren't equal")
|
|
}
|
|
}
|
|
|
|
func TestDS1_SetVersion(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
newVersion := 8
|
|
|
|
ds1.SetVersion(newVersion)
|
|
|
|
test := func(ds1 *DS1) {
|
|
if newVersion != int(ds1.version) {
|
|
t.Fatal("ds1.SetVersion set version incorrectly")
|
|
}
|
|
}
|
|
|
|
if err := testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_Width(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
if int(ds1.width) != ds1.Width() {
|
|
t.Error("unexpected width")
|
|
}
|
|
}
|
|
|
|
func TestDS1_SetWidth(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
var newWidth int32 = 4
|
|
|
|
ds1.SetWidth(int(newWidth))
|
|
|
|
test := func(ds1 *DS1) {
|
|
if newWidth != ds1.width {
|
|
t.Fatal("unexpected width after set")
|
|
}
|
|
}
|
|
|
|
if err := testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_Height(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
if int(ds1.height) != ds1.Height() {
|
|
t.Error("unexpected height")
|
|
}
|
|
}
|
|
|
|
func TestDS1_SetHeight(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
var newHeight int32 = 5
|
|
|
|
ds1.SetHeight(int(newHeight))
|
|
|
|
test := func(ds1 *DS1) {
|
|
if newHeight != ds1.height {
|
|
t.Fatal("unexpected heigth after set")
|
|
}
|
|
}
|
|
|
|
if err := testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_Act(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
if ds1.Act() != int(ds1.act) {
|
|
t.Error("unexpected value in example ds1")
|
|
}
|
|
}
|
|
|
|
func TestDS1_SetAct(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
ds1.SetAct(-1)
|
|
|
|
if ds1.Act() < 0 {
|
|
t.Error("act cannot be less than 0")
|
|
}
|
|
|
|
nice := 5
|
|
|
|
ds1.SetAct(nice)
|
|
|
|
test := func(ds1 *DS1) {
|
|
if int(ds1.act) != nice {
|
|
t.Error("unexpected value for act")
|
|
}
|
|
}
|
|
|
|
if err := testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_SubstitutionType(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
st := ds1.substitutionType
|
|
|
|
if int(st) != ds1.SubstitutionType() {
|
|
t.Fatal("unexpected substitution type returned")
|
|
}
|
|
}
|
|
|
|
func TestDS1_SetSubstitutionType(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
newST := 5
|
|
|
|
ds1.SetSubstitutionType(newST)
|
|
|
|
if ds1.substitutionType != int32(newST) {
|
|
t.Fatal("unexpected substitutionType was set")
|
|
}
|
|
}
|
|
|
|
func TestDS1_NumberOfWalls(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
if ds1.NumberOfWallLayers() != int(ds1.numberOfWallLayers) {
|
|
t.Error("unexpected number of wall layers")
|
|
}
|
|
}
|
|
|
|
func TestDS1_SetNumberOfWalls(t *testing.T) {
|
|
var err error
|
|
|
|
ds1 := exampleDS1()
|
|
|
|
newNumber := int32(4)
|
|
|
|
err = ds1.SetNumberOfWallLayers(newNumber)
|
|
if err != nil {
|
|
t.Errorf("error setting number of walls: %v", err)
|
|
}
|
|
|
|
test := func(ds1 *DS1) {
|
|
if len(ds1.tiles[0][0].Walls) != int(newNumber) {
|
|
t.Fatal("unexpected walls length set")
|
|
}
|
|
|
|
if ds1.NumberOfWallLayers() != int(newNumber) {
|
|
t.Fatal("unexpected walls length set")
|
|
}
|
|
}
|
|
|
|
if err = testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
|
|
newNumber = 1
|
|
|
|
err = ds1.SetNumberOfWallLayers(newNumber)
|
|
if err != nil {
|
|
t.Errorf("error setting number of walls: %v", err)
|
|
}
|
|
|
|
test = func(ds1 *DS1) {
|
|
if len(ds1.tiles[0][0].Walls) != int(newNumber) {
|
|
t.Fatal("unexpected walls length set")
|
|
}
|
|
|
|
if ds1.NumberOfWallLayers() != int(newNumber) {
|
|
t.Fatal("unexpected walls length set")
|
|
}
|
|
}
|
|
|
|
if err = testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_NumberOfFloors(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
if ds1.NumberOfFloorLayers() != int(ds1.numberOfFloorLayers) {
|
|
t.Error("unexpected number of floor layers")
|
|
}
|
|
}
|
|
|
|
func TestDS1_SetNumberOfFloors(t *testing.T) {
|
|
var err error
|
|
|
|
ds1 := exampleDS1()
|
|
|
|
newNumber := int32(2)
|
|
|
|
err = ds1.SetNumberOfFloorLayers(newNumber)
|
|
if err != nil {
|
|
t.Errorf("error setting number of floors: %v", err)
|
|
}
|
|
|
|
test := func(ds1 *DS1) {
|
|
if len(ds1.tiles[0][0].Floors) != int(newNumber) {
|
|
t.Fatal("unexpected floors length set")
|
|
}
|
|
|
|
if ds1.numberOfFloorLayers != newNumber {
|
|
t.Fatal("unexpected floors length set")
|
|
}
|
|
}
|
|
|
|
if err = testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
|
|
newNumber = 1
|
|
|
|
err = ds1.SetNumberOfFloorLayers(newNumber)
|
|
if err != nil {
|
|
t.Errorf("error setting number of floors: %v", err)
|
|
}
|
|
|
|
test = func(ds1 *DS1) {
|
|
if len(ds1.tiles[0][0].Floors) != int(newNumber) {
|
|
t.Fatal("unexpected floors length set")
|
|
}
|
|
|
|
if ds1.numberOfFloorLayers != newNumber {
|
|
t.Fatal("unexpected floors length set")
|
|
}
|
|
}
|
|
|
|
if err = testIfRestorable(ds1, test); err != nil {
|
|
t.Errorf("unable to restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDS1_NumberOfShadowLayers(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
if ds1.NumberOfShadowLayers() != int(ds1.numberOfShadowLayers) {
|
|
t.Error("unexpected number of shadow layers")
|
|
}
|
|
}
|
|
|
|
func TestDS1_NumberOfSubstitutionLayers(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
if ds1.NumberOfSubstitutionLayers() != int(ds1.numberOfSubstitutionLayers) {
|
|
t.Error("unexpected number of substitution layers")
|
|
}
|
|
}
|
|
|
|
func TestDS1_SubstitutionGroups(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
sg := ds1.SubstitutionGroups()
|
|
|
|
for i := 0; i < len(ds1.substitutionGroups); i++ {
|
|
if sg[i] != ds1.substitutionGroups[i] {
|
|
t.Fatal("unexpected substitution group returned")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDS1_SetSubstitutionGroups(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
newGroup := []SubstitutionGroup{
|
|
{
|
|
TileX: 20,
|
|
TileY: 12,
|
|
WidthInTiles: 212,
|
|
HeightInTiles: 334,
|
|
Unknown: 1024,
|
|
},
|
|
}
|
|
|
|
ds1.SetSubstitutionGroups(newGroup)
|
|
|
|
if ds1.substitutionGroups[0] != newGroup[0] {
|
|
t.Fatal("unexpected substitution group added")
|
|
}
|
|
}
|
|
|
|
func TestDS1_GetStreamLayerTypes(t *testing.T) {
|
|
ds1 := exampleDS1()
|
|
|
|
lst := []d2enum.LayerStreamType{
|
|
d2enum.LayerStreamWall1,
|
|
d2enum.LayerStreamOrientation1,
|
|
d2enum.LayerStreamFloor1,
|
|
d2enum.LayerStreamShadow,
|
|
d2enum.LayerStreamSubstitute,
|
|
}
|
|
|
|
layerStreamTypes := ds1.GetStreamLayerTypes()
|
|
|
|
if len(lst) != len(layerStreamTypes) {
|
|
t.Fatal("unexpected length")
|
|
}
|
|
|
|
for i := range lst {
|
|
if lst[i] != layerStreamTypes[i] {
|
|
t.Fatal("Unexpected type was set")
|
|
}
|
|
}
|
|
}
|