russia.txt

在matlab中自己编写的一个俄罗斯方块的小游戏

            XScale = diff( AxesXLim ) / size(Picture, 2) ;
            YScale = diff( AxesYLim ) / size(Picture, 1) ;
            % 取较小比例压缩
            Scale = min( XScale, YScale ) ;
            ImageXLimit = size(Picture, 2) * Scale ;
            ImageYLimit = size(Picture, 1) * Scale ;
        end
        
        ImageXData(1) = AxesXLim(1) + (diff( AxesXLim ) - ImageXLimit) / 2 + 1;
        ImageXData(2) = ImageXData(1) + ImageXLimit - 1;
        ImageYData(1) = AxesYLim(1) + (diff( AxesYLim ) - ImageYLimit) / 2 + 1;
        ImageYData(2) = ImageYData(1) + ImageYLimit - 1;
                
        image( ValidPicture, 'Parent', handles.MainAxes, 'Hittest', 'off', ...
            'XData',ImageXData,'YData',ImageYData, 'Tag', 'MainImage' );
        setappdata( handles.RussiaBlock, 'ImageData', ValidPicture ) ;
    catch
        ErrorString = sprintf( ['读取图片失败，错误信息为:\n',lasterr] ) ;
        errordlg( ErrorString ) ;
    end
end


% -------------------------------------------------------------------------
function BlockColor_Callback( h )

handles = guidata( h ) ;

CurrentColor = getappdata( handles.RussiaBlock, 'BlockColor' ) ;
if isempty( CurrentColor )
    CurrentColor = GetDefaultBlockColor ;
    setappdata( handles.RussiaBlock, 'BlockColor', CurrentColor ) ;
end

NewColor = uisetcolor( CurrentColor, '请选择方块颜色' ) ;

if length( NewColor ) == 0
    return;
else
    setappdata( handles.RussiaBlock, 'BlockColor', NewColor ) ;
    set( handles.BlockHandle, 'MarkerFaceColor', NewColor ) ;
    set( handles.TempBlock, 'MarkerFaceColor', NewColor ) ; 
    set( handles.NextBlock, 'MarkerFaceColor', NewColor ) ;
end



% ------------------------------------------------------------------------
function Default_Callback( h )

handles = guidata( h ) ;

BlockColor = GetDefaultBlockColor ;
AxesColor = GetDefaultMainAxesColor ;

set( handles.MainAxes, 'Color', AxesColor ) ;
set( handles.BlockHandle, 'MarkerFaceColor', BlockColor ) ;
set( handles.TempBlock, 'MarkerFaceColor', BlockColor ) ;
set( handles.NextBlock, 'MarkerFaceColor', BlockColor ) ;


% -------------------------------------------------------------------------
function PauseGame_Callback( h )

handles = guidata( h ) ;

ToolStart = get( handles.PauseTool, 'State' ) ;

if strcmp( ToolStart, 'on' )
    set( handles.PauseButton, 'Value', 1 ) ;
    waitfor( handles.PauseTool, 'State', 'off' ) ;
else
    set( handles.PauseButton, 'Value', 0 ) ;
end


% -------------------------------------------------------------------------
function ButtonPauseGame_Callback( h )

handles = guidata( h ) ;

ToggleButtonValue = get( h, 'Value' ) ;

if ToggleButtonValue == 0
    set( h, 'Value', 1 ) ;
    set( h, 'String', '继续' ) ;
    set( handles.PauseTool, 'State', 'on' ) ;
    waitfor( handles.PauseTool, 'State', 'off' ) ;
else
    set( h, 'Value', 0 ) ;
    set( h, 'String', '暂停' ) ;
    set( handles.PauseTool, 'State', 'off' ) ;
    set( handles.RussiaBlock, 'CurrentObject', handles.MainAxes ) ;
end


% ------------------------------------------------------------------------
function CloseFigure_Callback( h )

handles = guidata( h ) ;

BlockColor = getappdata( handles.RussiaBlock, 'BlockColor' ) ;
MainAxesColor = get( handles.MainAxes, 'Color' ) ;
MainAxesImageHandle = findobj( handles.MainAxes, 'Type', 'image' ) ;
if ~isempty( MainAxesImageHandle )
    MainAxesImage.Property.Tag = get( MainAxesImageHandle, 'Tag' );
    MainAxesImage.Property.Hittest = get( MainAxesImageHandle, 'Hittest' );
    MainAxesImage.Property.XData = get( MainAxesImageHandle, 'XData' );
    MainAxesImage.Property.YData = get( MainAxesImageHandle, 'YData' );
    MainAxesImage.ImageData = getappdata( handles.RussiaBlock, 'ImageData' ) ;
else
    MainAxesImage.ImageData = [] ;
end

save ColorInfo.mat BlockColor MainAxesColor MainAxesImage

delete( handles.RussiaBlock ) ;


% -------------------------------------------------------------------------
function Color = GetDefaultBlockColor

Color = [0 0 1] ;


% -------------------------------------------------------------------------
function Color = GetDefaultMainAxesColor

Color = [1 1 1] ;


% ----------------------------------------------------------------
function [BlockXArray, BlockYArray] = Com_GetBlock( varargin )

global BlockIndex ;

BlockXArray = [] ;
BlockYArray = [] ;

handles = guidata( varargin{1} ) ;

if nargin == 1
    BlockArray = getappdata( handles.RussiaBlock, 'BlockArray' ) ;
    BlockIndex = ceil( rand(1) * 24 ) ;
else % nargin == 2
    BlockIndex = varargin{2} ;
end
   
switch(BlockIndex)
    case {1,2,3,4} % 方块
        BlockXArray = [0;0;1;1] * 20 - 10 ;
        BlockYArray = [0;1;1;0] * 20 - 10 ;
    case {5,6}     % 竖长条
        BlockXArray = [0;0;0;0] * 20 - 10 ;
        BlockYArray = [-1;0;1;2] * 20 - 10 ;
    case {7,8}     % 横长条
        BlockXArray = [-1;0;1;2] * 20 - 10 ;
        BlockYArray = [1;1;1;1] * 20 - 10 ;
    case {9}       % 4类T T1
        BlockXArray = [-1;0;1;0] * 20 - 10 ;
        BlockYArray = [1;1;1;0] * 20 - 10 ;
    case {10}      % T2
        BlockXArray = [0;0;1;0] * 20 - 10 ;
        BlockYArray = [2;1;1;0] * 20 - 10 ;
    case {11}      % T3
        BlockXArray = [0;0;1;-1] * 20 - 10 ;
        BlockYArray = [2;1;1;1] * 20 - 10 ;
    case {12}      % T4
        BlockXArray = [0;0;0;-1] * 20 - 10 ;
        BlockYArray = [2;1;0;1] * 20 - 10 ;
    case {13}      % 8类L L1
        BlockXArray = [0;0;0;1] * 20 - 10 ;
        BlockYArray = [1;0;-1;-1] * 20 - 10 ;
    case {14}      % L2
        BlockXArray = [-1;0;1;1] * 20 - 10 ;
        BlockYArray = [0;0;0;1] * 20 - 10 ;
    case {15}      % L3
        BlockXArray = [-1;0;0;0] * 20 - 10 ;
        BlockYArray = [1;1;0;-1] * 20 - 10 ;
    case {16}      % L4 
        BlockXArray = [-1;-1;0;1] * 20 - 10 ;
        BlockYArray = [-1;0;0;0] * 20 - 10 ;
    case {17}      % L5
        BlockXArray = [-1;0;0;0] * 20 - 10 ;
        BlockYArray = [-1;-1;0;1] * 20 - 10 ;
    case {18}      % L6
        BlockXArray = [-1;-1;0;1] * 20 - 10 ;
        BlockYArray = [1;0;0;0] * 20 - 10 ;
    case {19}      % L7
        BlockXArray = [0;0;0;1] * 20 - 10 ;
        BlockYArray = [-1;0;1;1] * 20 - 10 ;
    case {20}      % L8
        BlockXArray = [-1;0;1;1] * 20 - 10 ;
        BlockYArray = [0;0;0;-1] * 20 - 10 ;
    case {21 22}   % 4类Z Z1
        BlockXArray = [-1;0;0;1] * 20 - 10 ;
        BlockYArray = [1;1;0;0] * 20 - 10 ;
    case {23 24}   % Z2
        BlockXArray = [0;0;1;1] * 20 - 10 ;
        BlockYArray = [-1;0;0;1] * 20 - 10 ;
    case {25 26}   % Z3
        BlockXArray = [-1;0;0;1] * 20 - 10 ;
        BlockYArray = [0;0;1;1] * 20 - 10 ;
    case {27 28}   % Z4
        BlockXArray = [0;0;1;1] * 20 - 10 ;
        BlockYArray = [1;0;0;-1] * 20 - 10 ;
end

if nargin == 1
    NewBlockArray.BlockXArray = BlockXArray ;
    NewBlockArray.BlockYArray = BlockYArray ;
    NewBlockArray.BlockIndex = BlockIndex ;    
    NextAxesXLim = get( handles.NextBlockAxes, 'XLim' ) ;
    NextAxesYLim = get( handles.NextBlockAxes, 'YLim' ) ;
    set( handles.NextBlock, 'XData', [BlockXArray + 0.5 * diff( NextAxesXLim ) - ceil( sum( BlockXArray ) / 4 ) ],...
            'YData', [BlockYArray + 0.5 * diff( NextAxesYLim )] - ceil( sum( BlockYArray ) / 4 )  ) ;
    setappdata( handles.RussiaBlock, 'BlockArray', NewBlockArray ) ;
    if isempty( BlockArray ) 
        Com_GetBlock( varargin{1} ) ;
    else
        BlockXArray = BlockArray.BlockXArray ;
        BlockYArray = BlockArray.BlockYArray ;
        BlockIndex = BlockArray.BlockIndex ;
    end
    
end

AxesXLim = getappdata( handles.RussiaBlock, 'XLim' ) ;
AxesYLim = getappdata( handles.RussiaBlock, 'YLim' ) ;

BlockXArray = BlockXArray + 0.5 * diff( AxesXLim ) ; 
BlockYArray = BlockYArray + diff( AxesYLim ) ;


% -------------------------------------------------------------------------
function Status = test_MoveBlock( h, MoveMode ) 

Status = 1;
if ~ishandle( h )
    return
end

handles = guidata( h ) ;

TempXData = get( handles.TempBlock, 'XData' ) ;
TempYData = get( handles.TempBlock, 'YData' ) ;
TempXData = TempXData';
TempYData = TempYData' ;

TotalXData = get( handles.BlockHandle, 'XData' ) ;
TotalYData = get( handles.BlockHandle, 'YData' ) ;
TotalXData = TotalXData' ;
TotalYData = TotalYData' ;

TempBlockPos = getappdata( handles.RussiaBlock, 'TempBlockPos' ) ;
if isempty( TempBlockPos ) 
    return
end

AxesXLim = getappdata( handles.RussiaBlock, 'XLim' ) ;
AxesYLim = getappdata( handles.RussiaBlock, 'YLim' ) ;
 
switch MoveMode
    case 'Left'
        if any( TempXData - 20 < AxesXLim(1) )
            return
        end
        TestArray = ismember( [TempXData - 20, TempYData], [TotalXData, TotalYData], 'rows' ) ;
        if any( TestArray )
            return;
        else
            set( handles.TempBlock, 'XData', TempXData - 20 ) ;
            TempBlockPos.LeftStep = TempBlockPos.LeftStep + 1 ;
            setappdata( handles.RussiaBlock, 'TempBlockPos', TempBlockPos ) ;
        end
    case 'Right'
      if any( TempXData + 20 > AxesXLim(2) )
            return
      end
      TestArray = ismember( [TempXData + 20, TempYData], [TotalXData, TotalYData], 'rows' ) ;
        if any( TestArray )
            return;
        else
            set( handles.TempBlock, 'XData', TempXData + 20 ) ;
            TempBlockPos.LeftStep = TempBlockPos.LeftStep - 1 ;
            setappdata( handles.RussiaBlock, 'TempBlockPos', TempBlockPos ) ;
        end      
    case 'Down'
        if any( TempYData - 20 < AxesYLim(1) )
            set( handles.BlockHandle, 'XData', [TotalXData; TempXData],...
                'YData', [TotalYData; TempYData] ) ;
            Status = 0 ;
            return
        end
        TestArray = ismember( [TempXData, TempYData - 20], [TotalXData, TotalYData], 'rows' ) ;
        if any( TestArray )
            set( handles.BlockHandle, 'XData', [TotalXData; TempXData],...
                'YData', [TotalYData; TempYData] ) ;
            Status = 0 ;
        else
            set( handles.TempBlock, 'YData', TempYData - 20 ) ;
            TempBlockPos.DownStep = TempBlockPos.DownStep + 1 ;
            setappdata( handles.RussiaBlock, 'TempBlockPos', TempBlockPos ) ;
        end 
    case 'Drop'
        global PauseTime
        PauseTime = 0 ;
    case 'Change'
        global BlockIndex
        OldBlockIndex = BlockIndex ;
        switch BlockIndex
            case {1,2,3,4}
                return;
            case {5,6}
                NewIndex = 7 ;                
            case {7,8}
                NewIndex = 5 ;
            case {9,10,11,12}
                NewIndex = mod( OldBlockIndex, 4 ) + 9;
            case {13,14,15,16}
                NewIndex = mod( OldBlockIndex, 4 ) + 13;
            case {17,18,19,20}
                NewIndex = mod( OldBlockIndex, 4 ) + 17;
            case {21,22}
                NewIndex = 23;
            case {23,24}
                NewIndex = 21;
            case {25,26}
                NewIndex = 27 ;
            case {27,28}
                NewIndex = 25 ;
        end
        [BlockXArray, BlockYArray] = Com_GetBlock( h, NewIndex ) ;
        NewTempXData = BlockXArray - TempBlockPos.LeftStep * 20 ;
        NewTempYData = BlockYArray - TempBlockPos.DownStep * 20 ;
        if any( NewTempXData < AxesXLim(1) ) | any( NewTempXData > AxesXLim(2) ) |...
                any( NewTempYData < AxesYLim(1) )
            BlockIndex = OldBlockIndex ;
            return;
        end
        TestArray = ismember( [NewTempXData, NewTempYData], [TotalXData, TotalYData], 'rows' ) ;
        if any( TestArray )
            BlockIndex = OldBlockIndex ;
        else
            BlockIndex = NewIndex ;
            set( handles.TempBlock, 'XData', NewTempXData, 'YData', NewTempYData ) ;
        end
        
end


% -------------------------------------------------------------------------
function UpdateGameLevel( FigureHandle, Score ) ;

GameLevel = ceil( Score / 10000 ) ;

if GameLevel > 9 
    GameLevel = 9 ;
end

setappdata( FigureHandle, 'GameLevel', GameLevel ) ;


% -------------------------------------------------------------------------
function GameLevel_Callback( h ) 

handles = guidata( h ) ;

ScoreFigure = figure( 'name', '游戏难度设置', 'menubar', 'none', 'numbertitle', 'off',...
    'pos', [200 200 200 180], 'windowstyle', 'modal', 'resize', 'off' ) ;

uicontrol( 'Parent', ScoreFigure, 'Style', 'listbox', 'Pos', [20 20 80 140],...
    'String', [sprintf( '%d 级|', 1:8 ),'9 级'] ) ;
uicontrol( 'Parent', ScoreFigure, 'Style', 'pushbutton', 'Pos', [120 100 60 50], 'String', '确定',...
    'Cal', ['GameLevel = get( findobj( ''Style'', ''listbox''), ''Value'');',...
    'set( 0, ''Userdata'', GameLevel ); close( gcf );'] ) ;
uicontrol( 'Parent', ScoreFigure, 'Style', 'pushbutton', 'Pos', [120 30 60 50], 'String', '取消',...
    'Cal', 'close( gcf )' ) ;

waitfor( ScoreFigure ) ;

ButtonAction = questdlg( '重新设置游戏难度将初始化界面,是否继续?', '设置确认', '是的', '取消', '取消' ) ;

if strcmp( '取消', ButtonAction )
   return
end

GameLevel = get( 0, 'Userdata' ) ;

setappdata( handles.RussiaBlock, 'GameLevel', GameLevel ) ;