git-svn-id: https://ssl.buetow.org/repos/hsbot/trunk@2 9f8f72e9-4bf4-416e-b76e-7d4203597157

1 files changed, 0 insertions, 157 deletions

diff --git a/Main.hs b/Main.hs
deleted file mode 100644
index ab6ec7e..0000000
--- a/Main.hs
+++ /dev/null
@@ -1,157 +0,0 @@
--- Karmabot By Paul C. Buetow
-
-module Main (main) where
-
-import Control.Monad (forM)
-import Control.Monad.State
-import IO
-import Monad
-import Random
-import System
-
-
-version :: String
-version = "0.0"
-
-data Karma = Karma { karmaName :: String, minPts :: Int, minPerc :: Float } deriving (Show, Read)
-
-instance Eq Karma where x == y = (minPerc x) == (minPerc y) && (minPts x == minPts y)
-
-instance Ord Karma where
-	x > y	| (minPerc x) > (minPerc y) = True
-		| otherwise = (minPts x) > (minPts y)
-	x < y	| (minPerc x) < (minPerc y) = True
-		| otherwise = (minPts x) < (minPts y)
-	x >= y	= not (x < y)
-	x <= y	= not (x > y)
-
-data Conf = Conf { users :: [User], karmas :: [Karma] } deriving (Show, Read)
-
-type StateTrans st = s -> (t, s)
-
-
-
-data User =  User { userName :: String, userPts :: Int	} deriving (Show, Read) 
-
-instance Eq User where x == y = (userPts x) == (userPts y)
-
-instance Ord User where
-	x < y = (userPts x) < (userPts y)
-	x > y = (userPts x) > (userPts y)
-	x >= y = not (x < y)
-	x <= y = not (x > y)
-
-class Render a where render :: a -> String
-
-instance Render User where
-	render user = 
-		userName user ++ 
-		": " ++ (userKarma user) ++ 	
-		" (rank " ++ (show $ userRank user) ++ "/" ++ (show numUsers) ++ "; " ++ 
-		(show $ userPts user) ++ "pts; " ++ (show $ userPerc user) ++ "%)"
-
-makeDefaultConf :: Conf
-makeDefaultConf = Conf {
-	users = [
-		User "thunder" 100,
-		User "otto" 1,
-		User "rantanplan" 3,
-		User "rantanplan2" 3,
-		User "icefox2" 11,
-		User "icefox" 10,
-		User "foobar" 5,
-		User "foobar1" 5,
-		User "foobar2" 5,
-		User "foobar3" 5,
-		User "foobar4" 5,
-		User "foobar5" 5,
-		User "foobar6" 5,
-		User "openfire" 2
-	],
-	karmas = [
-		Karma "God" 20 90,
-		Karma "Guru" 10 80,
-		Karma "Nerd" 10 70, 
-		Karma "Expert" 5 60, 
-		Karma "Geek" 3 40,
-		Karma "Advanced" 0 20, 
-		Karma "Cool dude" 0 0 
-	] }
-
-makeConf :: Conf
-makeConf = makeDefaultConf
-
-numUsers :: Int
-numUsers = length $ users makeConf
-
-sortedUsers :: [User]
-sortedUsers = sort $ users makeConf
-
-userEquals :: User -> User -> Bool
-userEquals x y = (userName x) == (userName y)
-
-userRank :: User -> Int
-userRank = userRank' 1 sortedUsers
-	where userRank' rank (x:xs) user
-		| userEquals x user = rank
-		| otherwise = userRank' (rank+1) xs user
-
-userPerc :: User -> Float
-userPerc user = 
-	let rank = userRank user
-	    userPerc' 
-		| rank == 1 = 100 -- 1st always has 100%
-		| rank == numUsers = 0 -- last always has 0%
-		| otherwise = 
-			let userWeight = 100 / (fromIntegral numUsers)
-			in 100 - userWeight * (fromIntegral rank)
-	in userPerc' 
-
-userKarma :: User -> String
-userKarma user = userKarma' (userPts user) (userPerc user)
-	where userKarma' pts perc = 
-		let cands = sort $ filter (\x -> minPts x <= pts && minPerc x <= perc) (karmas makeConf)
-		in karmaName $ cands !! 0 -- Best posible karma 
-			 
-sort :: (Ord a) => [a] -> [a]
-sort [] = []
-sort (x:xs) = sort (filter (>= x) xs) ++ [x] ++ sort (filter (< x) xs)
-
-readline :: IO ()
-readline = do
-	line <- getLine
-	case line of
-		"q" -> do { putStrLn "Good bye"; exitWith ExitSuccess }
-		_ -> putStrLn ""
-
-
-data MyType = MT Int Bool Char Int deriving Show
-
-{- Using the State monad, we can define a function that returns
-   a random value and updates the random generator state at
-   the same time.
--}
-getAny :: (Random a) => State StdGen a
-getAny = do g      <- get
-            (x,g') <- return $ random g
-            put g'
-            return x
-
--- similar to getAny, but it bounds the random value returned
-getOne :: (Random a) => (a,a) -> State StdGen a
-getOne bounds = do g      <- get
-                   (x,g') <- return $ randomR bounds g
-                   put g'
-                   return x
-
-{- Using the State monad with StdGen as the state, we can build
-   random complex types without manually threading the
-   random generator states through the code.
--}   
-makeRandomValueST :: StdGen -> (MyType, StdGen)
-makeRandomValueST = runState (do n <- getOne (1,100)
-                                 b <- getAny
-                                 c <- getOne ('a','z')
-                                 m <- getOne (-n,n)
-                                 return (MT n b c m))
-