Add notes

LinwoodDev · Sep 7, 2024 · 1ee2476 · 1ee2476
1 parent 59b54d5
commit 1ee2476
Show file tree

Hide file tree

Showing 18 changed files with 752 additions and 17 deletions.
diff --git a/api/lib/src/event/event.mapper.dart b/api/lib/src/event/event.mapper.dart
@@ -1797,6 +1797,8 @@ class HybridWorldEventMapper extends SubClassMapperBase<HybridWorldEvent> {
       CellItemsClearedMapper.ensureInitialized();
       TableRenamedMapper.ensureInitialized();
       TableRemovedMapper.ensureInitialized();
+      NoteChangedMapper.ensureInitialized();
+      NoteRemovedMapper.ensureInitialized();
     }
     return _instance!;
   }
@@ -3260,6 +3262,234 @@ class _TableRemovedCopyWithImpl<$R, $Out>
       _TableRemovedCopyWithImpl($value, $cast, t);
 }
 
+class NoteChangedMapper extends SubClassMapperBase<NoteChanged> {
+  NoteChangedMapper._();
+
+  static NoteChangedMapper? _instance;
+  static NoteChangedMapper ensureInitialized() {
+    if (_instance == null) {
+      MapperContainer.globals.use(_instance = NoteChangedMapper._());
+      HybridWorldEventMapper.ensureInitialized().addSubMapper(_instance!);
+    }
+    return _instance!;
+  }
+
+  @override
+  final String id = 'NoteChanged';
+
+  static String _$name(NoteChanged v) => v.name;
+  static const Field<NoteChanged, String> _f$name = Field('name', _$name);
+  static String _$content(NoteChanged v) => v.content;
+  static const Field<NoteChanged, String> _f$content =
+      Field('content', _$content);
+
+  @override
+  final MappableFields<NoteChanged> fields = const {
+    #name: _f$name,
+    #content: _f$content,
+  };
+
+  @override
+  final String discriminatorKey = 'type';
+  @override
+  final dynamic discriminatorValue = 'NoteChanged';
+  @override
+  late final ClassMapperBase superMapper =
+      HybridWorldEventMapper.ensureInitialized();
+
+  static NoteChanged _instantiate(DecodingData data) {
+    return NoteChanged(data.dec(_f$name), data.dec(_f$content));
+  }
+
+  @override
+  final Function instantiate = _instantiate;
+
+  static NoteChanged fromMap(Map<String, dynamic> map) {
+    return ensureInitialized().decodeMap<NoteChanged>(map);
+  }
+
+  static NoteChanged fromJson(String json) {
+    return ensureInitialized().decodeJson<NoteChanged>(json);
+  }
+}
+
+mixin NoteChangedMappable {
+  String toJson() {
+    return NoteChangedMapper.ensureInitialized()
+        .encodeJson<NoteChanged>(this as NoteChanged);
+  }
+
+  Map<String, dynamic> toMap() {
+    return NoteChangedMapper.ensureInitialized()
+        .encodeMap<NoteChanged>(this as NoteChanged);
+  }
+
+  NoteChangedCopyWith<NoteChanged, NoteChanged, NoteChanged> get copyWith =>
+      _NoteChangedCopyWithImpl(this as NoteChanged, $identity, $identity);
+  @override
+  String toString() {
+    return NoteChangedMapper.ensureInitialized()
+        .stringifyValue(this as NoteChanged);
+  }
+
+  @override
+  bool operator ==(Object other) {
+    return NoteChangedMapper.ensureInitialized()
+        .equalsValue(this as NoteChanged, other);
+  }
+
+  @override
+  int get hashCode {
+    return NoteChangedMapper.ensureInitialized().hashValue(this as NoteChanged);
+  }
+}
+
+extension NoteChangedValueCopy<$R, $Out>
+    on ObjectCopyWith<$R, NoteChanged, $Out> {
+  NoteChangedCopyWith<$R, NoteChanged, $Out> get $asNoteChanged =>
+      $base.as((v, t, t2) => _NoteChangedCopyWithImpl(v, t, t2));
+}
+
+abstract class NoteChangedCopyWith<$R, $In extends NoteChanged, $Out>
+    implements HybridWorldEventCopyWith<$R, $In, $Out> {
+  @override
+  $R call({String? name, String? content});
+  NoteChangedCopyWith<$R2, $In, $Out2> $chain<$R2, $Out2>(Then<$Out2, $R2> t);
+}
+
+class _NoteChangedCopyWithImpl<$R, $Out>
+    extends ClassCopyWithBase<$R, NoteChanged, $Out>
+    implements NoteChangedCopyWith<$R, NoteChanged, $Out> {
+  _NoteChangedCopyWithImpl(super.value, super.then, super.then2);
+
+  @override
+  late final ClassMapperBase<NoteChanged> $mapper =
+      NoteChangedMapper.ensureInitialized();
+  @override
+  $R call({String? name, String? content}) => $apply(FieldCopyWithData(
+      {if (name != null) #name: name, if (content != null) #content: content}));
+  @override
+  NoteChanged $make(CopyWithData data) => NoteChanged(
+      data.get(#name, or: $value.name), data.get(#content, or: $value.content));
+
+  @override
+  NoteChangedCopyWith<$R2, NoteChanged, $Out2> $chain<$R2, $Out2>(
+          Then<$Out2, $R2> t) =>
+      _NoteChangedCopyWithImpl($value, $cast, t);
+}
+
+class NoteRemovedMapper extends SubClassMapperBase<NoteRemoved> {
+  NoteRemovedMapper._();
+
+  static NoteRemovedMapper? _instance;
+  static NoteRemovedMapper ensureInitialized() {
+    if (_instance == null) {
+      MapperContainer.globals.use(_instance = NoteRemovedMapper._());
+      HybridWorldEventMapper.ensureInitialized().addSubMapper(_instance!);
+    }
+    return _instance!;
+  }
+
+  @override
+  final String id = 'NoteRemoved';
+
+  static String _$name(NoteRemoved v) => v.name;
+  static const Field<NoteRemoved, String> _f$name = Field('name', _$name);
+
+  @override
+  final MappableFields<NoteRemoved> fields = const {
+    #name: _f$name,
+  };
+
+  @override
+  final String discriminatorKey = 'type';
+  @override
+  final dynamic discriminatorValue = 'NoteRemoved';
+  @override
+  late final ClassMapperBase superMapper =
+      HybridWorldEventMapper.ensureInitialized();
+
+  static NoteRemoved _instantiate(DecodingData data) {
+    return NoteRemoved(data.dec(_f$name));
+  }
+
+  @override
+  final Function instantiate = _instantiate;
+
+  static NoteRemoved fromMap(Map<String, dynamic> map) {
+    return ensureInitialized().decodeMap<NoteRemoved>(map);
+  }
+
+  static NoteRemoved fromJson(String json) {
+    return ensureInitialized().decodeJson<NoteRemoved>(json);
+  }
+}
+
+mixin NoteRemovedMappable {
+  String toJson() {
+    return NoteRemovedMapper.ensureInitialized()
+        .encodeJson<NoteRemoved>(this as NoteRemoved);
+  }
+
+  Map<String, dynamic> toMap() {
+    return NoteRemovedMapper.ensureInitialized()
+        .encodeMap<NoteRemoved>(this as NoteRemoved);
+  }
+
+  NoteRemovedCopyWith<NoteRemoved, NoteRemoved, NoteRemoved> get copyWith =>
+      _NoteRemovedCopyWithImpl(this as NoteRemoved, $identity, $identity);
+  @override
+  String toString() {
+    return NoteRemovedMapper.ensureInitialized()
+        .stringifyValue(this as NoteRemoved);
+  }
+
+  @override
+  bool operator ==(Object other) {
+    return NoteRemovedMapper.ensureInitialized()
+        .equalsValue(this as NoteRemoved, other);
+  }
+
+  @override
+  int get hashCode {
+    return NoteRemovedMapper.ensureInitialized().hashValue(this as NoteRemoved);
+  }
+}
+
+extension NoteRemovedValueCopy<$R, $Out>
+    on ObjectCopyWith<$R, NoteRemoved, $Out> {
+  NoteRemovedCopyWith<$R, NoteRemoved, $Out> get $asNoteRemoved =>
+      $base.as((v, t, t2) => _NoteRemovedCopyWithImpl(v, t, t2));
+}
+
+abstract class NoteRemovedCopyWith<$R, $In extends NoteRemoved, $Out>
+    implements HybridWorldEventCopyWith<$R, $In, $Out> {
+  @override
+  $R call({String? name});
+  NoteRemovedCopyWith<$R2, $In, $Out2> $chain<$R2, $Out2>(Then<$Out2, $R2> t);
+}
+
+class _NoteRemovedCopyWithImpl<$R, $Out>
+    extends ClassCopyWithBase<$R, NoteRemoved, $Out>
+    implements NoteRemovedCopyWith<$R, NoteRemoved, $Out> {
+  _NoteRemovedCopyWithImpl(super.value, super.then, super.then2);
+
+  @override
+  late final ClassMapperBase<NoteRemoved> $mapper =
+      NoteRemovedMapper.ensureInitialized();
+  @override
+  $R call({String? name}) =>
+      $apply(FieldCopyWithData({if (name != null) #name: name}));
+  @override
+  NoteRemoved $make(CopyWithData data) =>
+      NoteRemoved(data.get(#name, or: $value.name));
+
+  @override
+  NoteRemovedCopyWith<$R2, NoteRemoved, $Out2> $chain<$R2, $Out2>(
+          Then<$Out2, $R2> t) =>
+      _NoteRemovedCopyWithImpl($value, $cast, t);
+}
+
 class LocalWorldEventMapper extends SubClassMapperBase<LocalWorldEvent> {
   LocalWorldEventMapper._();
 

diff --git a/api/lib/src/event/hybrid.dart b/api/lib/src/event/hybrid.dart
@@ -98,3 +98,17 @@ final class TableRemoved extends HybridWorldEvent with TableRemovedMappable {
 
   TableRemoved(this.name);
 }
+
+@MappableClass()
+final class NoteChanged extends HybridWorldEvent with NoteChangedMappable {
+  final String name, content;
+
+  NoteChanged(this.name, this.content);
+}
+
+@MappableClass()
+final class NoteRemoved extends HybridWorldEvent with NoteRemovedMappable {
+  final String name;
+
+  NoteRemoved(this.name);
+}
diff --git a/api/lib/src/event/process/server.dart b/api/lib/src/event/process/server.dart
@@ -233,5 +233,10 @@ WorldState? processServerEvent(
       return state.copyWith(
           tableName: state.tableName == event.name ? '' : state.tableName,
           data: state.data.removeTable(event.name));
+    case NoteChanged():
+      return state.copyWith(
+          data: state.data.setNote(event.name, event.content));
+    case NoteRemoved():
+      return state.copyWith(data: state.data.removeNote(event.name));
   }
 }
diff --git a/api/lib/src/models/data.dart b/api/lib/src/models/data.dart
@@ -23,6 +23,7 @@ const kPackBackgroundsPath = 'backgrounds';
 
 const kGameTablePath = 'tables';
 const kGameTeamPath = 'teams.json';
+const kGameNotesPath = 'notes';
 
 class QuokkaData extends ArchiveData<QuokkaData> {
   QuokkaData(super.archive, {super.state});
@@ -52,6 +53,21 @@ class QuokkaData extends ArchiveData<QuokkaData> {
 
   Iterable<String> getTables() => getAssets(kGameTablePath, true);
 
+  String? getNote(String name) {
+    final data = getAsset('$kGameNotesPath/$name.md');
+    if (data == null) return null;
+    return utf8.decode(data);
+  }
+
+  QuokkaData setNote(String name, String content) => setAsset(
+        '$kGameNotesPath/$name.md',
+        utf8.encode(content),
+      );
+
+  QuokkaData removeNote(String name) => removeAsset('$kGameNotesPath/$name.md');
+
+  Iterable<String> getNotes() => getAssets(kGameNotesPath, true);
+
   FileMetadata? getMetadata() {
     final data = getAsset(kPackMetadataPath);
     if (data == null) {

diff --git a/app/lib/bloc/world/bloc.dart b/app/lib/bloc/world/bloc.dart
@@ -86,6 +86,9 @@ class WorldBloc extends Bloc<PlayableWorldEvent, ClientWorldState> {
         data: state.data.setTable(state.table, state.tableName),
       ));
     });
+    on<DrawerViewChanged>((event, emit) {
+      emit(state.copyWith(drawerView: event.view));
+    });
   }
 
   Future<void> save() async {

diff --git a/app/lib/bloc/world/local.dart b/app/lib/bloc/world/local.dart
@@ -1,5 +1,6 @@
 import 'package:dart_mappable/dart_mappable.dart';
 import 'package:flutter/material.dart';
+import 'package:quokka/bloc/world/state.dart';
 import 'package:quokka_api/quokka_api.dart';
 
 part 'local.mapper.dart';
@@ -49,3 +50,11 @@ final class TableSwitched extends LocalWorldEvent with TableSwitchedMappable {
 
   TableSwitched([this.name = '']);
 }
+
+@MappableClass()
+final class DrawerViewChanged extends LocalWorldEvent
+    with DrawerViewChangedMappable {
+  final DrawerView view;
+
+  DrawerViewChanged(this.view);
+}