forked from Mirrors/openclonk
942 lines
24 KiB
C
942 lines
24 KiB
C
/**
|
|
Pump
|
|
Pumps liquids using drain and source pipes. Features include:
|
|
+ switch on and off
|
|
+ consume/produce a variable amount of power depending on the height of
|
|
source and drain
|
|
|
|
@author Maikel, ST-DDT, Sven2, Newton
|
|
*/
|
|
|
|
#include Library_Structure
|
|
#include Library_Ownable
|
|
#include Library_PowerConsumer
|
|
#include Library_PowerProducer
|
|
#include Library_LiquidContainer
|
|
#include Library_PipeControl
|
|
#include Library_ResourceSelection
|
|
|
|
static const PUMP_Menu_Action_Switch_On = "on";
|
|
static const PUMP_Menu_Action_Switch_Off = "off";
|
|
static const PUMP_Menu_Action_Description = "description";
|
|
|
|
|
|
local animation; // animation handle
|
|
|
|
local switched_on; // controlled by Interaction. Indicates whether the user wants to pump or not
|
|
|
|
local powered; // whether the pump has enough power as a consumer, always true if producing
|
|
local power_used; // the amount of power currently consumed or (if negative) produced
|
|
|
|
local clog_count; // increased when the pump doesn't find liquid or can't insert it. When it reaches max_clog_count, it will put the pump into temporary idle mode.
|
|
local max_clog_count = 5; // note that even when max_clog_count is reached, the pump will search through offsets (but in idle mode)
|
|
|
|
local accepted_mat; // currently accepted material.
|
|
|
|
local stored_material_name; //contained liquid
|
|
local stored_material_amount;
|
|
|
|
/** This object is a liquid pump, thus pipes can be connected. */
|
|
public func IsLiquidPump() { return true; }
|
|
public func IsLiquidContainer() { return false; }
|
|
|
|
|
|
// The pump is rather complex for players. If anything happened, tell it to the player via the interaction menu.
|
|
local last_status_message;
|
|
|
|
public func Construction()
|
|
{
|
|
// Rotate at a 45 degree angle towards viewer and add a litte bit of Random
|
|
this.MeshTransformation = Trans_Rotate(50 + RandomX(-10, 10), 0, 1, 0);
|
|
// Default selection
|
|
accepted_mat = nil;
|
|
return _inherited(...);
|
|
}
|
|
|
|
public func IsHammerBuildable() { return true; }
|
|
public func NoConstructionFlip() { return true; }
|
|
|
|
public func Initialize()
|
|
{
|
|
switched_on = true;
|
|
var start = 0;
|
|
var end = GetAnimationLength("pump");
|
|
animation = PlayAnimation("pump", 5, Anim_Linear(GetAnimationPosition(animation), start, end, 35, ANIM_Loop));
|
|
SetState("Wait");
|
|
// Let the fast pump rule know it has been created.
|
|
for (var rule in FindObjects(Find_ID(Rule_FastPump)))
|
|
rule->~OnPumpCreation(this);
|
|
return _inherited(...);
|
|
}
|
|
|
|
|
|
/*-- Interaction --*/
|
|
|
|
public func HasInteractionMenu() { return true; }
|
|
|
|
public func GetPumpControlMenuEntries(object clonk)
|
|
{
|
|
var menu_entries = [];
|
|
// default design of a control menu item
|
|
var custom_entry =
|
|
{
|
|
Right = "100%", Bottom = "2em",
|
|
BackgroundColor = {Std = 0, OnHover = 0x50ff0000},
|
|
image = {Right = "2em"},
|
|
text = {Left = "2em"}
|
|
};
|
|
|
|
// Add info message about what is going on with the pump.
|
|
var status = "$StateOk$";
|
|
var lightbulb_graphics = "Green";
|
|
if (last_status_message != nil)
|
|
{
|
|
status = last_status_message;
|
|
lightbulb_graphics = "Red";
|
|
}
|
|
PushBack(menu_entries, {symbol = this, extra_data = PUMP_Menu_Action_Description,
|
|
custom =
|
|
{
|
|
Prototype = custom_entry,
|
|
Bottom = "1.2em",
|
|
Priority = -1,
|
|
BackgroundColor = RGB(25, 100, 100),
|
|
text = {Prototype = custom_entry.text, Text = status},
|
|
image = {Prototype = custom_entry.image, Symbol = Icon_Lightbulb, GraphicsName = lightbulb_graphics}
|
|
}});
|
|
|
|
// switch on and off
|
|
if (!switched_on)
|
|
PushBack(menu_entries, GetPumpMenuEntry(custom_entry, Icon_Play, "$MsgTurnOn$", 1, PUMP_Menu_Action_Switch_On));
|
|
else
|
|
PushBack(menu_entries, GetPumpMenuEntry(custom_entry, Icon_Stop, "$MsgTurnOff$", 1, PUMP_Menu_Action_Switch_Off));
|
|
|
|
return menu_entries;
|
|
}
|
|
|
|
public func GetPumpMenuEntry(proplist custom_entry, symbol, string text, int priority, extra_data)
|
|
{
|
|
return {symbol = symbol, extra_data = extra_data,
|
|
custom =
|
|
{
|
|
Prototype = custom_entry,
|
|
Priority = priority,
|
|
text = {Prototype = custom_entry.text, Text = text},
|
|
image = {Prototype = custom_entry.image, Symbol = symbol}
|
|
}};
|
|
}
|
|
|
|
public func GetInteractionMenus(object clonk)
|
|
{
|
|
var menus = _inherited(clonk, ...) ?? [];
|
|
var control_menu =
|
|
{
|
|
title = "$Control$",
|
|
entries_callback = this.GetPumpControlMenuEntries,
|
|
callback = "OnPumpControl",
|
|
callback_hover = "OnPumpControlHover",
|
|
callback_target = this,
|
|
BackgroundColor = RGB(0, 50, 50),
|
|
Priority = 20
|
|
};
|
|
PushBack(menus, control_menu);
|
|
var materials_menu =
|
|
{
|
|
title = "$PumpMaterials$",
|
|
entries_callback = this.GetPumpMaterialsMenuEntries,
|
|
callback = "OnPumpMaterials",
|
|
callback_hover = "OnPumpMaterialsHover",
|
|
callback_target = this,
|
|
BackgroundColor = RGB(0, 50, 50),
|
|
Priority = 25
|
|
};
|
|
PushBack(menus, materials_menu);
|
|
return menus;
|
|
}
|
|
|
|
public func OnPumpControlHover(id symbol, string action, desc_menu_target, menu_id)
|
|
{
|
|
var text = "";
|
|
if (action == PUMP_Menu_Action_Switch_On) text = "$DescTurnOn$";
|
|
else if (action == PUMP_Menu_Action_Switch_Off) text = "$DescTurnOff$";
|
|
else if (action == PUMP_Menu_Action_Description) text = this.Description;
|
|
GuiUpdateText(text, menu_id, 1, desc_menu_target);
|
|
}
|
|
|
|
|
|
public func OnPumpControl(symbol_or_object, string action, bool alt)
|
|
{
|
|
if (action == PUMP_Menu_Action_Switch_On || action == PUMP_Menu_Action_Switch_Off)
|
|
ToggleOnOff(true);
|
|
|
|
UpdateInteractionMenus(this.GetPumpControlMenuEntries);
|
|
}
|
|
|
|
private func SetInfoMessage(string msg)
|
|
{
|
|
if (last_status_message == msg) return;
|
|
last_status_message = msg;
|
|
UpdateInteractionMenus(this.GetPumpControlMenuEntries);
|
|
}
|
|
|
|
static const LIBRARY_TANK_Menu_Action_Cut_AirPipe = "cutairpipe";
|
|
static const LIBRARY_TANK_Menu_Action_Add_AirPipe = "addairpipe";
|
|
|
|
// Extend liquid tank connection interface to air pipes.
|
|
public func GetPipeControlMenuEntries(object clonk)
|
|
{
|
|
var menu_entries = inherited(clonk, ...);
|
|
|
|
var drain_pipe = GetDrainPipe();
|
|
// Modify cut drain pipe menu entry for air pipe.
|
|
if (drain_pipe && !drain_pipe->QueryCutLineConnection(this) && drain_pipe->IsAirPipe())
|
|
{
|
|
for (var entry in menu_entries)
|
|
{
|
|
if (entry.extra_data == LIBRARY_TANK_Menu_Action_Cut_Drain)
|
|
{
|
|
entry.extra_data = LIBRARY_TANK_Menu_Action_Cut_AirPipe;
|
|
entry.Priority = 4;
|
|
entry.custom.image.BackgroundColor = RGB(0, 153, 255);
|
|
entry.custom.text.Text = GetConnectedPipeMessage("$MsgCutAirPipe$", GetDrainPipe());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add attach air pipe menu entry.
|
|
var air_pipe = FindAvailablePipe(clonk, Find_Func("IsAirPipe"));
|
|
if (!drain_pipe && air_pipe)
|
|
PushBack(menu_entries, GetTankMenuEntry(air_pipe, GetConnectedPipeMessage("$MsgConnectAirPipe$", air_pipe), 4, LIBRARY_TANK_Menu_Action_Add_AirPipe, RGB(0, 153, 255)));
|
|
return menu_entries;
|
|
}
|
|
|
|
public func OnPipeControlHover(symbol_or_object, string action, desc_menu_target, menu_id)
|
|
{
|
|
if (action == LIBRARY_TANK_Menu_Action_Cut_AirPipe)
|
|
{
|
|
GuiUpdateText(GetConnectedPipeDescription("$DescCutAirPipe$", GetDrainPipe()), menu_id, 1, desc_menu_target);
|
|
return;
|
|
}
|
|
if (action == LIBRARY_TANK_Menu_Action_Add_AirPipe)
|
|
{
|
|
GuiUpdateText(GetConnectedPipeDescription("$DescConnectAirPipe$", symbol_or_object), menu_id, 1, desc_menu_target);
|
|
return;
|
|
}
|
|
return inherited(symbol_or_object, action, desc_menu_target, menu_id, ...);
|
|
}
|
|
|
|
public func OnPipeControl(symbol_or_object, string action, object clonk)
|
|
{
|
|
if (action == LIBRARY_TANK_Menu_Action_Cut_AirPipe)
|
|
{
|
|
this->DoCutPipe(GetDrainPipe(), clonk);
|
|
UpdateInteractionMenus(this.GetPipeControlMenuEntries);
|
|
return;
|
|
}
|
|
if (action == LIBRARY_TANK_Menu_Action_Add_AirPipe)
|
|
{
|
|
this->DoConnectPipe(symbol_or_object, PIPE_STATE_Air);
|
|
UpdateInteractionMenus(this.GetPipeControlMenuEntries);
|
|
return;
|
|
}
|
|
return inherited(symbol_or_object, action, clonk, ...);
|
|
}
|
|
|
|
|
|
/*-- Pipe control --*/
|
|
|
|
public func QueryConnectPipe(object pipe, bool do_msg)
|
|
{
|
|
if (GetDrainPipe() && GetSourcePipe())
|
|
{
|
|
if (do_msg) pipe->Report("$MsgHasPipes$");
|
|
return true;
|
|
}
|
|
else if (pipe->IsSourcePipe() && GetSourcePipe())
|
|
{
|
|
if (do_msg) pipe->Report("$MsgSourcePipeProhibited$");
|
|
return true;
|
|
}
|
|
else if (pipe->IsDrainPipe() && GetDrainPipe())
|
|
{
|
|
if (do_msg) pipe->Report("$MsgDrainPipeProhibited$");
|
|
return true;
|
|
}
|
|
else if (pipe->IsAirPipe() && GetDrainPipe())
|
|
{
|
|
if (do_msg) pipe->Report("$MsgAirPipeProhibited$");
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
public func OnPipeConnect(object pipe, string specific_pipe_state)
|
|
{
|
|
if (PIPE_STATE_Source == specific_pipe_state)
|
|
{
|
|
SetSourcePipe(pipe);
|
|
pipe->SetSourcePipe();
|
|
pipe->Report("$MsgCreatedSource$");
|
|
}
|
|
else if (PIPE_STATE_Drain == specific_pipe_state)
|
|
{
|
|
SetDrainPipe(pipe);
|
|
pipe->SetDrainPipe();
|
|
pipe->Report("$MsgCreatedDrain$");
|
|
}
|
|
else if (PIPE_STATE_Air == specific_pipe_state)
|
|
{
|
|
// Air pipes take up the place of the drain
|
|
SetDrainPipe(pipe);
|
|
pipe->Report("$MsgCreatedAirDrain$");
|
|
}
|
|
else
|
|
{
|
|
// add a drain if we already connected a source pipe,
|
|
// or if the line is already connected to a container
|
|
var line = pipe->GetConnectedLine();
|
|
var pump_target = !line || line->GetConnectedObject(this);
|
|
if (pump_target) pump_target = pump_target->~IsLiquidContainer();
|
|
if (line->IsAirPipe())
|
|
{
|
|
OnPipeConnect(pipe, PIPE_STATE_Air);
|
|
}
|
|
else if (GetSourcePipe() || pump_target)
|
|
{
|
|
OnPipeConnect(pipe, PIPE_STATE_Drain);
|
|
}
|
|
// otherwise create a source first
|
|
else
|
|
{
|
|
OnPipeConnect(pipe, PIPE_STATE_Source);
|
|
}
|
|
}
|
|
}
|
|
|
|
public func OnPipeDisconnect(object pipe)
|
|
{
|
|
_inherited(pipe, ...);
|
|
// Stop pumping to prevent errors from Pumping() function.
|
|
if (pipe->IsAirPipe())
|
|
CheckState();
|
|
}
|
|
|
|
public func SetSourcePipe(object pipe)
|
|
{
|
|
_inherited(pipe, ...);
|
|
CheckState();
|
|
}
|
|
|
|
public func IsAirPipeConnected()
|
|
{
|
|
if (!GetDrainPipe())
|
|
return false;
|
|
return GetDrainPipe()->~IsAirPipe();
|
|
}
|
|
|
|
/*-- Power stuff --*/
|
|
|
|
public func GetConsumerPriority()
|
|
{
|
|
if (IsAirPipeConnected())
|
|
return 125;
|
|
return 25;
|
|
}
|
|
|
|
public func GetProducerPriority() { return 100; }
|
|
|
|
public func IsSteadyPowerProducer() { return true; }
|
|
|
|
public func OnNotEnoughPower()
|
|
{
|
|
powered = false;
|
|
CheckState();
|
|
return _inherited(...);
|
|
}
|
|
|
|
public func OnEnoughPower()
|
|
{
|
|
powered = true;
|
|
CheckState();
|
|
return _inherited(...);
|
|
}
|
|
|
|
// TODO: these functions may be useful in the liquid tank, maybe move it to that library
|
|
|
|
/** Returns object to which the liquid is pumped */
|
|
private func GetDrainObject()
|
|
{
|
|
var drain = GetDrainPipe();
|
|
if (drain && drain->GetConnectedLine())
|
|
return drain->GetConnectedLine()->GetConnectedObject(this) ?? this;
|
|
return this;
|
|
}
|
|
|
|
/** Returns object from which the liquid is pumped */
|
|
private func GetSourceObject()
|
|
{
|
|
var source = GetSourcePipe();
|
|
if (source && source->GetConnectedLine())
|
|
return source->GetConnectedLine()->GetConnectedObject(this) ?? this;
|
|
return this;
|
|
}
|
|
|
|
/** PhaseCall of Pump: Pump the liquid from the source to the drain pipe */
|
|
protected func Pumping()
|
|
{
|
|
// at this point we can assert that we have power
|
|
|
|
// something went wrong in the meantime?
|
|
// let the central function handle that on next check
|
|
if (!GetSourcePipe() && !IsAirPipeConnected())
|
|
return;
|
|
|
|
// Get the drain object.
|
|
var drain_obj = GetDrainObject();
|
|
|
|
// Don't do anything special if pumping air but inform the drain object.
|
|
if (IsAirPipeConnected())
|
|
{
|
|
if (!GetAirSourceOk() || !GetAirDrainOk())
|
|
return SetState("WaitForLiquid");
|
|
if (drain_obj)
|
|
drain_obj->~OnAirPumped(this);
|
|
return;
|
|
}
|
|
|
|
var pump_ok = true;
|
|
|
|
// is empty? -> try to get liquid
|
|
if (!stored_material_name)
|
|
{
|
|
// get new materials
|
|
var source_obj = GetSourceObject();
|
|
var mat = this->ExtractMaterialFromSource(source_obj, this.PumpSpeed / 10);
|
|
|
|
// no material to pump?
|
|
if (mat)
|
|
{
|
|
stored_material_name = mat[0];
|
|
stored_material_amount = mat[1];
|
|
}
|
|
else
|
|
{
|
|
source_obj->~CycleApertureOffset(this); // try different offsets, so we don't stop pumping just because 1px of earth was dropped on the source pipe
|
|
pump_ok = false;
|
|
}
|
|
}
|
|
if (pump_ok)
|
|
{
|
|
var i = stored_material_amount;
|
|
while (i > 0)
|
|
{
|
|
if (this->InsertMaterialAtDrain(drain_obj, stored_material_name, 1))
|
|
{
|
|
i--;
|
|
}
|
|
// Drain is stuck.
|
|
else
|
|
{
|
|
drain_obj->~CycleApertureOffset(this); // try different offsets, so we don't stop pumping just because 1px of earth was dropped on the drain pipe
|
|
pump_ok = false;
|
|
break;
|
|
}
|
|
}
|
|
stored_material_amount = i;
|
|
if (stored_material_amount <= 0)
|
|
stored_material_name = nil;
|
|
}
|
|
|
|
if (pump_ok)
|
|
{
|
|
clog_count = 0;
|
|
}
|
|
else
|
|
{
|
|
// Put into wait state if no liquid could be pumped for a while or if the drain has no aperture, i.e. is a liquid tank.
|
|
if (++clog_count >= max_clog_count || !drain_obj->~HasAperture())
|
|
{
|
|
SetState("WaitForLiquid");
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// interface for the extraction logic
|
|
func ExtractMaterialFromSource(object source_obj, int amount)
|
|
{
|
|
if (source_obj->~IsLiquidContainer())
|
|
{
|
|
return source_obj->RemoveLiquid(accepted_mat, amount, this);
|
|
}
|
|
else
|
|
{
|
|
var mat = source_obj->ExtractLiquidAmount(source_obj.ApertureOffsetX, source_obj.ApertureOffsetY, amount, true);
|
|
if (mat)
|
|
return [MaterialName(mat[0]), mat[1]];
|
|
}
|
|
return nil;
|
|
}
|
|
|
|
// interface for the insertion logic
|
|
public func InsertMaterialAtDrain(object drain_obj, string material_name, int amount)
|
|
{
|
|
// insert material into containers, if possible
|
|
if (drain_obj->~IsLiquidContainer())
|
|
{
|
|
amount -= drain_obj->PutLiquid(material_name, amount, this);
|
|
}
|
|
else
|
|
{
|
|
// convert to actual material, and insert remaining
|
|
var material_index = Material(material_name);
|
|
if (material_index == -1 && material_name != nil)
|
|
material_index = Material(GetDefinition(material_name)->GetLiquidMaterial());
|
|
if (material_index != -1)
|
|
{
|
|
while (amount > 0 && drain_obj->InsertMaterial(material_index, drain_obj.ApertureOffsetX, drain_obj.ApertureOffsetY))
|
|
amount--;
|
|
}
|
|
}
|
|
return amount <= 0;
|
|
}
|
|
|
|
|
|
/** Re check state and change the state if needed */
|
|
public func CheckState()
|
|
{
|
|
var is_fullcon = GetCon() >= 100;
|
|
// The pump can work without source if it needs to supply air.
|
|
var can_pump = (GetSourcePipe() || IsAirPipeConnected()) && is_fullcon && switched_on;
|
|
|
|
// Can't pump at all -> wait.
|
|
if (!can_pump)
|
|
{
|
|
if (!GetSourcePipe() && switched_on)
|
|
SetInfoMessage("$StateNoSource$");
|
|
SetState("Wait");
|
|
}
|
|
else if(IsAirPipeConnected())
|
|
{
|
|
if (!GetAirSourceOk())
|
|
{
|
|
SetInfoMessage("$StateNoAir$");
|
|
SetState("WaitForLiquid");
|
|
}
|
|
else if (!GetAirDrainOk())
|
|
{
|
|
SetInfoMessage("$StateNoAirNeed$");
|
|
SetState("WaitForLiquid");
|
|
}
|
|
else
|
|
{
|
|
// Can pump, has air but has no power -> wait for power.
|
|
if (!powered)
|
|
{
|
|
SetInfoMessage("$StateNoPower$");
|
|
SetState("WaitForPower");
|
|
}
|
|
else
|
|
{
|
|
SetInfoMessage();
|
|
clog_count = 0;
|
|
SetState("Pump");
|
|
}
|
|
UpdatePowerUsage();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Can pump but has no liquid or can't dispense liquid -> wait.
|
|
var source_mat = GetLiquidSourceMaterial();
|
|
var source_ok = IsInResourceSelection(source_mat);
|
|
var drain_ok = GetLiquidDrainOk(source_mat);
|
|
if (!source_ok || !drain_ok)
|
|
{
|
|
accepted_mat = nil;
|
|
if (!source_ok)
|
|
SetInfoMessage("$StateNoInput$");
|
|
else if (!drain_ok)
|
|
SetInfoMessage("$StateNoOutput$");
|
|
SetState("WaitForLiquid");
|
|
}
|
|
else
|
|
{
|
|
accepted_mat = source_mat;
|
|
// can pump, has liquid but has no power -> wait for power
|
|
if (!powered)
|
|
{
|
|
SetInfoMessage("$StateNoPower$");
|
|
SetState("WaitForPower");
|
|
}
|
|
// otherwise, pump! :-)
|
|
else
|
|
{
|
|
SetInfoMessage();
|
|
clog_count = 0;
|
|
SetState("Pump");
|
|
}
|
|
|
|
// regularly update the power usage while pumping or waiting for power
|
|
UpdatePowerUsage();
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Get current height the pump has to push liquids upwards (input.y - output.y) */
|
|
private func GetPumpHeight()
|
|
{
|
|
// compare each the surfaces of the bodies of liquid pumped
|
|
|
|
// find Y position of surface of liquid that is pumped to target
|
|
var source_obj = GetSourceObject();
|
|
var source_x = source_obj.ApertureOffsetX;
|
|
var source_y = source_obj.ApertureOffsetY;
|
|
if (source_obj->GBackLiquid(source_x, source_y))
|
|
{
|
|
var src_mat = source_obj->GetMaterial(source_x, source_y);
|
|
while (src_mat == source_obj->GetMaterial(source_x, source_y - 1))
|
|
--source_y;
|
|
}
|
|
// same for target (use same function as if inserting)
|
|
var target_pos = {X = 0, Y = 0};
|
|
var drain_obj = GetDrainObject();
|
|
drain_obj->CanInsertMaterial(Material("Water"), drain_obj.ApertureOffsetX, drain_obj.ApertureOffsetY, target_pos);
|
|
return source_obj->GetY() + source_y - target_pos.Y;
|
|
}
|
|
|
|
/** Recheck power usage/production for current pump height
|
|
and make the pump a producer / consumer for the power system */
|
|
private func UpdatePowerUsage()
|
|
{
|
|
var new_power;
|
|
if (IsUsingPower())
|
|
new_power = PumpHeight2Power(GetPumpHeight());
|
|
else
|
|
new_power = 0;
|
|
|
|
// do nothing if not necessary
|
|
if (new_power == power_used)
|
|
{
|
|
// But still set powered to true if power_used was not positive.
|
|
if (power_used <= 0)
|
|
powered = true;
|
|
return;
|
|
}
|
|
|
|
// and update energy system
|
|
if (new_power > 0)
|
|
{
|
|
if (power_used < 0)
|
|
{
|
|
powered = false; // needed since the flag was set manually
|
|
UnregisterPowerProduction();
|
|
}
|
|
RegisterPowerRequest(new_power);
|
|
}
|
|
else if (new_power < 0)
|
|
{
|
|
if (power_used > 0)
|
|
UnregisterPowerRequest();
|
|
RegisterPowerProduction(-new_power);
|
|
powered = true; // when producing, we always have power
|
|
}
|
|
else // new_power == 0
|
|
{
|
|
if (power_used < 0)
|
|
UnregisterPowerProduction();
|
|
else if (power_used > 0)
|
|
UnregisterPowerRequest();
|
|
powered = true;
|
|
}
|
|
|
|
power_used = new_power;
|
|
return;
|
|
}
|
|
|
|
// Return whether the pump should be using power in the current state.
|
|
private func IsUsingPower()
|
|
{
|
|
return switched_on && (GetAction() == "Pump" || GetAction() == "WaitForPower");
|
|
}
|
|
|
|
// Transform pump height (input.y - output.y) into required power.
|
|
private func PumpHeight2Power(int pump_height)
|
|
{
|
|
// Pumping upwards will always cost the minimum energy.
|
|
// Pumping downwards will only produce energy after an offset.
|
|
var power_offset = 10;
|
|
// Max power consumed / produced.
|
|
var max_power = 60;
|
|
// Calculate the used power in steps of ten, every 60 pixels represents ten units.
|
|
var used_power = pump_height / 60 * 10;
|
|
// If the pump height is positive then add the minimum energy.
|
|
if (pump_height >= 0)
|
|
used_power = Min(used_power + 10, max_power);
|
|
// Pumping power downwards never costs energy, but only brings something if offset is overcome.
|
|
else
|
|
used_power = BoundBy(used_power + power_offset - 10, -max_power, 0);
|
|
// Pumped air always requires 20 power.
|
|
if (IsAirPipeConnected())
|
|
used_power = 20;
|
|
return used_power;
|
|
}
|
|
|
|
// Returns whether there is liquid at the source pipe to pump.
|
|
private func GetLiquidSourceMaterial()
|
|
{
|
|
// Get the source object and check whether there is liquid.
|
|
var source_obj = GetSourceObject();
|
|
if (!source_obj)
|
|
return;
|
|
// The source is a liquid container: check which material will be supplied.
|
|
if (source_obj->~IsLiquidContainer())
|
|
{
|
|
var liquid = source_obj->HasLiquid(GetResourceSelection());
|
|
if (liquid)
|
|
return liquid->GetLiquidType();
|
|
return;
|
|
}
|
|
var is_liquid = source_obj->GBackLiquid(source_obj.ApertureOffsetX, source_obj.ApertureOffsetY);
|
|
var liquid = MaterialName(source_obj->GetMaterial(source_obj.ApertureOffsetX, source_obj.ApertureOffsetY));
|
|
if (!is_liquid)
|
|
{
|
|
// Try different offsets, so we can resume pumping after clog because 1px of earth was dropped on the source pipe.
|
|
source_obj->~CycleApertureOffset(this);
|
|
return;
|
|
}
|
|
return liquid;
|
|
}
|
|
|
|
// Returns whether the drain pipe is free or the liquid container accepts the given material.
|
|
private func GetLiquidDrainOk(string liquid)
|
|
{
|
|
if (!liquid)
|
|
return false;
|
|
var drain_obj = GetDrainObject();
|
|
if (drain_obj->~HasAperture())
|
|
{
|
|
var material_index = Material(liquid);
|
|
if (material_index == -1 && liquid != nil)
|
|
material_index = Material(GetDefinition(liquid)->GetLiquidMaterial());
|
|
if (!drain_obj->CanInsertMaterial(material_index, drain_obj.ApertureOffsetX, drain_obj.ApertureOffsetY))
|
|
{
|
|
drain_obj->~CycleApertureOffset(this); // try different offsets, so we can resume pumping after clog because 1px of earth was dropped on the source pipe
|
|
return false;
|
|
}
|
|
}
|
|
else if (drain_obj->~IsLiquidContainer())
|
|
{
|
|
if (!drain_obj->AcceptsLiquid(liquid, 1))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Returns whether the source (or alternatively the pump itself) is in free air.
|
|
public func GetAirSourceOk()
|
|
{
|
|
var source_obj = GetSourceObject();
|
|
if (!source_obj)
|
|
return !GBackSemiSolid();
|
|
var is_air = !source_obj->GBackSemiSolid(source_obj.ApertureOffsetX, source_obj.ApertureOffsetY);
|
|
if (!is_air)
|
|
source_obj->~CycleApertureOffset(this);
|
|
return is_air;
|
|
}
|
|
|
|
// Returns whether the other side of air drain is in need of air.
|
|
public func GetAirDrainOk()
|
|
{
|
|
var drain_obj = GetDrainObject();
|
|
if (!drain_obj)
|
|
return false;
|
|
return drain_obj->~QueryAirNeed(this);
|
|
}
|
|
|
|
// Set the state of the pump, retaining the animation position and updating the power usage.
|
|
private func SetState(string act)
|
|
{
|
|
if (act == GetAction())
|
|
return;
|
|
|
|
// Set animation depending on the current action.
|
|
var start = 0;
|
|
var end = GetAnimationLength("pump");
|
|
var anim_pos = GetAnimationPosition(animation);
|
|
if (act == "Pump")
|
|
{
|
|
SetAnimationPosition(animation, Anim_Linear(anim_pos, start, end, 35, ANIM_Loop));
|
|
}
|
|
else if(act == "WaitForLiquid")
|
|
{
|
|
SetAnimationPosition(animation, Anim_Linear(anim_pos, start, end, 350, ANIM_Loop));
|
|
}
|
|
else
|
|
{
|
|
SetAnimationPosition(animation, Anim_Const(anim_pos));
|
|
}
|
|
|
|
// Deactivate power usage when not pumping.
|
|
if (powered && (act == "Wait" || act == "WaitForLiquid"))
|
|
{
|
|
if (power_used < 0)
|
|
UnregisterPowerProduction();
|
|
else if (power_used > 0)
|
|
UnregisterPowerRequest();
|
|
|
|
power_used = 0;
|
|
powered = false;
|
|
}
|
|
// Finally, set the action.
|
|
SetAction(act);
|
|
}
|
|
|
|
/* Deactivates a running pump or vice-versa. */
|
|
func ToggleOnOff(bool no_menu_refresh)
|
|
{
|
|
switched_on = !switched_on;
|
|
CheckState();
|
|
if (!switched_on)
|
|
SetInfoMessage("$StateTurnedOff$");
|
|
if (!no_menu_refresh)
|
|
UpdateInteractionMenus(this.GetPumpControlMenuEntries);
|
|
}
|
|
|
|
|
|
/*-- Material Selection --*/
|
|
|
|
func IsResourceSelectionParent(id child_resource, id parent_resource)
|
|
{
|
|
return child_resource->~GetParentLiquidType() == parent_resource;
|
|
}
|
|
|
|
|
|
func ShowResourceSelectionMenuEntry(id resource)
|
|
{
|
|
return resource->~IsLiquid() && resource != Library_Liquid;
|
|
}
|
|
|
|
|
|
func InitResourceSelection()
|
|
{
|
|
// Add all liquids to the list of ones allowed to pump.
|
|
var index = 0, resource;
|
|
while (resource = GetDefinition(index++))
|
|
if (ShowResourceSelectionMenuEntry(resource))
|
|
AddToResourceSelection(resource);
|
|
return inherited();
|
|
}
|
|
|
|
func IsInResourceSelection(/* any */ mat)
|
|
{
|
|
if (GetType(mat) == C4V_Def)
|
|
{
|
|
return inherited(mat);
|
|
}
|
|
for (var resource in GetResourceSelection())
|
|
{
|
|
if (resource->GetLiquidType() == mat)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public func GetPumpMaterialsMenuEntries(object clonk)
|
|
{
|
|
return GetResourceSelectionMenuEntries(clonk);
|
|
}
|
|
|
|
public func OnPumpMaterialsHover(id symbol, string action, desc_menu_target, menu_id)
|
|
{
|
|
var text = "";
|
|
if (action == RESOURCE_SELECT_Menu_Action_Resource_Enable)
|
|
{
|
|
text = Format("$MsgEnableMaterial$", symbol->GetName());
|
|
}
|
|
else if (action == RESOURCE_SELECT_Menu_Action_Resource_Disable)
|
|
{
|
|
text = Format("$MsgDisableMaterial$", symbol->GetName());
|
|
}
|
|
GuiUpdateText(text, menu_id, 1, desc_menu_target);
|
|
}
|
|
|
|
public func OnPumpMaterials(symbol_or_object, string action, bool alt)
|
|
{
|
|
if (action == RESOURCE_SELECT_Menu_Action_Resource_Enable)
|
|
{
|
|
AddToResourceSelection(symbol_or_object);
|
|
}
|
|
else if (action == RESOURCE_SELECT_Menu_Action_Resource_Disable)
|
|
{
|
|
RemoveFromResourceSelection(symbol_or_object);
|
|
}
|
|
UpdateInteractionMenus(this.GetPumpMaterialsMenuEntries);
|
|
}
|
|
|
|
|
|
/*-- Properties --*/
|
|
|
|
protected func Definition(def)
|
|
{
|
|
// for title image
|
|
SetProperty("PictureTransformation", Trans_Rotate(50, 0, 1, 0), def);
|
|
// for building preview
|
|
SetProperty("MeshTransformation", Trans_Rotate(50, 0, 1, 0), def);
|
|
return _inherited(def, ...);
|
|
}
|
|
|
|
/*
|
|
States
|
|
"Wait": turned off or source pipe not connected
|
|
"WaitForPower": turned on but no power (does consume power)
|
|
"WaitForLiquid": turned on but no liquid (does not consume power)
|
|
"Pump": currently working and consuming/producing power
|
|
*/
|
|
local ActMap = {
|
|
Pump = {
|
|
Prototype = Action,
|
|
Name = "Pump",
|
|
Length = 30,
|
|
Delay = 3,
|
|
Sound = "Structures::Pumpjack",
|
|
NextAction = "Pump",
|
|
StartCall = "CheckState",
|
|
PhaseCall = "Pumping"
|
|
},
|
|
Wait = {
|
|
Prototype = Action,
|
|
Name = "Wait",
|
|
Delay = 90,
|
|
NextAction = "Wait",
|
|
EndCall = "CheckState"
|
|
},
|
|
WaitForPower = {
|
|
Prototype = Action,
|
|
Name = "WaitForPower",
|
|
Delay = 30,
|
|
NextAction = "WaitForPower",
|
|
EndCall = "CheckState"
|
|
},
|
|
WaitForLiquid = {
|
|
Prototype = Action,
|
|
Name = "WaitForLiquid",
|
|
Delay = 30,
|
|
NextAction = "WaitForLiquid",
|
|
EndCall = "CheckState"
|
|
}
|
|
};
|
|
|
|
local Name = "$Name$";
|
|
local Description = "$Description$";
|
|
local BlastIncinerate = 70;
|
|
local NoBurnDecay = true;
|
|
local HitPoints = 70;
|
|
local FireproofContainer = true;
|
|
local Components = {Wood = 1, Metal = 3};
|
|
// Pump speed in amount of pixels to pump per 30 frames.
|
|
local PumpSpeed = 50;
|