FinalCustomDoom

OptionMenu cd_Player
{
  StaticText "========================================", CDLightBlue
  StaticText "Player"                                  , CDLightBlue
  StaticText "========================================", CDLightBlue
  StaticText ""
  StaticText "0 disables the option.", CDLightBlue
  StaticText ""

  TextField   "Weapon damage multiplier", "cd_Player:weaponDamage:Immediately"
  TextField   "Taken damage multiplier" , "cd_Player:takenDamage:Immediately"
  StaticText  ""
  NumberField "Start health"            , "cd_Player:startHealth:OnPlayerStarted"
  NumberField "Start armor"             , "cd_Player:startArmor:OnPlayerStarted"
  TextField   "Save percent"            , "cd_Player:savePercent"
  StaticText  ""
  NumberField "Max health"              , "cd_Player:maxHealth:Immediately"
  TextField   "Speed multiplier"        , "cd_Player:speedMultiplier:Immediately"
  TextField   "Jump height multiplier"  , "cd_Player:jumpMultiplier:Immediately"
  StaticText  ""
  TextField   "Friction multiplier"     , "cd_Player:friction:Immediately"
  TextField   "Self damage multiplier"  , "cd_Player:selfDamage:Immediately"
}

OptionMenu cd_Actors
{
  StaticText "========================================", CDLightBlue
  StaticText "Actors"                                  , CDLightBlue
  StaticText "========================================", CDLightBlue
  StaticText ""
  StaticText "0 disables the option.", CDLightBlue
  StaticText ""

  StaticText  "Enemies"          , White
  TextField   "Health multiplier", "cd_Actors:enemyHealth:OnActorSpawned"
  NumberField "Health max"       , "cd_Actors:enemyHealthMax:OnActorSpawned"
  TextField   "Speed multiplier" , "cd_Actors:enemySpeed:OnActorSpawned"
  StaticText  ""
  StaticText  "Friends"          , White
  TextField   "Health multiplier", "cd_Actors:friendHealth:OnActorSpawned"
  NumberField "Health max"       , "cd_Actors:friendHealthMax:OnActorSpawned"
  TextField   "Speed multiplier" , "cd_Actors:friendSpeed:OnActorSpawned"
}

OptionMenu cd_Powerups
{
  StaticText "========================================", CDLightBlue
  StaticText "Permanent powerups"                      , CDLightBlue
  StaticText "========================================", CDLightBlue
  StaticText ""

  Option "Buddha"             , "cd_Powerups:buddha:Periodically"           , OnOff
  Option "Damage"             , "cd_Powerups:damage:Periodically"           , OnOff
  Option "Double firing speed", "cd_Powerups:doubleFiringSpeed:Periodically", OnOff
  Option "Drain"              , "cd_Powerups:drain:Periodically"            , OnOff
  Option "Flight"             , "cd_Powerups:flight:Periodically"           , OnOff
  Option "Frightener"         , "cd_Powerups:frightener:Periodically"       , OnOff
  Option "Ghost"              , "cd_Powerups:ghost:Periodically"            , OnOff
  Option "High jump"          , "cd_Powerups:highJump:Periodically"         , OnOff
  Option "Infinite ammo"      , "cd_Powerups:infiniteAmmo:Periodically"     , OnOff
  Option "Invisibility"       , "cd_Powerups:invisibility:Periodically"     , OnOff
  Option "Invulnerability"    , "cd_Powerups:invulnerability:Periodically"  , OnOff
  Option "IronFeet"           , "cd_Powerups:ironFeet:Periodically"         , OnOff
  Option "LightAmp"           , "cd_Powerups:lightAmp:Periodically"         , OnOff
  Option "Mask"               , "cd_Powerups:mask:Periodically"             , OnOff
  Option "Minotaur"           , "cd_Powerups:minotaur:Periodically"         , OnOff
  Option "Morph"              , "cd_Powerups:morph:Periodically"            , OnOff
  Option "Protection"         , "cd_Powerups:protection:Periodically"       , OnOff
  Option "Regeneration"       , "cd_Powerups:regeneration:Periodically"     , OnOff
  Option "Scanner"            , "cd_Powerups:scanner:Periodically"          , OnOff
  Option "Shadow"             , "cd_Powerups:shadow:Periodically"           , OnOff
  Option "Speed"              , "cd_Powerups:speed:Periodically"            , OnOff
  Option "Strength"           , "cd_Powerups:strength:Periodically"         , OnOff
  Option "Targeter"           , "cd_Powerups:targeter:Periodically"         , OnOff
  Option "Time freeze"        , "cd_Powerups:timeFreeze:Periodically"       , OnOff
  Option "Torch"              , "cd_Powerups:torch:Periodically"            , OnOff
  Option "Weapon level 2"     , "cd_Powerups:weaponLevel2:Periodically"     , OnOff
}

OptionMenu cd_HealthRegeneration
{
  StaticText "========================================", CDLightBlue
  StaticText "Health Regeneration"                     , CDLightBlue
  StaticText "========================================", CDLightBlue
  StaticText ""
  StaticText "0 disables the option.", CDLightBlue
  StaticText ""

  NumberField "Amount", "cd_HealthRegeneration:amount:Periodically"
  Option      "Type"  , "cd_HealthRegeneration:type", cd_RegenerationType
  NumberField "Period (seconds)", "cd_HealthRegeneration:period"
  StaticText  ""
  NumberField "Min", "cd_HealthRegeneration:min"
  NumberField "Max", "cd_HealthRegeneration:max"
  StaticText  ""
  Textfield   "Sound effect volume"    , "cd_HealthRegeneration:sound"
  TextField   "Visual effect intensity", "cd_HealthRegeneration:visual"
  ColorPicker "Visual effect color"    , "cd_HealthRegeneration:color"
}

OptionMenu cd_ArmorRegeneration
{
  StaticText "========================================", CDLightBlue
  StaticText "$Armor Regeneration"                     , CDLightBlue
  StaticText "========================================", CDLightBlue
  StaticText ""
  StaticText "0 disables the option.", CDLightBlue
  StaticText ""

  NumberField "Amount", "cd_ArmorRegeneration:amount:Periodically"
  Option      "Type"  , "cd_ArmorRegeneration:type", cd_RegenerationType
  NumberField "Period (seconds)", "cd_ArmorRegeneration:period"
  StaticText  ""
  NumberField "Min", "cd_ArmorRegeneration:min"
  NumberField "Max", "cd_ArmorRegeneration:max"
  StaticText  ""
  TextField   "Sound effect volume"    , "cd_ArmorRegeneration:sound"
  TextField   "Visual effect intensity", "cd_ArmorRegeneration:visual"
  ColorPicker "Visual effect color"    , "cd_ArmorRegeneration:color"
}

OptionMenu cd_AmmoRegeneration
{
  StaticText "========================================", CDLightBlue
  StaticText "Ammo Regeneration"                       , CDLightBlue
  StaticText "========================================", CDLightBlue
  StaticText ""
  StaticText "0 disables the option.", CDLightBlue
  StaticText ""

  NumberField "Amount"           , "cd_AmmoRegeneration:amount:Periodically"
  NumberField "Period (seconds)" , "cd_AmmoRegeneration:period"
  Option      "Backpack required", "cd_AmmoRegeneration:backpackRequired", OnOff
  StaticText  ""
  TextField   "Sound effect volume"    , "cd_AmmoRegeneration:sound"
  TextField   "Visual effect intensity", "cd_AmmoRegeneration:visual"
  ColorPicker "Visual effect color"    , "cd_AmmoRegeneration:color"
}

AddOptionMenu OptionsMenu       { Submenu "$cd_Title", cd_Menu }
AddOptionMenu OptionsMenuSimple { Submenu "$cd_Title", cd_Menu }

OptionMenu cd_Menu protected
{
  Class cd_Menu
  cd_PlainTranslator
  StaticText "========================================", CDLightBlue
  StaticText "$cd_Title"                               , CDLightBlue
  StaticText "========================================", CDLightBlue
  StaticText ""

  Submenu    "Player"  , cd_Player
  Submenu    "Actors"  , cd_Actors
  Submenu    "Powerups", cd_Powerups
  StaticText ""
  StaticText "Regeneration/Degeneration", White
  Submenu    "Health"  , cd_HealthRegeneration
  Submenu    "Armor"   , cd_ArmorRegeneration
  Submenu    "Ammo"    , cd_AmmoRegeneration
  StaticText ""
  Submenu    "Commands", cd_Commands
}

OptionValue cd_RegenerationType
{
  0, "$cd_Regeneration"
  1, "$cd_Degeneration"
}

CDLightBlue { #111111 #99CCFF }

// Translation note: most FCD menu items have their strings written in plain English
// and not as $, but are still translatable, for example:
// TextField "Weapon damage multiplier" "cd_something"
// here the string identifier to translate is $cd_Weapon_damage_multiplier.
// Normal $ string identifier can be used too.

[enu default]
cd_Title = "\c[CDLightBlue]⚒\c- Final Custom Doom";
cd_Regeneration = "Regeneration";
cd_Degeneration = "Degeneration";

[ru]
cd_Weapon_damage_multiplier = "Множитель урона от оружия";

class cd_Menu : OptionMenu
{
  override void init(Menu parent, OptionMenuDescriptor descriptor)
  {
    replaceItems(descriptor.mItems);
    Super.init(parent, descriptor);
  }

  private void replaceItems(out Array<OptionMenuItem> items)
  {
    int itemsCount = items.size();
    for (int i = 0; i < itemsCount; ++i)
      items[i] = getReplacement(items[i]);
  }

  private OptionMenuItem getReplacement(OptionMenuItem item)
  {
    let itemClass = item.getClass();

    if (itemClass == 'OptionMenuItemTextField')
      return new("cd_DoubleField").init(item.mLabel, item.getAction());

    if (itemClass == 'OptionMenuItemNumberField')
      return new("cd_IntField").init(item.mLabel, item.getAction());

    if (itemClass == 'OptionMenuItemColorPicker')
      return new("cd_ColorPicker").init(item.mLabel, item.getAction());

    if (itemClass == 'OptionMenuItemOption')
    {
      let option = OptionMenuItemOption(item);
      return new("cd_Option").init(item.mLabel, item.getAction(), option.mValues);
    }

    if (itemClass == 'OptionMenuItemSubmenu')
    {
      let descriptor = MenuDescriptor.getDescriptor(item.getAction());
      replaceItems(OptionMenuDescriptor(descriptor).mItems);

      return item;
    }

    return item;
  }
}

mixin class cd_SettingItem
{
  string mTag;

  private string getSetting() const
  {
    return Dictionary.fromString(cd_settings).at(mTag);
  }

  private void setSetting(string value)
  {
    let settings = Dictionary.fromString(cd_settings);
    string oldValue = settings.at(mTag);

    double doubleValue = value.toDouble();
    if (doubleValue ~== oldValue.toDouble()) return;
    if (doubleValue < 0) return;

    if (doubleValue ~== 0)
      settings.remove(mTag);
    else
      settings.insert(mTag, value);

    Cvar.getCvar('cd_settings', players[consolePlayer]).setString(settings.toString());

    let [_1, _2, _3, when] = cd_EventHandler.parseEffect(mTag);
    if (when == cd_EventHandler.Immediately || when == cd_EventHandler.OnActorSpawned)
      EventHandler.sendNetworkEvent(string.format("%s:%s", mTag, value));
  }
}

server string cd_settings;

class cd_NumberField : OptionMenuItemTextField
{
  mixin cd_SettingItem;
  string mFormat;

  OptionMenuItem init(string label, Name command, int decimalPlaces)
  {
    mTag = command;
    mFormat = string.format("%%.%df", decimalPlaces);

    return Super.init(label, '');
  }

  override bool, string getString(int i)
  {
    if (i != 0) return false, "";

    return true, string.format(mFormat, getSetting().toDouble());
  }

  override bool setString(int i, string aString)
  {
    if (i != 0) return false;

    setSetting(string.format(mFormat, aString.toDouble()));
    return true;
  }

  override string represent()
  {
    return mEnter ? Super.represent()
                  : string.format(mFormat, getSetting().toDouble());
  }
}

class cd_DoubleField : cd_NumberField
{
  OptionMenuItem init(string label, Name command)
  {
    return Super.init(label, command, 2);
  }
}

class cd_IntField : cd_NumberField
{
  OptionMenuItem init(string label, Name command)
  {
    return Super.init(label, command, 0);
  }
}

class cd_Option : OptionMenuItemOptionBase
{
  mixin cd_SettingItem;

  OptionMenuItem init(string label, Name command, Name values)
  {
    mTag = command;
    Super.init(label, '', values, NULL, 0);
    return self;
  }

  override int getSelection()
  {
    int valuesCount = OptionValues.getCount(mValues);
    if (valuesCount <= 0) return -1;

    if (OptionValues.getTextValue(mValues, 0).length() == 0)
    {
      double value = getSetting().toDouble();
      for(int i = 0; i < valuesCount; ++i)
      {
        if (value ~== OptionValues.getValue(mValues, i)) return i;
      }
    }
    else
    {
      string value = getSetting();
      for(int i = 0; i < valuesCount; ++i)
      {
        if (value ~== OptionValues.getTextValue(mValues, i)) return i;
      }
    }

    return -1;
  }

  override void setSelection(int selection)
  {
    if (OptionValues.getCount(mValues) <= 0) return;

    if (OptionValues.getTextValue(mValues, 0).length() == 0)
      setSetting(string.format("%f", OptionValues.getValue(mValues, selection)));
    else
      setSetting(OptionValues.getTextValue(mValues, selection));
  }
}

// Uses a proxy Cvar as a hack just to reuse ColorPickerMenu code.
class cd_ColorPicker : OptionMenuItemColorPicker
{
  mixin cd_SettingItem;
  const CPF_RESET = 0x20001;

  OptionMenuItem init(string label, Name command)
  {
    mTag = command;
    return Super.init(label, 'cd_proxy_color');
  }

  override int draw(OptionMenuDescriptor desc, int y, int indent, bool selected)
  {
    drawLabel(indent, y, selected ? OptionMenuSettings.mFontColorSelection
                                  : OptionMenuSettings.mFontColor, isGrayed());

    int box_x = indent + cursorSpace();
    int box_y = y + CleanYfac_1;
    Screen.clear(box_x,
                 box_y,
                 box_x + CleanXfac_1 * 32,
                 box_y + CleanYfac_1 * OptionMenuSettings.mLinespacing,
                 getSetting().toInt() | 0xff000000);

    return indent;
  }

  override bool setValue(int i, int v)
  {
    if (i != CPF_RESET) return false;

    setSetting("");
    return true;
  }

  override bool activate()
  {
    Menu.menuSound("menu/choose");

    mCvar.setInt(getSetting().toInt());

    let desc = OptionMenuDescriptor(MenuDescriptor.getDescriptor('ColorPickerMenu'));
    let picker = new("cd_ColorPickerMenu");
    picker.mTag = mTag;
    picker.init(Menu.getCurrentMenu(), mLabel, desc, mCvar);
    picker.activateMenu();
    return true;
  }
}

// Uses a proxy Cvar as a hack just to reuse ColorPickerMenu code.
class cd_ColorPickerMenu : ColorPickerMenu
{
  mixin cd_SettingItem;

  override void onDestroy()
  {
    Super.onDestroy();
    setSetting(string.format("%d", Color(int(mRed), int(mGreen), int(mBlue))));
    mCvar.setInt(0);
  }
}

user color cd_proxy_color;

GameInfo { EventHandlers = "cd_EventHandler" }

class cd_EventHandler : StaticEventHandler
{
  enum EffecTime
  {
    Immediately,
    OnPlayerStarted,
    OnActorSpawned,
    Periodically,
    Direct,
  }

  private clearscope static int toEffectTime(string effectTime)
  {
    if (effectTime ~== "Immediately")     return Immediately;
    if (effectTime ~== "OnPlayerStarted") return OnPlayerStarted;
    if (effectTime ~== "OnActorSpawned")  return OnActorSpawned;
    if (effectTime ~== "Periodically")    return Periodically;
    if (effectTime  == "")                return Direct;

    throwAbortException("unknown effect time: %s", effectTime);
    return Direct;
  }

  // Returns class name, function name, value as a string, effect time.
  // Effect string examples:
  // cd_ExampleClass:exampleFunction:onPlayerStarted:3.5
  // cd_ExampleClass:exampleFunction:3.5
  // cd_ExampleClass:exampleFunction:onPlayerStarted
  static clearscope string, string, string, int parseEffect(string input)
  {
    Array<string> parts;
    input.split(parts, ":");

    switch (parts.size())
    {
      case 0:
      case 1: throwAbortException("no class and function in effect description");
      case 2: return parts[0], parts[1], "", Direct;
      case 3: return parts[0], parts[1], parts[2], toEffectTime(parts[2]);
      case 4: return parts[0], parts[1], parts[3], toEffectTime(parts[2]);
      default: throwAbortException("too much parts: %s", input);
    }

    return "", "", "", Direct;
  }

  private static void callByName(string className, string functionName, string value)
  {
    class<Object> aClass = className;
    if (aClass == NULL)
      throwAbortException("class %s not found", className);

    let aFunction = (Function<play void(string)>)(findFunction(aClass, functionName));
    if (aFunction == NULL)
      throwAbortException("function %s.%s not found", className, functionName);

    aFunction.call(value);
  }

  override void networkProcess(ConsoleEvent event)
  {
    if (event.name.left(2) ~== "cd")
    {
      let [className, functionName, value, when] = parseEffect(event.name);
      callByName(className, functionName, value);
    }
  }

  private void applyEffects(int effectTime)
  {
    let settings = Dictionary.fromString(cd_settings);
    for (let i = DictionaryIterator.create(settings); i.next();)
    {
      let [className, functionName, _, when] = parseEffect(i.key());
      if (when == effectTime)
        callByName(className, functionName, i.value());
    }
  }

  override void playerEntered(PlayerEvent event)
  {
    // TODO: support multiplayer?
    if (multiplayer)
      throwAbortException("Final Custom Doom doesn't support multiplayer (yet?).");

    PlayerPawn player = players[event.playerNumber].mo;

    bool isOldGame = (player.findInventory('cd_OldGameMarker') != NULL);
    if (isOldGame) return;

    player.giveInventoryType('cd_OldGameMarker');

    applyEffects(OnPlayerStarted);
    applyEffects(Immediately);
  }

  private Actor mLastSpawnedActor;

  static Actor getLastSpawnedActor()
  {
    return cd_EventHandler(find('cd_EventHandler')).mLastSpawnedActor;
  }

  override void worldThingSpawned(WorldEvent event)
  {
    if (event.thing == NULL) return;

    mLastSpawnedActor = event.thing;
    applyEffects(OnActorSpawned);
    mLastSpawnedActor = NULL;
  }

  override void worldTick()
  {
    if (level.totalTime % TICRATE == 0) applyEffects(Periodically);
  }
}

class cd_OldGameMarker : Inventory
{
  Default
  {
    inventory.maxAmount 1;
    +inventory.untossable;
  }
}

class cd_EffectsBase play
{
  enum GenerationType
  {
    Regeneration,
    Degeneration
  }

  const BLEND_DURATION = TICRATE / 2;

  protected static PlayerPawn pawn()
  {
    return players[consolePlayer].mo;
  }

  protected static readonly<PlayerPawn> defaultPawn()
  {
    return getDefaultByType(pawn().getClass());
  }

  // 0 to 1 multipliers: 0.0 acts as 1.0, both meaning it effectively does nothing.
  protected static double as0to1Multiplier(string stringValue)
  {
    double value = stringValue.toDouble();
    return (value ~== 0.0) ? 1.0 : value;
  }

  protected static bool isMyTime(int period)
  {
    return (period != 0) && ((level.totalTime / TICRATE) % period == 0);
  }

  protected static void playSound(string sound, double volume)
  {
    if (volume != 0.0) pawn().a_startSound(sound, CHAN_AUTO, 0, volume);
  }

  protected static void flashColor(double intensity, int aColor)
  {
    if (intensity != 0.0) pawn().a_setBlend(aColor, intensity, BLEND_DURATION);
  }

  protected static int getNew(int old, int target, int min, int max)
  {
    if (min == 0) min = 1;
    if (max == 0) max = max(old, target);
    if (!(min <= old && old <= max)) return old;

    return clamp(target, min, max);
  }

  protected static string getSetting(string setting)
  {
    return Dictionary.fromString(cd_settings).at(setting);
  }
}