(simulation) object & exact score computation & we can run w/o gui

Author: AkselsLedins

config/config.go

@@ -20,13 +20,8 @@ type uiConfig struct {
 	VehicleDefaultColor color.RGBA
 }
 
-type simulationConfig struct {
-	Bonus int
-}
-
 type config struct {
-	UI         uiConfig
-	Simulation simulationConfig
+	UI uiConfig
 }
 
 var Config config
@@ -39,6 +34,4 @@ func init() {
 	Config.UI.VehicleDefaultColor = colornames.Red
 	Config.UI.GridColor = colornames.Gray
 	Config.UI.WindowTitle = "Google Hashcode 2018 - Simulator!"
-
-	Config.Simulation.Bonus = 2
 }

ghashcode/trip.go

@@ -107,9 +107,9 @@ func (t *Trip) SomeoneIsOnIt() {
 // StartTrip takes the current step as parameter
 // if we start it on time we earn the bonus points
 // a different color is assigned if we start it on time or not
-func (t *Trip) StartTrip(step int) {
+func (t *Trip) StartTrip(step int, bonus int16) {
 	if step == int(t.EarliestStart) {
-		t.Bonus += config.Config.Simulation.Bonus
+		t.Bonus += int(bonus)
 		t.Color = colornames.Gold
 		return
 	}
@@ -121,6 +121,7 @@ func (t *Trip) StartTrip(step int) {
 // a different is assigned if we end it on time or not
 func (t *Trip) Finish(step int32) int {
 	failed := false
+	// the vehicle does this even if the arrival step is later than the latest finish
 	if step > t.LatestFinish {
 		failed = true
 	}
@@ -130,6 +131,7 @@ func (t *Trip) Finish(step int32) int {
 		t.Color = colornames.Green
 		return t.Distance + t.Bonus
 	}
+	// but no points are earned by such a ride
 	t.Color = colornames.Red
 	return 0
 }

ghashcode/vehicle.go

@@ -43,32 +43,43 @@ func (v *Vehicle) AddToImd(imd *imdraw.IMDraw) {
 	imd.Line(config.Config.UI.VehicleSize)
 }
 
-func (v *Vehicle) Drive(allTrips []*Trip, step int) (score int) {
-	// it has done every of his trips
+func (v *Vehicle) Drive(allTrips []*Trip, step int, bonus int16) (score int) {
+	// until the vehicle handles all scheduled rides
 	if v.CurrentTrip >= len(v.Trips) {
 		return
 	}
 
 	tripToGoTo := allTrips[v.Trips[v.CurrentTrip]]
+	tripToGoTo.SomeoneIsOnIt()
+
+	// first, the vehicle drives from its current intersection ([0,0] at the beginning of the simulation) to the
+	// start intersection of the next ride (unless the vehicle is already in this intersection)
+	if !v.OnRide {
+		v.DriveTo(tripToGoTo.Start.X, tripToGoTo.Start.Y)
+	}
 
 	if v.OnRide {
-		tripToGoTo.StartTrip(step)
+		tripToGoTo.StartTrip(step, bonus)
+		// then, if the current step is earlier than the earliest start of the next ride,
+		// the vehicle waits until that step
 		if int32(step) < tripToGoTo.EarliestStart {
 			tripToGoTo.WarnEarly()
 			return
 		}
+
+		// then, the vehicle drives to the finish intersection
 		v.DriveOnTrip(tripToGoTo.End.X, tripToGoTo.End.Y)
 		currentX, currentY := v.GetPosition()
+
 		if currentX == tripToGoTo.End.X && currentY == tripToGoTo.End.Y {
 			score += tripToGoTo.Finish(int32(step))
+			// then, the process repeats for the next assigned ride,
 			v.NextTrip()
 			return
 		}
 		return
 	}
 
-	tripToGoTo.SomeoneIsOnIt()
-	v.DriveTo(tripToGoTo.Start.X, tripToGoTo.Start.Y)
 	return
 }
 
@@ -107,6 +118,10 @@ func (v *Vehicle) DriveOnTrip(destinationX, destinationY int32) {
 func (v *Vehicle) DriveTo(destinationX, destinationY int32) {
 	// retrieve current position
 	currentX, currentY := v.GetPosition()
+	if destinationX == currentX && destinationY == currentY {
+		v.OnRide = true
+		return
+	}
 
 	// calculate the absolute difference between the positions
 	dx := math.Abs(float64(currentX - destinationX))

main.go

@@ -23,25 +23,33 @@ var (
 	frames = 0
 	second = time.Tick(time.Second)
 
+	noGuiFlag *bool
+
 	outputFile *string
 	inputFile  *string
 
 	camPos       = pixel.ZV
 	camSpeed     = 500.0
 	camZoom      = 1.0
 	camZoomSpeed = 1.2
+
+	simulation *simulator.Simulation
 )
 
 func init() {
+	simulation = simulator.NewSimulation()
+
 	outputFile = flag.String("o", "", "Path to your result")
 	inputFile = flag.String("i", "", "Path to the exercice input")
+	noGuiFlag = flag.Bool("noGui", false, "Run the simulation without a GUI")
+
 	flag.Parse()
+
+	simulation.ParseOutputFile(*outputFile)
+	simulation.ParseInputFile(*inputFile)
 }
 
 func run() {
-	vehicles := simulator.ParseOutputFile(*outputFile)
-	trips := simulator.ParseInputFile(*inputFile)
-
 	cfg := pixelgl.WindowConfig{
 		Title:  config.Config.UI.WindowTitle,
 		Bounds: pixel.R(0, 0, 1024, 720),
@@ -53,19 +61,20 @@ func run() {
 
 	tick := time.Tick(6 * time.Millisecond)
 
-	score := 0
-	step := 0
-	lastStep := 0
 	imd := imdraw.New(nil)
 	last := time.Now()
-	for !win.Closed() {
+
+	for !win.Closed() && !simulation.Ended {
 		imd.Clear()
 		frames++
 		dt := time.Since(last).Seconds()
 		last = time.Now()
 
 		cam := pixel.IM.Scaled(camPos, camZoom).Moved(win.Bounds().Center().Sub(camPos))
 		win.SetMatrix(cam)
+		if win.JustPressed(pixelgl.KeySpace) {
+			simulation.Toggle()
+		}
 		if win.Pressed(pixelgl.KeyLeft) {
 			camPos.X -= camSpeed * dt
 		}
@@ -80,41 +89,42 @@ func run() {
 		}
 		camZoom *= math.Pow(camZoomSpeed, win.MouseScroll().Y)
 
-		step++
 		select {
 		case <-tick:
 			win.Clear(colornames.Black)
-			for _, trip := range trips {
-				trip.AddToImd(imd)
-			}
-			for _, vehicle := range vehicles {
-				if !vehicle.Enabled {
-					continue
-				}
-				if lastStep != step {
-					score += vehicle.Drive(trips, step)
-				}
-				vehicle.AddToImd(imd)
-			}
+
+			simulation.Run(imd)
+
 			imd.Draw(win)
 
-			if lastStep != step {
-				lastStep = step
-			}
 		case <-second:
 			win.SetTitle(fmt.Sprintf("%s | FPS: %d", cfg.Title, frames))
 			frames = 0
 		}
 
 		win.SetMatrix(pixel.IM)
-		ui.DrawStepNumber(win, step)
-		ui.DrawScore(win, score)
-		ui.DrawNumberOfVehicles(win, len(vehicles))
-		ui.DrawNumberOfTrips(win, len(trips))
+		ui.DrawStepNumber(win, simulation.Step)
+		ui.DrawScore(win, simulation.Score)
+		ui.DrawNumberOfVehicles(win, len(simulation.Vehicles))
+		ui.DrawNumberOfTrips(win, len(simulation.Trips))
 		win.Update()
 	}
+
+	fmt.Printf("Score: %d\n", simulation.Score)
+}
+
+func noGui() {
+	simulation.Start()
+	for !simulation.Ended {
+		simulation.Run(nil)
+	}
+	fmt.Printf("Score: %d in %d steps\n", simulation.Score, simulation.Step)
 }
 
 func main() {
+	if *noGuiFlag == true {
+		noGui()
+		return
+	}
 	pixelgl.Run(run)
 }