Use conventional mixin structure for submixin pattern (#195)

Author: Bawnorton

tags/faq/mixinoverride.ytag

@@ -18,7 +18,7 @@ For mod compatibility reasons, you should not do this. Instead, you should use o
 
 // Mixin the parent, and use instanceof to check what `this` is
 @Mixin(Entity.class)
-class EntityMixin {
+abstract class EntityMixin {
   @ModifyReturnValue(
     method = "getPose",
     at = @At("RETURN")
@@ -33,26 +33,25 @@ class EntityMixin {
 
 // use submixin to conditionally modify the parent
 @Mixin(Entity.class)
-class EntityMixin {
+abstract class EntityMixin {
   // 1. define a dummy handler in a mixin to the superclass, that does nothing, but is protected
   @WrapMethod(
     method = "getPose"
   )
   protected EntityPose overrideForPlayer(Operation<EntityPose> original) {
     return original.call();
   }
-
-  @Mixin(PlayerEntity.class)
-  private static class PlayerEntityMixin extends EntityMixin /* !important! */ {
-    // 2. Override the handler in the child mixin, and make the actual changes
-    @Override
-    protected EntityPose overrideForPlayer(Operation<EntityPose> original) {
-      return EntityPose.SWIMMING;
-    }
+}
+@Mixin(PlayerEntity.class)
+abstract class PlayerEntityMixin extends EntityMixin /* !important! */ {
+  // 2. Override the handler in the child mixin, and make the actual changes
+  @Override
+  protected EntityPose overrideForPlayer(Operation<EntityPose> original) {
+    return EntityPose.SWIMMING;
   }
 }
 ```
 
 Both of the above patterns can work for any mixin injector, and even when you just need to make small changes to the superclass.
 
-The `instanceof` pattern is more direct, and can be simpler to understand, while the submixin pattern can lead to a code structure more similar to just overriding the target method and keeps all code relevant to a given class in a mixin to that class. the general agreement is that it doesn't matter which you pick; either is better than `@Override`.
+The `instanceof` pattern is more direct, and can be simpler to understand, while the submixin pattern can lead to a code structure more similar to just overriding the target method and keeps all code relevant to a given class in a mixin to that class. the general agreement is that it doesn't matter which you pick; either is better than `@Override`.