Code:

//sledi alpha beta odsjecanje -algoritam iplementiran iz plavog fajla
    public static int MinMaxAB(int[][] stanje,int igr,int A,int B,int deep){ //stek je daljina matrice od stvarnog poteza
                if (fullMat(stanje)&&(deep==1)){
                    System.out.println("izlazak- PUNA tabela");                    
                    return -1;
                }else  if (deep==dubina){
                        System.out.println("izlazak -DUBOKO");                    
            return HeuristicFunction(stanje);
        }
        else{                
                        boolean imaMesta=false;
            if (igr==first){ //prvi igrac-Maximizer
                                 System.out.println("       MINIMAX IGR=FIRST");      
                for (int kolona=0;kolona<number_of_columns;kolona++){
                                    if(!full(stanje,kolona)){                                                                                        
                                            System.out.println("    NOVO Dijete 1 na dubini"+(deep+1));      
                        stek[deep][0]=getRow(stanje,kolona);
                                            boolean dobro=set(stanje,kolona,first);
                                            stek[deep][1]=kolona;                                            
                                            ispisi(stanje);
                                            int score=MinMaxAB(stanje,second,A,B,deep+1);
                                            dobro=remove(stanje,kolona,first);
                                            igr=first;
                                            stek[deep][0]=-1;stek[deep][1]=-1;
                                            if (score>A){A=score;}//found better move
                                            if (A>B){return A;}//cut off                                        
                                    }
                }
                if (imaMesta){return A;}else{return A;}//our best move
            }
            else { //drugi igrac-Minimizer
                                System.out.println("   MINIMAX IGR=SECOND");      
                for (int kolona=0;kolona<number_of_columns;kolona++){
                                    if(!full(stanje,kolona)){ 
                                            stek[deep][0]=getRow(stanje,kolona);
                                            boolean dobro=set(stanje,kolona,second);
                                            stek[deep][1]=kolona; 
                                            ispisi(stanje);
                                            int score=MinMaxAB(stanje,first,A,B,deep+1);
                                            dobro=remove(stanje,kolona,second);
                                            igr=second;
                                            stek[deep][0]=-1;stek[deep][1]=-1;
                                            if (score<B){B=score;}//found better move
                                            if (A>B){return A;}//cut off
                                        }
                }
                if (imaMesta){return B;}else{return B;}//opponents best move
                
            }
    
        }    
    }//MinMaxAB

    //end 
    
        public static final int initA=-100000;
        public static final int initB=+100000;
        public static int igrac;
        
    public static int makeMove(Integer previous){
    // metod ce da stavi na prvo slobodno polje desno od nasheg, ako ima mesta                    
    
    move_counter = GlavniFrame.getCounter();
        
        
    
    // prvi potez igraca je ako je njegov potez prvi ili drugi, tj ako je 
    // move_counter == 0 (prvi potez prvog igracha) ili 1 (prvi potez drugog igracha) 
    // tada treba inicijalizovati matricu ponovo
    if(move_counter == 0){
                   igrac=first;
           init(arr,stek);                          
           int rez=(number_of_columns/2);    
           set(arr,rez, first);    
           return rez;             
    }else{        
        if (move_counter == 1){ // 
           init(arr,stek);
                   igrac=second;
        }    
        set(arr,previous.intValue(), second);            
                    
        // ovde implementirati algoritam koji inteligentno racuna sledeci potez    
                int A=initA;int B=initB;
                int[] ocena=new int[number_of_columns];//svaki potez vrednujemo minimaxom               
                int maxocena=-1;
                int rez=-1;
                igrac=next(igrac);
                
                for (int kol=0;kol<number_of_columns;kol++){
                   boolean dobro=set(arr,kol,igrac);
                   if (dobro){
                    ocena[kol]=MinMaxAB(arr,igrac,A,B,1);
                    if (ocena[kol]>maxocena){
                       maxocena=ocena[kol];
                       rez=kol;
                    }
                   }                   
                   dobro=remove(arr,kol,igrac);                  
                }
                
                //if (!fullMat(arr)){    
                    
                            
                    if((getRow(arr,rez)!=-1)&&(rez>-1)&&(rez<number_of_columns)){
                        set(arr,rez,igrac);    
                        return rez;
                    }else{
                        System.out.println("       izracunat NEMOGUC potez!    ");
                        System.exit(1);
                        return 0;                       
                    }
                /*}else{                
                    System.out.println("Puna tabela,nemo se kuda,dotjerali ste do KRAJA");
                    return -1;
                }*/
                //kraj inteligencije sledeceg poteza    
        
    }
        //return -1; // ako je tabela puna, vraca -1
    }// else