Great concept lol... is fun but had a hard time finding enemies and stuff at the start

The game didn't scale well to my resolution 2560x1440. Otherwise it was a fun experience (although i couldn't see my evo points).

Ok, so I was a little unsure about this game at the start. The controls took some getting used to. However, after a few minutes of smashing and grinding enemy cars, I went back to my car nest and noticed the upgrades I could have. I was like oooh this getting interesting. I got those tusks and fangs and mmmm I was devouring that "succulent car meat" hahaha. Over all pretty well-built game. Nice job.

Not a bad game, Besides the obvious like sounds/music I'd definitely have more of a clear objective. I didn't even know about the upgrades until I read about it in the comments, so it might be worth having a screen between the Title and the game explaining the objective. It would be nice to have a pointer that always points back to the nest so you can find it

Beyond that, I think this game would greatly benefit from zooming the camera out based on player speed. Like Sonic The Hedgehog, a major complaint was that because you were going so fast, you couldn't see what was ahead of you and would hit obstacles. This was helped in later games(Sonic Mania) by moving the camera so it was easier to spot obstacles coming, In this same kind of effort, it would help if as I got faster I could see more of the level so have a better Idea of where I was going. Either with a manual camera zoom or an automatic one like this:

```
//Here's an example of how I'd do a camera zoom based on speed
float defaultOrthoSize = 5;
float orthoMaxIncrease = 10;//defaultOrthoSize + orthoMaxIncrease is the max zoom
float forwardVelocity = 0;//This is the current velocity
float maxForwardVelocity = 10;//This is the max velocity
float targetOrthoSize = 0;//this is added to the defaultOrthoSize, should be a range from 0 to orthoMaxIncrease

//This is used to scale the speed at which the camera zooms
//don't make this too high or crashing into a wall will make the camera zoom in super fast.
//Basically at a speed of 1, when crashing into a wall and going from max Velocity to 0
//The camera will take 1 second to zoom back to defaultOrthoSize
//Making this 2 would make it take 0.5 seconds
//And making this 0.5f would make it take 2 seconds.
float zoomSpeed = 1;
void Update(){
// Some logic that updates the forwardVelocity would go here

//how close to max speed are they going?
//Clamped so that we don't over zoom
float percentageOfMaxSpeed = Mathf.Clamp((forwardVelocity/maxForwardVelocity),0,1);

//Determine how much over defaultOrthoSize we're zooming out based on the percentOfMaxSpeed
targetOrthoSize = defaultOrthoSize + (percentageOfMaxSpeed*orthoMaxIncrease);

//Smoothly scale the zoom to match the target scale.
Camera.main.orthographicSize = Mathf.MoveTowards(Camera.main.orthographicSize, targetOrthoSize, zoomSpeed * Time.deltaTime);

}
//In theory this works but try it out and see how it feels.
```

Hopefully this helps!

Pretty interesting concept and a good take on the theme. The resolution was a problem but I still had fun. Good job!

Super wacky game!
Some kind of indicator for the nest would be awesome. Is really easy to get lost with all the map spinning.
Keep on!

The concept is good. Although, I wasn't sure if the upgrades did anything. I had difficulty finding the nest, so a minimap would have been great. The reverse direction is counter intuitive to typical top down driving games.