CREATE TABLE #tmp (team1 INT, team2 INT, result INT);
INSERT INTO #tmp VALUES (1,2,1),(2,1,0);

;WITH wins AS
(
	SELECT 
		team1,
		SUM(CASE WHEN result = 1 THEN 1 ELSE 0 END) AS wins
	FROM
		#tmp
	GROUP BY
		team1
),
InitialRankings AS
(
	SELECT *,
		RANK() OVER (ORDER BY wins DESC) AS Standing 
	FROM wins
),
HeadToHeadRankings AS
(
	SELECT
		i.*,
		ISNULL(h.head_to_head_wins,0) AS head_to_head_wins
	FROM
		InitialRankings i
		OUTER APPLY
		(
			SELECT	SUM(CASE WHEN result = 1 THEN 1 ELSE 0 END) AS head_to_head_wins
			FROM	#tmp a 
					INNER JOIN InitialRankings s ON 
						a.team2 = s.team1            -- all the opposing teams
						AND s.standing = i.standing  -- that have the same ranking
						AND a.team1 = i.team1        -- as this team
		) h
)
SELECT	*,RANK() OVER(ORDER BY Standing,head_to_head_wins DESC) AS FinalRank
FROM	HeadToHeadRankings;

CREATE TABLE [dbo].[SCHEDULE](
	[GNUM] [float] NULL,
	[DIVISION] [nvarchar](255) NULL,
	[FCODE] [nvarchar](255) NULL,
	[GDATE] [datetime] NULL,
	[HTEAM] [nvarchar](255) NULL,
	[VTEAM] [nvarchar](255) NULL,
	[PLAYED] [bit] NULL,
	[HRUNS] [float] NULL,
	[VRUNS] [float] NULL,
	[HFORFEIT] [bit] NULL,
	[VFORFEIT] [bit] NULL,
	[HCLUB] [nvarchar](255) NULL,
	[VCLUB] [nvarchar](255) NULL,
) ON [PRIMARY]

GO

SELECT     *, CASE WHEN GD > 3 THEN 3 WHEN GD < - 3 THEN - 3 ELSE GD END AS [MaxGD], CASE WHEN W = 1 THEN 3 WHEN D = 1 THEN 1 ELSE 0 END AS [Points]
FROM         (SELECT     SCHEDULE.GNUM, SCHEDULE.DIVISION, SCHEDULE.HTEAM AS TeamID, CASE WHEN (Schedule.HRuns > Schedule.VRuns) OR
                                              (Schedule.VForfeit = 1) THEN 1 ELSE 0 END AS [W], CASE WHEN (Schedule.HRuns < Schedule.VRuns) AND (Schedule.VForfeit = 0) 
                                              THEN 1 ELSE 0 END AS [L], CASE WHEN Schedule.HRuns = Schedule.VRuns THEN 1 ELSE 0 END AS [D], 
                                              CASE WHEN Schedule.Hforfeit = 1 THEN 1 ELSE 0 END AS [Forfeit], Schedule.HRuns AS [GF], Schedule.VRuns AS [GA], 
                                              Schedule.HRuns - Schedule.VRuns AS [GD], Teams.TCode, Teams.Team
                       FROM          SCHEDULE INNER JOIN
                                              TEAMS ON SCHEDULE.HTEAM = TEAMS.TCODE
                       WHERE      (SCHEDULE.PLAYED <> 0) AND (SCHEDULE.HFORFEIT = 0)) AS T
UNION
SELECT     *, CASE WHEN GD > 3 THEN 3 WHEN GD < - 3 THEN - 3 ELSE GD END AS [MaxGD], CASE WHEN W = 1 THEN 3 WHEN D = 1 THEN 1 ELSE 0 END AS [Points]
FROM         (SELECT     SCHEDULE.GNUM, SCHEDULE.DIVISION, SCHEDULE.VTEAM AS TeamID, CASE WHEN (Schedule.HRuns < Schedule.VRuns) OR
                                              (Schedule.HForfeit = 1) THEN 1 ELSE 0 END AS [W], CASE WHEN (Schedule.HRuns > Schedule.VRuns) AND (Schedule.HForfeit = 0) 
                                              THEN 1 ELSE 0 END AS [L], CASE WHEN Schedule.HRuns = Schedule.VRuns THEN 1 ELSE 0 END AS [D], 
                                              CASE WHEN Schedule.Hforfeit = 1 THEN 1 ELSE 0 END AS [Forfeit], Schedule.VRuns AS [GF], Schedule.HRuns AS [GA], 
                                              Schedule.VRuns - Schedule.HRuns AS [GD], Teams.TCode, Teams.Team
                       FROM          SCHEDULE, teams
                       WHERE      (Schedule.VTeam = Teams.TCode) AND (SCHEDULE.PLAYED <> 0) AND (SCHEDULE.VFORFEIT = 0)) AS T
UNION
SELECT     *, CASE WHEN GD > 3 THEN 3 WHEN GD < - 3 THEN - 3 ELSE GD END AS [MaxGD], 0 AS [Points]
FROM         (SELECT     Schedule.gnum, Schedule.Division, Schedule.HTeam AS TeamID, 0 AS [W], 1 AS [L], 0 AS [D], 1 AS [Forfeit], 0 AS [GF], 3 AS [GA], - 3 AS [GD], Teams.TCode, 
                                              Teams.Team
                       FROM          Schedule, Teams
                       WHERE      Schedule.HTeam = Teams.TCode AND Schedule.Played <> 0 AND HForfeit = 1) AS T
UNION
SELECT     *, CASE WHEN GD > 3 THEN 3 WHEN GD < - 3 THEN - 3 ELSE GD END AS [MaxGD], 0 AS [Points]
FROM         (SELECT     Schedule.gnum, Schedule.Division, Schedule.VTeam AS TeamID, 0 AS [W], 1 AS [L], 0 AS [D], 1 AS [Forfeit], 0 AS [GF], 3 AS [GA], - 3 AS [GD], Teams.TCode, 
                                              Teams.Team
                       FROM          Schedule, Teams
                       WHERE      Schedule.VTeam = Teams.TCode AND Schedule.Played <> 0 AND VForfeit = 1) AS T

SELECT     TOP (100) PERCENT DIVISION, TCode, Team, Wins, Losses, Draws, Forfeits, Points, GF, GA, MaxGD, Wins + Losses + Draws AS TotGms, 
                      CAST(Points / (Wins + Losses + Draws) AS decimal(6, 4)) AS AvgPts, CAST(MaxGD / (Wins + Losses + Draws) AS decimal(6, 4)) AS AvgGD
FROM         (SELECT DISTINCT 
                                              TOP (100) PERCENT DIVISION, TCode, Team, SUM(W) AS Wins, SUM(L) AS Losses, SUM(D) AS Draws, SUM(Forfeit) AS Forfeits, CAST(SUM(Points) 
                                              AS decimal(5, 0)) AS Points, SUM(GF) AS GF, SUM(GA) AS GA, CAST(SUM(MaxGD) AS decimal(5, 0)) AS MaxGD
                       FROM          dbo.PointsQuery
                       GROUP BY DIVISION, TCode, Team
                       ORDER BY DIVISION, Points DESC, MaxGD DESC) AS x
ORDER BY DIVISION, AvgPts DESC, AvgGD DESC

CREATE PROCEDURE [dbo].[usp_Build_Comparison_Table]

AS

--get a distinct list of all teams in the league.
IF (OBJECT_ID('tempdb..#Teams') IS NULL) 
BEGIN 
	SELECT DISTINCT Home as TeamName INTO #Teams FROM Prem ORDER BY TeamName 
END

--rebuild your results table (mine is called 'Prem'). The reason for this is to create a new field 'HAD' (to determine if it is a home win, away win or a draw). This
--is neccessary because for a league containing 20 teams like the English Premier League, the dynamic SQL string was too long (over 8000 characters) when I did the
--calculation in the query string. Its a bit of an ugly workaround.

IF (OBJECT_ID('tempdb..#Prem') IS NULL) 
BEGIN 
	--DROP TABLE #Prem
	SELECT * INTO #Prem FROM Prem 
	ALTER TABLE #Prem ADD HAD CHAR(1) 
	UPDATE #Prem SET Home = REPLACE(Home,' ','')
	UPDATE #Prem SET Away = REPLACE(Away,' ','')
	UPDATE #Prem SET HAD = CASE WHEN LEFT(Result,1) > RIGHT(Result,1) THEN 'H' WHEN LEFT(Result,1) = RIGHT(Result,1) THEN 'D' ELSE 'A' END 
END 

--@BuildComparisonTable is where we will build our dynamic sql string.
DECLARE @BuildComparisonTable VARCHAR(8000)
SET @BuildComparisonTable = 'SELECT TeamName '

SELECT @BuildComparisonTable = @BuildComparisonTable + ',SUM(' + REPLACE(TeamName,' ','') + ') as ' + REPLACE(TeamName,' ','') FROM #Teams 
SET @BuildComparisonTable = @BuildComparisonTable + ' FROM ( SELECT Home as TeamName'

SELECT @BuildComparisonTable = @BuildComparisonTable +  ',CASE WHEN Away = ''' + REPLACE(TeamName,' ','') + ''' THEN CASE WHEN HAD = ''H'' THEN 3 WHEN HAD = ''D'' THEN 1 ELSE 0 END + LEFT(Result,1) - RIGHT(Result,1) END AS ' + REPLACE(TeamName,' ','') FROM #Teams 
SET @BuildComparisonTable = @BuildComparisonTable + ' FROM #Prem UNION ALL SELECT Away as TeamName'
SELECT @BuildComparisonTable = @BuildComparisonTable +  ',CASE WHEN Home = ''' + REPLACE(TeamName,' ','') + ''' THEN CASE WHEN HAD = ''A'' THEN 3 WHEN HAD = ''D'' THEN 1 ELSE 0 END + RIGHT(Result,1) - LEFT(Result,1) END AS ' + REPLACE(TeamName,' ','') FROM #Teams 
SET @BuildComparisonTable = @BuildComparisonTable + ' FROM #Prem ) x GROUP BY TeamName'

--if Comparison table exists already, drop it
IF OBJECT_ID('ComparisonTable') IS NOT NULL BEGIN DROP TABLE ComparisonTable END
--build a table from your list of teams
DECLARE @BuildTableSQL VARCHAR(1000)
SET @BuildTableSQL = 'CREATE TABLE ComparisonTable (TeamName VARCHAR(20), '
SELECT @BuildTableSQL = @BuildTableSQL + '[' + TeamName + '] INT, ' FROM #teams
SET @BuildTableSQL = LEFT(@BuildTableSQL,LEN(@BuildTableSQL)-1)
SET @BuildTableSQL = @BuildTableSQL + ')'
exec(@BuildTableSQL)

--execute the @BuildComparisonTable sql string to populate the table with a grid of results between the teams.
--Here's how the scoring system works for this comparison table:
--Its all done based on the home team. If a team has won they get three points plus a point for each unit of goal difference.
--e.g. A team wins 3-1, they get 3 for the win, plus 2 for the goal difference.
--a team gets one point for a draw
--Teams get zero for a defeat MINUS the goal difference. e.g. a 1-0 defeat will result in a score of -1.
--You could use any points system, it doesn't affect the main league table, rather it enables a comparison to be drawn between any two teams based on their results during the season.
INSERT INTO ComparisonTable
EXEC(@BuildComparisonTable)