hedgewars-draft: hedgewars/adler32.pas@b50215a8a43d (annotated)

3526 a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	1	unit Adler32;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	2
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	3	{ZLib - Adler32 checksum function}
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	4
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	5
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	6	interface
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	7
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	8	(*************************************************************************
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	9
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	10	DESCRIPTION : ZLib - Adler32 checksum function
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	11
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	12	REQUIREMENTS : TP5-7, D1-D7/D9-D10/D12, FPC, VP
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	13
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	14	EXTERNAL DATA : ---
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	15
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	16	MEMORY USAGE : ---
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	17
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	18	DISPLAY MODE : ---
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	19
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	20	REFERENCES : RFC 1950 (http://tools.ietf.org/html/rfc1950)
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	21
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	22
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	23	Version Date Author Modification
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	24	------- -------- ------- ------------------------------------------
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	25	0.10 30.08.03 W.Ehrhardt Initial version based on MD5 layout
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	26	2.10 30.08.03 we Common vers., XL versions for Win32
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	27	2.20 27.09.03 we FPC/go32v2
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	28	2.30 05.10.03 we STD.INC, TP5.0
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	29	2.40 10.10.03 we common version, english comments
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	30	3.00 01.12.03 we Common version 3.0
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	31	3.01 22.05.05 we Adler32UpdateXL (i,n: integer)
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	32	3.02 17.12.05 we Force $I- in Adler32File
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	33	3.03 07.08.06 we $ifdef BIT32: (const fname: shortstring...)
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	34	3.04 10.02.07 we Adler32File: no eof, XL and filemode via $ifdef
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	35	3.05 04.07.07 we BASM16: speed-up factor 15
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	36	3.06 12.11.08 we uses BTypes, Ptr2Inc and/or Str255
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	37	3.07 25.04.09 we updated RFC URL(s)
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	38	3.08 19.07.09 we D12 fix: assign with typecast string(fname)
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	39	**************************************************************************)
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	40
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	41	(*-------------------------------------------------------------------------
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	42	(C) Copyright 2002-2009 Wolfgang Ehrhardt
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	43
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	44	This software is provided 'as-is', without any express or implied warranty.
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	45	In no event will the authors be held liable for any damages arising from
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	46	the use of this software.
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	47
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	48	Permission is granted to anyone to use this software for any purpose,
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	49	including commercial applications, and to alter it and redistribute it
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	50	freely, subject to the following restrictions:
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	51
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	52	1. The origin of this software must not be misrepresented; you must not
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	53	claim that you wrote the original software. If you use this software in
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	54	a product, an acknowledgment in the product documentation would be
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	55	appreciated but is not required.
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	56
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	57	2. Altered source versions must be plainly marked as such, and must not be
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	58	misrepresented as being the original software.
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	59
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	60	3. This notice may not be removed or altered from any source distribution.
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	61	----------------------------------------------------------------------------*)
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	62
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	63	(*
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	64	As per the license above, noting that this implementation of adler32 was stripped of everything we didn't need.
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	65	That means no btypes, file loading, and the assembly version disabled.
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	66	*)
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	67
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	68	procedure Adler32Update(var adler: longint; Msg: pointer; Len: longint);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	69
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	70	implementation
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	71
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	72	(*
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	73	$ifdef BASM16
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	74
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	75	procedure Adler32Update(var adler: longint; Msg: pointer; Len: longint);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	76	//-update Adler32 with Msg data
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	77	const
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	78	BASE = 65521; // max. prime < 65536
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	79	NMAX = 5552; // max. n with 255n(n+1)/2 + (n+1)(BASE-1) < 2^32
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	80	type
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	81	LH = packed record
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	82	L,H: word;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	83	end;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	84	var
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	85	s1,s2: longint;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	86	n: integer;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	87	begin
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	88	s1 := LH(adler).L;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	89	s2 := LH(adler).H;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	90	while Len > 0 do begin
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	91	if Len<NMAX then n := Len else n := NMAX;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	92	//BASM increases speed from about 52 cyc/byte to about 3.7 cyc/byte
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	93	asm
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	94	mov cx,[n]
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	95	db $66; mov ax,word ptr [s1]
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	96	db $66; mov di,word ptr [s2]
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	97	les si,[msg]
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	98	@@1: db $66, $26, $0f, $b6, $1c // movzx ebx,es:[si]
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	99	inc si
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	100	db $66; add ax,bx // inc(s1, pByte(Msg)^)
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	101	db $66; add di,ax // inc(s2, s1
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	102	dec cx
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	103	jnz @@1
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	104	db $66; sub cx,cx
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	105	mov cx,BASE
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	106	db $66; sub dx,dx
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	107	db $66; div cx
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	108	db $66; mov word ptr [s1],dx // s1 := s1 mod BASE
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	109	db $66; sub dx,dx
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	110	db $66; mov ax,di
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	111	db $66; div cx
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	112	db $66; mov word ptr [s2],dx // s2 := s2 mod BASE
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	113	mov word ptr [msg],si // save offset for next chunk
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	114	end;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	115	dec(len, n);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	116	end;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	117	LH(adler).L := word(s1);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	118	LH(adler).H := word(s2);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	119	end;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	120	*)
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	121
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	122	procedure Adler32Update(var adler: longint; Msg: pointer; Len: longint);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	123	{-update Adler32 with Msg data}
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	124	const
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	125	BASE = 65521; {max. prime < 65536 }
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	126	NMAX = 3854; {max. n with 255n(n+1)/2 + (n+1)(BASE-1) < 2^31}
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	127	type
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	128	LH = packed record
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	129	L,H: word;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	130	end;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	131	var
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	132	s1,s2: longint;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	133	i,n: integer;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	134	begin
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	135	s1 := LH(adler).L;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	136	s2 := LH(adler).H;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	137	while Len > 0 do begin
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	138	if Len<NMAX then n := Len else n := NMAX;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	139	for i:=1 to n do begin
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	140	inc(s1, pByte(Msg)^);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	141	inc(Msg);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	142	inc(s2, s1);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	143	end;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	144	s1 := s1 mod BASE;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	145	s2 := s2 mod BASE;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	146	dec(len, n);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	147	end;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	148	LH(adler).L := word(s1);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	149	LH(adler).H := word(s2);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	150	end;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	151
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster. nemo parents: diff changeset	152	end.

author	koda
	Sat, 03 Jul 2010 01:31:18 +0200
changeset 3612	b50215a8a43d
parent 3526	a1d2180fef42
child 3690	c247dee9e1c0
permissions	-rw-r--r--