QuenchTreeArboretum/system/wpn_waterpistol.modifier.api.wren

class Modifier {
  static id : String { "system/wpn_waterpistol.modifier" }
  static system(world: World) : System { World.get_system(world, Modifier.id) }
  static get(entity: Entity) : Data { Mod.get(entity, Modifier.id) }
  construct new(world: World) {
    _world = world
    _block = World.get_modifier_block(_world, Modifier.id)
  }
  world : World { _world }
  attached_count : Num { Block.count(_block) }

  init(world: World) : None {}
  pre(entity: Entity, data) : None {}
  attach(entity: Entity, data) : None {}
  detach(entity: Entity, data) : None  {}
  change(entity: Entity, change: ModifierChange) : None {}
  tick(delta: Num) : None {}

  internal_tick(delta: Num) : None {
  }

  editor_init(world: World) : None {}
  editor_pre(entity: Entity, data) : None {}
  editor_attach(entity: Entity, data) : None {}
  editor_detach(entity: Entity, data) : None {}
  editor_change(entity: Entity, change: ModifierChange) : None {}

  editor_tick(delta: Num) : None {}

  get(entity: Entity) : Data { Mod.get(entity, Modifier.id) }

  list() : List {
    var list = []
    each {|entity: Entity, unused|
      list.add(entity)
    }
    return list
  }

  each(fn: Fn) : None {
    var count = attached_count
    for(idx in 0 ... count) {
      var inst = Block.get_at(_block, idx)
      var data = Block.instance(_block, inst)
      var entity = Block.get_handle(_block, inst, HandleTag.entity)
      fn.call(entity, data)
    }
  }

  each(start: Num, count: Num, fn: Fn) : None {
    for(idx in start ... start + count) {
      var inst = Block.get_at(_block, idx)
      var data = Block.instance(_block, inst)
      var entity = Block.get_handle(_block, inst, HandleTag.entity)
      fn.call(entity, data)
    }
  }
}

class API {
  static id { Modifier.id }
  static create(entity: Entity) { Mod.create(Modifier.id, entity) }
  static has(entity: Entity) { Mod.has(Modifier.id, entity) }
  static destroy(entity: Entity) { Mod.destroy(Modifier.id, entity) }
  static get(entity: Entity) : Data { Mod.get(entity, Modifier.id) }
  static system_in(world: World) : System { World.get_system(world, Modifier.id) }
  static system(entity: Entity) : System { World.get_system(Entity.get_world(entity), Modifier.id) }
  static count(world: World) : Num { system_in(world).attached_count }
  static each(world: World, fn: Fn) : System { system_in(world).each(fn) }
  static with(world: World) : List { system_in(world).list() }
  static get : APIGet { APIGetter }
  static set : APISet { APISetter }
  static connect : APIWireConnect { APIWireConnects }
  static send : APIWireSend { APIWireSends }
}

class Fields {
  static starting_ammo : String { "starting_ammo" }
  static max_capacity : String { "max_capacity" }
  static reload_rate : String { "reload_rate" }
  static depressurize_rate : String { "depressurize_rate" }
  static current_ammo : String { "current_ammo" }
  static current_pressure : String { "current_pressure" }
}

import "luxe: world/states" for AState, States, Op
#doc="The base class for a state, and our API for accessing it"
class State is AState {
  construct create(in_name: String, in_parent: State) { super(in_name, in_parent) }
  goto_on(entity: Entity, state: State, wire: Num) {  this.goto_on(entity, state, This, wire) }
}

class APIWireSend {
  construct new() {}
}

class APIWireConnect {
  construct new() {}
}

class APIGet {
  construct new() {}
  starting_ammo(entity: Entity) : Num { Modifier.get(entity).starting_ammo }
  max_capacity(entity: Entity) : Num { Modifier.get(entity).max_capacity }
  reload_rate(entity: Entity) : Num { Modifier.get(entity).reload_rate }
  depressurize_rate(entity: Entity) : Num { Modifier.get(entity).depressurize_rate }
  current_ammo(entity: Entity) : Num { Modifier.get(entity).current_ammo }
  current_pressure(entity: Entity) : Num { Modifier.get(entity).current_pressure }
}

class APISet {
  construct new() {}
  starting_ammo(entity: Entity, value: Num) { Modifier.get(entity).starting_ammo = value }
  max_capacity(entity: Entity, value: Num) { Modifier.get(entity).max_capacity = value }
  reload_rate(entity: Entity, value: Num) { Modifier.get(entity).reload_rate = value }
  depressurize_rate(entity: Entity, value: Num) { Modifier.get(entity).depressurize_rate = value }
  current_ammo(entity: Entity, value: Num) { Modifier.get(entity).current_ammo = value }
  current_pressure(entity: Entity, value: Num) { Modifier.get(entity).current_pressure = value }
}

var APIGetter = APIGet.new()
var APISetter = APISet.new()
var APIWireSends = APIWireSend.new()
var APIWireConnects = APIWireConnect.new()

import "system/wpn_waterpistol.modifier" for Data, System
import "luxe: world/world" for World, Wire
import "luxe: world" for Entity
import "luxe: world/modifier" for Modifier as Mod, ModifierChange
import "luxe: blocks" for Block
import "luxe: io" for HandleTag