func TestAccelerationProcessor(t *testing.T) {
physics := processor.DefaultPhysics()
physics.TurnCommandModifier = 1.0
physics.AccelerationCommandModifier = 1.0
acceleration_processor := processor.AccelerationCommandProcessor{Physics: &physics}
c := cmd.NewAcceleration(.5)
c2 := cmd.NewAcceleration(.2)
c.UserId = "abc123"
c2.UserId = "abc123"
accelerate := cmd.GameCommand(&c)
accelerate2 := cmd.GameCommand(&c2)
game_state := physics.NewGameState()
game_state.Vehicles = append(game_state.Vehicles, &(state.Vehicle{Owner: "abc123", Velocity: 0, IsAlive: true}))
Convey("Acceleration Processor", t, func() {
So(len(game_state.Vehicles), ShouldEqual, 1)
So(game_state.Vehicles[0].Velocity, ShouldAlmostEqual, 0, .0001)
acceleration_processor.Run(&game_state, accelerate)
So(game_state.Vehicles[0].Velocity, ShouldAlmostEqual, .5, .0001)
acceleration_processor.Run(&game_state, accelerate2)
So(game_state.Vehicles[0].Velocity, ShouldAlmostEqual, .7, .0001)
accelerate2.Command().UserId = "blach"
acceleration_processor.Run(&game_state, accelerate2)
So(game_state.Vehicles[0].Velocity, ShouldAlmostEqual, .7, .0001)
})
Convey("Test Max Speed", t, func() {
c.Value = 10000000
acceleration_processor.Run(&game_state, accelerate)
So(game_state.Vehicles[0].Velocity, ShouldBeLessThanOrEqualTo, physics.MaxVehicleVelocity)
})
Convey("Test Max negative Speed", t, func() {
c.Value = -10000000
acceleration_processor.Run(&game_state, accelerate)
So(game_state.Vehicles[0].Velocity, ShouldBeGreaterThanOrEqualTo, -1*physics.MaxVehicleVelocity)
})
}
func TestProcessorFactory(t *testing.T) {
Convey("ProcessorFactory", t, func() {
physics := processor.DefaultPhysics()
physics.TurnCommandModifier = 1.0
physics.AccelerationCommandModifier = 1.0
factory := processor.NewFactory(&physics)
t := cmd.NewTurn(1)
t_comm := cmd.GameCommand(&t)
turn_cp := factory.GetCommandProcessor(&t_comm)
So(turn_cp, ShouldHaveSameTypeAs, &processor.TurnCommandProcessor{Physics: &physics})
a := cmd.NewAcceleration(1)
a_comm := cmd.GameCommand(&a)
acceleration_cp := factory.GetCommandProcessor(&a_comm)
So(acceleration_cp, ShouldHaveSameTypeAs, &processor.AccelerationCommandProcessor{Physics: &physics})
c := cmd.NewConnect("test")
c_comm := cmd.GameCommand(&c)
connect_cp := factory.GetCommandProcessor(&c_comm)
So(connect_cp, ShouldHaveSameTypeAs, &processor.ConnectCommandProcessor{Physics: &physics})
f := cmd.NewFire()
f_comm := cmd.GameCommand(&f)
fire_cp := factory.GetCommandProcessor(&f_comm)
So(fire_cp, ShouldHaveSameTypeAs, &processor.FireCommandProcessor{Physics: &physics})
b := cmd.BaseCommand{}
b_comm := cmd.GameCommand(&b)
base_cp := factory.GetCommandProcessor(&b_comm)
So(base_cp, ShouldEqual, nil)
})
}
func TestAcceleration(t *testing.T) {
Convey("Acceleration Command", t, func() {
acceleration := cmd.NewAcceleration(.4)
So(acceleration.UniqueId, ShouldEqual, "")
So(acceleration.Subtype, ShouldEqual, cmd.Acceleration)
So(acceleration.Type, ShouldEqual, cmd.Post)
So(acceleration.Value, ShouldAlmostEqual, .4, .00001)
So(acceleration.Type, ShouldEqual, acceleration.Command().Type)
So(acceleration.Subtype, ShouldEqual, acceleration.Command().Subtype)
So(acceleration.UniqueId, ShouldEqual, acceleration.Command().UniqueId)
})
}
func main() {
var waiter sync.WaitGroup
waiter.Add(1)
//get connection to host and sets a timeout for connection when completed
conn, err := net.DialTimeout("udp", host, 1*time.Second)
// start goroutine to listen for messages
go responsePrinter(conn)
for i := 0; i < 12; i++ {
if err != nil {
log.Print(err)
} else {
var message []byte
// creates unique identifier to be returned for the packet ack
uuid := uuid.NewUUID().String()
if i == 0 {
a := cmd.NewConnect("Dan")
a.UniqueId = uuid
message, err = json.Marshal(a)
} else {
// randomly select between commands
randType := rand.Intn(2)
if randType == 0 {
a := cmd.NewTurn(.5)
a.UniqueId = uuid
message, err = json.Marshal(a)
}
if randType == 1 {
a := cmd.NewAcceleration(.5)
a.UniqueId = uuid
message, err = json.Marshal(a)
}
}
//send the message
conn.Write(message)
time.Sleep(1 * time.Millisecond)
}
}
waiter.Wait()
//clean up connection
conn.Close()
}
func TestDecodeAcceleration(t *testing.T) {
Convey("Acceleration Decode", t, func() {
formatter := encoder.JsonEncoderDecoder{Tag: "DecodeTest"}
data := cmd.NewAcceleration(.2)
data.UniqueId = "ABC123"
buffer, error := json.Marshal(data)
command, err := formatter.Decode(buffer)
acceleration := command.(*cmd.AccelerationCommand)
So(error, ShouldEqual, nil)
So(acceleration.Command().Type, ShouldEqual, cmd.Post)
So(acceleration.Command().Subtype, ShouldEqual, cmd.Acceleration)
So(err, ShouldEqual, nil)
So(acceleration.Value, ShouldAlmostEqual, .2, .000001)
So(acceleration.Command().UniqueId, ShouldEqual, "ABC123")
})
}
