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") }) }