add Lua hooks

stepmania/src/GameState.cpp

@@ -1392,3 +1392,41 @@ bool GameState::ChangeCourseDifficulty( PlayerNumber pn, int dir )
 	return true;
 }
 
+bool PlayerIsUsingModifier( PlayerNumber pn, const CString sModifier )
+{
+	PlayerOptions po = GAMESTATE->m_PlayerOptions[pn];
+	SongOptions so = GAMESTATE->m_SongOptions;
+	po.FromString( sModifier );
+	so.FromString( sModifier );
+
+	return po == GAMESTATE->m_PlayerOptions[pn] && so == GAMESTATE->m_SongOptions;
+}
+
+#include "LuaFunctions.h"
+LuaFunction_PlayerNumber( IsHumanPlayer,	GAMESTATE->IsHumanPlayer(pn) )
+LuaFunction_NoArgs( IsCourseMode,			GAMESTATE->IsCourseMode() )
+LuaFunction_NoArgs( IsDemonstration,		GAMESTATE->m_bDemonstrationOrJukebox )
+LuaFunction_NoArgs( StageIndex,				GAMESTATE->GetStageIndex() )
+LuaFunction_NoArgs( NumStagesLeft,			GAMESTATE->GetNumStagesLeft() )
+LuaFunction_NoArgs( IsFinalStage,			GAMESTATE->IsFinalStage() )
+LuaFunction_NoArgs( IsExtraStage,			GAMESTATE->IsExtraStage() )
+LuaFunction_NoArgs( IsExtraStage2,			GAMESTATE->IsExtraStage2() )
+LuaFunction_NoArgs( CourseSongIndex,		GAMESTATE->GetCourseSongIndex() )
+LuaFunction_NoArgs( CurStyle,				GAMESTATE->m_CurStyle )
+
+/* Return an integer into SONGMAN->m_pSongs.  This lets us do input checking, which we
+ * can't easily do if we return pointers. */
+LuaFunction_NoArgs( CurSong,				GAMESTATE->m_pCurSong )
+LuaFunction_PlayerNumber( CurSteps,			GAMESTATE->m_pCurNotes[pn] )
+
+int LuaFunc_UsingModifier( lua_State *L )
+{
+	REQ_ARGS( "UsingModifier", 2 );
+	REQ_ARG_NUMBER_RANGE( "UsingModifier", 1, 1, NUM_PLAYERS );
+	REQ_ARG( "UsingModifier", 2, string );
+
+	const PlayerNumber pn = (PlayerNumber) (int(lua_tonumber( L, 1 ))-1);
+	const CString modifier = lua_tostring( L, 2 );
+	LUA_RETURN( PlayerIsUsingModifier( pn, modifier ) );
+}
+LuaFunction( UsingModifier );

stepmania/src/SongManager.cpp

@@ -946,3 +946,50 @@ void SongManager::FreeAllLoadedFromProfiles()
 	}
 }
 
+static bool CheckPointer( const Song *p )
+{
+	const vector<Song*> &songs = SONGMAN->GetAllSongs();
+	for( unsigned i = 0; i < songs.size(); ++i )
+		if( songs[i] == p )
+			return true;
+	return false;
+}
+
+
+#include "LuaFunctions.h"
+#define LuaFunction_Song( func, call ) \
+int LuaFunc_##func( lua_State *L ) { \
+	REQ_ARGS( #func, 1 ); \
+	REQ_ARG( #func, 1, lightuserdata ); \
+	const Song *p = (const Song *) (lua_touserdata( L, -1 )); \
+	LUA_ASSERT( CheckPointer(p), ssprintf("%p is not a valid song", p) ); \
+	LUA_RETURN( call ); \
+} \
+LuaFunction( func ); /* register it */
+
+LuaFunction_Str( Song, SONGMAN->FindSong( str ) );
+
+LuaFunction_Song( SongFullDisplayTitle, p->GetFullDisplayTitle() );
+
+static bool CheckPointer( const Steps *p )
+{
+	const vector<Song*> &songs = SONGMAN->GetAllSongs();
+	for( unsigned i = 0; i < songs.size(); ++i )
+	{
+		for( unsigned j = 0; j < songs.size(); ++j )
+			if( songs[i]->m_apNotes[j] == p )
+				return true;
+	}
+	return false;
+}
+
+#define LuaFunction_Steps( func, call ) \
+int LuaFunc_##func( lua_State *L ) { \
+	REQ_ARGS( #func, 1 ); \
+	REQ_ARG( #func, 1, lightuserdata ); \
+	const Steps *p = (const Steps *) (lua_touserdata( L, -1 )); \
+	LUA_ASSERT( CheckPointer(p), ssprintf("%p is not a valid steps", p) ); \
+	LUA_RETURN( call ); \
+} \
+LuaFunction( func ); /* register it */
+LuaFunction_Steps( StepsMeter, p->GetMeter() );

stepmania/src/StageStats.cpp

@@ -408,3 +408,83 @@ bool StageStats::FullCombo( PlayerNumber pn ) const
 	return ComboStartsAtBeginning && ComboEndsAtEnd;
 }
 
+static Grade GetBestGrade()
+{
+	Grade g = NUM_GRADES;
+	for( unsigned pn=0; pn<NUM_PLAYERS; ++pn )
+	{
+		if( !GAMESTATE->IsPlayerEnabled(pn) )
+			continue;
+		g = min( g, g_CurStageStats.GetGrade( (PlayerNumber)pn ) );
+	}
+	return g;
+}
+
+static Grade GetWorstGrade()
+{
+	Grade g = GRADE_TIER_1;
+	for( unsigned pn=0; pn<NUM_PLAYERS; ++pn )
+	{
+		if( !GAMESTATE->IsPlayerEnabled(pn) )
+			continue;
+		g = max( g, g_CurStageStats.GetGrade( (PlayerNumber)pn ) );
+	}
+	return g;
+}
+
+#include "LuaFunctions.h"
+LuaFunction_NoArgs( GetBestGrade,			GetBestGrade() );
+LuaFunction_NoArgs( GetWorstGrade,			GetWorstGrade() );
+LuaFunction_NoArgs( OnePassed,				g_CurStageStats.OnePassed() );
+LuaFunction_PlayerNumber( FullCombo,		g_CurStageStats.FullCombo(pn) )
+LuaFunction_PlayerNumber( MaxCombo,			g_CurStageStats.GetMaxCombo(pn).cnt )
+LuaFunction_PlayerNumber( GetGrade,			g_CurStageStats.GetGrade(pn) )
+LuaFunction_Str( Grade,						StringToGrade(str) );
+
+/* PrevGrade(0) returns the last grade; PrevGrade(1) returns the one before that,
+ * and so on.  If you go back beyond the first song played, return GRADE_NO_DATA. */
+Grade GetPrevGrade( int n, PlayerNumber pn )
+{
+	int stage = int(g_vPlayedStageStats.size()) - n - 1;
+	if( stage < 0 || stage >= (int) g_vPlayedStageStats.size() )
+		return GRADE_NO_DATA;
+	return g_vPlayedStageStats[stage].GetGrade( pn );
+}
+
+bool OneGotGrade( int n, Grade g )
+{
+	for( unsigned pn=0; pn<NUM_PLAYERS; pn++ )
+		if( GAMESTATE->IsHumanPlayer((PlayerNumber)pn) )
+			if( GetPrevGrade( n, (PlayerNumber)pn ) == g )
+				return true;
+
+	return false;
+}
+
+
+LuaFunction_IntInt( OneGotGrade, OneGotGrade( a1, (Grade) a2 ) );
+
+Grade GetFinalGrade( PlayerNumber pn )
+{
+	if( !GAMESTATE->IsHumanPlayer(pn) )
+		return GRADE_NO_DATA;
+	vector<Song*> vSongs;
+	StageStats stats;
+	GAMESTATE->GetFinalEvalStatsAndSongs( stats, vSongs );
+	return stats.GetGrade( pn );
+}
+LuaFunction_PlayerNumber( GetFinalGrade, GetFinalGrade( pn ) );
+
+Grade GetBestFinalGrade()
+{
+	Grade top_grade = GRADE_FAILED;
+	vector<Song*> vSongs;
+	StageStats stats;
+	GAMESTATE->GetFinalEvalStatsAndSongs( stats, vSongs );
+	for( int p=0; p<NUM_PLAYERS; p++ )
+		if( GAMESTATE->IsHumanPlayer(p) )
+			top_grade = min( top_grade, stats.GetGrade((PlayerNumber)p) );
+	return top_grade;
+}
+LuaFunction_NoArgs( GetBestFinalGrade, GetBestFinalGrade() );
+