Часть 7 из 12
Строки: 12001-14000 из 22262
================================================================================


            if( $user_id_0 == $user_id_1){
                errors::exc(errors::errorIncorrectInput,"user_in id == user_out id" );
            }
            //--------------------------------------------------------------------------
           
           
            //провека на число исходящих/входящих дуэлей 
            if(0 >= Model::factory("user", $user_id_0)->checkGameOutEmptySlot()){
                return array("result" => -10, "text" => "user_out has no free outgoing game slots"); 
            }
            if(0 == $friend_flag){ 
                if($invite_flag == 0){
                     if(0 >= Model::factory("user", $user_id_1)->checkGameInEmptySlot( )){
                        return array("result" => -11, "text" => "user_in has no free incoming game slots"); 
                    }
                } else if($invite_flag == 1){
                    //найти все игры, в случае если они есть, проверить сколько не превышает ли число игр лимит var.start_game_in_max 
                      $list_invite_games = Model::factory("user_game")->getList(array("user_id_1" => $user_id_1), array( "id" ));
                      $invite_games_count = count($list_invite_games);
                      $start_game_in_max    = Model::factory ( 'var' )->loadByKey ( 'start_game_in_max' )->value;
          
                      if(count($invite_games_count) >  $start_game_in_max){
                          return array("result" => -7, "text" => "too much invite games"); 
                      }
                    
                } else {
                      return array("result" => -6, "text" => "invite errors"); 
                }
            }
            //--------------------------------------------------------------------------
           
            //проверка нет ли активных дуэлей между игроками
            $list_check_user0 = array();
            $list_check_user1 = array();
            
            $list_check_user0 = Model::factory("user_game")->getList(array("user_id_0" => $user_id_0, "user_id_1" => $user_id_1));
            $list_check_user1 = Model::factory("user_game")->getList(array("user_id_0" => $user_id_1, "user_id_1" => $user_id_0));
           
            if(count($list_check_user0) != 0 || count($list_check_user1) !=0  ){
                return array("result" => -5, "text" => "game between selected users already active");  
            }
           
            //проверка: достаточно ли у начинающего дуэль игрока ресурсов
            $CostMoney1    = Model::factory ( 'var' )->loadByKey ( 'game_start_price_money0' )->value;
            $CostMoney2    = Model::factory ( 'var' )->loadByKey ( 'game_start_price_money1' )->value;
            $CostEnergy    = Model::factory ( 'var' )->loadByKey ( 'game_start_price_energy' )->value;
            
            if(!Model::factory("user", $user_id_0)->checkMoney($CostMoney1, $CostMoney2)){
                return array("result" => -3, "text" => "not enough money");  
            }
            if(!Model::factory("user", $user_id_0)->checkEnergy($CostEnergy)){
                return array("result" => -4, "text" => "not enough energy");  
            } 
         
            //--------------------------------------------------------------------------
            
            $rounds_count             = Model::factory ( 'var' )->loadByKey ( 'game_round_count' )->value;
            $active_user              = 0;
            $active_round_number      = 0;
            $active_round_start_flag  = 0;
            
            $oNewUserGame = Model::factory("user_game")->add($user_id_0, $user_id_1, $rounds_count, $active_user, $active_round_number, $active_round_start_flag);
            $aNewUserGame = $oNewUserGame->get();
            
            $aUserAsk = Model::factory("user_game_ask_buffer")->add($aNewUserGame["id"]);
            
            //------------------------------------------------------------------------------------
            //добавляем по единице к счестчикам активных игр у игроков
            Model::factory( "user", $user_id_0)->changeGameOut( 1 );
            
            if($invite_flag == 0){
                Model::factory( "user", $user_id_1)->changeGameIn( 1 );
            }
            //------------------------------------------------------------------------------------
            //списываем валюту и энегрию у игрока начинающего дуэль
            $reason_id = 9;
            Model::factory( "user", $user_id_0)->changeMoney( - $CostMoney1, - $CostMoney2, $reason_id);
            Model::factory( "user", $user_id_0)->changeEnergy( - $CostEnergy, $reason_id);
            //------------------------------------------------------------------------------------
            Model::factory("game")->convertGame( $user_id_0, $aNewUserGame ); 
                                                        
            return array("result" => 1, 
                         "friend_flag" => $friend_flag,
                         "invite_flag" => $invite_flag,
                         "game" => array("id"                         => $aNewUserGame["id"],
                                         "user_id_0"                  => $aNewUserGame["user_id_0"],
                                         "user_id_1"                  => $aNewUserGame["user_id_1"],
                                         "rounds_count"               => $aNewUserGame["rounds_count"],
                                         "active_user"                => $aNewUserGame["active_user"],
                                         "active_round_number"        => $aNewUserGame["active_round_number"],
                                         "active_round_start_flag"    => $aNewUserGame["active_round_start_flag"],
                                         "time_last_activity"         => $aNewUserGame["time_last_activity"],
                                         "user_cancel"                => $aNewUserGame["user_cancel"],
                                         "round_cancel"               => $aNewUserGame["round_cancel"]),
                         "terms" => array("position_bonus_char"        => $aUserAsk["position_bonus_char"],
                                          "open_chars"                 => $aUserAsk["open_chars"]));
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "initGame", $user_id_0);
            throw new Exception ($e->getMessage(), $e->getCode());
        }     
    }
    
    /**
    * Возвращает список плейлиство для следующей дуэли 
    * @param  bigint $user_id  номер игрока который пытается получить список
    * @param  int    $game_id  номер игры в таблице user_game 
    * @return mix 
    */ 
    public function getStartData($user_id, $game_id) {
        try{
            if(!Model::factory("user", $user_id)->exist()){
                errors::exc(errors::errorIncorrectInput,"user id not exist" );
            }
            if(!Model::factory("user_game", $game_id)->exist()){
                errors::exc(errors::errorIncorrectInput,"game id not exist" );
            } 
             
              
            $list_user_game =  Model::factory("user_game")->getList(array("id" => $game_id), array("id","user_id_0", "user_id_1", "playlist_case_count", "playlist_case0","playlist_case1","playlist_case2","playlist_case3","rounds_count", "active_user", "active_round_number", "playlist_set_chosen_flag", "playlist_case_count","active_round_start_flag" ));
            $aUserGame = $list_user_game[0];
            
            //-----------------------------------------------------------------------------------------------------
            //проверки на легальность запроса от этого пользователя
            //-----------------------------------------------------------------------------------------------------
            if($aUserGame["user_id_0"] != $user_id && $aUserGame["user_id_1"]!= $user_id){
                errors::exc(errors::errorIncorrectInput,"wrong user id" ); 
            }
            
            
            //проверка на то, чья сейчас очередь играть раунд------------------------------------------------------
            if($aUserGame["active_user"] == 0){
                if($aUserGame["user_id_0"] != $user_id){
                     return array("result" => -5, "another player's turn"); 
                }
            } else if($aUserGame["active_user"] == 1){
                if($aUserGame["user_id_1"] != $user_id){
                     return array("result" => -5, "another player's turn"); 
                }
            }
            if($aUserGame["active_round_number"] >= $aUserGame["rounds_count"]){
                 errors::exc(errors::errorIncorrectDBValue, "round number is more than the max count of rounds" );
            }
            //----------------------------------------------------------------------------------------------------- 
            //проверка: запущен ли уже раунд
            if($aUserGame["active_round_start_flag"] == 1){
                return array("result" => -6, "round already start");
            }
            //-----------------------------------------------------------------------------------------------------
            //проверка на то выбран ли уже плейлист или нет, плейлист выбран только в случае если раунд уже начат
            if($aUserGame["active_round_start_flag"] == 1){
                errors::exc(errors::errorIncorrectDBValue,"round already started" );
            } 
            //-----------------------------------------------------------------------------------------------------
            
            if(1 == $aUserGame["playlist_set_chosen_flag"]){
                  //--------------------------------------------------------------------------
                //Подготовка возвращаемых данные
                $aPlaylistOut = array();
                if($aUserGame["playlist_case0"] != -1){
                   $aPlaylistOut[] = $aUserGame["playlist_case0"];
                }
                if($aUserGame["playlist_case1"] != -1){
                   $aPlaylistOut[] = $aUserGame["playlist_case1"];
                }
                if($aUserGame["playlist_case2"] != -1){
                   $aPlaylistOut[] = $aUserGame["playlist_case2"];
                }
                if($aUserGame["playlist_case3"] != -1){
                   $aPlaylistOut[] = $aUserGame["playlist_case3"];
                }
                //--------------------------------------------------------------------------
                return array("result" => 1,  "game" => array("id" => $game_id, "playlist_set_chosen_flag" => $aUserGame["playlist_set_chosen_flag"], "playlist_case_count" => $aUserGame["playlist_case_count"], "playlist_case" => $aPlaylistOut));
            }  
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------
            //----------------------------------------------------------------------------------------------------- 
            
            //--------------------------------------------------------------------------
            $playlist_case_count  = Model::factory ( 'var' )->loadByKey ( 'game_playlist_case_count' )->value;
            //производится подбор списка плейлистов и он возвращается игроку начинающему дуэль
             
            $aPlaylistStatSet = Model::factory("user_playlist")->get_available_playlist_set($user_id, $playlist_case_count);
            
            $aUserGame["playlist_case0"]           = (count($aPlaylistStatSet) >= 1) ? $aPlaylistStatSet[0] : -1;
            $aUserGame["playlist_case1"]           = (count($aPlaylistStatSet) >= 2) ? $aPlaylistStatSet[1] : -1;
            $aUserGame["playlist_case2"]           = (count($aPlaylistStatSet) >= 3) ? $aPlaylistStatSet[2] : -1;
            $aUserGame["playlist_case3"]           = (count($aPlaylistStatSet) >= 4) ? $aPlaylistStatSet[3] : -1;
            $aUserGame["playlist_case_count"]      = count($aPlaylistStatSet);
            $aUserGame["playlist_set_chosen_flag"] = 1;
            
            Model::factory("user_game")->create($aUserGame);

            
            //--------------------------------------------------------------------------
            //Подготовка возвращаемых данные
            $aPlaylistOut = array();
            if($aUserGame["playlist_case0"] != -1){
               $aPlaylistOut[] = $aUserGame["playlist_case0"];
            }
            if($aUserGame["playlist_case1"] != -1){
               $aPlaylistOut[] = $aUserGame["playlist_case1"];
            }
            if($aUserGame["playlist_case2"] != -1){
               $aPlaylistOut[] = $aUserGame["playlist_case2"];
            }
            if($aUserGame["playlist_case3"] != -1){
               $aPlaylistOut[] = $aUserGame["playlist_case3"];
            }
            //--------------------------------------------------------------------------
            return array("result" => 1,  "game" => array("id" => $game_id, "playlist_set_chosen_flag" => $aUserGame["playlist_set_chosen_flag"], "playlist_case_count" => $aUserGame["playlist_case_count"], "playlist_case" => $aPlaylistOut));
     
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "initGame", $user_id_0);
            throw new Exception ($e->getMessage(), $e->getCode());
        }     
    }
    
    
    /**
    * Купить возможность изменить список плейлистов для конкретной игры (id статических плейлистов) и обновить информацию в игре
    * @param  bigint user_id id             игрока из соц сети
    * @param  int    $shop_playlist_stat_id id-плейлиста из таблицы shop_playlist_stat
    * @return array  array("result" => 1, 'shop_playlist_stat_id' => int, "user_playlist" => $array());
    */ 
    public function buyShufflePlaylistSet($user_id, $game_id) {
        try{   
            if(!Model::factory("user", $user_id)->exist()){
                errors::exc(errors::errorIncorrectInput,"user id not exist" );
            } 
            if(!Model::factory("user_game", $game_id)->exist()){
                errors::exc(errors::errorIncorrectInput,"game id not exist" );
            }
            
            $list_user_game =  Model::factory("user_game")->getList(array("id" => $game_id), array("id","user_id_0", "user_id_1", "playlist_case_count", "playlist_case0","playlist_case1","playlist_case2","playlist_case3","rounds_count", "active_user", "active_round_number", "playlist_set_chosen_flag", "playlist_case_count","active_round_start_flag" ));
            $aUserGame = $list_user_game[0];
                                                                                                                   
            //-----------------------------------------------------------------------------------------------------
            //проверки на легальность запроса от этого пользователя
            //-----------------------------------------------------------------------------------------------------            
            if($aUserGame["user_id_0"] != $user_id && $aUserGame["user_id_1"]!= $user_id){
                errors::exc(errors::errorIncorrectInput,"wrong user id" ); 
            } 
            
            //проверка на то, чья сейчас очередь играть раунд------------------------------------------------------
            if($aUserGame["active_user"] == 0){
                if($aUserGame["user_id_0"] != $user_id){
                     return array("result" => -5, "another player's turn"); 
                }
            } else if($aUserGame["active_user"] == 1){
                if($aUserGame["user_id_1"] != $user_id){
                     return array("result" => -5, "another player's turn"); 
                }
            }
            if($aUserGame["active_round_number"] >= $aUserGame["rounds_count"]){
                 errors::exc(errors::errorIncorrectDBValue, "round number is more than the max count of rounds" );
            }
       
            //----------------------------------------------------------------------------------------------------- 
            //проверка: отменен ли раунд
            if(-1 != $aGame["user_cancel"]){
                return array("result" => 0, "test" => "game canseled, use refresh");
            }
            
            //проверка: запущен ли уже раунд
            if($aUserGame["active_round_start_flag"] == 1){
                return array("result" => -6, "round already start");
            }
            //-----------------------------------------------------------------------------------------------------
            //проверка на то выбран ли уже плейлист или нет, плейлист выбран только в случае если раунд уже начат
            if($aUserGame["active_round_start_flag"] == 1){
                errors::exc(errors::errorIncorrectDBValue,"round already started" );
            } 
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------                
            //-----------------------------------------------------------------------------------------------------
            
            //-----------------------------------------------------------------------------------------------------
            //подбор списка новых плейлистов:
            //-----------------------------------------------------------------------------------------------------
            $aSetOld    = array();
            $aSetAll    = array();
            $aSetDiff   = array();
            $aSetResult = array();
            
            
            //--------------------------------------------------------------------------
            $playlist_case_count  = Model::factory ( 'var' )->loadByKey ( 'game_playlist_case_count' )->value;
            //производится подбор списка плейлистов и он возвращается игроку начинающему дуэль             
            $aSetAll = Model::factory("user_playlist")->get_available_playlist_set($user_id, $playlist_case_count, TRUE);

            $flagNewSet = FALSE;
            
            if($aUserGame["playlist_case_count"] > $playlist_case_count){
                $aUserGame["playlist_case_count"] = $playlist_case_count;    
            }
            for($i = 0; $i < $aUserGame["playlist_case_count"]; $i++ ){
                if( $i >= 4){
                    //в базе прописано всего 4 слота на данный момент
                    break;
                }
                if($aUserGame["playlist_case$i"] != -1){
                   $aSetOld[] = $aUserGame["playlist_case$i"];
                }
            }
            
            $aSetDiff = array_diff($aSetAll, $aSetOld);
            if(count($aSetDiff) <= 0){
                 return array('result' => 0, "text" => "new list of playlists is identical to the old, too few other playlist"); 
            }
            
            $aSetResult = array_merge($aSetDiff, $aSetOld);
            $aSetResult = array_unique($aSetResult);                 //удаляем повторяющиеся по значению элементы 
            if(count($aSetResult) > $playlist_case_count ){
                 $aSetResult = array_slice($aSetResult , 0, $playlist_case_count );                     //оставляем только первых $count значений(сбрасываем ключи массива)
            } else{
                 $aSetResult = array_slice($aSetResult, 0, count($aSetResult));    //сбрасываем ключи массива 
            }
            shuffle ( $aSetResult );
            
            $aUserGame["playlist_case0"]           = (count($aSetResult) >= 1) ? $aSetResult[0] : -1;
            $aUserGame["playlist_case1"]           = (count($aSetResult) >= 2) ? $aSetResult[1] : -1;
            $aUserGame["playlist_case2"]           = (count($aSetResult) >= 3) ? $aSetResult[2] : -1;
            $aUserGame["playlist_case3"]           = (count($aSetResult) >= 4) ? $aSetResult[3] : -1;
            $aUserGame["playlist_case_count"]      = count($aSetResult);
            $aUserGame["time_last_activity"]      = SConfig::$time;
           
            //$aUserGame["playlist_set_chosen_flag"] = 0;

            //--------------------------------------------------------------------------
            //проверка: достаточно ли у начинающего дуэль игрока ресурсов
            $CostMoney1    = Model::factory ( 'var' )->loadByKey ( 'buy_playlist_set_price_money1' )->value;
            $CostMoney2    = Model::factory ( 'var' )->loadByKey ( 'buy_playlist_set_price_money2' )->value;
            $CostEnergy    = Model::factory ( 'var' )->loadByKey ( 'buy_playlist_set_price_energy' )->value;
            
            if(!Model::factory("user", $user_id)->checkMoney($CostMoney1, $CostMoney2)){
                return array("result" => -3, "text" => "not enough money");  
            }
            if(!Model::factory("user", $user_id)->checkEnergy($CostEnergy)){
                return array("result" => -4, "text" => "not enough energy");  
            } 
            
            Model::factory("user_game")->create($aUserGame);
            
            //------------------------------------------------------------------------------------
            //списываем валюту и энегрию у игрока за смену плейлистов
            $reason_id = 10;
            Model::factory( "user", $user_id)->changeMoney( - $CostMoney1, - $CostMoney2, $reason_id);
            Model::factory( "user", $user_id)->changeEnergy( - $CostEnergy, $reason_id);
            //------------------------------------------------------------------------------------
     
            //--------------------------------------------------------------------------
            //Подготовка возвращаемых данные
            $aPlaylistOut = array();
            if($aUserGame["playlist_case0"] != -1){
               $aPlaylistOut[] = $aUserGame["playlist_case0"];
            }
            if($aUserGame["playlist_case1"] != -1){
               $aPlaylistOut[] = $aUserGame["playlist_case1"];
            }
            if($aUserGame["playlist_case2"] != -1){
               $aPlaylistOut[] = $aUserGame["playlist_case2"];
            }
            if($aUserGame["playlist_case3"] != -1){
               $aPlaylistOut[] = $aUserGame["playlist_case3"];
            }
            //--------------------------------------------------------------------------
            return array("result" => 1,  "game" => array("id" => $game_id, "playlist_set_chosen_flag" => $aUserGame["playlist_set_chosen_flag"], "playlist_case_count" => $aUserGame["playlist_case_count"], "playlist_case" => $aPlaylistOut));
   
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "buyShufflePlaylistSet", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        }     
    }
    
    
    /**
    * Начинает игру(дуэль) или продолжает, в случае если игра уже была начата ранее
    * @param $user_id bigint номер пользователя в соц.сети
    * @param $game_id int номер игры
    * @param $playlist_id int номер выбранного плейлиста
    * @return mix Формат отдачи клиену array("result" => 1/0, ...)
    */                       
    public function startGame($user_id, $game_id = NULL, $question = ""){
        try{
            
            if(!Model::factory("user", $user_id)->exist()){
                errors::exc(errors::errorIncorrectInput,"user_id not exist" );
            }
            if(!Model::factory("user_game", $game_id)->exist()){
                errors::exc(errors::errorIncorrectInput,"game_id not exist" );
            } 
            $aGame   = Model::factory("user_game", $game_id)->get();
            $iNumRound   = $aGame["active_round_number"];
            $iNumUser    = $aGame["active_user"];
            
            
            //-------------------------------------------------------------------------------------------------
            //<проверка легальности слова
            
            $str_question = Model::factory("word")->convert_to_in($question); //convert
            
            if(!Model::factory("user_game_ask_buffer", $aGame["id"])->exist()){
                 errors::exc(errors::errorIncorrectInput,"ask buffer error" );
            }
            $arr_ask_buffer = Model::factory("user_game_ask_buffer", $aGame["id"])->get();
            $str_open_chars = Model::factory("word")->convert_to_in( $arr_ask_buffer["open_chars"]); //convert
            
            $arr_open_chars = str_split($str_open_chars);
            
            $use_sign = "";
            for($i = 0; $i < strlen($str_question); $i++){
                $pos = array_search( $str_question[$i], $arr_open_chars);
                if( $pos === FALSE ){
                    errors::exc(errors::errorIncorrectInput,"wrong char in question, miss in open_char" );
                } else {
                    unset($arr_open_chars[ $pos ]);
                }
            }
          
            $list_question = Model::factory("task_stat")->getList(array("question" => $question));
            if( ! is_array($list_question) || 0 == count($list_question)){
                return array("result" => 0);
            }
            $question_id = $list_question[0]["id"];
            
          
            //--------------------------------------------------------------------------
            //считаем очки за слово
            $word_points   = 0;
            for($i = 0; $i < strlen($str_question); $i++){
                $char       = Model::factory("word")->convert_to_out($str_question[$i]);
                $list_char = Model::factory("char_stat")->getList( array("char" => $char), array("point"));
                
                if(is_array($list_char) && 0 != count($list_char)){
                    if($i == $arr_ask_buffer["position_bonus_char"]){
                       $word_points +=  $list_char[0]["point"]*2;
                    } else {
                       $word_points +=  $list_char[0]["point"];    
                    } 
                }
            }
            
            //КУДА ДЕВАТЬ ЭТИ ОЧКИ???
            //$word_points
            //что за них начислять?
            //КУДА ДЕВАТЬ ЭТИ ОЧКИ???
          
            //проверка легальности слова>
            //--------------------------------------------------------------------------
            
            //-----------------------------------------------------------------------------------------------------
            //проверки на легальность запроса от этого пользователя
        
            if($aGame["user_id_0"] != $user_id && $aGame["user_id_1"]!= $user_id){
                errors::exc(errors::errorIncorrectInput,"wrong user id" ); 
            }
            
            //проверка на то, чья сейчас очередь играть раунд------------------------------------------------------
            if(! $this->isPlayerTurn($user_id, $aGame)){
               return array("result" => -5, "another player's turn");  
            }
            
            //проверка на максимальное кол-во раундов 
            if($aGame["active_round_number"] >= $aGame["rounds_count"]){
                 errors::exc(errors::errorIncorrectDBValue, "round number is more than the max count of rounds" );
            }
            
            //----------------------------------------------------------------------------------------------------- 
            //проверка: отменен ли раунд
            if(-1 != $aGame["user_cancel"]){
                return array("result" => 0, "test" => "game canseled, use refresh");
            }
            
            //-----------------------------------------------------------------------------------------------------
            //не начата ли уже игра
            if($aGame["active_round_start_flag"] == 1){ 
                 return array("result" => -10, "tast" => "game already started, use refresh");
            } 
            
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------                
            //-----------------------------------------------------------------------------------------------------
            
           
            //действия для игрока 
            if((0 == $aGame["active_user"] && $user_id == $aGame["user_id_0"]) || (1 == $aGame["active_user"] && $user_id == $aGame["user_id_1"])){
                //if(!Model::factory('user_playlist')->usePlaylist($user_id, $playlist_id)){
                //    return array("result" => -2, "text" => "error in use playlist");
                //}
            } 
            
            //хватает ли энергии
            $round_energy_price    = Model::factory ( 'var' )->loadByKey ( 'round_energy_price' )->value;
            if(!Model::factory("user", $user_id)->checkEnergy( $round_energy_price )){
                return array("result" => -50, "text" => "not enough energy");  
            }
            
            //------------------------------------------------------------------------------------------------------------
            //создаем задание
            $aUserTask            = array(); 
            $round_completed_flag = 0;
            $user_win             = -1;
            $word_mask            = "";
            $aRound               = array(); 
            
            
            if( -1 == $aGame[ "active_round_id" ]){           
                Model::factory('user_round')->createRound($user_id, $game_id, $aRound);
            } else {
                $aRound =  Model::factory("user_round", $aGame[ "active_round_id" ])->get();
            }
            
            Model::factory('user_task')->createTask($user_id, $aRound["id"], $aGame['active_user'], $question_id, $str_question, $aUserTask, $word_mask);
            
            //-------------------------------------------------- 
            $aGame["active_round_id"]             = $aRound["id"];
            //------------------------------------------------------------------------------------------------------------
            //если все в порядке корректируем данные по игре
            $aGame["active_round_start_flag"]         = 1;
            $aGame["time_last_activity"]              = SConfig::$time;

            
            if($aGame['active_user'] == 0){
                $aGame['active_user'] = 1; 
            } else {
                $aGame['active_user'] = 0;
            } 
            
            Model::factory("user_game")->create($aGame);
            
            $reason_id = 50;
            Model::factory("user", $user_id)->changeEnergy( - $round_energy_price, $reason_id);
            
            //---------------------------------------------------------------------------------------------------------------------------------- 
            Model::factory("game")->convertGame( $user_id, $aGame );                    //приводит игру    в вид удобный для вывода клиенту
            Model::factory("user_round")->convertRound($user_id, $aRound );             //приводит раунд   в вид удобный для вывода клиенту
            Model::factory("user_task")->convertTask( $user_id, $word_mask, $aUserTask );         //приводит задания в вид удобный для вывода клиенту
            //---------------------------------------------------------------------------------------------------------------------------------- 
                            
            return array("result" => 1, "game" => $aGame, "round" => $aRound, "task" => $aUserTask, "question_points" => $word_points );
            
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "startGame", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        } 
    }
    
    public function endGame($user_id, $game_id, $sign = ''){
        try{
            
            if(!Model::factory("user", $user_id)->exist()){
                errors::exc(errors::errorIncorrectInput,"user_id not exist" );
            }
            if(!Model::factory("user_game", $game_id)->exist()){
                errors::exc(errors::errorIncorrectInput,"game_id not exist" );
            } 
            //--------------------------------------------------------------------------
            $aGame   = Model::factory("user_game", $game_id)->get();
            //-----------------------------------------------------------------------------------------------------
            //проверки на легальность запроса от этого пользователя
            if($aGame["user_id_0"] != $user_id && $aGame["user_id_1"]!= $user_id){
                errors::exc(errors::errorIncorrectInput,"wrong user id" ); 
            }
            
            //проверка: запущен ли уже раунд
            if($aGame["active_round_start_flag"] != 1){
                return array("result" => -6, "round is not running or shift move in progress");
            }
                                               
            //проверка на то, чья сейчас очередь играть раунд------------------------------------------------------
            if(! $this->isPlayerTurn($user_id, $aGame)){
               return array("result" => -5, "another player's turn");  
            }
            
            if($aGame["active_round_number"] >= $aGame["rounds_count"]){
                 //!?! Удалить игру. Самоочистка.
                 errors::exc(errors::errorIncorrectDBValue, "round number is more than the max count of rounds" );
            }
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------
            
            $flag_task_finish   = false; 
            $flag_task_win      = false;
                       
            $iNumRound       =  $aGame["active_round_number"];
            $iNumUser        =  $aGame["active_user"];
            $active_round_id =  $aGame["active_round_id"];
           
            $aTerms = array();  
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------                
            //-----------------------------------------------------------------------------------------------------
            //<----------------------------------------------------------------------------------------------------
            //<проверка на правильность ответа
            
            //-----------------------------------------------------------------
            //существует ли 
            if(!Model::factory("user_round", $active_round_id)->exist()){
                 errors::exc(errors::errorIncorrectDBValue,"active_round_id not exist" );
            }  
            $aRound        = Model::factory("user_round", $active_round_id)->get();
            $listTask      = Model::factory("user_task")->getList(array("user_round_id" => $aRound["id"], "active_user" => $iNumUser));
            $aTask         =  $listTask[0];
            $aTaskStat     = array();
            if(!Model::factory("task_stat", $aTask["task_stat_id"])->exist()){
                errors::exc(errors::errorIncorrectDBValue, "task_stat is not correct" );
            }
            
            $aTaskStat = Model::factory("task_stat", $aTask["task_stat_id"])->get();
     
            $str_question_mask  = "";
            $str_sign       = Model::factory("word")->convert_to_in($sign); //convert
            $str_question   = Model::factory("word")->convert_to_in($aTaskStat["question"]); //convert
            $str_fail_signs = Model::factory("word")->convert_to_in($aTask["fail_signs"]); //convert
            $str_history    = Model::factory("word")->convert_to_in($aTask["history"]); //convert
            
            //-----------------------------------------------------------------------
            $list_char = Model::factory("char_stat")->getList(array("char" => $sign));
            if( !is_array($list_char) || 0 == count($list_char)){
                 return array(result => "-1", "text" => "illegal sign" );
            }
            
            //<--проверка - есть ли буква в слове 
            $arr_pos= array();
            if(Model::factory("word")->strpos_all($str_question, $str_sign, $arr_pos)){
               
                $aTask["bit_mask"]  = Model::factory("word")->set_bit_mask($arr_pos, $aTask["bit_mask"]);
                 
                if(strpos($str_history, $str_sign) !== FALSE){
                //если символ уже записан в историю как использованный
                    return array(result => "-2", "text" => "sign already in str_history" );
                }
          
            } else {
                
                if(strpos($str_fail_signs, $str_sign) !== FALSE){
                //если символ уже записан в историю как использованный
                    return array(result => "-3", "text" => "sign already in fail_signs" );
                }
                $str_fail_signs = $str_fail_signs.$str_sign;
                $aTask["try_count"] = $aTask["try_count"] - 1;
            } 
           
            $str_question_mask  = Model::factory("word")->get_word_mask($str_question, $aTask["bit_mask"]);
            $str_history    = $str_history.$str_sign;
            
            //<--полностью ли разгадано слово 
            if( pow( 2, strlen($str_question) ) - 1 == $aTask["bit_mask"]){ //|хлеб| = 4; 2^4 - 1 = 15 = 1111;
                if(0 == strcmp($str_question, $str_question_mask)){
                     $flag_task_finish = true; 
                     $flag_task_win    = true; 
                } else {
                     errors::exc(errors::errorIncorrectInput, "comperate error" );
                }
            } else {
                //не полностью
            }
            //-->
            
            if($aTask["try_count"] <= 0){
                $flag_task_finish = true; 
                $flag_task_win    = false; 
            }
           
            //--------------------------------------------------------------------------
            //--------------------------------------------------------------------------
            //--------------------------------------------------------------------------
           
            $aTask["fail_signs"]    = Model::factory("word")->convert_to_out($str_fail_signs); //convert
            $aTask["history"]       = Model::factory("word")->convert_to_out($str_history);    //convert
            $aGame["time_last_activity"] = SConfig::$time;
            
            $aRound = Model::factory("user_round", $active_round_id)->get();
            
            if( false == $flag_task_finish){
                
            //ВЫХОД ИЗ ФУНКЦИИ
                
                //Model::factory('user_round')->create($aRound); 
                Model::factory("user_game")->create($aGame); 
                Model::factory("user_task")->create($aTask); 
                 
                Model::factory("user_task")->convertTask($user_id, $str_question_mask, $aTask );
                
                //return array("result" => 0, "game" => $aGame, "round" => $aRound,  "task" => $aTaskSet);
                //присываем только task
                return array("result" => 1, "game" => $aGame, "round" => $aRound,  "task" => $aTask, "terms" => $aTerms);
                //return array("result" => 0, "task" => $aTask);
                  
            }
            
            //--------------------------------------------------------------------------
            //----------------------------------------------------------------------------------------------------------------------------------
            //----------------------------------------------------------------------------------------------------------------------------------
            
            if(true == $flag_task_win){
                
                $aTask["result_user"]   = 1;
                $aRound["user_result_".$iNumUser] = 1; 
    
                $round_win_prize_money1 = Model::factory ( 'var' )->loadByKey ( 'round_win_prize_money1' )->value;            
                Model::factory("user", $aGame["user_id_".$iNumUser])->changeMoney($round_win_prize_money1,  0, 10);  //$reason_id = 10; //выигрыш в раунде
            } else if(false == $flag_task_win){
              
                $aTask["result_user"]   = 0; 
                $aRound["user_result_".$iNumUser] = 0;
                
                $round_lose_prize_money1 = Model::factory ( 'var' )->loadByKey ( 'round_lose_prize_money1' )->value;            
                Model::factory("user", $aGame["user_id_".$iNumUser])->changeMoney($round_lose_prize_money1, 0, 11);  //$reason_id = 11; //проигрыш в раунде
            }
            
           
            //--------------------------------------------------------------------------
            //----------------------------------------------------------------------------------------------------------------------------------
            //----------------------------------------------------------------------------------------------------------------------------------
           
            $aGame["time_last_activity"]  = SConfig::$time;
                        
            $flag_game_finish    = false;
            $flag_round_finish   = false;
            $game_user_lose_num  = -1;
            
            //-----------------------------------------------------------------------------
            //Проверяем вылетел ли кто-нибудь
       
            $aRoundSet = array();
            $aRoundSet = Model::factory("user_round")->getGameRoundSet($user_id, $game_id);
            $aRoundSet = Model::factory("user_round")->combineRound($user_id, $aRoundSet, $aRound);
            
            //кто первый вылетел тот и проиграл
            
            $arrLoseCount = array(); //ключ - порядковый номер игрока, значение - сколько раундов он проиграл
            $arrLoseCount[0] = Model::factory("user_round")->getLoseRoundsCount(0, $aRoundSet);
            $arrLoseCount[1] = Model::factory("user_round")->getLoseRoundsCount(1, $aRoundSet);

            $game_round_lose_count = Model::factory ( 'var' )->loadByKey ( 'game_round_lose_count' )->value;
            if($arrLoseCount[ $iNumUser ] >= $game_round_lose_count){
                $flag_game_finish = true;
                $user_lose_num    = $iNumUser;
                $aGame['user_winner_game'] = 1 - $iNumUser;
            }
            //-----------------------------------------------------------------------------
            //-----------------------------------------------------------------------------
            //-----------------------------------------------------------------------------
            //-----------------------------------------------------------------------------
            
            
             
            if( false == $flag_game_finish && -1 != $aRound['user_result_0'] && -1 != $aRound['user_result_0']){
                  $aRound["round_completed_flag"]      = 1;
                  
                  if($iNumRound + 1 == $aGame["rounds_count"] + 0 ){
                      $flag_game_finish = true;
                      
                      if($arrLoseCount[0] > $arrLoseCount[1]){
                         $aGame['user_winner_game'] = 1;     
                      } else if($arrLoseCount[1] > $arrLoseCount[0]){
                         $aGame['user_winner_game'] = 0;  
                      } else {
                         $aGame['user_winner_game'] = 2;
                      }
                  } else {
                        $aGame["active_round_number"] = $aGame["active_round_number"] + 1;
                        $aGame["active_round_id"]     = -1;
                  }
            } 
            
            //-----------------------------------------------------------------------------
            
           
            //! С этого момента все изменения вносимые в $aRound сохранены не будут, в связи с использованием в конечном счете для записи в статистику $aRoundSet, который уже дополнен $aRound 
            if(true == $flag_game_finish || $aGame["user_cancel"] != -1){                                                                        
                $aRound["round_completed_flag"]      = 1;
                    
                if(0 == $aGame['user_winner_game']){
                    $this->takeGamePrizeToPlayers($aGame["user_id_0"], $aGame["user_id_1"], 1);
                } else if(1 == $aGame['user_winner_game']){
                    $this->takeGamePrizeToPlayers($aGame["user_id_1"], $aGame["user_id_0"], 1);
                }  else if(2 == $aGame['user_winner_game']){
                    
                }
               
                //-------------------------------------------------------------------------------------
                //<--перевод игры в статистику
                
                $aRoundSet = Model::factory("user_round")->combineRound($user_id, $aRoundSet, $aRound);
                $aTaskSet  = array();
                foreach($aRoundSet as $round){
                    $listTask  = Model::factory("user_task")->getRoundTaskSet($user_id, $round["id"]);
                    foreach( $listTask as $task){
                        if($aTask["id"] == $task["id"]){
                            $aTaskSet[] = $aTask;
                        } else {
                            $aTaskSet[] = $task;    
                        } 
                    }
                }
                
                Model::factory("statistics")->addGameResult($user_id, $aGame, $aRoundSet, $aTaskSet);
                
                //-------------------------------------------------------------------------------------
                //перевод игры в статистику-->
                
                //удаляем все раунды и данные о игре из БД--------------------------------------------------------------------
                $this->deleteGameData($user_id, $aGame['id']);  
          
                //-------------------------------------------------------------------------------------
                Model::factory("user", $aGame["user_id_0"])->changeGameOut( -1 );
                Model::factory("user", $aGame["user_id_1"])->changeGameIn( -1 );
            
            } else {
                
                 //тут дописывать если слово разадано!?
                 //-----------------------------------------------------------------------------
                 
                 $aGame["active_round_start_flag"]  = 0;
                 //-----------------------------------------------------------------------------
            
                 Model::factory('user_round')->create($aRound); 
                 Model::factory("user_game")->create($aGame); 
                 Model::factory("user_task")->create($aTask); 
                 //Model::factory("user_task")->updateTaskSet($user_id, $aTaskSet); 
                 
                 $aUserAsk = Model::factory("user_game_ask_buffer")->add($aGame["id"]);
                 /////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                 $aTerms =  array("position_bonus_char"        => $aUserAsk["position_bonus_char"],
                                  "open_chars"                 => $aUserAsk["open_chars"]);
                 
            }
           
            Model::factory("game")->convertGame( $user_id, $aGame );                    //приводит игру    в вид удобный для вывода клиенту
            Model::factory("user_round")->convertRound($user_id, $aRound );             //приводит раунд   в вид удобный для вывода клиенту
            
            if($flag_task_finish == false){
                Model::factory("user_task")->convertTask($user_id, $str_question_mask, $aTask );                //приводит задания в вид удобный для вывода клиенту
            } else {
                Model::factory("user_task")->convertTask($user_id, $str_question, $aTask );                //приводит задания в вид удобный для вывода клиенту
            }
            
            //что возвращать???                
            return array("result" => 1, "game" => $aGame, "round" => $aRound,  "task" => $aTask, "terms" => $aTerms);
            
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "endGame", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        } 
    }

    /**
    * Отменяет игру
    * При отмене игры не начисляются бонус за выйгранный раунд/проигранный раунд
    * @param bigint $user_id номер пользователя в соц.сети
    * @param int    $game_id номер игры
    * @return mix 
    */                 
    public function cancelGame($user_id, $game_id){
        try{
            
            
            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            //если игрок был приглашен но не ответил - не сыграл ниодного раунда, тогда игра просто отменяется, 
            //ничего не пишется в статистику и не выдается никаких призов или поощерений!!!!!!!!!!!!!!!!!!!!!!!
            
            if(!Model::factory("user", $user_id)->exist()){
                errors::exc(errors::errorIncorrectInput,"user_id not exist" );
            }
            if(!Model::factory("user_game", $game_id)->exist()){
                errors::exc(errors::errorIncorrectInput,"game_id not exist" );
            } 
            //--------------------------------------------------------------------------
            $aGame   = Model::factory("user_game", $game_id)->get();
            $aGame1   = Model::factory("user_game")->getList(array("id" => $game_id));
            
            $fast_cancel_flag = false;
            
            //if(0 == $aGame["active_round_number"] && 0 == $aGame["active_user"]){
            if(0 == $aGame["active_round_number"] || -1 == $aGame["active_round_number"]){  
                
                 //ПРОВЕРИТЬ!!!
                 //ПРОВЕРИТЬ!!!
                 //ПРОВЕРИТЬ!!!
                 
                 $fast_cancel_flag = true;
                 $list_round   = Model::factory("user_round")->getList(array("user_game_id" => $aGame["id"]));
                 foreach($list_round as $round_check){
                     if($round_check["user_result_0"] != -1 || $round_check["user_result_1"] != -1){
                         $fast_cancel_flag = false;
                         break;
                     }
                 }
            }
            //-----------------------------------------------------------------------------------------------------
            //проверки на легальность запроса от этого пользователя
            //-----------------------------------------------------------------------------------------------------            
            //if($aGame["user_id_0"] != $user_id && $aGame["user_id_1"]!= $user_id){
            //    errors::exc(errors::errorIncorrectInput,"wrong user id" ); 
            //}
            //----------------------------------------------------------------------------------------------------- 
            //-----------------------------------------------------------------------------------------------------
            if(0){
                if($aGame["active_round_number"] >= $aGame["rounds_count"]){
                    errors::exc(errors::errorIncorrectDBValue, "round number is more than the max count of rounds" );
                }
            }
            
            $aRound = Model::factory("user_round", $aGame["active_round_id"])->get();
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------
            //корректируем данные по игре
   
            $iNumRound =  $aGame["active_round_number"];
            //$iNumUser  =  $aGame["active_user"];

            $user_cancel = -1;
            $user_win    = -1;
        
            if($user_id == $aGame["user_id_0"]){
            //if( $this->isPlayerTurn( $user_id , $aGame ) ){
                $user_cancel = 0;
                $user_win    = 1;
            } else {
                $user_cancel = 1; 
                $user_win    = 0; 
            }
            
            $iNumUser  =  $user_cancel;
            
            $aGame["user_cancel"]             = $user_cancel;  
            $aGame["time_last_activity"]      = SConfig::$time;
            $aGame["round_cancel"]            = $aGame["active_round_number"];
            
            //-----------------------------------------------------------------
            //корректируем данные по раунда
            
            $aRound["round_completed_flag"]         = 1;
            $aRound["user_win"]                     = $user_win;
            
            //-----------------------------------------------------------------
            //-----------------------------------------------------------------
            //-----------------------------------------------------------------
            //давать ли возраграждение за именно этот раунд победившему в ранде пользователю?
            //пока не давать
            //-----------------------------------------------------------------
            //-----------------------------------------------------------------
            //-----------------------------------------------------------------
            
            $aRoundSet = array();
            $aTaskSet  = array();
            
            if(false == $fast_cancel_flag){
            
                $aRoundSet = Model::factory("user_round")->getGameRoundSet($user_id, $game_id);
                $aRoundSet = Model::factory("user_round")->combineRound($user_id, $aRoundSet, $aRound);
               
                
                foreach($aRoundSet as $round){
                   $round_task  = Model::factory("user_task")->getRoundTaskSet($user_id, $round["id"]); 
                   foreach($round_task as $task){
                      $aTaskSet[] = $task;
                   }
                }   
                    
                //выдаем награду за выгранную/проигранную игру 
                $this->takeGamePrizeToPlayers($aGame["user_id_".$user_win], $aGame["user_id_".$user_cancel], 0);
                $aGame["user_winner_game"] = $user_win;
                //------------------------------------------------------------------------------------------------------------ 

                //перевод игры в статистику
                Model::factory("game")->convertGame( $user_id, $aGame );             //приводит игру   в вид удобный для вывода клиенту
          
                Model::factory("statistics")->addGameResult($user_id, $aGame, $aRoundSet, $aTaskSet);
            }
            //удаляем все раунды и данные о игре из БД--------------------------------------------------------------------
            $this->deleteGameData($user_id, $aGame['id']);
       
            Model::factory("user", $aGame["user_id_0"])->changeGameOut( -1 );
            
            if(false == $fast_cancel_flag){
                Model::factory("user", $aGame["user_id_1"])->changeGameIn( -1 );
            }
                
            return array("result" => 1, "game" => $aGame);
            
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "cancelGame", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        } 
    }
    
    
    
    //--------------------------------------------------------------------------------------------------------------------------------------------    
    //--------------------------------------------------------------------------------------------------------------------------------------------    
    //--------------------------------------------------------------------------------------------------------------------------------------------    
    //--------------------------------------------------------------------------------------------------------------------------------------------    
    //--------------------------------------------------------------------------------------------------------------------------------------------    
    
    
    /**
    * Возвращает данные обо всех запущенных играх и раундах
    * @return array Массив возвращаемых значений, cодержит:
    *  -  (int)    result    :  "1" - успех / "-x" - ошибка;
    *  -  (array)  game_list    :  массив игр, в которых учавствует игрок
    *  -  (array)  round_list   :  массив раундов, сыгранных или начатых в незаконченных играх
    */  
    public function refreshGames($user_id){
        try{ 
            
            $game_set  = array(); 
            $round_set = array();  
            $task_set  = array();  
            $term_set  = array();  
                           
            $list0 = Model::factory("user_game")->getList(array("user_id_0" => $user_id), array("id"));
            $list1 = Model::factory("user_game")->getList(array("user_id_1" => $user_id), array("id")); 
            
            foreach( $list0 as $game ){
                $this->getAllGameSet($user_id, $game["id"], $game_set, $round_set, $task_set, $term_set);          
            }
            foreach( $list1 as $game ){
                $this->getAllGameSet($user_id, $game["id"], $game_set, $round_set, $task_set, $term_set);          
            }
            
            return array( "result" => 1, "game" => $game_set, "round" => $round_set, "task" => $task_set, "term" => $term_set);
            
            //-----------------------------------------------------------------------------------------------------------------------------


        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "refreshGames", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        }     
    }
    
    
    
    
    /**
    * Подготавливает данные для возврата их клиенту (запрос start)
    * @return array Массив возвращаемых значений, cодержит:
    *  -  (array)  aGamend_list   :  передается по ссылке, массив с данными о игре
    */ 
    public function convertGame( $user_id, &$aGame ){
          try{
              
              $aGame["time_last_activity"]      = SConfig::$time - $aGame["time_last_activity"];

              return 1;
             } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "convertGame", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        } 
    }

    
    
    /**
    * Выдает награду участлинкам дуэли
    * @param  bigint $user_winner_id    номер пользователя в соц.сети
    * @param  bigint $user_loser_id     номер пользователя в соц.сети
    * @param  int    $flag_cancel_game  флаг отмены игры, если = 1, значит игрок отменивший игру(проигравший) не получает поощерительной награды
    * @return mix 
    */ 
    private function takeGamePrizeToPlayers($user_winner_id, $user_loser_id, $flag_cancel_game = 0, $flag_equal_results = 0){
        try{
               $game_win_prize_money1  = Model::factory ( 'var' )->loadByKey ( 'game_win_prize_money1' )->value;
               $game_lose_prize_money1 = Model::factory ( 'var' )->loadByKey ( 'game_lose_prize_money1' )->value;

               if(0 == $flag_equal_results){
                   Model::factory("user", $user_winner_id)->changeMoney($game_win_prize_money1,  0, 12);      //$reason_id = 12; //выигрыш в игре
                   if(0 == $flag_cancel_game){
                       Model::factory("user", $user_loser_id)->changeMoney($game_lose_prize_money1, 0, 13);     //$reason_id = 13; //проигрыш в игре
                   }
               } else {
                   if(0 == $flag_cancel_game){
                       Model::factory("user", $user_winner_id)->changeMoney($game_win_prize_money1,  0, 12);      //$reason_id = 12; //выигрыш в игре
                       Model::factory("user", $user_loser_id)->changeMoney($game_win_prize_money1,  0, 12);      //$reason_id = 12; //выигрыш в игре
                   } else {
                       Model::factory("user", $user_winner_id)->changeMoney($game_lose_prize_money1,  0, 13);      //$reason_id = 12; //выигрыш в игре
                       Model::factory("user", $user_loser_id)->changeMoney($game_lose_prize_money1,  0, 13);      //$reason_id = 12; //выигрыш в игре
                   }
               }
               return 1; 
               
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "takeGamePrize", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        } 
     }
     
    /**
    * Очищает базу от записей о игре 
    * @param  bigint $user_id  номер пользователя в соц. сети
    * @param  int    $game_id  номер игры в user_game
    * @return mix 
    */ 
     private function deleteGameData($user_id, $game_id){
        try{
               $list_round_id = Model::factory("user_round")->getList(array("user_game_id" => $game_id), array("id"));
               foreach($list_round_id as $round){ 
                    Model::factory("user_task")->deleteTaskSet($user_id, $round["id"]);
               }
               Model::factory("user_round")->deleteRoundSet($user_id, $game_id );
               Model::factory("user_game")->deleteGame($user_id, $game_id);
               Model::factory("user_game_ask_buffer", $game_id)->delete();
               //или Model::factory("user_game_ask_buffer")->delete(array("id" => $game_id));
              
               return 1; 
            
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "deleteGameData", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        } 
     }
     
     private function calculatePoints($user_id, $flag_round_success, $round_cancel_flag, $duration_client){
         try{
                //подсчет очков получаемых игроком за раунд
                $round_time_limit = Model::factory ( 'var' )->loadByKey ( 'round_time_limit' )->value;
                $round_max_prize_point = Model::factory ( 'var' )->loadByKey ( 'round_max_prize_point' )->value;
                $round_min_prize_point = Model::factory ( 'var' )->loadByKey ( 'round_min_prize_point' )->value;
                if(1 == $flag_round_success && 0 == $round_cancel_flag){
                    $points = ceil($round_min_prize_point + $flag_round_success * (($round_max_prize_point - $round_min_prize_point) * ($round_time_limit - $duration_client)/$round_time_limit));
                } else {
                    if(0 == $round_cancel_flag){
                        $points = $round_min_prize_point;
                    } else {
                        $points = 0;
                    }
                }
                
                return $points; 
            } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "calculatePoints", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        } 
     }
     
    
    /**
    * Возвращается полня информаци о игре, раунде и заданиях. в случае если передаваемые в 
    * фунцию массивы не пустые, то они дополняются новой игрой
    * 
    * @param  (bigint) $user_id     :   номер пользователя в соц.сети, чьи записи проверяются
    * @param  (int)    $game_id     :   номер пользователя в соц.сети, чьи записи проверяются
    * @param  (array)  &game_set    :   передается по ссылке, массив game_set дополняется массивом game
    * @param  (array)  &round_set   :   передается по ссылке, массив game_set дополняется массивом game
    * @param  (array)  &task_set    :   передается по ссылке, массив game_set дополняется массивом game
 
    * @return array
    */                
    private function getAllGameSet($user_id, $game_id, &$game_set, &$round_set, &$task_set, &$term_set){
        try{
             $game = Model::factory("user_game", $game_id)->get();

             if( $this->isPlayerTurn( $user_id , $game ) ){
                  $term_set[] = Model::factory("user_game_ask_buffer", $game["id"] )->get();
             }
                                  
             $list_round_set = Model::factory("user_round")->getList(array("user_game_id" => $game_id));
           
             foreach($list_round_set as $round){
                  $list_task_set = Model::factory("user_task")->getList(array("user_round_id" => $round["id"]));
                  foreach($list_task_set as $task){
                        
                       $task_stat     = Model::factory("task_stat",$task["task_stat_id"])->get();
                      
                       if(0 == $task["try_count"] || 1 == $task["result_user"] ){
                           $task["mask"] = $task_stat["question"]; 
                       } else {
                           $str_question  = Model::factory("word")->convert_to_in( $task_stat["question"] );
                           $str_word_mask = Model::factory("word")->get_word_mask( $str_question, $task[ 'bit_mask' ]);
                           $task["mask"]  = Model::factory("word")->convert_to_out($str_word_mask);
                       }
                   
                       unset( $task["bit_mask"] );
                       
                       $task_set[] =  $task;
                  }
                  Model::factory("user_round")->convertRound( $user_id, $round );
                  $round_set[] =  $round;
             }
             $this->convertGame( $user_id, $game );
             $game_set[] = $game;
             
      
        return 1;
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "getAllGameSet");
            throw new Exception ($e->getMessage(), $e->getCode());
        }         
    }
    
     private function copy_array($arr_in){
         $arr_out = array();
         foreach($arr_in as $key => $value){
             $arr_out[ $key ] = $value;
         }
         return $arr_out;
     }  
     
     /**
    * Возращает этого ли пользователя сейчас очередь или нет
    * 
    * @param  (bigint) $user_id     :   номер пользователя в соц.сети, чьи записи проверяются
    * @param  (array)  &game_set    :   передается по ссылке, массив game данные о игре, дуэли
    * @return (bool)
    */ 
      public function isPlayerTurn($user_id, &$aGame){
          try{
                if($aGame["active_user"] == 0){
                    if($aGame["user_id_0"] == $user_id){
                         return true;  
                    } else {
                         return false; 
                    }
                } else if($aGame["active_user"] == 1){
                    if($aGame["user_id_1"] == $user_id){
                         return true; 
                    } else {
                         return false;  
                    }
                }
              return false;  
          } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "whichPlayerTurn");
            throw new Exception ($e->getMessage(), $e->getCode());
          }
      }
      
    /**
    * Возвращается всех соперников с которыми уже начата игра
    * 
    * @param  (bigint) $user_id     :   номер пользователя в соц.сети, чьи записи проверяются

    * @return array user_id
    */                
    public function getActiveGameUsers($user_id){
        try{
             $arr_user_id = array();
             
             $list_game_in  = array();
             $list_game_out = array();
             

             $list_game_out  = Model::factory("user_game")->getList( array("user_id_0" => $user_id), array("user_id_1"));
             $list_game_in  = Model::factory("user_game")->getList( array("user_id_1" => $user_id), array("user_id_0"));

             foreach($list_game_out as $game_out){
                 $arr_user_id[] = $game_out["user_id_1"];
             }
             foreach($list_game_in as $game_in){
                 $arr_user_id[] = $game_in["user_id_0"];
             }              
            
        return $arr_user_id;
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "gameModel", "getActiveGameUsers");
            throw new Exception ($e->getMessage(), $e->getCode());
        }         
    }
}

================================================================================
ФАЙЛ: app/models/levelModel.php
================================================================================

<?php
/**
 * 
 * Класс модели пользователя
 */
class levelModel extends Model {
	
	protected $_tableName = 'levels';
	
}

================================================================================
ФАЙЛ: app/models/eventModel.php
================================================================================

<?php
/**
 * 
 */
class eventModel extends Model {
    
  protected $_tableName = 'event';

  
  

    /**
    * Проверка текущего события  
    * @return mix Созданный объект
    */ 
    public function checkActual( $user_id, $event_stat_id = -1, &$arr_event  = array() ){
        try{
           
            
            if($event_stat_id == -1){
                return 0;
            }
            $TimeNow = SConfig::$time;
            $count_of_days = 0;
            $visit_time    = 0;
            $visit_count   = 0;
            $fNewDay       = 0;
            
            $iTimeToUse = 0;
            
            if(!Model::factory('user', $user_id)->exist()){
                return -1;        
            } 
            
            if(!Model::factory("event_stat", $event_stat_id)->exist()){
               return -1;      
            }
            $aEventStat = Model::factory("event_stat", $event_stat_id)->get();
            
            if($aEventStat["enable_flag"] != 1){
                $arr_event = array();
                return -2; // event disable
            }
            
            
            $arr_event["user_id"]             = $user_id; 
            $arr_event["event_stat_id"]       = $event_stat_id; 
            
            
            $listEvent = Model::factory("event")->getList(array("user_id" => $user_id, "event_stat_id" => $event_stat_id), array("id"));
            if( !is_array($listEvent) || count($listEvent) == 0 ){
                $arr_event["time_to_use"]       = $iTimeToUse; 
                return 1;  
            } else {
                
                $arr_event["id"]                = $listEvent[0]["id"];
                $aEvent = Model::factory("event",$arr_event["id"])->get();
                
                //event записывается только если уже использовался, если replay_flag в event_stat такого эвента = 1, то его уже нельзя использовать повторно
                if($aEventStat["replay_flag"] != 1){
                   $arr_event = array();
                   return -3; // one time event, already use
                }    
            } 
            
           
            $last_event_time     = $aEvent["time"];
            
            $iTodayInYear  = date('z', $TimeNow);
            $iLastInYear   = date('z', $last_event_time);
            
            $iTodayYear    = date('Y', $TimeNow);
            $iLastYear     = date('Y', $last_event_time);
           
            
                       
            switch( $aEventStat["type_id"] ){
                case 0:{
                   
                     if($iTodayInYear != $iLastInYear || $iTodayYear != $iLastYear){
                          //НОВЫЙ ДЕНЬ  
                         $fNewDay        = 1;
                         $iTimeToUse = 0;
                     } else {
                         $dayStart = mktime(0,0,0);
                         $iTimeToUse =  mktime(23, 59, 59, date("m"), date("d"), date("Y")) - $TimeNow; 
                     } 
                } break;
            }
            
            $arr_event["time_to_use"]       = $iTimeToUse; 
            
            if($fNewDay == 1){
                return 1;
            } else {
                return 0;
            }
            
            
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "eventModel", "check", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        }  
    } 
    
    
    public function refreshAll( $user_id, &$arr_all_event  = array() ){
        try{
                                            
            $listEventStat = Model::factory("event_stat")->getList();
            foreach( $listEventStat as $event_stat ){
                $aEventCheck = array();
                $aEvent      = array();
                
                $result = Model::factory("event")->checkActual( $user_id, $event_stat["id"], $aEventCheck );
                
                switch($result){
                     case 1:{
                         $aEvent["event_stat_id" ] = $event_stat["id"];
                         $aEvent["time_to_use"] = 0;
                     } break;
                     case 0:{
                         $aEvent["event_stat_id" ] = $event_stat["id"];
                         $aEvent["time_to_use"] =  $aEventCheck["time_to_use"];
                     } break;
                     case -2:{
                         continue; 
                     } break;
                     case -3:{
                         continue; 
                     } break;
                     default:{
                         continue;   
                     } break;
               }

                if(is_array( $aEvent) && count($aEvent) != 0){
                    $arr_all_event[] = $aEvent;
                }
            }
                                            
          return 1;  
            
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "eventModel", "check", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        }  
    }  
    
    
    /**
    * Проверка текущего события  
    * @return mix Созданный объект
    */ 
    public function useEvent( $user_id, $event_stat_id = -1, &$arr_event = array(), &$arr_prize = array() ){
        try{
           
            $arr_prize["money1"]        = 0;
            $arr_prize["money2"]        = 0;
            $arr_prize["energy"]        = 0;
            $arr_prize["booster_type"]  = 0;
            $arr_prize["booster_count"] = 0;
            
            if($event_stat_id == -1){
                return 0;
            } 
            $aEvent = array();
            
            
            $resultCheck = Model::factory("event")->checkActual( $user_id, $event_stat_id, $aEvent );
            
            switch($resultCheck){
                     case 1:{
                         
                     } break;
                     case 0:{
                         $arr_event["time_to_use"] =  $aEvent["time_to_use"];
                         return 0;
                     } break;
                     case -2:{
                         return -2; 
                     } break;
                     case -3:{
                         return -3; 
                     } break;
                     default:{
                         return -1;  
                     } break;
               }
               
            $TimeNow = SConfig::$time;
            
            if(!is_array( $aEvent) || count($aEvent) == 0 ){
              $aEvent  = array("user_id" => $user_id, "event_stat_id" => $event_stat_id, "time" => $TimeNow);
                
            } else {
              $aEvent["time"] = $TimeNow;
            }
            
            
            $aEventStat = Model::factory("event_stat", $event_stat_id)->get();
            

            $prize_money1        =  $aEventStat["prize_money1"];
            $prize_money2        =  $aEventStat["prize_money2"];
            $prize_energy        =  $aEventStat["prize_energy"];
            $prize_booster_type  =  $aEventStat["prize_booster_type"];
            $prize_booster_count =  $aEventStat["prize_booster_count"];
          
           //выдача бонусов:
            //--------------------------------------------------------------------------------------------------------------
            //энергия
            if($prize_energy > 0){
                $energy = Model::factory('user', $user_id)->checkEnergyRecoveryStatus();
                $reason_id = 11; // Проверить!
                Model::factory('user', $user_id)->changeEnergy( $prize_energy,  $reason_id);
                $arr_prize["energy"] = $prize_energy;
            }
            //валюта
            if($prize_money1 > 0){
                $reason_id = 11; // Проверить!
                Model::factory('user', $user_id)->changeMoney( $prize_money1,  0, $reason_id);
                $arr_prize["money1"] = $prize_money1;
            }
            //валюта
            if($prize_money2 > 0){
                $reason_id = 11; // Проверить!
                Model::factory('user', $user_id)->changeMoney( 0,  $prize_money2, $reason_id);
                $arr_prize["money2"] = $prize_money2;
            }
            //бустеры
            
            if($prize_booster_type >= 0 && $prize_booster_count > 0){
                $array_booster[ $prize_booster_type ] = $prize_booster_count;
                Model::factory('user_booster', $user_id)->giveBooster( $array_booster );
                
                $arr_prize["booster_type"] = $prize_booster_type;
                $arr_prize["booster_count"] = $prize_booster_count;
                //--------------------------------------------------------------------------------------------------------------
            }
            
            
            //что тут не так? 
            //$aEvent
            unset($aEvent["time_to_use"]); 
            Model::factory("event")->create( $aEvent );
            
            
            $iTimeToUse =  mktime(23, 59, 59, date("m"), date("d"), date("Y")) - $TimeNow; 
               
           
            $arr_event["time_to_use"]   = $iTimeToUse;
            
            return 1;
            
        } catch(Exception $e) {
            
            LOG_CRASH::add($e->getCode(), $e->getMessage(), "eventModel", "check", $user_id);
            throw new Exception ($e->getMessage(), $e->getCode());
        }  
    }
    
       
}


      

================================================================================
ФАЙЛ: app/models/stage_timeModel.php
================================================================================

<?php
/**
 * 
 */
class stage_timeModel extends Model {
    
    protected $_tableName = 'stage_time';
    
}


================================================================================
ФАЙЛ: app/models/userModel.php
================================================================================

<?php
/**
 * 
 * Класс модели пользователя
 */
class userModel extends Model 
{
    protected $_client = false; 
    protected $_tableName = 'users';
    
    
    //--------------------------------------------------------------------------------------------------------------------------------------------------------------
    public function _after_construct(){ 
        if ($this->exist ()) 
        {
            ////////////////////////////////////////$this->_client = ($this->id == social::$authAPI->getUserId ());
          if ($this->_client) {
                //$this->update_online ();
            }
        }
    }   
    
    public function checkExist($raise = true) { 
        try{
            if (! $this->exist ()) 
            {
                if ($raise) 
                {
                   //return -1;
                   errors::exc ( 1 );
                } 
                else 
                {
                    return false;
                }
            } 
            else 
            {
                return true;
            }
        } catch (Exception $e){

             LOG_CRASH::add($e->getCode(), $e->getMessage(), "userModel", "checkExist");
             throw new Exception ($e->getMessage(), $e->getCode());
        }
    }
    
    /**
     * Проверка валидности идинтификационного ключа
     * @param $s_key идинтификационный ключ сессии
     * @return mixed|multitype: mixed
     */
    public function checkSessionKey($s_key = false){  
        try{
             $id_user = $this->id;
             $s_key_base =  Model::factory('session_key')->get_skey( $id_user );
            
             if($s_key_base == $s_key)
             {
                 return 1;
             }
             else
             {
                 errors::exc ( 217 , "invalid session key" ); 
                 return 0;     
             }
        } catch (Exception $e){

             LOG_CRASH::add($e->getCode(), $e->getMessage(), "userModel", "checkSessionKey", $this->id);
             throw new Exception ($e->getMessage(), $e->getCode());
        }
    }

     
    //--------------------------------------------------------------------------------------------------------------------------------------------------------------
    
    /**
    * ?нициализация конкретного пользователя в игре 
    * запрос вызывается клинетом при каждом новом запуске игры  
    * так же как и uset.newuser назначает новый ключ игровой сессии session_key
    * @return mix массив базовых динамических данных о пользователе 
    * @example: 
    */
    public function initUser( $first_input_flag = 0) {
        try{   
            $id_user = $this->id;
          
            //$aDailyBonus = Model::factory('dailybonus')->check($id_user);
            //----------------------------------------------------------------------------------
            
            $profile = Model::factory('user', $id_user)->getProfileData();
                   
            //$result = Model::factory('user', $id_user)->getProfile()
            $result['result']         = 1;
            
            $energy = Model::factory('user', $id_user)->checkEnergyRecoveryStatus();
          
            $result['user'] = array(
                'money1'                      => $profile['money1'],    
                'money2'                      => $profile['money2'],
                'energy'                      => $energy['energy'],
                'energy_max'                  => $energy['energy_max'],
                'time_to_next_recovery'       => $energy['time_to_next_recovery'],

                //'point'                       => $profile['point'],
                //'star'                        => $profile['star'],
				//'stage'                       => $this->stage //$profile[['stage'],
				/////'booster_slot_count'          => $this->booster_slot_count, //$profile[['stage']

			);
            //------------------------------------------------------------------------------------------------------------------------------------------------------- 
            $daily_bonus    = Model::factory('user_daily_actions', $id_user)->check();
     
            $result['user']["money1"]+= $daily_bonus["bonus_money1"]; 
            $result['user']["money2"]+= $daily_bonus["bonus_money2"];
            $result['user']["energy"]+= $daily_bonus["bonus_energy"];
            
            $result['daily_bonus'] = array("flag_daily_bonus" => $daily_bonus["flag_daily_bonus"], "count_of_days" => $daily_bonus["count_of_days"]);
            //лотерея
            
            
            $result['user']["money2"]+= $daily_bonus["bonus_lottery"]["money2"]; 
            $flag_lottery_bonus = 0;
            if($daily_bonus["bonus_lottery"]["money2"] > 0 ){
                $flag_lottery_bonus = 1;
            }
            
            $result['lottery_bonus'] =  array( "flag_lottery_bonus" => $flag_lottery_bonus);
            //-------------------------------------------------------------------------------------------------------------------------------------------------------
            
            $listUserBoosters          = Model::factory('user_booster')->getList(array('id' => $id_user));
            $aUserBoosters            = $listUserBoosters[0];
            unset($aUserBoosters['id']);
            $result['user_booster']   = $aUserBoosters;
            
            $result['company']   = Model::factory('company')->getListCompany($id_user);
            
            $result['stage']       = Model::factory('stage')->getListStage($id_user);
            
            $result['stage_key']   = Model::factory('stage')->getStageActualKey($id_user);
            
            $result['stage_time']  = Model::factory('stage')->getStageActualTime($id_user);
            
            $result['mission']     = Model::factory('mission')->getListMission($id_user);
            
            //-------------------------------------------------------------------------------------------------------------------------------------------------------
            $friend_bonus_list = array();
            $friend_bonus_money1 = 0;
            $friend_bonus_money2 = 0;
            $friend_bonus_energy = 0;
      
            Model::factory('user', $id_user)->checkInvitation( $friend_bonus_list, $friend_bonus_money1, $friend_bonus_money2, $friend_bonus_energy );
           
            $result['user']["money1"]+= $friend_bonus_money1; 
            $result['user']["money2"]+= $friend_bonus_money2; 
            $result['user']["energy"]+= $friend_bonus_energy; 
           
            $result['friend_bonus_list']      = $friend_bonus_list;
            //-------------------------------------------------------------------------------------------------------------------------------------------------------
            $result['first_input_flag'] = $first_input_flag;
            
            $arr_all_event              = array();
            Model::factory('event')->refreshAll($id_user, $arr_all_event);
            $result['arr_event']        = $arr_all_event;
            
             Model::factory("user_orders")->get_and_change_uninform_orders($id_user);
            
            if(SConfig::$session_key_flag == TRUE){
                $session_key = Model::factory("session_key")->set_skey($id_user);
                $result['s_key'] = $session_key;
            }
            
            
            
            return $result; 
        } catch (Exception $e){

             LOG_CRASH::add($e->getCode(), $e->getMessage(), "userModel", "initUser", $this->id);
             throw new Exception ($e->getMessage(), $e->getCode());
        }
             
    }
    
    /**
    * Получить профиль пользователя
    * @return mixed|multitype: mixed
    */   
    public function getProfileData(){ 
        try{             
            $not_full_field = array ('id', 'money1', 'money2', 'energy', 'energy_max');   

            if ($this->exist ()) 
            {          
                $data = $this->_data;
                $result = array ();
                foreach ( $not_full_field as $field ) 
                {
                    $result [$field] = $data [$field];
                }
            }
            else 
            {
                errors::exc ( 1 );
            }
                
            //$level = Model::factory ( 'level', $result ['level'] + 1 );
            //$result ['exp_next_level'] = $level->exist () ? $level->exp : 999999;
            //$user = $this->getProfile( true );
			$energy = $this->checkEnergyRecoveryStatus();

            $result['energy']                = $energy['energy'];
            $result['energy_max']            = $energy['energy_max'];
            $result['time_to_next_recovery'] = $energy['time_to_next_recovery'];  
            /////$result['energy_type']           = $energy['energy_type'];  
            /////$result['time_to_unlimited_end'] = $energy['time_to_unlimited_end'];

            unset($result["energy_type"]);
            unset($result["energy_recovery_start_date"]);
            unset($result["energy_unlimited_end_date"]);
            unset($result["point"]);
            unset($result["star"]);
            unset($result["stage"]); 
            
            return $result;
        } catch (Exception $e){

             LOG_CRASH::add($e->getCode(), $e->getMessage(), "userModel", "getProfileData");
             throw new Exception ($e->getMessage(), $e->getCode());
        }
    }
    //--------------------------------------------------------------------------------------------------------------------------------------------------------------
    
    
    /**
     * Получить профиль пользователя(ей). Если передан второй параметр то выдается массив профилей,
     * если нет - то профиль текущего
     * @param boolean $full - полный или частичный
     * @param multitype:number $ids - массив ID ползователей
     * @return mixed|multitype: mixed
     */
    public function getProfile($full = false, $ids = NULL){
        try{ 
            
            $id_user = $this->id;
            
            //errors::exc ( errors::errorIncorrectCommand, "ger profile crush");
            $not_full_field = array ('id', 'money1', 'money2', 'energy', 'energy_max'); 
           
            if (is_null ( $ids ))
            {
                if ($this->exist ()){
                    if ($full){
                        $result = $this->get ();
                    } 
                    else{
                        $data = $this->_data;
                        $result = array ();
                        foreach ( $not_full_field as $field ){
                            $result [$field] = $data [$field];
                        }
                    }
                }
                else{
                    errors::exc ( 1 );
                }
                //$level = Model::factory ( 'level', $result ['level'] + 1 );
                //------------------------------------------------------
                //------------------------------------------------------
                //------------------------------------------------------
                $energy = Model::factory('user', $id_user)->checkEnergyRecoveryStatus();
                    
                $result['energy']                = $energy['energy'];
                $result['energy_max']            = $energy['energy_max'];
                $result['time_to_next_recovery'] = $energy['time_to_next_recovery'];  
                
                $result['mission']   = Model::factory('mission')->getListMission($id_user);
                
                //------------------------------------------------------
                //------------------------------------------------------
                //------------------------------------------------------
                unset($result["energy_type"]);
                unset($result["energy_recovery_start_date"]);
                unset($result["energy_unlimited_end_date"]);
                unset($result["point"]);
                unset($result["star"]);
                unset($result["stage"]);
                //------------------------------------------------------
                //------------------------------------------------------
                //------------------------------------------------------
                    
                return $result;
            } 
            else 
            {
                if (! is_array ( $ids )){
                    errors::exc ( errors::errorIncorrectInput, 'Not array' );
                }
                foreach ( $ids as $id ) {
                    if (! is_numeric ( $id ))
                        errors::exc ( errors::errorIncorrectInput, 'User must be numeric' );
                }
                //foreach ( $ids as $key => $value ) {
                //    $ids [$key] = '\'' . $value . '\'';
                //}
                $fields = array();
                if (!$full) {
                    $fields = array ();
                    foreach ( $not_full_field as $field ) {
                        //$fields [] = $this->_tableName . '.' . $field;     
                        $fields [] =  $field;                       
                    }
                }
                foreach ( $ids as $key => $value ) {
					if(!Model::factory("user", $value)->exist()){
                        $result[] =  array("id" => $value);
                        continue;
                    }
                    $listUserFields = Model::factory('user')->getList(array( "id" => $value), $fields);
					$energy = Model::factory('user', $value)->checkEnergyRecoveryStatus();
                    
					$listUserFields[0]['energy']                = $energy['energy'];
                    $listUserFields[0]['energy_max']            = $energy['energy_max'];
                    $listUserFields[0]['time_to_next_recovery'] = $energy['time_to_next_recovery'];  
                    
                    $listUserFields[0]['mission']   = Model::factory('mission')->getListMission( $value );
                    /////$listUserFields[0]['energy_type']           = $energy['energy_type'];  
                    /////$listUserFields[0]['time_to_unlimited_end'] = $energy['time_to_unlimited_end']; 

                    
                    //------------------------------------------------------
                    //------------------------------------------------------
                    //------------------------------------------------------
                    unset($listUserFields[0]["energy_type"]);
                    unset($listUserFields[0]["energy_recovery_start_date"]);
                    unset($listUserFields[0]["energy_unlimited_end_date"]);
                    unset($listUserFields[0]["point"]);
                    unset($listUserFields[0]["star"]);
                    unset($listUserFields[0]["stage"]);
                    //------------------------------------------------------
                    //------------------------------------------------------
                    //------------------------------------------------------
                                     
					//$listUserFields[0]['mission']               =   Model::factory("mission")->getListMission( $value );
                    
                    
                    
                    $result[] = $listUserFields[0];
                }
               
                //$key = key($result);
                //$current = current($result);
                //$level = $current['level'];
                
                //$level = Model::factory ( 'level', $level + 1 );
                //$key = key($result);
                //$result [$key] = $current;
                
                return $result;
            }
        } catch (Exception $e){

             LOG_CRASH::add($e->getCode(), $e->getMessage(), "userModel", "getProfile");
             throw new Exception ($e->getMessage(), $e->getCode());
        }
    }
    //--------------------------------------------------------------------------------------------------------------------------------------------------------------
    
    
    /**
     * Сохранить профиль 
     * @return boolean
     */
    public function saveProfile() {
        try{
            
            
            $data = array ();
            $data ['id'] = $this->_data ['id'];
            
            /*    
            if (isset ( $rawData ['name'] ) && (! isset ( $this->_data ['name'] ) || (isset ( $this->_data ['name'] ) && $this->_data ['name'] != $rawData ['name']))) {
                $data ['name'] = validate::string ( $rawData ['name'], 255 );
            }
            */
            if ( $data ['id'] > 0) 
            {
                if ($this->exist ()) 
                {
                    $this->loadFromArray ( $data );
                    $result = $this->save ();
                } else {
                    $data ['money1']       = Model::factory ( 'var' )->loadByKey ( 'start_money1' )->value;
                    $data ['money2']       = Model::factory ( 'var' )->loadByKey ( 'start_money2' )->value;
                    $data ['level']        = 1;
                    $data ['energy']       = Model::factory ( 'var' )->loadByKey ( 'start_energy' )->value;
                    $data ['energy_max']   = Model::factory ( 'var' )->loadByKey ( 'start_energy_max' )->value;
                    
                    
                    //начислить ключи на этапы----------------------------------------------------------------- 
                    Model::factory("stage")->giveStageKeyToNewUser( $data ['id'] );
                    //----------------------------------------------------------------------------------------- 
                    
                    
                    
                    
                    /////$data ['energy_type']  = 0;
                    /////$data ['energy_recovery_start_date']   = 0;
                    //$data ['game_out']     = Model::factory ( 'var' )->loadByKey ( 'start_game_out' )->value;
                    //$data ['game_out_max'] = Model::factory ( 'var' )->loadByKey ( 'start_game_out_max' )->value;
                   
                   
