OurGamesForCourse

1
namespace PauchiaUkladka;
2

3
public class GameState
4
{
5
    private Block currentBlock;
6

7
    public Block CurrentBlock
8
    {
9
        get
10
        {
11
            return currentBlock;
12
        }
13
        private set
14
        {
15
            currentBlock = value;
16
            currentBlock.Reset();
17

18
            for (int i = 0; i < 2; i++)
19
            {
20
                currentBlock.Move(1, 0);
21

22
                if (BlockFits() == false)
23
                {
24
                    currentBlock.Move(-1, 0);
25
                }
26
            }
27
        }
28
    }
29

30
    public GameGrid GameGrid
31
    {
32
        get;
33
    }
34

35
    public BlockQueue BlockQueue
36
    {
37
        get;
38
    }
39

40
    public bool GameOver
41
    {
42
        get;
43
        private set;
44
    }
45
    
46
    public int Score
47
    {
48
        get;
49
        private set;
50
    }
51

52
    public Block HeldBlock
53
    {
54
        get;
55
        private set;
56
    }
57

58
    public bool CanHold
59
    {
60
        get;
61
        private set;
62
    }
63

64
    public GameState()
65
    {
66
        GameGrid = new GameGrid(22, 10);
67
        BlockQueue = new BlockQueue();
68
        CurrentBlock = BlockQueue.GetAndUpdate();
69
        CanHold = true;
70
    }
71

72
    public void HoldBlock()
73
    {
74
        if (CanHold == false)
75
        {
76
            return;
77
        }
78

79
        if (HeldBlock == null)
80
        {
81
            HeldBlock = CurrentBlock;
82
            CurrentBlock = BlockQueue.GetAndUpdate();
83
        }
84
        else
85
        {
86
            Block tmp = CurrentBlock;
87
            CurrentBlock = HeldBlock;
88
            HeldBlock = tmp;
89
        }
90

91
        CanHold = false;
92
    }
93

94
    private bool BlockFits()
95
    {
96
        foreach (Position p in CurrentBlock.TilePositions())
97
        {
98
            if (GameGrid.IsEmpty(p.Row, p.Column) == false)
99
            {
100
                return false;
101
            }
102
        }
103

104
        return true;
105
    }
106

107
    public void RotateBlockCW()
108
    {
109
        CurrentBlock.RoatateCW();
110

111
        if (BlockFits() == false)
112
        {
113
            CurrentBlock.RoatateCCW();
114
        }
115
    }
116
    
117
    public void RotateBlockCCW()
118
    {
119
        CurrentBlock.RoatateCCW();
120

121
        if (BlockFits() == false)
122
        {
123
            CurrentBlock.RoatateCW();
124
        }
125
    }
126

127
    public void MoveBlockLeft()
128
    {
129
        CurrentBlock.Move(0, -1);
130

131
        if (BlockFits() == false)
132
        {
133
            CurrentBlock.Move(0, 1);
134
        }
135
    }
136
    
137
    public void MoveBlockRight()
138
    {
139
        CurrentBlock.Move(0, 1);
140

141
        if (BlockFits() == false)
142
        {
143
            CurrentBlock.Move(0, -1);
144
        }
145
    }
146

147
    private bool IsGameOver()
148
    {
149
        if (GameGrid.IsRowEmpty(0) == false || GameGrid.IsRowEmpty(1) == false)
150
            return true;
151
        else
152
            return false;
153
    }
154

155
    private void PlaceBlock()
156
    {
157
        foreach (Position p in CurrentBlock.TilePositions())
158
        {
159
            GameGrid[p.Row, p.Column] = CurrentBlock.Id;
160
        }
161

162
        Score += GameGrid.ClearFullRows();
163

164
        if (IsGameOver())
165
        {
166
            GameOver = true;
167
        }
168
        else
169
        {
170
            CurrentBlock = BlockQueue.GetAndUpdate();
171
            CanHold = true;
172
        }
173
    }
174

175
    public void MoveBlockDown()
176
    {
177
        CurrentBlock.Move(1, 0);
178

179
        if (BlockFits() == false)
180
        {
181
            CurrentBlock.Move(-1, 0);
182
            PlaceBlock();
183
        }
184
    }
185

186
    private int TileDropDistance(Position p)
187
    {
188
        int drop = 0;
189

190
        while (GameGrid.IsEmpty(p.Row + drop + 1, p.Column))
191
        {
192
            drop++;
193
        }
194

195
        return drop;
196
    }
197

198
    public int BlockDropDistance()
199
    {
200
        int drop = GameGrid.Rows;
201

202
        foreach (Position p in CurrentBlock.TilePositions())
203
        {
204
            drop = Math.Min(drop, TileDropDistance(p));
205
        }
206

207
        return drop;
208
    }
209

210
    public void DropBlock()
211
    {
212
        CurrentBlock.Move(BlockDropDistance(), 0);
213
        PlaceBlock();
214
    }
215
}