Studying for Python Mid-Term

So I will have my mid-term for my Python class soon and I wanted to share a script that will most likely be on the test.

This semester we have been working a little with Pygame, and this script uses Pygame to load an image and essentially change the color of the image depending on the color temperature. Here is what I have:

	import pygame, sys
	from pygame.locals import *
	pygame.init()
	grey = (150, 150, 150)
	lite_grey = (220, 220, 220)
	blue = (80, 144, 154)
	dark_blue = (0,50,77)
	lite_blue = (143,220,236)
	display_surface = pygame.display.set_mode((900,948))
	display_surface.fill(grey)
	image = pygame.image.load("image_before.png").convert()
	for x in range(900):
	for y in range(948):
	color_temp = image.get_at((x,y))
	temp_int = color_temp[0] + color_temp[1] + color_temp[2]
	integer = (max(color_temp[0], color_temp[1], color_temp[2]) + temp_int//2//3)
	if integer < 70:
	image.set_at((x,y),dark_blue)
	elif integer < 100:
	image.set_at((x,y),blue)
	elif integer < 130:
	image.set_at((x,y),lite_blue)
	else:
	image.set_at((x,y),lite_grey)
	pygame.image.save(image, 'image_after.png')
	while True:
	for event in pygame.event.get():
	if event.type == QUIT:
	pygame.quit()
	sys.exit()
	display_surface.blit(image, (0,0))
	pygame.display.update()

view raw Image_Manipulation.py hosted with ❤ by GitHub

Here is what I got from this script:

Before and After

Pygame is still really new to me, but its really cool to be able to do this. Anyways, that's all for now, thanks for reading!

Graphic Dice - Homework 6 Finished

This week we had to turn in the homework for making a set of graphic dice using Pygame. We had to make a total of 3 files that would work. Below are the three files that I made: a class file, an interface, and the main game file.

	# graphic_die.py
	# Christian Munoz
	# 03/13/2015
	import pygame
	import math
	from pygame.locals import *
	from random import randint
	class graphic_die:
	"""class that displays a graphical representation of a 6 sided die"""
	def __init__(self, size, surface, position):
	"""This function defines some values of the die and where things should display."""
	self.SURF = surface
	self.POS = position
	self.VALUE = 1
	self.SIZE = size
	self.DIESURF = pygame.Surface((size, size), flags=SRCALPHA, depth=32)
	self.DIESURF.fill((0, 0, 0, 0))
	# RGB values for later use.
	self.DIEIVORY = (230, 230, 200)
	self.DIERED = (200, 0, 0)
	self.PIPSBLK = (40, 40, 40)
	self.PIPSWHT = (200, 200, 200)
	self.RADIUS = self.SIZE//10
	HSIZE = self.SIZE//2
	QSIZE = self.SIZE//4
	# create Pips/Dots in standard places
	self.POINT1 = (HSIZE, HSIZE)
	self.POINT2 = (QSIZE, QSIZE)
	self.POINT3 = (HSIZE + QSIZE, HSIZE + QSIZE)
	self.POINT4 = (HSIZE + QSIZE, QSIZE)
	self.POINT5 = (QSIZE, HSIZE + QSIZE)
	self.POINT6 = (QSIZE, HSIZE)
	self.POINT7 = (HSIZE + QSIZE, HSIZE)
	def draw_background(self):
	"""Create square with rounded corners"""
	pygame.draw.circle(self.DIESURF, self.DIEIVORY, (self.RADIUS, self.RADIUS), self.RADIUS)
	pygame.draw.circle(self.DIESURF, self.DIEIVORY, (self.SIZE - self.RADIUS, self.RADIUS), self.RADIUS)
	pygame.draw.circle(self.DIESURF, self.DIEIVORY, (self.RADIUS, self.SIZE - self.RADIUS), self.RADIUS)
	pygame.draw.circle(self.DIESURF, self.DIEIVORY, (self.SIZE - self.RADIUS, self.SIZE - self.RADIUS), self.RADIUS)
	pygame.draw.rect(self.DIESURF, self.DIEIVORY, Rect((self.RADIUS, 0), (self.SIZE - 2 * self.RADIUS, self.SIZE)))
	pygame.draw.rect(self.DIESURF, self.DIEIVORY, Rect((0, self.RADIUS), (self.SIZE, self.SIZE - 2 * self.RADIUS)))
	def make_pip(self, point):
	"""Helper function to make pips."""
	pip_big = pygame.draw.circle(self.DIESURF, self.PIPSBLK, point, self.RADIUS)
	pip_medium = pygame.draw.circle(self.DIESURF, self.DIERED, point, (self.RADIUS -2))
	pip_small = pygame.draw.circle(self.DIESURF, self.PIPSBLK, point, math.ceil(self.RADIUS/2))
	return pip_big, pip_medium, pip_small
	def set_random_value(self):
	"""Returns a random value between 1-6."""
	self.VALUE = randint(1, 6)
	return self.VALUE
	def draw_value(self, value):
	"""Draws the right amount of pips depending on the value of the die."""
	self.draw_background()
	if value == 1:
	pip1 = self.make_pip(self.POINT1)
	elif value == 2:
	pip2 = self.make_pip(self.POINT2)
	pip3 = self.make_pip(self.POINT3)
	elif value == 3:
	pip1 = self.make_pip(self.POINT1)
	pip2 = self.make_pip(self.POINT2)
	pip3 = self.make_pip(self.POINT3)
	elif value == 4:
	pip2 = self.make_pip(self.POINT2)
	pip3 = self.make_pip(self.POINT3)
	pip4 = self.make_pip(self.POINT4)
	pip5 = self.make_pip(self.POINT5)
	elif value == 5:
	pip1 = self.make_pip(self.POINT1)
	pip2 = self.make_pip(self.POINT2)
	pip3 = self.make_pip(self.POINT3)
	pip4 = self.make_pip(self.POINT4)
	pip5 = self.make_pip(self.POINT5)
	elif value == 6:
	pip2 = self.make_pip(self.POINT2)
	pip3 = self.make_pip(self.POINT3)
	pip4 = self.make_pip(self.POINT4)
	pip5 = self.make_pip(self.POINT5)
	pip6 = self.make_pip(self.POINT6)
	pip7 = self.make_pip(self.POINT7)
	def display_die(self):
	self.draw_value(self.VALUE)
	self.SURF.blit(self.DIESURF, self.POS)

view raw Graphic_Die_Class.py hosted with ❤ by GitHub

	# graphic_die_game.py
	# Christian Munoz
	# 03/13/2015
	import pygame
	import sys
	from pygame.locals import *
	from graphic_die_interface import graphic_die_interface
	def main():
	"""This function will run the die game."""
	pygame.init()
	game_interface = graphic_die_interface()
	while True:
	for event in pygame.event.get():
	if event.type == QUIT:
	pygame.quit()
	sys.exit()
	game_interface.display_interface()
	pygame.display.update()
	if __name__ == "__main__":
	main()
	sys.exit()

view raw Graphic_Die_Game.py hosted with ❤ by GitHub

	# graphic_die_interface.py
	# Christian Munoz
	# 03/13/2015
	import pygame
	from pygame.locals import *
	from graphic_die_class import graphic_die
	class graphic_die_interface:
	def __init__(self):
	pygame.init()
	#Sets the size of the screen and the dice that will be used.
	self.screen_size = (1280, 720)
	self.die_size = 100
	self.half_x = (self.screen_size[0]/2) - (self.die_size/2)
	self.half_y = (self.screen_size[1]/2) - (self.die_size/2)
	#RGB colors for later use
	self.black = (0, 0, 0)
	self.white = (255, 255, 255)
	self.display_surface = pygame.display.set_mode(self.screen_size)
	pygame.display.set_caption('Dice Game')
	self.font = pygame.font.SysFont("Broadway", 60)
	self.text = "Christian's Dice Game"
	self.label = self.font.render(self.text, 1, self.white)
	self.die1 = graphic_die(self.die_size, self.display_surface, (self.half_x, self.half_y))
	self.die1.set_random_value()
	self.die2 = graphic_die(self.die_size, self.display_surface, ((self.half_x/2), self.half_y))
	self.die2.set_random_value()
	self.die3 = graphic_die(self.die_size, self.display_surface, ((self.half_x/2) + self.half_x, self.half_y))
	self.die3.set_random_value()
	self.die4 = graphic_die(self.die_size, self.display_surface, ((self.half_x/4) - self.die_size, self.half_y))
	self.die4.set_random_value()
	self.die5 = graphic_die(self.die_size, self.display_surface, (self.screen_size[0] - (self.die_size * 1.5), self.half_y))
	self.die5.set_random_value()
	def fill_gradient(self, surface, color, gradient, rect=None, vertical=True, forward=True):
	"""fill a surface with a gradient pattern
	Parameters:
	color -> starting color
	gradient -> final color
	rect -> area to fill; default is surface's rect
	vertical -> True=vertical; False=horizontal
	forward -> True=forward; False=reverse
	Pygame recipe: http://www.pygame.org/wiki/GradientCode"""
	if rect is None: rect = surface.get_rect()
	x1,x2 = rect.left, rect.right
	y1,y2 = rect.top, rect.bottom
	if vertical:
	h = y2-y1
	else:
	h = x2-x1
	if forward:
	a, b = color, gradient
	else:
	b, a = color, gradient
	rate = (
	float(b[0]-a[0])/h,
	float(b[1]-a[1])/h,
	float(b[2]-a[2])/h
	)
	fn_line = pygame.draw.line
	if vertical:
	for line in range(y1,y2):
	color = (
	min(max(a[0]+(rate[0]*(line-y1)),0),255),
	min(max(a[1]+(rate[1]*(line-y1)),0),255),
	min(max(a[2]+(rate[2]*(line-y1)),0),255)
	)
	fn_line(surface, color, (x1,line), (x2,line))
	else:
	for col in range(x1,x2):
	color = (
	min(max(a[0]+(rate[0]*(col-x1)),0),255),
	min(max(a[1]+(rate[1]*(col-x1)),0),255),
	min(max(a[2]+(rate[2]*(col-x1)),0),255)
	)
	fn_line(surface, color, (col,y1), (col,y2))
	def display_dice(self):
	"""This function will display all dice."""
	self.fill_gradient(self.display_surface, self.black, self.white)
	self.die1.display_die()
	self.die2.display_die()
	self.die3.display_die()
	self.die4.display_die()
	self.die5.display_die()
	def display_text(self):
	"""This functions displays all the text on the game."""
	self.display_surface.blit(self.label, (self.half_x - (len( self.text)/2), self.half_y/2))
	def display_interface(self):
	"""This functions displays everything that needs to go on the display surface."""
	#self.display_text()
	self.display_dice()

view raw Graphic_Die_Interface.py hosted with ❤ by GitHub

I will have to go back and fix some of the code since if I scale down the size of the window, the position of the dice breaks and it doesn't look like it should.

That's all for now, thanks for reading!

Final Project - Group Created

So a couple weeks ago we got some details on what our final project for our Python class will be. Essentially we will be building on top of some past assignment and build our own game using Pygame. 

My team started to brainstorm some ideas and today we had a Skype meeting to finalize what we will be doing. Here are the game ideas we had:

Christian:

Here is my idea. We could do a top-down space shooter. This way we don’t have to worry about animating any of the sprites we use for the game. If we nail down the idea, it could also give us a bunch of time to polish the game and get the level design just right.

http://static.gamesradar.com/images/mb//GamesRadar/us/Games/R/Raiden%20III/Everything%20Else/PS2/2007-04-24/raideniii_04--screenshot_large.jpg

Steve:

I really like that idea, I think we could have one, or maybe even two solid levels and it would be great!

My idea is that we could make a simple 2d side-scroller platformer that we could do a level or two in. That would keep most animation down to either going left or going right, and a jump or death animation.

Hiro:

Those are some awesome ideas. I was thinking we could do something like a simple 2D, 3rd person shooter type game like this:

http://www.crazymonkeygames.com/Boxhead-The-Zombie-Wars.html

The setting can be completely like space or medieval or stuff like that. I know the animation and coding will be kind of tough but I think if we can figure how to randomly make sprites appear and start moving it would be a pretty cool game.

Final Idea:

Top Down Shooter that will switch to vehicle combat. We are still not sure if it will be a plane, but it will be a vehicle where the player has another mode of playing. The player will start by walking around and killing enemies as the player moves to the goal. We plan on having a few different types of enemies and weapons.

At this time everything is very basic and open, but this is the basic idea of what we are planning to do and we think it will be a good project. That's all for now, thanks for reading!

Grey Fox Helmet - ZBrush Sculpt

So for this week we had to make a hard surface model of some kind in ZBrush, so I decided to make some fan art of Grey Fox's helmet.

In my model I tried to make it look like he had been in a fight and part of it was damaged. I will have to go back and add more damage since at the moment its a little too smooth for it to be real. Anyways, here is what I have so far:

Anyways, that's all for now and thanks for reading!