raycaster/lib/main.dart

import "dart:math" as math;

import "package:flutter/material.dart";

// dart format off
const List<int> map = [
   1,1,1,1,1,1,1,1,
   1,0,0,0,0,0,0,1,
   1,0,1,0,0,0,0,1,
   1,0,1,0,0,0,0,1,
   1,0,0,0,0,0,0,1,
   1,0,0,0,0,2,0,1,
   1,0,0,0,0,0,0,1,
   1,1,1,1,1,1,1,1,
];
// dart format on

const int mapX = 8;
const int mapY = 8;
const int mapSize = 32;

void main() {
  runApp(const MainApp());
}

class MainApp extends StatelessWidget {
  const MainApp({super.key});

  @override
  Widget build(BuildContext context) {
    return Directionality(
      textDirection: TextDirection.ltr,
      child: LayoutBuilder(
        builder: (context, constraints) => const Row(
          spacing: mapSize / 1,
          textDirection: TextDirection.ltr,
          children: [
            Flexible(
              child: Center(
                child: FittedBox(
                  fit: BoxFit.contain,
                  child: Stack(
                    children: [
                      Map(),
                      Player(),
                    ],
                  ),
                ),
              ),
            ),
            Flexible(child: Background()),
          ],
        ),
      ),
    );
  }
}

// * Player
class Player extends StatefulWidget {
  const new({super.key});

  @override
  State<Player> createState() => _PlayerState();
}

class _PlayerState extends State<Player> {
  double playerAngle = 0;
  double get playerDeltaX => math.cos(playerAngle) * 5;
  double get playerDeltaY => math.sin(playerAngle) * 5;

  Offset playerPosition = const Offset(1.5 * mapSize, 1.5 * mapSize);

  @override
  Widget build(BuildContext context) {
    return CustomPaint(
      painter: PlayerPainter(offset: playerPosition),
    );
  }
}

class PlayerPainter extends CustomPainter {
  final Offset offset;

  const new({
    required this.offset,
  });

  @override
  void paint(Canvas canvas, Size size) {
    final paintYelow = Paint()..color = Colors.yellow;

    canvas.drawRect(
      Rect.fromLTWH(offset.dx, offset.dy, 8, 8),
      paintYelow,
    );
  }

  @override
  bool shouldRepaint(covariant oldDelegate) => false;
  @override
  bool shouldRebuildSemantics(covariant oldDelegate) => false;
}

// * Map
class Map extends StatelessWidget {
  const new({super.key});

  @override
  Widget build(BuildContext context) {
    const double width = mapX * mapSize / 1;
    const double height = mapY * mapSize / 1;

    return const CustomPaint(
      size: Size(width, height),
      painter: MapPainter(
        mapData: map,
        mapX: mapX,
        mapY: mapY,
        tileSize: mapSize / 1,
      ),
    );
  }
}

class MapPainter extends CustomPainter {
  final List<int> mapData;
  final int mapX;
  final int mapY;
  final double tileSize;

  const new({
    required this.mapData,
    required this.mapX,
    required this.mapY,
    required this.tileSize,
  });

  @override
  void paint(Canvas canvas, Size size) {
    final paintWhite = Paint()..color = Colors.white;
    final paintBlack = Paint()..color = Colors.black;

    for (int i = 0; i < mapData.length; i++) {
      final double x = (i % mapX) * tileSize;
      final double y = (i ~/ mapX) * tileSize;

      canvas.drawRect(
        Rect.fromLTWH(x, y, tileSize - 1, tileSize - 1),
        mapData[i] == 0 ? paintBlack : paintWhite,
      );
    }
  }

  @override
  bool shouldRepaint(covariant oldDelegate) => false;
  @override
  bool shouldRebuildSemantics(covariant oldDelegate) => false;
}

// * Background
class Background extends StatelessWidget {
  const new({
    super.key,
  });

  @override
  Widget build(BuildContext context) {
    return LayoutBuilder(
      builder: (context, constraints) => Stack(
        textDirection: TextDirection.ltr,
        children: [
          CustomPaint(
            size: constraints.biggest,
            painter: Ceiling(),
          ),
          CustomPaint(
            size: constraints.biggest,
            painter: Floor(),
          ),
        ],
      ),
    );
  }
}

class Ceiling extends CustomPainter {
  @override
  void paint(Canvas canvas, Size size) {
    final Rect rect = Offset.zero & size;
    final double halfHeight = rect.height / 2;
    final Rect topHalf = Rect.fromLTWH(
      rect.left,
      rect.top,
      rect.width,
      halfHeight,
    );

    const LinearGradient gradient = LinearGradient(
      begin: Alignment.topCenter,
      end: Alignment.bottomCenter,
      colors: [
        Color.fromRGBO(32, 32, 32, 1.0),
        Color.fromRGBO(96, 96, 96, 1.0),
      ],
      stops: [0.0, 1.0],
    );
    canvas.drawRect(
      topHalf,
      Paint()..shader = gradient.createShader(topHalf),
    );
  }

  @override
  bool shouldRepaint(covariant oldDelegate) => false;
  @override
  bool shouldRebuildSemantics(covariant oldDelegate) => false;
}

class Floor extends CustomPainter {
  @override
  void paint(Canvas canvas, Size size) {
    final Rect rect = Offset.zero & size;
    final double halfHeight = rect.height / 2;
    final Rect bottomHalf = Rect.fromLTWH(
      rect.left,
      halfHeight,
      rect.width,
      rect.bottom,
    );

    const LinearGradient gradient = LinearGradient(
      begin: Alignment.topCenter,
      end: Alignment.bottomCenter,
      colors: [
        Color.fromRGBO(32, 32, 0, 1.0),
        Color.fromRGBO(96, 96, 0, 1.0),
      ],
      stops: [0.0, 1.0],
    );
    canvas.drawRect(
      bottomHalf,
      Paint()..shader = gradient.createShader(bottomHalf),
    );
  }

  @override
  bool shouldRepaint(covariant oldDelegate) => false;
  @override
  bool shouldRebuildSemantics(covariant oldDelegate) => false;
}