raycaster/lib/main.dart

import "dart:math" as math;

import "package:flutter/material.dart";
import "package:flutter/services.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> {
  late final FocusNode _focusNode;

  double playerAngle = 0;
  double get playerDeltaX => math.cos(playerAngle) * 5;
  double get playerDeltaY => math.sin(playerAngle) * 5;

  Offset get playerDelta => Offset(playerDeltaX, playerDeltaY);

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

  @override
  void initState() {
    super.initState();
    _focusNode = FocusNode()..requestFocus();
  }

  @override
  void dispose() {
    _focusNode.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Focus(
      focusNode: _focusNode,
      onKeyEvent: (FocusNode node, value) {
        if (value is! KeyDownEvent && value is! KeyRepeatEvent) {
          return KeyEventResult.ignored;
        }

        final LogicalKeyboardKey key = value.logicalKey;
        bool handled = false;

        if (key == LogicalKeyboardKey.keyA) {
          // Move left
          playerAngle -= 0.1;
          if (playerAngle < 0) {
            playerAngle += 2 * math.pi;
          }
          handled = true;
        } else if (key == LogicalKeyboardKey.keyD) {
          // Move right
          playerAngle += 0.1;

          if (playerAngle > 2 * math.pi) {
            playerAngle -= 2 * math.pi;
          }
          handled = true;
        } else if (key == LogicalKeyboardKey.keyW) {
          // Move forward
          playerPosition += playerDelta;
          handled = true;
        } else if (key == LogicalKeyboardKey.keyS) {
          // Move backwwards
          playerPosition -= playerDelta;
          handled = true;
        }

        if (handled) {
          setState(() {});
          return KeyEventResult.handled;
        }

        return KeyEventResult.ignored;
      },
      child: CustomPaint(
        painter: PlayerPainter(
          offset: playerPosition,
          delta: playerDelta,
        ),
      ),
    );
  }
}

class PlayerPainter extends CustomPainter {
  final Offset offset;
  final Offset delta;

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

  @override
  void paint(Canvas canvas, Size size) {
    // Player dot
    canvas.drawRect(
      Rect.fromLTWH(offset.dx, offset.dy, 8, 8),
      Paint()..color = Colors.yellow,
    );

    // Player direction line
    canvas.drawLine(
      offset + const Offset(4, 4),
      offset + const Offset(4, 4) + (delta * 5),
      Paint()
        ..color = Colors.yellow
        ..strokeWidth = 2,
    );
  }

  @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;
}