14 files changed, 1213 insertions, 36 deletions

diff --git a/engines/pegasus/items/biochips/aichip.cpp b/engines/pegasus/items/biochips/aichip.cpp
new file mode 100755
index 0000000000..d4e425921b
--- /dev/null
+++ b/engines/pegasus/items/biochips/aichip.cpp
@@ -0,0 +1,279 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * Additional copyright for this file:
+ * Copyright (C) 1995-1997 Presto Studios, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "pegasus/energymonitor.h"
+#include "pegasus/gamestate.h"
+#include "pegasus/pegasus.h"
+#include "pegasus/ai/ai_area.h"
+#include "pegasus/items/biochips/aichip.h"
+#include "pegasus/neighborhood/neighborhood.h"
+
+namespace Pegasus {
+
+// indexed by [number of hints][number of solves (0, 1, or 2)][which button to highlight]
+static const tItemState s_highlightState[4][3][7] = {
+	{
+		{kAI000,	-1,			-1,			-1,			-1,			kAI005,		kAI006},
+		{kAI010,	-1,			-1,			-1,			-1,			kAI015,		kAI016},
+		{kAI020,	-1,			-1,			-1,			kAI024,		-1,			-1}
+	},
+	{
+		{kAI100,	kAI101,		-1,			-1,			-1,			kAI105,		kAI106},
+		{kAI110,	kAI111,		-1,			-1,			-1,			kAI115,		kAI116},
+		{kAI120,	kAI121,		-1,			-1,			kAI124,		kAI125,		kAI126}
+	},
+	{
+		{kAI200,	kAI201,		kAI202,		-1,			-1,			kAI205,		kAI206},
+		{kAI210,	kAI211,		kAI212,		-1,			-1,			kAI215,		kAI216},
+		{kAI220,	kAI221,		kAI222,		-1,			kAI224,		kAI225,		kAI226}
+	},
+	{
+		{kAI300,	kAI301,		kAI302,		kAI303,		-1,			kAI305,		kAI306},
+		{kAI310,	kAI311,		kAI312,		kAI313,		-1,			kAI315,		kAI316},
+		{kAI320,	kAI321,		kAI322,		kAI323,		kAI324,		kAI325,		kAI326}
+	}
+};
+
+AIChip *g_AIChip = 0;
+
+AIChip::AIChip(const tItemID id, const tNeighborhoodID neighborhood, const tRoomID room, const tDirectionConstant direction) :
+		BiochipItem(id, neighborhood, room, direction), _briefingSpot(kAIBriefingSpotID), _scanSpot(kAIScanSpotID),
+		_hint1Spot(kAIHint1SpotID), _hint2Spot(kAIHint2SpotID), _hint3Spot(kAIHint3SpotID), _solveSpot(kAISolveSpotID) {
+	_briefingSpot.setArea(Common::Rect(kAIMiddleAreaLeft + 10, kAIMiddleAreaTop + 27, kAIMiddleAreaLeft + 10 + 81, kAIMiddleAreaTop + 27 + 31));
+	_briefingSpot.setHotspotFlags(kAIBiochipSpotFlag);
+	g_allHotspots.push_back(&_briefingSpot);
+	
+	_scanSpot.setArea(Common::Rect(kAIMiddleAreaLeft + 100, kAIMiddleAreaTop + 27, kAIMiddleAreaLeft + 100 + 81, kAIMiddleAreaTop + 27 + 31));
+	_scanSpot.setHotspotFlags(kAIBiochipSpotFlag);
+	g_allHotspots.push_back(&_scanSpot);
+	
+	_hint1Spot.setArea(Common::Rect(kAIMiddleAreaLeft + 70, kAIMiddleAreaTop + 67, kAIMiddleAreaLeft + 70 + 21, kAIMiddleAreaTop + 67 + 21));
+	_hint1Spot.setHotspotFlags(kAIBiochipSpotFlag);
+	g_allHotspots.push_back(&_hint1Spot);
+	
+	_hint2Spot.setArea(Common::Rect(kAIMiddleAreaLeft + 91, kAIMiddleAreaTop + 67, kAIMiddleAreaLeft + 91 + 20, kAIMiddleAreaTop + 67 + 21));
+	_hint2Spot.setHotspotFlags(kAIBiochipSpotFlag);
+	g_allHotspots.push_back(&_hint2Spot);
+	
+	_hint3Spot.setArea(Common::Rect(kAIMiddleAreaLeft + 111, kAIMiddleAreaTop + 67, kAIMiddleAreaLeft + 111 + 20, kAIMiddleAreaTop + 67 + 21));
+	_hint3Spot.setHotspotFlags(kAIBiochipSpotFlag);
+	g_allHotspots.push_back(&_hint3Spot);
+	
+	_solveSpot.setArea(Common::Rect(kAIMiddleAreaLeft + 131, kAIMiddleAreaTop + 67, kAIMiddleAreaLeft + 131 + 50, kAIMiddleAreaTop + 67 + 21));
+	_solveSpot.setHotspotFlags(kAIBiochipSpotFlag);
+	g_allHotspots.push_back(&_solveSpot);
+	
+	_playingMovie = false;
+	setItemState(kAI000);
+	
+	g_AIChip = this;
+}
+
+AIChip::~AIChip() {
+	g_AIChip = NULL;
+	
+	g_allHotspots.removeOneHotspot(kAIBriefingSpotID);
+	g_allHotspots.removeOneHotspot(kAIScanSpotID);
+	g_allHotspots.removeOneHotspot(kAIHint1SpotID);
+	g_allHotspots.removeOneHotspot(kAIHint2SpotID);
+	g_allHotspots.removeOneHotspot(kAIHint3SpotID);
+	g_allHotspots.removeOneHotspot(kAISolveSpotID);
+}
+
+void AIChip::select() {
+	BiochipItem::select();
+	setUpAIChip();
+}
+
+void AIChip::takeSharedArea() {
+	setUpAIChip();
+}
+
+void AIChip::setUpAIChip() {	
+	if (!_playingMovie) {
+		PegasusEngine *vm = (PegasusEngine *)g_engine;
+
+		uint numSolves;
+		if (GameState.getWalkthroughMode()) {
+			if (vm->canSolve())
+				numSolves = 2;
+			else
+				numSolves = 1;
+		} else {
+			numSolves = 0;
+		}
+
+		setItemState(s_highlightState[vm->getNumHints()][numSolves][0]);
+	}
+}
+
+// Only does something when there are hints or solves available.
+void AIChip::setUpAIChipRude() {	
+	if (!_playingMovie) {
+		PegasusEngine *vm = (PegasusEngine *)g_engine;
+
+		uint numSolves;
+		if (GameState.getWalkthroughMode()) {
+			if (vm->canSolve())
+				numSolves = 2;
+			else
+				numSolves = 1;
+		} else {
+			numSolves = 0;
+		}
+
+		uint numHints = vm->getNumHints();
+		if (numSolves == 2 || numHints != 0)
+			setItemState(s_highlightState[numHints][numSolves][0]);
+	}
+}
+
+void AIChip::activateAIHotspots() {
+	PegasusEngine *vm = (PegasusEngine *)g_engine;
+	_briefingSpot.setActive();
+	_scanSpot.setActive();
+
+	switch (vm->getNumHints()) {
+	case 3:
+		_hint3Spot.setActive();
+		// fall through
+	case 2:
+		_hint2Spot.setActive();
+		// fall through
+	case 1:
+		_hint1Spot.setActive();
+		break;
+	}
+
+	if (GameState.getWalkthroughMode() && vm->canSolve())
+		_solveSpot.setActive();
+}
+
+void AIChip::showBriefingClicked() {
+	PegasusEngine *vm = (PegasusEngine *)g_engine;
+
+	_playingMovie = true;
+
+	uint numSolves;
+	if (GameState.getWalkthroughMode()) {
+		if (vm->canSolve())
+			numSolves = 2;
+		else
+			numSolves = 1;
+	} else {
+		numSolves = 0;
+	}
+
+	tItemState newState = s_highlightState[vm->getNumHints()][numSolves][kAIBriefingSpotID - kAIHint1SpotID + 1];
+	if (newState != -1)
+		setItemState(newState);
+}
+
+void AIChip::showEnvScanClicked() {
+	PegasusEngine *vm = (PegasusEngine *)g_engine;
+
+	_playingMovie = true;
+
+	uint numSolves;
+	if (GameState.getWalkthroughMode()) {
+		if (vm->canSolve())
+			numSolves = 2;
+		else
+			numSolves = 1;
+	} else {
+		numSolves = 0;
+	}
+
+	tItemState newState = s_highlightState[vm->getNumHints()][numSolves][kAIScanSpotID - kAIHint1SpotID + 1];
+
+	if (newState != -1)
+		setItemState(newState);
+}
+
+void AIChip::clearClicked() {
+	_playingMovie = false;
+	setUpAIChip();
+}
+
+void AIChip::clickInAIHotspot(tHotSpotID id) {
+	PegasusEngine *vm = (PegasusEngine *)g_engine;
+
+	Common::String movieName;
+
+	switch (id) {
+	case kAIBriefingSpotID:
+		movieName = vm->getBriefingMovie();
+		break;
+	case kAIScanSpotID:
+		movieName = vm->getEnvScanMovie();
+		break;
+	case kAIHint1SpotID:
+		movieName = vm->getHintMovie(1);
+		break;
+	case kAIHint2SpotID:
+		movieName = vm->getHintMovie(2);
+		break;
+	case kAIHint3SpotID:
+		movieName = vm->getHintMovie(3);
+		break;
+	case kAISolveSpotID:
+		g_neighborhood->doSolve();
+		break;
+	}
+
+	tItemState state = getItemState();
+
+	if (!movieName.empty()) {
+		_playingMovie = true;
+
+		uint numSolves;
+		if (GameState.getWalkthroughMode()) {
+			if (vm->canSolve())
+				numSolves = 2;
+			else
+				numSolves = 1;
+		} else {
+			numSolves = 0;
+		}
+
+		tItemState newState = s_highlightState[vm->getNumHints()][numSolves][id - kAIHint1SpotID + 1];
+
+		if (newState != -1)
+			setItemState(newState);
+
+		if (g_AIArea) {
+			vm->prepareForAIHint(movieName);
+			g_AIArea->playAIMovie(kRightAreaSignature, movieName, false, kHintInterruption);
+			vm->cleanUpAfterAIHint(movieName);
+		}
+
+		if (newState != -1)
+			setItemState(state);
+
+		_playingMovie = false;
+	}
+}
+
+} // End of namespace Pegasus
diff --git a/engines/pegasus/items/biochips/aichip.h b/engines/pegasus/items/biochips/aichip.h
new file mode 100755
index 0000000000..96d2fb2c01
--- /dev/null
+++ b/engines/pegasus/items/biochips/aichip.h
@@ -0,0 +1,69 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * Additional copyright for this file:
+ * Copyright (C) 1995-1997 Presto Studios, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef PEGASUS_ITEMS_BIOCHIPS_AICHIP_H
+#define PEGASUS_ITEMS_BIOCHIPS_AICHIP_H
+
+#include "pegasus/hotspot.h"
+#include "pegasus/items/biochips/biochipitem.h"
+
+namespace Pegasus {
+
+class AIChip : public BiochipItem {
+public:
+	AIChip(const tItemID, const tNeighborhoodID, const tRoomID, const tDirectionConstant);
+	virtual ~AIChip();
+
+	void select();
+
+	void setUpAIChip();
+
+	// Called to set up the AI chip when the AI chip is the current chip but does not
+	// own the center area.
+	void setUpAIChipRude();
+	void activateAIHotspots();
+	void clickInAIHotspot(tHotSpotID);
+
+	void takeSharedArea();
+
+	void showBriefingClicked();
+	void showEnvScanClicked();
+	void clearClicked();
+
+protected:
+	Hotspot _briefingSpot;
+	Hotspot _scanSpot;
+	Hotspot _hint1Spot;
+	Hotspot _hint2Spot;
+	Hotspot _hint3Spot;
+	Hotspot _solveSpot;
+	bool _playingMovie;
+};
+
+extern AIChip *g_AIChip;
+
+} // End of namespace Pegasus
+
+#endif
\ No newline at end of file
diff --git a/engines/pegasus/items/biochips/biochipitem.cpp b/engines/pegasus/items/biochips/biochipitem.cpp
index 71065f1efe..99e6050c85 100755
--- a/engines/pegasus/items/biochips/biochipitem.cpp
+++ b/engines/pegasus/items/biochips/biochipitem.cpp
@@ -27,6 +27,7 @@
 #include "common/stream.h"
 
 #include "pegasus/pegasus.h"
+#include "pegasus/ai/ai_area.h"
 #include "pegasus/items/biochips/biochipitem.h"
 
 namespace Pegasus {
@@ -80,13 +81,15 @@ TimeValue BiochipItem::getRightAreaTime() const {
 void BiochipItem::select() {
 	Item::select();
 
-	// TODO: AI
+	if (g_AIArea)
+		g_AIArea->setAIAreaToTime(kBiochipSignature, kRightAreaSignature, getRightAreaTime());
 }
 
 void BiochipItem::deselect() {
 	Item::deselect();
 
-	// TODO: AI
+	if (g_AIArea)
+		g_AIArea->setAIAreaToTime(kBiochipSignature, kRightAreaSignature, 0xffffffff);
 }
 
 } // End of namespace Pegasus
diff --git a/engines/pegasus/items/biochips/opticalchip.cpp b/engines/pegasus/items/biochips/opticalchip.cpp
new file mode 100755
index 0000000000..f6519c7f61
--- /dev/null
+++ b/engines/pegasus/items/biochips/opticalchip.cpp
@@ -0,0 +1,189 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * Additional copyright for this file:
+ * Copyright (C) 1995-1997 Presto Studios, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "pegasus/ai/ai_area.h"
+#include "pegasus/items/biochips/opticalchip.h"
+
+namespace Pegasus {
+
+OpticalChip *g_opticalChip = 0;
+
+OpticalChip::OpticalChip(const tItemID id, const tNeighborhoodID neighborhood, const tRoomID room, const tDirectionConstant direction) :
+		BiochipItem(id, neighborhood, room, direction), _ariesHotspot(kAriesSpotID), _mercuryHotspot(kMercurySpotID),
+		_poseidonHotspot(kPoseidonSpotID) {
+	_ariesHotspot.setArea(Common::Rect(kAIMiddleAreaLeft + 60, kAIMiddleAreaTop + 27, kAIMiddleAreaLeft + 60 + 121, kAIMiddleAreaTop + 27 + 20));
+	_ariesHotspot.setHotspotFlags(kOpticalBiochipSpotFlag);
+	g_allHotspots.push_back(&_ariesHotspot);
+
+	_mercuryHotspot.setArea(Common::Rect(kAIMiddleAreaLeft + 60, kAIMiddleAreaTop + 47, kAIMiddleAreaLeft + 60 + 121, kAIMiddleAreaTop + 47 + 20));
+	_mercuryHotspot.setHotspotFlags(kOpticalBiochipSpotFlag);
+	g_allHotspots.push_back(&_mercuryHotspot);
+
+	_poseidonHotspot.setArea(Common::Rect(kAIMiddleAreaLeft + 60, kAIMiddleAreaTop + 67, kAIMiddleAreaLeft + 60 + 121, kAIMiddleAreaTop + 67 + 20));
+	_poseidonHotspot.setHotspotFlags(kOpticalBiochipSpotFlag);
+	g_allHotspots.push_back(&_poseidonHotspot);
+
+	setItemState(kOptical000);
+
+	g_opticalChip = this;
+}
+
+OpticalChip::~OpticalChip() {
+	g_allHotspots.removeOneHotspot(kAriesSpotID);
+	g_allHotspots.removeOneHotspot(kMercurySpotID);
+	g_allHotspots.removeOneHotspot(kPoseidonSpotID);
+}
+
+void OpticalChip::writeToStream(Common::WriteStream *stream) {
+	BiochipItem::writeToStream(stream);
+	_opticalFlags.writeToStream(stream);
+}
+
+void OpticalChip::readFromStream(Common::ReadStream *stream) {
+	BiochipItem::readFromStream(stream);
+	_opticalFlags.readFromStream(stream);
+}
+
+void OpticalChip::addAries() {
+	_opticalFlags.setFlag(kOpticalAriesExposed, true);
+	setUpOpticalChip();
+}
+
+void OpticalChip::addMercury() {
+	_opticalFlags.setFlag(kOpticalMercuryExposed, true);
+	setUpOpticalChip();
+}
+
+void OpticalChip::addPoseidon() {
+	_opticalFlags.setFlag(kOpticalPoseidonExposed, true);
+	setUpOpticalChip();
+}
+
+void OpticalChip::setUpOpticalChip() {
+	if (_opticalFlags.getFlag(kOpticalAriesExposed)) {
+		if (_opticalFlags.getFlag(kOpticalMercuryExposed)) {
+			if (_opticalFlags.getFlag(kOpticalPoseidonExposed))
+				setItemState(kOptical111);
+			else
+				setItemState(kOptical011);
+		} else {
+			if (_opticalFlags.getFlag(kOpticalPoseidonExposed))
+				setItemState(kOptical101);
+			else
+				setItemState(kOptical001);
+		}
+	} else {
+		if (_opticalFlags.getFlag(kOpticalMercuryExposed)) {
+			if (_opticalFlags.getFlag(kOpticalPoseidonExposed))
+				setItemState(kOptical110);
+			else
+				setItemState(kOptical010);
+		} else {
+			if (_opticalFlags.getFlag(kOpticalPoseidonExposed))
+				setItemState(kOptical100);
+			else
+				setItemState(kOptical000);
+		}
+	}
+}
+
+void OpticalChip::activateOpticalHotspots() {
+	if (_opticalFlags.getFlag(kOpticalAriesExposed))
+		_ariesHotspot.setActive();
+	if (_opticalFlags.getFlag(kOpticalMercuryExposed))
+		_mercuryHotspot.setActive();
+	if (_opticalFlags.getFlag(kOpticalPoseidonExposed))
+		_poseidonHotspot.setActive();
+}
+
+void OpticalChip::clickInOpticalHotspot(tHotSpotID id) {
+	playOpMemMovie(id);
+}
+
+void OpticalChip::playOpMemMovie(tHotSpotID id) {
+	Common::String movieName;
+	switch (id) {
+	case kAriesSpotID:
+		movieName = "Images/AI/Globals/OMAI";
+		break;
+	case kMercurySpotID:
+		movieName = "Images/AI/Globals/OMMI";
+		break;
+	case kPoseidonSpotID:
+		movieName = "Images/AI/Globals/OMPI";
+		break;
+	}
+
+	tItemState state = getItemState(), newState;
+	switch (state) {
+	case kOptical000:
+		// Can never happen.
+		break;
+	case kOptical001:
+		newState = kOptical002;
+		break;
+	case kOptical010:
+		newState = kOptical020;
+		break;
+	case kOptical011:
+		if (id == kAriesSpotID)
+			newState = kOptical012;
+		else
+			newState = kOptical021;
+		break;
+	case kOptical100:
+		newState = kOptical200;
+		break;
+	case kOptical101:
+		if (id == kAriesSpotID)
+			newState = kOptical102;
+		else
+			newState = kOptical201;
+		break;
+	case kOptical110:
+		if (id == kMercurySpotID)
+			newState = kOptical120;
+		else
+			newState = kOptical210;
+		break;
+	case kOptical111:
+		if (id == kAriesSpotID)
+			newState = kOptical112;
+		else if (id == kMercurySpotID)
+			newState = kOptical121;
+		else
+			newState = kOptical211;
+		break;
+	}
+
+	setItemState(newState);
+
+	if (g_AIArea)
+		g_AIArea->playAIMovie(kRightAreaSignature, movieName, false, kOpticalInterruption);
+
+	setItemState(state);
+}
+
+} // End of namespace Pegasus
diff --git a/engines/pegasus/items/biochips/opticalchip.h b/engines/pegasus/items/biochips/opticalchip.h
new file mode 100755
index 0000000000..c44a5eaf63
--- /dev/null
+++ b/engines/pegasus/items/biochips/opticalchip.h
@@ -0,0 +1,71 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * Additional copyright for this file:
+ * Copyright (C) 1995-1997 Presto Studios, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef PEGASUS_ITEMS_BIOCHIPS_OPTICALCHIP_H
+#define PEGASUS_ITEMS_BIOCHIPS_OPTICALCHIP_H
+
+#include "pegasus/hotspot.h"
+#include "pegasus/util.h"
+#include "pegasus/items/biochips/biochipitem.h"
+
+namespace Pegasus {
+
+class OpticalChip : public BiochipItem {
+public:
+	OpticalChip(const tItemID, const tNeighborhoodID, const tRoomID, const tDirectionConstant);
+	virtual ~OpticalChip();
+
+	virtual void writeToStream(Common::WriteStream *);
+	virtual void readFromStream(Common::ReadStream *);
+
+	void addAries();
+	void addMercury();
+	void addPoseidon();
+
+	void activateOpticalHotspots();
+	void clickInOpticalHotspot(tHotSpotID);
+	void playOpMemMovie(tHotSpotID);
+
+protected:
+	enum {
+		kOpticalAriesExposed,
+		kOpticalMercuryExposed,
+		kOpticalPoseidonExposed,
+		kNumOpticalChipFlags
+	};
+	
+	void setUpOpticalChip();
+	
+	FlagsArray<byte, kNumOpticalChipFlags> _opticalFlags;
+	Hotspot _ariesHotspot;
+	Hotspot _mercuryHotspot;
+	Hotspot _poseidonHotspot;
+};
+
+extern OpticalChip *g_opticalChip;
+
+} // End of namespace Pegasus
+
+#endif
diff --git a/engines/pegasus/items/biochips/pegasuschip.cpp b/engines/pegasus/items/biochips/pegasuschip.cpp
new file mode 100755
index 0000000000..5d0c9915d8
--- /dev/null
+++ b/engines/pegasus/items/biochips/pegasuschip.cpp
@@ -0,0 +1,178 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * Additional copyright for this file:
+ * Copyright (C) 1995-1997 Presto Studios, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "pegasus/energymonitor.h"
+#include "pegasus/gamestate.h"
+#include "pegasus/pegasus.h"
+#include "pegasus/items/biochips/pegasuschip.h"
+
+namespace Pegasus {
+
+PegasusChip::PegasusChip(const tItemID id, const tNeighborhoodID neighborhood, const tRoomID room, const tDirectionConstant direction) :
+		BiochipItem(id, neighborhood, room, direction), _recallSpot(kPegasusRecallSpotID) {
+	_recallSpot.setArea(Common::Rect(kAIMiddleAreaLeft + 116, kAIMiddleAreaTop + 63, kAIMiddleAreaLeft + 184, kAIMiddleAreaTop + 91));
+	_recallSpot.setHotspotFlags(kPegasusBiochipSpotFlag);
+	g_allHotspots.push_back(&_recallSpot);
+	setItemState(kPegasusTSA00);
+}
+
+PegasusChip::~PegasusChip() {
+	g_allHotspots.removeOneHotspot(kPegasusRecallSpotID);
+}
+
+void PegasusChip::select() {
+	BiochipItem::select();
+	setUpPegasusChip();
+}
+
+void PegasusChip::setUpPegasusChip() {
+	switch (GameState.getCurrentNeighborhood()) {
+	case kCaldoriaID:
+		setItemState(kPegasusCaldoria);
+		break;
+	case kFullTSAID:
+	case kFinalTSAID:
+	case kTinyTSAID:
+		setItemState(kPegasusTSA10);
+		break;
+	case kPrehistoricID:
+		if (((PegasusEngine *)g_engine)->playerHasItemID(kHistoricalLog))
+			setItemState(kPegasusPrehistoric00);
+		else
+			setItemState(kPegasusPrehistoric10);
+		break;
+	case kMarsID:
+		if (GameState.getMarsFinished())
+			setItemState(kPegasusMars00);
+		else
+			setItemState(kPegasusMars10);
+		break;
+	case kWSCID:
+		if (GameState.getWSCFinished())
+			setItemState(kPegasusWSC00);
+		else
+			setItemState(kPegasusWSC10);
+		break;
+	case kNoradAlphaID:
+	case kNoradDeltaID:
+		if (GameState.getNoradFinished())
+			setItemState(kPegasusNorad00);
+		else
+			setItemState(kPegasusNorad10);
+		break;
+	}
+}
+
+// Only does something if the chip should be announcing that the time zone is finished...
+void PegasusChip::setUpPegasusChipRude() {
+	switch (GameState.getCurrentNeighborhood()) {
+	case kPrehistoricID:
+		if (((PegasusEngine *)g_engine)->playerHasItemID(kHistoricalLog))
+			setItemState(kPegasusPrehistoric00);
+		break;
+	case kMarsID:
+		if (GameState.getMarsFinished())
+			setItemState(kPegasusMars00);
+		break;
+	case kWSCID:
+		if (GameState.getWSCFinished())
+			setItemState(kPegasusWSC00);
+		break;
+	case kNoradAlphaID:
+	case kNoradDeltaID:
+		if (GameState.getNoradFinished())
+			setItemState(kPegasusNorad00);
+		break;
+	}
+}
+
+void PegasusChip::activatePegasusHotspots() {
+	switch (GameState.getCurrentNeighborhood()) {
+	case kPrehistoricID:
+	case kMarsID:
+	case kWSCID:
+	case kNoradAlphaID:
+	case kNoradDeltaID:
+		_recallSpot.setActive();
+		break;
+	}
+}
+
+void PegasusChip::clickInPegasusHotspot() {
+	PegasusEngine *vm = (PegasusEngine *)g_engine;
+
+	tItemState thisState = getItemState();
+	tItemState hiliteState;
+
+	switch (thisState) {
+	case kPegasusPrehistoric00:
+		hiliteState = kPegasusPrehistoric01;
+		break;
+	case kPegasusPrehistoric10:
+		hiliteState = kPegasusPrehistoric11;
+		break;
+	case kPegasusMars00:
+		hiliteState = kPegasusMars01;
+		break;
+	case kPegasusMars10:
+		hiliteState = kPegasusMars11;
+		break;
+	case kPegasusNorad00:
+		hiliteState = kPegasusNorad01;
+		break;
+	case kPegasusNorad10:
+		hiliteState = kPegasusNorad11;
+		break;
+	case kPegasusWSC00:
+		hiliteState = kPegasusWSC01;
+		break;
+	case kPegasusWSC10:
+		hiliteState = kPegasusWSC11;
+		break;
+	}
+
+	setItemState(hiliteState);
+
+	uint32 time = g_system->getMillis();
+	while (g_system->getMillis() < time + 500) {
+		vm->refreshDisplay();
+		g_system->delayMillis(10);
+	}
+
+	setItemState(thisState);
+
+	if (!((Neighborhood *)g_neighborhood)->okayToJump())
+		return;
+
+	if (g_energyMonitor)
+		g_energyMonitor->stopEnergyDraining();
+	
+	if (GameState.getTSAState() == kPlayerWentToPrehistoric || GameState.allTimeZonesFinished())
+		vm->jumpToNewEnvironment(kFullTSAID, kTSA37, kNorth);
+	else
+		vm->jumpToNewEnvironment(kTinyTSAID, kTinyTSA37, kNorth);
+}
+
+} // End of namespace Pegasus
diff --git a/engines/pegasus/items/biochips/pegasuschip.h b/engines/pegasus/items/biochips/pegasuschip.h
new file mode 100755
index 0000000000..1ee35b78a1
--- /dev/null
+++ b/engines/pegasus/items/biochips/pegasuschip.h
@@ -0,0 +1,55 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * Additional copyright for this file:
+ * Copyright (C) 1995-1997 Presto Studios, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef PEGASUS_ITEMS_BIOCHIPS_PEGASUSCHIP_H
+#define PEGASUS_ITEMS_BIOCHIPS_PEGASUSCHIP_H
+
+#include "pegasus/hotspot.h"
+#include "pegasus/items/biochips/biochipitem.h"
+
+namespace Pegasus {
+
+class PegasusChip : public BiochipItem {
+public:
+	PegasusChip(const tItemID, const tNeighborhoodID, const tRoomID, const tDirectionConstant);
+	virtual ~PegasusChip();
+
+	void select();
+
+	void setUpPegasusChip();
+
+	// Called to set up the Pegasus chip when the Pegasus chip is the current chip but does not
+	// own the center area.
+	void setUpPegasusChipRude();
+	void activatePegasusHotspots();
+	void clickInPegasusHotspot();
+
+protected:
+	Hotspot _recallSpot;
+};
+
+} // End of namespace Pegasus
+
+#endif
diff --git a/engines/pegasus/items/inventory/airmask.cpp b/engines/pegasus/items/inventory/airmask.cpp
new file mode 100755
index 0000000000..682927deaf
--- /dev/null
+++ b/engines/pegasus/items/inventory/airmask.cpp
@@ -0,0 +1,248 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * Additional copyright for this file:
+ * Copyright (C) 1995-1997 Presto Studios, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "pegasus/gamestate.h"
+#include "pegasus/ai/ai_area.h"
+#include "pegasus/items/inventory/airmask.h"
+#include "pegasus/neighborhood/neighborhood.h"
+
+namespace Pegasus {
+
+AirMask *g_airMask = 0;
+
+//	Based on full == 100, which is scale used by GetAirLeft().
+static const TimeValue kOxygenLowThreshold = 25;
+
+void AirMask::airMaskTimerExpired(FunctionPtr *, void *) {
+	if (g_neighborhood)
+		g_neighborhood->checkAirMask();
+}
+
+AirMask::AirMask(const tItemID id, const tNeighborhoodID neighborhood, const tRoomID room, const tDirectionConstant direction) :
+		InventoryItem(id, neighborhood, room, direction), _toggleSpot(kAirMaskToggleSpotID) {
+	g_airMask = this;
+	_toggleSpot.setArea(Common::Rect(kAIMiddleAreaLeft + 10, kAIMiddleAreaTop + 17, kAIMiddleAreaLeft + 110, kAIMiddleAreaTop + 57));
+	_toggleSpot.setHotspotFlags(kAirMaskSpotFlag);
+	g_allHotspots.push_back(&_toggleSpot);
+	setItemState(kAirMaskEmptyOff);
+	_oxygenTimer.primeFuse(0);
+	_oxygenTimer.setFunctionPtr(&airMaskTimerExpired, 0);
+}
+
+AirMask::~AirMask() {
+	g_allHotspots.removeOneHotspot(kAirMaskToggleSpotID);
+	g_airMask = 0;
+}
+
+void AirMask::writeToStream(Common::WriteStream *stream) {
+	InventoryItem::writeToStream(stream);
+	stream->writeUint32BE(_oxygenTimer.getTimeRemaining());
+}
+
+void AirMask::readFromStream(Common::ReadStream *stream) {	
+	_oxygenTimer.stopFuse();
+	InventoryItem::readFromStream(stream);
+	_oxygenTimer.primeFuse(stream->readUint32BE());
+}
+
+void AirMask::putMaskOn() {
+	tAirQuality airQuality;
+
+	if (g_neighborhood)
+		airQuality = g_neighborhood->getAirQuality(GameState.getCurrentRoom());
+	else
+		airQuality = kAirQualityGood;
+
+	uint airLevel = getAirLeft();
+	tItemState newState = getItemState();
+	tItemState oldState = newState;
+
+	if (airLevel == 0) {
+		newState = kAirMaskEmptyFilter;
+	} else if (airLevel <= kOxygenLowThreshold) {
+		if (airQuality == kAirQualityVacuum)
+			newState = kAirMaskLowOn;
+		else
+			newState = kAirMaskLowFilter;
+	} else {
+		if (airQuality == kAirQualityVacuum)
+			newState = kAirMaskFullOn;
+		else
+			newState = kAirMaskFullFilter;
+	}
+
+	if (newState != oldState)
+		setItemState(newState);
+}
+
+void AirMask::takeMaskOff() {	
+	uint airLevel = getAirLeft();
+	tItemState newState = getItemState();
+	tItemState oldState = newState;
+
+	if (airLevel == 0)
+		newState = kAirMaskEmptyOff;
+	else if (airLevel <= kOxygenLowThreshold)
+		newState = kAirMaskLowOff;
+	else
+		newState = kAirMaskFullOff;
+
+	if (newState != oldState)
+		setItemState(newState);
+}
+
+void AirMask::toggleItemState() {
+	if (isAirMaskInUse())
+		takeMaskOff();
+	else
+		putMaskOn();
+}
+
+void AirMask::airQualityChanged() {
+	if (isAirMaskInUse())
+		putMaskOn();
+	else
+		takeMaskOff();
+}
+
+void AirMask::setItemState(const tItemState newState) {
+	if (newState != getItemState()) {
+		InventoryItem::setItemState(newState);
+
+		switch (newState) {
+		case kAirMaskFullOn:
+		case kAirMaskLowOn:
+			if (!_oxygenTimer.isFuseLit()) {
+				_oxygenTimer.lightFuse();
+				startIdling();
+			}
+			break;
+		default:
+			if (_oxygenTimer.isFuseLit()) {
+				_oxygenTimer.stopFuse();
+				stopIdling();
+			}
+			break;
+		}
+
+		if (g_neighborhood)
+			g_neighborhood->checkAirMask();
+
+		g_AIArea->checkMiddleArea();
+	}
+}
+
+void AirMask::useIdleTime() {
+	if (getAirLeft() == 0)
+		setItemState(kAirMaskEmptyOff);
+	else if (getAirLeft() <= kOxygenLowThreshold)
+		setItemState(kAirMaskLowOn);
+}
+
+void AirMask::refillAirMask() {
+	switch (getItemState()) {
+		case kAirMaskEmptyOff:
+		case kAirMaskLowOff:
+			setItemState(kAirMaskFullOff);
+			break;
+		case kAirMaskEmptyFilter:
+		case kAirMaskLowFilter:
+			setItemState(kAirMaskFullFilter);
+			break;
+		case kAirMaskLowOn:
+			setItemState(kAirMaskFullOn);
+			break;
+	}
+
+	if (_oxygenTimer.isFuseLit()) {
+		_oxygenTimer.stopFuse();
+		_oxygenTimer.primeFuse(kOxyMaskFullTime);
+		_oxygenTimer.lightFuse();
+	} else {
+		_oxygenTimer.primeFuse(kOxyMaskFullTime);
+	}
+}
+
+//	Doesn't return 0 until the timer is actually at 0.
+uint AirMask::getAirLeft() {
+	return CLIP<int>(((_oxygenTimer.getTimeRemaining() * 100) + kOxyMaskFullTime - 1) / kOxyMaskFullTime, 0, 100);
+}
+
+bool AirMask::isAirMaskInUse() {
+	switch (getItemState()) {
+	case kAirMaskEmptyOff:
+	case kAirMaskLowOff:
+	case kAirMaskFullOff:
+		return false;
+		break;
+	default:
+		return true;
+		break;
+	}
+}
+
+bool AirMask::isAirMaskOn() {
+	switch (getItemState()) {
+	case kAirMaskLowOn:
+	case kAirMaskFullOn:
+		return true;
+		break;
+	default:
+		return false;
+		break;
+	}
+}
+
+bool AirMask::isAirFilterOn() {
+	switch (getItemState()) {
+	case kAirMaskEmptyFilter:
+	case kAirMaskLowFilter:
+	case kAirMaskFullFilter:
+		return true;
+		break;
+	default:
+		return false;
+		break;
+	}
+}
+
+void AirMask::addedToInventory() {
+	GameState.setMarsMaskOnFiller(false);
+}
+
+void AirMask::removedFromInventory() {
+	if (isAirMaskInUse())
+		toggleItemState();
+}
+
+void AirMask::activateAirMaskHotspots() {
+	_toggleSpot.setActive();
+}
+
+void AirMask::clickInAirMaskHotspot() {
+	toggleItemState();
+}
+
+} // End of namespace Pegasus
diff --git a/engines/pegasus/items/inventory/airmask.h b/engines/pegasus/items/inventory/airmask.h
new file mode 100755
index 0000000000..0e71380baf
--- /dev/null
+++ b/engines/pegasus/items/inventory/airmask.h
@@ -0,0 +1,76 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * Additional copyright for this file:
+ * Copyright (C) 1995-1997 Presto Studios, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef PEGASUS_ITEMS_INVENTORY_AIRMASK_H
+#define PEGASUS_ITEMS_INVENTORY_AIRMASK_H
+
+#include "pegasus/hotspot.h"
+#include "pegasus/timers.h"
+#include "pegasus/items/inventory/inventoryitem.h"
+
+namespace Pegasus {
+
+class AirMask : public InventoryItem, private Idler {
+public:
+	AirMask(const tItemID, const tNeighborhoodID, const tRoomID, const tDirectionConstant);
+	virtual ~AirMask();
+
+	virtual void writeToStream(Common::WriteStream *);
+	virtual void readFromStream(Common::ReadStream *);
+
+	virtual void setItemState(const tItemState);
+	void putMaskOn();
+	void takeMaskOff();
+	void toggleItemState();
+	void airQualityChanged();
+
+	bool isAirMaskInUse();
+	bool isAirMaskOn();
+	bool isAirFilterOn();
+
+	void refillAirMask();
+
+	// Returns a percentage
+	uint getAirLeft();
+
+	void activateAirMaskHotspots();
+	void clickInAirMaskHotspot();
+
+protected:
+	static void airMaskTimerExpired(FunctionPtr *, void *);
+
+	virtual void removedFromInventory();
+	virtual void addedToInventory();
+	void useIdleTime();
+
+	Hotspot _toggleSpot;
+	FuseFunction _oxygenTimer;
+};
+
+extern AirMask *g_airMask;
+
+} // End of namespace Pegasus
+
+#endif
diff --git a/engines/pegasus/items/inventory/inventoryitem.cpp b/engines/pegasus/items/inventory/inventoryitem.cpp
index ffa745acef..17f07050b3 100755
--- a/engines/pegasus/items/inventory/inventoryitem.cpp
+++ b/engines/pegasus/items/inventory/inventoryitem.cpp
@@ -26,6 +26,7 @@
 #include "common/stream.h"
 
 #include "pegasus/pegasus.h"
+#include "pegasus/ai/ai_area.h"
 #include "pegasus/items/inventory/inventoryitem.h"
 
 namespace Pegasus {
@@ -90,13 +91,15 @@ TimeValue InventoryItem::getAnimationTime() const {
 void InventoryItem::select() {
 	Item::select();
 
-	// TODO: AI
+	if (g_AIArea)
+		g_AIArea->setAIAreaToTime(kInventorySignature, kLeftAreaSignature, getLeftAreaTime());
 }
 
 void InventoryItem::deselect() {
 	Item::deselect();
 
-	// TODO: AI
+	if (g_AIArea)
+		g_AIArea->setAIAreaToTime(kInventorySignature, kLeftAreaSignature, 0xffffffff);
 }
 
 void InventoryItem::getPanelTimes(TimeValue &start, TimeValue &stop) const {
diff --git a/engines/pegasus/items/item.cpp b/engines/pegasus/items/item.cpp
index e4f1b712d7..aba9741940 100755
--- a/engines/pegasus/items/item.cpp
+++ b/engines/pegasus/items/item.cpp
@@ -30,8 +30,11 @@
 #include "pegasus/elements.h"
 #include "pegasus/pegasus.h"
 #include "pegasus/surface.h"
+#include "pegasus/ai/ai_area.h"
 #include "pegasus/items/item.h"
 #include "pegasus/items/itemlist.h"
+#include "pegasus/items/biochips/biochipitem.h"
+#include "pegasus/items/inventory/inventoryitem.h"
 
 namespace Pegasus {
 
@@ -128,30 +131,20 @@ Item::~Item() {
 	delete[] _itemExtras.entries;
 }
 
-Common::Error Item::writeToStream(Common::WriteStream *stream) {
+void Item::writeToStream(Common::WriteStream *stream) {
 	stream->writeUint16BE(_itemNeighborhood);
 	stream->writeUint16BE(_itemRoom);
 	stream->writeByte(_itemDirection);
 	stream->writeUint16BE(_itemOwnerID);
 	stream->writeUint16BE(_itemState);
-
-	if (stream->err())
-		return Common::kWritingFailed;
-	
-	return Common::kNoError;
 }
 
-Common::Error Item::readFromStream(Common::ReadStream *stream) {
+void Item::readFromStream(Common::ReadStream *stream) {
 	_itemNeighborhood = stream->readUint16BE();
 	_itemRoom = stream->readUint16BE();
 	_itemDirection = stream->readByte();
 	_itemOwnerID = stream->readUint16BE();
 	_itemState = stream->readUint16BE();
-	
-	if (stream->err())
-		return Common::kReadingFailed;
-	
-	return Common::kNoError;
 }
 
 tActorID Item::getItemOwner() const {
@@ -181,7 +174,11 @@ tItemState Item::getItemState() const {
 void Item::setItemState(const tItemState state) {
 	if (state != _itemState) {
 		_itemState = state;
-		// TODO: Selection
+
+		if (getItemType() == kInventoryItemType && ((PegasusEngine *)g_engine)->getCurrentInventoryItem() == (InventoryItem *)this)
+			select();
+		else if (getItemType() == kBiochipItemType && ((PegasusEngine *)g_engine)->getCurrentBiochip() == (BiochipItem *)this)
+			select();
 	}
 }
 
@@ -224,14 +221,24 @@ TimeValue Item::getSharedAreaTime() const {
 void Item::select() {
 	_isSelected = true;
 
-	// TODO: AI
+	if (g_AIArea) {
+		if (getItemType() == kInventoryItemType)
+			g_AIArea->setAIAreaToTime(kInventorySignature, kMiddleAreaSignature, getSharedAreaTime());
+		else
+			g_AIArea->setAIAreaToTime(kBiochipSignature, kMiddleAreaSignature, getSharedAreaTime());
+	}
 }
 
 void Item::deselect() {
 	_isActive = false;
 	_isSelected = false;
 
-	// TODO: AI
+	if (g_AIArea) {
+		if (getItemType() == kInventoryItemType)
+			g_AIArea->setAIAreaToTime(kInventorySignature, kMiddleAreaSignature, 0xffffffff);
+		else
+			g_AIArea->setAIAreaToTime(kBiochipSignature, kMiddleAreaSignature, 0xffffffff);
+	}
 }
 
 void Item::getItemStateEntry(ItemStateInfo info, uint32 index, tItemState &state, TimeValue &time) {	
@@ -286,4 +293,13 @@ Sprite *Item::getDragSprite(const tDisplayElementID id) const {
 	return result;
 }
 
+TimeValue Item::getInfoLeftTime() const {
+	return _itemInfo.infoLeftTime;
+}
+
+void Item::getInfoRightTimes(TimeValue &start, TimeValue &stop) const {
+	start = _itemInfo.infoRightStart;
+	stop = _itemInfo.infoRightStop;
+}
+
 } // End of namespace Pegasus
diff --git a/engines/pegasus/items/item.h b/engines/pegasus/items/item.h
index 1373913892..b74dfc4e96 100755
--- a/engines/pegasus/items/item.h
+++ b/engines/pegasus/items/item.h
@@ -294,8 +294,8 @@ public:
 	
 	// WriteToStream writes everything EXCEPT the item's ID.
 	// It is assumed that the calling function will write and read the ID.
-	virtual Common::Error writeToStream(Common::WriteStream *stream);
-	virtual Common::Error readFromStream(Common::ReadStream *stream);
+	virtual void writeToStream(Common::WriteStream *stream);
+	virtual void readFromStream(Common::ReadStream *stream);
 	
 	virtual tActorID getItemOwner() const;
 	virtual void setItemOwner(const tActorID owner);
@@ -312,7 +312,7 @@ public:
 	virtual tItemType getItemType() = 0;
 	
 	TimeValue getInfoLeftTime() const;
-	void getInfoRightTimes(TimeValue&, TimeValue&) const;
+	void getInfoRightTimes(TimeValue &, TimeValue &) const;
 	TimeValue getSharedAreaTime() const;
 
 	Sprite *getDragSprite(const tDisplayElementID) const;
diff --git a/engines/pegasus/items/itemlist.cpp b/engines/pegasus/items/itemlist.cpp
index 2b980d6f5f..cbe48285e9 100755
--- a/engines/pegasus/items/itemlist.cpp
+++ b/engines/pegasus/items/itemlist.cpp
@@ -40,32 +40,22 @@ ItemList::ItemList() {
 ItemList::~ItemList() {
 }
 
-Common::Error ItemList::writeToStream(Common::WriteStream *stream) {
+void ItemList::writeToStream(Common::WriteStream *stream) {
 	stream->writeUint32BE(size());
 
 	for (ItemIterator it = begin(); it != end(); it++) {
 		stream->writeUint16BE((*it)->getObjectID());
 		(*it)->writeToStream(stream);
 	}
-
-	if (stream->err())
-		return Common::kWritingFailed;
-	
-	return Common::kNoError;
 }
 
-Common::Error ItemList::readFromStream(Common::ReadStream *stream) {
+void ItemList::readFromStream(Common::ReadStream *stream) {
 	uint32 itemCount = stream->readUint32BE();
 
 	for (uint32 i = 0; i < itemCount; i++) {
 		tItemID itemID = stream->readUint16BE();
 		g_allItems.findItemByID(itemID)->readFromStream(stream);
 	}
-
-	if (stream->err())
-		return Common::kReadingFailed;
-	
-	return Common::kNoError;
 }
 
 Item *ItemList::findItemByID(const tItemID id) {
diff --git a/engines/pegasus/items/itemlist.h b/engines/pegasus/items/itemlist.h
index dd9a4ba023..df31b5c262 100755
--- a/engines/pegasus/items/itemlist.h
+++ b/engines/pegasus/items/itemlist.h
@@ -44,8 +44,8 @@ public:
 	ItemList();
 	virtual ~ItemList();
 	
-	virtual Common::Error writeToStream(Common::WriteStream *stream);
-	virtual Common::Error readFromStream(Common::ReadStream *stream);
+	virtual void writeToStream(Common::WriteStream *stream);
+	virtual void readFromStream(Common::ReadStream *stream);
 	
 	Item *findItemByID(const tItemID id);
 };