pdf to jpg c# open source : Change pdf document security properties control SDK system web page wpf .net console makinggames16-part641

Chapter 6 
Wormy
143 
>>> 
Drawing the Screen 
101.         DISPLAYSURF.fill(BGCOLOR) 
102.         drawGrid() 
103.         drawWorm(wormCoords) 
104.         drawApple(apple) 
105.         drawScore(len(wormCoords) - 3) 
106.         pygame.display.update() 
107.         FPSCLOCK.tick(FPS) 
The code for drawing the screen in the 
runGame()
function is fairly simple. Line 101 fills in 
the entire display Surface with the background color. Lines 102 to 105 draw the grid, worm, 
apple, and score to the display Surface. Then the call to 
pygame.display.update()
draws 
the display Surface to the actual computer screen. 
Drawing “Press a key” Text to the Screen 
109. def drawPressKeyMsg(): 
110.     pressKeySurf = BASICFONT.render('Press a key to play.', True, 
DARKGRAY) 
111.     pressKeyRect = pressKeySurf.get_rect() 
112.     pressKeyRect.topleft = (WINDOWWIDTH - 200, WINDOWHEIGHT - 30) 
113.     DISPLAYSURF.blit(pressKeySurf, pressKeyRect) 
While the start screen animation is playing or the game over screen is being shown, there will be 
some small text in the bottom right corner that says ―Press a key to play.‖ Rather than have the 
code typed out in both the 
showStartScreen()
and the 
showGameOverScreen()
, we 
put it in a this separate function and simply call the function from 
showStartScreen()
and 
showGameOverScreen()
The checkForKeyPress() Function 
116. def checkForKeyPress(): 
117.     if len(pygame.event.get(QUIT)) > 0: 
118.         terminate() 
119.  
120.     keyUpEvents = pygame.event.get(KEYUP) 
121.     if len(keyUpEvents) == 0: 
122.         return None 
123.     if keyUpEvents[0].key == K_ESCAPE: 
124.         terminate() 
125.     return keyUpEvents[0].key 
Change pdf document security properties - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF
Help to Improve the Security of Your PDF File by Adding Digital Signatures
change security settings pdf reader; create pdf security
Change pdf document security properties - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures
change pdf document security properties; pdf password security
144    
http://inventwithpython.com/pygame
Email questions to the author: al@inventwithpython.com 
This function first checks if there are any 
QUIT
events in the event queue. The call to 
pygame.event.get()
on line 117 returns a list of all the 
QUIT
events in the event queue 
(because we pass 
QUIT
as an argument). If there are not 
QUIT
events in the event queue, then 
the list that 
pygame.event.get()
returns will be the empty list: 
[]
The 
len()
call on line 117 will return 
0
if 
pygame.event.get()
returned an empty list. If 
there are more than zero items in the list returned by 
pygame.event.get()
(and remember, 
any items in this list will only be 
QUIT
events because we passed 
QUIT
as the argument to 
pygame.event.get()
), then the 
terminate()
function gets called on line 118 and the 
program terminates. 
After that, the call to 
pygame.event.get()
gets a list of any 
KEYUP
events in the event 
queue. If the key event is for the Esc key, then the program terminates in that case as well. 
Otherwise, the first key event object in the list that was returned by 
pygame.event.get()
is 
returned from this 
checkForKeyPress()
function. 
The Start Screen 
128. def showStartScreen(): 
129.     titleFont = pygame.font.Font('freesansbold.ttf', 100) 
130.     titleSurf1 = titleFont.render('Wormy!', True, WHITE, DARKGREEN) 
131.     titleSurf2 = titleFont.render('Wormy!', True, GREEN) 
132.  
133.     degrees1 = 0 
134.     degrees2 = 0 
135.     while True: 
136.         DISPLAYSURF.fill(BGCOLOR) 
When the Wormy game program first begins running, the player doesn’t automatically begin 
playing the game. Instead, a start screen appears which tells the player what program they are 
running. A start screen also gives the player a chance to prepare for the game to begin (otherwise 
the player might not be ready and crash on their first game). 
The Wormy start screen requires two Surface objects with the ―Wormy!‖ text 
drawn on them. 
These are what the 
render()
method calls create on lines 130 and 131. The text will be large: 
the 
Font()
constructor function call on line 129 creates a Font object that is 100 points in size. 
The first ―Wormy!‖ text will have white text wit
h a dark green background, and the other will 
have green text with a transparent background. 
Line 135 begins the animation loop for the start screen. During this animation, the two pieces of 
text will be rotated and drawn to the display Surface object. 
C# PDF Password Library: add, remove, edit PDF file password in C#
To help protect your PDF document in C# project, XDoc.PDF provides some PDF security settings. C# Sample Code: Change and Update PDF Document Password in C#
cannot print pdf security; change pdf security settings reader
C# HTML5 Viewer: Deployment on ASP.NET MVC
RasterEdge.XDoc.PDF.HTML5Editor.dll. click MyMVCApplication and select "properties". validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
decrypt a pdf; add security to pdf document
Chapter 6 
Wormy
145 
Rotating the Start Screen Text 
137.         rotatedSurf1 = pygame.transform.rotate(titleSurf1, degrees1) 
138.         rotatedRect1 = rotatedSurf1.get_rect() 
139.         rotatedRect1.center = (WINDOWWIDTH / 2, WINDOWHEIGHT / 2) 
140.         DISPLAYSURF.blit(rotatedSurf1, rotatedRect1) 
141.  
142.         rotatedSurf2 = pygame.transform.rotate(titleSurf2, degrees2) 
143.         rotatedRect2 = rotatedSurf2.get_rect() 
144.         rotatedRect2.center = (WINDOWWIDTH / 2, WINDOWHEIGHT / 2) 
145.         DISPLAYSURF.blit(rotatedSurf2, rotatedRect2) 
146.  
147.         drawPressKeyMsg() 
148.  
149.         if checkForKeyPress(): 
150.             pygame.event.get() # clear event queue 
151.             return 
152.         pygame.display.update() 
153.         FPSCLOCK.tick(FPS) 
The 
showStartScreen()
function will rotate the images on the Surface objects that the 
―Wormy!‖ text is written on. The first parameter is the Surface object to make a rotated copy of. 
The second parameter is the number of degrees to rotate the Surface. The 
pygame.transform.rotate()
function doesn’t change the Surface object you pass it, but 
rather returns a new Surface object with the rotated image drawn on it. 
Note that this new Surface object will probably be larger than the original one, since all Surface 
objects represent rectangular areas and the corners of the rotated Surface will stick out past the 
width and height of original Surface. The picture below has a black rectangle along with a 
slightly rotated version of itself. In order to make a Surface object that can fit the rotated 
rectangle (which is colored gray in the picture below), it must be larger than the original black 
rectangle
’s Surface object
The amount you rotate it is given in degrees, which is a measure of rotation. There are 360 
degrees in a circle. Not rotated at all is 0 degrees. Rotating to one quarter counter-clockwise is 90 
degrees. To rotate clockwise, pass a negative integer. Rotating 360 degrees is rotating the image 
all the way around, which means you end up with the same image as if you rotated it 0 degrees. In 
fact, if the rotation argument you pass to 
pygame.transform.rotate()
is 360 or larger, 
VB Imaging - VB Codabar Generator
check digit function for user's security consideration. Right click the project -> Properties -> Build -> Platform Create Codabar on Certain PDF Document Area.
decrypt pdf password online; pdf security options
C# Imaging - C# MSI Plessey Barcode Tutorial
to automatically add checksum digit for better data security. Plessey barcode at certain area of a document file, like Word, Excel, PowerPoint, PDF and TIFF
can print pdf security; pdf password unlock
146    
http://inventwithpython.com/pygame
Email questions to the author: al@inventwithpython.com 
then Pygame automatically keeps subtracting 360 from it until it gets a number less than 360. 
This image shows several examples of different rotation amounts: 
The two rotated ―Wormy!‖ Surface objects are blitted to the display Surface on each frame of the 
animation loop on lines 140 and 145. 
On line 147 the 
drawPressKeyMsg()
function call draws the ―
Press a key to play.
‖ text in 
the 
lower corner of the display Surface object. This animation loop will keep looping until 
checkForKeyPress()
returns a value that is not 
None
, which happens if the player presses a 
key. Before returning, 
pygame.event.get()
is called simply to clear out any other events 
that have accumulated in the event queue which the start screen was displayed. 
Rotations Are Not Perfect 
You may wonder why we store the rotated Surface in a separate variable, rather than just 
overwrite the 
titleSurf1
and 
titleSurf2
variables. There are two reasons. 
First, rotating a 2D image is never completely perfect. The rotated image is always approximate. 
If you rotate an image by 10 degrees counterclockwise, and then rotate it back 10 degrees 
clockwise, the image you have will not be the exact same image you started with. Think of it as 
making a photocopy, and then a photocopy of the first photocopy, and the another photocopy of 
that photocopy. If you keep doing this, the image gets worse and worse as the slight distortions 
add up. 
(The only exception to this is if you rotate an image by a multiple of 90 degrees, such as 0, 90, 
180, 270, or 360 degrees. In that case, the pixels can be rotated without any distortion.) 
Second, if you rotate a 2D image then the rotated image will be slightly larger than the original 
image. If you rotate that rotated image, then the next rotated image will be slightly larger again. If 
you keep doing this, eventually the image will become too large for Pygame to handle, and your 
VB Imaging - VB Code 93 Generator Tutorial
to create Code 93 barcode on a certain page of PDF or Word document in VB Easy to use barcode relocation API solution to change barcode position within VB
pdf secure signature; add security to pdf in reader
C# Imaging - Decode Code 93 Barcode in C#.NET
a higher density and data security enhancement to Right click the project -> Properties -> Build -> Platform & recognition from PDF document, our RasterEdge
decrypt pdf password; pdf security password
Chapter 6 
Wormy
147 
program will crash with the error message, 
pygame.error: Width or height is too 
large
154.         degrees1 += 3 # rotate by 3 degrees each frame 
155.         degrees2 += 7 # rotate by 7 degrees each frame 
The amount that we rotate the two ―Wormy!‖ text Surface objects is stored in degrees1
and 
degrees2
. On each iteration through the animation loop, we increase the number stored in 
degrees1
by 
3
and 
degrees2
by 
7
. This means on the next iteration of the animation loop 
the white text ―Wormy!‖ Surface object will 
be rotated by another 3 degrees and the green text 
―Wormy!‖ Surface object will be rotated by another 7 degrees.
This is why the one of the Surface 
objects rotates slower than the other. 
158. def terminate(): 
159.     pygame.quit() 
160.     sys.exit() 
The 
terminate()
function calls 
pygame.quit()
and 
sys.exit()
so that the game 
correctly shuts down. It is identical to the 
terminate()
functions in the previous game 
programs. 
Deciding Where the Apple Appears 
163. def getRandomLocation(): 
164.     return {'x': random.randint(0, CELLWIDTH - 1), 'y': random.randint(0, 
CELLHEIGHT - 1)} 
The 
getRandomLocation()
function is called whenever new coordinates for the apple are 
needed. This function returns a dictionary with keys 
'x'
and 
'y'
, with the values set to random 
XY coordinates. 
Game Over Screens 
167. def showGameOverScreen(): 
168.     gameOverFont = pygame.font.Font('freesansbold.ttf', 150) 
169.     gameSurf = gameOverFont.render('Game', True, WHITE) 
170.     overSurf = gameOverFont.render('Over', True, WHITE) 
171.     gameRect = gameSurf.get_rect() 
172.     overRect = overSurf.get_rect() 
173.     gameRect.midtop = (WINDOWWIDTH / 2, 10) 
174.     overRect.midtop = (WINDOWWIDTH / 2, gameRect.height + 10 + 25) 
175.  
176.     DISPLAYSURF.blit(gameSurf, gameRect) 
C# Imaging - C# Code 93 Generator Tutorial
Users can freely adjust the coordinates to change barcode location on Create Code 93 on C# Document Page. Code 93 linear barcode pictures on PDF documents, multi
convert locked pdf to word; convert secure webpage to pdf
148    
http://inventwithpython.com/pygame
Email questions to the author: al@inventwithpython.com 
177.     DISPLAYSURF.blit(overSurf, overRect) 
178.     drawPressKeyMsg() 
179.     pygame.display.update() 
The game over screen 
is similar to the start screen, except it isn’t animated. The words ―Game‖ 
and ―Over‖ are 
rendered to two Surface objects which are then drawn on the screen. 
180.     pygame.time.wait(500) 
181.     checkForKeyPress() # clear out any key presses in the event queue 
182.  
183.     while True: 
184.         if checkForKeyPress(): 
185.             pygame.event.get() # clear event queue 
186.             return 
The Game Over text will stay on the screen until the player pushes a key. Just to make sure the 
player doesn’t accidentally press a key too soon, we will put a half second pause with the call to 
pygame.time.wait()
on line 180. (The 500 argument stands for a 500 millisecond pause, 
which is half of one second.)  
Then, 
checkForKeyPress()
is called so that any key events that were made since the 
showGameOverScreen()
function started are ignored. This pause and dropping of the key 
events is to prevent the following situation: Say the player was trying to turn away from the edge 
of the screen at the last minute, but pressed the key too late and crashed into the edge of the 
board. If this happens, then the key press would have happened after the 
showGameOverScreen()
was called, and that key press would cause the game over screen to 
disappear almost instantly. The next game would start immediately after that, and might take the 
player by surprise. Adding this pause helps the make the game more ―user friendly‖.
Drawing Functions 
The code to draw the score, worm, apple, and grid are all put into separate functions. 
188. def drawScore(score): 
189.     scoreSurf = BASICFONT.render('Score: %s' % (score), True, WHITE) 
190.     scoreRect = scoreSurf.get_rect() 
191.     scoreRect.topleft = (WINDOWWIDTH - 120, 10) 
192.     DISPLAYSURF.blit(scoreSurf, scoreRect) 
The 
drawScore()
function simply renders and draws the text of the score that was passed in 
its 
score
parameter on the display Surface object. 
Chapter 6 
Wormy
149 
195. def drawWorm(wormCoords): 
196.     for coord in wormCoords: 
197.         x = coord['x'] * CELLSIZE 
198.         y = coord['y'] * CELLSIZE 
199.         wormSegmentRect = pygame.Rect(x, y, CELLSIZE, CELLSIZE) 
200.         pygame.draw.rect(DISPLAYSURF, DARKGREEN, wormSegmentRect) 
201.         wormInnerSegmentRect = pygame.Rect(x + 4, y + 4, CELLSIZE - 8, 
CELLSIZE - 8) 
202.         pygame.draw.rect(DISPLAYSURF, GREEN, wormInnerSegmentRect) 
The 
drawWorm()
function will draw a green box for each of the segments of the worm’s body. 
The segments are passed in the 
wormCoords
parameter, which is a list of dictionaries each with 
an 
'x'
key and a 
'y'
key. The 
for
loop on line 196 loops through each of the dictionary values 
in 
wormCoords
Because the grid coordinates take up the entire window and also begin a 0, 0 pixel, it is fairly 
easy to convert from grid coordinates to pixel coordinates. Line 197 and 198 simply multiply the 
coord['x']
and 
coord['y']
coordinate by the 
CELLSIZE
Line 199 creates a Rect object for the worm segment that will be passed to the 
pygame.draw.rect()
function on line 200. Remember that each cell in the grid is 
CELLSIZE
in width and height, so that’s what the size of the segment’s Rect object should be. 
Line 200 draws a dark green rectangle for the segment. Then on top of this, a smaller bright green 
rectangle is drawn. This makes the worm look a little nicer.  
The inner bright green rectangle starts 4 pixels to the right and 4 pixels below the topleft corner of 
the cell. The width and height of this rectangle are 8 pixels less than the cell size, so there will be 
a 4 pixel margin on the right and bottom sides as well. 
205. def drawApple(coord): 
206.     x = coord['x'] * CELLSIZE 
207.     y = coord['y'] * CELLSIZE 
208.     appleRect = pygame.Rect(x, y, CELLSIZE, CELLSIZE) 
209.     pygame.draw.rect(DISPLAYSURF, RED, appleRect) 
The 
drawApple()
function is very similar to 
drawWorm()
, except since the red apple is just 
a single rectangle that fills up the cell, all the function needs to do is convert to pixel coordinates 
(which is what lines 206 and 207 do), create the Rect object with the location and size of the 
apple (line 208), and then pass this Rect object to the 
pygame.draw.rect()
function. 
212. def drawGrid(): 
213.     for x in range(0, WINDOWWIDTH, CELLSIZE): # draw vertical lines 
150    
http://inventwithpython.com/pygame
Email questions to the author: al@inventwithpython.com 
214.         pygame.draw.line(DISPLAYSURF, DARKGRAY, (x, 0), (x, WINDOWHEIGHT)) 
215.     for y in range(0, WINDOWHEIGHT, CELLSIZE): # draw horizontal lines 
216.         pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, y), (WINDOWWIDTH, y)) 
Just to make it easier to visualize the grid of cells, we call 
pygame.draw.line()
to draw out 
each of the vertical and horizontal lines of the grid. 
Normally, to draw the 32 vertical lines needed, we would need 32 calls to 
pygame.draw.line()
with the following coordinates: 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, 0), (0, WINDOWHEIGHT)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (20, 0), (20, WINDOWHEIGHT)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (40, 0), (40, WINDOWHEIGHT)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (60, 0), (60, WINDOWHEIGHT)) 
...skipped for brevity... 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (560, 0), (560, WINDOWHEIGHT)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (580, 0), (580, WINDOWHEIGHT)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (600, 0), (600, WINDOWHEIGHT)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (620, 0), (620, WINDOWHEIGHT)) 
Instead of typing out all these lines of code, we can just have one line of code inside a 
for
loop. 
Notice that the pattern for the vertical lines is that the X coordinate of the start and end point 
starts at 
0
and goes up to 
620
, increasing by 
20
each time. The Y coordinate is always 
0
for the 
start point and 
WINDOWHEIGHT
for the end point parameter. That means the 
for
loop should 
iterate over 
range(0, 640, 20)
. This is why the 
for
loop on line 213 iterates over 
range(0, WINDOWWIDTH, CELLSIZE)
For the horizontal lines, the coordinates would have to be: 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, 0), (WINDOWWIDTH, 0)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, 20), (WINDOWWIDTH, 20)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, 40), (WINDOWWIDTH, 40)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, 60), (WINDOWWIDTH, 60)) 
...skipped for brevity... 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, 400), (WINDOWWIDTH, 400)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, 420), (WINDOWWIDTH, 420)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, 440), (WINDOWWIDTH, 440)) 
pygame.draw.line(DISPLAYSURF, DARKGRAY, (0, 460), (WINDOWWIDTH, 460)) 
The Y coordinate ranges from 
0
to 
460
, increasing by 
20
each time. The X coordinate is always 
0
for the start point and 
WINDOWWIDTH
for the end point parameter. We can also use a 
for
loop 
here so we don’t have to type out all those pygame.draw.line()
calls. 
Chapter 6 
Wormy
151 
Noticing regular patterns needed by the calls and using loops is a clever programmer trick to save 
us from a lot of typing. We could have typed out all 56 
pygame.draw.line()
calls and the 
program would have worked the exact same. But by being a little bit clever, we can save 
ourselves a lot of work. 
219. if __name__ == '__main__': 
220.     main() 
After all the functions and constants and global variables have been defined and created, the 
main()
function is called to start the game. 
on’t Reuse Variable Names 
Take a look at a few lines of code from the 
drawWorm()
function again: 
199.         wormSegmentRect = pygame.Rect(x, y, CELLSIZE, CELLSIZE) 
200.         pygame.draw.rect(DISPLAYSURF, DARKGREEN, wormSegmentRect) 
201.         wormInnerSegmentRect = pygame.Rect(x + 4, y + 4, CELLSIZE - 8, 
CELLSIZE - 8) 
202.         pygame.draw.rect(DISPLAYSURF, GREEN, wormInnerSegmentRect) 
Notice that two different Rect objects are created on lines 199 and 201. The Rect object created 
on line 199 is stored in the 
wormSegmentRect
local variable and is passed to the 
pygame.draw.rect()
function on line 200. The Rect object created on line 201 is stored in 
the 
wormInnerSegmentRect
local variable and is passed to the 
pygame.draw.rect()
function on line 202. 
Every time you create a variable, it takes up a small amount of the computer’s memory.
You 
might think it would be clever to reuse the 
wormSegmentRect
variable for both Rect objects, 
like this: 
199.         wormSegmentRect = pygame.Rect(x, y, CELLSIZE, CELLSIZE) 
200.         pygame.draw.rect(DISPLAYSURF, DARKGREEN, wormSegmentRect) 
201.         wormSegmentRect = pygame.Rect(x + 4, y + 4, CELLSIZE - 8, CELLSIZE 
- 8) 
202.         pygame.draw.rect(DISPLAYSURF, GREEN, wormInnerSegmentRect) 
Because the Rect object returned by 
pygame.Rect()
on line 199 won’t be needed after 200, 
we can overwrite this value and reuse the variable to store the Rect object returned by 
pygame.Rect()
on line 201. Since we are now using fewer variables we are saving memory, 
right? 
152    
http://inventwithpython.com/pygame
Email questions to the author: al@inventwithpython.com 
While this is technically true, you really are only saving a few bytes. Modern computers have 
memory of several billion bytes. So the savings aren’t that great. Meanwhile, reusing variables 
reduces the code readability. If a programmer was reading through this code after it was written, 
they would see that 
wormSegmentRect
is passed to the 
pygame.draw.rect()
calls on 
line 200 and 202. If they tried to find the first time the 
wormSegmentRect
variable was 
assigned a value, they would see the 
pygame.Rect()
call on line 199. They might not realize 
that the Rect object returned by line 199’s pygame.Rect()
call isn’t the same as the one that is 
passed to the 
pygame.draw.rect()
call on line 202. 
Little things like this make it harder to understand how exactly your program works. It won’t just 
be other programmers looking at your code who will be confused. When you look at your own 
code a couple weeks after writing it, you may have a hard time remembering how exactly it 
works. Code readability is much more important than saving a few bytes of memory here and 
there. 
For additional programming practice, you can download buggy versions of Wormy from 
http://invpy.com/buggy/wormy and try to figure out how to fix the bugs. 
Documents you may be interested
Documents you may be interested