@version 1

# Battlechain : Decentralized turn based battle game 

# max players number : 1000


# reset action points daily at midnight
# action points can be used for : attack , heal , feed and many more coming ...
# the reset is read and consumed when player do their first action of the day ( new day find)
actions triggered_by: interval, at: "0 0 * * *" do
  
  current_day = State.get("day",1)
  State.set("day", current_day + 1 )

end

# end turn every 5 minutes 
# player can do only one action per turn
actions triggered_by: interval, at: "*/5 * * * *" do
  
  current_turn = State.get("turn",1)
  State.set("turn", current_turn + 1 )

end



# resurrect all archmon every hour
actions triggered_by: interval, at: "0 * * * *" do
  
  current_rez_round = State.get("rez_round",1)
  State.set("rez_round", current_rez_round + 1)

end


condition triggered_by: transaction, on: add_player(), as: [
  content:  ( 
      player = get_player(Chain.get_genesis_address(transaction.address))
      player == nil
   )
]

actions triggered_by: transaction, on: add_player() do

  player_genesis_address_hex = Chain.get_genesis_address(transaction.address)
  base_health = 10
  base_power = 2

  archmon = [ 
    level: 1,
    xp: 0,
    base_health: base_health,
    base_power: base_power,
    health: base_health,
    power: base_power,
    is_ko: false
  ]


  player = [
    action_points: 10,
    consumed_day: State.get("day",1),
    consumed_rez_round: State.get("rez_round",1),
    consumed_turn: State.get("turn",1) - 1 ,
    last_action: nil,
    archmon: archmon
  ]

  players = State.get("players", Map.new())
  players = Map.set(players,player_genesis_address_hex, player)
  
  State.set("players",players)

end

  #player_attacker = get_player(Chain.get_genesis_address(transaction.address))
      #player_defender = get_player(Chain.get_genesis_address(player_address))

      #player_attacker != nil && player_defender != nil  && !player_attacker.archmon.is_ko 
      #&& !player_defender.archmon.is_ko
      #&& player_attacker.action_points > 0

condition triggered_by: transaction, on: attack(player_address), as: [
  content:  (
            player_attacker = get_player(Chain.get_genesis_address(transaction.address))
            player_defender = get_player(Chain.get_genesis_address(String.to_hex(player_address)))

            player_attacker != nil && player_defender != nil

  )
]

actions triggered_by: transaction, on: attack(player_address) do

players = State.get("players")

  player_raw_transaction_address = transaction.address
  player_raw_genesis_address = Chain.get_genesis_address(transaction.address)

  player_attacker_previous_address = Chain.get_previous_address(transaction)
  player_attacker_genesis_address_hex = Chain.get_genesis_address(player_attacker_previous_address)

  player_defender_genesis_address_hex = Chain.get_genesis_address(String.to_hex(player_address))
  player_defender_without_hex = Chain.get_genesis_address(player_address)

   player_attacker = Map.get(players,player_attacker_genesis_address_hex)
   player_defender = Map.get(players,player_defender_genesis_address_hex)

   attacker_power = player_attacker.archmon.power
   defender_health = player_defender.archmon.health - attacker_power

action = nil

defender_archmon =  player_defender.archmon

if defender_health <= 0  do

defender_archmon = Map.set(defender_archmon,"health", 0)
defender_archmon = Map.set(defender_archmon,"is_ko", true)

action = [
  code: "ko",
  target: player_defender_genesis_address_hex
]


else

defender_archmon = Map.set(defender_archmon,"health", defender_health)

action = [
  code: "hit",
  target: player_defender_genesis_address_hex
]

end

player_defender = Map.set(player_defender,"archmon",defender_archmon )


player_attacker = Map.set(player_attacker,"last_action",action)
player_attacker = Map.set(player_attacker,"action_points", player_attacker.action_points - 1)

players = Map.set(players,player_attacker_genesis_address_hex, player_attacker)
players = Map.set(players,player_defender_genesis_address_hex, player_defender)

State.set("players", players)

Contract.set_content(Json.to_string(action))

#Contract.set_content("attack done to : #{player_address},#{player_raw_transaction_address},#{player_raw_genesis_address},#{player_defender_without_hex},#{Json.to_string(player_attacker)}")


end


condition triggered_by: transaction, on: feed(), as: [

content: (
  player = get_player(Chain.get_genesis_address(transaction.address))
      player != nil && !player.archmon.is_ko 
      && player.action_points > 0
       
)

]
actions triggered_by: transaction, on: feed() do
  players = State.get("players")
  player_genesis_address_hex = String.to_hex(Chain.get_genesis_address(transaction.address))
  player = Map.get(players,player_genesis_address_hex)
  
  archmon = player.archmon

  xp_from_feed = 20

  xp_after_feed = archmon.xp + xp_from_feed
  xp_to_next_level = get_xp_to_next_level(current_level)

  if xp_after_feed >= xp_to_next_level do

  add_xp = xp_after_feed - xp_to_next_level
  #level up
  archmon = level_up(archmon, add_xp )

  else

  archmon = Map.set(archmon,"xp", xp_after_feed)
  
  end

action = [
  code: "feed",
  target: player_genesis_address_hex
]
player = Map.set(player,"last_action", action)
player = Map.set(player,"action_points", player.action_points - 1)
player = Map.set(player,"archmon", archmon)

players = Map.set(players,player_genesis_address_hex,player)

State.set("players", players)
Contract.set_content(Json.to_string(action))

end

condition triggered_by: transaction, on: heal(), as: [
  content: (
      player = get_player(Chain.get_genesis_address(transaction.address))
      player != nil && !player.archmon.is_ko 
      && player.action_points > 0
       
  )
]
actions triggered_by: transaction, on: heal() do
players = State.get("players")
player_genesis_address_hex = String.to_hex(Chain.get_genesis_address(transaction.address))

player = Map.get(players,player_genesis_address_hex)

archmon = player.archmon

if archmon.health + 2 < archmon.base_health do

archmon = Map.set(archmon,"health", archmon.health + 2)

else

archmon = Map.set(archmon,"health", archmon.base_health)

end


action = [
  code: "heal",
  target: player_genesis_address_hex
]


player = Map.set(player,"last_action",action)
player = Map.set(player,"action_points", player.action_points - 1 )
player = Map.set(player,"archmon",archmon)
players = Map.set(players,player_genesis_address_hex,player)

State.set("players", players)

Contract.set_content(Json.to_string(action))
  
end

condition triggered_by: transaction, on: refrech_action_points(), as: [
  content: (player = get_player(Chain.get_genesis_address(transaction.address))
      player != nil && player.consumed_day < State.get("day", 1))

]

actions triggered_by: transaction, on: refrech_action_points() do
  players = State.get("players")
  player_genesis_address_hex = String.to_hex(Chain.get_genesis_address(transaction.address))
  player = Map.get(players,player_genesis_address_hex)

 player = Map.set(player,"action_points", 10)
 player = Map.set(player,"consumed_day",State.get("day",1))

players = Map.set(players,player_genesis_address_hex, player)

State.set("players", player)
end



condition triggered_by: transaction, on: resurrect(), as: [
  content:  (
      player = get_player(Chain.get_genesis_address(transaction.address))
      player != nil && player.archmon.is_ko 
      && player.consumed_rez_round < State.get("rez_round",1)
       
   )

]



actions triggered_by: transaction, on: resurrect() do
  players = State.get("players")
  player_genesis_address_hex = String.to_hex(Chain.get_genesis_address transaction.address)
  player = Map.get(players,player_genesis_address_hex )

  
  Map.set(player.archmon, "health", player.archmon.base_health)

  Map.set(player,"consumed_rez_round", State.get("rez_round",1))
  
  Map.set(players,player_genesis_address_hex,player)
  State.set("players",players)

end

fun save_action(player,action) do

  Map.set(player,"last_action",action)
  Map.set(player,"action_points", player.action_points - 1)


  player

end

fun level_up(archmon,add_xp) do

 archmon = Map.set(archmon,"base_health", archmon.base_health + 5)
 archmon = Map.set(archmon,"health", archmon.base_health + 5)

 archmon = Map.set(archmon,"base_power", archmon.base_power + 1)
 archmon = Map.set(archmon,"power", archmon.base_power + 1)

 archmon = Map.set(archmon,"level", archmon.level + 1)
 archmon = Map.set(archmon,"xp",add_xp)

 archmon

end

fun get_xp_to_next_level(current_level) do

 
  Math.pow(current_level, 2) * 10

end



fun is_known(player_genesis_address) do 
players = State.get("players", Map.new())

 player = Map.get(players, player_genesis_address)

 player != nil

end

fun get_player(player_genesis_address) do

#player_genesis_address = String.to_hex(player_genesis_address)
players = State.get("players", Map.new())

 Map.get(players, player_genesis_address, nil)

end

export fun get_player_info(player_genesis_address) do
  player_genesis_address = String.to_hex(player_genesis_address)

  players = State.get("players", Map.new())


  Map.get(players, player_genesis_address, nil)


end



export fun get_archmon_info(player_genesis_address) do

player_genesis_address = String.to_hex(player_genesis_address)

players = State.get("players")

player = Map.get(players, player_genesis_address)

archmon = nil

if player do

  archmon = player.archmon

  end


  archmon

end



export fun get_last_action(player_genesis_address) do

player_genesis_address = String.to_hex(player_genesis_address)

players = State.get("players")

player = Map.get(players, player_genesis_address)

last_action = nil

if player do 

last_action = player.last_action

end

  
last_action

end