Cube  Diff

// client processing of the incoming network stream

#include "cube.h"

#import "DynamicEntity.h"
#import "Entity.h"
#import "Player.h"

extern int clientnum;
extern bool c2sinit, senditemstoserver;
extern OFString *toservermap;
extern OFString *clientpassword;

void

// update the position of other clients in the game in our world
// don't care if he's in the scenery or other players,
// just don't overlap with our client

void
updatepos(DynamicEntity *d)
{
	Player *player1 = Player.player1;
	const float r = player1.radius + d.radius;
	const float dx = player1.origin.x - d.origin.x;
	const float dy = player1.origin.y - d.origin.y;
	const float dz = player1.origin.z - d.origin.z;
	const float rz = player1.aboveEye + d.eyeHeight;
	const float fx = (float)fabs(dx), fy = (float)fabs(dy),
	            fz = (float)fabs(dz);

			    getalias(nextmapalias); // look up map in the cycle
			changemap(map != nil ? map : getclientmap());
			break;
		}

		// another client either connected or changed name/team
		case SV_INITC2S: {
			Player *d_ = (Player *)d;
			sgetstr();
			if (d.name.length > 0) {
			if (d_.name.length > 0) {
				// already connected
				if (![d.name isEqual:@(text)])
				if (![d_.name isEqual:@(text)])
					conoutf(@"%@ is now known as %s",
					    d.name, text);
					    d_.name, text);
			} else {
				// new client

				// send new players my info again
				c2sinit = false;
				conoutf(@"connected: %s", text);
			}
			d.name = @(text);
			d_.name = @(text);
			sgetstr();
			d.team = @(text);
			d.lifeSequence = getint(&p);
			d_.team = @(text);
			d_.lifeSequence = getint(&p);
			break;
		}

		case SV_CDIS:
			cn = getint(&p);
			if ((d = getclient(cn)) == nil)
				break;

		}

		case SV_DAMAGE: {
			int target = getint(&p);
			int damage = getint(&p);
			int ls = getint(&p);
			if (target == clientnum) {
				if (ls == player1.lifeSequence)
				if (ls == Player.player1.lifeSequence)
					selfdamage(damage, cn, d);
			} else {
				OFVector3D loc = getclient(target).origin;
				playsound(S_PAIN1 + rnd(5), &loc);
			}
			break;
		}

		case SV_DIED: {
			Player *d_ = (Player *)d;
			int actor = getint(&p);
			if (actor == cn) {
				conoutf(@"%@ suicided", d.name);
				conoutf(@"%@ suicided", d_.name);
			} else if (actor == clientnum) {
				int frags;
				if (isteam(player1.team, d.team)) {
				if (isteam(Player.player1.team, d_.team)) {
					frags = -1;
					conoutf(@"you fragged a teammate (%@)",
					    d.name);
					    d_.name);
				} else {
					frags = 1;
					conoutf(@"you fragged %@", d.name);
					conoutf(@"you fragged %@", d_.name);
				}
				addmsg(
				    1, 2, SV_FRAGS, (player1.frags += frags));
				addmsg(1, 2, SV_FRAGS,
				    (Player.player1.frags += frags));
			} else {
				DynamicEntity *a = getclient(actor);
				Player *a = getclient(actor);
				if (a != nil) {
					if (isteam(a.team, d.name))
						conoutf(@"%@ fragged his "
						        @"teammate (%@)",
						    a.name, d.name);
					else
						conoutf(@"%@ fragged %@",
						    a.name, d.name);
				}
			}
			OFVector3D loc = d.origin;
			OFVector3D loc = d_.origin;
			playsound(S_DIE1 + rnd(2), &loc);
			d.lifeSequence++;
			d_.lifeSequence++;
			break;
		}

		case SV_FRAGS:
			[players[cn] setFrags:getint(&p)];
			break;

			OFVector3D v =
			    OFMakeVector3D(ents[i].x, ents[i].y, ents[i].z);
			playsound(S_ITEMSPAWN, &v);
			break;
		}
		// server acknowledges that I picked up this item
		case SV_ITEMACC:
			realpickup(getint(&p), player1);
			realpickup(getint(&p), Player.player1);
			break;

		case SV_EDITH: // coop editing messages, should be extended to
		               // include all possible editing ops
		case SV_EDITT:
		case SV_EDITS:
		case SV_EDITD:

		case SV_PING:
			getint(&p);
			break;

		case SV_PONG:
			addmsg(0, 2, SV_CLIENTPING,
			    player1.ping =
			        (player1.ping * 5 + lastmillis - getint(&p)) /
			    Player.player1.ping = (Player.player1.ping * 5 +
			                              lastmillis - getint(&p)) /
			        6);
			break;

		case SV_CLIENTPING:
			[players[cn] setPing:getint(&p)];
			break;