Merge pull request #6807 from Goober5000/subsystem_enhancements

subsystem scripting enhancements

Author: Goober5000

code/model/model.h

@@ -1012,6 +1012,7 @@ SCP_set<int> model_get_textures_used(const polymodel* pm, int submodel);
 // Returns a pointer to the polymodel structure for model 'n'
 polymodel *model_get(int model_num);
 
+int num_model_instances();
 polymodel_instance* model_get_instance(int model_instance_num);
 
 // routine to copy subsystems.  Must be called when subsystems sets are the same -- see ship.cpp

code/model/modelread.cpp

@@ -3895,6 +3895,11 @@ polymodel * model_get(int model_num)
 	return Polygon_models[num];
 }
 
+int num_model_instances()
+{
+	return static_cast<int>(Polygon_model_instances.size());
+}
+
 polymodel_instance* model_get_instance(int model_instance_num)
 {
 	Assert( model_instance_num >= 0 );

code/scripting/api/objs/model.cpp

@@ -23,7 +23,7 @@ int model_h::GetID() const
 }
 bool model_h::isValid() const
 {
-	return (model_num >= 0) && (model_get(model_num) != nullptr);
+	return (model_num >= 0) && (model_get(model_num) != nullptr);	// note: the model ID can exceed MAX_POLYGON_MODELS because the modulo is taken
 }
 model_h::model_h(int n_modelnum)
 	: model_num(n_modelnum)
@@ -56,13 +56,41 @@ bool submodel_h::isValid() const
 	if (model_num >= 0 && submodel_num >= 0)
 	{
 		auto model = model_get(model_num);
-		if (model != nullptr)
-			return submodel_num < model->n_models;
+		if (model != nullptr && submodel_num < model->n_models)
+			return true;
 	}
 	return false;
 }
 
 
+ADE_FUNC(__eq, l_Model, "model, model", "Checks if two model handles refer to the same model", "boolean", "True if models are equal")
+{
+	model_h* mdl1;
+	model_h* mdl2;
+
+	if (!ade_get_args(L, "oo", l_Model.GetPtr(&mdl1), l_Model.GetPtr(&mdl2)))
+		return ADE_RETURN_NIL;
+
+	if (mdl1->GetID() == mdl2->GetID())
+		return ADE_RETURN_TRUE;
+
+	return ADE_RETURN_FALSE;
+}
+
+ADE_FUNC(__eq, l_Submodel, "submodel, submodel", "Checks if two submodel handles refer to the same submodel", "boolean", "True if submodels are equal")
+{
+	submodel_h* smh1;
+	submodel_h* smh2;
+
+	if (!ade_get_args(L, "oo", l_Submodel.GetPtr(&smh1), l_Submodel.GetPtr(&smh2)))
+		return ADE_RETURN_NIL;
+
+	if (smh1->GetModelID() == smh2->GetModelID() && smh1->GetSubmodelIndex() == smh2->GetSubmodelIndex())
+		return ADE_RETURN_TRUE;
+
+	return ADE_RETURN_FALSE;
+}
+
 ADE_VIRTVAR(Submodels, l_Model, nullptr, "Model submodels", "submodels", "Model submodels, or an invalid submodels handle if the model handle is invalid")
 {
 	model_h *mdl = nullptr;

code/scripting/api/objs/modelinstance.cpp

@@ -111,65 +111,118 @@ ADE_OBJ(l_ModelInstance, modelinstance_h, "model_instance", "Model instance hand
 
 modelinstance_h::modelinstance_h(int pmi_id)
 {
-	_pmi = model_get_instance(pmi_id);
+	_pmi_id = pmi_id;
 }
 modelinstance_h::modelinstance_h(polymodel_instance *pmi)
-	: _pmi(pmi)
+	: _pmi_id(pmi ? pmi->id : -1)
 {}
 modelinstance_h::modelinstance_h()
-	: _pmi(nullptr)
+	: _pmi_id(-1)
 {}
-polymodel_instance *modelinstance_h::Get()
+polymodel_instance *modelinstance_h::Get() const
 {
-	return _pmi;
+	return isValid() ? model_get_instance(_pmi_id) : nullptr;
+}
+int modelinstance_h::GetID() const
+{
+	return isValid() ? _pmi_id : -1;
+}
+polymodel *modelinstance_h::GetModel() const
+{
+	return isValid() ? model_get(model_get_instance(_pmi_id)->model_num) : nullptr;
+}
+int modelinstance_h::GetModelID() const
+{
+	return isValid() ? model_get_instance(_pmi_id)->model_num : -1;
 }
 bool modelinstance_h::isValid() const
 {
-	return (_pmi != nullptr);
+	return (_pmi_id >= 0) && (_pmi_id < num_model_instances()) && (model_get_instance(_pmi_id) != nullptr);
 }
 
 
 ADE_OBJ(l_SubmodelInstance, submodelinstance_h, "submodel_instance", "Submodel instance handle");
 
 submodelinstance_h::submodelinstance_h(int pmi_id, int submodel_num)
-	: _submodel_num(submodel_num)
+	: _pmi_id(pmi_id), _submodel_num(submodel_num)
+{}
+submodelinstance_h::submodelinstance_h(polymodel_instance *pmi, int submodel_num)
+	: _pmi_id(pmi ? pmi->id : -1), _submodel_num(submodel_num)
+{}
+submodelinstance_h::submodelinstance_h()
+	: _pmi_id(-1), _submodel_num(-1)
+{}
+polymodel_instance *submodelinstance_h::GetModelInstance() const
 {
-	_pmi = model_get_instance(pmi_id);
-	_pm = _pmi ? model_get(_pmi->model_num) : nullptr;
+	return isValid() ? model_get_instance(_pmi_id) : nullptr;
 }
-submodelinstance_h::submodelinstance_h(polymodel_instance *pmi, int submodel_num)
-	: _pmi(pmi), _submodel_num(submodel_num)
+int submodelinstance_h::GetModelInstanceID() const
 {
-	_pm = pmi ? model_get(pmi->model_num) : nullptr;
+	return isValid() ? _pmi_id : -1;
 }
-submodelinstance_h::submodelinstance_h()
-	: _pmi(nullptr), _pm(nullptr), _submodel_num(-1)
-{}
-polymodel_instance *submodelinstance_h::GetModelInstance()
+submodel_instance *submodelinstance_h::Get() const
 {
-	return isValid() ? _pmi : nullptr;
+	return isValid() ? &model_get_instance(_pmi_id)->submodel[_submodel_num] : nullptr;
 }
-submodel_instance *submodelinstance_h::Get()
+polymodel *submodelinstance_h::GetModel() const
 {
-	return isValid() ? &_pmi->submodel[_submodel_num] : nullptr;
+	return isValid() ? model_get(model_get_instance(_pmi_id)->model_num) : nullptr;
 }
-polymodel *submodelinstance_h::GetModel()
+int submodelinstance_h::GetModelID() const
 {
-	return isValid() ? _pm : nullptr;
+	return isValid() ? model_get_instance(_pmi_id)->model_num : -1;
 }
-bsp_info *submodelinstance_h::GetSubmodel()
+bsp_info *submodelinstance_h::GetSubmodel() const
 {
-	return isValid() ? &_pm->submodel[_submodel_num] : nullptr;
+	return isValid() ? &model_get(model_get_instance(_pmi_id)->model_num)->submodel[_submodel_num] : nullptr;
 }
-int submodelinstance_h::GetSubmodelIndex()
+int submodelinstance_h::GetSubmodelIndex() const
 {
 	return isValid() ? _submodel_num : -1;
 }
 bool submodelinstance_h::isValid() const
 {
-	return _pmi != nullptr && _pm != nullptr && _submodel_num >= 0 && _submodel_num < _pm->n_models;
+	if (_pmi_id >= 0 && _submodel_num >= 0 && _pmi_id < num_model_instances())
+	{
+		auto pmi = model_get_instance(_pmi_id);
+		if (pmi != nullptr && pmi->model_num >= 0)
+		{
+			auto pm = model_get(pmi->model_num);
+			if (pm != nullptr && _submodel_num < pm->n_models)
+				return true;
+		}
+	}
+	return false;
+}
+
+
+ADE_FUNC(__eq, l_ModelInstance, "model_instance, model_instance", "Checks if two model instance handles refer to the same model instance", "boolean", "True if model instances are equal")
+{
+	modelinstance_h* mih1;
+	modelinstance_h* mih2;
+
+	if (!ade_get_args(L, "oo", l_ModelInstance.GetPtr(&mih1), l_ModelInstance.GetPtr(&mih2)))
+		return ADE_RETURN_NIL;
+
+	if (mih1->GetID() == mih2->GetID())
+		return ADE_RETURN_TRUE;
+
+	return ADE_RETURN_FALSE;
 }
 
+ADE_FUNC(__eq, l_SubmodelInstance, "submodel_instance, submodel_instance", "Checks if two submodel instance handles refer to the same submodel instance", "boolean", "True if submodel instances are equal")
+{
+	submodelinstance_h* smih1;
+	submodelinstance_h* smih2;
+
+	if (!ade_get_args(L, "oo", l_SubmodelInstance.GetPtr(&smih1), l_SubmodelInstance.GetPtr(&smih2)))
+		return ADE_RETURN_NIL;
+
+	if (smih1->GetModelInstanceID() == smih2->GetModelInstanceID() && smih1->GetSubmodelIndex() == smih2->GetSubmodelIndex())
+		return ADE_RETURN_TRUE;
+
+	return ADE_RETURN_FALSE;
+}
 
 ADE_FUNC(getModel, l_ModelInstance, nullptr, "Returns the model used by this instance", "model", "A model")
 {

code/scripting/api/objs/modelinstance.h

@@ -10,14 +10,18 @@ namespace api {
 class modelinstance_h
 {
  protected:
-	polymodel_instance *_pmi;
+	int _pmi_id;
 
  public:
 	explicit modelinstance_h(int pmi_id);
 	explicit modelinstance_h(polymodel_instance *pmi);
 	modelinstance_h();
 
-	polymodel_instance *Get();
+	polymodel_instance *Get() const;
+	int GetID() const;
+
+	polymodel *GetModel() const;
+	int GetModelID() const;
 
 	bool isValid() const;
 };
@@ -27,21 +31,23 @@ DECLARE_ADE_OBJ(l_ModelInstance, modelinstance_h);
 class submodelinstance_h
 {
 protected:
-	polymodel_instance *_pmi;
-	polymodel *_pm;
+	int _pmi_id;
 	int _submodel_num;
 
 public:
 	explicit submodelinstance_h(int pmi_id, int submodel_num);
 	explicit submodelinstance_h(polymodel_instance *pmi, int submodel_num);
 	submodelinstance_h();
 
-	polymodel_instance *GetModelInstance();
-	submodel_instance *Get();
+	polymodel_instance *GetModelInstance() const;
+	int GetModelInstanceID() const;
+
+	polymodel *GetModel() const;
+	int GetModelID() const;
 
-	polymodel *GetModel();
-	bsp_info *GetSubmodel();
-	int GetSubmodelIndex();
+	submodel_instance *Get() const;
+	bsp_info *GetSubmodel() const;
+	int GetSubmodelIndex() const;
 
 	bool isValid() const;
 };

code/scripting/api/objs/ship.cpp

@@ -94,6 +94,36 @@ ADE_FUNC(__len, l_Ship, NULL, "Number of subsystems on ship", "number", "Subsyst
 	return ade_set_args(L, "i", ship_get_num_subsys(&Ships[objh->objp()->instance]));
 }
 
+ADE_FUNC(getSubsystemList,
+	l_Ship,
+	nullptr,
+	"Get the list of subsystems on this ship",
+	"iterator<subsystem>",
+	"An iterator across all subsystems on the ship. Can be used in a for .. in loop. Is not valid for more than one frame.")
+{
+	object_h* objh;
+	if (!ade_get_args(L, "o", l_Ship.GetPtr(&objh)))
+		return ADE_RETURN_NIL;
+
+	if (!objh->isValid())
+		return ADE_RETURN_NIL;
+
+	ship* shipp = &Ships[objh->objp()->instance];
+	ship_subsys* ss = &shipp->subsys_list;
+
+	return ade_set_args(L, "u", luacpp::LuaFunction::createFromStdFunction(L, [shipp, ss](lua_State* LInner, const luacpp::LuaValueList& /*params*/) mutable -> luacpp::LuaValueList {
+		//Since the first element of a list is the next element from the head, and we start this function with the captured "ss" object being the head, this GET_NEXT will return the first element on first call of this lambda.
+		//Similarly, an empty list is defined by the head's next element being itself, hence an empty list will immediately return nil just fine
+		ss = GET_NEXT(ss);
+
+		if (ss == END_OF_LIST(&shipp->subsys_list) || ss == nullptr) {
+			return luacpp::LuaValueList{ luacpp::LuaValue::createNil(LInner) };
+		}
+
+		return luacpp::LuaValueList{ luacpp::LuaValue::createValue(LInner, l_Subsystem.Set(ship_subsys_h(&Objects[shipp->objnum], ss))) };
+	}));
+}
+
 ADE_FUNC(setFlag, l_Ship, "boolean set_it, string flag_name", "Sets or clears one or more flags - this function can accept an arbitrary number of flag arguments.  The flag names can be any string that the alter-ship-flag SEXP operator supports.", nullptr, "Returns nothing")
 {
 	object_h *objh;