JFrameにコンポーネントが追加されず真っ白い状態となる

四目並べを行うプログラムを作ったのですがうまく起動してくれません。具体的には正しくコンポーネントが追加されていないようで真っ白になってしまします。コンポーネントを追加する順序にミスがあるのでしょうか...?自力では解決しなかったためご指摘のほどお願いします。また、ほかの点で改善点があれば容赦なくお願いします。

import java.awt.Color;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.border.BevelBorder;

public class GameScreen extends JPanel implements ActionListener{
    private int cn;        //升目の数　cn * cn
    private JPanel backpane;
    private JLabel telllimit;
    private JLabel tellcolor;
    private GameSystem s;
    private Color player_c;
    static  JLabel timelimit;
    static boolean play_turn;                //現在のターンを保持
    static boolean[] enter = new boolean[400];    //すべての入力を保持
    static ArrayList<ArrayList<JButton>> y_coordinate = new ArrayList<ArrayList<JButton>>();

    public static void main(String args[]){
        JFrame jf = new JFrame();
        GameScreen gs = new GameScreen(15);
        jf.add(gs);
        jf.setVisible(true);

    }
    public GameScreen(int n){
        /*
         * 画面生成
         */
            //親パネル
        super();
        this.setPreferredSize(new Dimension(930,700));
        this.setLayout(null);
        this.setBackground(Color.GREEN);

            //ターン表示のためのパネル
        tellcolor = new JLabel();
        tellcolor.setBackground(getPlayer_c());
        tellcolor.setBounds(0, 0, 200, 200);
        this.add(tellcolor);

            //残り時間表示のためのパネル
        telllimit = new JLabel();
        telllimit.setBorder(new BevelBorder(BevelBorder.RAISED, Color.white, Color.black));
        telllimit.setBounds(200, 0, 200, 430);
        telllimit.setForeground(Color.WHITE);

        this.add(telllimit);

            //升目パネル
        JPanel screen = new JPanel();
        screen.setBounds(207,200,456, 516);
        screen.setLayout(new GridLayout(20,20,0,0));
        cn = n;
        for(int i = 0;i<cn;i++){
            ArrayList<JButton> x_coordinate = new ArrayList<JButton>();
            for(int t = 0;t<cn;t++){
                JButton cell = CreateCell(i,t);
                cell.addActionListener(this);
                screen.add(cell);
                x_coordinate.add(cell);
            }
            y_coordinate.add(x_coordinate);
        }
        this.add(screen);

        //ゲーム開始
        s = new GameSystem(15);
    }

    public JButton CreateCell(int x,int y){
        JButton btn = new JButton();
        btn.setSize(10, 10);
        btn.setActionCommand(x+"-"+y);
        return btn;
    }
    public void setTelllimittext(int second){
        String s= "残り時間　"+ second+"秒";
        telllimit.setText(s);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        String coordinate = e.getActionCommand();
        for(int k=0;k<cn;k++){
            for(int j = 0;j<cn;j++){
                String number = k+"-"+j;
                if(coordinate.equals(number)){
                    int order = k*20 + j+1;    //入力の番号を作成
                    if(play_turn == true){
                        player_c = Color.RED;
                        s.addA(order);
                    }else{
                        player_c = Color.BLUE;
                        s.addB(order);
                    }
                    changeTurn();

                    if(k == 19){                    //入力が底の時
                        processEnter(order,k,j,player_c);
                    }else{                            //入力が上部の時
                        if(enter[order+20] == false){
                            System.out.println("無効な入力です");
                        }else{
                            processEnter(order,k,j,player_c);
                        }
                    }
                    s.createCombinations();
                }
            }
        }
        return;
    }

    public Color getPlayer_c(){
        if(play_turn == true){
            player_c = Color.RED;
        }else{
            player_c = Color.BLUE;
        }
        return player_c;
    }
    public void changeTurn(){
        if(play_turn == true){
            player_c = Color.RED;
            tellcolor.setBackground(Color.red);
            play_turn = false;
        }else{
            player_c = Color.BLUE;
            tellcolor.setBackground(Color.BLUE);
            play_turn = true;
        }
        tellcolor.setBackground(getPlayer_c());
    }
    /*    色塗り処理    */
    public void processEnter(int order,int k,int j,Color player_c){
        /* 過去に入力があればtrueなければfalse */
        if( enter[order] == true){
            System.out.println("既に入力されています");
            return;
        }else{
            y_coordinate.get(k).get(j).setBackground(player_c);
            enter[order] = true;
        }
    }
}

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import javax.swing.Timer;

public class GameSystem implements ActionListener{
    private Timer timer;
    private int sec;
    private Combinations<Integer> c ;
    private GameScreen gs ;
    private Screen sc;
    private ArrayList<Integer> number_a = new ArrayList<Integer>();    //player1の入力
    private ArrayList<Integer> number_b = new ArrayList<Integer>();    //player2の入力
    private boolean finish = false;


    public GameSystem(int limit){
        sec = 0;
        timer = new Timer(limit*1000,this);
        timer.start();
    }

    public void createCombinations(){
        if(GameScreen.play_turn == !true){
            if(number_a.size() > 3){
                c = new Combinations<Integer>(number_a,4);
                //con = c.count(number_a.size(),4);
                judgeWinner();
            }else{
                return;
            }
        }else{
            if(number_b.size() > 3){
                c = new Combinations<Integer>(number_b,4);
                //con = c.count(number_b.size(),4);
                judgeWinner();
            }else{
                return;
            }
        }

    }
    /*    勝者判定    */
    public void judgeWinner(){
        Iterator<List<Integer>> i = c.iterator();
        while(i.hasNext()){
            List<Integer> t = i.next();
            Collections.sort(t);            //小さい順に並び替え
            Collections.reverse(t);            //大きい順へ
            if(t.get(0)-t.get(3)==3 && t.get(0)-t.get(1)==1    ||
               t.get(0)-t.get(1)==20 && t.get(1)-t.get(2)==20 && t.get(2)-t.get(3)==20 ||
               t.get(0)-t.get(1)==21 && t.get(1)-t.get(2)==21 && t.get(2)-t.get(3)==21 ||
               t.get(0)-t.get(1)==19 && t.get(1)-t.get(2)==19 && t.get(2)-t.get(3)==19 ){
                finish = true;
                System.out.println("ゲーム終了");
            }
        }
    }
    public void addA(int n){
        number_a.add(n);
    }
    public void addB(int n){
        number_b.add(n);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if(finish == true){
            timer.stop();
        }
        if (sec == 15){
             sec = 0;
             gs.changeTurn();
        }else{
             gs.setTelllimittext(sec);
             sec++;

        }
    }
}

/*http://kuidaored.hatenablog.com/entry/20101120/1290268944様より引用
*組み合わせをすべて列挙するプログラム
*/
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class Combinations<T> implements Iterator{

    private List<List<T>> combinations;
    private List<T> list;
    private int[] index;
    private boolean[] visited;
    private int r;
    private boolean overHalf;
    private Iterator<List<T>> iterator;

    public Combinations(List<T> l,int r){
        if(l.size() < 1 || r < 1 || l.size() < r){
            throw new IllegalArgumentException();
        }

        this.combinations = new ArrayList<List<T>>();
        this.list = l;
        this.r = r;
        if(this.r == l.size()){
            this.combinations.add(list);
        }
        else{
            if(this.r > list.size() / 2){
                this.r = list.size() - this.r;
                this.overHalf = true;
            }

            this.index = new int[this.r];
            this.visited = new boolean[list.size()];
            this.compute(0);
        }

        this.iterator = this.combinations.iterator();
    }

    public Combinations(T[] array, int r){
        this(Arrays.asList(array),r);
    }

    private void compute(int n){
        if(n == this.r){
            List<T> combination = new ArrayList<T>();
            if(overHalf){
                for(int i = 0;i < this.list.size();i++){
                    boolean skip = false;
                    for(int j = 0;j < this.index.length;j++){
                        if(i == this.index[j]){
                            skip = true;
                        }
                    }
                    if(skip){
                        continue;
                    }
                    combination.add(list.get(i));
                }
            }
            else{
                for(int i = 0;i < this.index.length;i++){
                    combination.add(list.get(index[i]));
                }
            }
            this.combinations.add(combination);
        }
        else{
            for(int i = 0;i < this.list.size();i++){
                if(n == 0 || !this.visited[i] && index[n - 1] < i){
                    this.visited[i] = true;
                    this.index[n] = i;
                    this.compute(n + 1);
                    this.visited[i] = false;
                }
            }
        }
    }

    public List<List<T>> getCombinations(){
        return this.combinations;
    }

    public static int count(int n, int r) throws IllegalArgumentException{
        if(n < 1 || r < 1 || n < r){
            throw new IllegalArgumentException();
        }

        int res = 1;
        for(int i = n;i > r;i--){
            res *= i;
        }
        for(int i = n - r;i > 1;i--){
            res /= i;
        }
        return res;
    }

    public List<T> next(){

        return this.iterator.next();
    }

    public boolean hasNext(){
        return this.iterator.hasNext();
    }

    public Iterator<List<T>> iterator(){
        return this.iterator;
    }

    public void remove(){
    }
}