Dino run in the jungle game by flutter project.

 Dino run in the jungle game by flutter project.

This code is totally free for my birthday.

main.dart

import 'package:dino_run/screens/game_over_screen.dart';
import 'package:dino_run/screens/game_play_screen.dart';
import 'package:dino_run/screens/game_start_screen.dart';
import 'package:dino_run/utils/background.dart';
import 'package:dino_run/widgets/game_utils.dart';
import 'package:flame/events.dart';
import 'package:flame/experimental.dart';
import 'package:flame/flame.dart';
import 'package:flame/game.dart';
import 'package:flame_audio/audio_pool.dart';
import 'package:flame_audio/flame_audio.dart';
import 'package:flutter/material.dart' hide Route;
import 'package:google_fonts/google_fonts.dart';

import 'actors/bat.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Flame.device.fullScreen();
  await Flame.device.setLandscape();
  final game = MainScreen();
  runApp(MaterialApp(
    debugShowCheckedModeBanner: false,
    home: Scaffold(
      body: GameWidget(
        game: game,
        overlayBuilderMap: {
          'GameUtils': (BuildContext context, MainScreen game) {
            return GameUtils(game: game);
          }
        },
      ),
    ),
  ));
}

class MainScreen extends FlameGame with HasCollisionDetection, TapDetector {
  late final RouterComponent router;
  late AudioPool jumpAudio;
  late AudioPool hitAudio;

  Vector2 gravity = Vector2(100, 170);
  bool isTapped = false;
  bool isJump = false;
  bool gameIsOver = false;
  bool showingGameScreen = false;
  bool gameStartScreen = true;

  int score = 0;
  int liveStill = 4;


  final myNewFont = GoogleFonts.pressStart2p(
      textStyle: const TextStyle(
        color: Colors.black,
        letterSpacing: 3,
      ));

  final myNewFontWhite = GoogleFonts.pressStart2p(
      textStyle:
      const TextStyle(color: Colors.white, letterSpacing: 3, fontSize: 20));

  @override
  Future<void> onLoad() async {
    super.onLoad();

    router = RouterComponent(initialRoute: 'gameStart', routes: {
      'gameStart': Route(GameStartScreen.new),
      'playGame': Route(PLayGameScreen.new),
      'gameOver': Route(GameOverScreen.new),
    });
    add(router);

    FlameAudio.bgm.initialize();
    FlameAudio.audioCache.load('music.mp3');
    jumpAudio = await AudioPool.create('audio/Jump_8.wav', maxPlayers: 1);
    hitAudio = await AudioPool.create('audio/Loose_10.wav', maxPlayers: 1);
    overlays.add('GameUtils');
  }

  @override
  void update(double dt) {
    if (gameIsOver && !showingGameScreen) {
      router.pushNamed('gameOver');
      score = 0;
      liveStill = 0;
      showingGameScreen = true;
    }
    super.update(dt);
  }

  @override
  Future<void> onTapDown(TapDownInfo info) async {
    if(!gameStartScreen){
      if (!isJump && !gameIsOver) {
        isTapped = true;
      }

      if(gameIsOver && showingGameScreen){
        router.pop();
        gameIsOver = false;
        showingGameScreen = false;
        score = 0;
        liveStill = 4;
      }
    }

    if(gameStartScreen){
      router.pushNamed('playGame');
      gameStartScreen = false;
    }
    super.onTapDown(info);
  }
}

game_utils.dart

import 'dart:async';

import 'package:flame_audio/flame_audio.dart';
import 'package:flutter/material.dart';


import '../main.dart';

class GameUtils extends StatefulWidget {
  final MainScreen game;
  const GameUtils({Key? key, required this.game}) : super(key: key);

  @override
  State<GameUtils> createState() => _GameUtilsState();
}

class _GameUtilsState extends State<GameUtils> {
  bool musicIsPlaying = false;

  @override
  void initState() {
    stateChange();
    super.initState();
  }

  void stateChange(){
    Timer.periodic(const Duration(milliseconds: 10), (timer) {
      setState(() {

      });
    });
  }

  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.transparent,
      child: Row(
        mainAxisAlignment: MainAxisAlignment.spaceEvenly,
        children: [
          IconButton(
              onPressed: () {
                if(!widget.game.gameIsOver){
                  if (!musicIsPlaying) {
                    setState(() {
                      FlameAudio.bgm.play('music.mp3');
                      musicIsPlaying = true;
                    });
                  } else if (musicIsPlaying) {
                    setState(() {
                      FlameAudio.bgm.stop();
                      musicIsPlaying = false;
                    });
                  }
                }
              },
              icon: musicIsPlaying
                  ? const Icon(
                Icons.volume_up_rounded,
                color: Colors.white,
                size: 24,
              )
                  : const Icon(
                Icons.volume_off_rounded,
                color: Colors.white,
                size: 24,
              )),
          Text(
            'score : ${widget.game.score}',
            style: widget.game.myNewFont,
          ),
          const Icon(
            Icons.heart_broken_rounded,
            color: Colors.red,
            size: 24,
          ),
          Text(
            '${widget.game.liveStill}',
            style: widget.game.myNewFont,
          ),
        ],
      ),
    );
  }
}

background.dart

import 'package:dino_run/main.dart';
import 'package:flame/components.dart';
import 'package:flame/parallax.dart';

class BackgroundScreen extends Component with HasGameRef<MainScreen>{
  late ParallaxComponent parallaxComponent1;
  late ParallaxComponent parallaxComponent2;
  @override
  Future<void> onLoad() async{
    super.onLoad();

    parallaxComponent1 = await gameRef.loadParallaxComponent([
      ParallaxImageData('bg-1.png'),
      ParallaxImageData('bg-2.png'),
      ParallaxImageData('bg-3.png'),
      ParallaxImageData('bg-4.png'),
      ParallaxImageData('bg-5.png'),
    ],
      baseVelocity: Vector2(10, 0),
        velocityMultiplierDelta: Vector2(1.6, 1)
    );

    parallaxComponent2 = await gameRef.loadParallaxComponent([
      ParallaxImageData('bg-6.png'),
    ],
        baseVelocity: Vector2(10, 0),
        fill: LayerFill.none,
        velocityMultiplierDelta: Vector2(10, 1)
    );

    add(parallaxComponent1);
    add(parallaxComponent2);
  }
}

bat.dart

import 'dart:math';

import 'package:flame/collisions.dart';
import 'package:flame/components.dart';
import 'package:flame/flame.dart';
import 'package:flame/sprite.dart';

import '../main.dart';

class ActorBat1 extends SpriteAnimationComponent
    with HasGameRef<MainScreen>, CollisionCallbacks {
  late SpriteAnimationComponent bat;
  late SpriteAnimation batAnimation;

  late SpriteAnimationComponent bird;
  late SpriteAnimation birdAnimation;

  late SpriteAnimationComponent tree;
  late SpriteAnimation treeAnimation;

  late SpriteAnimationComponent mushroom;
  late SpriteAnimation mushroomAnimation;

  late SpriteAnimationComponent rino;
  late SpriteAnimation rinoAnimation;

  double speed = 250;

  @override
  Future<void> onLoad() async {
    await super.onLoad();

    final batSpriteSheet = SpriteSheet(
        image: await Flame.images.load('Flying (46x30)bat.png'),
        srcSize: Vector2(46, 30));
    batAnimation = batSpriteSheet.createAnimation(row: 0, stepTime: 0.1, to: 7);

    final treeSpriteSheet = SpriteSheet(
        image: await Flame.images.load('Idle (44x42)tree.png'),
        srcSize: Vector2(44, 42));
    treeAnimation =
        treeSpriteSheet.createAnimation(row: 0, stepTime: 0.1, to: 11);

    final mushroomSpriteSheet = SpriteSheet(
        image: await Flame.images.load('Run (32x32)mushroom.png'),
        srcSize: Vector2(32, 32));
    mushroomAnimation =
        mushroomSpriteSheet.createAnimation(row: 0, stepTime: 0.1, to: 16);

    final rinoSpriteSheet = SpriteSheet(
        image: await Flame.images.load('Run (52x34)rino.png'),
        srcSize: Vector2(52, 34));
    rinoAnimation =
        rinoSpriteSheet.createAnimation(row: 0, stepTime: 0.1, to: 6);

    SpriteAnimationComponent();

    animation = mushroomAnimation;
    size = Vector2(100, 100);
    position = Vector2(300, gameRef.size.y - 110 - 15);



    add(
      RectangleHitbox.relative(
        Vector2.all(0.7),
        parentSize: size,
        position: Vector2(x * 0.1, y * 0.2) / 2,
      ),
    );
  }


  @override
  void update(double dt) {

    x -= speed * dt;
    if (x < -1) {
      x = gameRef.size.x;

      int actorNumber = Random().nextInt(4);

      switch (actorNumber) {
        case 1:
          animation = treeAnimation;
          break;
        case 2:
          animation = rinoAnimation;
          break;
        case 3:
          animation = mushroomAnimation;
          break;
      }
    }
    super.update(dt);
  }
}

bat2.dart

import 'dart:math';

import 'package:flame/collisions.dart';
import 'package:flame/components.dart';
import 'package:flame/flame.dart';
import 'package:flame/sprite.dart';

import '../main.dart';

class ActorBat2 extends SpriteAnimationComponent
    with HasGameRef<MainScreen>, CollisionCallbacks {
  late SpriteAnimationComponent bat;
  late SpriteAnimation batAnimation;

  late SpriteAnimationComponent bird;
  late SpriteAnimation birdAnimation;

  double speed = 250;

  @override
  Future<void> onLoad() async {
    await super.onLoad();

    final batSpriteSheet = SpriteSheet(
        image: await Flame.images.load('Flying (46x30)bat.png'),
        srcSize: Vector2(46, 30));
    batAnimation = batSpriteSheet.createAnimation(row: 0, stepTime: 0.1, to: 7);

    final birdSpriteSheet = SpriteSheet(
        image: await Flame.images.load('Flying (32x32) bird.png'),
        srcSize: Vector2(32, 32));
    birdAnimation = birdSpriteSheet.createAnimation(row: 0, stepTime: 0.1, to: 9);


    SpriteAnimationComponent();
    animation = birdAnimation;
    size = Vector2(100, 100);
    position = Vector2(600, 100);

    add(
      RectangleHitbox.relative(
        Vector2.all(0.7),
        parentSize: size,
        position: Vector2(x * 0.1, y * 0.2) / 2,
      ),
    );
  }

  @override
  void update(double dt) {
    x -= speed * dt;
    if (x < -1) {
      x = gameRef.size.x;

      int actorNumber = Random().nextInt(3);

      switch (actorNumber) {
        case 1:
          animation = batAnimation;
          break;
        case 2:
          animation = birdAnimation;
          break;
      }
    }
    super.update(dt);
  }
}

dino.dart

import 'package:dino_run/main.dart';
import 'package:flame/collisions.dart';
import 'package:flame/components.dart';
import 'package:flame/flame.dart';
import 'package:flame/sprite.dart';
import 'package:flame_audio/audio_pool.dart';
import 'package:flame_audio/flame_audio.dart';

import 'dart:async';

import 'bat.dart';
import 'bat2.dart';
import 'obstacle.dart';

class MyDino extends SpriteAnimationComponent
    with HasGameRef<MainScreen>, CollisionCallbacks {

  late SpriteAnimation dinoAnimation;
  late SpriteAnimation hitAnimation;
  late SpriteAnimationComponent spriteComponent;

  bool isRunning = true;

  double speedY = 0.0;
  double gravity = 1000;
  double yMax = 0.0;
  double dinoHeight = 110;
  double groundHeight = 15;

  @override
  Future<void> onLoad() async {
    super.onLoad();

    final spriteSheet = SpriteSheet(
        image: await Flame.images.load('dino_2.png'),
        srcSize: Vector2(24, 24));

    dinoAnimation = spriteSheet.createAnimation(
      row: 0,
      stepTime: 0.1,
      from: 4,
      to: 10,
    );

    hitAnimation = spriteSheet.createAnimation(
      row: 0,
      stepTime: 0.1,
      from: 14,
      to: 16,
    );

    spriteComponent = SpriteAnimationComponent();
      animation = dinoAnimation;
      position = Vector2(80, gameRef.size.y - dinoHeight - groundHeight);
      size = Vector2.all(dinoHeight);

    yMax = gameRef.size.y - dinoHeight - groundHeight;
    spriteComponent.y = speedY;

  

    add(
      RectangleHitbox.relative(
        Vector2.all(0.7),
        parentSize: size,
        position: Vector2(x * 0.3, y * 0.1) / 2,
      ),
    );
  }


  @override
  void update(double dt) {
    if(!gameRef.gameIsOver){
      speedY += gravity * dt;
      y += speedY * dt;

      gameRef.score += (60.0 * dt).toInt();

      if(!isRunning){
        animation = hitAnimation;
      }else{
        animation = dinoAnimation;
      }

      if(gameRef.liveStill < 1){
        gameRef.gameIsOver = true;
      }

      if (isGround()) {
        y = yMax;
        speedY = 0.0;
        gameRef.isJump = false;
      }

      if (gameRef.isTapped && !gameRef.isJump) {
        speedY = -600;
        gameRef.isTapped = false;
        gameRef.isJump = true;
        gameRef.jumpAudio.start();
      }
    }
    super.update(dt);
  }

  bool isGround() {
    if (y >= yMax) {
      return true;
    }
    return false;
  }

  @override
  void onCollisionStart(Set<Vector2> intersectionPoints, PositionComponent other) async {
    if(!gameRef.gameIsOver){
      if(other is ActorBat1){
        isRunning = false;
        gameRef.liveStill -= 1;
      }else if(other is ActorBat2){
        isRunning = false;
        gameRef.liveStill -= 1;
      }
      gameRef.hitAudio.start();
    }
    super.onCollisionStart(intersectionPoints, other);
  }

  @override
  void onCollisionEnd(PositionComponent other) {
    if(!gameRef.gameIsOver){
      isRunning = true;
    }
    super.onCollisionEnd(other);
  }
}

game_play_screen.dart

import 'package:dino_run/actors/bat.dart';
import 'package:flame/components.dart';

import '../actors/bat2.dart';
import '../actors/dino.dart';
import '../utils/background.dart';

class PLayGameScreen extends Component {
  @override
  Future<void> onLoad() async {
    super.onLoad();

    add(BackgroundScreen());
    add(MyDino());
    add(ActorBat1());
    add(ActorBat2());
  }
}

game_start_screen.dart

import 'package:dino_run/main.dart';
import 'package:flame/components.dart';
import 'package:flame/events.dart';
import 'package:flame/experimental.dart';
import 'package:flutter/material.dart';

class GameStartScreen extends Component with HasGameRef<MainScreen> {
  @override
  Future<void> onLoad() async {
    super.onLoad();

    add(TextComponent(
        text: 'GAME START',
        anchor: Anchor.center,
        position: gameRef.size / 2,
        textRenderer: TextPaint(
            style: const TextStyle(color: Colors.red, fontSize: 64))));
  }
}

game_over_screen.dart

import 'package:dino_run/main.dart';
import 'package:flame/components.dart';
import 'package:flutter/material.dart';

class GameOverScreen extends Component with HasGameRef<MainScreen> {
  @override
  Future<void> onLoad() async {
    super.onLoad();

    add(TextComponent(
        text: 'GAME OVER',
        anchor: Anchor.center,
        position: gameRef.size / 2,
        textRenderer: TextPaint(
            style: const TextStyle(color: Colors.red, fontSize: 64))));
  }
}