ang 9.19.0

data/net/net.rb

@@ -0,0 +1,199 @@
+# Creative Commons BY-SA :  Regis d'Aubarede <regis.aubarede@gmail.com>
+###########################################################################
+#   reseau sharing for ANG
+#    NetClient: singleton inteface main <=> net
+#    MCast : multicasting encapsulation
+###########################################################################
+require "thread"
+require "socket"
+require "ipaddr"
+require "zlib"	# if message is too big for a datagram, zip it
+(puts "ruby version must be 1.9.3 or best (patched for multicast)";exit(1)) if RUBY_VERSION < "1.9.3"
+
+################ Net manager : multicast member, send to all, receive from any ##############
+class NetClient
+	class << self
+		def init(game) 
+		    @is_master=true
+			@trace=false
+			@event_stack = Queue.new
+			@players,@players_ip,@game={},{},game
+			@queue= Queue.new
+			@mcast=MCast.new(self)
+			Thread.new { dispatch() }
+		end
+		def set_trace(on)
+			@trace=on
+		end
+		def is_master() @is_master end
+		def reinit_master(lid) 
+			@is_master=true unless lid.any? {|id| id<$id}
+		end
+		# invoked by MCast, data is string (ruby literal)
+		# ["move",id,time,[x,y],[vx,vy],[a,va]]
+		def receive_data(data)
+			return if !(data && data[0,1]=="[")
+			bdata=eval( data )
+			log("Received: #{bdata.inspect[0..100]} / length=#{data.size} bytes") if @trace
+			if Array===bdata && bdata.length>1
+				code,id,*bdata=bdata
+				if id==$id
+					log(" This message is from myself ! so, multicast seem ok")if @trace
+					return
+				end
+				@is_master=false if id<$id 
+				@event_stack << [code,id,bdata]
+			end
+		end
+		# event recived by multicast, are evaluated here, 
+		# event_invoke() must be called in main thread loop
+		def event_invoke()
+			while @event_stack.size>0
+				code,id,bdata=*(@event_stack.pop)
+				invoke(code,id,bdata)
+			end
+		end
+		def wait_and_invoke()
+			code,id,bdata=*(@event_stack.pop)
+			invoke(code,id,bdata)
+		end
+		def invoke(code,id,bdata)
+			case code
+			when "move"
+				@game.update_payers(id,bdata)
+			when "connect"
+				@game.init_player(id)
+				@game.send_positions(id) 
+			when "success"
+				@game.receive_success(id)
+			when "echec"
+				@game.receive_echec(id)
+			when "positions"
+				@game.get_positions(id,bdata) if id < $id
+			when "star_delete"
+				@game.star_deleted(bdata[0])
+			when "nmissile"
+				@game.new_missile(bdata)
+			when "emissile"
+				@game.end_missile(bdata[0])
+			when "comment"
+				@game.display_comment(bdata[0])
+			when "dead-pl"
+				@game.receive_echec(bdata[0])
+			when "echo"
+				recho(bdata)
+			when "recho"
+				@game.recho(id,*bdata) rescue p $!
+			when "quit"
+				@game.recho(id,*bdata) rescue nil
+			else
+				puts "recieved unknown message #{[code,id,data].join(", ")}"
+			end rescue (puts $!.to_s + "\n  "+ $!.backtrace.join("\n  "))
+		end
+		def dispatch()
+			@mcast.send_message(1,["connect",$id])
+			loop do
+				begin
+						m=@queue.pop
+						#log "#{$id} send to serveur : ",m
+						@mcast.send_message(1,m) 
+				rescue Exception => e
+					puts e.to_s + "\n  "+ e.backtrace.join("\n  ")
+				end
+			end
+		end
+		def connect() 			@mcast.send_message(1,["connect",$id])	end
+		def player_is_moving(data) 	@queue.push(["move",$id,*data]) 	end
+		def send_success() 			@queue.push(["success",$id])		end
+		def send_echec() 			@queue.push(["echec",$id]) 			end
+		def send_position(data)		@queue.push(["positions",$id,*data]) end
+		def star_deleted(index) 	@queue.push(["star_delete",$id,index]) end
+		def comment(text)			@queue.push(["comment",$id,text]) 	end
+		def new_missile(data)		@queue.push(["nmissile",$id,*data]) 	end
+		def end_missile(data)		@queue.push(["emissile",$id,*data]) 	end
+		def dead_player(data)		@queue.push(["dead-pl",$id,*data]) 	end
+		def echo(data)				@queue.push(["echo",$id,*data]) 	end
+		def recho(data)				@queue.push(["recho",$id,*data]) 	end
+		def is_stoping()
+			@queue.pop while (@queue.size>2)
+			@queue.push(["quit",$id])
+			Thread.new { sleep(1) ; exit! }
+		end
+	end
+end
+
+
+class MCast
+  MULTICAST_ADDR = "224.6.1.89"
+  BIND_ADDR = "0.0.0.0"
+  PORT = 6811
+
+  def initialize(client)
+    @client  = client
+	socket
+	listen()
+  end
+
+  def send_message(n,content)
+    message = content.inspect
+	if message.size>1024
+		message= "#" +  Zlib::Deflate.new(9).deflate(message, Zlib::FINISH)
+		if message.size>1024
+			puts "message size too big for a datagram !"
+			return
+		end
+	end
+    socket.send(message, 0, MULTICAST_ADDR, PORT)
+	(n-1).times { sleep(0.02); socket.send(message, 0, MULTICAST_ADDR, PORT) }
+  end
+
+  private
+
+  def listen
+    socket.bind(BIND_ADDR, PORT) rescue nil
+
+    Thread.new do
+      loop do
+        message, x = socket.recvfrom(1024)
+		if message[0,1]=="#"
+			zstream = Zlib::Inflate.new
+			message = zstream.inflate(message[1..-1])
+			zstream.finish
+			zstream.close
+		end
+		@client.receive_data(message)
+      end
+    end
+  end
+
+
+  def socket
+    @socket ||= UDPSocket.open.tap do |socket|
+	  begin
+		  socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1) rescue nil
+		  socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1) rescue nil
+
+		  ctx="bind()"		  
+		  socket.bind(BIND_ADDR, PORT) if RUBY_PLATFORM =~ /(win|w)32$/  # for winxp
+		  
+		  ctx="IP_ADD_MEMBERSHIP"
+		  socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, bind_address)
+		  ctx="IP_MULTICAST_TTL"
+		  socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, 1)
+	  rescue Exception => e
+		puts "******************************************"
+		puts "Multicast seem problematic on your system :"
+		puts "   in #{ctx} :   #{$!.to_s}"
+		puts "Did you have installed last version of Ruby (1.9.3p362 is ok)"
+		puts "Or your network is deconnected..."
+		puts "******************************************"
+		sleep 5
+		exit(1)
+	  end
+    end
+  end
+
+  def bind_address
+    IPAddr.new(MULTICAST_ADDR).hton + IPAddr.new(BIND_ADDR).hton
+  end
+end

data/net/player.rb

@@ -0,0 +1,166 @@
+# Creative Commons BY-SA :  Regis d'Aubarede <regis.aubarede@gmail.com>
+###########################################################################
+#                        P l a y e r
+###########################################################################
+# move by arrow keyboard acceleration commande, 
+# eat star, move with current speed, and attractive planets
+class Player
+  attr_accessor :x,:y,:r,:local,:score,:id
+  def initialize(window,animation,local)
+	@local = local
+	@top=0
+	@pos=1
+    @animation = animation  
+    @app=window
+	clear()
+	@id=(Time.now.to_f*1000).to_i*1000+rand(1000)
+	@r=15
+	self.restart()
+  end
+  def restart
+    @vel_x = @vel_y = @angle = @vangle = 0.0
+    @x = SX/2
+	@y = SY/2
+	@vx,@vy=[0,0]
+    @score = $INITIALE_SCORE
+	@lxy=[]
+	@now=Time.now.to_f * 1000
+	@top=0
+  end
+  def clear() @pos=1 end
+  def dead
+	@vangle=1000
+	NetClient.dead_player([id])
+  end
+  def fire_missile
+	v=Math.sqrt(@vel_x*@vel_x+@vel_y*@vel_y)
+	v=6 if v.abs<6
+    vx=Gosu::offset_x(@angle,v)
+    vy=Gosu::offset_y(@angle,v)
+	Missile.new(@app,@animation,@local,nil,@x+10*vx,@y+10*vy,vx*1.2,vy*1.2,@r)
+  end
+  def warp(x, y)    @x, @y = x, y  ; end
+  def turn_left()    @pos=3 ;  @vangle -= 0.3 ; end
+  def turn_right()   @pos=4 ;  @vangle += 0.3 ; end  
+  def accelerate(s)
+    @pos= s ? 0 : 2
+    @score-=3
+    @vel_x += Gosu::offset_x(@angle, s ? 0.1 : -0.1)
+    @vel_y += Gosu::offset_y(@angle, s ? 0.1 : -0.1)
+  end
+  def receive_button(command)
+	@top=5
+	@command=command
+  end
+
+  def move(stars,now)
+	return if @x==-1000 && @y==-1000
+	if @local
+		a=false
+		(a=true;@vel_x *= -1) if @x >= SX || @x <= 0 
+		(a=true;@vel_y *= -1) if @y >= SY || @y <= 0
+		@x = SX-10 if @x >= SX   && @vel_x.abs < 0.01
+		@y = SY-10 if @y >= SY  && @vel_y.abs < 0.01
+		@x = 10 if @x <= 0   && @vel_x.abs < 0.01
+		@y = 10 if @y <= 0   && @vel_y.abs < 0.01
+		
+		@angle+=@vangle
+		@vangle=@vangle*95.0/100
+		@lxy << [@x,@y] if @vel_x!=0 && @vel_y!=0
+		vx,vy=newton(stars)
+		@vel_x+=vx
+		@vel_y+=vy
+		@vel_x.minmax(-50,+50)
+		@vel_y.minmax(-50,+50)
+		@x += @vel_x
+		@y += @vel_y
+		n=now*1000
+		delta=n-@now
+		if delta >= $NET_TRANSMIT
+			@top+=1
+			NetClient.player_is_moving([@top,n,[@x,@y],[@vel_x,@vel_y],[vx,vy],[@angle,@vangle],@score])
+			@now=n
+		end
+	else
+		@vel_x+=@vx
+		@vel_y+=@vy
+		@vx,@vy=[@vx/2,@vy/2]
+		@x += @vel_x
+		@y += @vel_y
+		@angle+=@vangle
+		@vangle=@vangle*95.0/100		
+	end
+  end
+  def update_by_net(data) 
+    top,t,pos,vel,acc,ang,@score=*data
+	return if top<=@top
+	@top=top
+	
+	#puts  "delta #{Time.now.to_f*1000-t} ms"
+	
+	@x,@y=(pos[0]+@x)/2,(pos[1]+@y)/2
+	@vel_x,@vel_y=vel[0]/2,vel[1]/2
+	@vx,@vy=acc
+	@angle,@vangle=ang
+  end
+
+  def newton(stars)
+	vx = vy = 0.0
+	stars.each  do |star|
+	  next if star.type
+	  d=Gosu::distance(@x,@y,star.x,star.y)-15-star.r
+	  dx,dy=*newton_xy1(15*15,star.r*star.r,self,star)
+	  vx+=dx
+	  vy+=dy
+	end
+	[vx,vy]
+  end
+  def draw(app,stars)
+	img = @animation[@pos]
+	img.draw_rot(@x, @y, ZOrder::Player, @angle)
+    x,y=newton(stars) ; app.draw_line(@x,@y, 0xffffffff,@x+x*1000,@y+y*1000,0xffffffff)  # debug: mark gravity force
+	if app.pending?
+		@lxy.each_cons(2) { |p0,p1| app.draw_line(p0[0],p0[1], 0xffffff00 ,p1[0],p1[1], 0xffffff00 ) if p1} rescue nil
+	elsif @lxy.size>100
+		@lxy[(-1*[800,@lxy.size].min)..-1].each_cons(2) { |p0,p1| 
+			app.draw_line(p0[0],p0[1], 0x33ffff00 ,p1[0],p1[1], 0x33ffff00 ) if p1
+		} rescue nil
+	end
+	@lxy=@lxy[-5000..-1] if @lxy.size>10000
+  end
+  
+  def collect_stars(stars)
+    stars.reject!  do |star|
+	  next(false) if star.x-@x > 200
+	  next(false) if star.x-@x < -200
+	  next(false) if star.y-@y > 200
+	  next(false) if star.y-@y < -200
+
+      if Gosu::distance(@x, @y, star.x, star.y) < (15+star.r) then
+		if star.type
+			@score += 120
+			NetClient.star_deleted(star.index)
+			true
+		else
+			if @vel_x !=0 || @vel_y!=0			
+				@score -= 10
+				@x -= 15*@vel_x
+				@y -= 15*@vel_y
+				@x -= -2*10*@vel_x if @x >= SX   && @vel_x == 0
+				@y -= -2*10*@vel_y if @y >= SY  && @vel_y == 0
+			else
+				@x += (-10..+10).rand
+				@y += (-10..+10).rand
+			end
+			@vel_x=0
+			@vel_y=0
+			false
+		end
+	  else
+		false
+      end
+    end
+	@app.finish if @score<=0
+  end
+  
+end

data/net/star.rb

@@ -0,0 +1,76 @@
+# Creative Commons BY-SA :  Regis d'Aubarede <regis.aubarede@gmail.com>
+###########################################################################
+#                        S t a r 
+###########################################################################
+class Star
+  attr_accessor :x, :y, :type,:r
+  
+  def initialize(ls,type,animation)
+    @animation = animation
+    @index=ls.size
+    @ls=ls
+    @type=type
+    @r=@type ? 10 : $RANGE_STAR_SIZE.rand() 
+    @no_img= type ? 1 : (rand()>0.5 && @r>35) ? 0 : (rand(3)+2)
+    @rot=rand(180)
+    ok=(@type || rand()<0.4)
+    p "nok" unless ok
+    @show= ok  ? 1000 : 0
+    @color = Gosu::Color.new(0xff000000 )
+    @color.red =   type ? 255 : 200
+    @color.green = type ? 0   : 200 
+    @color.blue =  type ? 0   : 200
+    @x = (SX/7..(SX-SX/7)).rand
+    @y = (SY/7..(SY-SY/7)).rand
+    #@x = (index % 10) * (SX/10)
+    #@y = (index / 10) * (SY/10)
+	end
+  def index() @index end
+  
+  ########### Net
+
+  def self.create(anim,no_img,r,rot)
+	Star.new([],10,anim).reinit(no_img,r,rot)
+  end
+  def reinit(no_img,r,rot,colors) 
+		@no_img,@r,@rot = no_img,r,rot
+		@color.red,@color.green,@color.blue=*colors
+		self 
+  end  
+  def serialize(i)  
+	[i,[@no_img,@r,@rot,[@color.red,@color.green,@color.blue]],[@x,@y]] 
+  end
+  
+  def update(x,y)  @x,@y=x,y end
+  
+  def get_pos()
+	[@x.to_i,@y.to_i,@type,@index,@r,@no_img]
+  end
+  def set_pos(pos)
+    @x,@y,@type,@index,@r,@no_img=*pos
+  end
+  ####### serveur side behavior
+  def move(game,ls)
+    ox,oy=@x,@y
+	expand(game,ls)
+	@x=ox if @x>(SX-40) || @x<40
+	@y=oy if @y>(SY-40) || @y<40
+	
+  end
+  def expand(game,ls) 
+	 return unless game.pending?(40)
+     motion(ls,self,-100.0,110) { |o| ! o.type} if type    # Star   <-> Planet
+     motion(ls,self,-10.0,50)   { |o| o.type}             # *      <-> Star
+     motion(ls,self,-10.0,500)  { |o| ! o.type } if !type # Planet <-> Planet
+  end
+  
+  ####### draw client+server side
+  def draw()
+    @show+=0.3 if @show<1000
+    return unless @show>600
+    img = @animation[@no_img]
+    fx=(@r/40.0)*(@show/1000.0)
+    img.draw_rot(@x, @y, ZOrder::Stars, @rot, 0.5,0.5 ,fx,fx,@color)
+  end
+end
+

data/net/tools.rb

@@ -0,0 +1,58 @@
+# Creative Commons BY-SA :  Regis d'Aubarede <regis.aubarede@gmail.com>
+
+module ZOrder
+  Background, Stars, Player, UI = [0,1,2,3]
+end
+class Numeric
+	def minmax(min,max=nil)
+	  (max=min;min=-min) if !max
+	  return self if self>=min && self<=max
+	  return(min) if self<min
+	  return(max)
+	end
+end
+class Range ; def rand() self.begin+Kernel.rand((self.end-self.begin).abs) end ; end
+
+# pseudo newton
+def newton_xy1(p1,p2,a,b)
+ k1=1.0/40
+ k2=1.0/40000
+ dx,dy=[a.x-b.x,a.y-b.y]
+ d=Math::sqrt(dx ** 2 + dy ** 2)
+ f1=(k1*p1*p2/(d*d+100)).minmax(100)
+ f2=(k2*p1*p2/(d)).minmax(100)
+ f=0.8*[f1,f2].max
+ #p [f,f1,f2]
+ teta=Math.atan2(dy,dx)   
+ r=[-f*Math.cos(teta),-f*Math.sin(teta)]
+ r
+end
+
+# newton, with  'amrtissement'
+def newton_xy(p1,p2,a,b,k=1.0/300,dmin=10,dmax=10000)
+ dx,dy=[a.x-b.x,a.y-b.y]
+ d=dmin+Math::sqrt(dx ** 2 + dy ** 2)
+ return [0,0] if d>dmax
+ #f=(k*p1*p2/(d*d)).minmax(100) : k/d**2 not good for gameplay
+ f=(k*p1*p2/(d*d-dmin*dmin)).minmax(10)
+ teta=Math.atan2(dy,dx)   
+ [-f*Math.cos(teta),-f*Math.sin(teta)]
+end
+
+# apply gravity between obj and a list l of planet
+# k=coef gr&avity, >0 attraction, <0 repulsion
+# dmaw : distance max, no attaction if distance>dmax
+def motion(l,obj,k,dmax) 
+ dx,dy=0,0
+ l.each do |o| 
+	next if o==obj
+	next if block_given?  && ! yield(o)
+	dx1,dy1= newton_xy(obj.r,o.r,obj,o,k,0,dmax)
+	dx+=dx1
+	dy+=dy1
+  end
+  obj.x+=dx
+  obj.y+=dy
+  return Math.sqrt(dx*dx+dy*dy)
+end
+