module Rattletrap.Type.Attribute.Demolish where

import qualified Rattletrap.BitGet as BitGet
import qualified Rattletrap.BitPut as BitPut
import qualified Rattletrap.Schema as Schema
import qualified Rattletrap.Type.U32 as U32
import qualified Rattletrap.Type.Vector as Vector
import qualified Rattletrap.Type.Version as Version
import qualified Rattletrap.Utility.Json as Json

data Demolish = Demolish
  { Demolish -> Bool
attackerFlag :: Bool,
    Demolish -> U32
attackerActorId :: U32.U32,
    Demolish -> Bool
victimFlag :: Bool,
    Demolish -> U32
victimActorId :: U32.U32,
    Demolish -> Vector
attackerVelocity :: Vector.Vector,
    Demolish -> Vector
victimVelocity :: Vector.Vector
  }
  deriving (Demolish -> Demolish -> Bool
(Demolish -> Demolish -> Bool)
-> (Demolish -> Demolish -> Bool) -> Eq Demolish
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Demolish -> Demolish -> Bool
== :: Demolish -> Demolish -> Bool
$c/= :: Demolish -> Demolish -> Bool
/= :: Demolish -> Demolish -> Bool
Eq, Int -> Demolish -> ShowS
[Demolish] -> ShowS
Demolish -> String
(Int -> Demolish -> ShowS)
-> (Demolish -> String) -> ([Demolish] -> ShowS) -> Show Demolish
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Demolish -> ShowS
showsPrec :: Int -> Demolish -> ShowS
$cshow :: Demolish -> String
show :: Demolish -> String
$cshowList :: [Demolish] -> ShowS
showList :: [Demolish] -> ShowS
Show)

instance Json.FromJSON Demolish where
  parseJSON :: Value -> Parser Demolish
parseJSON = String -> (Object -> Parser Demolish) -> Value -> Parser Demolish
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Json.withObject String
"Demolish" ((Object -> Parser Demolish) -> Value -> Parser Demolish)
-> (Object -> Parser Demolish) -> Value -> Parser Demolish
forall a b. (a -> b) -> a -> b
$ \Object
object -> do
    attackerFlag <- Object -> String -> Parser Bool
forall value. FromJSON value => Object -> String -> Parser value
Json.required Object
object String
"attacker_flag"
    attackerActorId <- Json.required object "attacker_actor_id"
    victimFlag <- Json.required object "victim_flag"
    victimActorId <- Json.required object "victim_actor_id"
    attackerVelocity <- Json.required object "attacker_velocity"
    victimVelocity <- Json.required object "victim_velocity"
    pure
      Demolish
        { attackerFlag,
          attackerActorId,
          victimFlag,
          victimActorId,
          attackerVelocity,
          victimVelocity
        }

instance Json.ToJSON Demolish where
  toJSON :: Demolish -> Value
toJSON Demolish
x =
    [(Key, Value)] -> Value
Json.object
      [ String -> Bool -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"attacker_flag" (Bool -> (Key, Value)) -> Bool -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Demolish -> Bool
attackerFlag Demolish
x,
        String -> U32 -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"attacker_actor_id" (U32 -> (Key, Value)) -> U32 -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Demolish -> U32
attackerActorId Demolish
x,
        String -> Bool -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"victim_flag" (Bool -> (Key, Value)) -> Bool -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Demolish -> Bool
victimFlag Demolish
x,
        String -> U32 -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"victim_actor_id" (U32 -> (Key, Value)) -> U32 -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Demolish -> U32
victimActorId Demolish
x,
        String -> Vector -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"attacker_velocity" (Vector -> (Key, Value)) -> Vector -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Demolish -> Vector
attackerVelocity Demolish
x,
        String -> Vector -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"victim_velocity" (Vector -> (Key, Value)) -> Vector -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Demolish -> Vector
victimVelocity Demolish
x
      ]

schema :: Schema.Schema
schema :: Schema
schema =
  String -> Value -> Schema
Schema.named String
"attribute-demolish" (Value -> Schema) -> Value -> Schema
forall a b. (a -> b) -> a -> b
$
    [((Key, Value), Bool)] -> Value
Schema.object
      [ (String -> Value -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"attacker_flag" (Value -> (Key, Value)) -> Value -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
Schema.boolean, Bool
True),
        (String -> Value -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"attacker_actor_id" (Value -> (Key, Value)) -> Value -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
U32.schema, Bool
True),
        (String -> Value -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"victim_flag" (Value -> (Key, Value)) -> Value -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
Schema.boolean, Bool
True),
        (String -> Value -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"victim_actor_id" (Value -> (Key, Value)) -> Value -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
U32.schema, Bool
True),
        (String -> Value -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"attacker_velocity" (Value -> (Key, Value)) -> Value -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
Vector.schema, Bool
True),
        (String -> Value -> (Key, Value)
forall value e p.
(ToJSON value, KeyValue e p) =>
String -> value -> p
Json.pair String
"victim_velocity" (Value -> (Key, Value)) -> Value -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ Schema -> Value
Schema.ref Schema
Vector.schema, Bool
True)
      ]

bitPut :: Demolish -> BitPut.BitPut
bitPut :: Demolish -> BitPut
bitPut Demolish
demolishAttribute =
  Bool -> BitPut
BitPut.bool (Demolish -> Bool
attackerFlag Demolish
demolishAttribute)
    BitPut -> BitPut -> BitPut
forall a. Semigroup a => a -> a -> a
<> U32 -> BitPut
U32.bitPut (Demolish -> U32
attackerActorId Demolish
demolishAttribute)
    BitPut -> BitPut -> BitPut
forall a. Semigroup a => a -> a -> a
<> Bool -> BitPut
BitPut.bool (Demolish -> Bool
victimFlag Demolish
demolishAttribute)
    BitPut -> BitPut -> BitPut
forall a. Semigroup a => a -> a -> a
<> U32 -> BitPut
U32.bitPut (Demolish -> U32
victimActorId Demolish
demolishAttribute)
    BitPut -> BitPut -> BitPut
forall a. Semigroup a => a -> a -> a
<> Vector -> BitPut
Vector.bitPut (Demolish -> Vector
attackerVelocity Demolish
demolishAttribute)
    BitPut -> BitPut -> BitPut
forall a. Semigroup a => a -> a -> a
<> Vector -> BitPut
Vector.bitPut (Demolish -> Vector
victimVelocity Demolish
demolishAttribute)

bitGet :: Version.Version -> BitGet.BitGet Demolish
bitGet :: Version -> BitGet Demolish
bitGet Version
version = String -> BitGet Demolish -> BitGet Demolish
forall a. String -> BitGet a -> BitGet a
BitGet.label String
"Demolish" (BitGet Demolish -> BitGet Demolish)
-> BitGet Demolish -> BitGet Demolish
forall a b. (a -> b) -> a -> b
$ do
  attackerFlag <- String -> BitGet Bool -> BitGet Bool
forall a. String -> BitGet a -> BitGet a
BitGet.label String
"attackerFlag" BitGet Bool
BitGet.bool
  attackerActorId <- BitGet.label "attackerActorId" U32.bitGet
  victimFlag <- BitGet.label "victimFlag" BitGet.bool
  victimActorId <- BitGet.label "victimActorId" U32.bitGet
  attackerVelocity <- BitGet.label "attackerVelocity" $ Vector.bitGet version
  victimVelocity <- BitGet.label "victimVelocity" $ Vector.bitGet version
  pure
    Demolish
      { attackerFlag,
        attackerActorId,
        victimFlag,
        victimActorId,
        attackerVelocity,
        victimVelocity
      }