Пример #1
0
func TestFindSolarSlotPosition(t *testing.T) {
	friends := []*Sun{
		{
			Username: "******",
			Name:     "MORS01",
			Position: vec2d.New(0, 0),
		},
		{
			Username: "******",
			Name:     "MORS02",
			Position: vec2d.New(-9000, 0),
		},
		{
			Username: "******",
			Name:     "MORS03",
			Position: vec2d.New(-18000, 0),
		},
		{
			Username: "******",
			Name:     "MORS04",
			Position: vec2d.New(-4500, -7794),
		},
	}

	targetSlot := getStartSolarSlotPosition(friends)

	if targetSlot.Position.X != -9000 || targetSlot.Position.Y != 0 {
		t.Error("Target solar slot out of place. Coordinates: ")
		t.Error(targetSlot.Position)
	}
}
func TestListAreas(t *testing.T) {
	topLeft := vec2d.New(-5380, 5350)
	bottomRight := vec2d.New(5420, -5250)

	areas := listAreas(topLeft, bottomRight)
	if len(areas) != 4 {
		t.Errorf("Areas turned out to be %#v", areas)
	}
}
func TestCalculateCanvasSize(t *testing.T) {
	topLeft, bottomRight := calculateCanvasSize(vec2d.New(20, 50), []uint64{800, 600})
	if *topLeft != *vec2d.New(-5380, 5350) {
		t.Errorf("topLeft is %#v, expected: %#v", *topLeft, *vec2d.New(-5380, 5350))
	}
	if *bottomRight != *vec2d.New(5420, -5250) {
		t.Errorf("bottomRight is %#v, expected: %#v", *bottomRight, *vec2d.New(5420, -5250))
	}
}
Пример #4
0
func TestCreateMission(t *testing.T) {
	startTime := time.Now()
	planetStart := Planet{
		Name:                "GOP6720",
		Color:               Color{0.59215686, 0.59215686, 0.59215686},
		Position:            vec2d.New(271, 203),
		IsHome:              true,
		Texture:             3,
		Size:                1,
		LastShipCountUpdate: startTime.Unix(),
		ShipCount:           100,
		MaxShipCount:        1000,
		Owner:               "gophie",
	}
	planetEnd := Planet{
		Name:                "GOP6721",
		Color:               Color{0.59215686, 0.59215686, 0.59215686},
		Position:            vec2d.New(471, 403),
		IsHome:              false,
		Texture:             3,
		Size:                1,
		LastShipCountUpdate: startTime.Unix(),
		ShipCount:           50,
		MaxShipCount:        1000,
		Owner:               "gophie",
	}
	player := Player{
		Username:       "******",
		RaceID:         1,
		TwitterID:      "asdf",
		HomePlanet:     "planet.GOP6720",
		ScreenSize:     []uint64{1, 1},
		ScreenPosition: &vec2d.Vector{2, 2},
	}

	validMission := player.StartMission(&planetStart, &planetEnd, []*vec2d.Vector{}, 80, "Attack")

	planetStart.ShipCount = 100

	if validMission.Source.Name != "GOP6720" {
		t.Error(validMission.Source)
		t.Error("Planet planet.GOP6720 was expected as start planet!")
	}

	if validMission.Target.Name != "GOP6721" {
		t.Error(validMission.Target)
		t.Error("Planet planet.GOP6720 was expected as end planet!")
	}

	if validMission.ShipCount != 80 {
		t.Error(validMission.ShipCount)
		t.Error("Mission ShipCount was expected to be 80!")
	}
}
Пример #5
0
// Note that operations like Collect, Sub, Mul and Div changes the Vector
// if they are called as its methods. If you want to create a new instance
// you have to use the functions instead
func ExampleVector_Collect() {
	vector := vec2d.New(2.0, 4.0)
	other := vec2d.New(3.0, 5.0)
	vector.Collect(other)
	result := vec2d.Collect(vector, other)

	fmt.Printf("Vector.Collect(Other) has changed Vector's values to X: %v, Y: %v\n", vector.X, vector.Y)
	fmt.Printf("vec2d.Collect(Vector, Other) gave a new vector with X: %v, Y: %v\n", result.X, result.Y)
	// Output:
	// Vector.Collect(Other) has changed Vector's values to X: 5, Y: 9
	// vec2d.Collect(Vector, Other) gave a new vector with X: 8, Y: 14
}
Пример #6
0
func ExampleGetAngleBetween() {
	vector := vec2d.New(2.0, 4.0)
	other := vec2d.New(5.0, 12.0)
	angle_between := vec2d.GetAngleBetween(vector, other)

	fmt.Printf("Vector{X: %v, Y: %v}\n", vector.X, vector.Y)
	fmt.Printf("Vector{X: %v, Y: %v}\n", other.X, other.Y)
	fmt.Printf("Angle between: %v\n", angle_between)
	// Output:
	// Vector{X: 2, Y: 4}
	// Vector{X: 5, Y: 12}
	// Angle between: 3.945186229037563
}
Пример #7
0
func ExampleGetDistance() {
	vector := vec2d.New(2.0, 4.0)
	other := vec2d.New(5.0, 12.0)
	distance := vec2d.GetDistance(vector, other)

	fmt.Printf("Vector{X: %v, Y: %v}\n", vector.X, vector.Y)
	fmt.Printf("Vector{X: %v, Y: %v}\n", other.X, other.Y)
	fmt.Printf("Distance between: %v\n", distance)
	// Output:
	// Vector{X: 2, Y: 4}
	// Vector{X: 5, Y: 12}
	// Distance between: 8.54400374531753
}
Пример #8
0
func TestEndAttackMissionDenyTakeover(t *testing.T) {
	var (
		excessShips     int32
		ownerHasChanged bool
	)

	endPlanet := new(Planet)
	*endPlanet = Planet{"", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(2, 2), true, 6, 3, timeStamp, 2, 0, "chochko"}

	mission.ShipCount = 5
	excessShips, ownerHasChanged = mission.EndAttackMission(endPlanet)

	if ownerHasChanged {
		t.Error("Owner has changed after a mission weaker than his planet")
	}

	if endPlanet.GetShipCount() != 0 {
		t.Error("End Planet ship count was expected to be 0 but it is:", endPlanet.GetShipCount())
	}

	if endPlanet.Owner != "chochko" {
		t.Error("End Planet owner was expected to be chochko but is:", endPlanet.Owner)
	}

	if excessShips != 5 {
		t.Error("There should be 5 excess ships, but the value is", excessShips)
	}
}
Пример #9
0
// In this example we rotate our vector by 2 degrees, and this will change X and Y
// of the current instance, without creating a new one.
//
// Note: If you don't want to change the current instance take a look at Vector.Rotated
func ExampleVector_Rotate() {
	vector := vec2d.New(2.0, 4.0)
	vector.Rotate(2.0)

	fmt.Printf("Vector.Rotate(2.0) changed X to %v and Y to %v\n", vector.X, vector.Y)
	// Output: Vector.Rotate(2.0) changed X to 1.8591836672281876 and Y to 4.067362301481385
}
Пример #10
0
// Generates the key of the start position node
func getStartSolarSlotPosition(friends []*Sun) *SolarSlot {
	targetPosition := vec2d.New(0, 0)

	verticalOffset := math.Floor(Settings.SolarSystemRadius * (math.Sqrt(3) / 2))

	//Find best position between all friends
	for _, friend := range friends {
		targetPosition.Collect(friend.Position)
	}
	if len(friends) > 0 {
		targetPosition.DivToFloat64(float64(len(friends)))
	}

	//math.Floor(targetPosition.Y/Settings.SolarSystemRadius*(math.Sqrt(3)/2) + 0.5)

	//Approximate target to nearest node
	verticalOffsetCoefficent := math.Floor((targetPosition.Y / verticalOffset) + 0.5)
	if int64(verticalOffsetCoefficent)%2 != 0 {
		targetPosition.X += Settings.SolarSystemRadius / 2
	}
	targetPosition.X = Settings.SolarSystemRadius * math.Floor((targetPosition.X/Settings.SolarSystemRadius)+0.5)
	targetPosition.Y = verticalOffset * verticalOffsetCoefficent
	return newSolarSlot(targetPosition.X, targetPosition.Y)

}
Пример #11
0
// Returns some random start position for a sun, before starting
// to move it over the galaxy
func getRandomStartPosition(scope int) *vec2d.Vector {
	xSeed := time.Now().UTC().UnixNano()
	ySeed := time.Now().UTC().UnixNano()
	xGenerator := rand.New(rand.NewSource(xSeed))
	yGenerator := rand.New(rand.NewSource(ySeed))
	return vec2d.New(
		float64(xGenerator.Intn(scope)-scope/2),
		float64(yGenerator.Intn(scope)-scope/2),
	)
}
Пример #12
0
func TestUpdatePlanetShipCount(t *testing.T) {
	var spmSize3 float64
	var maxPlanetShipMod int64
	defer func() {
		Settings.ShipsPerMinute3 = spmSize3
		Settings.PlanetMaxShipsMod = maxPlanetShipMod
		return
	}()

	spmSize3 = Settings.ShipsPerMinute3
	maxPlanetShipMod = Settings.PlanetMaxShipsMod

	Settings.ShipsPerMinute3 = 1
	Settings.PlanetMaxShipsMod = 10

	basePlanets := []Planet{
		{"ABC1231", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(-77, 57), false, 6, 3, time.Now().Unix() - 100, 170, 100, "gophie"},     //160
		{"ABC1232", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(1470, 300), false, 8, 3, time.Now().Unix() - 6000, 10, 100, "gophie"},   //100
		{"ABC1233", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(-690, -201), false, 3, 3, time.Now().Unix() - 6000, 110, 100, "gophie"}, //100
		{"ABC1234", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(1110, 200), false, 2, 3, time.Now().Unix() - 100, 50, 100, "gophie"},    //60
	}

	planetOneShipCount := basePlanets[0].GetShipCount()
	if planetOneShipCount != 140 {
		t.Error("Planet[", basePlanets[0].Key(), "] Expected", 140, "Actual ", planetOneShipCount)
	}

	planetTwoShipCount := basePlanets[1].GetShipCount()
	if planetTwoShipCount != 100 {
		t.Error("Planet[", basePlanets[1].Key(), "] Expected", 100, "Actual ", planetTwoShipCount)
	}

	planetThreeShipCount := basePlanets[2].GetShipCount()
	if planetThreeShipCount != 100 {
		t.Error("Planet[", basePlanets[2].Key(), "] Expected", 100, "Actual ", planetThreeShipCount)
	}

	planetFourShipCount := basePlanets[3].GetShipCount()
	if planetFourShipCount != 60 {
		t.Error("Planet[", basePlanets[3].Key(), "] Expected", 60, "Actual ", planetFourShipCount)
	}
}
Пример #13
0
func TestSegmentTravelTime(t *testing.T) {
	source := vec2d.New(100, 200)
	target := vec2d.New(800, 150)
	expectedTime := time.Duration(7017)
	time := calculateSegmentTravelTime(source, target, 10)

	if Settings.MissionSpeed <= 0 {
		t.Errorf("The mission speed in config is %d\n", Settings.MissionSpeed)
	}

	if time != expectedTime {
		t.Errorf(
			"CalculateSegmentTravelTime(%v, %v, 10) = %d instead of %d",
			source,
			target,
			time,
			expectedTime,
		)
	}
}
Пример #14
0
// In this example we create new vector with X=2 and Y=4,
// then we get the length and angle of it.
func ExampleVector_create() {
	vector := vec2d.New(2.0, 4.0)
	length := vector.Length()
	angle := vector.Angle()

	fmt.Printf("Vector{X: %v, Y: %v}\n", vector.X, vector.Y)
	fmt.Printf("Length: %v\n", length)
	fmt.Printf("Angle: %v\n", angle)
	// Output:
	// Vector{X: 2, Y: 4}
	// Length: 4.47213595499958
	// Angle: 63.434948822922
}
Пример #15
0
// We're able to edit our Vector by changing its X, Y, angle or length.
// Obviously, if we change X or Y, then the angle and length
// most definately will be changes, also.
func ExampleVector_edit() {
	vector := vec2d.New(2.0, 4.0)
	vector.X = 4
	length := vector.Length()
	angle := vector.Angle()

	fmt.Printf("Vector{X: %v, Y: %v}\n", vector.X, vector.Y)
	fmt.Printf("Length: %v\n", length)
	fmt.Printf("Angle: %v\n", angle)
	// Output:
	// Vector{X: 4, Y: 4}
	// Length: 5.656854249492381
	// Angle: 45
}
Пример #16
0
// Uses all player's twitter friends and tries to place the sun as
// close as possible to all of them. This of course could cause tons of
// overlapping. To solve this, we simply throw the sun somewhere far away
// from the desired point and start to move it to THE POINT, but carefully
// watching for collisions.
func GenerateSun(username string, friends []*Sun, setupData *SetupData) *Sun {
	newSun := Sun{
		Username:     username,
		Position:     vec2d.New(0, 0),
		SunTextureId: setupData.SunTextureId,
	}
	newSun.generateName(username)

	node := findHomeSolarSlot(getStartSolarSlotPosition(friends))
	node.Data = newSun.Key()
	Save(node)

	newSun.Position.X = node.Position.X
	newSun.Position.Y = node.Position.Y
	newSun.createAdjacentSlots()
	return &newSun
}
Пример #17
0
func (suite *ResponseTestSuite) SetupTest() {
	suite.conn = db.Pool.Get()
	suite.conn.Do("FLUSHDB")
	entities.Save(&planet1)
	entities.Save(&planet2)
	entities.Save(&planet3)
	entities.Save(&gophie)
	entities.Save(&panda)

	suite.request = new(Request)
	suite.request.Command = "start_mission"
	suite.request.StartPlanets = []string{"planet.GOP6720"}
	suite.request.EndPlanet = "planet.PAN6720"
	suite.request.Position = vec2d.New(2.0, 4.0)
	suite.request.Resolution = []uint64{1920, 1080}
	suite.request.Fleet = 32
	suite.request.Username = "******"
	suite.request.TwitterID = "gophie92"
	suite.request.Race = 4
	suite.request.SunTextureId = 0
	suite.request.Client = &client
	suite.request.Type = "Spy"
}
Пример #18
0
func TestAdjacentSlotsCalculation(t *testing.T) {
	testSun := Sun{
		Username: "******",
		Name:     "MORS01",
		Position: vec2d.New(0, 0),
	}

	testData := [][2]float64{
		{-9000, 0},
		{9000, 0},
		{-4500, 7794},
		{-4500, -7794},
		{4500, 7794},
		{4500, -7794},
	}

	testSlots := testSun.calculateAdjacentSlots()

	for i := 0; i < len(testData); i++ {
		if testSlots[i].Position.X != testData[i][0] || testSlots[i].Position.Y != testData[i][1] {
			t.Errorf("Left solar slot out of place. Coordinates: %s\n", testSlots[0].Position)
		}
	}
}
Пример #19
0
// Returns all transfer points this mission will ever cross
func (m *Mission) TransferPoints() AreaTransferPoints {
	result := make(AreaTransferPoints, 0, 10)

	calculateSegmentTransfers := func(source, target *vec2d.Vector) AreaTransferPoints {
		result := make(AreaTransferPoints, 0, 10)
		var baseTravelTime time.Duration

		xAxises := fillAxises(source.X, target.X)
		yAxises := fillAxises(source.Y, target.Y)

		missionVectorEquation := NewCartesianEquation(source, target)

		direction := []int8{
			axisDirection(source.X, target.X),
			axisDirection(source.Y, target.Y),
		}

		for _, axis := range xAxises {
			crossPoint := vec2d.New(float64(axis), missionVectorEquation.GetYByX(float64(axis)))
			transferPoint := &AreaTransferPoint{
				TravelTime:     calculateSegmentTravelTime(source, crossPoint, Settings.MissionSpeed),
				Direction:      direction[0],
				CoordinateAxis: 'X',
			}
			result.Append(transferPoint)
		}

		for _, axis := range yAxises {
			crossPoint := vec2d.New(missionVectorEquation.GetXByY(float64(axis)), float64(axis))
			transferPoint := &AreaTransferPoint{
				TravelTime:     calculateSegmentTravelTime(source, crossPoint, Settings.MissionSpeed),
				Direction:      direction[1],
				CoordinateAxis: 'Y',
			}
			result.Append(transferPoint)
		}
		sort.Sort(result)

		if result.Size() >= 1 {
			baseTravelTime = result[0].TravelTime
			for idx, point := range result {
				if idx != 0 {
					point.TravelTime -= baseTravelTime
					baseTravelTime += point.TravelTime
				}
			}
		}
		return result
	}

	prevWaypoint := m.Source.Position

	for _, waypoint := range m.Path {
		result.Append(calculateSegmentTransfers(prevWaypoint, waypoint)...)
		prevWaypoint = waypoint
	}

	result.Append(calculateSegmentTransfers(prevWaypoint, m.Target.Position)...)

	return result
}
Пример #20
0
func TestGeneratePlanets(t *testing.T) {
	expectedPlanets := []Planet{
		{"ABC1234", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(-77, 57), false, 6, 3, timeStamp, 10, 0, "gophie"},
		{"ABC1234", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(1470, 300), false, 8, 5, timeStamp, 10, 0, "gophie"},
		{"ABC1234", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(-690, -201), false, 3, 1, timeStamp, 10, 0, "gophie"},
		{"ABC1234", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(-1052, 648), false, 2, 8, timeStamp, 10, 0, "gophie"},
		{"ABC1234", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(1428, -1364), false, 3, 1, timeStamp, 10, 0, "gophie"},
		{"ABC1234", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(2735, 300), false, 6, 8, timeStamp, 10, 0, "gophie"},
		{"ABC1234", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(2818, -799), false, 9, 6, timeStamp, 10, 0, "gophie"},
		{"ABC1234", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(-323, 3080), false, 5, 4, timeStamp, 10, 0, "gophie"},
		{"ABC1234", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(1547, 3339), false, 1, 1, timeStamp, 10, 0, "gophie"},
		{"ABC1234", Color{0.59215686, 0.59215686, 0.59215686}, vec2d.New(-2745, -1066), false, 4, 6, timeStamp, 10, 0, "gophie"},
	}
	sun.Position = vec2d.New(500, 300)
	generatedPlanets, _ := GeneratePlanets("gophie", &sun)

	if len(generatedPlanets) != 10 {
		t.Error("Wrong planets count")
	}
	for i := 0; i < 10; i++ {
		if generatedPlanets[i].Position.X != expectedPlanets[i].Position.X {
			t.Error("X coordinate missmatch on Planet[", strconv.Itoa(i), "] Expected", expectedPlanets[i].Position.X, "Actual ", generatedPlanets[i].Position.X)
		}
		if generatedPlanets[i].Position.Y != expectedPlanets[i].Position.Y {
			t.Error("Y coordinate missmatch on Planet[", strconv.Itoa(i), "] Expected", expectedPlanets[i].Position.Y, "Actual ", generatedPlanets[i].Position.Y)
		}
		if generatedPlanets[i].Texture != expectedPlanets[i].Texture {
			t.Error("Ring offset missmatch on Planet[", strconv.Itoa(i), "] Expected", expectedPlanets[i].Texture, "Actual ", generatedPlanets[i].Texture)
		}
		if generatedPlanets[i].Size != expectedPlanets[i].Size {
			t.Error("Size missmatch on Planet[", strconv.Itoa(i), "] Expected", expectedPlanets[i].Size, "Actual ", generatedPlanets[i].Size)
		}
	}
}